Cache implementation

Source/SwiftLintFramework/Models/Configuration.swift

@@ -35,6 +35,7 @@ private enum ConfigurationKey: String {
     case swiftlintVersion = "swiftlint_version"
     case useNestedConfigs = "use_nested_configs" // deprecated
     case warningThreshold = "warning_threshold"
+    case cachePath = "cache_path"
     case whitelistRules = "whitelist_rules"
 }
 
@@ -47,6 +48,8 @@ public struct Configuration: Equatable {
     public let rules: [Rule]
     public var rootPath: String?              // the root path to search for nested configurations
     public var configurationPath: String?     // if successfully loaded from a path
+    public var hash: Int?
+    public let cachePath: String?
 
     public init?(disabledRules: [String] = [],
                  optInRules: [String] = [],
@@ -57,7 +60,8 @@ public struct Configuration: Equatable {
                  reporter: String = XcodeReporter.identifier,
                  ruleList: RuleList = masterRuleList,
                  configuredRules: [Rule]? = nil,
-                 swiftlintVersion: String? = nil) {
+                 swiftlintVersion: String? = nil,
+                 cachePath: String? = nil) {
 
         if let pinnedVersion = swiftlintVersion, pinnedVersion != Version.current.value {
             queuedPrintError("Currently running SwiftLint \(Version.current.value) but " +
@@ -67,6 +71,7 @@ public struct Configuration: Equatable {
         self.included = included
         self.excluded = excluded
         self.reporter = reporter
+        self.cachePath = cachePath
 
         let configuredRules = configuredRules
             ?? (try? ruleList.configuredRules(with: [:]))
@@ -156,7 +161,8 @@ public struct Configuration: Equatable {
                     XcodeReporter.identifier,
                   ruleList: ruleList,
                   configuredRules: configuredRules,
-                  swiftlintVersion: dict[ConfigurationKey.swiftlintVersion.rawValue] as? String)
+                  swiftlintVersion: dict[ConfigurationKey.swiftlintVersion.rawValue] as? String,
+                  cachePath: dict[ConfigurationKey.cachePath.rawValue] as? String)
     }
 
     public init(path: String = Configuration.fileName, rootPath: String? = nil,
@@ -179,6 +185,7 @@ public struct Configuration: Equatable {
             }
             self.init(dict: dict)!
             configurationPath = fullPath
+            hash = yamlContents.hash
             self.rootPath = rootPath
             return
         } catch YamlParserError.yamlParsing(let message) {
@@ -265,7 +272,8 @@ private func validKeys(ruleList: RuleList) -> [String] {
         .swiftlintVersion,
         .useNestedConfigs,
         .warningThreshold,
-        .whitelistRules
+        .whitelistRules,
+        .cachePath
     ].map({ $0.rawValue }) + ruleList.allValidIdentifiers()
 }
 

Source/SwiftLintFramework/Models/Linter.swift

@@ -54,6 +54,7 @@ extension Rule {
 public struct Linter {
     public let file: File
     private let rules: [Rule]
+    private let cache: LinterCache?
 
     public var styleViolations: [StyleViolation] {
         return getStyleViolations().0
@@ -64,6 +65,11 @@ public struct Linter {
     }
 
     private func getStyleViolations(_ benchmark: Bool = false) -> ([StyleViolation], [(id: String, time: Double)]) {
+
+        if let cached = cachedStyleViolations(benchmark) {
+            return cached
+        }
+
         if file.sourcekitdFailed {
             queuedPrintError("Most rules will be skipped because sourcekitd has failed.")
         }
@@ -78,6 +84,11 @@ public struct Linter {
             deprecatedToValidIdentifier[key] = value
         }
 
+        if let cache = cache, let file = file.path {
+            let hash = self.file.contents.hash
+            cache.cacheFile(file, violations: violations, hash: hash)
+        }
+
         for (deprecatedIdentifier, identifier) in deprecatedToValidIdentifier {
             queuedPrintError("'\(deprecatedIdentifier)' rule has been renamed to '\(identifier)' and will be " +
                 "completely removed in a future release.")
@@ -86,8 +97,34 @@ public struct Linter {
         return (violations, ruleTimes)
     }
 
-    public init(file: File, configuration: Configuration = Configuration()!) {
+    private func cachedStyleViolations(_ benchmark: Bool = false) -> ([StyleViolation], [(id: String, time: Double)])? {
+        let start: Date! = benchmark ? Date() : nil
+        guard let cache = cache,
+            let file = file.path,
+            case let hash = self.file.contents.hash,
+            let cachedViolations = cache.violations(for: file, hash: hash) else {
+                return nil
+        }
+
+        var ruleTimes = [(id: String, time: Double)]()
+        if benchmark {
+            // let's assume that all rules should have the same duration and split the duration among them
+            let totalTime = -start.timeIntervalSinceNow
+            let fractionedTime = totalTime / TimeInterval(rules.count)
+            ruleTimes = rules.flatMap { rule in
+                let id = type(of: rule).description.identifier
+                return (id, fractionedTime)
+            }
+        }
+
+        return (cachedViolations, ruleTimes)
+    }
+
+    public init(file: File,
+                configuration: Configuration = Configuration()!,
+                cache: LinterCache? = nil) {
         self.file = file
+        self.cache = cache
         rules = configuration.rules
     }
 

Source/SwiftLintFramework/Models/LinterCache.swift

@@ -0,0 +1,125 @@
+//
+//  LinterCache.swift
+//  SwiftLint
+//
+//  Created by Marcelo Fabri on 12/27/16.
+//  Copyright © 2016 Realm. All rights reserved.
+//
+
+import Foundation
+import SourceKittenFramework
+
+public enum LinterCacheError: Error {
+    case invalidFormat
+    case differentVersion
+    case differentConfiguration
+}
+
+public final class LinterCache {
+    private var cache: [String: Any]
+    private let lock = NSLock()
+
+    public init(currentVersion: Version = .current, configurationHash: Int? = nil) {
+        cache = [String: Any]()
+        cache["version"] = currentVersion.value
+        cache["configuration_hash"] = configurationHash
+        cache["files"] = [:]
+    }
+
+    public init(cache: Any, currentVersion: Version = .current, configurationHash: Int? = nil) throws {
+        guard let dictionary = cache as? [String: Any] else {
+            throw LinterCacheError.invalidFormat
+        }
+
+        guard let version = dictionary["version"] as? String, version == currentVersion.value else {
+            throw LinterCacheError.differentVersion
+        }
+
+        if dictionary["configuration_hash"] as? Int != configurationHash {
+            throw LinterCacheError.differentConfiguration
+        }
+
+        self.cache = dictionary
+    }
+
+    public convenience init(contentsOf url: URL, currentVersion: Version = .current,
+                            configurationHash: Int? = nil) throws {
+        let data = try Data(contentsOf: url)
+        let json = try JSONSerialization.jsonObject(with: data, options: [])
+        try self.init(cache: json, currentVersion: currentVersion,
+                      configurationHash: configurationHash)
+    }
+
+    public func cacheFile(_ file: String, violations: [StyleViolation], hash: Int) {
+        var entry = [String: Any]()
+        var fileViolations = entry["violations"] as? [[String: Any]] ?? []
+
+        for violation in violations {
+            fileViolations.append(dictionaryForViolation(violation))
+        }
+
+        entry["violations"] = fileViolations
+        entry["hash"] = hash
+
+        lock.lock()
+        var filesCache = (cache["files"] as? [String: Any]) ?? [:]
+        filesCache[file] = entry
+        cache["files"] = filesCache
+        lock.unlock()
+    }
+
+    public func violations(for file: String, hash: Int) -> [StyleViolation]? {
+        lock.lock()
+
+        guard let filesCache = cache["files"] as? [String: Any],
+            let entry = filesCache[file] as? [String: Any],
+            let cacheHash = entry["hash"] as? Int,
+            cacheHash == hash,
+            let violations = entry["violations"] as? [[String: Any]] else {
+                lock.unlock()
+                return nil
+        }
+
+        lock.unlock()
+        return violations.flatMap { StyleViolation.fromCache($0, file: file) }
+    }
+
+    public func save(to url: URL) throws {
+        lock.lock()
+        let json = toJSON(cache)
+        lock.unlock()
+        try json.write(to: url, atomically: true, encoding: .utf8)
+    }
+
+    private func dictionaryForViolation(_ violation: StyleViolation) -> [String: Any] {
+        return [
+            "line": violation.location.line ?? NSNull() as Any,
+            "character": violation.location.character ?? NSNull() as Any,
+            "severity": violation.severity.rawValue,
+            "type": violation.ruleDescription.name,
+            "rule_id": violation.ruleDescription.identifier,
+            "reason": violation.reason
+        ]
+    }
+}
+
+extension StyleViolation {
+    fileprivate static func fromCache(_ cache: [String: Any], file: String) -> StyleViolation? {
+        guard let severity = (cache["severity"] as? String).flatMap({ ViolationSeverity(rawValue: $0) }),
+            let name = cache["type"] as? String,
+            let ruleId = cache["rule_id"] as? String,
+            let reason = cache["reason"] as? String else {
+                return nil
+        }
+
+        let line = cache["line"] as? Int
+        let character = cache["character"] as? Int
+
+        let ruleDescription = RuleDescription(identifier: ruleId, name: name, description: reason)
+        let location = Location(file: file, line: line, character: character)
+        let violation = StyleViolation(ruleDescription: ruleDescription, severity: severity,
+                                       location: location, reason: reason)
+
+        return violation
+    }
+}

Source/swiftlint/Commands/LintCommand.swift

@@ -23,8 +23,9 @@ struct LintCommand: CommandProtocol {
         var violations = [StyleViolation]()
         let configuration = Configuration(options: options)
         let reporter = reporterFrom(options: options, configuration: configuration)
+        let cache = LinterCache.makeCache(options: options, configuration: configuration)
         let visitorMutationQueue = DispatchQueue(label: "io.realm.swiftlint.lintVisitorMutation")
-        return configuration.visitLintableFiles(options) { linter in
+        return configuration.visitLintableFiles(options, cache: cache) { linter in
             let currentViolations: [StyleViolation]
             if options.benchmark {
                 let start = Date()
@@ -58,6 +59,9 @@ struct LintCommand: CommandProtocol {
                 fileBenchmark.save()
                 ruleBenchmark.save()
             }
+
+            cache?.save(options: options, configuration: configuration)
+
             return LintCommand.successOrExit(numberOfSeriousViolations: numberOfSeriousViolations,
                                              strictWithViolations: options.strict && !violations.isEmpty)
         }
@@ -113,12 +117,14 @@ struct LintOptions: OptionsProtocol {
     let benchmark: Bool
     let reporter: String
     let quiet: Bool
+    let cachePath: String
+    let ignoreCache: Bool
 
     // swiftlint:disable line_length
-    static func create(_ path: String) -> (_ useSTDIN: Bool) -> (_ configurationFile: String) -> (_ strict: Bool) -> (_ useScriptInputFiles: Bool) -> (_ benchmark: Bool) -> (_ reporter: String) -> (_ quiet: Bool) -> LintOptions {
-        return { useSTDIN in { configurationFile in { strict in { useScriptInputFiles in { benchmark in { reporter in { quiet in
-            self.init(path: path, useSTDIN: useSTDIN, configurationFile: configurationFile, strict: strict, useScriptInputFiles: useScriptInputFiles, benchmark: benchmark, reporter: reporter, quiet: quiet)
-        }}}}}}}
+    static func create(_ path: String) -> (_ useSTDIN: Bool) -> (_ configurationFile: String) -> (_ strict: Bool) -> (_ useScriptInputFiles: Bool) -> (_ benchmark: Bool) -> (_ reporter: String) -> (_ quiet: Bool) -> (_ cachePath: String) -> (_ ignoreCache: Bool) -> LintOptions {
+        return { useSTDIN in { configurationFile in { strict in { useScriptInputFiles in { benchmark in { reporter in { quiet in { cachePath in { ignoreCache in
+            self.init(path: path, useSTDIN: useSTDIN, configurationFile: configurationFile, strict: strict, useScriptInputFiles: useScriptInputFiles, benchmark: benchmark, reporter: reporter, quiet: quiet, cachePath: cachePath, ignoreCache: ignoreCache)
+        }}}}}}}}}
     }
 
     static func evaluate(_ mode: CommandMode) -> Result<LintOptions, CommandantError<CommandantError<()>>> {
@@ -137,5 +143,9 @@ struct LintOptions: OptionsProtocol {
             <*> mode <| Option(key: "reporter", defaultValue: "",
                                usage: "the reporter used to log errors and warnings")
             <*> mode <| quietOption(action: "linting")
+            <*> mode <| Option(key: "cache-path", defaultValue: "",
+                               usage: "the location of the cache used when linting")
+            <*> mode <| Option(key: "no-cache", defaultValue: false,
+                               usage: "ignore cache when linting")
     }
 }

Source/swiftlint/Extensions/Configuration+CommandLine.swift

@@ -67,7 +67,8 @@ extension Configuration {
     }
 
     func visitLintableFiles(_ path: String, action: String, useSTDIN: Bool = false,
-                            quiet: Bool = false, useScriptInputFiles: Bool, parallel: Bool = false,
+                            quiet: Bool = false, useScriptInputFiles: Bool,
+                            cache: LinterCache? = nil, parallel: Bool = false,
                             visitorBlock: @escaping (Linter) -> Void) -> Result<[File], CommandantError<()>> {
         return getFiles(path, action: action, useSTDIN: useSTDIN, quiet: quiet,
                         useScriptInputFiles: useScriptInputFiles)
@@ -95,7 +96,7 @@ extension Configuration {
                     }
                 }
                 autoreleasepool {
-                    visitorBlock(Linter(file: file, configuration: self.configurationForFile(file)))
+                    visitorBlock(Linter(file: file, configuration: self.configurationForFile(file), cache: cache))
                 }
             }
             if parallel {
@@ -133,10 +134,10 @@ extension Configuration {
         self.init(commandLinePath: options.configurationFile, rootPath: options.path, quiet: options.quiet)
     }
 
-    func visitLintableFiles(_ options: LintOptions, visitorBlock: @escaping (Linter) -> Void) ->
-                            Result<[File], CommandantError<()>> {
+    func visitLintableFiles(_ options: LintOptions, cache: LinterCache? = nil,
+                            visitorBlock: @escaping (Linter) -> Void) -> Result<[File], CommandantError<()>> {
         return visitLintableFiles(options.path, action: "Linting", useSTDIN: options.useSTDIN, quiet: options.quiet,
-                                  useScriptInputFiles: options.useScriptInputFiles, parallel: true,
-                                  visitorBlock: visitorBlock)
+                                  useScriptInputFiles: options.useScriptInputFiles, cache: cache,
+                                  parallel: true, visitorBlock: visitorBlock)
     }
 }