gn_check_autofix.py

Enable keyboard shortcuts

#!/usr/bin/env vpython3

# Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.

# Use of this source code is governed by a BSD-style license

# that can be found in the LICENSE file in the root of the source

# tree. An additional intellectual property rights grant can be found

# in the file PATENTS.  All contributing project authors may

# be found in the AUTHORS file in the root of the source tree.

"""

This tool tries to fix (some) errors reported by `gn gen --check` or

`gn check`.

If a command line flag `-C out/<dir>` is supplied, it will run `gn gen --check`

in that directory. Otherwise it will run `mb gen` in a temporary directory

which is useful to check for different configurations.

Usage:

    $ vpython3 tools_webrtc/gn_check_autofix.py -C out/Default

or

    $ vpython3 tools_webrtc/gn_check_autofix.py -m some_mater -b some_bot

or

    $ vpython3 tools_webrtc/gn_check_autofix.py -c some_mb_config

"""

import argparse

import os

import re

import shutil

import subprocess

import sys

import tempfile

from collections import defaultdict

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))

CHROMIUM_DIRS = [

    'base', 'build', 'buildtools', 'testing', 'third_party', 'tools'

TARGET_RE = re.compile(

    r'(?P<indentation_level>\s*)\w*\("(?P<target_name>\w*)"\) {$')

class TemporaryDirectory:

    def __init__(self):

        self._closed = False

        self._name = None

        self._name = tempfile.mkdtemp()

    def __enter__(self):

        return self._name

    def __exit__(self, exc, value, _tb):

        if self._name and not self._closed:

            shutil.rmtree(self._name)

            self._closed = True

def Run(cmd):

    print('Running:', ' '.join(cmd))

    sub = subprocess.Popen(cmd,

                           stdout=subprocess.PIPE,

                           stderr=subprocess.PIPE,

                           universal_newlines=True)

    return sub.communicate()

def fix_errors(filename, missing_deps, deleted_sources):

    with open(filename) as file:

        lines = file.readlines()

    fixed_file = ''

    indentation_level = None

    for line in lines:

        match = TARGET_RE.match(line)

        if match:

            target = match.group('target_name')

            if target in missing_deps:

                indentation_level = match.group('indentation_level')

        elif indentation_level is not None:

            match = re.match(indentation_level + '}$', line)

            if match:

                line = ('deps = [\n' + ''.join('  "' + dep + '",\n'

                                               for dep in missing_deps[target])

                        + ']\n') + line

                indentation_level = None

            elif line.strip().startswith('deps = ['):

                joined_deps = ''.join('  "' + dep + '",\n'

                                      for dep in missing_deps[target])

                line = line.replace('deps = [', 'deps = [' + joined_deps)

                indentation_level = None

        if line.strip() not in deleted_sources:

            fixed_file += line

    with open(filename, 'w') as file:

        file.write(fixed_file)

    Run(['gn', 'format', filename])

def first_non_empty(iterable):

    """Return first item which evaluates to True, or fallback to None."""

    return next((x for x in iterable if x), None)

def rebase(base_path, dependency_path, dependency):

    """Adapt paths so they work both in stand-alone WebRTC and Chromium tree.

  To cope with varying top-level directory (WebRTC VS Chromium), we use:

    * relative paths for WebRTC modules.

    * absolute paths for shared ones.

  E.g. '//common_audio/...' -> '../../common_audio/'

       '//third_party/...' remains as is.

  Args:

    base_path: current module path  (E.g. '//video')

    dependency_path: path from root (E.g. '//rtc_base/time')

    dependency: target itself       (E.g. 'timestamp_extrapolator')

  Returns:

    Full target path (E.g. '../rtc_base/time:timestamp_extrapolator').

"""

    root = first_non_empty(dependency_path.split('/'))

    if root in CHROMIUM_DIRS:

        # Chromium paths must remain absolute. E.g.

        # //third_party//abseil-cpp...

        rebased = dependency_path

    else:

        base_path = base_path.split(os.path.sep)

        dependency_path = dependency_path.split(os.path.sep)

        first_difference = None

        shortest_length = min(len(dependency_path), len(base_path))

        for i in range(shortest_length):

            if dependency_path[i] != base_path[i]:

                first_difference = i

                break

        first_difference = first_difference or shortest_length

        base_path = base_path[first_difference:]

        dependency_path = dependency_path[first_difference:]

        rebased = os.path.sep.join((['..'] * len(base_path)) + dependency_path)

    return rebased + ':' + dependency

def main():

    helptext = """

This tool tries to fix (some) errors reported by `gn gen --check`.

If a command line flag `-C out/<dir>` is supplied, it will run `gn gen --check`

in that directory. Otherwise it will run `mb gen` in a temporary directory

with all other command line arguments forwarded to `mb gen`. This mode is

useful to check for different configurations."""

    parser = argparse.ArgumentParser(

        description=helptext,

        formatter_class=argparse.RawDescriptionHelpFormatter)

    parser.add_argument('-C',

                        dest='local_build_dir',

                        help='Path lo a local build dir, e.g. out/Default')

    (flags, argv_to_forward) = parser.parse_known_args(sys.argv[1:])

    deleted_sources = set()

    errors_by_file = defaultdict(lambda: defaultdict(set))

    if flags.local_build_dir:

        mb_output = Run(["gn", "gen", "--check", flags.local_build_dir])

    else:

        with TemporaryDirectory() as tmp_dir:

            mb_script_path = os.path.join(SCRIPT_DIR, 'mb', 'mb.py')

            mb_config_file_path = os.path.join(SCRIPT_DIR, 'mb',

                                               'mb_config.pyl')

            mb_gen_command = ([

                mb_script_path,

                'gen',

                tmp_dir,

                '--config-file',

                mb_config_file_path,

            ] + argv_to_forward)

        mb_output = Run(mb_gen_command)

    errors = mb_output[0].split('ERROR')[1:]

    if mb_output[1]:

        print(mb_output[1])

        return 1

    for error in errors:

        error = error.split('\n')

        target_msg = 'The target:'

        if target_msg not in error:

            target_msg = 'It is not in any dependency of'

        if target_msg not in error:

            print('\n'.join(error))

            continue

        index = error.index(target_msg) + 1

        path, target = error[index].strip().split(':')

        if error[index + 1] in ('is including a file from the target:',

                                'The include file is in the target(s):'):

            dep = error[index + 2].strip()

            dep_path, dep = dep.split(':')

            dep = rebase(path, dep_path, dep)

            # Replacing /target:target with /target

            dep = re.sub(r'/(\w+):(\1)$', r'/\1', dep)

            # Replacing target:target with target

            dep = re.sub(r'^(\w+):(\1)$', r'\1', dep)

            path = os.path.join(path[2:], 'BUILD.gn')

            errors_by_file[path][target].add(dep)

        elif error[index + 1] == 'has a source file:':

            deleted_file = '"' + os.path.basename(

                error[index + 2].strip()) + '",'

            deleted_sources.add(deleted_file)

        else:

            print('\n'.join(error))

            continue

    for path, missing_deps in list(errors_by_file.items()):

        fix_errors(path, missing_deps, deleted_sources)

    return 0

if __name__ == '__main__':

    sys.exit(main())