Introduce StashCollection.Apply and Pop

LibGit2Sharp.Tests/StashFixture.cs

@@ -204,6 +204,156 @@ public void CanStashIgnoredFiles()
             }
         }
 
+        [Fact]
+        public void CanStashAndApplyWithOptions()
+        {
+            string path = SandboxStandardTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var stasher = Constants.Signature;
+
+                const string filename = "staged_file_path.txt";
+                Touch(repo.Info.WorkingDirectory, filename, "I'm staged\n");
+                repo.Stage(filename);
+
+                repo.Stashes.Add(stasher, "This stash with default options");
+                Assert.Equal(StashApplyStatus.Applied, repo.Stashes.Apply(0));
+
+                Assert.Equal(FileStatus.NewInWorkdir, repo.RetrieveStatus(filename));
+                Assert.Equal(1, repo.Stashes.Count());
+
+                repo.Stage(filename);
+
+                repo.Stashes.Add(stasher, "This stash with default options");
+                Assert.Equal(StashApplyStatus.Applied, repo.Stashes.Apply(
+                    0,
+                    new StashApplyOptions
+                    {
+                        ApplyModifiers = StashApplyModifiers.ReinstateIndex,
+                    }));
+
+                Assert.Equal(FileStatus.NewInIndex, repo.RetrieveStatus(filename));
+                Assert.Equal(2, repo.Stashes.Count());
+            }
+        }
+
+        [Fact]
+        public void CanStashAndPop()
+        {
+            string path = SandboxStandardTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var stasher = Constants.Signature;
+
+                Assert.Equal(0, repo.Stashes.Count());
+
+                const string filename = "staged_file_path.txt";
+                const string contents = "I'm staged";
+                Touch(repo.Info.WorkingDirectory, filename, contents);
+                repo.Stage(filename);
+
+                repo.Stashes.Add(stasher, "This stash with default options");
+                Assert.Equal(1, repo.Stashes.Count());
+
+                Assert.Equal(StashApplyStatus.Applied, repo.Stashes.Pop(0));
+                Assert.Equal(0, repo.Stashes.Count());
+
+                Assert.Equal(FileStatus.NewInWorkdir, repo.RetrieveStatus(filename));
+                Assert.Equal(contents, File.ReadAllText(Path.Combine(repo.Info.WorkingDirectory, filename)));
+            }
+        }
+
+        [Fact]
+        public void StashReportsConflictsWhenReinstated()
+        {
+            string path = SandboxStandardTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var stasher = Constants.Signature;
+
+                const string filename = "staged_file_path.txt";
+                const string originalContents = "I'm pre-stash.";
+                const string filename2 = "unstaged_file_path.txt";
+                const string newContents = "I'm post-stash.";
+
+                Touch(repo.Info.WorkingDirectory, filename, originalContents);
+                repo.Stage(filename);
+                Touch(repo.Info.WorkingDirectory, filename2, originalContents);
+
+                repo.Stashes.Add(stasher, "This stash with default options");
+
+                Touch(repo.Info.WorkingDirectory, filename, newContents);
+                repo.Stage(filename);
+                Touch(repo.Info.WorkingDirectory, filename2, newContents);
+
+                Assert.Equal(StashApplyStatus.Conflicts, repo.Stashes.Pop(0, new StashApplyOptions
+                    {
+                        ApplyModifiers = StashApplyModifiers.ReinstateIndex,
+                    }));
+                Assert.Equal(1, repo.Stashes.Count());
+                Assert.Equal(newContents, File.ReadAllText(Path.Combine(repo.Info.WorkingDirectory, filename)));
+                Assert.Equal(newContents, File.ReadAllText(Path.Combine(repo.Info.WorkingDirectory, filename2)));
+            }
+        }
+
+        [Fact]
+        public void StashCallsTheCallback()
+        {
+            string path = SandboxStandardTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var stasher = Constants.Signature;
+                bool called;
+
+                const string filename = "staged_file_path.txt";
+                const string filename2 = "unstaged_file_path.txt";
+                const string originalContents = "I'm pre-stash.";
+
+                Touch(repo.Info.WorkingDirectory, filename, originalContents);
+                repo.Stage(filename);
+                Touch(repo.Info.WorkingDirectory, filename2, originalContents);
+
+                repo.Stashes.Add(stasher, "This stash with default options");
+
+                called = false;
+                repo.Stashes.Apply(0, new StashApplyOptions
+                    {
+                        ProgressHandler = (progress) => { called = true; return true; }
+                    });
+
+                Assert.Equal(true, called);
+
+                repo.Reset(ResetMode.Hard);
+
+                called = false;
+                repo.Stashes.Pop(0, new StashApplyOptions
+                    {
+                        ProgressHandler = (progress) => { called = true; return true; }
+                    });
+
+                Assert.Equal(true, called);
+            }
+        }
+
+        [Fact]
+        public void StashApplyReportsNotFound()
+        {
+            string path = SandboxStandardTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var stasher = Constants.Signature;
+
+                const string filename = "unstaged_file_path.txt";
+                Touch(repo.Info.WorkingDirectory, filename, "I'm unstaged\n");
+
+                repo.Stashes.Add(stasher, "This stash with default options", StashModifiers.IncludeUntracked);
+                Touch(repo.Info.WorkingDirectory, filename, "I'm another unstaged\n");
+
+                Assert.Equal(StashApplyStatus.NotFound, repo.Stashes.Pop(1));
+                Assert.Throws<ArgumentException>(() => repo.Stashes.Pop(-1));
+            }
+        }
+
         [Theory]
         [InlineData(-1)]
         [InlineData(-42)]

LibGit2Sharp/Core/GitStashApplyOpts.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace LibGit2Sharp.Core
+{
+    internal delegate int stash_apply_progress_cb(StashApplyProgress progress, IntPtr payload);
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal class GitStashApplyOpts
+    {
+        public uint Version = 1;
+
+        public StashApplyModifiers Flags;
+        public GitCheckoutOpts CheckoutOptions;
+
+        public stash_apply_progress_cb ApplyProgressCallback;
+        public IntPtr ProgressPayload;
+    }
+}

LibGit2Sharp/Core/NativeMethods.cs

@@ -1366,6 +1366,18 @@ internal static extern int git_stash_foreach(
         [DllImport(libgit2)]
         internal static extern int git_stash_drop(RepositorySafeHandle repo, UIntPtr index);
 
+        [DllImport(libgit2)]
+        internal static extern int git_stash_apply(
+            RepositorySafeHandle repo,
+            UIntPtr index,
+            GitStashApplyOpts opts);
+
+        [DllImport(libgit2)]
+        internal static extern int git_stash_pop(
+            RepositorySafeHandle repo,
+            UIntPtr index,
+            GitStashApplyOpts opts);
+
         [DllImport(libgit2)]
         internal static extern int git_status_file(
             out FileStatus statusflags,

LibGit2Sharp/Core/Proxy.cs

@@ -2452,6 +2452,38 @@ public static void git_stash_drop(RepositorySafeHandle repo, int index)
             Ensure.BooleanResult(res);
         }
 
+        private static StashApplyStatus get_stash_status(int res)
+        {
+            if (res == (int)GitErrorCode.Conflict)
+            {
+                return StashApplyStatus.Conflicts;
+            }
+
+            if (res == (int)GitErrorCode.NotFound)
+            {
+                return StashApplyStatus.NotFound;
+            }
+
+            Ensure.ZeroResult(res);
+            return StashApplyStatus.Applied;
+        }
+
+        public static StashApplyStatus git_stash_apply(
+            RepositorySafeHandle repo,
+            int index,
+            GitStashApplyOpts opts)
+        {
+            return get_stash_status(NativeMethods.git_stash_apply(repo, (UIntPtr)index, opts));
+        }
+
+        public static StashApplyStatus git_stash_pop(
+            RepositorySafeHandle repo,
+            int index,
+            GitStashApplyOpts opts)
+        {
+            return get_stash_status(NativeMethods.git_stash_pop(repo, (UIntPtr)index, opts));
+        }
+
         #endregion
 
         #region git_status_

LibGit2Sharp/Handlers.cs

@@ -112,6 +112,13 @@ namespace LibGit2Sharp.Handlers
     /// <param name="problematicRefspec">The refspec which didn't match the default.</param>
     public delegate void RemoteRenameFailureHandler(string problematicRefspec);
 
+    /// <summary>
+    /// Delegate definition for stash application callback.
+    /// </summary>
+    /// <param name="progress">The current step of the stash application.</param>
+    /// <returns>True to continue checkout operation; false to cancel checkout operation.</returns>
+    public delegate bool StashApplyProgressHandler(StashApplyProgress progress);
+
     /// <summary>
     /// The stages of pack building.
     /// </summary>

LibGit2Sharp/LibGit2Sharp.csproj

@@ -357,6 +357,10 @@
     <Compile Include="Core\RawContentStream.cs" />
     <Compile Include="Core\Handles\OdbStreamSafeHandle.cs" />
     <Compile Include="SupportedCredentialTypes.cs" />
+    <Compile Include="StashApplyProgress.cs" />
+    <Compile Include="StashApplyOptions.cs" />
+    <Compile Include="StashApplyStatus.cs" />
+    <Compile Include="Core\GitStashApplyOpts.cs" />
   </ItemGroup>
   <ItemGroup>
     <CodeAnalysisDictionary Include="CustomDictionary.xml" />

LibGit2Sharp/StashApplyOptions.cs

@@ -0,0 +1,48 @@
+using System;
+using LibGit2Sharp.Core;
+using LibGit2Sharp.Handlers;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// The options to be used for stash application.
+    /// </summary>
+    public sealed class StashApplyOptions
+    {
+        /// <summary>
+        /// <see cref="StashApplyModifiers"/> for controlling checkout index reinstating./> 
+        /// </summary>
+        /// <value>The flags.</value>
+        public StashApplyModifiers ApplyModifiers { get; set; }
+
+        /// <summary>
+        /// <see cref="CheckoutOptions"/> controlling checkout behavior.
+        /// </summary>
+        /// <value>The checkout options.</value>
+        public CheckoutOptions CheckoutOptions { get; set; }
+
+        /// <summary>
+        /// <see cref="StashApplyProgressHandler"/> for controlling stash application progress./>
+        /// </summary>
+        /// <value>The progress handler.</value>
+        public StashApplyProgressHandler ProgressHandler { get; set; }
+    }
+
+    /// <summary>
+    /// The flags which control whether the index should be reinstated.
+    /// </summary>
+    [Flags]
+    public enum StashApplyModifiers
+    {
+        /// <summary>
+        /// Default. Will apply the stash and result in an index with conflicts
+        /// if any arise.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// In case any conflicts arise, this will not apply the stash.
+        /// </summary>
+        ReinstateIndex = (1 << 0),
+    }
+}

LibGit2Sharp/StashApplyProgress.cs

@@ -0,0 +1,50 @@
+using System;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// The current progress of the stash application.
+    /// </summary>
+    public enum StashApplyProgress
+    {
+        /// <summary>
+        /// Not passed by the callback. Used as dummy value.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Loading the stashed data from the object database.
+        /// </summary>
+        LoadingStash,
+
+        /// <summary>
+        /// The stored index is being analyzed.
+        /// </summary>
+        AnalyzeIndex,
+
+        /// <summary>
+        /// The modified files are being analyzed.
+        /// </summary>
+        AnalyzeModified,
+
+        /// <summary>
+        /// The untracked and ignored files are being analyzed.
+        /// </summary>
+        AnalyzeUntracked,
+
+        /// <summary>
+        /// The untracked files are being written to disk.
+        /// </summary>
+        CheckoutUntracked,
+
+        /// <summary>
+        /// The modified files are being written to disk.
+        /// </summary>
+        CheckoutModified,
+
+        /// <summary>
+        /// The stash was applied successfully.
+        /// </summary>
+        Done,
+    }
+}

LibGit2Sharp/StashApplyStatus.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// The result of a stash application operation.
+    /// </summary>
+    public enum StashApplyStatus
+    {
+        /// <summary>
+        /// The stash application was successful.
+        /// </summary>
+        Applied,
+
+        /// <summary>
+        /// The stash application ended up with conflicts.
+        /// </summary>
+        Conflicts,
+
+        /// <summary>
+        /// The stash index given was not found.
+        /// </summary>
+        NotFound,
+    }
+}