Fix hidden folder checking on Unix-based OS

UltraStar Play/Assets/Editor/Tests/DirectoryScannerTest/DirectoryScannerTest.cs

@@ -13,7 +13,7 @@ public void NonRecursive()
     {
         List<string> folders = DirectoryScanner.GetFolders(folderPath,
             new DirectoryScannerConfig() { ExcludeHiddenFolders = false, Recursive = false });
-        Assert.AreEqual(2, folders.Count);
+        Assert.AreEqual(3, folders.Count);
     }
 
     [Test]
@@ -29,15 +29,15 @@ public void Recursive()
     {
         List<string> folders = DirectoryScanner.GetFolders(folderPath,
             new DirectoryScannerConfig() { ExcludeHiddenFolders = false, Recursive = true });
-        Assert.AreEqual(5, folders.Count);
+        Assert.AreEqual(8, folders.Count);
     }
 
     [Test]
     public void RecursiveSearchPattern()
     {
         List<string> folders = DirectoryScanner.GetFolders(folderPath,
             new DirectoryScannerConfig(searchPattern) { ExcludeHiddenFolders = false, Recursive = true });
-        Assert.AreEqual(2, folders.Count);
+        Assert.AreEqual(4, folders.Count);
     }
 
     [Test]
@@ -47,4 +47,28 @@ public void RecursiveExcludeHiddenFolders()
             new DirectoryScannerConfig() { ExcludeHiddenFolders = true, Recursive = true });
         Assert.AreEqual(4, folders.Count);
     }
+
+    [Test]
+    public void RecursiveExcludeHiddenFoldersExtraSlashes()
+    {
+        List<string> folders = DirectoryScanner.GetFolders($"{Application.dataPath}/Editor/Tests//DirectoryScannerTest//",
+            new DirectoryScannerConfig() { ExcludeHiddenFolders = true, Recursive = true });
+        Assert.AreEqual(4, folders.Count);
+    }
+
+    [Test]
+    public void RecursiveDoNotExcludeHiddenFolderBeingScanned()
+    {
+        List<string> folders = DirectoryScanner.GetFolders($"{folderPath}.HiddenFolderC",
+            new DirectoryScannerConfig() { ExcludeHiddenFolders = true, Recursive = true });
+        Assert.AreEqual(2, folders.Count);
+    }
+
+    [Test]
+    public void RecursiveDoNotExcludeHiddenFoldersInParents()
+    {
+        List<string> folders = DirectoryScanner.GetFolders($"{folderPath}.HiddenFolderC/FolderC_A",
+            new DirectoryScannerConfig() { ExcludeHiddenFolders = true, Recursive = true });
+        Assert.AreEqual(1, folders.Count);
+    }
 }

UltraStar Play/Assets/Editor/Tests/FileScannerTest/FileScannerTest.cs

@@ -35,15 +35,15 @@ public void Recursive()
     {
         List<string> files = FileScanner.GetFiles(folderPath,
             new FileScannerConfig(txtFilePattern) { ExcludeHiddenFiles = false, ExcludeHiddenFolders = false, Recursive = true });
-        Assert.AreEqual(6, files.Count);
+        Assert.AreEqual(7, files.Count);
     }
 
     [Test]
     public void RecursiveMultiplePatterns()
     {
         List<string> files = FileScanner.GetFiles(folderPath,
             new FileScannerConfig(patterns) { ExcludeHiddenFiles = false, ExcludeHiddenFolders = false, Recursive = true });
-        Assert.AreEqual(12, files.Count);
+        Assert.AreEqual(14, files.Count);
     }
 
     [Test]
@@ -54,11 +54,35 @@ public void RecursiveExcludeHiddenFolders()
         Assert.AreEqual(4, files.Count);
     }
 
+    [Test]
+    public void RecursiveExcludeHiddenFoldersExtraSlashes()
+    {
+        List<string> files = FileScanner.GetFiles($"{Application.dataPath}/Editor/Tests//FileScannerTest//",
+            new FileScannerConfig(txtFilePattern) { ExcludeHiddenFiles = false, ExcludeHiddenFolders = true, Recursive = true });
+        Assert.AreEqual(4, files.Count);
+    }
+
+    [Test]
+    public void RecursiveDoNotExcludeHiddenFolderBeingScanned()
+    {
+        List<string> files = FileScanner.GetFiles($"{folderPath}.HiddenFolder",
+            new FileScannerConfig(txtFilePattern) { ExcludeHiddenFiles = false, ExcludeHiddenFolders = true, Recursive = true });
+        Assert.AreEqual(3, files.Count);
+    }
+
+    [Test]
+    public void RecursiveDoNotExcludeHiddenFoldersInParents()
+    {
+        List<string> files = FileScanner.GetFiles($"{folderPath}.HiddenFolder/SubfolderInHiddenFolder",
+            new FileScannerConfig(txtFilePattern) { ExcludeHiddenFiles = false, ExcludeHiddenFolders = true, Recursive = true });
+        Assert.AreEqual(1, files.Count);
+    }
+
     [Test]
     public void RecursiveExcludeHiddenFiles()
     {
         List<string> files = FileScanner.GetFiles(folderPath,
             new FileScannerConfig(txtFilePattern) { ExcludeHiddenFiles = true, ExcludeHiddenFolders = false, Recursive = true });
-        Assert.AreEqual(5, files.Count);
+        Assert.AreEqual(6, files.Count);
     }
 }

UltraStar Play/Packages/playshared/Runtime/DirectoryScanner/DirectoryScanner.cs

@@ -37,15 +37,19 @@ public static List<string> GetFolders(string folder, DirectoryScannerConfig conf
 
         List<string> filteredResult = unfilteredResult
             // Ignore hidden folders
-            .Where(folderPath => (!config.ExcludeHiddenFolders || !IsHiddenFolder(folderPath)))
+            .Where(folderPath => (!config.ExcludeHiddenFolders || !IsHiddenFolder(folderPath, folder)))
             .ToList();
 
         return filteredResult;
     }
 
-    private static bool IsHiddenFolder(string folderPath)
+    private static bool IsHiddenFolder(string folderPath, string rootPath)
     {
         // On Unix based operating systems, files and folders that start with a dot are hidden.
-        return folderPath.Contains("\\.") || folderPath.Contains("/.");
+        // Only check for hidden folders that are children of the root path, not the root path
+        // itself or its parents.
+        // We know rootPath is always a prefix of filePath, so it can be cut out with Substring().
+        folderPath = folderPath.Substring(rootPath.Length);
+        return folderPath.StartsWith(".") || folderPath.Contains("\\.") || folderPath.Contains("/.");
     }
 }

UltraStar Play/Packages/playshared/Runtime/FileScanner/FileScanner.cs

@@ -52,7 +52,7 @@ public static List<string> GetFiles(string folder, FileScannerConfig config)
         List<string> filteredResult = unfilteredResult
             // Ignore hidden files and folders
             .Where(filePath => (!config.ExcludeHiddenFiles || !IsHiddenFile(filePath))
-                               && (!config.ExcludeHiddenFolders || !IsInsideHiddenFolder(filePath)))
+                               && (!config.ExcludeHiddenFolders || !IsInsideHiddenFolder(filePath, folder)))
             .ToList();
 
         return filteredResult;
@@ -64,10 +64,15 @@ private static bool IsHiddenFile(string filePath)
         return Path.GetFileName(filePath).StartsWith(".");
     }
 
-    private static bool IsInsideHiddenFolder(string filePath)
+    private static bool IsInsideHiddenFolder(string filePath, string rootPath)
     {
         // On Unix based operating systems, files and folders that start with a dot are hidden.
-        string folderPath = Path.GetDirectoryName(filePath);
-        return folderPath.Contains("\\.") || folderPath.Contains("/.");
+        // Only check for hidden folders that are children of the root path, not the root path
+        // itself or its parents.
+        // We know rootPath is always a prefix of filePath, so it can be cut out with Substring().
+        // We also need to cut out the filename. Path.GetDirectoryName() can not be used here
+        // because it removes duplicate and trailing slashes, changing the string length.
+        string folderPath = filePath.Substring(rootPath.Length, filePath.LastIndexOfAny(new[] { '/', '\\' }) + 1 - rootPath.Length);
+        return folderPath.StartsWith(".") || folderPath.Contains("\\.") || folderPath.Contains("/.");
     }
 }