private void ReturnRemote()
{
var modes = currentModes.Select(s => s.ToLowerInvariant()).ToArray();
var isFetch = modes.Contains("fetch");
var isPush = modes.Contains("push");
GitRemoteFunction remoteFunction;
if (isFetch && isPush)
{
remoteFunction = GitRemoteFunction.Both;
}
else if (isFetch)
{
remoteFunction = GitRemoteFunction.Fetch;
}
else if (isPush)
{
remoteFunction = GitRemoteFunction.Push;
}
else
{
remoteFunction = GitRemoteFunction.Unknown;
}
string host;
string user = null;
var proc = new LineParser(currentUrl);
if (proc.Matches("http") || proc.Matches("https"))
{
proc.MoveToAfter(':');
proc.MoveNext();
proc.MoveNext();
host = proc.ReadUntil('/');
}
else
{
//Assuming SSH here
user = proc.ReadUntil('@');
proc.MoveNext();
host = proc.ReadUntil(':');
currentUrl = currentUrl.Substring(user.Length + 1);
}
RaiseOnEntry(new GitRemote
{
Name = currentName,
Host = host,
Url = currentUrl,
User = user,
Function = remoteFunction
});
Reset();
}
public override void LineReceived(string line)
{
if (line == null)
{
return;
}
var proc = new LineParser(line);
if (proc.IsAtEnd)
{
return;
}
try
{
string name;
string trackingName = null;
if (proc.Matches('*'))
{
proc.MoveNext();
}
proc.SkipWhitespace();
if (proc.Matches("(HEAD "))
{
name = "detached";
proc.MoveToAfter(')');
}
else
{
name = proc.ReadUntilWhitespace();
}
proc.ReadUntilWhitespaceTrim();
if (proc.Matches(trackingBranchRegex))
{
trackingName = proc.ReadChunk('[', ']');
var indexOf = trackingName.IndexOf(':');
if (indexOf != -1)
{
trackingName = trackingName.Substring(0, indexOf);
}
}
var branch = new GitBranch(name, trackingName);
RaiseOnEntry(branch);
}
catch (Exception ex)
{
Logger.Warning(ex, "Unexpected input when listing branches");
}
}
public override void LineReceived(string line)
{
if (line == null)
{
return;
}
int kb;
var proc = new LineParser(line);
if (int.TryParse(proc.ReadUntilWhitespace(), out kb))
{
RaiseOnEntry(kb);
}
}
public override void LineReceived(string line)
{
if (line == null)
{
return;
}
var proc = new LineParser(line);
if (proc.IsAtEnd)
{
return;
}
try
{
proc.Matches('*');
proc.SkipWhitespace();
var detached = proc.Matches("(HEAD ");
var name = "detached";
if (detached)
{
proc.MoveToAfter(')');
}
else
{
name = proc.ReadUntilWhitespace();
}
proc.SkipWhitespace();
proc.ReadUntilWhitespace();
var tracking = proc.Matches(trackingBranchRegex);
var trackingName = "";
if (tracking)
{
trackingName = proc.ReadChunk('[', ']');
}
var branch = new GitBranch(name, trackingName);
RaiseOnEntry(branch);
}
catch (Exception ex)
{
Logger.Warning(ex, "Unexpected input when listing branches");
}
}
public override void LineReceived(string line)
{
if (line == null)
{
return;
}
var proc = new LineParser(line);
if (proc.IsAtEnd)
{
return;
}
var active = proc.Matches('*');
proc.SkipWhitespace();
var detached = proc.Matches("(HEAD ");
var name = "detached";
if (detached)
{
proc.MoveToAfter(')');
}
else
{
name = proc.ReadUntilWhitespace();
}
proc.SkipWhitespace();
proc.ReadUntilWhitespace();
var tracking = proc.Matches(trackingBranchRegex);
var trackingName = "";
if (tracking)
{
trackingName = proc.ReadChunk('[', ']');
}
var branch = new GitBranch(name, trackingName, active);
RaiseOnEntry(branch);
}
public override void LineReceived(string line)
{
//origin https://github.com/github/VisualStudio.git (fetch)
if (line == null)
{
ReturnRemote();
return;
}
var proc = new LineParser(line);
var name = proc.ReadUntilWhitespace();
proc.SkipWhitespace();
var url = proc.ReadUntilWhitespace();
proc.SkipWhitespace();
proc.MoveNext();
var mode = proc.ReadUntil(')');
if (currentName == null)
{
currentName = name;
currentUrl = url;
currentModes.Add(mode);
}
else if (currentName == name)
{
currentModes.Add(mode);
}
else
{
ReturnRemote();
currentName = name;
currentUrl = url;
currentModes.Add(mode);
}
}
public override void LineReceived(string line)
{
if (string.IsNullOrEmpty(line))
{
//Do Nothing
return;
}
var proc = new LineParser(line);
if (proc.Matches(locksSummaryLineRegex))
{
return;
}
Logger.Debug(line);
var path = proc.ReadUntil('\t').Trim();
var user = proc.ReadUntilLast("ID:").Trim();
proc.MoveToAfter("ID:");
var id = int.Parse(proc.ReadToEnd().Trim());
RaiseOnEntry(gitObjectFactory.CreateGitLock(path, user, id));
}
public override void LineReceived(string line)
{
if (line == null)
{
ReturnStatus();
}
else
{
Prepare();
var proc = new LineParser(line);
if (gitStatus.LocalBranch == null)
{
if (proc.Matches("##"))
{
proc.MoveToAfter('#');
proc.SkipWhitespace();
string branchesString;
if (proc.Matches(branchTrackedAndDelta))
{
//master...origin/master [ahead 1]
//master...origin/master [behind 1]
//master...origin/master [ahead 1, behind 1]
branchesString = proc.ReadUntilWhitespace();
proc.MoveToAfter('[');
var deltaString = proc.ReadUntil(']');
var deltas = deltaString.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries);
foreach (var delta in deltas)
{
var deltaComponents = delta.Split(' ');
if (deltaComponents[0] == "ahead")
{
gitStatus.Ahead = Int32.Parse(deltaComponents[1]);
}
else if (deltaComponents[0] == "behind")
{
gitStatus.Behind = Int32.Parse(deltaComponents[1]);
}
else if (deltaComponents[0] == "gone")
{
}
else
{
throw new InvalidOperationException("Unexpected deltaComponent in o");
}
}
}
else
{
branchesString = proc.ReadToEnd();
}
var branches = branchesString.Split(new[] { "..." }, StringSplitOptions.RemoveEmptyEntries);
gitStatus.LocalBranch = branches[0];
if (branches.Length == 2)
{
gitStatus.RemoteBranch = branches[1];
}
}
else
{
HandleUnexpected(line);
}
}
else
{
// M GitHubVS.sln
//R README.md -> README2.md
// D deploy.cmd
//A something added.txt
//?? something.txt
string originalPath = null;
string path = null;
var status = GitFileStatus.Added;
var staged = false;
if (proc.Matches('?'))
{
//?? something.txt
proc.MoveToAfter('?');
proc.SkipWhitespace();
path = proc.ReadToEnd().Trim('"');
status = GitFileStatus.Untracked;
}
else if (proc.Matches('!'))
{
//?? something.txt
proc.MoveToAfter('!');
proc.SkipWhitespace();
path = proc.ReadToEnd().Trim('"');
status = GitFileStatus.Ignored;
}
else
{
if (proc.IsAtWhitespace)
{
proc.SkipWhitespace();
}
else
{
staged = true;
}
if (proc.Matches('M'))
{
//M GitHubVS.sln
proc.MoveNext();
proc.SkipWhitespace();
path = proc.ReadToEnd().Trim('"');
status = GitFileStatus.Modified;
}
else if (proc.Matches('D'))
{
//D deploy.cmd
proc.MoveNext();
proc.SkipWhitespace();
path = proc.ReadToEnd().Trim('"');
status = GitFileStatus.Deleted;
}
else if (proc.Matches('R'))
{
//R README.md -> README2.md
proc.MoveNext();
proc.SkipWhitespace();
var files =
proc.ReadToEnd()
.Split(new[] { "->" }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim())
.Select(s => s.Trim('"'))
.ToArray();
originalPath = files[0];
path = files[1];
status = GitFileStatus.Renamed;
}
else if (proc.Matches('A'))
{
//A something added.txt
proc.MoveNext();
proc.SkipWhitespace();
path = proc.ReadToEnd().Trim('"');
status = GitFileStatus.Added;
}
else
{
HandleUnexpected(line);
}
}
var gitStatusEntry = gitObjectFactory.CreateGitStatusEntry(path, status, originalPath, staged);
gitStatus.Entries.Add(gitStatusEntry);
}
}
}
public override void LineReceived(string line)
{
if (line == null)
{
ReturnGitLogEntry();
return;
}
sb.AppendLine(line);
if (phase == ProcessingPhase.Files && seenBodyEnd)
{
seenBodyEnd = false;
var proc = new LineParser(line);
if (proc.Matches(hashRegex))
{
// there's no files on this commit, it's a new one!
ReturnGitLogEntry();
}
}
switch (phase)
{
case ProcessingPhase.CommitHash:
commitId = line;
phase++;
break;
case ProcessingPhase.ParentHash:
var parentHashes = line.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
if (parentHashes.Length > 1)
{
mergeA = parentHashes[0];
mergeB = parentHashes[1];
}
phase++;
break;
case ProcessingPhase.AuthorName:
authorName = line;
phase++;
break;
case ProcessingPhase.AuthorEmail:
authorEmail = line;
phase++;
break;
case ProcessingPhase.AuthorDate:
DateTimeOffset t;
if (DateTimeOffset.TryParse(line, out t))
{
time = t;
}
else
{
Logger.Error("ERROR {0}", sb.ToString());
throw new FormatException("Invalid line");
}
phase++;
break;
case ProcessingPhase.CommitterName:
committerName = line;
phase++;
break;
case ProcessingPhase.CommitterEmail:
committerEmail = line;
phase++;
break;
case ProcessingPhase.CommitterDate:
committerTime = DateTimeOffset.Parse(line);
phase++;
break;
case ProcessingPhase.Summary:
{
var idx = line.IndexOf("---GHUBODYEND---", StringComparison.InvariantCulture);
var oneliner = idx >= 0;
if (oneliner)
{
line = line.Substring(0, idx);
}
summary = line;
descriptionLines.Add(line);
phase++;
// there's no description so skip it
if (oneliner)
{
phase++;
seenBodyEnd = true;
}
}
break;
case ProcessingPhase.Description:
var indexOf = line.IndexOf("---GHUBODYEND---", StringComparison.InvariantCulture);
if (indexOf == -1)
{
descriptionLines.Add(line);
}
else if (indexOf == 0)
{
phase++;
seenBodyEnd = true;
}
else
{
var substring = line.Substring(0, indexOf);
descriptionLines.Add(substring);
phase++;
seenBodyEnd = true;
}
break;
case ProcessingPhase.Files:
if (line == string.Empty)
{
ReturnGitLogEntry();
return;
}
if (line.IndexOf("---GHUBODYEND---", StringComparison.InvariantCulture) >= 0)
{
seenBodyEnd = true;
return;
}
var proc = new LineParser(line);
string file = null;
GitFileStatus status;
string originalPath = null;
if (proc.Matches('M'))
{
status = GitFileStatus.Modified;
}
else if (proc.Matches('A'))
{
status = GitFileStatus.Added;
}
else if (proc.Matches('D'))
{
status = GitFileStatus.Deleted;
}
else if (proc.Matches('R'))
{
status = GitFileStatus.Renamed;
}
else if (proc.Matches('C'))
{
status = GitFileStatus.Copied;
}
else if (proc.Matches('T'))
{
status = GitFileStatus.TypeChange;
}
else if (proc.Matches('U'))
{
status = GitFileStatus.Unmerged;
}
else if (proc.Matches('X'))
{
status = GitFileStatus.Unknown;
}
else if (proc.Matches('B'))
{
status = GitFileStatus.Broken;
}
else if (String.IsNullOrEmpty(line))
{
// there's no files on this commit, it's a new one!
ReturnGitLogEntry();
return;
}
else
{
HandleUnexpected(line);
return;
}
switch (status)
{
case GitFileStatus.Modified:
case GitFileStatus.Added:
case GitFileStatus.Deleted:
proc.SkipWhitespace();
file = proc.Matches('"')
? proc.ReadUntil('"')
: proc.ReadToEnd();
break;
case GitFileStatus.Renamed:
proc.SkipWhitespace();
originalPath =
proc.Matches('"')
? proc.ReadUntil('"')
: proc.ReadUntilWhitespace();
proc.SkipWhitespace();
file = proc.Matches('"')
? proc.ReadUntil('"')
: proc.ReadToEnd();
break;
default:
proc.SkipWhitespace();
file = proc.Matches('"')
? proc.ReadUntil('"')
: proc.ReadUntilWhitespace();
if (file == null)
{
file = proc.ReadToEnd();
}
break;
}
changes.Add(gitObjectFactory.CreateGitStatusEntry(file, status, originalPath));
break;
default:
HandleUnexpected(line);
break;
}
}
public override void LineReceived(string line)
{
if (line == null)
{
ReturnStatus();
}
else
{
Prepare();
var proc = new LineParser(line);
if (gitStatus.LocalBranch == null)
{
if (proc.Matches("##"))
{
proc.MoveToAfter('#');
proc.SkipWhitespace();
string branchesString;
if (proc.Matches(branchTrackedAndDelta))
{
//master...origin/master [ahead 1]
//master...origin/master [behind 1]
//master...origin/master [ahead 1, behind 1]
branchesString = proc.ReadUntilWhitespace();
proc.MoveToAfter('[');
var deltaString = proc.ReadUntil(']');
var deltas = deltaString.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries);
foreach (var delta in deltas)
{
var deltaComponents = delta.Split(' ');
if (deltaComponents[0] == "ahead")
{
gitStatus.Ahead = Int32.Parse(deltaComponents[1]);
}
else if (deltaComponents[0] == "behind")
{
gitStatus.Behind = Int32.Parse(deltaComponents[1]);
}
else if (deltaComponents[0] == "gone")
{
}
else
{
throw new InvalidOperationException("Unexpected deltaComponent in o");
}
}
}
else
{
branchesString = proc.ReadToEnd();
}
var branches = branchesString.Split(new[] { "..." }, StringSplitOptions.RemoveEmptyEntries);
gitStatus.LocalBranch = branches[0];
if (branches.Length == 2)
{
gitStatus.RemoteBranch = branches[1];
}
}
else
{
HandleUnexpected(line);
}
}
else
{
var gitStatusMarker = proc.Read(2);
if (gitStatusMarker == null)
{
HandleUnexpected(line);
return;
}
/*
* X Y Meaning
* -------------------------------------------------
* [AMD] not updated
* M [ MD] updated in index
* A [ MD] added to index
* D deleted from index
* R [ MD] renamed in index
* C [ MD] copied in index
* [MARC] index and work tree matches
* [ MARC] M work tree changed since index
* [ MARC] D deleted in work tree
* [ D] R renamed in work tree
* [ D] C copied in work tree
* -------------------------------------------------
* D D unmerged, both deleted
* A A unmerged, both added
* A U unmerged, added by us
* D U unmerged, deleted by us
* U A unmerged, added by them
* U D unmerged, deleted by them
* U U unmerged, both modified
* -------------------------------------------------
* ? ? untracked
* ! ! ignored
* -------------------------------------------------
*/
string originalPath = null;
string path = null;
var indexStatusMarker = gitStatusMarker[0];
var workTreeStatusMarker = gitStatusMarker[1];
GitFileStatus indexStatus = GitStatusEntry.ParseStatusMarker(indexStatusMarker);
GitFileStatus workTreeStatus = GitStatusEntry.ParseStatusMarker(workTreeStatusMarker);
GitFileStatus status = workTreeStatus != GitFileStatus.None ? workTreeStatus : indexStatus;
if (status == GitFileStatus.None)
{
HandleUnexpected(line);
return;
}
if (status == GitFileStatus.Copied || status == GitFileStatus.Renamed)
{
var files =
proc.ReadToEnd()
.Split(new[] { "->" }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim())
.Select(s => s.Trim('"'))
.ToArray();
originalPath = files[0];
path = files[1];
}
else
{
path = proc.ReadToEnd().Trim().Trim('"');
}
var gitStatusEntry = gitObjectFactory.CreateGitStatusEntry(path, indexStatus, workTreeStatus, originalPath);
gitStatus.Entries.Add(gitStatusEntry);
}
}
}
