Merge pull request #130 from sharwell/handle-cps-projects

Detect CPS opening project files from temporary locations

Author: sharwell

GitDiffMargin/Core/DiffUpdateBackgroundParser.cs

@@ -16,8 +16,9 @@ public class DiffUpdateBackgroundParser : BackgroundParser
         private readonly IGitCommands _commands;
         private readonly ITextDocument _textDocument;
         private readonly ITextBuffer _documentBuffer;
+        private readonly string _originalPath;
 
-        internal DiffUpdateBackgroundParser(ITextBuffer textBuffer, ITextBuffer documentBuffer, TaskScheduler taskScheduler, ITextDocumentFactoryService textDocumentFactoryService, IGitCommands commands)
+        internal DiffUpdateBackgroundParser(ITextBuffer textBuffer, ITextBuffer documentBuffer, string originalPath, TaskScheduler taskScheduler, ITextDocumentFactoryService textDocumentFactoryService, IGitCommands commands)
             : base(textBuffer, taskScheduler, textDocumentFactoryService)
         {
             _documentBuffer = documentBuffer;
@@ -26,11 +27,12 @@ internal DiffUpdateBackgroundParser(ITextBuffer textBuffer, ITextBuffer document
 
             if (TextDocumentFactoryService.TryGetTextDocument(_documentBuffer, out _textDocument))
             {
-                if (_commands.IsGitRepository(_textDocument.FilePath))
+                _originalPath = originalPath;
+                if (_commands.IsGitRepository(_textDocument.FilePath, _originalPath))
                 {
                     _textDocument.FileActionOccurred += OnFileActionOccurred;
 
-                    var repositoryDirectory = _commands.GetGitRepository(_textDocument.FilePath);
+                    var repositoryDirectory = _commands.GetGitRepository(_textDocument.FilePath, _originalPath);
                     if (repositoryDirectory != null)
                     {
                         _watcher = new FileSystemWatcher(repositoryDirectory);
@@ -100,7 +102,7 @@ protected override void ReParseImpl()
                 ITextDocument textDocument;
                 if (!TextDocumentFactoryService.TryGetTextDocument(_documentBuffer, out textDocument)) return;
 
-                var diff = _commands.GetGitDiffFor(textDocument, snapshot);
+                var diff = _commands.GetGitDiffFor(textDocument, _originalPath, snapshot);
                 var result = new DiffParseResultEventArgs(snapshot, stopwatch.Elapsed, diff.ToList());
                 OnParseComplete(result);
             }

GitDiffMargin/Core/IMarginCore.cs

@@ -14,6 +14,7 @@ internal interface IMarginCore
         event EventHandler<HunksChangedEventArgs> HunksChanged;
 
         IWpfTextView TextView { get; }
+        string OriginalPath { get; }
         IGitCommands GitCommands { get; }
         FontFamily FontFamily { get; }
         FontStretch FontStretch { get; }

GitDiffMargin/Core/MarginCore.cs

@@ -27,7 +27,7 @@ internal sealed class MarginCore : IMarginCore, IDisposable
 
         private bool _isDisposed;
 
-        public MarginCore(IWpfTextView textView, ITextDocumentFactoryService textDocumentFactoryService, IClassificationFormatMapService classificationFormatMapService, IEditorFormatMapService editorFormatMapService, IGitCommands gitCommands)
+        public MarginCore(IWpfTextView textView, string originalPath, ITextDocumentFactoryService textDocumentFactoryService, IClassificationFormatMapService classificationFormatMapService, IEditorFormatMapService editorFormatMapService, IGitCommands gitCommands)
         {
             _textView = textView;
 
@@ -38,7 +38,7 @@ public MarginCore(IWpfTextView textView, ITextDocumentFactoryService textDocumen
 
             _gitCommands = gitCommands;
 
-            _parser = new DiffUpdateBackgroundParser(textView.TextBuffer, textView.TextDataModel.DocumentBuffer, TaskScheduler.Default, textDocumentFactoryService, GitCommands);
+            _parser = new DiffUpdateBackgroundParser(textView.TextBuffer, textView.TextDataModel.DocumentBuffer, originalPath, TaskScheduler.Default, textDocumentFactoryService, GitCommands);
             _parser.ParseComplete += HandleParseComplete;
             _parser.RequestParse(false);
 
@@ -59,6 +59,11 @@ public IWpfTextView TextView
             }
         }
 
+        public string OriginalPath
+        {
+            get;
+        }
+
         public IGitCommands GitCommands
         {
             get

GitDiffMargin/DiffMarginFactoryBase.cs

@@ -48,12 +48,15 @@ protected IMarginCore TryGetMarginCore(IWpfTextViewHost textViewHost)
             if (fullPath == null)
                 return null;
 
-            var repositoryPath = GitCommands.GetGitRepository(fullPath);
+            if (!GitCommands.TryGetOriginalPath(fullPath, out string originalPath))
+                return null;
+
+            var repositoryPath = GitCommands.GetGitRepository(fullPath, originalPath);
             if (repositoryPath == null)
                 return null;
 
             return textViewHost.TextView.Properties.GetOrCreateSingletonProperty(
-                        () => new MarginCore(textViewHost.TextView, TextDocumentFactoryService, ClassificationFormatMapService, EditorFormatMapService, GitCommands));
+                        () => new MarginCore(textViewHost.TextView, originalPath, TextDocumentFactoryService, ClassificationFormatMapService, EditorFormatMapService, GitCommands));
         }
 
         private static string GetFullPath(string filename)

GitDiffMargin/Git/GitCommands.cs

@@ -5,11 +5,18 @@
 using System.Linq;
 using System.Text;
 using LibGit2Sharp;
+using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Text;
 using __VSDIFFSERVICEOPTIONS = Microsoft.VisualStudio.Shell.Interop.__VSDIFFSERVICEOPTIONS;
+using __VSENUMPROJFLAGS = Microsoft.VisualStudio.Shell.Interop.__VSENUMPROJFLAGS;
+using IEnumHierarchies = Microsoft.VisualStudio.Shell.Interop.IEnumHierarchies;
 using IVsDifferenceService = Microsoft.VisualStudio.Shell.Interop.IVsDifferenceService;
+using IVsHierarchy = Microsoft.VisualStudio.Shell.Interop.IVsHierarchy;
+using IVsProject = Microsoft.VisualStudio.Shell.Interop.IVsProject;
+using IVsSolution = Microsoft.VisualStudio.Shell.Interop.IVsSolution;
 using SVsDifferenceService = Microsoft.VisualStudio.Shell.Interop.SVsDifferenceService;
+using SVsSolution = Microsoft.VisualStudio.Shell.Interop.SVsSolution;
 
 namespace GitDiffMargin.Git
 {
@@ -26,10 +33,10 @@ public GitCommands(SVsServiceProvider serviceProvider)
 
         private const int ContextLines = 0;
 
-        public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITextSnapshot snapshot)
+        public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, string originalPath, ITextSnapshot snapshot)
         {
             var filename = textDocument.FilePath;
-            var repositoryPath = GetGitRepository(Path.GetFullPath(filename));
+            var repositoryPath = GetGitRepository(Path.GetFullPath(filename), ref originalPath);
             if (repositoryPath == null)
                 yield break;
 
@@ -39,7 +46,7 @@ public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITex
                 if (workingDirectory == null)
                     yield break;
 
-                var retrieveStatus = repo.RetrieveStatus(filename);
+                var retrieveStatus = repo.RetrieveStatus(originalPath);
                 if (retrieveStatus == FileStatus.Nonexistent)
                 {
                     // this occurs if a file within the repository itself (not the working copy) is opened.
@@ -52,9 +59,13 @@ public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITex
                     yield break;
                 }
 
-                if (retrieveStatus == FileStatus.Unaltered && !textDocument.IsDirty)
+                if (retrieveStatus == FileStatus.Unaltered
+                    && !textDocument.IsDirty
+                    && Path.GetFullPath(filename) == originalPath)
                 {
-                    // truly unaltered
+                    // Truly unaltered. The `IsDirty` check isn't valid for cases where the textDocument is a view of a
+                    // temporary copy of the file, since the temporary copy could have been made using unsaved changes
+                    // and still appear "not dirty".
                     yield break;
                 }
 
@@ -63,7 +74,7 @@ public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITex
 
                 using (var currentContent = new MemoryStream(content))
                 {
-                    var relativeFilepath = filename;
+                    var relativeFilepath = originalPath;
                     if (relativeFilepath.StartsWith(workingDirectory, StringComparison.OrdinalIgnoreCase))
                         relativeFilepath = relativeFilepath.Substring(workingDirectory.Length);
 
@@ -139,20 +150,19 @@ private static byte[] GetCompleteContent(ITextDocument textDocument, ITextSnapsh
             return completeContent;
         }
 
-        public void StartExternalDiff(ITextDocument textDocument)
+        public void StartExternalDiff(ITextDocument textDocument, string originalPath)
         {
             if (textDocument == null || string.IsNullOrEmpty(textDocument.FilePath)) return;
 
             var filename = textDocument.FilePath;
-
-            var repositoryPath = GetGitRepository(Path.GetFullPath(filename));
+            var repositoryPath = GetGitRepository(Path.GetFullPath(filename), ref originalPath);
             if (repositoryPath == null)
                 return;
 
             using (var repo = new Repository(repositoryPath))
             {
                 string workingDirectory = repo.Info.WorkingDirectory;
-                string relativePath = Path.GetFullPath(filename);
+                string relativePath = originalPath;
                 if (relativePath.StartsWith(workingDirectory, StringComparison.OrdinalIgnoreCase))
                     relativePath = relativePath.Substring(workingDirectory.Length);
 
@@ -174,7 +184,7 @@ public void StartExternalDiff(ITextDocument textDocument)
                 IVsDifferenceService differenceService = _serviceProvider.GetService(typeof(SVsDifferenceService)) as IVsDifferenceService;
                 string leftFileMoniker = tempFileName;
                 // The difference service will automatically load the text from the file open in the editor, even if
-                // it has changed.
+                // it has changed. Don't use the original path here.
                 string rightFileMoniker = filename;
 
                 string actualFilename = objectName;
@@ -207,7 +217,7 @@ public void StartExternalDiff(ITextDocument textDocument)
                     leftLabel = string.Format("{0}@{1}", objectName, repo.Head.Tip.Sha.Substring(0, 7));
                 }
 
-                string rightLabel = filename;
+                string rightLabel = originalPath;
 
                 string inlineLabel = null;
                 string roles = null;
@@ -220,26 +230,63 @@ public void StartExternalDiff(ITextDocument textDocument)
         }
 
         /// <inheritdoc/>
-        public bool IsGitRepository(string path)
+        public bool TryGetOriginalPath(string path, out string originalPath)
         {
-            return GetGitRepository(path) != null;
+            originalPath = null;
+            if (GetGitRepository(path, ref originalPath) == null)
+            {
+                originalPath = path;
+                return false;
+            }
+
+            return true;
         }
 
         /// <inheritdoc/>
-        public string GetGitRepository(string path)
+        public bool IsGitRepository(string path, string originalPath)
+        {
+            return GetGitRepository(path, originalPath) != null;
+        }
+
+        /// <inheritdoc/>
+        public string GetGitRepository(string path, string originalPath)
+        {
+            if (originalPath == null)
+                throw new ArgumentNullException(nameof(originalPath));
+
+            return GetGitRepository(path, ref originalPath);
+        }
+
+        private string GetGitRepository(string path, ref string originalPath)
         {
-            if (!Directory.Exists(path) && !File.Exists(path))
+            if (originalPath == null)
+            {
+                originalPath = path;
+                if (!Directory.Exists(path) && !File.Exists(path))
+                    return null;
+
+                var discoveredPath = Repository.Discover(Path.GetFullPath(path));
+                if (discoveredPath != null)
+                    return discoveredPath;
+
+                originalPath = AdjustPath(path);
+                if (originalPath == path)
+                    return null;
+            }
+
+            if (!Directory.Exists(path) && !File.Exists(originalPath))
                 return null;
 
-            var discoveredPath = Repository.Discover(Path.GetFullPath(path));
-            // https://github.com/libgit2/libgit2sharp/issues/818#issuecomment-54760613
-            return discoveredPath;
+            return Repository.Discover(Path.GetFullPath(originalPath));
         }
 
         /// <inheritdoc/>
-        public string GetGitWorkingCopy(string path)
+        public string GetGitWorkingCopy(string path, string originalPath)
         {
-            var repositoryPath = GetGitRepository(path);
+            if (originalPath == null)
+                throw new ArgumentNullException(nameof(originalPath));
+
+            var repositoryPath = GetGitRepository(path, originalPath);
             if (repositoryPath == null)
                 return null;
 
@@ -282,5 +329,87 @@ static bool HasPreamble(string file, Encoding encoding)
 
             return true;
         }
+
+        private string AdjustPath(string fullPath)
+        {
+            // Right now the only adjustment is for CPS-based project systems which open their project files in a
+            // temporary location. There are several of these, such as .csproj, .vbproj, .shproj, and .fsproj, and more
+            // could appear in the future.
+            if (!fullPath.EndsWith("proj", StringComparison.Ordinal))
+            {
+                return fullPath;
+            }
+
+            // CPS will open the file in %TEMP%\{random name}\{ProjectFileName}
+            string directoryName = Path.GetDirectoryName(fullPath);
+            if (string.IsNullOrEmpty(directoryName))
+                return fullPath;
+
+            directoryName = Path.GetDirectoryName(directoryName);
+            if (!Path.GetTempPath().Equals(directoryName + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
+                return fullPath;
+
+            IVsSolution solution = _serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
+            if (solution == null)
+                return fullPath;
+
+            if (!ErrorHandler.Succeeded(solution.GetProjectEnum((uint)__VSENUMPROJFLAGS.EPF_LOADEDINSOLUTION, Guid.Empty, out IEnumHierarchies ppenum))
+                || ppenum == null)
+            {
+                return fullPath;
+            }
+
+            List<string> projectFiles = new List<string>();
+            IVsHierarchy[] hierarchies = new IVsHierarchy[1];
+            while (true)
+            {
+                int hr = ppenum.Next((uint)hierarchies.Length, hierarchies, out uint fetched);
+                if (!ErrorHandler.Succeeded(hr))
+                    return fullPath;
+
+                for (uint i = 0; i < fetched; i++)
+                {
+                    if (!(hierarchies[0] is IVsProject project))
+                        continue;
+
+                    if (!ErrorHandler.Succeeded(project.GetMkDocument((uint)VSConstants.VSITEMID.Root, out string projectFilePath)))
+                        continue;
+
+                    if (!Path.GetFileName(projectFilePath).Equals(Path.GetFileName(fullPath), StringComparison.Ordinal))
+                        continue;
+
+                    projectFiles.Add(projectFilePath);
+                }
+
+                if (hr != VSConstants.S_OK)
+                {
+                    // No more projects
+                    break;
+                }
+            }
+
+            switch (projectFiles.Count)
+            {
+            case 0:
+                // No matching project file found in solution
+                return fullPath;
+
+            case 1:
+                // Exactly one matching project file found in solution
+                return projectFiles[0];
+
+            default:
+                // Multiple project files found in solution; try to find one with a matching file size
+                long desiredSize = new FileInfo(fullPath).Length;
+                foreach (var projectFilePath in projectFiles)
+                {
+                    if (File.Exists(projectFilePath) && new FileInfo(projectFilePath).Length == desiredSize)
+                        return projectFilePath;
+                }
+
+                // No results found
+                return fullPath;
+            }
+        }
     }
 }