#!/usr/bin/env xcrun --sdk macosx swift

// swiftlint:disable all

import Foundation

// WHAT

// 1. Find Missing keys in other Localisation files

// 2. Find potentially untranslated keys

// 3. Find Duplicate keys

// 4. Find Unused keys and generate script to delete them all at once

// MARK: Start Of Configurable Section

/*

You can enable or disable the script whenever you want

*/

let enabled = true

/*

Flag to determine whether unused strings should be an error

*/

let careAboutUnused = false

/*

Flag to determine whether potentially untranslated strings should be a warning

*/

let careAboutUntranslated = false

/*

Put your path here, example -> Resources/Localizations/Languages

*/

let relativeLocalizableFolders = "/Rocket.Chat/Resources"

/*

This is the path of your source folder which will be used in searching

for the localization keys you actually use in your project

*/

let relativeSourceFolder = "/Rocket.Chat"

/*

Those are the regex patterns to recognize localizations.

*/

let patterns = [

/*

Those are the keys you don't want to be recognized as "unused"

For instance, Keys that you concatenate will not be detected by the parsing

so you want to add them here in order not to create false positives :)

*/

let ignoredFromUnusedKeys = [String]()

/* example

let ignoredFromUnusedKeys = [

"NotificationNoOne",

"NotificationCommentPhoto",

"NotificationCommentHisPhoto",

"NotificationCommentHerPhoto"

]

*/

let masterLanguage = "en"

/*

Sanitizing files will remove comments, empty lines and order your keys alphabetically.

*/

let sanitizeFiles = false

/*

Determines if there are multiple localizations or not.

*/

let singleLanguage = false

// MARK: End Of Configurable Section

// MARK: -

if enabled == false {

print("Localization check cancelled")

exit(000)

// Detect list of supported languages automatically

func listSupportedLanguages() -> [String] {

let supportedLanguages = listSupportedLanguages()

var ignoredFromSameTranslation = [String:[String]]()

let path = FileManager.default.currentDirectoryPath + relativeLocalizableFolders

var numberOfWarnings = 0

var numberOfErrors = 0

struct LocalizationFiles {

// MARK: - Load Localisation Files in memory

let masterLocalizationfile = LocalizationFiles(name: masterLanguage)

let localizationFiles = supportedLanguages

.filter { $0 != masterLanguage }

.map { LocalizationFiles(name: $0) }

// MARK: - Detect Unused Keys

let sourcesPath = FileManager.default.currentDirectoryPath + relativeSourceFolder

let fileManager = FileManager.default

let enumerator = fileManager.enumerator(atPath:sourcesPath)

var localizedStrings = [String]()

while let swiftFileLocation = enumerator?.nextObject() as? String {

// checks the extension // TODO OBJC?

if swiftFileLocation.hasSuffix(".swift") || swiftFileLocation.hasSuffix(".m") || swiftFileLocation.hasSuffix(".mm") {

let location = "\(sourcesPath)/\(swiftFileLocation)"

if let string = try? String(contentsOfFile: location, encoding: .utf8) {

for p in patterns {

let regex = try? NSRegularExpression(pattern: p, options: [])

let range = NSRange(location:0, length:(string as NSString).length) //Obj c wa

regex?.enumerateMatches(in: string,

options: [],

range: range,

using: { (result, _, _) in

if let r = result {

let value = (string as NSString).substring(with:r.range(at:r.numberOfRanges-1))

localizedStrings.append(value)

}

})

}

}

}

var masterKeys = Set(masterLocalizationfile.keyValue.keys)

let usedKeys = Set(localizedStrings)

let ignored = Set(ignoredFromUnusedKeys)

let unused = masterKeys.subtracting(usedKeys).subtracting(ignored)

// Here generate Xcode regex Find and replace script to remove dead keys all at once!

var replaceCommand = "\"("

var counter = 0

if careAboutUnused {

for v in unused {

var str = "\(path)/\(masterLocalizationfile.name).lproj/Localizable.strings:\(masterLocalizationfile.linesNumbers[v]!): "

str += "error: [Unused Key] \"\(v)\" is never used"

print(str)

numberOfErrors += 1

if counter != 0 {

replaceCommand += "|"

}

replaceCommand += v

if counter == unused.count-1 {

replaceCommand += ")\" = \".*\";"

}

counter += 1

}

print(replaceCommand)

// MARK: - Compare each translation file against master (en)

for file in localizationFiles {

for k in masterLocalizationfile.keyValue.keys {

if let v = file.keyValue[k] {

if careAboutUntranslated && v == masterLocalizationfile.keyValue[k] {

if !ignoredFromSameTranslation[file.name]!.contains(k) {

let str = "\(path)/\(file.name).lproj/Localizable.strings"

+ ":\(file.linesNumbers[k]!): "

+ "warning: [Potentialy Untranslated] \"\(k)\""

+ "in \(file.name.uppercased()) file doesn't seem to be localized"

print(str)

numberOfWarnings += 1

}

}

} else {

var str = "\(path)/\(file.name).lproj/Localizable.strings:\(masterLocalizationfile.linesNumbers[k]!): "

str += "error: [Missing] \"\(k)\" missing form \(file.name.uppercased()) file"

print(str)

numberOfErrors += 1

}

}

print("Number of warnings : \(numberOfWarnings)")

print("Number of errors : \(numberOfErrors)")

if numberOfErrors > 0 {

exit(1)

// swiftlint:enable all