clang-format.py

#!/usr/bin/env python

# Copyright 2015-present Samsung Electronics Co., Ltd. and other contributors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# 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.

from __future__ import print_function

import argparse
import fileinput
import functools
import os
import subprocess
import tempfile
from distutils import spawn

def parse_option():
    parser = argparse.ArgumentParser()
    parser.add_argument('--autoedit', action='store_true', default=False,
        help='Automatically edit the detected clang format errors.'
        'No diffs will be displayed')

    option = parser.parse_args()
    return option

class Executor(object):
    _TERM_RED = "\033[1;31m"
    _TERM_YELLOW = "\033[1;33m"
    _TERM_GREEN = "\033[1;32m"
    _TERM_BLUE = "\033[1;34m"
    _TERM_EMPTY = "\033[0m"

    @staticmethod
    def cmd_line(cmd, args=[]):
        return ' '.join([cmd] + args)

    @staticmethod
    def print_cmd_line(cmd, args=[]):
        print("%s%s%s" % (Executor._TERM_BLUE, Executor.cmd_line(cmd, args),
                          Executor._TERM_EMPTY))
        print()

    @staticmethod
    def fail(msg):
        print()
        print("%s%s%s" % (Executor._TERM_RED, msg, Executor._TERM_EMPTY))
        print()
        exit(1)

    @staticmethod
    def run_cmd(cmd, args=[], quiet=False, cwd=None):
        if not quiet:
            Executor.print_cmd_line(cmd, args)
        try:
            return subprocess.call([cmd] + args, cwd=cwd, env=environ)
        except OSError as e:
            Executor.fail("[Failed - %s] %s" % (cmd, e.strerror))

    @staticmethod
    def run_cmd_output(cmd, args=[], quiet=False):
        if not quiet:
            Executor.print_cmd_line(cmd, args)
        try:
            return subprocess.check_output([cmd] + args)
        except OSError as e:
            Executor.fail("[Failed - %s] %s" % (cmd, e.strerror))

    @staticmethod
    def check_run_cmd(cmd, args=[], quiet=False, cwd=None):
        retcode = Executor.run_cmd(cmd, args, quiet, cwd)
        if retcode != 0:
            Executor.fail("[Failed - %d] %s" % (retcode,
                                                Executor.cmd_line(cmd, args)))

class ClangFormat(object):

    def __init__(self, extensions, skip_files=None, options=None):
        self.diffs = []
        self._extensions = extensions
        self._skip_files = skip_files
        self._options = options
        self._check_clang_format("clang-format-9.0")

    def _check_clang_format(self, base):
        clang_format = spawn.find_executable(base)

        if not clang_format:
            clang_format = spawn.find_executable("clang-format")
            if clang_format:
                print("%sUsing %s instead of %s%s"
                      % (Executor._TERM_YELLOW, clang_format, base, Executor._TERM_EMPTY))
            else:
                print("%sNo %s found, skipping checks!%s"
                      % (Executor._TERM_RED, base, Executor._TERM_EMPTY))

        self._clang_format = clang_format

    @property
    def error_count(self):
        return len(self.diffs)

    def is_checked_by_clang(self, file):
        _, ext =  os.path.splitext(file)
        return ext in self._extensions and file not in self._skip_files

    def check(self, files):
        if not self._clang_format:
            return

        for file in filter(self.is_checked_by_clang, files):
            args = ['-style=file', file]
            if self._options and self._options.autoedit:
                args.append('-i')
            output = Executor.run_cmd_output(self._clang_format,
                                       args,
                                       quiet=True)

            if output:
                with tempfile.NamedTemporaryFile() as temp:
                    temp.write(output)
                    temp.flush() # just to be really safe
                    self._diff(file, temp.name)

    def _diff(self, original, formatted):
        try:
            subprocess.check_output(['diff', '-u', original, formatted])
        except subprocess.CalledProcessError as error:
            # if there is a difference between the two files
            # this error will be generated and we can extract
            # the diff from that it. Otherwise nothing to do.
            self.diffs.append(error.output.decode())


class FileFilter(object):

    def __init__(self, allowed_exts, allowed_files, skip_files):
        self._allowed_exts = allowed_exts
        self._allowed_files = allowed_files
        self._skip_files = skip_files

    def __call__(self, dir_path, file):
        if file in self._allowed_files:
            return True

        if file in self._skip_files:
            return False

        _, ext =  os.path.splitext(file)
        return ext in self._allowed_exts

def files_under(path, dirs_to_skip=[], file_filter=None):
    def filter_all(dirpath, basename):
        return True

    file_filter = file_filter or filter_all
    files = []
    if os.path.isfile(path):
        if file_filter(dirname(path), os.path.basename(path)):
            files.append(path)
        return files

    if os.path.basename(path) in dirs_to_skip:
        return []

    for (dirpath, dirnames, filenames) in os.walk(path):
        for d in dirs_to_skip:
            if d in dirnames:
                dirnames.remove(d)

        for filename in filenames:
            if file_filter(dirpath, filename):
                files.append(os.path.join(dirpath, filename))
    return files


def check_tidy(src_dir, options=None):
    allowed_exts = ['.c', '.cc', '.cpp', '.h', '.hpp']
    skip_dirs = ['binding',
                 '.git', '.data', '.checkpoints', '.nyc_output', '.miniconda',
                 'node_modules', 'coverage', 'pybind11',
                 ]
    skip_files = []

    clang = ClangFormat(allowed_exts, [], options)
    file_filter = FileFilter(allowed_exts, [], skip_files)
    files = files_under(src_dir, skip_dirs, file_filter)
    excluded_files = [file_path
                      for file_path in files
                      for skip_file in skip_files
                      if file_path.endswith(skip_file)]
    files = [file_path
             for file_path in files
             if file_path not in excluded_files]

    clang.check(files)
    if clang.error_count:
        print("Detected clang-format problems:")
        print("".join(clang.diffs))
        print()

    msg_color = Executor._TERM_RED if clang.error_count > 0 else Executor._TERM_GREEN
    print("%s* total errors: %d%s" % (msg_color, clang.error_count, Executor._TERM_EMPTY))
    print()
    return clang.error_count == 0

if __name__ == '__main__':
    PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__))
    options = parse_option()
    no_error = check_tidy(PROJECT_ROOT, options)
    if not no_error:
        exit(1)