Make the repo dir -> project dir mapping in IO operations more transparent

Every time we do an IO operation, we need to convert any relative paths we
have to be based off of the real working directory. That's easier to do with
an NPath object than with a string. This introduces a wrapper object that
does the conversion and passes the call onto IFileSystem, so that NPath
itself doesn't know about it, so it's easier to audit all calls and not miss
any conversions.

Context:
NPath/FileSystem are working under the assumption that the working directory
of the process is the repo root. This is a lie - Unity sets the working dir
to the project path when it loads a project. We lie so it's easier
to spawn our processes from the root of the git repository and to show all
changes, even though they're outside the Unity project path.

Author: shana

src/GitHub.Api/IO/FileSystem.cs

@@ -23,13 +23,11 @@ public interface IFileSystem
         IEnumerable<string> GetDirectories(string path);
         IEnumerable<string> GetDirectories(string path, string pattern);
         IEnumerable<string> GetDirectories(string path, string pattern, SearchOption searchOption);
-        string GetDirectoryName(string path);
         string GetFileNameWithoutExtension(string fileName);
         IEnumerable<string> GetFiles(string path);
         IEnumerable<string> GetFiles(string path, string pattern);
         IEnumerable<string> GetFiles(string path, string pattern, SearchOption searchOption);
         string GetFullPath(string path);
-        string GetParentDirectory(string path);
         string GetRandomFileName();
         string GetTempPath();
         Stream OpenRead(string path);
@@ -53,7 +51,6 @@ public interface IFileSystem
     public class FileSystem : IFileSystem
     {
         private string currentDirectory;
-        private string processDirectory;
 
         public FileSystem()
         { }
@@ -64,7 +61,7 @@ public FileSystem()
         /// <param name="directory">Current directory</param>
         public FileSystem(string directory)
         {
-            processDirectory = currentDirectory = directory;
+            currentDirectory = directory;
         }
 
         public void SetCurrentDirectory(string directory)
@@ -104,11 +101,6 @@ public string GetFullPath(string path)
             return Path.GetFullPath(path);
         }
 
-        public string GetDirectoryName(string path)
-        {
-            return Path.GetDirectoryName(path);
-        }
-
         public bool DirectoryExists(string path)
         {
             return Directory.Exists(path);
@@ -120,11 +112,6 @@ public bool ExistingPathIsDirectory(string path)
             return (attr & FileAttributes.Directory) == FileAttributes.Directory;
         }
 
-        public string GetParentDirectory(string path)
-        {
-            return Directory.GetParent(path).FullName;
-        }
-
         public IEnumerable<string> GetDirectories(string path, string pattern)
         {
             return Directory.GetDirectories(path, pattern);

src/GitHub.Api/IO/NiceIO.cs

@@ -308,7 +308,7 @@ public bool Exists(NPath append)
         public bool DirectoryExists()
         {
             ThrowIfNotInitialized();
-            return FileSystem.DirectoryExists(ToProcessDirectory().ToString());
+            return FSWrapper.DirectoryExists(this);
         }
 
         public bool DirectoryExists(string append)
@@ -324,13 +324,13 @@ public bool DirectoryExists(NPath append)
             ThrowIfNotInitialized();
             if (!append.IsInitialized)
                 return DirectoryExists();
-            return FileSystem.DirectoryExists(Combine(append).ToProcessDirectory().ToString());
+            return FSWrapper.DirectoryExists(Combine(append));
         }
 
         public bool FileExists()
         {
             ThrowIfNotInitialized();
-            return FileSystem.FileExists(ToProcessDirectory().ToString());
+            return FSWrapper.FileExists(this);
         }
 
         public bool FileExists(string append)
@@ -346,7 +346,7 @@ public bool FileExists(NPath append)
             ThrowIfNotInitialized();
             if (!append.IsInitialized)
                 return FileExists();
-            return FileSystem.FileExists(Combine(append).ToProcessDirectory().ToString());
+            return FSWrapper.FileExists(Combine(append));
         }
 
         public string ExtensionWithDot
@@ -535,7 +535,7 @@ public bool IsRoot
 
         public IEnumerable<NPath> Files(string filter, bool recurse = false)
         {
-            return FileSystem.GetFiles(ToProcessDirectory().ToString(), filter, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly).Select(s => new NPath(s));
+            return FSWrapper.GetFiles(this, filter, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly).Select(s => new NPath(s));
         }
 
         public IEnumerable<NPath> Files(bool recurse = false)
@@ -555,7 +555,7 @@ public IEnumerable<NPath> Contents(bool recurse = false)
 
         public IEnumerable<NPath> Directories(string filter, bool recurse = false)
         {
-            return FileSystem.GetDirectories(ToProcessDirectory().ToString(), filter, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly).Select(s => new NPath(s));
+            return FSWrapper.GetDirectories(this, filter, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly).Select(s => new NPath(s));
         }
 
         public IEnumerable<NPath> Directories(bool recurse = false)
@@ -572,7 +572,7 @@ public NPath CreateFile()
             ThrowIfRelative();
             ThrowIfRoot();
             EnsureParentDirectoryExists();
-            FileSystem.WriteAllBytes(ToProcessDirectory().ToString(), new byte[0]);
+            FSWrapper.WriteAllBytes(this, new byte[0]);
             return this;
         }
 
@@ -597,7 +597,7 @@ public NPath CreateDirectory()
             if (IsRoot)
                 throw new NotSupportedException("CreateDirectory is not supported on a root level directory because it would be dangerous:" + ToString());
 
-            FileSystem.DirectoryCreate(ToProcessDirectory().ToString());
+            FSWrapper.DirectoryCreate(this);
             return this;
         }
 
@@ -666,7 +666,7 @@ NPath CopyWithDeterminedDestination(NPath absoluteDestination, Func<NPath, bool>
 
                 absoluteDestination.EnsureParentDirectoryExists();
 
-                FileSystem.FileCopy(ToProcessDirectory().ToString(), absoluteDestination.ToString(), true);
+                FSWrapper.FileCopy(this, absoluteDestination, true);
                 return absoluteDestination;
             }
 
@@ -698,11 +698,11 @@ public void Delete(DeleteMode deleteMode = DeleteMode.Normal)
             {
                 if (isFile)
                 {
-                    FileSystem.FileDelete(ToProcessDirectory().ToString());
+                    FSWrapper.FileDelete(this);
                 }
                 else
                 {
-                    FileSystem.DirectoryDelete(ToProcessDirectory().ToString(), true);
+                    FSWrapper.DirectoryDelete(this, true);
                 }
             }
             catch (IOException)
@@ -797,13 +797,13 @@ public NPath Move(NPath dest)
             {
                 dest.DeleteIfExists();
                 dest.EnsureParentDirectoryExists();
-                FileSystem.FileMove(ToProcessDirectory().ToString(), dest.ToProcessDirectory().ToString());
+                FSWrapper.FileMove(this, dest);
                 return dest;
             }
 
             if (DirectoryExists())
             {
-                FileSystem.DirectoryMove(ToProcessDirectory().ToString(), dest.ToProcessDirectory().ToString());
+                FSWrapper.DirectoryMove(this, dest);
                 return dest;
             }
 
@@ -814,64 +814,64 @@ public NPath WriteAllText(string contents)
         {
             ThrowIfNotInitialized();
             EnsureParentDirectoryExists();
-            FileSystem.WriteAllText(ToProcessDirectory().ToString(), contents);
+            FSWrapper.WriteAllText(this, contents);
             return this;
         }
 
         public string ReadAllText()
         {
             ThrowIfNotInitialized();
-            return FileSystem.ReadAllText(ToProcessDirectory().ToString());
+            return FSWrapper.ReadAllText(this);
         }
 
         public NPath WriteAllText(string contents, Encoding encoding)
         {
             ThrowIfNotInitialized();
             EnsureParentDirectoryExists();
-            FileSystem.WriteAllText(ToProcessDirectory().ToString(), contents, encoding);
+            FSWrapper.WriteAllText(this, contents, encoding);
             return this;
         }
 
         public string ReadAllText(Encoding encoding)
         {
             ThrowIfNotInitialized();
-            return FileSystem.ReadAllText(ToProcessDirectory().ToString(), encoding);
+            return FSWrapper.ReadAllText(this, encoding);
         }
 
         public NPath WriteLines(string[] contents)
         {
             ThrowIfNotInitialized();
             EnsureParentDirectoryExists();
-            FileSystem.WriteLines(ToProcessDirectory().ToString(), contents);
+            FSWrapper.WriteLines(this, contents);
             return this;
         }
 
         public NPath WriteAllLines(string[] contents)
         {
             ThrowIfNotInitialized();
             EnsureParentDirectoryExists();
-            FileSystem.WriteAllLines(ToProcessDirectory().ToString(), contents);
+            FSWrapper.WriteAllLines(this, contents);
             return this;
         }
 
         public string[] ReadAllLines()
         {
             ThrowIfNotInitialized();
-            return FileSystem.ReadAllLines(ToProcessDirectory().ToString());
+            return FSWrapper.ReadAllLines(this);
         }
 
         public NPath WriteAllBytes(byte[] contents)
         {
             ThrowIfNotInitialized();
             EnsureParentDirectoryExists();
-            FileSystem.WriteAllBytes(ToProcessDirectory().ToString(), contents);
+            FSWrapper.WriteAllBytes(this, contents);
             return this;
         }
 
         public byte[] ReadAllBytes()
         {
             ThrowIfNotInitialized();
-            return FileSystem.ReadAllBytes(ToProcessDirectory().ToString());
+            return FSWrapper.ReadAllBytes(this);
         }
 
 
@@ -1100,18 +1100,21 @@ public static IFileSystem FileSystem
             {
                 if (_fileSystem == null)
 #if UNITY_4 || UNITY_5 || UNITY_5_3_OR_NEWER
-                    _fileSystem = new FileSystem(UnityEngine.Application.dataPath);
+                    FileSystem = new FileSystem(UnityEngine.Application.dataPath);
 #else
-                    _fileSystem = new FileSystem(Directory.GetCurrentDirectory());
+                    FileSystem = new FileSystem(Directory.GetCurrentDirectory());
 #endif
                 return _fileSystem;
             }
             set
             {
                 _fileSystem = value;
+                FSWrapper = new FSWrapper(value);
             }
         }
 
+        private static FSWrapper FSWrapper { get; set; }
+
         private static bool? _isUnix;
         internal static bool IsUnix
         {
@@ -1228,4 +1231,122 @@ public enum DeleteMode
         Normal,
         Soft
     }
+
+
+    class FSWrapper
+    {
+        private readonly IFileSystem fileSystem;
+
+        public FSWrapper(IFileSystem fileSystem)
+        {
+            this.fileSystem = fileSystem;
+        }
+
+        public void DirectoryCreate(NPath path)
+        {
+            fileSystem.DirectoryCreate(path.ToProcessDirectory().ToString());
+        }
+
+        public void DirectoryDelete(NPath path, bool recursive)
+        {
+            fileSystem.DirectoryDelete(path.ToProcessDirectory().ToString(), recursive);
+        }
+
+        public bool DirectoryExists(NPath path)
+        {
+            return fileSystem.DirectoryExists(path.ToProcessDirectory().ToString());
+        }
+        public void DirectoryMove(NPath from, NPath to)
+        {
+            fileSystem.DirectoryMove(from.ToProcessDirectory().ToString(), to.ToProcessDirectory().ToString());
+        }
+        public bool ExistingPathIsDirectory(NPath path)
+        {
+            return fileSystem.ExistingPathIsDirectory(path.ToProcessDirectory().ToString());
+        }
+        public void FileCopy(NPath from, NPath to, bool overwrite)
+        {
+            fileSystem.FileCopy(from.ToProcessDirectory().ToString(), to.ToProcessDirectory().ToString(), overwrite);
+        }
+        public void FileDelete(NPath path)
+        {
+            fileSystem.FileDelete(path.ToProcessDirectory().ToString());
+        }
+        public bool FileExists(NPath path)
+        {
+            return fileSystem.FileExists(path.ToProcessDirectory().ToString());
+        }
+        public void FileMove(NPath from, NPath to)
+        {
+            fileSystem.FileMove(from.ToProcessDirectory().ToString(), to.ToProcessDirectory().ToString());
+        }
+        public IEnumerable<string> GetDirectories(NPath path)
+        {
+            return fileSystem.GetDirectories(path.ToProcessDirectory().ToString());
+        }
+        public IEnumerable<string> GetDirectories(NPath path, string pattern)
+        {
+            return fileSystem.GetDirectories(path.ToProcessDirectory().ToString(), pattern);
+        }
+        public IEnumerable<string> GetDirectories(NPath path, string pattern, SearchOption searchOption)
+        {
+            return fileSystem.GetDirectories(path.ToProcessDirectory().ToString(), pattern, searchOption);
+        }
+        public IEnumerable<string> GetFiles(NPath path)
+        {
+            return fileSystem.GetFiles(path.ToProcessDirectory().ToString());
+        }
+        public IEnumerable<string> GetFiles(NPath path, string pattern)
+        {
+            return fileSystem.GetFiles(path.ToProcessDirectory().ToString(), pattern);
+        }
+        public IEnumerable<string> GetFiles(NPath path, string pattern, SearchOption searchOption)
+        {
+            return fileSystem.GetFiles(path.ToProcessDirectory().ToString(), pattern, searchOption);
+        }
+        public Stream OpenRead(NPath path)
+        {
+            return fileSystem.OpenRead(path.ToProcessDirectory().ToString());
+        }
+        public Stream OpenWrite(NPath path, FileMode mode)
+        {
+            return fileSystem.OpenWrite(path.ToProcessDirectory().ToString(), mode);
+        }
+        public byte[] ReadAllBytes(NPath path)
+        {
+            return fileSystem.ReadAllBytes(path.ToProcessDirectory().ToString());
+        }
+        public string[] ReadAllLines(NPath path)
+        {
+            return fileSystem.ReadAllLines(path.ToProcessDirectory().ToString());
+        }
+        public string ReadAllText(NPath path)
+        {
+            return fileSystem.ReadAllText(path.ToProcessDirectory().ToString());
+        }
+        public string ReadAllText(NPath path, Encoding encoding)
+        {
+            return fileSystem.ReadAllText(path.ToProcessDirectory().ToString(), encoding);
+        }
+        public void WriteAllBytes(NPath path, byte[] bytes)
+        {
+            fileSystem.WriteAllBytes(path.ToProcessDirectory().ToString(), bytes);
+        }
+        public void WriteAllLines(NPath path, string[] contents)
+        {
+            fileSystem.WriteAllLines(path.ToProcessDirectory().ToString(), contents);
+        }
+        public void WriteAllText(NPath path, string contents)
+        {
+            fileSystem.WriteAllText(path.ToProcessDirectory().ToString(), contents);
+        }
+        public void WriteAllText(NPath path, string contents, Encoding encoding)
+        {
+            fileSystem.WriteAllText(path.ToProcessDirectory().ToString(), contents, encoding);
+        }
+        public void WriteLines(NPath path, string[] contents)
+        {
+            fileSystem.WriteLines(path.ToProcessDirectory().ToString(), contents);
+        }
+    }
 }

src/tests/IntegrationTests/CachingClasses.cs

@@ -397,6 +397,12 @@ public void UpdateData(IRepositoryInfoCacheData data)
                 isUpdated = true;
             }
 
+            if (currentHead != data.CurrentHead)
+            {
+                currentHead =  data.CurrentHead;
+                isUpdated = true;
+            }
+
             SaveData(now, isUpdated);
         }