mm201
diff --git a/‎LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
Lines changed: 1 addition & 0 deletions b/‎LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
Lines changed: 1 addition & 0 deletions
diff --git a/‎LibGit2Sharp.Tests/StashFixture.cs
Lines changed: 181 additions & 0 deletions b/‎LibGit2Sharp.Tests/StashFixture.cs
Lines changed: 181 additions & 0 deletions
diff --git a/‎LibGit2Sharp/Core/NativeMethods.cs
Lines changed: 8 additions & 0 deletions b/‎LibGit2Sharp/Core/NativeMethods.cs
Lines changed: 8 additions & 0 deletions
diff --git a/‎LibGit2Sharp/Core/Proxy.cs
Lines changed: 27 additions & 0 deletions b/‎LibGit2Sharp/Core/Proxy.cs
Lines changed: 27 additions & 0 deletions
diff --git a/‎LibGit2Sharp/LibGit2Sharp.csproj
Lines changed: 3 additions & 0 deletions b/‎LibGit2Sharp/LibGit2Sharp.csproj
Lines changed: 3 additions & 0 deletions
diff --git a/‎LibGit2Sharp/Repository.cs
Lines changed: 10 additions & 0 deletions b/‎LibGit2Sharp/Repository.cs
Lines changed: 10 additions & 0 deletions
diff --git a/‎LibGit2Sharp/Stash.cs
Lines changed: 41 additions & 0 deletions b/‎LibGit2Sharp/Stash.cs
Lines changed: 41 additions & 0 deletions
diff --git a/‎LibGit2Sharp/StashCollection.cs
Lines changed: 51 additions & 0 deletions b/‎LibGit2Sharp/StashCollection.cs
Lines changed: 51 additions & 0 deletions
@@ -58,6 +58,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CheckoutFixture.cs" />
+    <Compile Include="StashFixture.cs" />
     <Compile Include="CloneFixture.cs" />
     <Compile Include="ConflictFixture.cs" />
     <Compile Include="IgnoreFixture.cs" />
 
@@ -0,0 +1,181 @@
+using System;
+using System.IO;
+using LibGit2Sharp.Tests.TestHelpers;
+using Xunit;
+
+namespace LibGit2Sharp.Tests
+{
+    public class StashFixture : BaseFixture
+    {
+        [Fact]
+        public void CannotAddStashAgainstBareRepository()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo();
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var stasher = DummySignature;
+
+                Assert.Throws<BareRepositoryException>(() => repo.Stashes.Add(stasher, "My very first stash"));
+            }
+        }
+
+        [Fact]
+        public void CanAddStash()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var stasher = DummySignature;
+
+                Assert.True(repo.Index.RetrieveStatus().IsDirty);
+
+                Stash stash = repo.Stashes.Add(stasher, "My very first stash", StashOptions.IncludeUntracked);
+
+                // Check that untracked files are deleted from working directory
+                Assert.False(File.Exists(Path.Combine(repo.Info.WorkingDirectory, "new_untracked_file.txt")));
+
+                Assert.NotNull(stash);
+                Assert.Equal("stash@{0}", stash.CanonicalName);
+                Assert.Contains("My very first stash", stash.Message);
+
+                var stashRef = repo.Refs["refs/stash"];
+                Assert.Equal(stash.Target.Sha, stashRef.TargetIdentifier);
+
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+
+                // Create extra file
+                string newFileFullPath = Path.Combine(repo.Info.WorkingDirectory, "stash_candidate.txt");
+                File.WriteAllText(newFileFullPath, "Oh, I'm going to be stashed!\n");
+
+                Stash secondStash = repo.Stashes.Add(stasher, "My second stash", StashOptions.IncludeUntracked);
+
+                Assert.NotNull(stash);
+                Assert.Equal("stash@{0}", stash.CanonicalName);
+                Assert.Contains("My second stash", secondStash.Message);
+
+                // Stash history has been shifted
+                Assert.Equal(repo.Lookup<Commit>("stash@{0}").Sha, secondStash.Target.Sha);
+            }
+        }
+
+        [Fact]
+        public void AddingAStashWithNoMessageGeneratesADefaultOne()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var stasher = DummySignature;
+
+                Stash stash = repo.Stashes.Add(stasher);
+
+                Assert.NotNull(stash);
+                Assert.Equal("stash@{0}", stash.CanonicalName);
+                Assert.NotEmpty(stash.Target.Message);
+
+                var stashRef = repo.Refs["refs/stash"];
+                Assert.Equal(stash.Target.Sha, stashRef.TargetIdentifier);
+            }
+        }
+
+        [Fact]
+        public void AddStashWithBadParamsShouldThrows()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                Assert.Throws<ArgumentNullException>(() => repo.Stashes.Add(null));
+            }
+        }
+
+        [Fact]
+        public void StashingAgainstCleanWorkDirShouldReturnANullStash()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var stasher = DummySignature;
+
+                Stash stash = repo.Stashes.Add(stasher, "My very first stash", StashOptions.IncludeUntracked);
+
+                Assert.NotNull(stash);
+
+                //Stash against clean working directory
+                Assert.Null(repo.Stashes.Add(stasher));
+            }
+        }
+
+        [Fact]
+        public void CanStashWithoutOptions()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var stasher = DummySignature;
+
+                var untrackedFilePath = Path.Combine(repo.Info.WorkingDirectory, "new_untracked_file.txt");
+                File.WriteAllText(untrackedFilePath, "I'm untracked\n");
+
+                string stagedfilePath = Path.Combine(repo.Info.WorkingDirectory, "staged_file_path.txt");
+                File.WriteAllText(stagedfilePath, "I'm staged\n");
+                repo.Index.Stage(stagedfilePath);
+
+                Stash stash = repo.Stashes.Add(stasher, "Stash with default options");
+
+                Assert.NotNull(stash);
+
+                //It should not keep staged files
+                Assert.Equal(FileStatus.Nonexistent, repo.Index.RetrieveStatus("staged_file_path.txt"));
+
+                //It should leave untracked files untracked
+                Assert.Equal(FileStatus.Untracked, repo.Index.RetrieveStatus("new_untracked_file.txt"));
+            }
+        }
+
+        [Fact]
+        public void CanStashAndKeepIndex()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var stasher = DummySignature;
+
+                string stagedfilePath = Path.Combine(repo.Info.WorkingDirectory, "staged_file_path.txt");
+                File.WriteAllText(stagedfilePath, "I'm staged\n");
+                repo.Index.Stage(stagedfilePath);
+
+                Stash stash = repo.Stashes.Add(stasher, "This stash wil keep index", StashOptions.KeepIndex);
+
+                Assert.NotNull(stash);
+                Assert.Equal(FileStatus.Added, repo.Index.RetrieveStatus("staged_file_path.txt"));
+            }
+        }
+
+        [Fact]
+        public void CanStashIgnoredFiles()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
+
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                string gitIgnoreFilePath = Path.Combine(repo.Info.WorkingDirectory, ".gitignore");
+                File.WriteAllText(gitIgnoreFilePath, "ignored_file.txt");
+                repo.Index.Stage(gitIgnoreFilePath);
+                repo.Commit("Modify gitignore", Constants.Signature, Constants.Signature);
+
+                string ignoredFilePath = Path.Combine(repo.Info.WorkingDirectory, "ignored_file.txt");
+                File.WriteAllText(ignoredFilePath, "I'm ignored\n");
+
+                Assert.True(repo.Ignore.IsPathIgnored("ignored_file.txt"));
+
+                var stasher = DummySignature;
+                repo.Stashes.Add(stasher, "This stash includes ignore files", StashOptions.IncludeIgnored);
+
+                //TODO : below assertion doesn't pass. Bug?
+                //Assert.False(File.Exists(ignoredFilePath));
+
+                var blob = repo.Lookup<Blob>("stash^3:ignored_file.txt");
+                Assert.NotNull(blob);
+            }
+        }
+    }
+}
@@ -904,6 +904,14 @@ internal static extern int git_signature_new(
             long time,
             int offset);
 
+        [DllImport(libgit2)]
+        internal static extern int git_stash_save(
+            out GitOid id,
+            RepositorySafeHandle repo,
+            SignatureSafeHandle stasher,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8Marshaler))] string message,
+            StashOptions flags);
+
         [DllImport(libgit2)]
         internal static extern int git_status_file(
             out FileStatus statusflags,
 
@@ -1747,6 +1747,33 @@ public static SignatureSafeHandle git_signature_new(string name, string email, D
 
         #endregion
 
+        #region git_stash_
+
+        public static ObjectId git_stash_save(
+            RepositorySafeHandle repo,
+            Signature stasher,
+            string prettifiedMessage,
+            StashOptions options)
+        {
+            using (ThreadAffinity())
+            using (SignatureSafeHandle stasherHandle = stasher.BuildHandle())
+            {
+                GitOid stashOid;
+
+                int res = NativeMethods.git_stash_save(out stashOid, repo, stasherHandle, prettifiedMessage, options);
+
+                if (res == (int)GitErrorCode.NotFound)
+                {
+                    return null;
+                }
+
+                Ensure.Int32Result(res)
10000
;
+
+                return new ObjectId(stashOid);
+            }
+        }
+        #endregion
+
         #region git_status_
 
         public static FileStatus git_status_file(RepositorySafeHandle repo, FilePath path)
 
@@ -71,7 +71,10 @@
     <Compile Include="Core\Handles\GitFetchSpecHandle.cs" />
     <Compile Include="Network.cs" />
     <Compile Include="Core\GitRemoteHead.cs" />
+    <Compile Include="Stash.cs" />
+    <Compile Include="StashOptions.cs" />
     <Compile Include="OrphanedHeadException.cs" />
+    <Compile Include="StashCollection.cs" />
     <Compile Include="UnmergedIndexEntriesException.cs" />
     <Compile Include="Commit.cs" />
     <Compile Include="CommitLog.cs" />
 
@@ -28,6 +28,7 @@ public class Repository : IRepository
         private readonly ConflictCollection conflicts;
         private readonly ReferenceCollection refs;
         private readonly TagCollection tags;
+        private readonly StashCollection stashes;
         private readonly Lazy<RepositoryInformation> info;
         private readonly Diff diff;
         private readonly NoteCollection notes;
@@ -103,6 +104,7 @@ public Repository(string path, RepositoryOptions options = null)
                 refs = new ReferenceCollection(this);
                 branches = new BranchCollection(this);
                 tags = new TagCollection(this);
+                stashes = new StashCollection(this);
                 info<
10000
/span> = new Lazy<RepositoryInformation>(() => new RepositoryInformation(this, isBare));
                 config =
                     new Lazy<Configuration>(
@@ -286,6 +288,14 @@ public TagCollection Tags
             get { return tags; }
         }
 
+        ///<summary>
+        /// Lookup and enumerate stashes in the repository.
+        ///</summary>
+        public StashCollection Stashes
+        {
+            get { return stashes; }
+        }
+
         /// <summary>
         ///   Provides high level information about this repository.
         /// </summary>
 
@@ -0,0 +1,41 @@
+namespace LibGit2Sharp
+{
+    ///<summary>
+    ///   A Stash
+    ///   <para>A stash is a snapshot of the dirty state of the working directory (i.e. the modified tracked files and staged changes)</para>
+    ///</summary>
+    public class Stash : ReferenceWrapper<Commit>
+    {
+        /// <summary>
+        ///   Needed for mocking purposes.
+        /// </summary>
+        protected Stash()
+        { }
+
+        internal Stash(Repository repo, ObjectId targetId)
+            : base(repo, new DirectReference("stash@{0}", repo, targetId), r => r.CanonicalName)
+        {
+        }
+
+        /// <summary>
+        ///   Gets the <see cref = "Commit" /> that this stash points to.
+        /// </summary>
+        public virtual Commit Target
+        {
+            get { return TargetObject; }
+        }
+
+        /// <summary>
+        ///   Gets the message associated to this <see cref="Stash"/>.
+        /// </summary>
+        public virtual string Message
+        {
+            get { return Target.Message; }
+        }
+
+        protected override string Shorten()
+        {
+            return CanonicalName;
+        }
+    }
+}
@@ -0,0 +1,51 @@
+using LibGit2Sharp.Core;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    ///   The collection of <see cref = "Stash" />es in a <see cref = "Repository" />
+    /// </summary>
+    public class StashCollection
+    {
+        internal readonly Repository repo;
+
+        /// <summary>
+        ///   Needed for mocking purposes.
+        /// </summary>
+        protected StashCollection()
+        { }
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref = "StashCollection" /> class.
+        /// </summary>
+        /// <param name = "repo">The repo.</param>
+        internal StashCollection(Repository repo)
+        {
+            this.repo = repo;
+        }
+
+        /// <summary>
+        ///   Creates a stash with the specified message.
+        /// </summary>
+        /// <param name="stasher">The <see cref="Signature"/> of the user who stashes </param>
+        /// <param name = "message">The message of the stash.</param>
+        /// <param name = "options">A combination of <see cref="StashOptions"/> flags</param>
+        /// <returns>the newly created <see cref="Stash"/></returns>
+        public virtual Stash Add(Signature stasher, string message = null, StashOptions options = StashOptions.Default)
+        {
+            Ensure.ArgumentNotNull(stasher, "stasher");
+
+            string prettifiedMessage = Proxy.git_message_prettify(string.IsNullOrEmpty(message) ? string.Empty : message);
+
+            ObjectId oid = Proxy.git_stash_save(repo.Handle, stasher, prettifiedMessage, options);
+
+            // in case there is nothing to stash
+            if (oid == null)
+            {
+                return null;
+            }
+
+            return new Stash(repo, oid);
+        }
+    }
+}