/// <summary>
/// Copy a
/// <see cref="PersonIdent">PersonIdent</see>
/// , but alter the clone's time stamp
/// </summary>
/// <param name="pi">
/// original
/// <see cref="PersonIdent">PersonIdent</see>
/// </param>
/// <param name="aWhen">local time</param>
public PersonIdent(NGit.PersonIdent pi, DateTime aWhen)
{
name = pi.GetName();
emailAddress = pi.GetEmailAddress();
when = aWhen.GetTime();
tzOffset = pi.tzOffset;
}
public virtual void SetUp()
{
mockSystemReader = new _MockSystemReader_62();
SystemReader.SetInstance(mockSystemReader);
ident = RawParseUtils.ParsePersonIdent("A U Thor <*****@*****.**> 1316560165 -0400"
);
}
/// <summary>Copy a PersonIdent, but alter the clone's time stamp</summary>
/// <param name="pi">
/// original
/// <see cref="PersonIdent">PersonIdent</see>
/// </param>
/// <param name="aWhen">local time stamp</param>
/// <param name="aTZ">time zone</param>
public PersonIdent(NGit.PersonIdent pi, long aWhen, int aTZ)
{
name = pi.GetName();
emailAddress = pi.GetEmailAddress();
when = aWhen;
tzOffset = aTZ;
}
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:"
));
}
internal Entry(byte[] raw, int pos)
{
oldId = ObjectId.FromString(raw, pos);
pos += Constants.OBJECT_ID_STRING_LENGTH;
if (raw[pos++] != ' ')
{
throw new ArgumentException(JGitText.Get().rawLogMessageDoesNotParseAsLogEntry);
}
newId = ObjectId.FromString(raw, pos);
pos += Constants.OBJECT_ID_STRING_LENGTH;
if (raw[pos++] != ' ')
{
throw new ArgumentException(JGitText.Get().rawLogMessageDoesNotParseAsLogEntry);
}
who = RawParseUtils.ParsePersonIdentOnly(raw, pos);
int p0 = RawParseUtils.Next(raw, pos, '\t');
if (p0 >= raw.Length)
{
comment = string.Empty;
}
else
{
// personident has no \t, no comment present
int p1 = RawParseUtils.NextLF(raw, p0);
comment = p1 > p0 ? RawParseUtils.Decode(raw, p0, p1 - 1) : string.Empty;
}
}
public override bool Equals(object o)
{
if (o is NGit.PersonIdent)
{
NGit.PersonIdent p = (NGit.PersonIdent)o;
return(GetName().Equals(p.GetName()) && GetEmailAddress().Equals(p.GetEmailAddress
()) && when / 1000L == p.when / 1000L);
}
return(false);
}
public virtual void Test002_NewIdent()
{
PersonIdent p = new PersonIdent("A U Thor", "*****@*****.**", Sharpen.Extensions.CreateDate
(1142878501000L), Sharpen.Extensions.GetTimeZone("GMT+0230"));
NUnit.Framework.Assert.AreEqual("A U Thor", p.GetName());
NUnit.Framework.Assert.AreEqual("*****@*****.**", p.GetEmailAddress());
NUnit.Framework.Assert.AreEqual(1142878501000L, p.GetWhen().GetTime());
NUnit.Framework.Assert.AreEqual("A U Thor <*****@*****.**> 1142878501 +0230",
p.ToExternalString());
}
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;
}
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);
}
}
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());
}
/// <summary>Write the given ref update to the ref's log</summary>
/// <param name="update"></param>
/// <param name="msg"></param>
/// <param name="deref"></param>
/// <returns>this writer</returns>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
public virtual NGit.Storage.File.ReflogWriter Log(RefUpdate update, string msg, bool
deref)
{
ObjectId oldId = update.GetOldObjectId();
ObjectId newId = update.GetNewObjectId();
Ref @ref = update.GetRef();
PersonIdent ident = update.GetRefLogIdent();
if (ident == null)
{
ident = new PersonIdent(parent);
}
else
{
ident = new PersonIdent(ident);
}
byte[] rec = Encode(oldId, newId, ident, msg);
if (deref && @ref.IsSymbolic())
{
Log(@ref.GetName(), rec);
Log(@ref.GetLeaf().GetName(), rec);
}
else
{
Log(@ref.GetName(), rec);
}
return this;
}
/// <summary>Set the identity of the user appearing in the reflog.</summary>
/// <remarks>
/// Set the identity of the user appearing in the reflog.
/// <p>
/// The timestamp portion of the identity is ignored. A new identity with the
/// current timestamp will be created automatically when the update occurs
/// and the log record is written.
/// </remarks>
/// <param name="pi">
/// identity of the user. If null the identity will be
/// automatically determined based on the repository
/// configuration.
/// </param>
/// <returns>
///
/// <code>this</code>
/// .
/// </returns>
public virtual NGit.BatchRefUpdate SetRefLogIdent(PersonIdent pi)
{
refLogIdent = pi;
return this;
}
private static Person ToPerson(PersonIdent ident)
{
return new Person(ident.GetName(), ident.GetEmailAddress());
}
/// <summary>Set the identity of the user appearing in the reflog.</summary>
/// <remarks>
/// Set the identity of the user appearing in the reflog.
/// <p>
/// The timestamp portion of the identity is ignored. A new identity with the
/// current timestamp will be created automatically when the update occurs
/// and the log record is written.
/// </remarks>
/// <param name="pi">
/// identity of the user. If null the identity will be
/// automatically determined based on the repository
/// configuration.
/// </param>
public virtual void SetRefLogIdent(PersonIdent pi)
{
refLogIdent = pi;
}
/// <summary>
/// Copy a
/// <see cref="PersonIdent">PersonIdent</see>
/// , but alter the clone's time stamp
/// </summary>
/// <param name="pi">
/// original
/// <see cref="PersonIdent">PersonIdent</see>
/// </param>
/// <param name="aWhen">local time</param>
public PersonIdent(NGit.PersonIdent pi, DateTime aWhen) : this(pi.GetName(), pi.GetEmailAddress
(), aWhen.GetTime(), pi.tzOffset)
{
}
/// <summary>
/// Copy a
/// <see cref="PersonIdent">PersonIdent</see>
/// .
/// </summary>
/// <param name="pi">
/// Original
/// <see cref="PersonIdent">PersonIdent</see>
/// </param>
public PersonIdent(NGit.PersonIdent pi) : this(pi.GetName(), pi.GetEmailAddress()
)
{
}
/// <summary>Set the identity of the user appearing in the reflog.</summary>
/// <remarks>
/// Set the identity of the user appearing in the reflog.
/// <p>
/// The timestamp portion of the identity is ignored. A new identity with the
/// current timestamp will be created automatically when the update occurs
/// and the log record is written.
/// </remarks>
/// <param name="pi">
/// identity of the user. If null the identity will be
/// automatically determined based on the repository
/// configuration.
/// </param>
/// <returns>
///
/// <code>this</code>
/// .
/// </returns>
public virtual NGit.BatchRefUpdate SetRefLogIdent(PersonIdent pi)
{
refLogIdent = pi;
return(this);
}
/// <exception cref="System.IO.IOException"></exception>
private void Commit(string commitMsg, PersonIdent author, PersonIdent committer)
{
NGit.CommitBuilder commit = new NGit.CommitBuilder();
commit.Author = author;
commit.Committer = committer;
commit.Message = commitMsg;
ObjectInserter inserter = db.NewObjectInserter();
ObjectId id;
try
{
commit.TreeId = inserter.Insert(new TreeFormatter());
id = inserter.Insert(commit);
inserter.Flush();
}
finally
{
inserter.Release();
}
int nl = commitMsg.IndexOf('\n');
RefUpdate ru = db.UpdateRef(Constants.HEAD);
ru.SetNewObjectId(id);
ru.SetRefLogMessage("commit : " + ((nl == -1) ? commitMsg : Sharpen.Runtime.Substring
(commitMsg, 0, nl)), false);
ru.ForceUpdate();
}
//
//
//
//
//
//
/// <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));
}
private void Commit_Button(object sender, System.Windows.RoutedEventArgs e)
{
var author = new PersonIdent("Michael", "*****@*****.**");
string message = FolderPathTextBox1.Text;
if (terminalMode)
{
//openActivePath();
autoIt.WinActivate("cmd.exe");
autoIt.Send("git commit -m \"" + activeRepoPath + "\"" + "\r");
autoIt.WinActivate("MainWindow");
}
else
{
var commit = repository.Commit()
.SetMessage(message)
.SetAuthor(author)
.SetAll(true) // This automatically stages modified and deleted files
.Call();
// Our new commit's hash
var hash = commit.Id;
//using (var repo = new Repository(activeRepoPath))
//{
// Create the committer's signature and commit
//Signature author = new Signature("Default User", "*****@*****.**", DateTime.Now);
//Signature committer = author;
// Commit to the repository
//Commit commit = repo.Commit(message, author, committer);
//}
}
Go_To_RepositoryMainGrid(sender, e);
}
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
());
}
//
//
//
/// <summary>
/// Increment the
/// <see cref="author">author</see>
/// and
/// <see cref="committer">committer</see>
/// times.
/// </summary>
protected internal virtual void Tick()
{
long delta = TimeUnit.MILLISECONDS.Convert(5 * 60, TimeUnit.SECONDS);
long now = author.GetWhen().GetTime() + delta;
author = new PersonIdent(author, now, tz);
committer = new PersonIdent(committer, now, tz);
}
/// <summary>Copy a PersonIdent, but alter the clone's time stamp</summary>
/// <param name="pi">
/// original
/// <see cref="PersonIdent">PersonIdent</see>
/// </param>
/// <param name="aWhen">local time stamp</param>
/// <param name="aTZ">time zone</param>
public PersonIdent(NGit.PersonIdent pi, long aWhen, int aTZ) : this(pi.GetName(),
pi.GetEmailAddress(), aWhen, aTZ)
{
}
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;
}
public override void Commit (ChangeSet changeSet, IProgressMonitor monitor)
{
PersonIdent author = new PersonIdent (repo);
PersonIdent committer = new PersonIdent (repo);
string message = changeSet.GlobalComment;
if (string.IsNullOrEmpty (message))
throw new ArgumentException ("Commit message must not be null or empty!", "message");
if (string.IsNullOrEmpty (author.GetName ()))
throw new ArgumentException ("Author name must not be null or empty!", "author");
RepositoryState state = repo.GetRepositoryState ();
if (!state.CanCommit ()) {
throw new WrongRepositoryStateException ("Cannot commit with repository in state: " + state);
}
try {
Ref head = repo.GetRef (Constants.HEAD);
if (head == null)
throw new InvalidOperationException ("No HEAD");
List<ObjectId> parents = new List<ObjectId>();
// determine the current HEAD and the commit it is referring to
ObjectId headId = repo.Resolve (Constants.HEAD + "^{commit}");
if (headId != null)
parents.Insert (0, headId);
ObjectInserter odi = repo.NewObjectInserter ();
try {
List<string> filePaths = GetFilesInPaths (changeSet.Items.Select (i => i.LocalPath));
ObjectId indexTreeId = CreateCommitTree (filePaths);
ObjectId commitId = GitUtil.CreateCommit (repo, message, parents, indexTreeId, author, committer);
RevWalk revWalk = new RevWalk (repo);
try {
RevCommit revCommit = revWalk.ParseCommit (commitId);
RefUpdate ru = repo.UpdateRef (Constants.HEAD);
ru.SetNewObjectId (commitId);
ru.SetRefLogMessage ("commit : " + revCommit.GetShortMessage (), false);
ru.SetExpectedOldObjectId (headId);
RefUpdate.Result rc = ru.Update ();
switch (rc) {
case RefUpdate.Result.NEW:
case RefUpdate.Result.FAST_FORWARD:
{
Unstage (filePaths);
if (state == RepositoryState.MERGING_RESOLVED) {
// Commit was successful. Now delete the files
// used for merge commits
repo.WriteMergeCommitMsg (null);
repo.WriteMergeHeads (null);
}
return;
}
case RefUpdate.Result.REJECTED:
case RefUpdate.Result.LOCK_FAILURE:
throw new ConcurrentRefUpdateException (JGitText.Get ().couldNotLockHEAD, ru.GetRef (), rc);
default:
throw new JGitInternalException ("Reference update failed");
}
} finally {
revWalk.Release ();
}
} 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 (JGitText.Get ().exceptionCaughtDuringExecutionOfCommitCommand, e);
}
}
/// <summary>Set the creator of this tag.</summary>
/// <remarks>Set the creator of this tag.</remarks>
/// <param name="taggerIdent">the creator. May be null.</param>
public virtual void SetTagger(PersonIdent taggerIdent)
{
tagger = taggerIdent;
}
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
());
}
/// <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)
{
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:
{
TimeZoneInfo 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;
}
}
}
/// <summary>Set the identity of the user appearing in the reflog.</summary>
/// <remarks>
/// Set the identity of the user appearing in the reflog.
/// <p>
/// The timestamp portion of the identity is ignored. A new identity with the
/// current timestamp will be created automatically when the rename occurs
/// and the log record is written.
/// </remarks>
/// <param name="pi">
/// identity of the user. If null the identity will be
/// automatically determined based on the repository
/// configuration.
/// </param>
public virtual void SetRefLogIdent(PersonIdent pi)
{
destination.SetRefLogIdent(pi);
}
/// <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);
}
private void AssertPersonIdent(string line, PersonIdent expected)
{
PersonIdent actual = RawParseUtils.ParsePersonIdent(line);
NUnit.Framework.Assert.AreEqual(expected, actual);
}
private byte[] Encode(ObjectId oldId, ObjectId newId, PersonIdent ident, string message
)
{
StringBuilder r = new StringBuilder();
r.Append(ObjectId.ToString(oldId));
r.Append(' ');
r.Append(ObjectId.ToString(newId));
r.Append(' ');
r.Append(ident.ToExternalString());
r.Append('\t');
r.Append(message);
r.Append('\n');
return Constants.Encode(r.ToString());
}
/// <summary>Copy a PersonIdent, but alter the clone's time stamp</summary>
/// <param name="pi">
/// original
/// <see cref="PersonIdent">PersonIdent</see>
/// </param>
/// <param name="when">local time</param>
/// <param name="tz">time zone</param>
public PersonIdent(NGit.PersonIdent pi, DateTime when, TimeZoneInfo tz) : this(pi
.GetName(), pi.GetEmailAddress(), when, tz)
{
}
private string ToString(PersonIdent author)
{
StringBuilder a = new StringBuilder();
a.Append("Author: ");
a.Append(author.GetName());
a.Append(" <");
a.Append(author.GetEmailAddress());
a.Append(">\n");
a.Append("Date: ");
a.Append(dateFormatter.FormatDate(author));
a.Append("\n");
return a.ToString();
}
public ChangeIdUtilTest()
{
when = mockSystemReader.GetCurrentTime();
tz = new MockSystemReader().GetTimezone(when);
{
author = new PersonIdent(author, when, tz);
}
{
committer = new PersonIdent(committer, when, tz);
}
}
/// <summary>Set the identity of the user appearing in the reflog.</summary>
/// <remarks>
/// Set the identity of the user appearing in the reflog.
/// <p>
/// The timestamp portion of the identity is ignored. A new identity with the
/// current timestamp will be created automatically when the rename occurs
/// and the log record is written.
/// </remarks>
/// <param name="pi">
/// identity of the user. If null the identity will be
/// automatically determined based on the repository
/// configuration.
/// </param>
public virtual void SetRefLogIdent(PersonIdent pi)
{
destination.SetRefLogIdent(pi);
}
public API_NGit()
{
Author = new PersonIdent(NGit_Consts.DEFAULT_COMMIT_NAME, NGit_Consts.DEFAULT_COMMIT_EMAIL);
Committer = new PersonIdent("FluentSharp NGit", "*****@*****.**");
}
private string Iso(PersonIdent id)
{
SimpleDateFormat fmt;
fmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
fmt.SetTimeZone(id.GetTimeZone());
return fmt.Format(id.GetWhen());
}
/// <summary>Set the identity of the user appearing in the reflog.</summary>
/// <remarks>
/// Set the identity of the user appearing in the reflog.
/// <p>
/// The timestamp portion of the identity is ignored. A new identity with the
/// current timestamp will be created automatically when the update occurs
/// and the log record is written.
/// </remarks>
/// <param name="pi">
/// identity of the user. If null the identity will be
/// automatically determined based on the repository
/// configuration.
/// </param>
public virtual void SetRefLogIdent(PersonIdent pi)
{
refLogIdent = pi;
}
public virtual void TestCommitRange()
{
// do 4 commits and set the range to the second and fourth one
Git git = new Git(db);
git.Commit().SetMessage("first commit").Call();
RevCommit second = git.Commit().SetMessage("second commit").SetCommitter(committer
).Call();
git.Commit().SetMessage("third commit").SetAuthor(author).Call();
RevCommit last = git.Commit().SetMessage("fourth commit").SetAuthor(author).SetCommitter
(committer).Call();
Iterable<RevCommit> commits = git.Log().AddRange(second.Id, last.Id).Call();
// check that we have the third and fourth commit
PersonIdent defaultCommitter = new PersonIdent(db);
PersonIdent[] expectedAuthors = new PersonIdent[] { author, author };
PersonIdent[] expectedCommitters = new PersonIdent[] { defaultCommitter, committer
};
string[] expectedMessages = new string[] { "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);
}
/// <summary>Set the creator of this tag.</summary>
/// <remarks>Set the creator of this tag.</remarks>
/// <param name="taggerIdent">the creator. May be null.</param>
public virtual void SetTagger(PersonIdent taggerIdent)
{
tagger = taggerIdent;
}