} // End Function Commit public virtual void CommitAndPush(string path) { // No empty commit if (!HasChanges(path)) { return; } NGit.Api.Git repository = NGit.Api.Git.Open(path); NGit.PersonIdent author = new NGit.PersonIdent("Lance Mcnearney", "*****@*****.**"); string message = "My commit message"; // Commit our changes after adding files to the stage NGit.Revwalk.RevCommit commit = repository.Commit() .SetMessage(message) .SetAuthor(author) .SetAll(true) // This automatically stages modified and deleted files .Call(); // Our new commit's hash NGit.ObjectId hash = commit.Id; // Push our changes back to the origin Sharpen.Iterable <NGit.Transport.PushResult> push = repository.Push().Call(); CloseRepository(repository); } // End Sub CommitAndPush
/// <param name="newHead">commit the head points at after this cherry-pick</param> /// <param name="cherryPickedRefs">list of successfully cherry-picked <code>Ref</code>'s /// </param> public CherryPickResult(RevCommit newHead, IList<Ref> cherryPickedRefs) { this.status = CherryPickResult.CherryPickStatus.OK; this.newHead = newHead; this.cherryPickedRefs = cherryPickedRefs; this.failingPaths = null; }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="NGit.Api.Errors.NoFilepatternException"></exception> /// <exception cref="NGit.Api.Errors.NoHeadException"></exception> /// <exception cref="NGit.Api.Errors.NoMessageException"></exception> /// <exception cref="NGit.Api.Errors.ConcurrentRefUpdateException"></exception> /// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> /// <exception cref="NGit.Api.Errors.WrongRepositoryStateException"></exception> public virtual void SetupRepository() { // create initial commit git = new Git(db); initialCommit = git.Commit().SetMessage("initial commit").Call(); // create file indexFile = new FilePath(db.WorkTree, "a.txt"); FileUtils.CreateNewFile(indexFile); PrintWriter writer = new PrintWriter(indexFile); writer.Write("content"); writer.Flush(); // add file and commit it git.Add().AddFilepattern("a.txt").Call(); secondCommit = git.Commit().SetMessage("adding a.txt").Call(); prestage = DirCache.Read(db.GetIndexFile(), db.FileSystem).GetEntry(indexFile.GetName ()); // modify file and add to index writer.Write("new content"); writer.Close(); git.Add().AddFilepattern("a.txt").Call(); // create a file not added to the index untrackedFile = new FilePath(db.WorkTree, "notAddedToIndex.txt"); FileUtils.CreateNewFile(untrackedFile); PrintWriter writer2 = new PrintWriter(untrackedFile); writer2.Write("content"); writer2.Close(); }
/// <summary>Core validation to be performed on all stashed commits</summary> /// <param name="commit"></param> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> private void ValidateStashedCommit(RevCommit commit) { NUnit.Framework.Assert.IsNotNull(commit); Ref stashRef = db.GetRef(Constants.R_STASH); NUnit.Framework.Assert.IsNotNull(stashRef); NUnit.Framework.Assert.AreEqual(commit, stashRef.GetObjectId()); NUnit.Framework.Assert.IsNotNull(commit.GetAuthorIdent()); NUnit.Framework.Assert.AreEqual(commit.GetAuthorIdent(), commit.GetCommitterIdent ()); NUnit.Framework.Assert.AreEqual(2, commit.ParentCount); // Load parents RevWalk walk = new RevWalk(db); try { foreach (RevCommit parent in commit.Parents) { walk.ParseBody(parent); } } finally { walk.Release(); } NUnit.Framework.Assert.AreEqual(1, commit.GetParent(1).ParentCount); NUnit.Framework.Assert.AreEqual(head, commit.GetParent(1).GetParent(0)); NUnit.Framework.Assert.IsFalse(commit.Tree.Equals(head.Tree), "Head tree matches stashed commit tree" ); NUnit.Framework.Assert.AreEqual(head, commit.GetParent(0)); NUnit.Framework.Assert.IsFalse(commit.GetFullMessage().Equals(commit.GetParent(1) .GetFullMessage())); }
internal static void CarryFlags(NGit.Revwalk.RevCommit c, int carry) { for (; ;) { NGit.Revwalk.RevCommit[] pList = c.parents; if (pList == null) { return; } int n = pList.Length; if (n == 0) { return; } for (int i = 1; i < n; i++) { NGit.Revwalk.RevCommit p = pList[i]; if ((p.flags & carry) == carry) { continue; } p.flags |= carry; CarryFlags(p, carry); } c = pList[0]; if ((c.flags & carry) == carry) { return; } c.flags |= carry; } }
} // End Function Commit public virtual string Commit(string path, string message) { string commitId = null; // No empty commit if (!HasChanges(path)) { return(commitId); } NGit.Api.Git repository = NGit.Api.Git.Open(path); NGit.PersonIdent author = new NGit.PersonIdent("FooBar2000", "*****@*****.**"); // Commit our changes after adding files to the stage NGit.Revwalk.RevCommit commit = repository.Commit() .SetMessage(message) .SetAuthor(author) .SetAll(true) // This automatically stages modified and deleted files .Call(); // Our new commit's hash NGit.ObjectId hash = commit.Id; commitId = hash.Name; CloseRepository(repository); return(commitId); } // End Function Commit
} // End Function GetRemoteBranchId // http://stackoverflow.com/questions/3407575/retrieving-oldest-commit-with-jgit public virtual System.DateTime GetLastCommitDate(string path) { System.DateTime retVal = default(System.DateTime); NGit.Revwalk.RevCommit c = null; NGit.Api.Git repository = NGit.Api.Git.Open(path); try { NGit.Revwalk.RevWalk rw = new NGit.Revwalk.RevWalk(repository.GetRepository()); NGit.AnyObjectId headid = repository.GetRepository().Resolve(NGit.Constants.HEAD); c = rw.ParseCommit(headid); // repository.GetRepository(). } catch (System.Exception ex) { System.Console.WriteLine(ex.Message); } // Get author NGit.PersonIdent authorIdent = c.GetAuthorIdent(); System.DateTime authorDate = authorIdent.GetWhen(); retVal = authorDate.ToUniversalTime(); CloseRepository(repository); return(retVal); }
/// <summary>Add a commit if it does not have a flag set yet, then set the flag.</summary> /// <remarks> /// Add a commit if it does not have a flag set yet, then set the flag. /// <p> /// This method permits the application to test if the commit has the given /// flag; if it does not already have the flag than the commit is added to /// the queue and the flag is set. This later will prevent the commit from /// being added twice. /// </remarks> /// <param name="c">commit to add.</param> /// <param name="queueControl">flag that controls admission to the queue.</param> public void Add(RevCommit c, RevFlag queueControl) { if (!c.Has(queueControl)) { c.Add(queueControl); Add(c); } }
/// <exception cref="NGit.Errors.StopWalkException"></exception> /// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="System.IO.IOException"></exception> public override bool Include(RevWalk walker, RevCommit cmit) { if (skip > count++) { return false; } return true; }
/// <summary> /// Compares two commits and returns a list of files that have changed /// </summary> public static IEnumerable<DiffEntry> CompareCommits (NGit.Repository repo, RevCommit reference, RevCommit compared) { var changes = new List<DiffEntry>(); if (reference == null && compared == null) return changes; ObjectId refTree = (reference != null ? reference.Tree.Id : ObjectId.ZeroId); ObjectId comparedTree = (compared != null ? compared.Tree.Id : ObjectId.ZeroId); return CompareCommits (repo, refTree, comparedTree); }
/// <exception cref="NGit.Errors.StopWalkException"></exception> /// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="System.IO.IOException"></exception> public override bool Include(RevWalk walker, RevCommit cmit) { count++; if (count > maxCount) { throw StopWalkException.INSTANCE; } return true; }
public override void SetUp() { base.SetUp(); git = Git.Wrap(db); committedFile = WriteTrashFile(PATH, "content"); git.Add().AddFilepattern(PATH).Call(); head = git.Commit().SetMessage("add file").Call(); NUnit.Framework.Assert.IsNotNull(head); }
public virtual PlotCommitListTest.CommitListAssert Commit(RevCommit id) { NUnit.Framework.Assert.IsTrue(this.pcl.Count > this.nextIndex, "Unexpected end of list at pos#" + this.nextIndex); this.current = this.pcl[this.nextIndex++]; NUnit.Framework.Assert.AreEqual(id.Id, this.current.Id, "Expected commit not found at pos#" + (this.nextIndex - 1)); return this; }
/// <summary> /// Returns a list of files that have changed in a commit /// </summary> public static IEnumerable<Change> GetCommitChanges (NGit.Repository repo, RevCommit commit) { var treeIds = new[] { commit.Tree.Id }.Concat (commit.Parents.Select (c => c.Tree.Id)).ToArray (); var walk = new TreeWalk (repo); walk.Reset (treeIds); walk.Recursive = true; walk.Filter = AndTreeFilter.Create (AndTreeFilter.ANY_DIFF, AndTreeFilter.ALL); return CalculateCommitDiff (repo, walk, new[] { commit }.Concat (commit.Parents).ToArray ()); }
/// <summary>Parse a commit from its canonical format.</summary> /// <remarks> /// Parse a commit from its canonical format. /// This method inserts the commit directly into the caller supplied revision /// pool, making it appear as though the commit exists in the repository, /// even if it doesn't. The repository under the pool is not affected. /// </remarks> /// <param name="rw"> /// the revision pool to allocate the commit within. The commit's /// tree and parent pointers will be obtained from this pool. /// </param> /// <param name="raw">the canonical formatted commit to be parsed.</param> /// <returns> /// the parsed commit, in an isolated revision pool that is not /// available to the caller. /// </returns> public static NGit.Revwalk.RevCommit Parse(RevWalk rw, byte[] raw) { ObjectInserter.Formatter fmt = new ObjectInserter.Formatter(); bool retain = rw.IsRetainBody(); rw.SetRetainBody(true); NGit.Revwalk.RevCommit r = rw.LookupCommit(fmt.IdFor(Constants.OBJ_COMMIT, raw)); r.ParseCanonical(rw, raw); rw.SetRetainBody(retain); return(r); }
public override void SetUp() { base.SetUp(); diskRepo = CreateBareRepository(); refdir = (RefDirectory)diskRepo.RefDatabase; repo = new TestRepository<Repository>(diskRepo); A = repo.Commit().Create(); B = repo.Commit(repo.GetRevWalk().ParseCommit(A)); v1_0 = repo.Tag("v1_0", B); repo.GetRevWalk().ParseBody(v1_0); }
public virtual void TestCommit() { Git git = new Git(db); revCommit = git.Commit().SetMessage("squash_me").Call(); Ref master = db.GetRef("refs/heads/master"); string message = msgFormatter.Format(Arrays.AsList(revCommit), master); NUnit.Framework.Assert.AreEqual("Squashed commit of the following:\n\ncommit " + revCommit.GetName() + "\nAuthor: " + revCommit.GetAuthorIdent().GetName() + " <" + revCommit.GetAuthorIdent().GetEmailAddress() + ">\nDate: " + dateFormatter. FormatDate(author) + "\n\n\tsquash_me\n", message); }
public override void Add(RevCommit c) { BlockRevQueue.Block b = head; if (b == null || !b.CanUnpop()) { b = free.NewBlock(); b.ResetToEnd(); b.next = head; head = b; } b.Unpop(c); }
public override void SetUp() { base.SetUp(); git = new Git(db); // commit something WriteTrashFile(FILE, "Hello world"); git.Add().AddFilepattern(FILE).Call(); commit1 = git.Commit().SetMessage("Initial commit").Call(); git.Rm().AddFilepattern(FILE).Call(); commit2 = git.Commit().SetMessage("Removed file").Call(); git.NotesAdd().SetObjectId(commit1).SetMessage("data").Call(); }
/// <exception cref="System.InvalidOperationException"></exception> /// <exception cref="System.IO.IOException"></exception> private void CheckoutCommit(RevCommit commit) { RevWalk walk = new RevWalk(db); RevCommit head = walk.ParseCommit(db.Resolve(Constants.HEAD)); DirCacheCheckout dco = new DirCacheCheckout(db, head.Tree, db.LockDirCache(), commit .Tree); dco.SetFailOnConflict(true); dco.Checkout(); walk.Release(); // update the HEAD RefUpdate refUpdate = db.UpdateRef(Constants.HEAD, true); refUpdate.SetNewObjectId(commit); refUpdate.ForceUpdate(); }
// https://stackoverflow.com/questions/45793800/jgit-read-the-content-of-a-file-at-a-commit-in-a-branch private string GetFileContent(string repositoryPath, string path, NGit.Revwalk.RevCommit commit) { NGit.Api.Git repository = NGit.Api.Git.Open(repositoryPath); NGit.Treewalk.TreeWalk treeWalk = NGit.Treewalk.TreeWalk.ForPath( repository.GetRepository(), path, commit.Tree); NGit.ObjectId blobId = treeWalk.GetObjectId(0); NGit.ObjectReader objectReader = repository.GetRepository().NewObjectReader(); NGit.ObjectLoader objectLoader = objectReader.Open(blobId); byte[] bytes = objectLoader.GetBytes(); return(System.Text.Encoding.UTF8.GetString(bytes)); }
public static List<DiffEntry> diff_Commits(this API_NGit nGit, RevCommit from_RevCommit, RevCommit to_RevCommit) { if (nGit.repository().notNull()) try { var outputStream = NGit_Factory.New_OutputStream(); var diffFormater = new DiffFormatter(outputStream); diffFormater.SetRepository(nGit.repository()); return diffFormater.Scan(from_RevCommit, to_RevCommit).toList(); } catch (Exception ex) { ex.log("[API_NGit][diff]"); } return new List<DiffEntry>(); }
/// <summary> /// Compares two commits and returns a list of files that have changed /// </summary> public static IEnumerable<Change> CompareCommits (NGit.Repository repo, RevCommit reference, RevCommit compared) { var changes = new List<Change>(); if (reference == null && compared == null) return changes; ObjectId refTree = (reference != null ? reference.Tree.Id : ObjectId.ZeroId); ObjectId comparedTree = (compared != null ? compared.Tree.Id : ObjectId.ZeroId); var walk = new TreeWalk (repo); if (reference == null || compared == null) walk.Reset ((reference ?? compared).Tree.Id); else walk.Reset (new AnyObjectId[] {refTree, comparedTree}); walk.Recursive = true; walk.Filter = AndTreeFilter.Create(TreeFilter.ANY_DIFF, TreeFilter.ALL); return CalculateCommitDiff (repo, walk, new[] { reference, compared }); }
public override void SetUp() { base.SetUp(); git = new Git(db); // commit something WriteTrashFile("Test.txt", "Hello world"); git.Add().AddFilepattern("Test.txt").Call(); initialCommit = git.Commit().SetMessage("Initial commit").Call(); // create a master branch and switch to it git.BranchCreate().SetName("test").Call(); RefUpdate rup = db.UpdateRef(Constants.HEAD); rup.Link("refs/heads/test"); // commit something on the test branch WriteTrashFile("Test.txt", "Some change"); git.Add().AddFilepattern("Test.txt").Call(); secondCommit = git.Commit().SetMessage("Second commit").Call(); }
public override void SetUp() { base.SetUp(); git = new Git(db); WriteTrashFile(FILE1, "1"); WriteTrashFile(FILE2, "a"); git.Add().AddFilepattern(FILE1).AddFilepattern(FILE2).Call(); initialCommit = git.Commit().SetMessage("Initial commit").Call(); WriteTrashFile(FILE1, "2"); WriteTrashFile(FILE2, "b"); git.Add().AddFilepattern(FILE1).AddFilepattern(FILE2).Call(); secondCommit = git.Commit().SetMessage("Second commit").Call(); WriteTrashFile(FILE1, "3"); WriteTrashFile(FILE2, "c"); git.Add().AddFilepattern(FILE1).AddFilepattern(FILE2).Call(); git.Commit().SetMessage("Third commit").Call(); }
// http://stackoverflow.com/questions/3407575/retrieving-oldest-commit-with-jgit public virtual void GetOldestCommit(string path) { NGit.Revwalk.RevCommit c = null; NGit.Api.Git repository = NGit.Api.Git.Open(path); try { NGit.Revwalk.RevWalk rw = new NGit.Revwalk.RevWalk(repository.GetRepository()); NGit.AnyObjectId headid = repository.GetRepository().Resolve(NGit.Constants.HEAD); NGit.Revwalk.RevCommit root = rw.ParseCommit(headid); string msg1 = root.GetFullMessage(); rw.Sort(NGit.Revwalk.RevSort.REVERSE); rw.MarkStart(root); c = rw.Next(); // repository.GetRepository(). } catch (System.Exception ex) { System.Console.WriteLine(ex.Message); } string msg2 = c.GetFullMessage(); // Get author NGit.PersonIdent authorIdent = c.GetAuthorIdent(); System.DateTime authorDate = authorIdent.GetWhen(); System.TimeZoneInfo authorTimeZone = authorIdent.GetTimeZone(); NGit.PersonIdent committerIdent = c.GetCommitterIdent(); // http://stackoverflow.com/questions/12608610/how-do-you-get-the-author-date-and-commit-date-from-a-jgit-revcommit System.Console.WriteLine(authorIdent); System.Console.WriteLine(authorDate); System.Console.WriteLine(authorTimeZone); System.Console.WriteLine(committerIdent); CloseRepository(repository); }
/// <summary>Create a new sorter and completely spin the generator.</summary> /// <remarks> /// Create a new sorter and completely spin the generator. /// <p> /// When the constructor completes the supplied generator will have no /// commits remaining, as all of the commits will be held inside of this /// generator's internal buffer. /// </remarks> /// <param name="s">generator to pull all commits out of, and into this buffer.</param> /// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> internal TopoSortGenerator(Generator s) { pending = new FIFORevQueue(); outputType = s.OutputType() | SORT_TOPO; s.ShareFreeList(pending); for (; ;) { RevCommit c = s.Next(); if (c == null) { break; } foreach (RevCommit p in c.parents) { p.inDegree++; } pending.Add(c); } }
public virtual void TestSort_TOPO() { // c1 is back dated before its parent. // RevCommit a = Commit(); RevCommit b = Commit(a); RevCommit c1 = Commit(-5, b); RevCommit c2 = Commit(10, b); RevCommit d = Commit(c1, c2); rw.Sort(RevSort.TOPO); MarkStart(d); AssertCommit(d, rw.Next()); AssertCommit(c2, rw.Next()); AssertCommit(c1, rw.Next()); AssertCommit(b, rw.Next()); AssertCommit(a, rw.Next()); NUnit.Framework.Assert.IsNull(rw.Next()); }
public override void SetUp() { base.SetUp(); git = new Git(db); // checkout master git.Commit().SetMessage("initial commit").Call(); // commit something WriteTrashFile("Test.txt", "Hello world"); git.Add().AddFilepattern("Test.txt").Call(); initialCommit = git.Commit().SetMessage("Initial commit").Call(); WriteTrashFile("Test.txt", "Some change"); git.Add().AddFilepattern("Test.txt").Call(); secondCommit = git.Commit().SetMessage("Second commit").Call(); // create a master branch RefUpdate rup = db.UpdateRef("refs/heads/master"); rup.SetNewObjectId(initialCommit.Id); rup.SetForceUpdate(true); rup.Update(); }
internal override RevCommit Next() { BlockRevQueue.Block b = head; if (b == null) { return(null); } RevCommit c = b.Pop(); if (b.IsEmpty()) { head = b.next; if (head == null) { tail = null; } free.FreeBlock(b); } return(c); }
public virtual void TestSort_COMMIT_TIME_DESC_OutOfOrder1() { // Despite being out of order time-wise, a strand-of-pearls must // still maintain topological order. // RevCommit a = Commit(); RevCommit b = Commit(a); RevCommit c = Commit(-5, b); RevCommit d = Commit(10, c); NUnit.Framework.Assert.IsTrue(ParseBody(a).CommitTime < ParseBody(d).CommitTime); NUnit.Framework.Assert.IsTrue(ParseBody(c).CommitTime < ParseBody(b).CommitTime); rw.Sort(RevSort.COMMIT_TIME_DESC); MarkStart(d); AssertCommit(d, rw.Next()); AssertCommit(c, rw.Next()); AssertCommit(b, rw.Next()); AssertCommit(a, rw.Next()); NUnit.Framework.Assert.IsNull(rw.Next()); }
public virtual void TestCloneFIFO() { RevCommit a = ParseBody(Commit()); RevCommit b = ParseBody(Commit(200, a)); RevCommit c = ParseBody(Commit(200, b)); FIFORevQueue src = new FIFORevQueue(); src.Add(a); src.Add(b); src.Add(c); q = new DateRevQueue(src); NUnit.Framework.Assert.IsFalse(q.EverbodyHasFlag(RevWalk.UNINTERESTING)); NUnit.Framework.Assert.IsFalse(q.AnybodyHasFlag(RevWalk.UNINTERESTING)); AssertCommit(c, q.Peek()); AssertCommit(c, q.Peek()); AssertCommit(c, q.Next()); AssertCommit(b, q.Next()); AssertCommit(a, q.Next()); NUnit.Framework.Assert.IsNull(q.Next()); }
public virtual void TestCrissCross() { // See http://marc.info/?l=git&m=111463358500362&w=2 for a nice // description of what this test is creating. We don't have a // clean merge base for d,e as they each merged the parents b,c // in different orders. // RevCommit a = Commit(); RevCommit b = Commit(a); RevCommit c = Commit(a); RevCommit d = Commit(b, c); RevCommit e = Commit(c, b); rw.SetRevFilter(RevFilter.MERGE_BASE); MarkStart(d); MarkStart(e); AssertCommit(c, rw.Next()); AssertCommit(b, rw.Next()); NUnit.Framework.Assert.IsNull(rw.Next()); }
public virtual void TestMatchesBugId() { RevCommit commit = Parse("this is a commit subject for test\n" + "\n" + "Simple-Bug-Id: 42\n" ); // paragraph break, now footers appear in final block IList <FooterLine> footers = commit.GetFooterLines(); NUnit.Framework.Assert.IsNotNull(footers); NUnit.Framework.Assert.AreEqual(1, footers.Count); FooterLine line = footers[0]; NUnit.Framework.Assert.IsNotNull(line); NUnit.Framework.Assert.AreEqual("Simple-Bug-Id", line.GetKey()); NUnit.Framework.Assert.AreEqual("42", line.GetValue()); FooterKey bugid = new FooterKey("Simple-Bug-Id"); NUnit.Framework.Assert.IsTrue(line.Matches(bugid), "matches Simple-Bug-Id"); NUnit.Framework.Assert.IsFalse(line.Matches(FooterKey.SIGNED_OFF_BY), "not Signed-off-by" ); NUnit.Framework.Assert.IsFalse(line.Matches(FooterKey.CC), "not CC"); }
public virtual void TestMaxCountRevFilter() { RevCommit a = Commit(); RevCommit b = Commit(a); RevCommit c1 = Commit(b); RevCommit c2 = Commit(b); RevCommit d = Commit(c1, c2); RevCommit e = Commit(d); rw.Reset(); rw.SetRevFilter(MaxCountRevFilter.Create(3)); MarkStart(e); AssertCommit(e, rw.Next()); AssertCommit(d, rw.Next()); AssertCommit(c2, rw.Next()); NUnit.Framework.Assert.IsNull(rw.Next()); rw.Reset(); rw.SetRevFilter(MaxCountRevFilter.Create(0)); MarkStart(e); NUnit.Framework.Assert.IsNull(rw.Next()); }
public virtual void TestTwoCommitTwoTreeTwoBlob() { RevBlob f0 = Blob("0"); RevBlob f1 = Blob("1"); RevBlob f2 = Blob("0v2"); RevTree ta = Tree(File("0", f0), File("1", f1), File("2", f1)); RevTree tb = Tree(File("0", f2), File("1", f1), File("2", f1)); RevCommit a = Commit(ta); RevCommit b = Commit(tb, a); MarkStart(b); AssertCommit(b, objw.Next()); AssertCommit(a, objw.Next()); NUnit.Framework.Assert.IsNull(objw.Next()); NUnit.Framework.Assert.AreSame(tb, objw.NextObject()); NUnit.Framework.Assert.AreSame(f2, objw.NextObject()); NUnit.Framework.Assert.AreSame(f1, objw.NextObject()); NUnit.Framework.Assert.AreSame(ta, objw.NextObject()); NUnit.Framework.Assert.AreSame(f0, objw.NextObject()); NUnit.Framework.Assert.IsNull(objw.NextObject()); }
public virtual void TestInsertTie() { RevCommit a = ParseBody(Commit()); RevCommit b = ParseBody(Commit(0, a)); { q = Create(); q.Add(a); q.Add(b); AssertCommit(a, q.Next()); AssertCommit(b, q.Next()); NUnit.Framework.Assert.IsNull(q.Next()); } { q = Create(); q.Add(b); q.Add(a); AssertCommit(b, q.Next()); AssertCommit(a, q.Next()); NUnit.Framework.Assert.IsNull(q.Next()); } }
/// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="System.IO.IOException"></exception> internal override RevCommit Next() { while (size < OVER_SCAN) { RevCommit c = pending.Next(); if (c == null) { break; } delay.Add(c); size++; } RevCommit c_1 = delay.Next(); if (c_1 == null) { return(null); } size--; return(c_1); }
/// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="System.IO.IOException"></exception> internal override RevCommit Next() { RevCommit c = this.source.Next(); if (c != null) { foreach (RevCommit p in c.parents) { if ((p.flags & BoundaryGenerator.UNINTERESTING) != 0) { this.held.Add(p); } } return(c); } FIFORevQueue boundary = new FIFORevQueue(); boundary.ShareFreeList(this.held); for (; ;) { c = this.held.Next(); if (c == null) { break; } if ((c.flags & BoundaryGenerator.InitialGenerator.DUPLICATE) != 0) { continue; } if ((c.flags & BoundaryGenerator.InitialGenerator.PARSED) == 0) { c.ParseHeaders(this.walk); } c.flags |= BoundaryGenerator.InitialGenerator.DUPLICATE; boundary.Add(c); } boundary.RemoveFlag(BoundaryGenerator.InitialGenerator.DUPLICATE); this._enclosing.g = boundary; return(boundary.Next()); }
public virtual void TestRevFilterReceivesParsedCommits() { RevCommit a = Commit(); RevCommit b = Commit(a); RevCommit c = Commit(b); AtomicBoolean filterRan = new AtomicBoolean(); RevFilter testFilter = new _RevFilter_68(filterRan); // Do an initial run through the walk filterRan.Set(false); rw.SetRevFilter(testFilter); MarkStart(c); rw.MarkUninteresting(b); for (RevCommit cmit = rw.Next(); cmit != null; cmit = rw.Next()) { } // Don't dispose the body here, because we want to test the effect // of marking 'b' as uninteresting. NUnit.Framework.Assert.IsTrue(filterRan.Get(), "filter ran"); // Run through the walk again, this time disposing of all commits. filterRan.Set(false); rw.Reset(); MarkStart(c); for (RevCommit cmit_1 = rw.Next(); cmit_1 != null; cmit_1 = rw.Next()) { cmit_1.DisposeBody(); } NUnit.Framework.Assert.IsTrue(filterRan.Get(), "filter ran"); // Do the third run through the reused walk. Test that the explicitly // disposed commits are parsed on this walk. filterRan.Set(false); rw.Reset(); MarkStart(c); for (RevCommit cmit_2 = rw.Next(); cmit_2 != null; cmit_2 = rw.Next()) { } // spin through the walk. NUnit.Framework.Assert.IsTrue(filterRan.Get(), "filter ran"); }
public virtual void TestTwoCommitDeepTree2() { RevBlob f1 = Blob("1"); RevTree ta = Tree(File("a/b/0", f1), File("a/c/q", f1)); RevTree tb = Tree(File("a/b/1", f1), File("a/c/q", f1)); RevCommit a = Commit(ta); RevCommit b = Commit(tb, a); MarkStart(b); AssertCommit(b, objw.Next()); AssertCommit(a, objw.Next()); NUnit.Framework.Assert.IsNull(objw.Next()); NUnit.Framework.Assert.AreSame(tb, objw.NextObject()); NUnit.Framework.Assert.AreSame(Get(tb, "a"), objw.NextObject()); NUnit.Framework.Assert.AreSame(Get(tb, "a/b"), objw.NextObject()); NUnit.Framework.Assert.AreSame(f1, objw.NextObject()); NUnit.Framework.Assert.AreSame(Get(tb, "a/c"), objw.NextObject()); NUnit.Framework.Assert.AreSame(ta, objw.NextObject()); NUnit.Framework.Assert.AreSame(Get(ta, "a"), objw.NextObject()); NUnit.Framework.Assert.AreSame(Get(ta, "a/b"), objw.NextObject()); NUnit.Framework.Assert.IsNull(objw.NextObject()); }
public override void Add(RevCommit c) { DateRevQueue.Entry q = head; long when = c.commitTime; DateRevQueue.Entry n = NewEntry(c); if (q == null || when > q.commit.commitTime) { n.next = q; head = n; } else { DateRevQueue.Entry p = q.next; while (p != null && p.commit.commitTime > when) { q = p; p = q.next; } n.next = q.next; q.next = n; } }
public override void Add(RevCommit c) { BlockRevQueue.Block b = tail; if (b == null) { b = free.NewBlock(); b.Add(c); head = b; tail = b; return; } else { if (b.IsFull()) { b = free.NewBlock(); tail.next = b; tail = b; } } b.Add(c); }
/// <param name="w"></param> /// <param name="s">Parent generator</param> /// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> internal DepthGenerator(DepthWalk w, Generator s) { pending = new FIFORevQueue(); walk = (RevWalk)w; this.depth = w.GetDepth(); this.UNSHALLOW = w.GetUnshallowFlag(); this.REINTERESTING = w.GetReinterestingFlag(); s.ShareFreeList(pending); // Begin by sucking out all of the source's commits, and // adding them to the pending queue for (; ;) { RevCommit c = s.Next(); if (c == null) { break; } if (((NGit.Revwalk.Depthwalk.Commit)c).GetDepth() == 0) { pending.Add(c); } } }
private bool CarryOntoOne(RevCommit p, int carry) { bool haveAll = (p.flags & carry) == carry; p.flags |= carry; if ((p.flags & recarryMask) == recarryTest) { // We were popped without being a merge base, but we just got // voted to be one. Inject ourselves back at the front of the // pending queue and tell all of our ancestors they are within // the merge base now. // p.flags &= ~POPPED; pending.Add(p); CarryOntoHistory(p, branchMask | MERGE_BASE); return(true); } // If we already had all carried flags, our parents do too. // Return true to stop the caller from running down this leg // of the revision graph any further. // return(haveAll); }
/// <summary>Verify all interesting objects are available, and reachable.</summary> /// <remarks> /// Verify all interesting objects are available, and reachable. /// <p> /// Callers should populate starting points and ending points with /// <see cref="MarkStart(RevObject)">MarkStart(RevObject)</see> /// and /// <see cref="MarkUninteresting(RevObject)">MarkUninteresting(RevObject)</see> /// and then use this method to verify all objects between those two points /// exist in the repository and are readable. /// <p> /// This method returns successfully if everything is connected; it throws an /// exception if there is a connectivity problem. The exception message /// provides some detail about the connectivity failure. /// </remarks> /// <exception cref="NGit.Errors.MissingObjectException"> /// one or or more of the next objects are not available from the /// object database, but were thought to be candidates for /// traversal. This usually indicates a broken link. /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"> /// one or or more of the objects in a tree do not match the type /// indicated. /// </exception> /// <exception cref="System.IO.IOException">a pack file or loose object could not be read. /// </exception> public virtual void CheckConnectivity() { for (; ;) { RevCommit c = Next(); if (c == null) { break; } } for (; ;) { RevObject o = NextObject(); if (o == null) { break; } if (o is RevBlob && !reader.Has(o)) { throw new MissingObjectException(o, Constants.OBJ_BLOB); } } }
// Never happen. The filter we use does not throw any // exceptions, for any reason. /// <summary>Find the next commit that has the given flag set.</summary> /// <remarks>Find the next commit that has the given flag set.</remarks> /// <param name="flag">the flag to test commits against.</param> /// <param name="begin"> /// first commit index to test at. Applications may wish to begin /// at 0, to test the first commit in the list. /// </param> /// <returns> /// index of the first commit at or after index <code>begin</code> /// that has the specified flag set on it; -1 if no match is found. /// </returns> public virtual int IndexOf(RevFlag flag, int begin) { while (begin < Count) { int index = begin; RevObjectListBlock s = contents; while (s.shift > 0) { int i = index >> s.shift; index -= i << s.shift; s = (RevObjectListBlock)s.contents[i]; } while (begin++ < Count && index < BLOCK_SIZE) { RevCommit c = (RevCommit)s.contents[index++]; if (c.Has(flag)) { return(begin); } } } return(-1); }
/// <summary>Find the next commit that has the given flag set.</summary> /// <remarks>Find the next commit that has the given flag set.</remarks> /// <param name="flag">the flag to test commits against.</param> /// <param name="begin"> /// first commit index to test at. Applications may wish to begin /// at <code>size()-1</code>, to test the last commit in the /// list. /// </param> /// <returns> /// index of the first commit at or before index <code>begin</code> /// that has the specified flag set on it; -1 if no match is found. /// </returns> public virtual int LastIndexOf(RevFlag flag, int begin) { begin = Math.Min(begin, Count - 1); while (begin >= 0) { int index = begin; RevObjectListBlock s = contents; while (s.shift > 0) { int i = index >> s.shift; index -= i << s.shift; s = (RevObjectListBlock)s.contents[i]; } while (begin-- >= 0 && index >= 0) { RevCommit c = (RevCommit)s.contents[index--]; if (c.Has(flag)) { return(begin); } } } return(-1); }
public virtual void TestProperlyCullAllAncestors_LongHistory() { RevCommit a = Commit(); RevCommit b = Commit(a); for (int i = 0; i < 24; i++) { b = Commit(b); if ((i & 2) == 0) { MarkUninteresting(b); } } RevCommit c = Commit(b); MarkStart(c); MarkUninteresting(b); AssertCommit(c, rw.Next()); NUnit.Framework.Assert.IsNull(rw.Next()); // We should have aborted before we got back so far that "a" // would be parsed. Thus, its parents shouldn't be allocated. // NUnit.Framework.Assert.IsNull(a.parents); }
} // End Sub ListBranches // https://stackoverflow.com/questions/40590039/how-to-get-the-file-list-for-a-commit-with-jgit // https://github.com/centic9/jgit-cookbook/blob/master/src/main/java/org/dstadler/jgit/api/GetRevCommitFromObjectId.java public virtual void ListFilesIncmt(string path, NGit.Revwalk.RevCommit commit) { NGit.Api.Git repository = NGit.Api.Git.Open(path); NGit.ObjectId treeId = commit.Tree.Id; NGit.Treewalk.TreeWalk treeWalk = new NGit.Treewalk.TreeWalk(repository.GetRepository()); treeWalk.Reset(treeId); while (treeWalk.Next()) { string filePath = treeWalk.PathString; System.Console.WriteLine(filePath); } NGit.Ref @ref = repository.GetRepository().GetRef("refs/heads/master"); NGit.ObjectId head = @ref.GetObjectId(); using (NGit.Revwalk.RevWalk walk = new NGit.Revwalk.RevWalk(repository.GetRepository())) { NGit.Revwalk.RevCommit headCommit = walk.ParseCommit(head); } NGit.ObjectId commitIdFromHash = repository.GetRepository().Resolve("revstr"); }
private string GetFileContent(RevCommit commit, string path) { return _git.GetFileContent(commit, path); }
private string GetTextFileContentSafe(RevCommit commit, string path) { try { return GetFileContent(commit, path); } catch { return string.Empty; } }
private DiffResult GetDiff(string path, RevCommit parent, RevCommit commit) { var fileContent = GetTextFileContentSafe(commit, path); var previousRevisionFileContent = GetTextFileContentSafe(parent, path); var diff = _diffProcessor.GetDiff(previousRevisionFileContent, fileContent); diff.LeftPanRevisionId = parent.Id.Name; diff.RightPanRevisionId = commit.Id.Name; return diff; }
/// <summary>Assume a commit is available on the recipient's side.</summary> /// <remarks> /// Assume a commit is available on the recipient's side. /// <p> /// In order to fetch from a bundle the recipient must have any assumed /// commit. Each assumed commit is explicitly recorded in the bundle header /// to permit the recipient to validate it has these objects. /// </remarks> /// <param name="c"> /// the commit to assume being available. This commit should be /// parsed and not disposed in order to maximize the amount of /// debugging information available in the bundle stream. /// </param> public virtual void Assume(RevCommit c) { if (c != null) { assume.AddItem(c); } }
/// <summary> /// Find commits that are reachable from <code>start</code> until a commit /// that is reachable from <code>end</code> is encountered. /// </summary> /// <remarks> /// Find commits that are reachable from <code>start</code> until a commit /// that is reachable from <code>end</code> is encountered. In other words, /// Find of commits that are in <code>start</code>, but not in /// <code>end</code>. /// <p> /// Note that this method calls /// <see cref="RevWalk.Reset()">RevWalk.Reset()</see> /// at the beginning. /// Also note that the existing rev filter on the walk is left as-is, so be /// sure to set the right rev filter before calling this method. /// </remarks> /// <param name="walk">the rev walk to use</param> /// <param name="start">the commit to start counting from</param> /// <param name="end"> /// the commit where counting should end, or null if counting /// should be done until there are no more commits /// </param> /// <returns>the commits found</returns> /// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public static IList<RevCommit> Find(RevWalk walk, RevCommit start, RevCommit end) { walk.Reset(); walk.MarkStart(start); if (end != null) { walk.MarkUninteresting(end); } IList<RevCommit> commits = new AList<RevCommit>(); foreach (RevCommit c in walk) { commits.AddItem(c); } return commits; }
// Utility class /// <summary> /// Count the number of commits that are reachable from <code>start</code> /// until a commit that is reachable from <code>end</code> is encountered. /// </summary> /// <remarks> /// Count the number of commits that are reachable from <code>start</code> /// until a commit that is reachable from <code>end</code> is encountered. In /// other words, count the number of commits that are in <code>start</code>, /// but not in <code>end</code>. /// <p> /// Note that this method calls /// <see cref="RevWalk.Reset()">RevWalk.Reset()</see> /// at the beginning. /// Also note that the existing rev filter on the walk is left as-is, so be /// sure to set the right rev filter before calling this method. /// </remarks> /// <param name="walk">the rev walk to use</param> /// <param name="start">the commit to start counting from</param> /// <param name="end"> /// the commit where counting should end, or null if counting /// should be done until there are no more commits /// </param> /// <returns>the number of commits</returns> /// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public static int Count(RevWalk walk, RevCommit start, RevCommit end) { return Find(walk, start, end).Count; }
public override void SetUp() { base.SetUp(); // Test graph was stolen from git-core t6012-rev-list-simplify // (by Junio C Hamano in 65347030590bcc251a9ff2ed96487a0f1b9e9fa8) // RevBlob zF = Blob("zF"); RevBlob zH = Blob("zH"); RevBlob zI = Blob("zI"); RevBlob zS = Blob("zS"); RevBlob zY = Blob("zY"); a = Commit(Tree(File(pF, zH))); b = Commit(Tree(File(pF, zI)), a); c = Commit(Tree(File(pF, zI)), a); d = Commit(Tree(File(pA, zS), File(pF, zI)), c); ParseBody(d); e = Commit(d.Tree, d, b); f = Commit(Tree(File(pA, zS), File(pE, zY), File(pF, zI)), e); ParseBody(f); g = Commit(Tree(File(pE, zY), File(pF, zI)), b); h = Commit(f.Tree, g, f); i = Commit(Tree(File(pA, zS), File(pE, zY), File(pF, zF)), h); byName = new Dictionary<RevCommit, string>(); foreach (FieldInfo z in Sharpen.Runtime.GetDeclaredFields(typeof(RevWalkPathFilter6012Test ))) { if (z.FieldType == typeof(RevCommit)) { byName.Put((RevCommit)z.GetValue(this), z.Name); } } }
/// <summary>Obtain the raw text to match against.</summary> /// <remarks>Obtain the raw text to match against.</remarks> /// <param name="cmit">current commit being evaluated.</param> /// <returns>sequence for the commit's content that we need to match on.</returns> protected internal abstract RawCharSequence Text(RevCommit cmit);