681fbbe2cf
Now "report" step combines result in a uniform way and processes unit test results XML output. It works for sub-builds only started from the 'premerge' pipeline, i.e. non-recursive. One downside is that now one has to wait until all jobs have finished. - Add instructions to setup python environment - added option to do full report cycle but not call Phabricator - use "annotations" to show build status. That lifts the need to filter ninja and other output (thus `ph_no_filter_output` param removed) and output everything. That is nice as script failures no longer lead to loss of logs. - improved annotate() usability - misc fixes
111 lines
4.6 KiB
Python
Executable file
111 lines
4.6 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
# Copyright 2020 Google LLC
|
|
#
|
|
# Licensed under the the Apache License v2.0 with LLVM Exceptions (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# https://llvm.org/LICENSE.txt
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import argparse
|
|
import logging
|
|
import os
|
|
import subprocess
|
|
from typing import Tuple, Optional
|
|
import pathspec
|
|
import unidiff
|
|
|
|
from phabtalk.phabtalk import Report, Step
|
|
from buildkite_utils import annotate
|
|
|
|
|
|
def get_diff(base_commit) -> Tuple[bool, str]:
|
|
r = subprocess.run(f'git-clang-format {base_commit}', shell=True)
|
|
logging.debug(f'git-clang-format {r}')
|
|
if r.returncode != 0:
|
|
logging.error(f'git-clang-format returned an non-zero exit code {r.returncode}')
|
|
r = subprocess.run(f'git checkout -- .', stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
|
|
logging.debug(f'git reset {r}')
|
|
return False, ''
|
|
diff_run = subprocess.run(f'git diff -U0 --no-prefix --exit-code', capture_output=True, shell=True)
|
|
logging.debug(f'git diff {diff_run}')
|
|
r = subprocess.run(f'git checkout -- .', stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
|
|
logging.debug(f'git reset {r}')
|
|
return True, diff_run.stdout.decode()
|
|
|
|
|
|
def run(base_commit, ignore_config, step: Optional[Step], report: Optional[Report]):
|
|
"""Apply clang-format and return if no issues were found."""
|
|
if report is None:
|
|
report = Report() # For debugging.
|
|
if step is None:
|
|
step = Step() # For debugging.
|
|
step.reproduce_commands.append(f'git-clang-format {base_commit}')
|
|
r, patch = get_diff(base_commit)
|
|
if not r:
|
|
step.success = False
|
|
return
|
|
add_artifact = False
|
|
patches = unidiff.PatchSet(patch)
|
|
ignore_lines = []
|
|
if ignore_config is not None and os.path.exists(ignore_config):
|
|
ignore_lines = open(ignore_config, 'r').readlines()
|
|
logging.debug("ignore patterns: " + str(';'.join(ignore_lines)))
|
|
ignore = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, ignore_lines)
|
|
patched_file: unidiff.PatchedFile
|
|
success = True
|
|
for patched_file in patches:
|
|
add_artifact = True
|
|
if ignore.match_file(patched_file.source_file) or ignore.match_file(patched_file.target_file):
|
|
logging.info(f'patch of {patched_file.patch_info} is ignored')
|
|
continue
|
|
hunk: unidiff.Hunk
|
|
for hunk in patched_file:
|
|
lines = [str(x) for x in hunk]
|
|
success = False
|
|
m = 10 # max number of lines to report.
|
|
description = 'please reformat the code\n```\n'
|
|
n = len(lines)
|
|
cut = n > m + 1
|
|
if cut:
|
|
lines = lines[:m]
|
|
description += ''.join(lines) + '\n```'
|
|
if cut:
|
|
description += f'\n{n - m} diff lines are omitted. See full path.'
|
|
report.add_lint({
|
|
'name': 'clang-format',
|
|
'severity': 'autofix',
|
|
'code': 'clang-format',
|
|
'path': patched_file.source_file,
|
|
'line': hunk.source_start,
|
|
'char': 1,
|
|
'description': description,
|
|
})
|
|
if add_artifact:
|
|
patch_file = 'clang-format.patch'
|
|
with open(patch_file, 'w') as f:
|
|
f.write(patch)
|
|
report.add_artifact(os.getcwd(), patch_file, 'clang-format')
|
|
if not success:
|
|
step.success = False
|
|
annotate(f'clang-format: Please format your changes with clang-format by running `git-clang-format HEAD^`'
|
|
f'or applying the attached patch.', style='error')
|
|
logging.debug(f'report: {report}')
|
|
logging.debug(f'step: {step}')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser = argparse.ArgumentParser(description='Runs clang-format against given diff with given commit. '
|
|
'Produces patch and attaches linter comments to a review.')
|
|
parser.add_argument('--base', default='HEAD~1')
|
|
parser.add_argument('--ignore-config', default=None, help='path to file with patters of files to ignore')
|
|
parser.add_argument('--log-level', type=str, default='INFO')
|
|
args = parser.parse_args()
|
|
logging.basicConfig(level=args.log_level)
|
|
run(args.base, args.ignore_config, None)
|