Collect files with directory enumerator

Author: SimplyDanny

Source/SwiftLintFramework/Configuration+CommandLine.swift

@@ -253,11 +253,8 @@ extension Configuration {
                 return files
             }
             let scriptInputPaths = files.compactMap(\.path)
-            return (
-                visitor.options.useExcludingByPrefix
-                    ? filterExcludedPathsByPrefix(in: scriptInputPaths)
-                    : filterExcludedPaths(in: scriptInputPaths)
-            ).map(SwiftLintFile.init(pathDeferringReading:))
+            return filteredPaths(in: scriptInputPaths, excludeByPrefix: visitor.options.useExcludingByPrefix)
+                .map(SwiftLintFile.init(pathDeferringReading:))
         }
         if !options.quiet {
             let filesInfo: String

Source/SwiftLintFramework/Configuration/Configuration+LintableFiles.swift

@@ -32,65 +32,61 @@ extension Configuration {
     /// - parameter fileManager:     The lintable file manager to use to search for lintable files.
     ///
     /// - returns: Paths for files to lint.
-    internal func lintablePaths(
+    func lintablePaths(
         inPath path: String,
         forceExclude: Bool,
         excludeByPrefix: Bool,
         fileManager: some LintableFileManager = FileManager.default
     ) -> [String] {
+        let excluder = createExcluder(excludeByPrefix: excludeByPrefix)
+
+        // Handle single file path.
         if fileManager.isFile(atPath: path) {
-            let file = fileManager.filesToLint(inPath: path, rootDirectory: nil)
-            if forceExclude {
-                return excludeByPrefix
-                    ? filterExcludedPathsByPrefix(in: file)
-                    : filterExcludedPaths(in: file)
-            }
-            // If path is a file and we're not forcing excludes, skip filtering with excluded/included paths
-            return file
+            return fileManager.filesToLint(
+                inPath: path,
+                rootDirectory: nil,
+                excluder: forceExclude ? excluder : .noExclusion
+            )
         }
 
-        let pathsForPath = includedPaths.isEmpty ? fileManager.filesToLint(inPath: path, rootDirectory: nil) : []
-        let includedPaths = self.includedPaths
-            .flatMap(Glob.resolveGlob)
-            .parallelFlatMap { fileManager.filesToLint(inPath: $0, rootDirectory: rootDirectory) }
+        // With no included paths, we lint everything in the given path.
+        if includedPaths.isEmpty {
+            return fileManager.filesToLint(
+                inPath: path,
+                rootDirectory: nil,
+                excluder: excluder
+            )
+        }
 
-        return excludeByPrefix
-            ? filterExcludedPathsByPrefix(in: pathsForPath + includedPaths)
-            : filterExcludedPaths(in: pathsForPath + includedPaths)
+        // With included paths, we only lint those paths (after resolving globs).
+        return includedPaths
+            .flatMap(Glob.resolveGlob)
+            .parallelFlatMap {
+                fileManager.filesToLint(
+                    inPath: $0,
+                    rootDirectory: rootDirectory,
+                    excluder: excluder
+                )
+            }
     }
 
-    /// Returns an array of file paths after removing the excluded paths as defined by this configuration.
-    ///
-    /// - parameter paths: The input paths to filter.
-    ///
-    /// - returns: The input paths after removing the excluded paths.
-    public func filterExcludedPaths(in paths: [String]) -> [String] {
-        #if os(Linux)
-        let result = NSMutableOrderedSet(capacity: paths.count)
-        result.addObjects(from: paths)
-        #else
-        let result = NSOrderedSet(array: paths)
-        #endif
-        let exclusionPatterns = self.excludedPaths.flatMap {
-            Glob.createFilenameMatchers(root: rootDirectory, pattern: $0)
-        }
-        return result.array
-            .parallelCompactMap { exclusionPatterns.anyMatch(filename: $0 as! String) ? nil : $0 as? String }
-            // swiftlint:disable:previous force_cast
+    func filteredPaths(in paths: [String], excludeByPrefix: Bool) -> [String] {
+        let excluder = createExcluder(excludeByPrefix: excludeByPrefix)
+        return paths.filter { !excluder.excludes(path: $0) }
     }
 
-    /// Returns the file paths that are excluded by this configuration using filtering by absolute path prefix.
-    ///
-    /// For cases when excluded directories contain many lintable files (e. g. Pods) it works faster than default
-    /// algorithm `filterExcludedPaths`.
-    ///
-    /// - returns: The input paths after removing the excluded paths.
-    public func filterExcludedPathsByPrefix(in paths: [String]) -> [String] {
-        let excludedPaths = self.excludedPaths
-            .parallelFlatMap { Glob.resolveGlob($0) }
-            .map { $0.absolutePathStandardized() }
-        return paths.filter { path in
-            !excludedPaths.contains { path.hasPrefix($0) }
+    private func createExcluder(excludeByPrefix: Bool) -> Excluder {
+        if excludeByPrefix {
+            return .byPrefix(
+                prefixes: self.excludedPaths
+                    .flatMap { Glob.resolveGlob($0) }
+                    .map { $0.absolutePathStandardized() }
+              )
         }
+        return .matching(
+            matchers: self.excludedPaths.flatMap {
+                Glob.createFilenameMatchers(root: rootDirectory, pattern: $0)
+            }
+        )
     }
 }

Source/SwiftLintFramework/Extensions/FileManager+SwiftLint.swift

@@ -1,17 +1,19 @@
+import FilenameMatcher
 import Foundation
 import SourceKittenFramework
 
 /// An interface for enumerating files that can be linted by SwiftLint.
 public protocol LintableFileManager {
     /// Returns all files that can be linted in the specified path. If the path is relative, it will be appended to the
-    /// specified root path, or currentt working directory if no root directory is specified.
+    /// specified root path, or current working directory if no root directory is specified.
     ///
     /// - parameter path:          The path in which lintable files should be found.
     /// - parameter rootDirectory: The parent directory for the specified path. If none is provided, the current working
     ///                            directory will be used.
+    /// - parameter excluder:     The excluder used to filter out files that should not be linted.
     ///
     /// - returns: Files to lint.
-    func filesToLint(inPath path: String, rootDirectory: String?) -> [String]
+    func filesToLint(inPath path: String, rootDirectory: String?, excluder: Excluder) -> [String]
 
     /// Returns the date when the file at the specified path was last modified. Returns `nil` if the file cannot be
     /// found or its last modification date cannot be determined.
@@ -29,22 +31,56 @@ public protocol LintableFileManager {
     func isFile(atPath path: String) -> Bool
 }
 
+/// An excluder for filtering out files that should not be linted.
+public enum Excluder {
+    /// Full matching excluder using filename matchers.
+    case matching(matchers: [FilenameMatcher])
+    /// Prefix-based excluder using path prefixes.
+    case byPrefix(prefixes: [String])
+    /// An excluder that does not exclude any files.
+    case noExclusion
+
+    func excludes(path: String) -> Bool {
+        switch self {
+        case let .matching(matchers):
+            matchers.contains(where: { $0.match(filename: path) })
+        case let .byPrefix(prefixes):
+            prefixes.contains(where: { path.hasPrefix($0) })
+        case .noExclusion:
+            false
+        }
+    }
+}
+
 extension FileManager: LintableFileManager {
-    public func filesToLint(inPath path: String, rootDirectory: String? = nil) -> [String] {
+    public func filesToLint(inPath path: String,
+                            rootDirectory: String? = nil,
+                            excluder: Excluder) -> [String] {
         let absolutePath = path.bridge()
             .absolutePathRepresentation(rootDirectory: rootDirectory ?? currentDirectoryPath).bridge()
             .standardizingPath
 
-        // if path is a file, it won't be returned in `enumerator(atPath:)`
+        // If path is a file, it won't be returned in `enumerator(atPath:)`.
         if absolutePath.bridge().isSwiftFile(), absolutePath.isFile {
-            return [absolutePath]
+            return excluder.excludes(path: absolutePath) ? [] : [absolutePath]
+        }
+
+        guard let enumerator = enumerator(atPath: absolutePath) else {
+            return []
         }
 
-        return subpaths(atPath: absolutePath)?.parallelCompactMap { element -> String? in
-            guard element.bridge().isSwiftFile() else { return nil }
+        var files = [String]()
+        while let element = enumerator.nextObject() as? String {
             let absoluteElementPath = absolutePath.bridge().appendingPathComponent(element)
-            return absoluteElementPath.isFile ? absoluteElementPath : nil
-        } ?? []
+            if absoluteElementPath.bridge().isSwiftFile(), absoluteElementPath.isFile {
+                if !excluder.excludes(path: absoluteElementPath) {
+                    files.append(absoluteElementPath)
+                }
+            } else if excluder.excludes(path: absoluteElementPath) {
+                enumerator.skipDescendants()
+            }
+        }
+        return files
     }
 
     public func modificationDate(forFileAtPath path: String) -> Date? {

Tests/FileSystemAccessTests/ConfigurationTests+Mock.swift

@@ -33,6 +33,10 @@ internal extension ConfigurationTests {
             static var remoteConfigLocalRef: String { level0.stringByAppendingPathComponent("RemoteConfig/LocalRef") }
             static var remoteConfigCycle: String { level0.stringByAppendingPathComponent("RemoteConfig/Cycle") }
             static var emptyFolder: String { level0.stringByAppendingPathComponent("EmptyFolder") }
+
+            static var exclusionTests: String { testResourcesPath.stringByAppendingPathComponent("ExclusionTests") }
+            static var directory: String { exclusionTests.stringByAppendingPathComponent("directory") }
+            static var directoryExcluded: String { directory.stringByAppendingPathComponent("excluded") }
         }
 
         // MARK: YAML File Paths

Tests/FileSystemAccessTests/ConfigurationTests.swift

@@ -281,85 +281,75 @@ final class ConfigurationTests: SwiftLintTestCase {
         XCTAssertEqual(actualExcludedPath, desiredExcludedPath)
     }
 
-    private class TestFileManager: LintableFileManager {
-        func filesToLint(inPath path: String, rootDirectory _: String? = nil) -> [String] {
-            var filesToLint: [String] = []
-            switch path {
-            case "directory": filesToLint = [
-                "directory/File1.swift",
-                "directory/File2.swift",
-                "directory/excluded/Excluded.swift",
-                "directory/ExcludedFile.swift",
-            ]
-            case "directory/excluded": filesToLint = ["directory/excluded/Excluded.swift"]
-            case "directory/ExcludedFile.swift": filesToLint = ["directory/ExcludedFile.swift"]
-            default: XCTFail("Should not be called with path \(path)")
-            }
-            return filesToLint.absolutePathsStandardized()
-        }
-
-        func modificationDate(forFileAtPath _: String) -> Date? {
-            nil
-        }
-
-        func isFile(atPath path: String) -> Bool {
-            path.hasSuffix(".swift")
-        }
-    }
-
     func testExcludedPaths() {
-        let fileManager = TestFileManager()
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
         let configuration = Configuration(
             includedPaths: ["directory"],
             excludedPaths: ["directory/excluded", "directory/ExcludedFile.swift"]
         )
 
-        let paths = configuration.lintablePaths(inPath: "",
-                                                forceExclude: false,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"].absolutePathsStandardized(), paths)
+        let paths = configuration.lintablePaths(
+            inPath: "",
+            forceExclude: false,
+            excludeByPrefix: false
+        )
+
+        assertEqual(["directory/File1.swift", "directory/File2.swift"], paths)
     }
 
     func testForceExcludesFile() {
-        let fileManager = TestFileManager()
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
         let configuration = Configuration(excludedPaths: ["directory/ExcludedFile.swift"])
-        let paths = configuration.lintablePaths(inPath: "directory/ExcludedFile.swift",
-                                                forceExclude: true,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual([], paths)
+
+        let paths = configuration.lintablePaths(
+            inPath: "directory/ExcludedFile.swift",
+            forceExclude: true,
+            excludeByPrefix: false
+        )
+
+        XCTAssert(paths.isEmpty)
     }
 
     func testForceExcludesFileNotPresentInExcluded() {
-        let fileManager = TestFileManager()
-        let configuration = Configuration(includedPaths: ["directory"],
-                                          excludedPaths: ["directory/ExcludedFile.swift", "directory/excluded"])
-        let paths = configuration.lintablePaths(inPath: "",
-                                                forceExclude: true,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"].absolutePathsStandardized(), paths)
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
+        let configuration = Configuration(
+            includedPaths: ["directory"],
+            excludedPaths: ["directory/ExcludedFile.swift", "directory/excluded"]
+        )
+
+        let paths = configuration.lintablePaths(
+            inPath: "",
+            forceExclude: true,
+            excludeByPrefix: false
+        )
+
+        assertEqual(["directory/File1.swift", "directory/File2.swift"], paths)
     }
 
     func testForceExcludesDirectory() {
-        let fileManager = TestFileManager()
-        let configuration = Configuration(excludedPaths: ["directory/excluded", "directory/ExcludedFile.swift"])
-        let paths = configuration.lintablePaths(inPath: "directory",
-                                                forceExclude: true,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"].absolutePathsStandardized(), paths)
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
+        let configuration = Configuration(excludedPaths: ["directory/excluded"])
+
+        let paths = configuration.lintablePaths(
+            inPath: "directory",
+            forceExclude: true,
+            excludeByPrefix: false
+        )
+
+        assertEqual(["directory/File1.swift", "directory/File2.swift", "directory/ExcludedFile.swift"], paths)
     }
 
     func testForceExcludesDirectoryThatIsNotInExcludedButHasChildrenThatAre() {
-        let fileManager = TestFileManager()
-        let configuration = Configuration(excludedPaths: ["directory/excluded", "directory/ExcludedFile.swift"])
-        let paths = configuration.lintablePaths(inPath: "directory",
-                                                forceExclude: true,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"].absolutePathsStandardized(), paths)
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
+        let configuration = Configuration(excludedPaths: ["directory/ExcludedFile.swift"])
+
+        let paths = configuration.lintablePaths(
+            inPath: "directory",
+            forceExclude: true,
+            excludeByPrefix: false
+        )
+
+        assertEqual(["directory/File1.swift", "directory/File2.swift", "directory/excluded/Excluded.swift"], paths)
     }
 
     func testLintablePaths() {
@@ -621,6 +611,18 @@ extension ConfigurationTests {
         XCTAssertEqual(configuration1.cachePath, "cache/path/1")
         XCTAssertEqual(configuration2.cachePath, "cache/path/1")
     }
+
+    private func assertEqual(_ relativeExpectedPaths: [String],
+                             _ actualPaths: [String],
+                             file: StaticString = #filePath,
+                             line: UInt = #line) {
+        XCTAssertEqual(
+            relativeExpectedPaths.absolutePathsStandardized().sorted(),
+            actualPaths.sorted(),
+            file: file,
+            line: line
+        )
+    }
 }
 
 private extension Sequence where Element == String {

Tests/FileSystemAccessTests/Resources/ExclusionTests/directory/ExcludedFile.swift

@@ -0,0 +1,4 @@
+// Excluded test file
+func excludedFunction() {
+    print("Excluded File")
+}

Tests/FileSystemAccessTests/Resources/ExclusionTests/directory/File1.swift

@@ -0,0 +1,4 @@
+// Test file 1
+func testFunction1() {
+    print("File 1")
+}

Tests/FileSystemAccessTests/Resources/ExclusionTests/directory/File2.swift

@@ -0,0 +1,4 @@
+// Test file 2
+func testFunction2() {
+    print("File 2")
+}

Tests/FileSystemAccessTests/Resources/ExclusionTests/directory/excluded/Excluded.swift

@@ -0,0 +1,4 @@
+// Excluded directory test file
+func excludedDirectoryFunction() {
+    print("Excluded in directory")
+}