Index.Stage: do not stage ignored files

Stage() now respects ignore files by default, similar to git.git.
Users accustomed to the old behavior may use the new StageOptions
class (in particular the IncludeIgnored bool) to override this
behavior.

Author: Edward Thomson

LibGit2Sharp.Tests/StageFixture.cs

@@ -67,7 +67,7 @@ public void StagingAnUnknownFileThrowsIfExplicitPath(string relativePath, FileSt
                 Assert.Null(repo.Index[relativePath]);
                 Assert.Equal(status, repo.Index.RetrieveStatus(relativePath));
 
-                Assert.Throws<UnmatchedPathException>(() => repo.Index.Stage(relativePath, new ExplicitPathsOptions()));
+                Assert.Throws<UnmatchedPathException>(() => repo.Index.Stage(relativePath, new StageOptions { ExplicitPathsOptions = new ExplicitPathsOptions() }));
             }
         }
 
@@ -82,7 +82,7 @@ public void CanStageAnUnknownFileWithLaxUnmatchedExplicitPathsValidation(string
                 Assert.Equal(status, repo.Index.RetrieveStatus(relativePath));
 
                 Assert.DoesNotThrow(() => repo.Index.Stage(relativePath));
-                Assert.DoesNotThrow(() => repo.Index.Stage(relativePath, new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false }));
+                Assert.DoesNotThrow(() => repo.Index.Stage(relativePath, new StageOptions { ExplicitPathsOptions = new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false } }));
 
                 Assert.Equal(status, repo.Index.RetrieveStatus(relativePath));
             }
@@ -99,7 +99,7 @@ public void StagingAnUnknownFileWithLaxExplicitPathsValidationDoesntThrow(string
                 Assert.Equal(status, repo.Index.RetrieveStatus(relativePath));
 
                 repo.Index.Stage(relativePath);
-                repo.Index.Stage(relativePath, new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false });
+                repo.Index.Stage(relativePath, new StageOptions { ExplicitPathsOptions = new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false } });
             }
         }
 
@@ -299,6 +299,22 @@ public void CanStageWithMultiplePathspecs()
             }
         }
 
+        [Theory]
+        [InlineData("ignored_file.txt")]
+        [InlineData("ignored_folder/file.txt")]
+        public void CanIgnoreIgnoredPaths(string path)
+        {
+            using (var repo = new Repository(CloneStandardTestRepo()))
+            {
+                Touch(repo.Info.WorkingDirectory, ".gitignore", "ignored_file.txt\nignored_folder/\n");
+                Touch(repo.Info.WorkingDirectory, path, "This file is ignored.");
+
+                Assert.Equal(FileStatus.Ignored, repo.Index.RetrieveStatus(path));
+                repo.Index.Stage("*");
+                Assert.Equal(FileStatus.Ignored, repo.Index.RetrieveStatus(path));
+            }
+        }
+
         [Theory]
         [InlineData("ignored_file.txt")]
         [InlineData("ignored_folder/file.txt")]
@@ -310,7 +326,7 @@ public void CanStageIgnoredPaths(string path)
                 Touch(repo.Info.WorkingDirectory, path, "This file is ignored.");
 
                 Assert.Equal(FileStatus.Ignored, repo.Index.RetrieveStatus(path));
-                repo.Index.Stage(path);
+                repo.Index.Stage(path, new StageOptions { IncludeIgnored = true });
                 Assert.Equal(FileStatus.Added, repo.Index.RetrieveStatus(path));
             }
         }

LibGit2Sharp.Tests/UnstageFixture.cs

@@ -50,7 +50,7 @@ public void CanStageAndUnstageAnIgnoredFile()
 
                 Assert.Equal(FileStatus.Ignored, repo.Index.RetrieveStatus(relativePath));
 
-                repo.Index.Stage(relativePath);
+                repo.Index.Stage(relativePath, new StageOptions { IncludeIgnored = true });
                 Assert.Equal(FileStatus.Added, repo.Index.RetrieveStatus(relativePath));
 
                 repo.Index.Unstage(relativePath);

LibGit2Sharp/Index.cs

@@ -129,32 +129,70 @@ IEnumerator IEnumerable.GetEnumerator()
 
         /// <summary>
         /// Promotes to the staging area the latest modifications of a file in the working directory (addition, updation or removal).
+        /// 
+        /// If this path is ignored by configuration then it will not be staged.
         /// </summary>
         /// <param name="path">The path of the file within the working directory.</param>
         /// <param name="explicitPathsOptions">
         /// If set, the passed <paramref name="path"/> will be treated as explicit paths.
         /// Use these options to determine how unmatched explicit paths should be handled.
         /// </param>
-        public virtual void Stage(string path, ExplicitPathsOptions explicitPathsOptions = null)
+        [Obsolete("This will be removed in a future release. Supply ExplicitPathsOptions to StageOptions.")]
+        public virtual void Stage(string path, ExplicitPathsOptions explicitPathsOptions)
+        {
+            Stage(path, new StageOptions { ExplicitPathsOptions = explicitPathsOptions });
+        }
+
+        /// <summary>
+        /// Promotes to the staging area the latest modifications of a file in the working directory (addition, updation or removal).
+        /// 
+        /// If this path is ignored by configuration then it will not be staged unless <see cref="StageOptions.IncludeIgnored"/> is unset.
+        /// </summary>
+        /// <param name="path">The path of the file within the working directory.</param>
+        /// <param name="stageOptions">If set, determines how paths will be staged.</param>
+        public virtual void Stage(string path, StageOptions stageOptions = null)
         {
             Ensure.ArgumentNotNull(path, "path");
 
-            Stage(new[] { path }, explicitPathsOptions);
+            Stage(new[] { path }, stageOptions);
         }
 
         /// <summary>
         /// Promotes to the staging area the latest modifications of a collection of files in the working directory (addition, updation or removal).
+        /// 
+        /// Any paths (even those listed explicitly) that are ignored by configuration will not be staged.
         /// </summary>
         /// <param name="paths">The collection of paths of the files within the working directory.</param>
         /// <param name="explicitPathsOptions">
         /// If set, the passed <paramref name="paths"/> will be treated as explicit paths.
         /// Use these options to determine how unmatched explicit paths should be handled.
         /// </param>
-        public virtual void Stage(IEnumerable<string> paths, ExplicitPathsOptions explicitPathsOptions = null)
+        [Obsolete("This will be removed in a future release. Supply ExplicitPathsOptions to StageOptions.")]
+        public virtual void Stage(IEnumerable<string> paths, ExplicitPathsOptions explicitPathsOptions)
+        {
+            Stage(paths, new StageOptions { ExplicitPathsOptions = explicitPathsOptions });
+        }
+
+        /// <summary>
+        /// Promotes to the staging area the latest modifications of a collection of files in the working directory (addition, updation or removal).
+        /// 
+        /// Any paths (even those listed explicitly) that are ignored by configuration will not be staged unless <see cref="StageOptions.IncludeIgnored"/> is unset.
+        /// </summary>
+        /// <param name="paths">The collection of paths of the files within the working directory.</param>
+        /// <param name="stageOptions">If set, determines how paths will be staged.</param>
+        public virtual void Stage(IEnumerable<string> paths, StageOptions stageOptions = null)
         {
             Ensure.ArgumentNotNull(paths, "paths");
 
-            var changes = repo.Diff.Compare<TreeChanges>(DiffModifiers.IncludeUntracked | DiffModifiers.IncludeIgnored, paths, explicitPathsOptions);
+            DiffModifiers diffModifiers = DiffModifiers.IncludeUntracked;
+            ExplicitPathsOptions explicitPathsOptions = stageOptions != null ? stageOptions.ExplicitPathsOptions : null;
+
+            if (stageOptions != null && stageOptions.IncludeIgnored)
+            {
+                diffModifiers |= DiffModifiers.IncludeIgnored;
+            }
+
+            var changes = repo.Diff.Compare<TreeChanges>(diffModifiers, paths, explicitPathsOptions);
 
             foreach (var treeEntryChanges in changes)
             {

LibGit2Sharp/LibGit2Sharp.csproj

@@ -132,6 +132,7 @@
     <Compile Include="RevertResult.cs" />
     <Compile Include="SignatureExtensions.cs" />
     <Compile Include="RevertOptions.cs" />
+    <Compile Include="StageOptions.cs" />
     <Compile Include="StatusOptions.cs" />
     <Compile Include="SimilarityOptions.cs" />
     <Compile Include="UnbornBranchException.cs" />
@@ -351,4 +352,4 @@
     </CreateItem>
     <Copy SourceFiles="@(NativeBinaries)" DestinationFiles="@(NativeBinaries->'$(OutputPath)NativeBinaries\%(RecursiveDir)%(Filename)%(Extension)')" SkipUnchangedFiles="true" />
   </Target>
-</Project>
+</Project>

LibGit2Sharp/StageOptions.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// Options to define file staging behavior.
+    /// </summary>
+    public sealed class StageOptions
+    {
+        /// <summary>
+        /// Stage ignored files. (Default = false)
+        /// </summary>
+        public bool IncludeIgnored { get; set; }
+
+        /// <summary>
+        /// If set, the passed paths will be treated as explicit paths.
+        /// Use these options to determine how unmatched explicit paths
+        /// should be handled. (Default = null)
+        /// </summary>
+        public ExplicitPathsOptions ExplicitPathsOptions { get; set; }
+    }
+}