[fix+enhancement] Improve handling of filemode changes

* Add handling of ChangeState.TypeChanged 'T' in CompareRevisions and QueryFileHistory (it's already handled in QueryLocalChanges and QueryStagedChangesWithAmend).
* DiffResult class:
  * Change type of OldMode and NewMode from string to int, for more convenient handling.
  * Make the FileModeChange property return a (human-readable, localized) name instead of a 'magic number'.
  * NOTE: The 6 new localized strings (Text.FileMode.*) are only provided for en_US, so far.
* Diff class:
  * Refactor the ParseLine() method by delegating to 3 new methods (for parsing of diff-header, chunk-start and chunk-body).
  * Add new private bool-variable _isInChunk, to keep track of when we're parsing the 'inside' of a chunk-body.
  * Improve the parsing within ParseLine() and related methods to correctly handle TypeChanged diffs, which actually contain two full diffs in one (1st diff-header, 1st chunk, 2nd diff-header, 2nd chunk).
  * Make ParseFileModeChange() parse file-mode strings into integers (they are actually 'octal' numbers, but we can treat them as 'decimal' numbers since we only ever check for equality against known values).
  * Refactor ParseLFSChange() to make use of the chunk body indicator (first char).

Author: goran-w

src/Commands/CompareRevisions.cs

@@ -7,7 +7,7 @@ namespace SourceGit.Commands
 {
     public partial class CompareRevisions : Command
     {
-        [GeneratedRegex(@"^([MAD])\s+(.+)$")]
+        [GeneratedRegex(@"^([MADT])\s+(.+)$")]
         private static partial Regex REG_FORMAT();
         [GeneratedRegex(@"^([CR])[0-9]{0,4}\s+(.+)$")]
         private static partial Regex REG_RENAME_FORMAT();
@@ -73,6 +73,10 @@ public CompareRevisions(string repo, string start, string end, string path)
                             change.Set(Models.ChangeState.Deleted);
                             changes.Add(change);
                             break;
+                        case 'T':
+                            change.Set(Models.ChangeState.TypeChanged);
+                            changes.Add(change);
+                            break;
                     }
                 }
 

src/Commands/Diff.cs

@@ -16,9 +16,16 @@ public partial class Diff : Command
         [GeneratedRegex(@"^index\s([0-9a-f]{6,64})\.\.([0-9a-f]{6,64})(\s[1-9]{6})?")]
         private static partial Regex REG_HASH_CHANGE();
 
-        private const string PREFIX_LFS_NEW = "+version https://git-lfs.github.com/spec/";
-        private const string PREFIX_LFS_DEL = "-version https://git-lfs.github.com/spec/";
-        private const string PREFIX_LFS_MODIFY = " version https://git-lfs.github.com/spec/";
+        private const string LFS_SPECIFIER = "version https://git-lfs.github.com/spec/";
+
+        private enum Indicator
+        {
+            ChunkHeader = '@',
+            Context = ' ',
+            Old = '-',
+            New = '+',
+            Special = '\\',
+        }
 
         public Diff(string repo, Models.DiffOption opt, int numContextLines, bool ignoreWhitespace, bool ignoreCRAtEOL)
         {
@@ -81,7 +88,12 @@ public Diff(string repo, Models.DiffOption opt, int numContextLines, bool ignore
             }
             else
             {
-                ProcessInlineHighlights();
+                if (_isInChunk)
+                {
+                    ProcessInlineHighlights();
+                    _isInChunk = false;
+                }
+
                 _result.TextDiff.MaxLineNumber = Math.Max(_newLine, _oldLine);
                 _result.TextDiff.OldMode = _result.OldMode;
                 _result.TextDiff.NewMode = _result.NewMode;
@@ -95,153 +107,194 @@ public Diff(string repo, Models.DiffOption opt, int numContextLines, bool ignore
         private void ParseLine(byte[] lineBytes)
         {
             var line = Encoding.UTF8.GetString(lineBytes);
-            if (_result.TextDiff.Lines.Count == 0)
-            {
-                if (ParseFileModeChange(line))
-                    return;
+            if (line.Length == 0)
+                return;
 
-                if (line.StartsWith("Binary", StringComparison.Ordinal))
-                {
-                    _result.IsBinary = true;
-                    return;
-                }
+            if (ParseChunkStartLine(line, lineBytes))
+                return;
 
-                if (string.IsNullOrEmpty(_result.OldHash))
-                {
-                    var match = REG_HASH_CHANGE().Match(line);
-                    if (!match.Success)
-                        return;
+            if (ParseChunkBodyLine(line[0], line.Substring(1), lineBytes[1..]))
+                return;
+
+            ParseDiffHeaderLine(line);
+        }
 
-                    _result.OldHash = match.Groups[1].Value;
+        private void ParseDiffHeaderLine(string line)
+        {
+            if (line.StartsWith("diff"))
+                return;
+
+            if (ParseFileModeChange(line))
+                return;
+
+            if (line.StartsWith("index"))
+            {
+                var match = REG_HASH_CHANGE().Match(line);
+                if (match.Success)
+                {
+                    // NOTE: For a TypeChanged file we receive two full sets of diff-lines within
+                    // the same diff output, indicating a 'deleted file' followed by a 'new file' .
+                    // We then keep the oldest Old hash and the newest New hash.
+                    if (string.IsNullOrEmpty(_result.OldHash))
+                        _result.OldHash = match.Groups[1].Value;
                     _result.NewHash = match.Groups[2].Value;
                 }
-                else
+                return;
+            }
+
+            if (line.StartsWith("Binary", StringComparison.Ordinal))
+                _result.IsBinary = true;
+        }
+
+        private bool ParseChunkStartLine(System.String line, byte[] lineBytes)
+        {
+            if (line[0] == (char)Indicator.ChunkHeader)
+            {
+                if (_isInChunk)
                 {
-                    var match = REG_INDICATOR().Match(line);
-                    if (!match.Success)
-                        return;
+                    ProcessInlineHighlights();
+                    _isInChunk = false;
+                }
 
+                var match = REG_INDICATOR().Match(line);
+                if (match.Success)
+                {
                     _oldLine = int.Parse(match.Groups[1].Value);
                     _newLine = int.Parse(match.Groups[2].Value);
                     _last = new Models.TextDiffLine(Models.TextDiffLineType.Indicator, line, lineBytes, 0, 0);
                     _result.TextDiff.Lines.Add(_last);
+
+                    _isInChunk = true;
+                    return true;
                 }
             }
-            else
-            {
-                if (ParseLFSChange(line))
-                    return;
+            return false;
+        }
 
-                if (line.Length == 0)
-                {
-                    ProcessInlineHighlights();
-                    _last = new Models.TextDiffLine(Models.TextDiffLineType.Normal, "", [], _oldLine, _newLine);
-                    _result.TextDiff.Lines.Add(_last);
-                    _oldLine++;
-                    _newLine++;
-                    return;
-                }
+        private bool ParseChunkBodyLine(char ch, string line, byte[] rawContent)
+        {
+            if (_isInChunk)
+            {
+                if (ParseLFSChange(ch, line))
+                    return true;
 
-                var ch = line[0];
-                if (ch == '-')
+                if (ch == (char)Indicator.Old)
                 {
                     _result.TextDiff.DeletedLines++;
-                    _last = new Models.TextDiffLine(Models.TextDiffLineType.Deleted, line.Substring(1), lineBytes[1..], _oldLine, 0);
+                    _last = new Models.TextDiffLine(Models.TextDiffLineType.Deleted, line, rawContent, _oldLine, 0);
                     _deleted.Add(_last);
                     _oldLine++;
+                    return true;
                 }
-                else if (ch == '+')
+
+                if (ch == (char)Indicator.New)
                 {
                     _result.TextDiff.AddedLines++;
-                    _last = new Models.TextDiffLine(Models.TextDiffLineType.Added, line.Substring(1), lineBytes[1..], 0, _newLine);
+                    _last = new Models.TextDiffLine(Models.TextDiffLineType.Added, line, rawContent, 0, _newLine);
                     _added.Add(_last);
                     _newLine++;
+                    return true;
                 }
-                else if (ch != '\\')
+
+                if (ch == (char)Indicator.Context)
                 {
                     ProcessInlineHighlights();
-                    var match = REG_INDICATOR().Match(line);
-                    if (match.Success)
-                    {
-                        _oldLine = int.Parse(match.Groups[1].Value);
-                        _newLine = int.Parse(match.Groups[2].Value);
-                        _last = new Models.TextDiffLine(Models.TextDiffLineType.Indicator, line, lineBytes, 0, 0);
-                        _result.TextDiff.Lines.Add(_last);
-                    }
-                    else
-                    {
-                        _last = new Models.TextDiffLine(Models.TextDiffLineType.Normal, line.Substring(1), lineBytes[1..], _oldLine, _newLine);
-                        _result.TextDiff.Lines.Add(_last);
-                        _oldLine++;
-                        _newLine++;
-                    }
+
+                    _last = new Models.TextDiffLine(Models.TextDiffLineType.Normal, line, rawContent, _oldLine, _newLine);
+                    _result.TextDiff.Lines.Add(_last);
+                    _oldLine++;
+                    _newLine++;
+                    return true;
                 }
-                else if (line.Equals("\\ No newline at end of file", StringComparison.Ordinal))
+
+                if (ch == (char)Indicator.Special)
                 {
-                    _last.NoNewLineEndOfFile = true;
+                    if (line.Equals(" No newline at end of file", StringComparison.Ordinal))
+                        _last.NoNewLineEndOfFile = true;
+                    return true;
                 }
             }
+
+            ProcessInlineHighlights();
+            _isInChunk = false;
+            return false;
+        }
+
+        private int ParseFileModeNumber(string fileModeStr)
+        {
+            int fileMode = 0;
+            Int32.TryParse(fileModeStr, out fileMode);
+            return fileMode;
         }
 
         private bool ParseFileModeChange(string line)
         {
             if (line.StartsWith("old mode ", StringComparison.Ordinal))
             {
-                _result.OldMode = line.Substring(9);
+                _result.OldMode = ParseFileModeNumber(line.Substring(9));
                 return true;
             }
 
             if (line.StartsWith("new mode ", StringComparison.Ordinal))
             {
-                _result.NewMode = line.Substring(9);
+                _result.NewMode = ParseFileModeNumber(line.Substring(9));
                 return true;
             }
 
             if (line.StartsWith("deleted file mode ", StringComparison.Ordinal))
             {
-                _result.OldMode = line.Substring(18);
+                _result.OldMode = ParseFileModeNumber(line.Substring(18));
                 return true;
             }
 
             if (line.StartsWith("new file mode ", StringComparison.Ordinal))
             {
-                _result.NewMode = line.Substring(14);
+                _result.NewMode = ParseFileModeNumber(line.Substring(14));
                 return true;
             }
 
             return false;
         }
 
-        private bool ParseLFSChange(string line)
+        private bool ParseLFSChange(char ch, string line)
         {
             if (_result.IsLFS)
             {
-                if (line.StartsWith("-oid sha256:", StringComparison.Ordinal))
-                    _result.LFSDiff.Old.Oid = line.Substring(12);
-                else if (line.StartsWith("-size ", StringComparison.Ordinal))
-                    _result.LFSDiff.Old.Size = long.Parse(line.AsSpan(6));
-                else if (line.StartsWith("+oid sha256:", StringComparison.Ordinal))
-                    _result.LFSDiff.New.Oid = line.Substring(12);
-                else if (line.StartsWith("+size ", StringComparison.Ordinal))
-                    _result.LFSDiff.New.Size = long.Parse(line.AsSpan(6));
-                else if (line.StartsWith(" size ", StringComparison.Ordinal))
-                    _result.LFSDiff.New.Size = _result.LFSDiff.Old.Size = long.Parse(line.AsSpan(6));
-
+                if (ch == (char)Indicator.Old)
+                {
+                    if (line.StartsWith("oid sha256:", StringComparison.Ordinal))
+                        _result.LFSDiff.Old.Oid = line.Substring(11);
+                    else if (line.StartsWith("size ", StringComparison.Ordinal))
+                        _result.LFSDiff.Old.Size = long.Parse(line.AsSpan(5));
+                }
+                else if (ch == (char)Indicator.New)
+                {
+                    if (line.StartsWith("oid sha256:", StringComparison.Ordinal))
+                        _result.LFSDiff.New.Oid = line.Substring(11);
+                    else if (line.StartsWith("size ", StringComparison.Ordinal))
+                        _result.LFSDiff.New.Size = long.Parse(line.AsSpan(5));
+                }
+                else if (ch == (char)Indicator.Context)
+                {
+                    if (line.StartsWith("size ", StringComparison.Ordinal))
+                        _result.LFSDiff.New.Size = _result.LFSDiff.Old.Size = long.Parse(line.AsSpan(5));
+                }
                 return true;
             }
 
             if (_result.TextDiff.Lines.Count != 1)
                 return false;
 
-            var isLFS = (_oldLine == 1 && _newLine == 1 && line.StartsWith(PREFIX_LFS_MODIFY, StringComparison.Ordinal)) ||
-                (_oldLine == 1 && _newLine == 0 && line.StartsWith(PREFIX_LFS_DEL, StringComparison.Ordinal)) ||
-                (_oldLine == 0 && _newLine == 1 && line.StartsWith(PREFIX_LFS_NEW, StringComparison.Ordinal));
-
-            if (isLFS)
+            if ((_oldLine == 1 && _newLine == 1 && ch == (char)Indicator.Context) ||
+                (_oldLine == 1 && _newLine == 0 && ch == (char)Indicator.Old) ||
+                (_oldLine == 0 && _newLine == 1 && ch == (char)Indicator.New))
             {
-                _result.IsLFS = true;
-                _result.LFSDiff = new Models.LFSDiff();
-                return true;
+                if (line.StartsWith(LFS_SPECIFIER, StringComparison.Ordinal))
+                {
+                    _result.IsLFS = true;
+                    _result.LFSDiff = new Models.LFSDiff();
+                    return true;
+                }
             }
 
             return false;
@@ -293,5 +346,6 @@ private void ProcessInlineHighlights()
         private Models.TextDiffLine _last = null;
         private int _oldLine = 0;
         private int _newLine = 0;
+        private bool _isInChunk = false;
     }
 }

src/Commands/QueryFileHistory.cs

@@ -8,7 +8,7 @@ namespace SourceGit.Commands
 {
     public partial class QueryFileHistory : Command
     {
-        [GeneratedRegex(@"^([MAD])\s+(.+)$")]
+        [GeneratedRegex(@"^([MADT])\s+(.+)$")]
         private static partial Regex REG_FORMAT();
         [GeneratedRegex(@"^([CR])[0-9]{0,4}\s+(.+)$")]
         private static partial Regex REG_RENAME_FORMAT();
@@ -86,6 +86,9 @@ public QueryFileHistory(string repo, string path, string head)
                         case 'D':
                             last.Change.Set(Models.ChangeState.Deleted);
                             break;
+                        case 'T':
+                            last.Change.Set(Models.ChangeState.TypeChanged);
+                            break;
                     }
                 }
             }