diff options
Diffstat (limited to 'circuitpython/tools/codeformat.py')
| -rw-r--r-- | circuitpython/tools/codeformat.py | 249 |
1 files changed, 249 insertions, 0 deletions
diff --git a/circuitpython/tools/codeformat.py b/circuitpython/tools/codeformat.py new file mode 100644 index 0000000..edefbc8 --- /dev/null +++ b/circuitpython/tools/codeformat.py @@ -0,0 +1,249 @@ +#!/usr/bin/env python3 +# +# This file is part of the MicroPython project, http://micropython.org/ +# +# The MIT License (MIT) +# +# Copyright (c) 2020 Damien P. George +# Copyright (c) 2020 Jim Mussared +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +import argparse +import glob +import fnmatch +import itertools +import os +import pathlib +import re +import sys +import subprocess + +# Relative to top-level repo dir. +PATHS = [ + # C + "main.c", + "devices/**/*.[ch]", + "extmod/*.[ch]", + "shared/netutils/*.[ch]", + "shared/timeutils/*.[ch]", + "shared/runtime/*.[ch]", + "mpy-cross/**/*.[ch]", + "ports/**/*.[ch]", + "py/**/*.[ch]", + "shared-bindings/**/*.[ch]", + "shared-module/**/*.[ch]", + "supervisor/**/*.[ch]", + # Python + "extmod/*.py", + "ports/**/*.py", + "py/**/*.py", + "tools/**/*.py", + "tests/**/*.py", +] + +EXCLUSIONS = [ + # STM32 build includes generated Python code. + "ports/*/build*", + # gitignore in ports/unix ignores *.py, so also do it here. + "ports/unix/*.py", + # not real python files + "tests/**/repl_*.py", + # needs careful attention before applying automatic formatting + "tests/basics/*.py", +] + +# None of the standard Python path matching routines implement the matching +# we want, which is most like git's "pathspec" version of globs. +# In particular, we want "**/" to match all directories. +# This routine is sufficient to work with the patterns we have, but +# subtle cases like character classes that contain meta-characters +# are not covered +def git_glob_to_regex(pat): + def transform(m): + m = m.group(0) + if m == "*": + return "[^/]*" + if m == "**/": + return "(.*/)?" + if m == "?": + return "[^/]" + if m == ".": + return r"\." + return m + + result = [transform(part) for part in re.finditer(r"(\*\*/|[*?.]|[^*?.]+)", pat)] + return "(^" + "".join(result) + "$)" + + +# Create a single, complicated regular expression that matches exactly the +# files we want, accounting for the PATHS as well as the EXCLUSIONS. +path_re = ( + "" + # First a negative lookahead assertion that it doesn't match + # any of the EXCLUSIONS + + "(?!" + + "|".join(git_glob_to_regex(pat) for pat in EXCLUSIONS) + + ")" + # Then a positive match for any of the PATHS + + "(?:" + + "|".join(git_glob_to_regex(pat) for pat in PATHS) + + ")" +) +path_rx = re.compile(path_re) + +# Path to repo top-level dir. +TOP = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) + +UNCRUSTIFY_CFG = os.path.join(TOP, "tools/uncrustify.cfg") + +C_EXTS = ( + ".c", + ".h", +) +PY_EXTS = (".py",) + + +def check_uncrustify_version(): + version = subprocess.check_output( + ["uncrustify", "--version"], encoding="utf-8", errors="replace" + ) + if version < "Uncrustify-0.71": + raise SystemExit(f"codeformat.py requires Uncrustify 0.71 or newer, got {version}") + + +# Transform a filename argument relative to the current directory into one +# relative to the TOP directory, which is what we need when checking against +# path_rx. +def relative_filename(arg): + return str(pathlib.Path(arg).resolve().relative_to(TOP)) + + +def list_files(args): + return sorted(arg for arg in args if path_rx.match(relative_filename(arg))) + + +def fixup_c(filename): + # Read file. + with open(filename) as f: + lines = f.readlines() + + # Write out file with fixups. + with open(filename, "w", newline="") as f: + dedent_stack = [] + i = 0 + while lines: + # Get next line. + i += 1 + l = lines.pop(0) + + # Revert "// |" back to "//| " + if l.startswith("// |"): + l = "//|" + l[4:] + + # Dedent #'s to match indent of following line (not previous line). + m = re.match(r"( +)#(if |ifdef |ifndef |elif |else|endif)", l) + if m: + indent = len(m.group(1)) + directive = m.group(2) + if directive in ("if ", "ifdef ", "ifndef "): + l_next = lines[0] + indent_next = len(re.match(r"( *)", l_next).group(1)) + if indent - 4 == indent_next and re.match(r" +(} else |case )", l_next): + # This #-line (and all associated ones) needs dedenting by 4 spaces. + l = l[4:] + dedent_stack.append(indent - 4) + else: + # This #-line does not need dedenting. + dedent_stack.append(-1) + elif dedent_stack: + if dedent_stack[-1] >= 0: + # This associated #-line needs dedenting to match the #if. + indent_diff = indent - dedent_stack[-1] + assert indent_diff >= 0 + l = l[indent_diff:] + if directive == "endif": + dedent_stack.pop() + + # Write out line. + f.write(l) + + assert not dedent_stack, filename + + +def main(): + cmd_parser = argparse.ArgumentParser( + description="Auto-format C and Python files -- to be used via pre-commit only." + ) + cmd_parser.add_argument("-c", action="store_true", help="Format C code only") + cmd_parser.add_argument("-p", action="store_true", help="Format Python code only") + cmd_parser.add_argument("-v", action="store_true", help="Enable verbose output") + cmd_parser.add_argument("--dry-run", action="store_true", help="Print, don't act") + cmd_parser.add_argument("files", nargs="+", help="Run on specific globs") + args = cmd_parser.parse_args() + + if args.dry_run: + print(" ".join(sys.argv)) + + # Setting only one of -c or -p disables the other. If both or neither are set, then do both. + format_c = args.c or not args.p + format_py = args.p or not args.c + + # Expand the arguments passed on the command line, subject to the PATHS and EXCLUSIONS + files = list_files(args.files) + + # Extract files matching a specific language. + def lang_files(exts): + for file in files: + if os.path.splitext(file)[1].lower() in exts: + yield file + + # Run tool on N files at a time (to avoid making the command line too long). + def batch(cmd, files, N=200): + while True: + file_args = list(itertools.islice(files, N)) + if not file_args: + break + if args.dry_run: + print(" ".join(cmd + file_args)) + else: + subprocess.call(cmd + file_args) + + # Format C files with uncrustify. + if format_c: + check_uncrustify_version() + command = ["uncrustify", "-c", UNCRUSTIFY_CFG, "-lC", "--no-backup"] + if not args.v: + command.append("-q") + batch(command, lang_files(C_EXTS)) + for file in lang_files(C_EXTS): + fixup_c(file) + + # Format Python files with black. + if format_py: + command = ["black", "--fast", "--line-length=99"] + if args.v: + command.append("-v") + else: + command.append("-q") + batch(command, lang_files(PY_EXTS)) + + +if __name__ == "__main__": + main() |