Use relativePath and gitPath in a consistent way

jcansdale · jcansdale · commit 5fe36d67889e · 2019-06-13T12:36:40.000+01:00
Use Guard.ArgumentIsRelativePath instead of Guard.ArgumentIsGitPath
Automatically convert to Git path where required.
diff --git a/src/GitHub.App/SampleData/GitServiceDesigner.cs b/src/GitHub.App/SampleData/GitServiceDesigner.cs
@@ -15,7 +15,7 @@ class GitServiceDesigner : IGitService
         public IRepository GetRepository(string path) => null;
         public UriString GetUri(string path, string remote = "origin") => null;
         public UriString GetUri(IRepository repository, string remote = "origin") => null;
-        public Task<Patch> Compare(IRepository repository, string sha1, string sha2, string path) => null;
+        public Task<Patch> Compare(IRepository repository, string sha1, string sha2, string relativePath) => null;
         public Task<ContentChanges> CompareWith(IRepository repository, string sha1, string sha2, string path, byte[] contents) => null;
         public Task<TreeChanges> Compare(IRepository repository, string sha1, string sha2, bool detectRenames = false) => null;
     }
diff --git a/src/GitHub.App/Services/GitClient.cs b/src/GitHub.App/Services/GitClient.cs
@@ -259,40 +259,42 @@ public Task<Remote> GetHttpRemote(IRepository repo, string remote)
             });
         }
 
-        public Task<string> ExtractFile(IRepository repository, string commitSha, string fileName)
+        public Task<string> ExtractFile(IRepository repository, string commitSha, string relativePath)
         {
             Guard.ArgumentNotNull(repository, nameof(repository));
             Guard.ArgumentNotEmptyString(commitSha, nameof(commitSha));
-            Guard.ArgumentIsGitPath(fileName, nameof(fileName));
+            Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));
 
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
             return Task.Run(() =>
             {
                 var commit = repository.Lookup<Commit>(commitSha);
                 if (commit == null)
                 {
-                    throw new FileNotFoundException("Couldn't find '" + fileName + "' at commit " + commitSha + ".");
+                    throw new FileNotFoundException("Couldn't find '" + gitPath + "' at commit " + commitSha + ".");
                 }
 
-                var blob = commit[fileName]?.Target as Blob;
+                var blob = commit[gitPath]?.Target as Blob;
                 return blob?.GetContentText();
             });
         }
 
-        public Task<byte[]> ExtractFileBinary(IRepository repository, string commitSha, string fileName)
+        public Task<byte[]> ExtractFileBinary(IRepository repository, string commitSha, string relativePath)
         {
             Guard.ArgumentNotNull(repository, nameof(repository));
             Guard.ArgumentNotEmptyString(commitSha, nameof(commitSha));
-            Guard.ArgumentIsGitPath(fileName, nameof(fileName));
+            Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));
 
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
             return Task.Run(() =>
             {
                 var commit = repository.Lookup<Commit>(commitSha);
                 if (commit == null)
                 {
-                    throw new FileNotFoundException("Couldn't find '" + fileName + "' at commit " + commitSha + ".");
+                    throw new FileNotFoundException("Couldn't find '" + gitPath + "' at commit " + commitSha + ".");
                 }
 
-                var blob = commit[fileName]?.Target as Blob;
+                var blob = commit[gitPath]?.Target as Blob;
 
                 if (blob != null)
                 {
@@ -308,16 +310,17 @@ public Task<byte[]> ExtractFileBinary(IRepository repository, string commitSha,
             });
         }
 
-        public Task<bool> IsModified(IRepository repository, string path, byte[] contents)
+        public Task<bool> IsModified(IRepository repository, string relativePath, byte[] contents)
         {
             Guard.ArgumentNotNull(repository, nameof(repository));
-            Guard.ArgumentIsGitPath(path, nameof(path));
+            Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));
 
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
             return Task.Run(() =>
             {
-                if (repository.RetrieveStatus(path) == FileStatus.Unaltered)
+                if (repository.RetrieveStatus(gitPath) == FileStatus.Unaltered)
                 {
-                    var treeEntry = repository.Head[path];
+                    var treeEntry = repository.Head[gitPath];
                     if (treeEntry?.TargetType != TreeEntryTargetType.Blob)
                     {
                         return false;
@@ -326,7 +329,7 @@ public Task<bool> IsModified(IRepository repository, string path, byte[] content
                     var blob1 = (Blob)treeEntry.Target;
                     using (var s = contents != null ? new MemoryStream(contents) : new MemoryStream())
                     {
-                        var blob2 = repository.ObjectDatabase.CreateBlob(s, path);
+                        var blob2 = repository.ObjectDatabase.CreateBlob(s, gitPath);
                         var diff = repository.Diff.Compare(blob1, blob2);
                         return diff.LinesAdded != 0 || diff.LinesDeleted != 0;
                     }
diff --git a/src/GitHub.App/Services/GitHubContextService.cs b/src/GitHub.App/Services/GitHubContextService.cs
@@ -404,16 +404,17 @@ public string FindObjectishForTFSTempFile(string tempFile)
         }
 
         /// <inheritdoc/>
-        public bool HasChangesInWorkingDirectory(string repositoryDir, string commitish, string path)
+        public bool HasChangesInWorkingDirectory(string repositoryDir, string commitish, string relativePath)
         {
-            Guard.ArgumentNotNull(path, nameof(repositoryDir));
-            Guard.ArgumentNotNull(path, nameof(commitish));
-            Guard.ArgumentIsGitPath(path, nameof(path));
+            Guard.ArgumentNotNull(repositoryDir, nameof(repositoryDir));
+            Guard.ArgumentNotNull(commitish, nameof(commitish));
+            Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));
 
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
             using (var repo = gitService.GetRepository(repositoryDir))
             {
                 var commit = repo.Lookup<Commit>(commitish);
-                var paths = new[] { path };
+                var paths = new[] { gitPath };
 
                 return repo.Diff.Compare<Patch>(commit.Tree, DiffTargets.WorkingDirectory, paths).Count() > 0;
             }
diff --git a/src/GitHub.App/Services/PullRequestEditorService.cs b/src/GitHub.App/Services/PullRequestEditorService.cs
@@ -573,23 +573,21 @@ void ShowErrorInStatusBar(string message, Exception e)
         void AddBufferTag(
             ITextBuffer buffer,
             IPullRequestSession session,
-            string gitPath,
+            string relativePath,
             string commitSha,
             DiffSide? side)
         {
-            Guard.ArgumentIsGitPath(gitPath, nameof(gitPath));
-
             buffer.Properties.GetOrCreateSingletonProperty(
                 typeof(PullRequestTextBufferInfo),
-                () => new PullRequestTextBufferInfo(session, gitPath, commitSha, side));
+                () => new PullRequestTextBufferInfo(session, relativePath, commitSha, side));
 
             var projection = buffer as IProjectionBuffer;
 
             if (projection != null)
             {
                 foreach (var source in projection.SourceBuffers)
                 {
-                    AddBufferTag(source, session, gitPath, commitSha, side);
+                    AddBufferTag(source, session, relativePath, commitSha, side);
                 }
             }
         }
@@ -656,9 +654,10 @@ async Task<string> GetBaseFileName(IPullRequestSession session, IPullRequestSess
                 session.LocalRepository,
                 session.PullRequest))
             {
-                var fileChange = changes.FirstOrDefault(x => x.Path == file.RelativePath);
+                var gitPath = file.RelativePath.Replace(Path.DirectorySeparatorChar, '/');
+                var fileChange = changes.FirstOrDefault(x => x.Path == gitPath);
                 return fileChange?.Status == LibGit2Sharp.ChangeKind.Renamed ?
-                    fileChange.OldPath : file.RelativePath;
+                    fileChange.OldPath.Replace('/', Path.DirectorySeparatorChar) : file.RelativePath;
             }
         }
 
diff --git a/src/GitHub.App/Services/PullRequestService.cs b/src/GitHub.App/Services/PullRequestService.cs
@@ -922,24 +922,22 @@ async Task ExtractToTempFile(
             IRepository repo,
             int pullRequestNumber,
             string commitSha,
-            string path,
+            string relativePath,
             Encoding encoding,
             string tempFilePath)
         {
-            Guard.ArgumentIsGitPath(path, nameof(path));
-
             string contents;
 
             try
             {
-                contents = await gitClient.ExtractFile(repo, commitSha, path) ?? string.Empty;
+                contents = await gitClient.ExtractFile(repo, commitSha, relativePath) ?? string.Empty;
             }
             catch (FileNotFoundException)
             {
                 var pullHeadRef = $"refs/pull/{pullRequestNumber}/head";
                 var remote = await gitClient.GetHttpRemote(repo, "origin");
                 await gitClient.Fetch(repo, remote.Name, commitSha, pullHeadRef);
-                contents = await gitClient.ExtractFile(repo, commitSha, path) ?? string.Empty;
+                contents = await gitClient.ExtractFile(repo, commitSha, relativePath) ?? string.Empty;
             }
 
             Directory.CreateDirectory(Path.GetDirectoryName(tempFilePath));
diff --git a/src/GitHub.App/ViewModels/PullRequestReviewCommentThreadViewModel.cs b/src/GitHub.App/ViewModels/PullRequestReviewCommentThreadViewModel.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
@@ -197,7 +198,7 @@ public override async Task PostComment(ICommentViewModel comment)
                     await Session.PostReviewComment(
                         comment.Body,
                         File.CommitSha,
-                        File.RelativePath.Replace("\\", "/"),
+                        File.RelativePath.Replace(Path.DirectorySeparatorChar, '/'),
                         File.Diff,
                         diffPosition.DiffLineNumber).ConfigureAwait(false);
                 }
@@ -234,8 +235,8 @@ public static (string key, string secondaryKey) GetDraftKeys(
             string relativePath,
             int lineNumber)
         {
-            relativePath = relativePath.Replace("\\", "/");
-            var key = Invariant($"pr-review-comment|{cloneUri}|{pullRequestNumber}|{relativePath}");
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
+            var key = Invariant($"pr-review-comment|{cloneUri}|{pullRequestNumber}|{gitPath}");
             return (key, lineNumber.ToString(CultureInfo.InvariantCulture));
         }
 
diff --git a/src/GitHub.Exports/Services/GitService.cs b/src/GitHub.Exports/Services/GitService.cs
@@ -234,13 +234,14 @@ public Task<Patch> Compare(
             IRepository repository,
             string sha1,
             string sha2,
-            string path)
+            string relativePath)
         {
             Guard.ArgumentNotNull(repository, nameof(repository));
             Guard.ArgumentNotEmptyString(sha1, nameof(sha1));
             Guard.ArgumentNotEmptyString(sha2, nameof(sha2));
-            Guard.ArgumentIsGitPath(path, nameof(path));
+            Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));
 
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
             return Task.Run(() =>
             {
                 var commit1 = repository.Lookup<Commit>(sha1);
@@ -251,7 +252,7 @@ public Task<Patch> Compare(
                     return repository.Diff.Compare<Patch>(
                         commit1.Tree,
                         commit2.Tree,
-                        new[] { path },
+                        new[] { gitPath },
                         defaultCompareOptions);
                 }
                 else
@@ -261,27 +262,28 @@ public Task<Patch> Compare(
             });
         }
 
-        public Task<ContentChanges> CompareWith(IRepository repository, string sha1, string sha2, string path, byte[] contents)
+        public Task<ContentChanges> CompareWith(IRepository repository, string sha1, string sha2, string relativePath, byte[] contents)
         {
             Guard.ArgumentNotNull(repository, nameof(repository));
             Guard.ArgumentNotEmptyString(sha1, nameof(sha1));
             Guard.ArgumentNotEmptyString(sha2, nameof(sha1));
-            Guard.ArgumentIsGitPath(path, nameof(path));
+            Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));
 
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
             return Task.Run(() =>
             {
                 var commit1 = repository.Lookup<Commit>(sha1);
                 var commit2 = repository.Lookup<Commit>(sha2);
 
                 var treeChanges = repository.Diff.Compare<TreeChanges>(commit1.Tree, commit2.Tree, defaultCompareOptions);
-                var change = treeChanges.FirstOrDefault(x => x.Path == path);
+                var change = treeChanges.FirstOrDefault(x => x.Path == gitPath);
                 var oldPath = change?.OldPath;
 
                 if (commit1 != null && oldPath != null)
                 {
                     var contentStream = contents != null ? new MemoryStream(contents) : new MemoryStream();
                     var blob1 = commit1[oldPath]?.Target as Blob ?? repository.ObjectDatabase.CreateBlob(new MemoryStream());
-                    var blob2 = repository.ObjectDatabase.CreateBlob(contentStream, path);
+                    var blob2 = repository.ObjectDatabase.CreateBlob(contentStream, gitPath);
                     return repository.Diff.Compare(blob1, blob2, defaultCompareOptions);
                 }
 
diff --git a/src/GitHub.Exports/Services/IGitService.cs b/src/GitHub.Exports/Services/IGitService.cs
@@ -90,13 +90,13 @@ public interface IGitService
         /// <param name="repository">The repository</param>
         /// <param name="sha1">The SHA of the first commit.</param>
         /// <param name="sha2">The SHA of the second commit.</param>
-        /// <param name="path">The relative path to the file (using '/' directory separator).</param>
+        /// <param name="path">The relative path to the file.</param>
         /// <param name="contents">The contents to compare with the file.</param>
         /// <returns>
         /// A <see cref="Patch"/> object or null if the commit could not be found in the repository.
         /// </returns>
         /// <exception cref="ArgumentException">If <paramref name="path"/> contains a '\'.</exception>
-        Task<ContentChanges> CompareWith(IRepository repository, string sha1, string sha2, string path, byte[] contents);
+        Task<ContentChanges> CompareWith(IRepository repository, string sha1, string sha2, string relativePath, byte[] contents);
 
         /// <summary>
         /// Compares two commits.
diff --git a/src/GitHub.Extensions/Guard.cs b/src/GitHub.Extensions/Guard.cs
@@ -7,15 +7,10 @@ namespace GitHub.Extensions
 {
     public static class Guard
     {
-        public static void ArgumentIsGitPath(string value, string name)
+        public static void ArgumentIsRelativePath(string value, string name)
         {
             ArgumentNotNull(value, name);
 
-            if (value.Contains('\\'))
-            {
-                throw new ArgumentException($"The value '{value}' must use '/' not '\\' as directory separator", name);
-            }
-
             if (Path.IsPathRooted(value))
             {
                 throw new ArgumentException($"The value '{value}' must not be rooted", name);
diff --git a/src/GitHub.InlineReviews/Services/DiffService.cs b/src/GitHub.InlineReviews/Services/DiffService.cs
@@ -29,9 +29,9 @@ public async Task<IReadOnlyList<DiffChunk>> Diff(
             IRepository repo,
             string baseSha,
             string headSha,
-            string path)
+            string relativePath)
         {
-            var patch = await gitService.Compare(repo, baseSha, headSha, path);
+            var patch = await gitService.Compare(repo, baseSha, headSha, relativePath);
 
             if (patch != null)
             {
diff --git a/src/GitHub.InlineReviews/Services/PullRequestSession.cs b/src/GitHub.InlineReviews/Services/PullRequestSession.cs
@@ -81,12 +81,12 @@ public async Task<IPullRequestSessionFile> GetFile(
             try
             {
                 PullRequestSessionFile file;
-                var normalizedPath = relativePath.Replace("\\", "/");
-                var key = normalizedPath + '@' + commitSha;
+                var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
+                var key = gitPath + '@' + commitSha;
 
                 if (!fileIndex.TryGetValue(key, out file))
                 {
-                    file = new PullRequestSessionFile(normalizedPath, commitSha);
+                    file = new PullRequestSessionFile(relativePath, commitSha);
                     await UpdateFile(file);
                     fileIndex.Add(key, file);
                 }
diff --git a/src/GitHub.InlineReviews/Services/PullRequestSessionService.cs b/src/GitHub.InlineReviews/Services/PullRequestSessionService.cs
@@ -95,13 +95,13 @@ public IReadOnlyList<InlineAnnotationModel> BuildAnnotations(
             PullRequestDetailModel pullRequest,
             string relativePath)
         {
-            relativePath = relativePath.Replace("\\", "/");
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
 
             return pullRequest.CheckSuites
                 ?.SelectMany(checkSuite => checkSuite.CheckRuns.Select(checkRun => new { checkSuite, checkRun }))
                 .SelectMany(arg =>
                     arg.checkRun.Annotations
-                        .Where(annotation => annotation.Path == relativePath)
+                        .Where(annotation => annotation.Path == gitPath)
                         .Select(annotation => new InlineAnnotationModel(arg.checkSuite, arg.checkRun, annotation)))
                 .OrderBy(tuple => tuple.StartLine)
                 .ToArray();
@@ -114,10 +114,10 @@ public IReadOnlyList<IInlineCommentThreadModel> BuildCommentThreads(
             IReadOnlyList<DiffChunk> diff,
             string headSha)
         {
-            relativePath = relativePath.Replace("\\", "/");
+            var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
 
             var threadsByPosition = pullRequest.Threads
-                .Where(x => x.Path == relativePath)
+                .Where(x => x.Path == gitPath)
                 .OrderBy(x => x.Id)
                 .GroupBy(x => Tuple.Create(x.OriginalCommitSha, x.OriginalPosition));
             var threads = new List<IInlineCommentThreadModel>();

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ class GitServiceDesigner : IGitService`
`15`	`15`	`public IRepository GetRepository(string path) => null;`
`16`	`16`	`public UriString GetUri(string path, string remote = "origin") => null;`
`17`	`17`	`public UriString GetUri(IRepository repository, string remote = "origin") => null;`
`18`		`- public Task<Patch> Compare(IRepository repository, string sha1, string sha2, string path) => null;`
	`18`	`+ public Task<Patch> Compare(IRepository repository, string sha1, string sha2, string relativePath) => null;`
`19`	`19`	`public Task<ContentChanges> CompareWith(IRepository repository, string sha1, string sha2, string path, byte[] contents) => null;`
`20`	`20`	`public Task<TreeChanges> Compare(IRepository repository, string sha1, string sha2, bool detectRenames = false) => null;`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -259,40 +259,42 @@ public Task<Remote> GetHttpRemote(IRepository repo, string remote)`
`259`	`259`	`});`
`260`	`260`	`}`
`261`	`261`
`262`		`- public Task<string> ExtractFile(IRepository repository, string commitSha, string fileName)`
	`262`	`+ public Task<string> ExtractFile(IRepository repository, string commitSha, string relativePath)`
`263`	`263`	`{`
`264`	`264`	`Guard.ArgumentNotNull(repository, nameof(repository));`
`265`	`265`	`Guard.ArgumentNotEmptyString(commitSha, nameof(commitSha));`
`266`		`- Guard.ArgumentIsGitPath(fileName, nameof(fileName));`
	`266`	`+ Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));`
`267`	`267`
	`268`	`+ var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');`
`268`	`269`	`return Task.Run(() =>`
`269`	`270`	`{`
`270`	`271`	`var commit = repository.Lookup<Commit>(commitSha);`
`271`	`272`	`if (commit == null)`
`272`	`273`	`{`
`273`		`- throw new FileNotFoundException("Couldn't find '" + fileName + "' at commit " + commitSha + ".");`
	`274`	`+ throw new FileNotFoundException("Couldn't find '" + gitPath + "' at commit " + commitSha + ".");`
`274`	`275`	`}`
`275`	`276`
`276`		`- var blob = commit[fileName]?.Target as Blob;`
	`277`	`+ var blob = commit[gitPath]?.Target as Blob;`
`277`	`278`	`return blob?.GetContentText();`
`278`	`279`	`});`
`279`	`280`	`}`
`280`	`281`
`281`		`- public Task<byte[]> ExtractFileBinary(IRepository repository, string commitSha, string fileName)`
	`282`	`+ public Task<byte[]> ExtractFileBinary(IRepository repository, string commitSha, string relativePath)`
`282`	`283`	`{`
`283`	`284`	`Guard.ArgumentNotNull(repository, nameof(repository));`
`284`	`285`	`Guard.ArgumentNotEmptyString(commitSha, nameof(commitSha));`
`285`		`- Guard.ArgumentIsGitPath(fileName, nameof(fileName));`
	`286`	`+ Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));`
`286`	`287`
	`288`	`+ var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');`
`287`	`289`	`return Task.Run(() =>`
`288`	`290`	`{`
`289`	`291`	`var commit = repository.Lookup<Commit>(commitSha);`
`290`	`292`	`if (commit == null)`
`291`	`293`	`{`
`292`		`- throw new FileNotFoundException("Couldn't find '" + fileName + "' at commit " + commitSha + ".");`
	`294`	`+ throw new FileNotFoundException("Couldn't find '" + gitPath + "' at commit " + commitSha + ".");`
`293`	`295`	`}`
`294`	`296`
`295`		`- var blob = commit[fileName]?.Target as Blob;`
	`297`	`+ var blob = commit[gitPath]?.Target as Blob;`
`296`	`298`
`297`	`299`	`if (blob != null)`
`298`	`300`	`{`
`@@ -308,16 +310,17 @@ public Task<byte[]> ExtractFileBinary(IRepository repository, string commitSha,`
`308`	`310`	`});`
`309`	`311`	`}`
`310`	`312`
`311`		`- public Task<bool> IsModified(IRepository repository, string path, byte[] contents)`
	`313`	`+ public Task<bool> IsModified(IRepository repository, string relativePath, byte[] contents)`
`312`	`314`	`{`
`313`	`315`	`Guard.ArgumentNotNull(repository, nameof(repository));`
`314`		`- Guard.ArgumentIsGitPath(path, nameof(path));`
	`316`	`+ Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));`
`315`	`317`
	`318`	`+ var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');`
`316`	`319`	`return Task.Run(() =>`
`317`	`320`	`{`
`318`		`- if (repository.RetrieveStatus(path) == FileStatus.Unaltered)`
	`321`	`+ if (repository.RetrieveStatus(gitPath) == FileStatus.Unaltered)`
`319`	`322`	`{`
`320`		`- var treeEntry = repository.Head[path];`
	`323`	`+ var treeEntry = repository.Head[gitPath];`
`321`	`324`	`if (treeEntry?.TargetType != TreeEntryTargetType.Blob)`
`322`	`325`	`{`
`323`	`326`	`return false;`
`@@ -326,7 +329,7 @@ public Task<bool> IsModified(IRepository repository, string path, byte[] content`
`326`	`329`	`var blob1 = (Blob)treeEntry.Target;`
`327`	`330`	`using (var s = contents != null ? new MemoryStream(contents) : new MemoryStream())`
`328`	`331`	`{`
`329`		`- var blob2 = repository.ObjectDatabase.CreateBlob(s, path);`
	`332`	`+ var blob2 = repository.ObjectDatabase.CreateBlob(s, gitPath);`
`330`	`333`	`var diff = repository.Diff.Compare(blob1, blob2);`
`331`	`334`	`return diff.LinesAdded != 0 \|\| diff.LinesDeleted != 0;`
`332`	`335`	`}`
Original file line number	Diff line number	Diff line change
`@@ -404,16 +404,17 @@ public string FindObjectishForTFSTempFile(string tempFile)`
`404`	`404`	`}`
`405`	`405`
`406`	`406`	`/// <inheritdoc/>`
`407`		`- public bool HasChangesInWorkingDirectory(string repositoryDir, string commitish, string path)`
	`407`	`+ public bool HasChangesInWorkingDirectory(string repositoryDir, string commitish, string relativePath)`
`408`	`408`	`{`
`409`		`- Guard.ArgumentNotNull(path, nameof(repositoryDir));`
`410`		`- Guard.ArgumentNotNull(path, nameof(commitish));`
`411`		`- Guard.ArgumentIsGitPath(path, nameof(path));`
	`409`	`+ Guard.ArgumentNotNull(repositoryDir, nameof(repositoryDir));`
	`410`	`+ Guard.ArgumentNotNull(commitish, nameof(commitish));`
	`411`	`+ Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath));`
`412`	`412`
	`413`	`+ var gitPath = relativePath.Replace(Path.DirectorySeparatorChar, '/');`
`413`	`414`	`using (var repo = gitService.GetRepository(repositoryDir))`
`414`	`415`	`{`
`415`	`416`	`var commit = repo.Lookup<Commit>(commitish);`
`416`		`- var paths = new[] { path };`
	`417`	`+ var paths = new[] { gitPath };`
`417`	`418`
`418`	`419`	`return repo.Diff.Compare<Patch>(commit.Tree, DiffTargets.WorkingDirectory, paths).Count() > 0;`
`419`	`420`	`}`
Original file line number	Diff line number	Diff line change
`@@ -573,23 +573,21 @@ void ShowErrorInStatusBar(string message, Exception e)`
`573`	`573`	`void AddBufferTag(`
`574`	`574`	`ITextBuffer buffer,`
`575`	`575`	`IPullRequestSession session,`
`576`		`- string gitPath,`
	`576`	`+ string relativePath,`
`577`	`577`	`string commitSha,`
`578`	`578`	`DiffSide? side)`
`579`	`579`	`{`
`580`		`- Guard.ArgumentIsGitPath(gitPath, nameof(gitPath));`
`581`		`-`
`582`	`580`	`buffer.Properties.GetOrCreateSingletonProperty(`
`583`	`581`	`typeof(PullRequestTextBufferInfo),`
`584`		`- () => new PullRequestTextBufferInfo(session, gitPath, commitSha, side));`
	`582`	`+ () => new PullRequestTextBufferInfo(session, relativePath, commitSha, side));`
`585`	`583`
`586`	`584`	`var projection = buffer as IProjectionBuffer;`
`587`	`585`
`588`	`586`	`if (projection != null)`
`589`	`587`	`{`
`590`	`588`	`foreach (var source in projection.SourceBuffers)`
`591`	`589`	`{`
`592`		`- AddBufferTag(source, session, gitPath, commitSha, side);`
	`590`	`+ AddBufferTag(source, session, relativePath, commitSha, side);`
`593`	`591`	`}`
`594`	`592`	`}`
`595`	`593`	`}`
`@@ -656,9 +654,10 @@ async Task<string> GetBaseFileName(IPullRequestSession session, IPullRequestSess`
`656`	`654`	`session.LocalRepository,`
`657`	`655`	`session.PullRequest))`
`658`	`656`	`{`
`659`		`- var fileChange = changes.FirstOrDefault(x => x.Path == file.RelativePath);`
	`657`	`+ var gitPath = file.RelativePath.Replace(Path.DirectorySeparatorChar, '/');`
	`658`	`+ var fileChange = changes.FirstOrDefault(x => x.Path == gitPath);`
`660`	`659`	`return fileChange?.Status == LibGit2Sharp.ChangeKind.Renamed ?`
`661`		`- fileChange.OldPath : file.RelativePath;`
	`660`	`+ fileChange.OldPath.Replace('/', Path.DirectorySeparatorChar) : file.RelativePath;`
`662`	`661`	`}`
`663`	`662`	`}`
`664`	`663`
Original file line number	Diff line number	Diff line change
`@@ -922,24 +922,22 @@ async Task ExtractToTempFile(`
`922`	`922`	`IRepository repo,`
`923`	`923`	`int pullRequestNumber,`
`924`	`924`	`string commitSha,`
`925`		`- string path,`
	`925`	`+ string relativePath,`
`926`	`926`	`Encoding encoding,`
`927`	`927`	`string tempFilePath)`
`928`	`928`	`{`
`929`		`- Guard.ArgumentIsGitPath(path, nameof(path));`
`930`		`-`
`931`	`929`	`string contents;`
`932`	`930`
`933`	`931`	`try`
`934`	`932`	`{`
`935`		`- contents = await gitClient.ExtractFile(repo, commitSha, path) ?? string.Empty;`
	`933`	`+ contents = await gitClient.ExtractFile(repo, commitSha, relativePath) ?? string.Empty;`
`936`	`934`	`}`
`937`	`935`	`catch (FileNotFoundException)`
`938`	`936`	`{`
`939`	`937`	`var pullHeadRef = $"refs/pull/{pullRequestNumber}/head";`
`940`	`938`	`var remote = await gitClient.GetHttpRemote(repo, "origin");`
`941`	`939`	`await gitClient.Fetch(repo, remote.Name, commitSha, pullHeadRef);`
`942`		`- contents = await gitClient.ExtractFile(repo, commitSha, path) ?? string.Empty;`
	`940`	`+ contents = await gitClient.ExtractFile(repo, commitSha, relativePath) ?? string.Empty;`
`943`	`941`	`}`
`944`	`942`
`945`	`943`	`Directory.CreateDirectory(Path.GetDirectoryName(tempFilePath));`
Original file line number	Diff line number	Diff line change
`@@ -7,15 +7,10 @@ namespace GitHub.Extensions`
`7`	`7`	`{`
`8`	`8`	`public static class Guard`
`9`	`9`	`{`
`10`		`- public static void ArgumentIsGitPath(string value, string name)`
	`10`	`+ public static void ArgumentIsRelativePath(string value, string name)`
`11`	`11`	`{`
`12`	`12`	`ArgumentNotNull(value, name);`
`13`	`13`
`14`		`- if (value.Contains('\\'))`
`15`		`- {`
`16`		`- throw new ArgumentException($"The value '{value}' must use '/' not '\\' as directory separator", name);`
`17`		`- }`
`18`		`-`
`19`	`14`	`if (Path.IsPathRooted(value))`
`20`	`15`	`{`
`21`	`16`	`throw new ArgumentException($"The value '{value}' must not be rooted", name);`
Original file line number	Diff line number	Diff line change
`@@ -29,9 +29,9 @@ public async Task<IReadOnlyList<DiffChunk>> Diff(`
`29`	`29`	`IRepository repo,`
`30`	`30`	`string baseSha,`
`31`	`31`	`string headSha,`
`32`		`- string path)`
	`32`	`+ string relativePath)`
`33`	`33`	`{`
`34`		`- var patch = await gitService.Compare(repo, baseSha, headSha, path);`
	`34`	`+ var patch = await gitService.Compare(repo, baseSha, headSha, relativePath);`
`35`	`35`
`36`	`36`	`if (patch != null)`
`37`	`37`	`{`