def _get_translated_strings(self, contents_callback, not_sorted):
strings = {}
languages = set()
for lang in self._LANGS:
filename = '%s/%s.lang' % (self._TEMPLATES_PATH, lang)
languages.add(lang)
last_key = ''
for lineno, line in enumerate(
contents_callback(filename).split(b'\n')[:-1]):
try:
row = line.decode('utf-8')
key, value = re.compile(r'\s+=\s+').split(row.strip(), 1)
if last_key >= key:
not_sorted.add(lang)
last_key = key
if key not in strings:
strings[key] = collections.defaultdict(str)
match = re.compile(r'^"((?:[^"]|\\")*)"$').match(value)
if match is None:
raise Exception("Invalid value")
strings[key][lang] = match.group(1).replace(r'\"', '"')
except: # pylint: disable=bare-except
raise linters.LinterException(
'Invalid i18n line "%s" in %s:%d' %
(row.strip(), filename, lineno + 1),
fixable=False)
if not_sorted:
raise linters.LinterException('Entries in %s are not sorted.' %
', '.join(sorted(not_sorted)),
fixable=False)
self._check_missing_entries(strings, languages)
return strings
def _get_translated_strings(self, contents_callback):
strings = {}
languages = set()
for lang in self._LANGS:
filename = '%s/%s.lang' % (self._TEMPLATES_PATH, lang)
languages.add(lang)
for lineno, line in enumerate(contents_callback(
filename).split(b'\n')[:-1]):
try:
row = line.decode('utf-8')
key, value = re.compile(r'\s+=\s+').split(row.strip(), 1)
if key not in strings:
strings[key] = collections.defaultdict(str)
match = re.compile(r'^"((?:[^"]|\\")*)"$').match(value)
if match is None:
raise Exception("Invalid value")
strings[key][lang] = match.group(1).replace(r'\"', '"')
except: # noqa: bare-except
raise linters.LinterException(
'Invalid i18n line "%s" in %s:%d' %
(row.strip(), filename, lineno + 1),
fixable=False)
# Removing badges entries
return {
k: v for k, v in strings.items() if not k.startswith('badge_')
}
def _check_missing_entries(self, strings, languages):
missing_items_lang = set()
for key, values in strings.items():
missing_languages = languages.difference(list(values.keys()))
if 'pseudo' in missing_languages:
missing_languages.remove('pseudo')
if missing_languages:
print('%s%s%s' % (self._HEADER, key, self._NORMAL),
file=sys.stderr)
for lang in sorted(languages):
if lang in values:
print(
'\t%s%-10s%s %s' %
(self._OKGREEN, lang, self._NORMAL, values[lang]),
file=sys.stderr)
else:
print('\t%s%-10s%s missing%s' %
(self._OKGREEN, lang, self._FAIL, self._NORMAL),
file=sys.stderr)
missing_items_lang.add(lang)
raise linters.LinterException(
'There are missing items in the %s.lang'
' file' % missing_items_lang,
fixable=False)
if key == 'locale':
values['pseudo'] = 'pseudo'
else:
values['pseudo'] = self._pseudoloc(values['en'])
def run_one(self, filename: str, contents: bytes) -> linters.SingleResult:
'''Runs the linter against |contents|.'''
diagnostics: List[linters.Diagnostic] = []
for lineno, line in enumerate(contents.decode('utf-8').split('\n'),
start=1):
if filename.endswith('.tpl'):
regex = _TEMPLATE_RE
else:
regex = _FRONTEND_RE
for match in regex.finditer(line):
if match[1] in self.__valid_strings:
continue
diagnostics.append(
linters.Diagnostic(
f'Missing translation string {match[1]!r}',
filename,
lineno=lineno,
line=line,
col=match.start(1) + 1,
col_end=match.end(1) + 1))
if diagnostics:
raise linters.LinterException('Missing translation strings',
fixable=False,
diagnostics=diagnostics)
return linters.SingleResult(contents, ['translation_strings'])
def _check_missing_entries(
self,
strings: Dict[str, Dict[str, str]],
languages: Set[str],
) -> None:
diagnostics: List[linters.Diagnostic] = []
for key, values in strings.items():
missing_languages = languages.difference(list(values.keys()))
if missing_languages:
for lang in missing_languages:
diagnostics.append(
linters.Diagnostic(f'Missing entry: {key!r}',
filename=os.path.join(
self._TEMPLATES_PATH,
f'{lang}.lang')))
continue
if key == 'locale':
values['pseudo'] = 'pseudo'
else:
values['pseudo'] = self._pseudoloc(values['en'])
if diagnostics:
raise linters.LinterException(
'There are missing items in some files',
diagnostics=diagnostics)
def _get_translated_strings(
self,
contents_callback: linters.ContentsCallback,
) -> Dict[str, Dict[str, str]]:
strings: Dict[str, DefaultDict[str, str]] = {}
languages: Set[str] = set()
diagnostics: List[linters.Diagnostic] = []
for lang in self._LANGS:
filename = '%s/%s.lang' % (self._TEMPLATES_PATH, lang)
languages.add(lang)
for lineno, line in enumerate(
contents_callback(filename).split(b'\n')[:-1]):
try:
row = line.decode('utf-8')
key, value = re.compile(r'\s+=\s+').split(row.strip(), 1)
if key not in strings:
strings[key] = collections.defaultdict(str)
match = re.compile(r'^"((?:[^"]|\\")*)"$').match(value)
if match is None:
raise Exception(f'Invalid line {row.strip()!r}')
strings[key][lang] = match.group(1).replace(r'\"', '"')
except Exception as exc: # pylint: disable=broad-except
diagnostics.append(
linters.Diagnostic(str(exc),
filename=filename,
lineno=lineno + 1,
line=row.strip()))
if diagnostics:
raise linters.LinterException('Invalid i18n files',
fixable=False,
diagnostics=diagnostics)
# Removing badges entries
return {k: v for k, v in strings.items() if not k.startswith('badge_')}
def _run_linter_one(
linter: linters.Linter, filename: Text, contents: bytes,
validate_only: bool,
diagnostics_output: DiagnosticsOutput) -> Tuple[Optional[Text], bool]:
'''Runs the linter against one file.'''
try:
try:
new_contents, violations = linter.run_one(filename, contents)
except linters.LinterException:
raise
except: # noqa: bare-except
exc_type, exc_value, exc_traceback = sys.exc_info()
raise linters.LinterException(
'Linter error',
fixable=False,
diagnostics=[
linters.Diagnostic(
message=''.join(
traceback.format_exception(exc_type, exc_value,
exc_traceback)),
filename=filename,
),
],
) from None
except linters.LinterException as lex:
_report_linter_exception(filename, lex, diagnostics_output)
return filename, lex.fixable
if contents == new_contents:
return None, False
return _report_linter_results(filename, new_contents, validate_only,
violations, True)
def _run_linter_all(
args: argparse.Namespace, linter: linters.Linter, files: Sequence[Text],
validate_only: bool, diagnostics_output: DiagnosticsOutput
) -> Sequence[Tuple[Optional[Text], bool]]:
try:
try:
new_file_contents, original_contents, violations = linter.run_all(
files, lambda filename: git_tools.file_contents(
args, _ROOT, filename))
except linters.LinterException:
raise
except: # noqa: bare-except
exc_type, exc_value, exc_traceback = sys.exc_info()
raise linters.LinterException(
'Linter error',
fixable=False,
diagnostics=[
linters.Diagnostic(
message=''.join(
traceback.format_exception(exc_type, exc_value,
exc_traceback)),
filename=', '.join(files),
),
],
) from None
except linters.LinterException as lex:
_report_linter_exception(', '.join(files), lex, diagnostics_output)
return [(filename, lex.fixable) for filename in files]
result: List[Tuple[Optional[Text], bool]] = []
for filename in new_file_contents:
if original_contents[filename] == new_file_contents[filename]:
result.append((None, False))
else:
result.append(
_report_linter_results(filename, new_file_contents[filename],
validate_only, violations, True))
return result