conan/conans/client/graph/graph_error.py at 74e809b0c34c91b1b5b830bfce91f2d2196aa2f2 · memsharded/conan · 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
from conans.errors import ConanException


class GraphError(ConanException):
    # TODO: refactor into multiple classes, do not do type by attribute "kind"
    LOOP = "graph loop"
    VERSION_CONFLICT = "version conflict"
    PROVIDE_CONFLICT = "provide conflict"
    CONFIG_CONFLICT = "configuration conflict"
    MISSING_RECIPE = "missing recipe"
    RUNTIME = "runtime"

    def __init__(self, kind):
        self.kind = kind

    def __str__(self):
        # TODO: Nicer error reporting
        if self.kind == GraphError.MISSING_RECIPE:
            return f"Package '{self.require.ref}' not resolved: {self.missing_error}"
        elif self.kind == GraphError.VERSION_CONFLICT:
            return f"Version conflict: {self.node.ref}->{self.require.ref}, "\
                   f"{self.base_previous.ref}->{self.prev_require.ref}."
        return self.kind

    @staticmethod
    def loop(node, require, ancestor):
        result = GraphError(GraphError.LOOP)
        result.node = node
        result.require = require
        result.ancestor = ancestor
        node.error = ancestor.error = result
        return result

    @staticmethod
    def runtime(node, conflicting_node):
        result = GraphError(GraphError.RUNTIME)
        result.node = node
        result.conflicting_node = conflicting_node
        node.error = conflicting_node.error = result
        return result

    @staticmethod
    def provides(node, conflicting_node):
        result = GraphError(GraphError.PROVIDE_CONFLICT)
        result.node = node
        result.conflicting_node = conflicting_node
        node.error = conflicting_node.error = result
        return result

    @staticmethod
    def missing(node, require, missing_error):
        result = GraphError(GraphError.MISSING_RECIPE)
        result.node = node
        result.require = require
        result.missing_error = missing_error
        node.error = result
        return result

    @staticmethod
    def conflict(node, require, prev_node, prev_require, base_previous):
        result = GraphError(GraphError.VERSION_CONFLICT)
        result.node = node
        result.require = require
        result.prev_node = prev_node
        result.prev_require = prev_require
        result.base_previous = base_previous
        node.error = base_previous.error = result
        if prev_node:
            prev_node.error = result
        return result

    @staticmethod
    def conflict_config(node, require, prev_node, prev_require, base_previous,
                        option, previous_value, new_value):
        result = GraphError(GraphError.CONFIG_CONFLICT)
        result.node = node
        result.require = require
        result.prev_node = prev_node
        result.prev_require = prev_require
        result.base_previous = base_previous
        result.option = option
        result.previous_value = previous_value
        result.new_value = new_value
        node.error = base_previous.error = result
        if prev_node:
            prev_node.error = result
        return result