public void test001_NewIdent() { PersonIdent p = new PersonIdent("A U Thor", "*****@*****.**", 1142878501L, 0); Assert.AreEqual("A U Thor", p.Name); Assert.AreEqual("*****@*****.**", p.EmailAddress); Assert.AreEqual(1142878501L, p.When.ToGitInternalTime()); Assert.AreEqual("A U Thor <*****@*****.**> 1142878501 +0000", p.ToExternalString()); }
public void test002_ParseIdent() { string i = "A U Thor <*****@*****.**> 1142878501 -0500"; var p = new PersonIdent(i); Assert.AreEqual(i, p.ToExternalString()); Assert.AreEqual("A U Thor", p.Name); Assert.AreEqual("*****@*****.**", p.EmailAddress); Assert.AreEqual(1142878501000L, p.When); }
public void test001_NewIdent() { var p = new PersonIdent("A U Thor", "*****@*****.**", 1142878501L.UnixTimeToDateTime(), TimeZoneInfo.FindSystemTimeZoneById("US/Eastern")); Assert.AreEqual("A U Thor", p.Name); Assert.AreEqual("*****@*****.**", p.EmailAddress); Assert.AreEqual(1142878501000L, p.When); Assert.AreEqual("A U Thor <*****@*****.**> 1142878501 -0500", p .ToExternalString()); }
/// <summary>Sets default values for not explicitly specified options.</summary> /// <remarks> /// Sets default values for not explicitly specified options. Then validates /// that all required data has been provided. /// </remarks> /// <param name="state">the state of the repository we are working on</param> /// <exception cref="NGit.Api.Errors.InvalidTagNameException">if the tag name is null or invalid /// </exception> /// <exception cref="System.NotSupportedException">if the tag is signed (not supported yet) /// </exception> private void ProcessOptions(RepositoryState state) { if (tagger == null) { tagger = new PersonIdent(repo); } if (name == null || !Repository.IsValidRefName(Constants.R_TAGS + name)) { throw new InvalidTagNameException(MessageFormat.Format(JGitText.Get().tagNameInvalid , name == null ? "<null>" : name)); } if (signed) { throw new NotSupportedException(JGitText.Get().signingNotSupportedOnTag); } }
static TestRepository() { MockSystemReader m = new MockSystemReader(); long now = m.getCurrentTime(); int tz = m.getTimezone(now); String an = "J. Author"; String ae = "*****@*****.**"; author = new PersonIdent(an, ae, now, tz); String cn = "J. Committer"; String ce = "*****@*****.**"; committer = new PersonIdent(cn, ce, now, tz); }
/// <exception cref="System.IO.IOException"></exception> private RebaseResult Stop(RevCommit commitToPick) { PersonIdent author = commitToPick.GetAuthorIdent(); string authorScript = ToAuthorScript(author); CreateFile(rebaseDir, AUTHOR_SCRIPT, authorScript); CreateFile(rebaseDir, MESSAGE, commitToPick.GetFullMessage()); ByteArrayOutputStream bos = new ByteArrayOutputStream(); DiffFormatter df = new DiffFormatter(bos); df.SetRepository(repo); df.Format(commitToPick.GetParent(0), commitToPick); CreateFile(rebaseDir, PATCH, Sharpen.Runtime.GetStringForBytes(bos.ToByteArray(), Constants.CHARACTER_ENCODING)); CreateFile(rebaseDir, STOPPED_SHA, repo.NewObjectReader().Abbreviate(commitToPick ).Name); return(new RebaseResult(commitToPick)); }
public virtual void TestParseAllFields() { ObjectId treeId = Id("9788669ad918b6fcce64af8882fc9a81cb6aba67"); string name = "v1.2.3.4.5"; string taggerName = "A U. Thor"; string taggerEmail = "*****@*****.**"; int taggerTime = 1218123387; StringBuilder body = new StringBuilder(); body.Append("object "); body.Append(treeId.Name); body.Append("\n"); body.Append("type tree\n"); body.Append("tag "); body.Append(name); body.Append("\n"); body.Append("tagger "); body.Append(taggerName); body.Append(" <"); body.Append(taggerEmail); body.Append("> "); body.Append(taggerTime); body.Append(" +0700\n"); body.Append("\n"); RevWalk rw = new RevWalk(db); RevTag c; c = new RevTag(Id("9473095c4cb2f12aefe1db8a355fe3fafba42f67")); NUnit.Framework.Assert.IsNull(c.GetObject()); NUnit.Framework.Assert.IsNull(c.GetTagName()); c.ParseCanonical(rw, Sharpen.Runtime.GetBytesForString(body.ToString(), "UTF-8")); NUnit.Framework.Assert.IsNotNull(c.GetObject()); NUnit.Framework.Assert.AreEqual(treeId, c.GetObject().Id); NUnit.Framework.Assert.AreSame(rw.LookupTree(treeId), c.GetObject()); NUnit.Framework.Assert.IsNotNull(c.GetTagName()); NUnit.Framework.Assert.AreEqual(name, c.GetTagName()); NUnit.Framework.Assert.AreEqual(string.Empty, c.GetFullMessage()); PersonIdent cTagger = c.GetTaggerIdent(); NUnit.Framework.Assert.IsNotNull(cTagger); NUnit.Framework.Assert.AreEqual(taggerName, cTagger.GetName()); NUnit.Framework.Assert.AreEqual(taggerEmail, cTagger.GetEmailAddress()); }
public virtual void RefLogIncludesCommitMessage() { PersonIdent who = new PersonIdent("user", "*****@*****.**"); DeleteTrashFile("file.txt"); RevCommit stashed = git.StashCreate().SetPerson(who).Call(); NUnit.Framework.Assert.IsNotNull(stashed); NUnit.Framework.Assert.AreEqual("content", Read(committedFile)); ValidateStashedCommit(stashed); ReflogReader reader = new ReflogReader(git.GetRepository(), Constants.R_STASH); ReflogEntry entry = reader.GetLastEntry(); NUnit.Framework.Assert.IsNotNull(entry); NUnit.Framework.Assert.AreEqual(ObjectId.ZeroId, entry.GetOldId()); NUnit.Framework.Assert.AreEqual(stashed, entry.GetNewId()); NUnit.Framework.Assert.AreEqual(who, entry.GetWho()); NUnit.Framework.Assert.AreEqual(stashed.GetFullMessage(), entry.GetComment()); }
/// <exception cref="System.IO.IOException"></exception> private void UpdateStashRef(ObjectId commitId, PersonIdent refLogIdent, string refLogMessage ) { Ref currentRef = repo.GetRef(@ref); RefUpdate refUpdate = repo.UpdateRef(@ref); refUpdate.SetNewObjectId(commitId); refUpdate.SetRefLogIdent(refLogIdent); refUpdate.SetRefLogMessage(refLogMessage, false); if (currentRef != null) { refUpdate.SetExpectedOldObjectId(currentRef.GetObjectId()); } else { refUpdate.SetExpectedOldObjectId(ObjectId.ZeroId); } refUpdate.ForceUpdate(); }
/// <summary>Sets default values for not explicitly specified options.</summary> /// <remarks> /// Sets default values for not explicitly specified options. Then validates /// that all required data has been provided. /// </remarks> /// <param name="state">the state of the repository we are working on</param> /// <exception cref="NGit.Api.Errors.NoMessageException">if the commit message has not been specified /// </exception> private void ProcessOptions(RepositoryState state) { if (committer == null) { committer = new PersonIdent(repo); } if (author == null) { author = committer; } // when doing a merge commit parse MERGE_HEAD and MERGE_MSG files if (state == RepositoryState.MERGING_RESOLVED) { try { parents = repo.ReadMergeHeads(); } catch (IOException e) { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().exceptionOccurredDuringReadingOfGIT_DIR , Constants.MERGE_HEAD, e), e); } if (message == null) { try { message = repo.ReadMergeCommitMsg(); } catch (IOException e) { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().exceptionOccurredDuringReadingOfGIT_DIR , Constants.MERGE_MSG, e), e); } } } if (message == null) { // as long as we don't suppport -C option we have to have // an explicit message throw new NoMessageException(JGitText.Get().commitMessageNotSpecified); } }
private void commit(Core.Tree t, string commitMsg, PersonIdent author, PersonIdent committer) { Core.Commit commit = new Core.Commit(db); commit.Author = (author); commit.Committer = (committer); commit.Message = (commitMsg); commit.TreeEntry = (t); //ObjectWriter writer = new ObjectWriter(db); //commit.CommitId = (writer.WriteCommit(commit)); commit.Save(); int nl = commitMsg.IndexOf('\n'); RefUpdate ru = db.UpdateRef(Constants.HEAD); ru.NewObjectId = (commit.CommitId); ru.SetRefLogMessage("commit : " + ((nl == -1) ? commitMsg : commitMsg.Slice(0, nl)), false); ru.ForceUpdate(); }
public virtual void TestSomeCommits() { // do 4 commits Git git = new Git(db); git.Commit().SetMessage("initial commit").Call(); git.Commit().SetMessage("second commit").SetCommitter(committer).Call(); git.Commit().SetMessage("third commit").SetAuthor(author).Call(); git.Commit().SetMessage("fourth commit").SetAuthor(author).SetCommitter(committer ).Call(); Iterable <RevCommit> commits = git.Log().Call(); // check that all commits came in correctly PersonIdent defaultCommitter = new PersonIdent(db); PersonIdent[] expectedAuthors = new PersonIdent[] { defaultCommitter, committer, author, author }; PersonIdent[] expectedCommitters = new PersonIdent[] { defaultCommitter, committer , defaultCommitter, committer }; string[] expectedMessages = new string[] { "initial commit", "second commit", "third commit" , "fourth commit" }; int l = expectedAuthors.Length - 1; foreach (RevCommit c in commits) { NUnit.Framework.Assert.AreEqual(expectedAuthors[l].GetName(), c.GetAuthorIdent(). GetName()); NUnit.Framework.Assert.AreEqual(expectedCommitters[l].GetName(), c.GetCommitterIdent ().GetName()); NUnit.Framework.Assert.AreEqual(c.GetFullMessage(), expectedMessages[l]); l--; } NUnit.Framework.Assert.AreEqual(l, -1); ReflogReader reader = db.GetReflogReader(Constants.HEAD); NUnit.Framework.Assert.IsTrue(reader.GetLastEntry().GetComment().StartsWith("commit:" )); reader = db.GetReflogReader(db.GetBranch()); NUnit.Framework.Assert.IsTrue(reader.GetLastEntry().GetComment().StartsWith("commit:" )); }
public virtual void CommitAmendWithoutAuthorShouldSetOriginalAuthorAndAuthorTime( ) { Git git = new Git(db); WriteTrashFile("file1", "file1"); git.Add().AddFilepattern("file1").Call(); string authorName = "First Author"; string authorEmail = "*****@*****.**"; DateTime authorDate = Sharpen.Extensions.CreateDate(1349621117000L); PersonIdent firstAuthor = new PersonIdent(authorName, authorEmail, authorDate, Sharpen.Extensions.GetTimeZone ("UTC")); git.Commit().SetMessage("initial commit").SetAuthor(firstAuthor).Call(); RevCommit amended = git.Commit().SetAmend(true).SetMessage("amend commit").Call(); PersonIdent amendedAuthor = amended.GetAuthorIdent(); NUnit.Framework.Assert.AreEqual(authorName, amendedAuthor.GetName()); NUnit.Framework.Assert.AreEqual(authorEmail, amendedAuthor.GetEmailAddress()); NUnit.Framework.Assert.AreEqual(authorDate.GetTime(), amendedAuthor.GetWhen().GetTime ()); }
internal virtual long Timeof(RevObject o) { if (o is RevCommit) { return(((RevCommit)o).CommitTime); } if (o is RevTag) { RevTag tag = (RevTag)o; try { this._enclosing.ParseBody(tag); } catch (IOException) { return(0); } PersonIdent who = tag.GetTaggerIdent(); return(who != null?who.GetWhen().GetTime() : 0); } return(0); }
public virtual void TestTimeAltersId() { PersonIdent oldAuthor = author; PersonIdent oldCommitter = committer; NUnit.Framework.Assert.AreEqual("a\n" + "\n" + "Change-Id: I7fc3876fee63c766a2063df97fbe04a2dddd8d7c\n" , Call("a\n")); // // // Tick(); NUnit.Framework.Assert.AreEqual("a\n" + "\n" + "Change-Id: I3251906b99dda598a58a6346d8126237ee1ea800\n" , Call("a\n")); // // // Tick(); NUnit.Framework.Assert.AreEqual("a\n" + "\n" + "Change-Id: I69adf9208d828f41a3d7e41afbca63aff37c0c5c\n" , Call("a\n")); author = oldAuthor; committer = oldCommitter; }
internal virtual string ToAuthorScript(PersonIdent author) { StringBuilder sb = new StringBuilder(100); sb.Append(GIT_AUTHOR_NAME); sb.Append("='"); sb.Append(author.GetName()); sb.Append("'\n"); sb.Append(GIT_AUTHOR_EMAIL); sb.Append("='"); sb.Append(author.GetEmailAddress()); sb.Append("'\n"); // the command line uses the "external String" // representation for date and timezone sb.Append(GIT_AUTHOR_DATE); sb.Append("='"); string externalString = author.ToExternalString(); sb.Append(Sharpen.Runtime.Substring(externalString, externalString.LastIndexOf('>' ) + 2)); sb.Append("'\n"); return(sb.ToString()); }
public virtual void TestAuthorScriptConverter() { // -1 h timezone offset PersonIdent ident = new PersonIdent("Author name", "*****@*****.**", 123456789123L , -60); string convertedAuthor = git.Rebase().ToAuthorScript(ident); string[] lines = convertedAuthor.Split("\n"); NUnit.Framework.Assert.AreEqual("GIT_AUTHOR_NAME='Author name'", lines[0]); NUnit.Framework.Assert.AreEqual("GIT_AUTHOR_EMAIL='*****@*****.**'", lines[1]); NUnit.Framework.Assert.AreEqual("GIT_AUTHOR_DATE='123456789 -0100'", lines[2]); PersonIdent parsedIdent = git.Rebase().ParseAuthor(Sharpen.Runtime.GetBytesForString (convertedAuthor, "UTF-8")); NUnit.Framework.Assert.AreEqual(ident.GetName(), parsedIdent.GetName()); NUnit.Framework.Assert.AreEqual(ident.GetEmailAddress(), parsedIdent.GetEmailAddress ()); // this is rounded to the last second NUnit.Framework.Assert.AreEqual(123456789000L, parsedIdent.GetWhen().GetTime()); NUnit.Framework.Assert.AreEqual(ident.GetTimeZoneOffset(), parsedIdent.GetTimeZoneOffset ()); // + 9.5h timezone offset ident = new PersonIdent("Author name", "*****@*****.**", 123456789123L, +570); convertedAuthor = git.Rebase().ToAuthorScript(ident); lines = convertedAuthor.Split("\n"); NUnit.Framework.Assert.AreEqual("GIT_AUTHOR_NAME='Author name'", lines[0]); NUnit.Framework.Assert.AreEqual("GIT_AUTHOR_EMAIL='*****@*****.**'", lines[1]); NUnit.Framework.Assert.AreEqual("GIT_AUTHOR_DATE='123456789 +0930'", lines[2]); parsedIdent = git.Rebase().ParseAuthor(Sharpen.Runtime.GetBytesForString(convertedAuthor , "UTF-8")); NUnit.Framework.Assert.AreEqual(ident.GetName(), parsedIdent.GetName()); NUnit.Framework.Assert.AreEqual(ident.GetEmailAddress(), parsedIdent.GetEmailAddress ()); NUnit.Framework.Assert.AreEqual(123456789000L, parsedIdent.GetWhen().GetTime()); NUnit.Framework.Assert.AreEqual(ident.GetTimeZoneOffset(), parsedIdent.GetTimeZoneOffset ()); }
public virtual void SetUp() { lock (this) { if (shutdownHook == null) { shutdownHook = new _Thread_117(this); // On windows accidentally open files or memory // mapped regions may prevent files from being deleted. // Suggesting a GC increases the likelihood that our // test repositories actually get removed after the // tests, even in the case of failure. Runtime.GetRuntime().AddShutdownHook(shutdownHook); } } RecursiveDelete(TestId(), trash, true, false); mockSystemReader = new MockSystemReader(); mockSystemReader.userGitConfig = new FileBasedConfig(new FilePath(trash, "usergitconfig" ), FS.DETECTED); CeilTestDirectories(GetCeilings()); SystemReader.SetInstance(mockSystemReader); long now = mockSystemReader.GetCurrentTime(); int tz = mockSystemReader.GetTimezone(now); author = new PersonIdent("J. Author", "*****@*****.**"); author = new PersonIdent(author, now, tz); committer = new PersonIdent("J. Committer", "*****@*****.**"); committer = new PersonIdent(committer, now, tz); WindowCacheConfig c = new WindowCacheConfig(); c.SetPackedGitLimit(128 * WindowCacheConfig.KB); c.SetPackedGitWindowSize(8 * WindowCacheConfig.KB); c.SetPackedGitMMAP(useMMAP); c.SetDeltaBaseCacheLimit(8 * WindowCacheConfig.KB); WindowCache.Reconfigure(c); }
private string iso(PersonIdent id) { return id.When.UnixTimeToDateTimeOffset(id.TimeZoneOffset).ToIsoDateFormat(); }
public void test007_ParseIdent() { string i = "A U Thor<*****@*****.**>1142878501 +0230 "; var p = new PersonIdent(i); Assert.AreEqual("A U Thor", p.Name); Assert.AreEqual("*****@*****.**", p.EmailAddress); Assert.AreEqual(1142878501000L, p.When); }
public void setRefLogIdent(PersonIdent pi) { refLogIdent = pi; }
/// <summary> /// Format committer, author or tagger ident according to this formatter's /// specification. /// </summary> /// <remarks> /// Format committer, author or tagger ident according to this formatter's /// specification. /// </remarks> /// <param name="ident"></param> /// <returns>formatted version of date, time and time zone</returns> public virtual string FormatDate(PersonIdent ident) { TimeZoneInfo tz; switch (format) { case GitDateFormatter.Format.RAW: { int offset = ident.GetTimeZoneOffset(); string sign = offset < 0 ? "-" : "+"; int offset2; if (offset < 0) { offset2 = -offset; } else { offset2 = offset; } int hours = offset2 / 60; int minutes = offset2 % 60; return(string.Format("%d %s%02d%02d", ident.GetWhen().GetTime() / 1000, sign, hours , minutes)); } case GitDateFormatter.Format.RELATIVE: { return(RelativeDateFormatter.Format(ident.GetWhen())); } case GitDateFormatter.Format.LOCALELOCAL: case GitDateFormatter.Format.LOCAL: { dateTimeInstance.SetTimeZone(SystemReader.GetInstance().GetTimeZone()); return(dateTimeInstance.Format(ident.GetWhen())); } case GitDateFormatter.Format.LOCALE: { tz = ident.GetTimeZone(); if (tz == null) { tz = SystemReader.GetInstance().GetTimeZone(); } dateTimeInstance.SetTimeZone(tz); dateTimeInstance2.SetTimeZone(tz); return(dateTimeInstance.Format(ident.GetWhen()) + " " + dateTimeInstance2.Format( ident.GetWhen())); } default: { tz = ident.GetTimeZone(); if (tz == null) { tz = SystemReader.GetInstance().GetTimeZone(); } dateTimeInstance.SetTimeZone(ident.GetTimeZone()); return(dateTimeInstance.Format(ident.GetWhen())); break; } } }
public void test004_ParseIdent() { String i = "A U Thor<*****@*****.**> 1142878501 +0230"; PersonIdent p = new PersonIdent(i); Assert.AreEqual("A U Thor", p.Name); Assert.AreEqual("*****@*****.**", p.EmailAddress); Assert.AreEqual(1142878501L, p.When.ToGitInternalTime()); }
public API_NGit() { Author = new PersonIdent(NGit_Consts.DEFAULT_COMMIT_NAME, NGit_Consts.DEFAULT_COMMIT_EMAIL); Committer = new PersonIdent("FluentSharp NGit", "*****@*****.**"); }
public static ObjectId CreateCommit(NGit.Repository rep, string message, IList <ObjectId> parents, ObjectId indexTreeId, PersonIdent author, PersonIdent committer) { try { ObjectInserter odi = rep.NewObjectInserter(); try { // Create a Commit object, populate it and write it NGit.CommitBuilder commit = new NGit.CommitBuilder(); commit.Committer = committer; commit.Author = author; commit.Message = message; commit.SetParentIds(parents); commit.TreeId = indexTreeId; ObjectId commitId = odi.Insert(commit); odi.Flush(); return(commitId); } finally { odi.Release(); } } catch (UnmergedPathException) { // since UnmergedPathException is a subclass of IOException // which should not be wrapped by a JGitInternalException we // have to catch and re-throw it here throw; } catch (IOException e) { throw new JGitInternalException("Commit failed", e); } }
/// <summary>Set the person to use as the author and committer in the commits made</summary> /// <param name="person"></param> /// <returns> /// /// <code>this</code> /// </returns> public virtual NGit.Api.StashCreateCommand SetPerson(PersonIdent person) { this.person = person; return(this); }
public Stash Create(ProgressMonitor monitor, string message) { if (monitor != null) { monitor.Start(1); monitor.BeginTask("Stashing changes", 100); } UserConfig config = _repo.GetConfig().Get(UserConfig.KEY); RevWalk rw = new RevWalk(_repo); ObjectId headId = _repo.Resolve(Constants.HEAD); var parent = rw.ParseCommit(headId); PersonIdent author = new PersonIdent(config.GetAuthorName() ?? "unknown", config.GetAuthorEmail() ?? "unknown@(none)."); if (string.IsNullOrEmpty(message)) { // Use the commit summary as message message = parent.Abbreviate(7) + " " + parent.GetShortMessage(); int i = message.IndexOfAny(new char[] { '\r', '\n' }); if (i != -1) { message = message.Substring(0, i); } } // Create the index tree commit ObjectInserter inserter = _repo.NewObjectInserter(); DirCache dc = _repo.ReadDirCache(); if (monitor != null) { monitor.Update(10); } var tree_id = dc.WriteTree(inserter); inserter.Release(); if (monitor != null) { monitor.Update(10); } string commitMsg = "index on " + _repo.GetBranch() + ": " + message; ObjectId indexCommit = GitUtil.CreateCommit(_repo, commitMsg + "\n", new ObjectId[] { headId }, tree_id, author, author); if (monitor != null) { monitor.Update(20); } // Create the working dir commit tree_id = WriteWorkingDirectoryTree(parent.Tree, dc); commitMsg = "WIP on " + _repo.GetBranch() + ": " + message; var wipCommit = GitUtil.CreateCommit(_repo, commitMsg + "\n", new ObjectId[] { headId, indexCommit }, tree_id, author, author); if (monitor != null) { monitor.Update(20); } string prevCommit = null; FileInfo sf = StashRefFile; if (sf.Exists) { prevCommit = File.ReadAllText(sf.FullName).Trim(' ', '\t', '\r', '\n'); } Stash s = new Stash(prevCommit, wipCommit.Name, author, commitMsg); FileInfo stashLog = StashLogFile; File.AppendAllText(stashLog.FullName, s.FullLine + "\n"); File.WriteAllText(sf.FullName, s.CommitId + "\n"); if (monitor != null) { monitor.Update(5); } // Wipe all local changes GitUtil.HardReset(_repo, Constants.HEAD); monitor.EndTask(); s.StashCollection = this; return(s); }
/// <summary> /// Sets the committer for this /// <code>commit</code> /// . If no committer is explicitly /// specified because this method is never called or called with /// <code>null</code> /// value then the committer will be deduced from config info in repository, /// with current time. /// </summary> /// <param name="committer"> /// the committer used for the /// <code>commit</code> /// </param> /// <returns> /// /// <code>this</code> /// </returns> public virtual NGit.Api.CommitCommand SetCommitter(PersonIdent committer) { CheckCallable(); this.committer = committer; return(this); }
/// <summary> /// Sets the author for this /// <code>commit</code> /// . If no author is explicitly /// specified because this method is never called or called with /// <code>null</code> /// value then the author will be set to the committer or to the original /// author when amending. /// </summary> /// <param name="author"> /// the author used for the /// <code>commit</code> /// </param> /// <returns> /// /// <code>this</code> /// </returns> public virtual NGit.Api.CommitCommand SetAuthor(PersonIdent author) { CheckCallable(); this.author = author; return(this); }
/// <summary> /// Executes the /// <code>commit</code> /// command with all the options and parameters /// collected by the setter methods of this class. Each instance of this /// class should only be used for one invocation of the command (means: one /// call to /// <see cref="Call()">Call()</see> /// ) /// </summary> /// <returns> /// a /// <see cref="NGit.Revwalk.RevCommit">NGit.Revwalk.RevCommit</see> /// object representing the successful commit. /// </returns> /// <exception cref="NGit.Api.Errors.NoHeadException">when called on a git repo without a HEAD reference /// </exception> /// <exception cref="NGit.Api.Errors.NoMessageException">when called without specifying a commit message /// </exception> /// <exception cref="NGit.Api.Errors.UnmergedPathsException">when the current index contained unmerged paths (conflicts) /// </exception> /// <exception cref="NGit.Api.Errors.ConcurrentRefUpdateException"> /// when HEAD or branch ref is updated concurrently by someone /// else /// </exception> /// <exception cref="NGit.Api.Errors.WrongRepositoryStateException">when repository is not in the right state for committing /// </exception> /// <exception cref="NGit.Api.Errors.GitAPIException"></exception> public override RevCommit Call() { CheckCallable(); RepositoryState state = repo.GetRepositoryState(); if (!state.CanCommit()) { throw new WrongRepositoryStateException(MessageFormat.Format(JGitText.Get().cannotCommitOnARepoWithState , state.Name())); } ProcessOptions(state); try { if (all && !repo.IsBare && repo.WorkTree != null) { Git git = new Git(repo); try { git.Add().AddFilepattern(".").SetUpdate(true).Call(); } catch (NoFilepatternException e) { // should really not happen throw new JGitInternalException(e.Message, e); } } Ref head = repo.GetRef(Constants.HEAD); if (head == null) { throw new NoHeadException(JGitText.Get().commitOnRepoWithoutHEADCurrentlyNotSupported ); } // determine the current HEAD and the commit it is referring to ObjectId headId = repo.Resolve(Constants.HEAD + "^{commit}"); if (headId == null && amend) { throw new WrongRepositoryStateException(JGitText.Get().commitAmendOnInitialNotPossible ); } if (headId != null) { if (amend) { RevCommit previousCommit = new RevWalk(repo).ParseCommit(headId); RevCommit[] p = previousCommit.Parents; for (int i = 0; i < p.Length; i++) { parents.Add(0, p[i].Id); } if (author == null) { author = previousCommit.GetAuthorIdent(); } } else { parents.Add(0, headId); } } // lock the index DirCache index = repo.LockDirCache(); try { if (!only.IsEmpty()) { index = CreateTemporaryIndex(headId, index); } ObjectInserter odi = repo.NewObjectInserter(); try { // Write the index as tree to the object database. This may // fail for example when the index contains unmerged paths // (unresolved conflicts) ObjectId indexTreeId = index.WriteTree(odi); if (insertChangeId) { InsertChangeId(indexTreeId); } // Create a Commit object, populate it and write it NGit.CommitBuilder commit = new NGit.CommitBuilder(); commit.Committer = committer; commit.Author = author; commit.Message = message; commit.SetParentIds(parents); commit.TreeId = indexTreeId; ObjectId commitId = odi.Insert(commit); odi.Flush(); RevWalk revWalk = new RevWalk(repo); try { RevCommit revCommit = revWalk.ParseCommit(commitId); RefUpdate ru = repo.UpdateRef(Constants.HEAD); ru.SetNewObjectId(commitId); if (reflogComment != null) { ru.SetRefLogMessage(reflogComment, false); } else { string prefix = amend ? "commit (amend): " : "commit: "; ru.SetRefLogMessage(prefix + revCommit.GetShortMessage(), false); } if (headId != null) { ru.SetExpectedOldObjectId(headId); } else { ru.SetExpectedOldObjectId(ObjectId.ZeroId); } RefUpdate.Result rc = ru.ForceUpdate(); switch (rc) { case RefUpdate.Result.NEW: case RefUpdate.Result.FORCED: case RefUpdate.Result.FAST_FORWARD: { SetCallable(false); if (state == RepositoryState.MERGING_RESOLVED) { // Commit was successful. Now delete the files // used for merge commits repo.WriteMergeCommitMsg(null); repo.WriteMergeHeads(null); } else { if (state == RepositoryState.CHERRY_PICKING_RESOLVED) { repo.WriteMergeCommitMsg(null); repo.WriteCherryPickHead(null); } } return(revCommit); } case RefUpdate.Result.REJECTED: case RefUpdate.Result.LOCK_FAILURE: { throw new ConcurrentRefUpdateException(JGitText.Get().couldNotLockHEAD, ru.GetRef (), rc); } default: { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().updatingRefFailed , Constants.HEAD, commitId.ToString(), rc)); } } } finally { revWalk.Release(); } } finally { odi.Release(); } } finally { index.Unlock(); } } catch (UnmergedPathException e) { throw new UnmergedPathsException(e); } catch (IOException e) { throw new JGitInternalException(JGitText.Get().exceptionCaughtDuringExecutionOfCommitCommand , e); } }
/// <summary>Create a command to stash changes in the working directory and index</summary> /// <param name="repo"></param> protected internal StashCreateCommand(Repository repo) : base(repo) { person = new PersonIdent(repo); }
private static Person ToPerson(PersonIdent ident) { return(new Person(ident.GetName(), ident.GetEmailAddress())); }
// // // // // // /// <summary>Compute a Change-Id.</summary> /// <remarks>Compute a Change-Id.</remarks> /// <param name="treeId">The id of the tree that would be committed</param> /// <param name="firstParentId">parent id of previous commit or null</param> /// <param name="author"> /// the /// <see cref="NGit.PersonIdent">NGit.PersonIdent</see> /// for the presumed author and time /// </param> /// <param name="committer"> /// the /// <see cref="NGit.PersonIdent">NGit.PersonIdent</see> /// for the presumed committer and time /// </param> /// <param name="message">The commit message</param> /// <returns> /// the change id SHA1 string (without the 'I') or null if the /// message is not complete enough /// </returns> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public static ObjectId ComputeChangeId(ObjectId treeId, ObjectId firstParentId, PersonIdent author, PersonIdent committer, string message) { string cleanMessage = Clean(message); if (cleanMessage.Length == 0) { return(null); } StringBuilder b = new StringBuilder(); b.Append("tree "); b.Append(ObjectId.ToString(treeId)); b.Append("\n"); if (firstParentId != null) { b.Append("parent "); b.Append(ObjectId.ToString(firstParentId)); b.Append("\n"); } b.Append("author "); b.Append(author.ToExternalString()); b.Append("\n"); b.Append("committer "); b.Append(committer.ToExternalString()); b.Append("\n\n"); b.Append(cleanMessage); return(new ObjectInserter.Formatter().IdFor(Constants.OBJ_COMMIT, Sharpen.Runtime.GetBytesForString (b.ToString(), Constants.CHARACTER_ENCODING))); }
public static RevCommit commit(this API_NGit nGit, string commitMessage, PersonIdent author, PersonIdent committer) { if (commitMessage.valid()) { "[API_NGit] commit: {0}".debug(commitMessage); var commit_Command = nGit.Git.Commit(); commit_Command.SetMessage(commitMessage); commit_Command.SetAuthor(author); commit_Command.SetCommitter(committer); return(commit_Command.Call()); } "[API_NGit] commit was called with no commitMessage".error(); return(null); }
/// <summary>Write the given entry information to the ref's log</summary> /// <param name="refName"></param> /// <param name="oldId"></param> /// <param name="newId"></param> /// <param name="ident"></param> /// <param name="message"></param> /// <returns>this writer</returns> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual NGit.Storage.File.ReflogWriter Log(string refName, ObjectId oldId, ObjectId newId, PersonIdent ident, string message) { byte[] encoded = Encode(oldId, newId, ident, message); return(Log(refName, encoded)); }
/// <summary>Sets the tagger of the tag.</summary> /// <remarks> /// Sets the tagger of the tag. If the tagger is null, a PersonIdent will be /// created from the info in the repository. /// </remarks> /// <param name="tagger"></param> /// <returns> /// /// <code>this</code> /// </returns> public virtual NGit.Api.TagCommand SetTagger(PersonIdent tagger) { this.tagger = tagger; return(this); }
private String iso(PersonIdent id) { return id.When.UnixTimeToDateTimeOffset(id.TimeZoneOffset).ToString("yyyy-MM-dd'T'HH:mm:ss"); return id.When.ToString("yyyy-MM-dd'T'HH:mm:ss"); //SimpleDateFormat fmt; //fmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); //fmt.setTimeZone(id.TimeZoneOffset); //return fmt.format(id.When); }