From 5fe1590b39a4b8efbf07d9ecf60473420ef87989 Mon Sep 17 00:00:00 2001 From: Sebastian Serth Date: Fri, 13 Nov 2020 22:52:56 +0100 Subject: [PATCH] Add filter for unknown PyLint messages --- config/locales/de.linter.yml | 28 ++++++++++++++++++++++++++++ lib/py_lint_adapter.rb | 12 +++++++++++- 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/config/locales/de.linter.yml b/config/locales/de.linter.yml index e20adb38..94965e28 100644 --- a/config/locales/de.linter.yml +++ b/config/locales/de.linter.yml @@ -13,6 +13,7 @@ de: # d. replacement: A fix replacement translation which is used instead of the # original English output. It may refer to one of the named capture # groups to include dynamic content from the English original + # e. log_missing: Specifies whether missing translations should be logged to Sentry # 4. Optionally a named capture group from the regex # 5. A list of fix translations for _values / matches_ of the named capture group # @@ -23,11 +24,13 @@ de: name: Falsche Import-Position regex: .*"(?.*)".* replacement: Der Import von "%{import}" sollte am Anfang der Datei stehen + log_missing: false bad-whitespace: example: No space allowed before bracket name: Inkorrektes Leerzeichen regex: (?Exactly one space required|No space allowed) (?after|before|around) (?.*) replacement: "%{where} %{when} %{what}" + log_missing: true what: No space allowed: sollte kein Leerzeichen stehen Exactly one space required: sollte genau ein Leerzeichen stehen @@ -47,11 +50,13 @@ de: name: Mehrere Anweisungen regex: .* replacement: Mehr als eine Anweisung in einer Zeile + log_missing: false superfluous-parens: example: Unnecessary parens after 'if' keyword name: Überflüssige Klammer regex: .*'(?.*)'.* replacement: Nach dem Schlüsselwort '%{keyword}' ist keine Klammer notwendig + log_missing: false error: severity_name: Fehler function-redefined: @@ -59,17 +64,20 @@ de: name: Funktionsdefinition überschrieben regex: .*line (?\d*).* replacement: Eine Funktion mit demselben Namen wurde bereits in Zeile %{line} definiert + log_missing: false import-error: example: Unable to import 'turtel' name: Import-Fehler regex: .*'(?.*)'.* replacement: Der Import von '%{import} ist fehlgeschlagen + log_missing: false syntax-error: example: EOL while scanning string literal (, line 1) name: Syntax-Fehler regex: | (?invalid syntax|EOL while scanning string literal|EOF while scanning triple-quoted string literal|cannot assign to|expected an indented block|Missing parentheses in call to|closing parenthesis|expression cannot contain assignment, perhaps you meant|f-string expression part cannot include a backslash|f-string:|invalid character in identifier|invalid decimal literal|trailing comma not allowed without surrounding parentheses|unexpected EOF while parsing|unexpected character after line continuation character|unexpected indent|unindent does not match any outer indentation level|unmatched) ?(?function call|literal|operator|set display|empty expression not allowed|single|unmatched)? ?(?:'(?[^'"]*)'\.*)? ?(?:(?Did you mean|does not match opening parenthesis|is not allowed)(?: ')?)?(?:(?.*)(?:\?|'|"))? ?\((?.*), line (?\d*)\).* replacement: "%{what}%{what_exactly}%{actual}%{explanation}%{suggestion}" # unused: context, line + log_missing: true what: invalid syntax: Ungültige Syntax EOL while scanning string literal: Ein String wurde nicht geschlossen @@ -116,16 +124,19 @@ de: name: Undefinierter Bezeichner regex: .*'(?.*)'.* replacement: Der Name '%{name}' ist unbekannt + log_missing: false used-before-assignment: example: Using variable 'kleidung' before assignment name: Verwendung vor Zuweisung regex: .*'(?.*)'.* replacement: Die Variable '%{name}' wird vor ihrer erstmaligen Zuweisung verwendet + log_missing: false return-outside-function: example: Return outside function name: Return außerhalb einer Funktion regex: .* replacement: Ein Return kann nur innerhalb einer Funktion verwendet werden + log_missing: false refactor: severity_name: Überarbeitung empfohlen comparison-with-itself: @@ -133,16 +144,19 @@ de: name: Vergleich mit sich selbst regex: .* - (?.*) replacement: Der Vergleich ist überflüssig - %{comparison} + log_missing: false inconsistent-return-statements: example: Either all return statements in a function should return an expression, or none of them should. name: Uneinheitliche Rückgabewerte regex: .* replacement: Entweder sollten alle return Anweisungen in einer Funktion ein Ergebnis zurückgeben oder keine Anweisung sollte einen Rückgabewert haben + log_missing: false redefined-argument-from-local: example: Redefining argument with the local name 'Wort' name: Überschreiben eines Arguments regex: .*'(?.*)'.* replacement: Das Argument '%{name}' wird überschrieben + log_missing: false warning: severity_name: Warnung bad-indentation: @@ -150,68 +164,82 @@ de: name: Ungültige Einrückung regex: .*(?\d+).*(?\d+).* replacement: Statt %{actual} Leerzeichen wurden %{expected} Leerzeichen erwartet + log_missing: false duplicate-key: example: Duplicate key 100 in dictionary name: Doppelter Schlüssel regex: Duplicate key (?.*) in dictionary replacement: Der Schlüssel '%{key}' ist im Dictionary doppelt vorhanden + log_missing: false duplicate-except: example: Catching previously caught exception type ValueError name: Doppeltes Except regex: Catching previously caught exception type (?.*) replacement: Die zuvor bereits aufgefangene Exception '%{exception}' wird erneut behandelt + log_missing: false mixed-indentation: example: Found indentation with tabs instead of spaces name: Gemischte Einrückung regex: .* replacement: Es wurde eine Einrückung mit Tabs anstelle von Leerzeichen entdeckt + log_missing: false pointless-statement: example: Statement seems to have no effect name: sinnlose Anweisung regex: .* replacement: Die Anweisung scheint keine Auswirkungen zu haben + log_missing: false pointless-string-statement: example: String statement has no effect name: sinnloser String regex: .* replacement: Ein einzelner String ohne Zuweisung hat keine Auswirkung + log_missing: false redefined-builtin: example: Redefining built-in 'print' name: Überschreiben regex: .*'(?.*)'.* replacement: Der interne Bezeichner '%{builtin}' wird überschrieben + log_missing: false redefined-outer-name: example: Redefining name 'name' from outer scope (line 1) name: Überschreiben regex: .*'(?.*)'.*\(line (?\d*)\).* replacement: Der Bezeichner '%{name}', der bereits in Zeile %{line} definiert wurde, wird überschrieben + log_missing: false self-assigning-variable: example: Assigning the same variable 'kleidung' to itself name: Selbstzuweisung regex: .*'(?.*)'.* replacement: Die Variable '%{name}' wird sich selbst zugewiesen + log_missing: false unreachable: example: Unreachable code name: Unerreichbar regex: .* replacement: Die Anweisung wird nie ausgeführt + log_missing: false undefined-loop-variable: example: Using possibly undefined loop variable 'i' name: Unbekannte Schleifenvariable regex: .*'(?.*)'.* replacement: Die Schleifenvariable '%{name}' ist möglicherweise nicht definiert + log_missing: false unnecessary-semicolon: example: Unnecessary semicolon name: Unnötiges Semikolon regex: .* replacement: Am Ende einer Zeile sollte kein Semikolon stehen + log_missing: false unused-argument: example: Unused argument 'laenge' name: Unbenutztes Argument regex: .*'(?.*)'.* replacement: Das Argument '%{name}' wird nicht verwendet + log_missing: false unused-variable: example: Unused variable 'i' name: Unbenutzte Variable regex: .*'(?.*)'.* replacement: Die Variable '%{name}' wird nicht verwendet + log_missing: false diff --git a/lib/py_lint_adapter.rb b/lib/py_lint_adapter.rb index 84b9fbf2..1a35b382 100644 --- a/lib/py_lint_adapter.rb +++ b/lib/py_lint_adapter.rb @@ -83,8 +83,18 @@ class PyLintAdapter < TestingFrameworkAdapter end def self.get_t(key, default) + # key might be "linter.#{severity}.#{name}.#{key}.#{value}" + # or something like "linter.#{severity}.#{name}.replacement" translation = I18n.t(key, locale: :de, default: default) - Raven.capture_message({key: key, default: default}.to_json) if translation == default + keys = key.split('.') + final_key = keys.pop + if %w[severity_name name regex replacement].exclude? final_key + keys.pop # second last key, e.g. #{key} + log_missing = I18n.t(keys.append('log_missing').join('.'), locale: :de, default: true) + else + log_missing = true + end + Raven.capture_message({key: key, default: default}.to_json) if translation == default && log_missing translation end end