StringsLint/Sources/StringsLintFramework/Rules/Lint/MissingRule.swift at master · dral3x/StringsLint · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
//
//  MissingRule.swift
//  StringsLintFramework
//
//  Created by Alessandro "Sandro" Calzavara on 11/09/2018.
//

import Foundation

public class MissingRule: LintRule {
    public static var description = RuleDescription(
        identifier: "missing",
        name: "Missing",
        description: "Localized string is used but not translated"
    )

    private var declaredStrings = [LocalizedString]()
    private var usedStrings = [LocalizedString]()
    private let ignoredStrings: [String]
    var severity: ViolationSeverity

    private let declareParser: LocalizableParser
    private let usageParser: LocalizableParser

    public required convenience init(configuration: Any) throws {
        var config = MissingRuleConfiguration()
        do {
            try config.apply(defaultDictionaryValue(configuration, for: MissingRule.self.description.identifier))
        } catch {}

        self.init(declareParser: ComposedParser(parsers: [
                    try StringsParser.self.init(configuration: configuration),
                    try StringsdictParser.self.init(configuration: configuration)
                    ]),
                  usageParser: ComposedParser(parsers: [
                    try SwiftParser.self.init(configuration: configuration),
                    try ObjcParser.self.init(configuration: configuration),
                    try XibParser.self.init(configuration: configuration)
                    ]),
                  ignoredStrings: config.ignored,
                  severity: config.severity
        )
    }
    public required convenience init() {
        let config = MissingRuleConfiguration()

        self.init(declareParser: StringsParser(),
                  usageParser: ComposedParser(parsers: [ SwiftParser(), ObjcParser(), XibParser() ]),
                  ignoredStrings: config.ignored,
                  severity: config.severity)
    }
    public convenience init(ignored: [String]) {
        var config = MissingRuleConfiguration()
        config.ignored = ignored

        self.init(declareParser: StringsParser(),
                  usageParser: ComposedParser(parsers: [ SwiftParser(), ObjcParser(), XibParser() ]),
                  ignoredStrings: config.ignored,
                  severity: config.severity)
    }

    public init(declareParser: LocalizableParser,
                usageParser: LocalizableParser,
                ignoredStrings: [String],
                severity: ViolationSeverity) {
        self.declareParser = declareParser
        self.usageParser = usageParser
        self.ignoredStrings = ignoredStrings
        self.severity = severity
    }

    public func processFile(_ file: File) {

        if self.declareParser.support(file: file) {
            self.declaredStrings += self.processDeclarationFile(file)
        }

        if self.usageParser.support(file: file) {
            self.usedStrings += self.processUsageFile(file)
        }
    }

    public var violations: [Violation] {

        let diff = self.usedStrings.difference(from: self.declaredStrings)

        return diff.compactMap({ (string) -> Violation? in
            if self.ignoredStrings.contains(string.key) {
                return nil
            }
            if string.value != nil {
                return nil
            }
            return self.buildViolation(key: string.key, location: string.location)
        })
    }

    private func processDeclarationFile(_ file: File) -> [LocalizedString] {
        do {
            return try self.declareParser.parse(file: file)
        } catch let error {
            print("Unable to parse file \(file): \(error)")
            return []
        }
    }

    private func processUsageFile(_ file: File) -> [LocalizedString] {
        do {
            return try self.usageParser.parse(file: file)
        } catch let error {
            print("Unable to parse file \(file): \(error)")
            return []
        }
    }

    private func buildViolation(key: String, location: Location) -> Violation {
        return Violation(ruleDescription: MissingRule.description, severity: self.severity, location: location, reason: "Localized string \"\(key)\" is missing")
    }
}