fiasko_bro/code_validator.py at main · tenqlw/fiasko_bro · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
from . import defaults
from .repository_info import ProjectFolder
from .utils.validator_helpers import ensure_repo_tokens_mutually_exclusive


def _is_successful_validation(validation_result):
    return validation_result is None


def _run_validator_group(group, arguments):
    errors = []
    for validator in group:
        validation_result = validator(**arguments)
        if not _is_successful_validation(validation_result):
            errors.append((validator.__name__, validation_result))
    return errors


def _run_validators_with_group_names(validator_groups, group_names, validator_arguments):
    errors = []
    for group_name in group_names:
        errors += _run_validator_group(
            validator_groups.get(group_name, []),
            validator_arguments
        )
    return errors


def run_validator_group(validator_group, validator_arguments, post_error_validator_group=None):
    successful_group_names = []
    for group_name, group in validator_group.items():
        errors = _run_validator_group(group, validator_arguments)
        if errors:
            if post_error_validator_group:
                errors += _run_validators_with_group_names(
                    post_error_validator_group,
                    group_names=successful_group_names,
                    validator_arguments=validator_arguments
                )
            return errors
        successful_group_names.append(group_name)
    return []


def _construct_validator_arguments(project_path, **kwargs):
    validator_arguments = {
        'project_path': project_path,
    }
    validator_arguments.update(defaults.VALIDATION_PARAMETERS)
    validator_arguments.update(kwargs)
    return validator_arguments


def determine_validators(**kwargs):
    pre_validation_checks = kwargs.pop('pre_validation_checks', None) or defaults.PRE_VALIDATION_CHECKS
    error_validator_groups = kwargs.pop('error_validator_groups', None)
    warning_validator_groups = kwargs.pop('warning_validator_groups', None) or {}
    if not error_validator_groups:
        error_validator_groups = defaults.ERROR_VALIDATOR_GROUPS
        # use default warning groups only with default error groups
        if not warning_validator_groups:
            warning_validator_groups = defaults.WARNING_VALIDATOR_GROUPS
    return pre_validation_checks, error_validator_groups, warning_validator_groups


def validate(project_path, original_project_path=None, **kwargs):
    ensure_repo_tokens_mutually_exclusive(**kwargs)
    pre_validation_checks, error_validator_groups, warning_validator_groups = determine_validators(**kwargs)
    validator_arguments = _construct_validator_arguments(
        project_path,
        original_project_path=original_project_path,
        **kwargs
    )

    pre_validation_errors = run_validator_group(pre_validation_checks, validator_arguments)
    if pre_validation_errors:
        return pre_validation_errors

    validator_arguments['project_folder'] = ProjectFolder(
        project_path,
        directories_to_skip=validator_arguments['directories_to_skip']
    )
    if original_project_path:
        validator_arguments['original_project_folder'] = ProjectFolder(
            original_project_path,
            directories_to_skip=validator_arguments['directories_to_skip']
        )
    return run_validator_group(
        validator_group=error_validator_groups,
        validator_arguments=validator_arguments,
        post_error_validator_group=warning_validator_groups
    )


def traverse_validator_groups(validator_groups, func):
    for validator_group in validator_groups.values():
        for validator in validator_group:
            func(validator)


def get_error_slugs(pre_validation_checks=None, error_validator_groups=None, warning_validator_groups=None):
    validators = determine_validators(
        pre_validation_checks=pre_validation_checks,
        error_validator_groups=error_validator_groups,
        warning_validator_groups=warning_validator_groups
    )
    error_slugs = set()
    for validator_groups in validators:
        traverse_validator_groups(
            validator_groups,
            func=lambda validator: error_slugs.add(validator.__name__)
        )
    return error_slugs