Clean swift localizable script

clean_localizable.swift

/// Throws error if ALL localizable files does not have matching keys
///
/// - Parameter files: list of localizable files to validate
func validateMatchKeys(_ files: [LocalizationStringsFile]) {
    print("------------ Validating keys match in all localizable files ------------")
    guard let base = files.first, files.count > 1 else { return }
    let files = Array(files.dropFirst())
    files.forEach {
        guard let extraKey = Set(base.keys).symmetricDifference($0.keys).first else { return }
        let incorrectFile = $0.keys.contains(extraKey) ? $0 : base
        printPretty("error: Found extra key: \(extraKey) in file: \(incorrectFile.path)")
    }
}

/// Throws error if localizable files are missing keys
///
/// - Parameters:
///   - codeFiles: Array of LocalizationCodeFile
///   - localizationFiles: Array of LocalizableStringFiles
func validateMissingKeys(_ codeFiles: [LocalizationCodeFile], localizationFiles: [LocalizationStringsFile]) {
    print("------------ Checking for missing keys -----------")
    guard let baseFile = localizationFiles.first else { fatalError("Could not locate base localization file") }
    let baseKeys = Set(baseFile.keys)
    codeFiles.forEach {
        let extraKeys = $0.keys.subtracting(baseKeys)
        if !extraKeys.isEmpty {
            printPretty("error: Found keys in code: \(extraKeys) from \($0.path), missing in strings file ")
        }
    }
}


/// Throws warning if keys exist in localizable file but are not being used
///
/// - Parameters:
///   - codeFiles: Array of LocalizationCodeFile
///   - localizationFiles: Array of LocalizableStringFiles
func validateDeadKeys(_ codeFiles: [LocalizationCodeFile], localizationFiles: [LocalizationStringsFile]) {
    print("------------ Checking for any dead keys in localizable file -----------")
    guard let baseFile = localizationFiles.first else { fatalError("Could not locate base localization file") }
    let baseKeys = Set(baseFile.keys)
    let allCodeFileKeys = codeFiles.flatMap { $0.keys }
    let deadKeys = baseKeys.subtracting(allCodeFileKeys)
    if !deadKeys.isEmpty {
        printPretty("warning: \(deadKeys) - Suggest cleaning dead keys")
    }
}

/// Parses contents of a file to localizable keys and values - Throws error if localizable file have duplicated keys
///
/// - Parameter path: Localizable file paths
/// - Returns: localizable key and value for content at path
static func parse(_ path: String) -> [String: String] {
    let content = contents(atPath: path)
    let trimmed = content
        .replacingOccurrences(of: "\n+", with: "", options: .regularExpression, range: nil)
        .trimmingCharacters(in: .whitespacesAndNewlines)
    let keys = regexFor("\"([^\"]*?)\"(?= =)", content: trimmed)
    let values = regexFor("(?<== )\"(.*?)\"(?=;)", content: trimmed)
    if keys.count != values.count { fatalError("Error parsing contents: Make sure all keys and values are in correct format without comments in file") }
    print("------------ Validating for duplicate keys: \(path) ------------")
    return zip(keys, values).reduce(into: [String: String]()) { results, keyValue in
        if results[keyValue.0] != nil {
            printPretty("error: Found duplicate key: \(keyValue.0) in file: \(path)")
            abort()
        }
        results[keyValue.0] = keyValue.1
    }
}

let stringFiles = create()
stringFiles.forEach { print($0.path) }
validateMatchKeys(stringFiles)
stringFiles.forEach { $0.cleanWrite() }

let codeFiles = localizedStringsInCode()
validateMissingKeys(codeFiles, localizationFiles: stringFiles)
validateDeadKeys(codeFiles, localizationFiles: stringFiles)