Merge branch 'master' into donokuda/not-delete-nooooooo

Author: grokys

CONTRIBUTING.md

@@ -13,16 +13,16 @@ This project adheres to the [Open Code of Conduct][code-of-conduct]. By particip
 
 ## Submitting a pull request
 
-0. [Fork][] and clone the repository (see Build Instructions in the [README][readme])
-0. Create a new branch: `git checkout -b my-branch-name`
-0. Make your change, add tests, and make sure the tests still pass
-0. Push to your fork and [submit a pull request][pr]
-0. Pat your self on the back and wait for your pull request to be reviewed and merged.
+1. [Fork][] and clone the repository (see Build Instructions in the [README][readme])
+2. Create a new branch: `git checkout -b my-branch-name`
+3. Make your change, add tests, and make sure the tests still pass
+4. Push to your fork and [submit a pull request][pr]
+5. Pat your self on the back and wait for your pull request to be reviewed and merged.
 
 Here are a few things you can do that will increase the likelihood of your pull request being accepted:
 
-- Follow the existing code's style.
-- Write tests.
+- Follow the style/format of the existing code.
+- Write tests for your changes.
 - Keep your change as focused as possible. If there are multiple changes you would like to make that are not dependent upon each other, consider submitting them as separate pull requests.
 - Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
 
@@ -38,7 +38,7 @@ There are certain areas of the extension that are restricted in what they can do
 ### Bug Reporting
 
 Here are a few helpful tips when reporting a bug:
-- Verify the bug resides in the GitHub for Visual Studio extension
+- Verify that the bug resides in the GitHub for Visual Studio extension
   - A lot of functionality provided by this extension resides in the Team Explorer pane, alongside other non-GitHub tools to manage and collaborate on source code, including Visual Studio's Git support, which is owned by Microsoft.
   - If this bug not is related to the GitHub extension, visit the [Visual Studio support page](https://www.visualstudio.com/support/support-overview-vs) for help
 - Screenshots are very helpful in diagnosing bugs and understanding the state of the extension when it's experiencing problems. Please include them whenever possible.

src/GitHub.App/Services/GitHubContextService.cs

@@ -58,6 +58,8 @@ public class GitHubContextService : IGitHubContextService
         static readonly Regex treeishCommitRegex = new Regex($"(?<commit>[a-z0-9]{{40}})(/(?<tree>.+))?", RegexOptions.Compiled);
         static readonly Regex treeishBranchRegex = new Regex($"(?<branch>master)(/(?<tree>.+))?", RegexOptions.Compiled);
 
+        static readonly Regex tempFileObjectishRegex = new Regex(@"\\TFSTemp\\[^\\]*[.](?<objectish>[a-z0-9]{8})[.][^.\\]*$", RegexOptions.Compiled);
+
         [ImportingConstructor]
         public GitHubContextService(IGitHubServiceProvider serviceProvider, IGitService gitService)
         {
@@ -305,6 +307,55 @@ public bool TryOpenFile(string repositoryDir, GitHubContext context)
             }
         }
 
+        /// <inheritdoc/>
+        public string FindObjectishForTFSTempFile(string tempFile)
+        {
+            var match = tempFileObjectishRegex.Match(tempFile);
+            if (match.Success)
+            {
+                return match.Groups["objectish"].Value;
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc/>
+        public (string commitSha, string blobPath) ResolveBlobFromHistory(string repositoryDir, string objectish)
+        {
+            using (var repo = gitService.GetRepository(repositoryDir))
+            {
+                var blob = repo.Lookup<Blob>(objectish);
+                if (blob == null)
+                {
+                    return (null, null);
+                }
+
+                foreach (var commit in repo.Commits)
+                {
+                    var trees = new Stack<Tree>();
+                    trees.Push(commit.Tree);
+
+                    while (trees.Count > 0)
+                    {
+                        foreach (var treeEntry in trees.Pop())
+                        {
+                            if (treeEntry.Target == blob)
+                            {
+                                return (commit.Sha, treeEntry.Path);
+                            }
+
+                            if (treeEntry.TargetType == TreeEntryTargetType.Tree)
+                            {
+                                trees.Push((Tree)treeEntry.Target);
+                            }
+                        }
+                    }
+                }
+
+                return (null, null);
+            }
+        }
+
         /// <inheritdoc/>
         public bool HasChangesInWorkingDirectory(string repositoryDir, string commitish, string path)
         {

src/GitHub.Exports/Services/IGitHubContextService.cs

@@ -71,6 +71,30 @@ public interface IGitHubContextService
         /// <returns>The resolved commit-ish, blob path and commit SHA for the blob. Path will be null if the commit-ish can be resolved but not the blob.</returns>
         (string commitish, string path, string commitSha) ResolveBlob(string repositoryDir, GitHubContext context, string remoteName = "origin");
 
+        /// <summary>
+        /// Find the object-ish (first 8 chars of a blob SHA) from the path to historical blob created by Team Explorer.
+        /// </summary>
+        /// <remarks>
+        /// Team Explorer creates temporary blob files in the following format:
+        /// C:\Users\me\AppData\Local\Temp\TFSTemp\vctmp21996_181282.IOpenFromClipboardCommand.783ac965.cs
+        /// The object-ish appears immediately before the file extension and the path contains the folder "TFSTemp".
+        /// <remarks>
+        /// <param name="tempFile">The path to a possible Team Explorer temporary blob file.</param>
+        /// <returns>The target file's object-ish (blob SHA fragment) or null if the path isn't recognized as a Team Explorer blob file.</returns>
+        string FindObjectishForTFSTempFile(string tempFile);
+
+        /// <summary>
+        /// Find a tree entry in the commit log where a blob appears and return its commit SHA and path.
+        /// </summary>
+        /// <remarks>
+        /// Search back through the commit log for the first tree entry where a blob appears. This operation only takes
+        /// a fraction of a seond on the `github/VisualStudio` repository even if a tree entry casn't be found.
+        /// </remarks>
+        /// <param name="repositoryDir">The target repository directory.</param>
+        /// <param name="objectish">The fragment of a blob SHA to find.</param>
+        /// <returns>The commit SHA and blob path or null if the blob can't be found.</returns>
+        (string commitSha, string blobPath) ResolveBlobFromHistory(string repositoryDir, string objectish);
+
         /// <summary>
         /// Check if a file in the working directory has changed since a specified commit-ish.
         /// </summary>

src/GitHub.VisualStudio/Commands/GoToSolutionOrPullRequestFileCommand.cs

@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using System.ComponentModel.Composition;
 using GitHub.Services;
 using GitHub.Extensions;
@@ -10,6 +11,7 @@
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Differencing;
+using Microsoft.VisualStudio.TextManager.Interop;
 using Task = System.Threading.Tasks.Task;
 
 namespace GitHub.Commands
@@ -40,6 +42,8 @@ public class GoToSolutionOrPullRequestFileCommand : VsCommand, IGoToSolutionOrPu
         readonly Lazy<IVsEditorAdaptersFactoryService> editorAdapter;
         readonly Lazy<IPullRequestSessionManager> sessionManager;
         readonly Lazy<IPullRequestEditorService> pullRequestEditorService;
+        readonly Lazy<ITeamExplorerContext> teamExplorerContext;
+        readonly Lazy<IGitHubContextService> gitHubContextService;
         readonly Lazy<IStatusBarNotificationService> statusBar;
         readonly Lazy<IUsageTracker> usageTracker;
 
@@ -49,13 +53,17 @@ public GoToSolutionOrPullRequestFileCommand(
             Lazy<IVsEditorAdaptersFactoryService> editorAdapter,
             Lazy<IPullRequestSessionManager> sessionManager,
             Lazy<IPullRequestEditorService> pullRequestEditorService,
+            Lazy<ITeamExplorerContext> teamExplorerContext,
+            Lazy<IGitHubContextService> gitHubContextService,
             Lazy<IStatusBarNotificationService> statusBar,
             Lazy<IUsageTracker> usageTracker) : base(CommandSet, CommandId)
         {
             this.serviceProvider = serviceProvider;
             this.editorAdapter = editorAdapter;
             this.sessionManager = sessionManager;
             this.pullRequestEditorService = pullRequestEditorService;
+            this.gitHubContextService = gitHubContextService;
+            this.teamExplorerContext = teamExplorerContext;
             this.statusBar = statusBar;
             this.usageTracker = usageTracker;
 
@@ -112,6 +120,11 @@ public override async Task Execute()
                     return;
                 }
 
+                if (TryNavigateFromHistoryFile(sourceView))
+                {
+                    return;
+                }
+
                 var relativePath = sessionManager.Value.GetRelativePath(textView.TextBuffer);
                 if (relativePath == null)
                 {
@@ -189,6 +202,11 @@ void OnBeforeQueryStatus(object sender, EventArgs e)
                         return;
                     }
                 }
+
+                if (TryNavigateFromHistoryFileQueryStatus(sourceView))
+                {
+                    return;
+                }
             }
             catch (Exception ex)
             {
@@ -198,6 +216,65 @@ void OnBeforeQueryStatus(object sender, EventArgs e)
             Visible = false;
         }
 
+        // Set command Text/Visible properties and return true when active
+        bool TryNavigateFromHistoryFileQueryStatus(IVsTextView sourceView)
+        {
+            if (teamExplorerContext.Value.ActiveRepository?.LocalPath is string && // Check there is an active repo
+                FindObjectishForTFSTempFile(sourceView) is string) // Looks like a history file
+            {
+                // Navigate from history file is active
+                Text = "Open File in Solution";
+                Visible = true;
+                return true;
+            }
+
+            return false;
+        }
+
+        // Attempt navigation to historical file
+        bool TryNavigateFromHistoryFile(IVsTextView sourceView)
+        {
+            if (teamExplorerContext.Value.ActiveRepository?.LocalPath is string repositoryDir &&
+                FindObjectishForTFSTempFile(sourceView) is string objectish)
+            {
+                var (commitSha, blobPath) = gitHubContextService.Value.ResolveBlobFromHistory(repositoryDir, objectish);
+                if (blobPath is string)
+                {
+                    var workingFile = Path.Combine(repositoryDir, blobPath);
+                    VsShellUtilities.OpenDocument(serviceProvider, workingFile, VSConstants.LOGVIEWID.TextView_guid,
+                        out IVsUIHierarchy hierarchy, out uint itemID, out IVsWindowFrame windowFrame, out IVsTextView targetView);
+
+                    pullRequestEditorService.Value.NavigateToEquivalentPosition(sourceView, targetView);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        // Find the blob SHA in a file name if any
+        string FindObjectishForTFSTempFile(IVsTextView sourceView)
+        {
+            return
+                FindPath(sourceView) is string path &&
+                gitHubContextService.Value.FindObjectishForTFSTempFile(path) is string objectish ?
+                objectish : null;
+        }
+
+        // See http://microsoft.public.vstudio.extensibility.narkive.com/agfoD1GO/full-pathname-of-file-shown-in-current-view-of-core-editor#post2
+        static string FindPath(IVsTextView textView)
+        {
+            ErrorHandler.ThrowOnFailure(textView.GetBuffer(out IVsTextLines buffer));
+            var userData = buffer as IVsUserData;
+            if (userData == null)
+            {
+                return null;
+            }
+
+            ErrorHandler.ThrowOnFailure(userData.GetData(typeof(IVsUserData).GUID, out object data));
+            return data as string;
+        }
+
         ITextView FindActiveTextView(IDifferenceViewer diffViewer)
         {
             switch (diffViewer.ActiveViewType)

test/GitHub.App.UnitTests/Services/GitHubContextServiceTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using GitHub.Exports;
 using GitHub.Services;
 using NSubstitute;
@@ -382,6 +383,117 @@ public void ResolveBlob(string url, string commitish, string objectish, string e
         }
     }
 
+    public class TheResolveBlobFromCommitsMethod
+    {
+        [Test]
+        public void FlatTree()
+        {
+            var objectish = "12345678";
+            var expectCommitSha = "2434215c5489db2bfa2e5249144a3bc532465f97";
+            var expectBlobPath = "Class1.cs";
+            var repositoryDir = "repositoryDir";
+            var blob = Substitute.For<Blob>();
+            var treeEntry = CreateTreeEntry(TreeEntryTargetType.Blob, blob, expectBlobPath);
+            var commit = CreateCommit(expectCommitSha, treeEntry);
+            var repository = CreateRepository(commit);
+            repository.Lookup<Blob>(objectish).Returns(blob);
+            var target = CreateGitHubContextService(repositoryDir, repository);
+
+            var (commitSha, blobPath) = target.ResolveBlobFromHistory(repositoryDir, objectish);
+
+            Assert.That((commitSha, blobPath), Is.EqualTo((expectCommitSha, expectBlobPath)));
+        }
+
+        [Test]
+        public void NestedTree()
+        {
+            var objectish = "12345678";
+            var expectCommitSha = "2434215c5489db2bfa2e5249144a3bc532465f97";
+            var expectBlobPath = @"AnnotateFileTests\Class1.cs";
+            var repositoryDir = "repositoryDir";
+            var blob = Substitute.For<Blob>();
+            var blobTreeEntry = CreateTreeEntry(TreeEntryTargetType.Blob, blob, expectBlobPath);
+            var childTree = CreateTree(blobTreeEntry);
+            var treeTreeEntry = CreateTreeEntry(TreeEntryTargetType.Tree, childTree, "AnnotateFileTests");
+            var commit = CreateCommit(expectCommitSha, treeTreeEntry);
+            var repository = CreateRepository(commit);
+            repository.Lookup<Blob>(objectish).Returns(blob);
+            var target = CreateGitHubContextService(repositoryDir, repository);
+
+            var (commitSha, blobPath) = target.ResolveBlobFromHistory(repositoryDir, objectish);
+
+            Assert.That((commitSha, blobPath), Is.EqualTo((expectCommitSha, expectBlobPath)));
+        }
+
+        [Test]
+        public void MissingBlob()
+        {
+            var objectish = "12345678";
+            var repositoryDir = "repositoryDir";
+            var treeEntry = Substitute.For<TreeEntry>();
+            var repository = CreateRepository();
+            var target = CreateGitHubContextService(repositoryDir, repository);
+
+            var (commitSha, blobPath) = target.ResolveBlobFromHistory(repositoryDir, objectish);
+
+            Assert.That((commitSha, blobPath), Is.EqualTo((null as string, null as string)));
+        }
+
+        static IRepository CreateRepository(params Commit[] commits)
+        {
+            var repository = Substitute.For<IRepository>();
+            var enumerator = commits.ToList().GetEnumerator();
+            repository.Commits.GetEnumerator().Returns(enumerator);
+            return repository;
+        }
+
+        static Commit CreateCommit(string sha, params TreeEntry[] treeEntries)
+        {
+            var commit = Substitute.For<Commit>();
+            commit.Sha.Returns(sha);
+            var tree = CreateTree(treeEntries);
+            commit.Tree.Returns(tree);
+            return commit;
+        }
+
+        static TreeEntry CreateTreeEntry(TreeEntryTargetType targetType, GitObject target, string path)
+        {
+            var treeEntry = Substitute.For<TreeEntry>();
+            treeEntry.TargetType.Returns(targetType);
+            treeEntry.Target.Returns(target);
+            treeEntry.Path.Returns(path);
+            return treeEntry;
+        }
+
+        static Tree CreateTree(params TreeEntry[] treeEntries)
+        {
+            var tree = Substitute.For<Tree>();
+            var enumerator = treeEntries.ToList().GetEnumerator();
+            tree.GetEnumerator().Returns(enumerator);
+            return tree;
+        }
+    }
+
+    public class TheFindBlobShaForTextViewMethod
+    {
+        [TestCase(@"C:\Users\me\AppData\Local\Temp\TFSTemp\vctmp21996_181282.IOpenFromClipboardCommand.783ac965.cs", "783ac965")]
+        [TestCase(@"\TFSTemp\File.12345678.ext", "12345678")]
+        [TestCase(@"\TFSTemp\File.abcdefab.ext", "abcdefab")]
+        [TestCase(@"\TFSTemp\.12345678.", "12345678")]
+        [TestCase(@"\TFSTemp\File.ABCDEFAB.ext", null)]
+        [TestCase(@"\TFSTemp\File.1234567.ext", null)]
+        [TestCase(@"\TFSTemp\File.123456789.ext", null)]
+        [TestCase(@"\TFSTemp\File.12345678.ext\\", null)]
+        public void FindObjectishForTFSTempFile(string path, string expectObjectish)
+        {
+            var target = CreateGitHubContextService();
+
+            var objectish = target.FindObjectishForTFSTempFile(path);
+
+            Assert.That(objectish, Is.EqualTo(expectObjectish));
+        }
+    }
+
     static GitHubContextService CreateGitHubContextService(string repositoryDir = null, IRepository repository = null)
     {
         var sp = Substitute.For<IGitHubServiceProvider>();