public virtual void TestCreateAndList() { int localBefore; int remoteBefore; int allBefore; // invalid name not allowed try { git.BranchCreate().SetName("In va lid").Call(); NUnit.Framework.Assert.Fail("Create branch with invalid ref name should fail"); } catch (InvalidRefNameException) { } // expected // existing name not allowed w/o force try { git.BranchCreate().SetName("master").Call(); NUnit.Framework.Assert.Fail("Create branch with existing ref name should fail"); } catch (RefAlreadyExistsException) { } // expected localBefore = git.BranchList().Call().Count; remoteBefore = git.BranchList().SetListMode(ListBranchCommand.ListMode.REMOTE).Call ().Count; allBefore = git.BranchList().SetListMode(ListBranchCommand.ListMode.ALL).Call().Count; NUnit.Framework.Assert.AreEqual(localBefore + remoteBefore, allBefore); Ref newBranch = CreateBranch(git, "NewForTestList", false, "master", null); NUnit.Framework.Assert.AreEqual("refs/heads/NewForTestList", newBranch.GetName()); NUnit.Framework.Assert.AreEqual(1, git.BranchList().Call().Count - localBefore); NUnit.Framework.Assert.AreEqual(0, git.BranchList().SetListMode(ListBranchCommand.ListMode .REMOTE).Call().Count - remoteBefore); NUnit.Framework.Assert.AreEqual(1, git.BranchList().SetListMode(ListBranchCommand.ListMode .ALL).Call().Count - allBefore); // we can only create local branches newBranch = CreateBranch(git, "refs/remotes/origin/NewRemoteForTestList", false, "master", null); NUnit.Framework.Assert.AreEqual("refs/heads/refs/remotes/origin/NewRemoteForTestList" , newBranch.GetName()); NUnit.Framework.Assert.AreEqual(2, git.BranchList().Call().Count - localBefore); NUnit.Framework.Assert.AreEqual(0, git.BranchList().SetListMode(ListBranchCommand.ListMode .REMOTE).Call().Count - remoteBefore); NUnit.Framework.Assert.AreEqual(2, git.BranchList().SetListMode(ListBranchCommand.ListMode .ALL).Call().Count - allBefore); }
public virtual void TestPullLocalConflict() { target.BranchCreate().SetName("basedOnMaster").SetStartPoint("refs/heads/master") .SetUpstreamMode(CreateBranchCommand.SetupUpstreamMode.TRACK).Call(); target.GetRepository().UpdateRef(Constants.HEAD).Link("refs/heads/basedOnMaster"); PullResult res = target.Pull().Call(); // nothing to update since we don't have different data yet NUnit.Framework.Assert.IsNull(res.GetFetchResult()); NUnit.Framework.Assert.IsTrue(res.GetMergeResult().GetMergeStatus().Equals(MergeStatus .ALREADY_UP_TO_DATE)); AssertFileContentsEqual(targetFile, "Hello world"); // change the file in master target.GetRepository().UpdateRef(Constants.HEAD).Link("refs/heads/master"); WriteToFile(targetFile, "Master change"); target.Add().AddFilepattern("SomeFile.txt").Call(); target.Commit().SetMessage("Source change in master").Call(); // change the file in slave target.GetRepository().UpdateRef(Constants.HEAD).Link("refs/heads/basedOnMaster"); WriteToFile(targetFile, "Slave change"); target.Add().AddFilepattern("SomeFile.txt").Call(); target.Commit().SetMessage("Source change in based on master").Call(); res = target.Pull().Call(); string sourceChangeString = "Master change\n>>>>>>> branch 'master' of local repository"; NUnit.Framework.Assert.IsNull(res.GetFetchResult()); NUnit.Framework.Assert.AreEqual(res.GetMergeResult().GetMergeStatus(), MergeStatus .CONFLICTING); string result = "<<<<<<< HEAD\nSlave change\n=======\n" + sourceChangeString + "\n"; AssertFileContentsEqual(targetFile, result); NUnit.Framework.Assert.AreEqual(RepositoryState.MERGING, target.GetRepository().GetRepositoryState ()); }
public virtual void StashChangeInANewSubdirectory() { string subdir = "subdir"; string fname = "file2.txt"; string path = subdir + "/" + fname; string otherBranch = "otherbranch"; WriteTrashFile(subdir, fname, "content2"); git.Add().AddFilepattern(path).Call(); RevCommit stashed = git.StashCreate().Call(); NUnit.Framework.Assert.IsNotNull(stashed); NUnit.Framework.Assert.IsTrue(git.Status().Call().IsClean()); git.BranchCreate().SetName(otherBranch).Call(); git.Checkout().SetName(otherBranch).Call(); ObjectId unstashed = git.StashApply().Call(); NUnit.Framework.Assert.AreEqual(stashed, unstashed); Status status = git.Status().Call(); NUnit.Framework.Assert.IsTrue(status.GetChanged().IsEmpty()); NUnit.Framework.Assert.IsTrue(status.GetConflicting().IsEmpty()); NUnit.Framework.Assert.IsTrue(status.GetMissing().IsEmpty()); NUnit.Framework.Assert.IsTrue(status.GetRemoved().IsEmpty()); NUnit.Framework.Assert.IsTrue(status.GetModified().IsEmpty()); NUnit.Framework.Assert.IsTrue(status.GetUntracked().IsEmpty()); NUnit.Framework.Assert.AreEqual(1, status.GetAdded().Count); NUnit.Framework.Assert.IsTrue(status.GetAdded().Contains(path)); }
public virtual void TestCherryPick() { Git git = new Git(db); WriteTrashFile("a", "first line\nsec. line\nthird line\n"); git.Add().AddFilepattern("a").Call(); RevCommit firstCommit = git.Commit().SetMessage("create a").Call(); WriteTrashFile("b", "content\n"); git.Add().AddFilepattern("b").Call(); git.Commit().SetMessage("create b").Call(); WriteTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n"); git.Add().AddFilepattern("a").Call(); git.Commit().SetMessage("enlarged a").Call(); WriteTrashFile("a", "first line\nsecond line\nthird line\nfourth line\n"); git.Add().AddFilepattern("a").Call(); RevCommit fixingA = git.Commit().SetMessage("fixed a").Call(); git.BranchCreate().SetName("side").SetStartPoint(firstCommit).Call(); CheckoutBranch("refs/heads/side"); WriteTrashFile("a", "first line\nsec. line\nthird line\nfeature++\n"); git.Add().AddFilepattern("a").Call(); git.Commit().SetMessage("enhanced a").Call(); git.CherryPick().Include(fixingA).Call(); NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "b").Exists()); CheckFile(new FilePath(db.WorkTree, "a"), "first line\nsecond line\nthird line\nfeature++\n" ); Iterator <RevCommit> history = git.Log().Call().Iterator(); NUnit.Framework.Assert.AreEqual("fixed a", history.Next().GetFullMessage()); NUnit.Framework.Assert.AreEqual("enhanced a", history.Next().GetFullMessage()); NUnit.Framework.Assert.AreEqual("create a", history.Next().GetFullMessage()); NUnit.Framework.Assert.IsFalse(history.HasNext()); }
public virtual void TestPushRefUpdate() { Git git = new Git(db); Git git2 = new Git(CreateBareRepository()); StoredConfig config = git.GetRepository().GetConfig(); RemoteConfig remoteConfig = new RemoteConfig(config, "test"); URIish uri = new URIish(git2.GetRepository().Directory.ToURI().ToURL()); remoteConfig.AddURI(uri); remoteConfig.AddPushRefSpec(new RefSpec("+refs/heads/*:refs/heads/*")); remoteConfig.Update(config); config.Save(); WriteTrashFile("f", "content of f"); git.Add().AddFilepattern("f").Call(); RevCommit commit = git.Commit().SetMessage("adding f").Call(); NUnit.Framework.Assert.AreEqual(null, git2.GetRepository().Resolve("refs/heads/master" )); git.Push().SetRemote("test").Call(); NUnit.Framework.Assert.AreEqual(commit.Id, git2.GetRepository().Resolve("refs/heads/master" )); git.BranchCreate().SetName("refs/heads/test").Call(); git.Checkout().SetName("refs/heads/test").Call(); for (int i = 0; i < 6; i++) { WriteTrashFile("f" + i, "content of f" + i); git.Add().AddFilepattern("f" + i).Call(); commit = git.Commit().SetMessage("adding f" + i).Call(); git.Push().SetRemote("test").Call(); git2.GetRepository().GetAllRefs(); NUnit.Framework.Assert.AreEqual(commit.Id, git2.GetRepository().Resolve("refs/heads/test" ), "failed to update on attempt " + i); } }
public virtual void TestCherryPick() { Git git = new Git(db); WriteTrashFile("a", "first line\nsec. line\nthird line\n"); git.Add().AddFilepattern("a").Call(); RevCommit firstCommit = git.Commit().SetMessage("create a").Call(); WriteTrashFile("b", "content\n"); git.Add().AddFilepattern("b").Call(); git.Commit().SetMessage("create b").Call(); WriteTrashFile("a", "first line\nsec. line\nthird line\nfourth line\n"); git.Add().AddFilepattern("a").Call(); git.Commit().SetMessage("enlarged a").Call(); WriteTrashFile("a", "first line\nsecond line\nthird line\nfourth line\n"); git.Add().AddFilepattern("a").Call(); RevCommit fixingA = git.Commit().SetMessage("fixed a").Call(); git.BranchCreate().SetName("side").SetStartPoint(firstCommit).Call(); CheckoutBranch("refs/heads/side"); WriteTrashFile("a", "first line\nsec. line\nthird line\nfeature++\n"); git.Add().AddFilepattern("a").Call(); git.Commit().SetMessage("enhanced a").Call(); git.CherryPick().Include(fixingA).Call(); NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "b").Exists()); CheckFile(new FilePath(db.WorkTree, "a"), "first line\nsecond line\nthird line\nfeature++\n" ); Iterator<RevCommit> history = git.Log().Call().Iterator(); NUnit.Framework.Assert.AreEqual("fixed a", history.Next().GetFullMessage()); NUnit.Framework.Assert.AreEqual("enhanced a", history.Next().GetFullMessage()); NUnit.Framework.Assert.AreEqual("create a", history.Next().GetFullMessage()); NUnit.Framework.Assert.IsFalse(history.HasNext()); }
public virtual void LogAllCommits() { IList <RevCommit> commits = new AList <RevCommit>(); Git git = Git.Wrap(db); WriteTrashFile("Test.txt", "Hello world"); git.Add().AddFilepattern("Test.txt").Call(); commits.AddItem(git.Commit().SetMessage("initial commit").Call()); git.BranchCreate().SetName("branch1").Call(); Ref checkedOut = git.Checkout().SetName("branch1").Call(); NUnit.Framework.Assert.AreEqual("refs/heads/branch1", checkedOut.GetName()); WriteTrashFile("Test1.txt", "Hello world!"); git.Add().AddFilepattern("Test1.txt").Call(); commits.AddItem(git.Commit().SetMessage("branch1 commit").Call()); checkedOut = git.Checkout().SetName("master").Call(); NUnit.Framework.Assert.AreEqual("refs/heads/master", checkedOut.GetName()); WriteTrashFile("Test2.txt", "Hello world!!"); git.Add().AddFilepattern("Test2.txt").Call(); commits.AddItem(git.Commit().SetMessage("branch1 commit").Call()); Iterator <RevCommit> log = git.Log().All().Call().Iterator(); NUnit.Framework.Assert.IsTrue(log.HasNext()); NUnit.Framework.Assert.IsTrue(commits.Contains(log.Next())); NUnit.Framework.Assert.IsTrue(log.HasNext()); NUnit.Framework.Assert.IsTrue(commits.Contains(log.Next())); NUnit.Framework.Assert.IsTrue(log.HasNext()); NUnit.Framework.Assert.IsTrue(commits.Contains(log.Next())); NUnit.Framework.Assert.IsFalse(log.HasNext()); }
public virtual void TestUpdateSmudgedEntries() { git.BranchCreate().SetName("test2").Call(); RefUpdate rup = db.UpdateRef(Constants.HEAD); rup.Link("refs/heads/test2"); FilePath file = new FilePath(db.WorkTree, "Test.txt"); long size = file.Length(); long mTime = file.LastModified() - 5000L; NUnit.Framework.Assert.IsTrue(file.SetLastModified(mTime)); DirCache cache = DirCache.Lock(db.GetIndexFile(), db.FileSystem); DirCacheEntry entry = cache.GetEntry("Test.txt"); NUnit.Framework.Assert.IsNotNull(entry); entry.SetLength(0); entry.LastModified = 0; cache.Write(); NUnit.Framework.Assert.IsTrue(cache.Commit()); cache = DirCache.Read(db.GetIndexFile(), db.FileSystem); entry = cache.GetEntry("Test.txt"); NUnit.Framework.Assert.IsNotNull(entry); NUnit.Framework.Assert.AreEqual(0, entry.Length); NUnit.Framework.Assert.AreEqual(0, entry.LastModified); db.GetIndexFile().SetLastModified(db.GetIndexFile().LastModified() - 5000); NUnit.Framework.Assert.IsNotNull(git.Checkout().SetName("test").Call()); cache = DirCache.Read(db.GetIndexFile(), db.FileSystem); entry = cache.GetEntry("Test.txt"); NUnit.Framework.Assert.IsNotNull(entry); NUnit.Framework.Assert.AreEqual(size, entry.Length); NUnit.Framework.Assert.AreEqual(mTime, entry.LastModified); }
/// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> /// <exception cref="NGit.Api.Errors.RefAlreadyExistsException"></exception> /// <exception cref="NGit.Api.Errors.RefNotFoundException"></exception> /// <exception cref="NGit.Api.Errors.InvalidRefNameException"></exception> public virtual Ref CreateBranch(Git actGit, string name, bool force, string startPoint , CreateBranchCommand.SetupUpstreamMode? mode) { CreateBranchCommand cmd = actGit.BranchCreate(); cmd.SetName(name); cmd.SetForce(force); cmd.SetStartPoint(startPoint); cmd.SetUpstreamMode(mode != null ? mode.Value : CreateBranchCommand.SetupUpstreamMode.NOT_SET); return cmd.Call(); }
/// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> /// <exception cref="NGit.Api.Errors.RefAlreadyExistsException"></exception> /// <exception cref="NGit.Api.Errors.RefNotFoundException"></exception> /// <exception cref="NGit.Api.Errors.InvalidRefNameException"></exception> public virtual Ref CreateBranch(Git actGit, string name, bool force, string startPoint , CreateBranchCommand.SetupUpstreamMode?mode) { CreateBranchCommand cmd = actGit.BranchCreate(); cmd.SetName(name); cmd.SetForce(force); cmd.SetStartPoint(startPoint); cmd.SetUpstreamMode(mode != null ? mode.Value : CreateBranchCommand.SetupUpstreamMode.NOT_SET); return(cmd.Call()); }
public virtual void TestCloneRepositoryWithMultipleHeadBranches() { git.Checkout().SetName(Constants.MASTER).Call(); git.BranchCreate().SetName("a").Call(); FilePath directory = CreateTempDirectory("testCloneRepositoryWithMultipleHeadBranches" ); CloneCommand clone = Git.CloneRepository(); clone.SetDirectory(directory); clone.SetURI("file://" + git.GetRepository().WorkTree.GetPath()); Git git2 = clone.Call(); AddRepoToClose(git2.GetRepository()); NUnit.Framework.Assert.IsNotNull(git2); NUnit.Framework.Assert.AreEqual(Constants.MASTER, git2.GetRepository().GetBranch( )); }
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(); }
/// <exception cref="System.Exception"></exception> public override void SetUp() { base.SetUp(); tr = new TestRepository<Repository>(db); git = new Git(db); // commit something WriteTrashFile("Test.txt", "Hello world"); git.Add().AddFilepattern("Test.txt").Call(); 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(); git.Commit().SetMessage("Second commit").Call(); RevBlob blob = tr.Blob("blob-not-in-master-branch"); git.Tag().SetName("tag-for-blob").SetObjectId(blob).Call(); }
/// <exception cref="System.Exception"></exception> public override void SetUp() { base.SetUp(); tr = new TestRepository <Repository>(db); git = new Git(db); // commit something WriteTrashFile("Test.txt", "Hello world"); git.Add().AddFilepattern("Test.txt").Call(); 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(); git.Commit().SetMessage("Second commit").Call(); RevBlob blob = tr.Blob("blob-not-in-master-branch"); git.Tag().SetName("tag-for-blob").SetObjectId(blob).Call(); }
public virtual void TestPullLocalConflict() { target.BranchCreate().SetName("basedOnMaster").SetStartPoint("refs/heads/master") .SetUpstreamMode(CreateBranchCommand.SetupUpstreamMode.NOTRACK).Call(); StoredConfig config = target.GetRepository().GetConfig(); config.SetString("branch", "basedOnMaster", "remote", "."); config.SetString("branch", "basedOnMaster", "merge", "refs/heads/master"); config.SetBoolean("branch", "basedOnMaster", "rebase", true); config.Save(); target.GetRepository().UpdateRef(Constants.HEAD).Link("refs/heads/basedOnMaster"); PullResult res = target.Pull().Call(); // nothing to update since we don't have different data yet NUnit.Framework.Assert.IsNull(res.GetFetchResult()); NUnit.Framework.Assert.AreEqual(RebaseResult.Status.UP_TO_DATE, res.GetRebaseResult ().GetStatus()); AssertFileContentsEqual(targetFile, "Hello world"); // change the file in master target.GetRepository().UpdateRef(Constants.HEAD).Link("refs/heads/master"); WriteToFile(targetFile, "Master change"); target.Add().AddFilepattern("SomeFile.txt").Call(); target.Commit().SetMessage("Source change in master").Call(); // change the file in slave target.GetRepository().UpdateRef(Constants.HEAD).Link("refs/heads/basedOnMaster"); WriteToFile(targetFile, "Slave change"); target.Add().AddFilepattern("SomeFile.txt").Call(); target.Commit().SetMessage("Source change in based on master").Call(); res = target.Pull().Call(); NUnit.Framework.Assert.IsNull(res.GetFetchResult()); NUnit.Framework.Assert.AreEqual(RebaseResult.Status.STOPPED, res.GetRebaseResult( ).GetStatus()); string result = "<<<<<<< Upstream, based on branch 'master' of local repository\n" + "Master change\n=======\nSlave change\n>>>>>>> 4049c9e Source change in based on master\n"; AssertFileContentsEqual(targetFile, result); NUnit.Framework.Assert.AreEqual(RepositoryState.REBASING_INTERACTIVE, target.GetRepository ().GetRepositoryState()); }
/// <summary> /// Commit a file with the specified contents on the specified branch, /// creating the branch if it didn't exist before. /// </summary> /// <remarks> /// Commit a file with the specified contents on the specified branch, /// creating the branch if it didn't exist before. /// <p> /// It switches back to the original branch after the commit if there was /// one. /// </remarks> /// <param name="filename"></param> /// <param name="contents"></param> /// <param name="branch"></param> /// <returns>the created commit</returns> protected internal virtual RevCommit CommitFile(string filename, string contents, string branch) { try { Git git = new Git(db); string originalBranch = git.GetRepository().GetFullBranch(); if (git.GetRepository().GetRef(branch) == null) { git.BranchCreate().SetName(branch).Call(); } git.Checkout().SetName(branch).Call(); WriteTrashFile(filename, contents); git.Add().AddFilepattern(filename).Call(); RevCommit commit = git.Commit().SetMessage(branch + ": " + filename).Call(); if (originalBranch != null) { git.Checkout().SetName(originalBranch).Call(); } return commit; } catch (IOException e) { throw new RuntimeException(e); } catch (GitAPIException e) { throw new RuntimeException(e); } }
public static FileRepository Clone (string targetLocalPath, string url, IProgressMonitor monitor) { FileRepository repo = Init (targetLocalPath, url, monitor); // Fetch string remoteName = "origin"; string branch = Constants.R_HEADS + "master"; Transport tn = Transport.Open (repo, remoteName); FetchResult r; try { r = tn.Fetch(new GitMonitor (monitor), null); } finally { tn.Close (); } // Create the master branch // branch is like 'Constants.R_HEADS + branchName', we need only // the 'branchName' part String branchName = branch.Substring (Constants.R_HEADS.Length); NGit.Api.Git git = new NGit.Api.Git (repo); git.BranchCreate ().SetName (branchName).SetUpstreamMode (CreateBranchCommand.SetupUpstreamMode.TRACK).SetStartPoint ("origin/master").Call (); // Checkout DirCache dc = repo.LockDirCache (); try { RevWalk rw = new RevWalk (repo); ObjectId remCommitId = repo.Resolve (remoteName + "/" + branchName); RevCommit remCommit = rw.ParseCommit (remCommitId); DirCacheCheckout co = new DirCacheCheckout (repo, null, dc, remCommit.Tree); co.Checkout (); } catch { dc.Unlock (); throw; } return repo; }
public virtual void TestResetHard() { Git git = new Git(db); WriteTrashFile("f", "f()"); WriteTrashFile("D/g", "g()"); git.Add().AddFilepattern(".").Call(); git.Commit().SetMessage("inital").Call(); AssertIndex(Mkmap("f", "f()", "D/g", "g()")); git.BranchCreate().SetName("topic").Call(); WriteTrashFile("f", "f()\nmaster"); WriteTrashFile("D/g", "g()\ng2()"); WriteTrashFile("E/h", "h()"); git.Add().AddFilepattern(".").Call(); RevCommit master = git.Commit().SetMessage("master-1").Call(); AssertIndex(Mkmap("f", "f()\nmaster", "D/g", "g()\ng2()", "E/h", "h()")); CheckoutBranch("refs/heads/topic"); AssertIndex(Mkmap("f", "f()", "D/g", "g()")); WriteTrashFile("f", "f()\nside"); NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "D/g").Delete()); WriteTrashFile("G/i", "i()"); git.Add().AddFilepattern(".").Call(); git.Add().AddFilepattern(".").SetUpdate(true).Call(); RevCommit topic = git.Commit().SetMessage("topic-1").Call(); AssertIndex(Mkmap("f", "f()\nside", "G/i", "i()")); WriteTrashFile("untracked", "untracked"); ResetHard(master); AssertIndex(Mkmap("f", "f()\nmaster", "D/g", "g()\ng2()", "E/h", "h()")); ResetHard(topic); AssertIndex(Mkmap("f", "f()\nside", "G/i", "i()")); AssertWorkDir(Mkmap("f", "f()\nside", "G/i", "i()", "untracked", "untracked")); NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, git.Merge().Include(master ).Call().GetMergeStatus()); NUnit.Framework.Assert.AreEqual("[D/g, mode:100644, stage:1][D/g, mode:100644, stage:3][E/h, mode:100644][G/i, mode:100644][f, mode:100644, stage:1][f, mode:100644, stage:2][f, mode:100644, stage:3]" , IndexState(0)); ResetHard(master); AssertIndex(Mkmap("f", "f()\nmaster", "D/g", "g()\ng2()", "E/h", "h()")); AssertWorkDir(Mkmap("f", "f()\nmaster", "D/g", "g()\ng2()", "E/h", "h()", "untracked" , "untracked")); }
/// <exception cref="NGit.Api.Errors.RefAlreadyExistsException"> /// when trying to create (without force) a branch with a name /// that already exists /// </exception> /// <exception cref="NGit.Api.Errors.RefNotFoundException">if the start point or branch can not be found /// </exception> /// <exception cref="NGit.Api.Errors.InvalidRefNameException"> /// if the provided name is <code>null</code> or otherwise /// invalid /// </exception> /// <returns>the newly created branch</returns> /// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> public override Ref Call() { CheckCallable(); ProcessOptions(); try { if (createBranch) { Git git = new Git(repo); CreateBranchCommand command = git.BranchCreate(); command.SetName(name); command.SetStartPoint(GetStartPoint().Name); if (upstreamMode != null) { command.SetUpstreamMode(upstreamMode); } command.Call(); } Ref headRef = repo.GetRef(Constants.HEAD); string refLogMessage = "checkout: moving from " + headRef.GetTarget().GetName(); ObjectId branch = repo.Resolve(name); if (branch == null) { throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved , name)); } RevWalk revWalk = new RevWalk(repo); AnyObjectId headId = headRef.GetObjectId(); RevCommit headCommit = headId == null ? null : revWalk.ParseCommit(headId); RevCommit newCommit = revWalk.ParseCommit(branch); RevTree headTree = headCommit == null ? null : headCommit.Tree; DirCacheCheckout dco = new DirCacheCheckout(repo, headTree, repo.LockDirCache(), newCommit.Tree); dco.SetFailOnConflict(true); try { dco.Checkout(); } catch (NGit.Errors.CheckoutConflictException e) { status = new CheckoutResult(CheckoutResult.Status.CONFLICTS, dco.GetConflicts()); throw; } Ref @ref = repo.GetRef(name); if (@ref != null && [email protected]().StartsWith(Constants.R_HEADS)) { @ref = null; } RefUpdate refUpdate = repo.UpdateRef(Constants.HEAD, @ref == null); refUpdate.SetForceUpdate(force); refUpdate.SetRefLogMessage(refLogMessage + " to " + newCommit.GetName(), false); RefUpdate.Result updateResult; if (@ref != null) { updateResult = refUpdate.Link(@ref.GetName()); } else { refUpdate.SetNewObjectId(newCommit); updateResult = refUpdate.ForceUpdate(); } SetCallable(false); bool ok = false; switch (updateResult) { case RefUpdate.Result.NEW: { ok = true; break; } case RefUpdate.Result.NO_CHANGE: case RefUpdate.Result.FAST_FORWARD: case RefUpdate.Result.FORCED: { ok = true; break; } default: { break; break; } } if (!ok) { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().checkoutUnexpectedResult , updateResult.ToString())); } if (!dco.GetToBeDeleted().IsEmpty()) { status = new CheckoutResult(CheckoutResult.Status.NONDELETED, dco.GetToBeDeleted( )); } else { status = CheckoutResult.OK_RESULT; } return(@ref); } catch (IOException ioe) { throw new JGitInternalException(ioe.Message, ioe); } finally { if (status == null) { status = CheckoutResult.ERROR_RESULT; } } }