error.py 5.15 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"""error.py - error handling for DHParser

Copyright 2016  by Eckhart Arnold (arnold@badw.de)
                Bavarian Academy of Sciences an Humanities (badw.de)

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.
"""
di68kap's avatar
di68kap committed
18

19
20
import bisect
import functools
21
from typing import Iterable, Iterator, Union, Tuple, List
22

23
from DHParser.stringview import StringView
24
25
26
27
28
29
30

__all__ = ('Error',
           'is_error',
           'is_warning',
           'has_errors',
           'only_errors',
           'linebreaks',
31
           'line_col')
32
33
34
35
36


class Error:
    __slots__ = ['message', 'level', 'code', 'pos', 'line', 'column']

37
38
    # error levels

39
40
41
42
    WARNING   = 1
    ERROR     = 1000
    HIGHEST   = ERROR

43
44
45
46
    # warning codes

    REDEFINED_DIRECTIVE_WARNING = 101

47
48
49
50
    # error codes

    MANDATORY_CONTINUATION = 1001

51
    def __init__(self, message: str, code: int = ERROR,
52
                 pos: int = -1, line: int = -1, column: int = -1) -> None:
53
        self.message = message
54
        assert code >= 0
55
        self.code = code
56
57
58
        self.pos = pos
        self.line = line
        self.column = column
59
60
61
62
63
64
65

    def __str__(self):
        prefix = ''
        if self.line > 0:
            prefix = "line: %3i, column: %2i, " % (self.line, self.column)
        return prefix + "%s: %s" % (self.level_str, self.message)

66
    def __repr__(self):
67
68
        return 'Error("%s", %s, %i, %i, %i)' \
               % (self.message, repr(self.code), self.pos, self.line, self.column)
69

70
71
    @property
    def level_str(self):
72
        """Returns a string representation of the error level, e.g. "warning"."""
73
        return "Warning" if is_warning(self.code) else "Error"
74

75
76
77
78
79
80
81
    def visualize(self, document: str) -> str:
        """Shows the line of the document and the position where the error
        occurred."""
        start = document.rfind('\n', 0, self.pos) + 1
        stop = document.find('\n', self.pos)
        return document[start:stop] + '\n' + ' ' * (self.pos - start) + '^\n'

82

83
def is_warning(code: int) -> bool:
eckhart's avatar
eckhart committed
84
    """Returns True, if error is merely a warning."""
85
    return code < Error.ERROR
86
87


88
def is_error(code: int) -> bool:
eckhart's avatar
eckhart committed
89
    """Returns True, if error is an error, not just a warning."""
90
    return code >= Error.ERROR
91
92


eckhart's avatar
eckhart committed
93
def has_errors(messages: Iterable[Error], level: int = Error.ERROR) -> bool:
94
95
96
97
98
    """
    Returns True, if at least one entry in `messages` has at
    least the given error `level`.
    """
    for err_obj in messages:
99
        if err_obj.code >= level:
100
101
102
103
            return True
    return False


eckhart's avatar
eckhart committed
104
def only_errors(messages: Iterable[Error], level: int = Error.ERROR) -> Iterator[Error]:
105
106
107
108
109
110
111
    """
    Returns an Iterator that yields only those messages that have
    at least the given error level.
    """
    return (err for err in messages if err.level >= level)


eckhart's avatar
eckhart committed
112
def linebreaks(text: Union[StringView, str]) -> List[int]:
eckhart's avatar
eckhart committed
113
114
115
116
    """
    Returns a list of indices all line breaks in the text.
    """
    lbr = [-1]
117
118
    i = text.find('\n', 0)
    while i >= 0:
eckhart's avatar
eckhart committed
119
        lbr.append(i)
120
        i = text.find('\n', i + 1)
eckhart's avatar
eckhart committed
121
122
    lbr.append(len(text))
    return lbr
123
124
125
126


@functools.singledispatch
def line_col(text: Union[StringView, str], pos: int) -> Tuple[int, int]:
eckhart's avatar
eckhart committed
127
128
    """
    Returns the position within a text as (line, column)-tuple.
129
130
131
132
133
134
135
136
137
138
    """
    if pos < 0 or pos > len(text):  # one character behind EOF is still an allowed position!
        raise ValueError('Position %i outside text of length %s !' % (pos, len(text)))
    line = text.count("\n", 0, pos) + 1
    column = pos - text.rfind("\n", 0, pos)
    return line, column


@line_col.register(list)
def _line_col(lbreaks: List[int], pos: int) -> Tuple[int, int]:
eckhart's avatar
eckhart committed
139
140
    """
    Returns the position within a text as (line, column)-tuple based
141
142
143
144
145
146
147
148
    on a list of all line breaks, including -1 and EOF.
    """
    if pos < 0 or pos > lbreaks[-1]:  # one character behind EOF is still an allowed position!
        raise ValueError('Position %i outside text of length %s !' % (pos, lbreaks[-1]))
    line = bisect.bisect_left(lbreaks, pos)
    column = pos - lbreaks[line - 1]
    return line, column

149

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
# def error_messages(source_text:str, errors: List[Error]) -> List[str]:
#     """Adds line, column information for error messages, if the position
#     is given.
#
#     Args:
#         source_text (str):  The source text on which the errors occurred.
#             (Needed in order to determine the line and column numbers.)
#         errors (list):  The list of errors as returned by the method
#             ``collect_errors()`` of a Node object
#     Returns:
#         The same list of error messages, which now contain line and
#         column numbers.
#     """
#     for err in errors:
#         if err.pos >= 0 and err.line <= 0:
#             err.line, err.column = line_col(source_text, err.pos)
#     return errors