Support redirecting the config search path.

Allow getting/setting the global/system/XDG config search path using
Configuration.GetSearchPath Configuration.SetSearchPath.

This is useful for libgit2sharp consumers who are writing unit tests that want
to 'fake' a global config.

While the config search path can be changed using the RepositoryOptions, this
requires that every function you test would need to accept a config path
argument. Changing the search path at the library level ensures that all config
access is redirected.

This is how the libgit2 config tests work; see the initialization of
tests/config/global.c for an example.

Author: Ryan Roden-Corrent

LibGit2Sharp.Tests/ConfigurationFixture.cs

@@ -409,5 +409,94 @@ public void PassingANonExistingLocalConfigurationFileToBuildFromthrowss()
             Assert.Throws<FileNotFoundException>(() => Configuration.BuildFrom(
                 Path.Combine(Path.GetTempPath(), Path.GetRandomFileName())));
         }
+
+        [Fact]
+        public void CanSetAndGetSearchPath()
+        {
+            string globalPath = Path.Combine(Constants.TemporaryReposPath, Path.GetRandomFileName());
+            string systemPath = Path.Combine(Constants.TemporaryReposPath, Path.GetRandomFileName());
+            string xdgPath    = Path.Combine(Constants.TemporaryReposPath, Path.GetRandomFileName());
+
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.Global, globalPath);
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.System, systemPath);
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.Xdg,    xdgPath);
+
+            Assert.Equal(globalPath, GlobalSettings.GetConfigSearchPaths(ConfigurationLevel.Global).Single());
+            Assert.Equal(systemPath, GlobalSettings.GetConfigSearchPaths(ConfigurationLevel.System).Single());
+            Assert.Equal(xdgPath,    GlobalSettings.GetConfigSearchPaths(ConfigurationLevel.Xdg).Single());
+
+            // reset the search paths to their defaults
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.Global, null);
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.System, null);
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.Xdg,    null);
+        }
+
+        [Fact]
+        public void CanSetAndGetMultipleSearchPaths()
+        {
+            string[] paths =
+            {
+                Path.Combine(Constants.TemporaryReposPath, Path.GetRandomFileName()),
+                Path.Combine(Constants.TemporaryReposPath, Path.GetRandomFileName()),
+                Path.Combine(Constants.TemporaryReposPath, Path.GetRandomFileName()),
+            };
+
+            GlobalSettings.SetConfigSearchPaths(ConfigurationLevel.Global, paths);
+
+            Assert.Equal(paths, GlobalSettings.GetConfigSearchPaths(ConfigurationLevel.Global));
+
+            // set back to the defaults
+            GlobalSettings.SetConfigSearchPaths(ConfigurationLevel.Global, null);
+        }
+
+        [Fact]
+        public void CanResetSearchPaths()
+        {
+            // set the global search path to its default value
+            GlobalSettings.SetConfigSearchPaths(ConfigurationLevel.Global, null);
+            var oldPaths = GlobalSettings.GetConfigSearchPaths(ConfigurationLevel.Global);
+            Assert.NotNull(oldPaths);
+
+            // change to something other than the default
+            var newPaths = new string[] { Path.Combine(Constants.TemporaryReposPath, Path.GetRandomFileName()) };
+            GlobalSettings.SetConfigSearchPaths(ConfigurationLevel.Global, newPaths);
+            Assert.Equal(newPaths, GlobalSettings.GetConfigSearchPaths(ConfigurationLevel.Global));
+
+            // set it back to the default
+            GlobalSettings.SetConfigSearchPaths(ConfigurationLevel.Global, null);
+            Assert.Equal(oldPaths, GlobalSettings.GetConfigSearchPaths(ConfigurationLevel.Global));
+        }
+
+        [Fact]
+        public void CanRedirectConfigAccess()
+        {
+            var scd1 = BuildSelfCleaningDirectory();
+            var scd2 = BuildSelfCleaningDirectory();
+
+            Touch(scd1.RootedDirectoryPath, ".gitconfig");
+            Touch(scd2.RootedDirectoryPath, ".gitconfig");
+
+            // redirect global access to the first path
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.Global, scd1.RootedDirectoryPath);
+
+            // set a value in the first config
+            using (var config = Configuration.BuildFrom(null))
+            {
+                config.Set("luggage.code", 9876, ConfigurationLevel.Global);
+                Assert.Equal(9876, config.Get<int>("luggage.code", ConfigurationLevel.Global).Value);
+            }
+
+            // redirect global config access to path2
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.Global, scd2.RootedDirectoryPath);
+
+            // if the redirect succeeds, the value set in the prior config should not be visible
+            using (var config = Configuration.BuildFrom(null))
+            {
+                Assert.Equal(-1, config.GetValueOrDefault<int>("luggage.code", ConfigurationLevel.Global, -1));
+            }
+
+            // reset the search path to the default
+            GlobalSettings.SetConfigSearchPath(ConfigurationLevel.Global, null);
+        }
     }
 }

LibGit2Sharp/Core/NativeMethods.cs

@@ -581,6 +581,10 @@ internal static extern int git_filter_unregister(
         [DllImport(libgit2)]
         internal static extern int git_libgit2_features();
 
+        // use __arglist to bind varargs in C#. The C signature is git_libgit2_opts(int option, ...)
+        [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int git_libgit2_opts(int option, __arglist);
+
         [DllImport(libgit2)]
         internal static extern int git_graph_ahead_behind(out UIntPtr ahead, out UIntPtr behind, RepositorySafeHandle repo, ref GitOid one, ref GitOid two);
 

LibGit2Sharp/Core/Proxy.cs

@@ -3148,6 +3148,60 @@ public static BuiltInFeatures git_libgit2_features()
             return (BuiltInFeatures)NativeMethods.git_libgit2_features();
         }
 
+        // C# equivalent of libgit2's git_libgit2_opt_t
+        private enum LibGitOption
+        {
+            GetMWindowSize,        // GIT_OPT_GET_MWINDOW_SIZE
+            SetMWindowSize,        // GIT_OPT_SET_MWINDOW_SIZE
+            GetMWindowMappedLimit, // GIT_OPT_GET_MWINDOW_MAPPED_LIMIT
+            SetMWindowMappedLimit, // GIT_OPT_SET_MWINDOW_MAPPED_LIMIT
+            GetSearchPath,         // GIT_OPT_GET_SEARCH_PATH
+            SetSearchPath,         // GIT_OPT_SET_SEARCH_PATH
+            SetCacheObjectLimit,   // GIT_OPT_SET_CACHE_OBJECT_LIMIT
+            SetCacheMaxSize,       // GIT_OPT_SET_CACHE_MAX_SIZE
+            EnableCaching,         // GIT_OPT_ENABLE_CACHING
+            GetCachedMemory,       // GIT_OPT_GET_CACHED_MEMORY
+            GetTemplatePath,       // GIT_OPT_GET_TEMPLATE_PATH
+            SetTemplatePath,       // GIT_OPT_SET_TEMPLATE_PATH
+            SetSslCertLocations,   // GIT_OPT_SET_SSL_CERT_LOCATIONS
+        }
+
+        /// <summary>
+        /// Get the paths under which libgit2 searches for the configuration file of a given level.
+        /// </summary>
+        /// <param name="level">The level (global/system/XDG) of the config.</param>
+        /// <returns>
+        ///     The paths delimited by 'GIT_PATH_LIST_SEPARATOR' (<see cref="GlobalSettings.PathListSeparator"/>).
+        /// </returns>
+        public static string git_libgit2_opts_get_search_path(ConfigurationLevel level)
+        {
+            string path;
+
+            using (var buf = new GitBuf())
+            {
+                var res = NativeMethods.git_libgit2_opts((int)LibGitOption.GetSearchPath, __arglist((uint)level, buf));
+                Ensure.ZeroResult(res);
+
+                path = LaxUtf8Marshaler.FromNative(buf.ptr) ?? string.Empty;
+            }
+
+            return path;
+        }
+
+        /// <summary>
+        /// Set the path(s) under which libgit2 searches for the configuration file of a given level.
+        /// </summary>
+        /// <param name="level">The level (global/system/XDG) of the config.</param>
+        /// <param name="path">
+        ///     A string of paths delimited by 'GIT_PATH_LIST_SEPARATOR' (<see cref="GlobalSettings.PathListSeparator"/>).
+        ///     Pass null to reset the search path to the default.
+        /// </param>
+        public static void git_libgit2_opts_set_search_path(ConfigurationLevel level, string path)
+        {
+            var res = NativeMethods.git_libgit2_opts((int)LibGitOption.SetSearchPath, __arglist((uint)level, path));
+            Ensure.ZeroResult(res);
+        }
+
         #endregion
 
         private static ICollection<TResult> git_foreach<T, TResult>(

LibGit2Sharp/GlobalSettings.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Reflection;
+using System.Collections.Generic;
 using LibGit2Sharp.Core;
 
 namespace LibGit2Sharp
@@ -203,5 +204,48 @@ public static void DeregisterFilter(FilterRegistration registration)
             Proxy.git_filter_unregister(registration.Name);
             registration.Free();
         }
+
+        /// <summary>
+        /// The separator used in path list strings (like in the PATH environment variable).
+        /// A semi-colon ";" is used on Windows, and a colon ":" for all other systems.
+        /// </summary>
+        public static char PathListSeparator
+        {
+            get
+            {
+                return (Platform.OperatingSystem == OperatingSystemType.Windows) ? ';' : ':';
+            }
+        }
+
+        /// <summary>
+        /// Get the paths under which libgit2 searches for the configuration file of a given level.
+        /// </summary>
+        /// <param name="level">The level (global/system/XDG) of the config.</param>
+        /// <returns>The paths that are searched</returns>
+        public static IEnumerable<string> GetConfigSearchPaths(ConfigurationLevel level)
+        {
+            return Proxy.git_libgit2_opts_get_search_path(level).Split(PathListSeparator);
+        }
+
+        /// <summary>
+        /// Set the path under which libgit2 searches for the configuration file of a given level.
+        /// </summary>
+        /// <param name="level">The level (global/system/XDG) of the config.</param>
+        /// <param name="path">The new search path, or null to reset to default.</param>
+        public static void SetConfigSearchPath(ConfigurationLevel level, string path)
+        {
+            Proxy.git_libgit2_opts_set_search_path(level, path);
+        }
+
+        /// <summary>
+        /// Set the paths under which libgit2 searches for the configuration file of a given level.
+        /// </summary>
+        /// <param name="level">The level (global/system/XDG) of the config.</param>
+        /// <param name="paths">The new search paths, or null to reset to default.</param>
+        public static void SetConfigSearchPaths(ConfigurationLevel level, IEnumerable<string> paths)
+        {
+            var pathString = (paths == null) ? null : string.Join(PathListSeparator.ToString(), paths);
+            Proxy.git_libgit2_opts_set_search_path(level, pathString);
+        }
     }
 }