add Frame class to render errors in HumanizedErrorsFormatter

Author: NiumXp

norminette/errors.py

@@ -2,6 +2,7 @@
 
 import os
 import json
+import collections
 from dataclasses import dataclass, field, asdict
 from typing import (
     TYPE_CHECKING,
@@ -37,8 +38,8 @@ def __lt__(self, other: Any) -> bool:
         if self.lineno == other.lineno:
             if self.column == other.column:
                 return len(self.hint or '') > len(other.hint or '')
-            return self.column > other.column
-        return self.lineno > other.lineno
+            return self.column < other.column
+        return self.lineno < other.lineno
 
     @classmethod
     def from_token(
@@ -54,6 +55,53 @@ def from_token(
             hint=hint,
         )
 
+    @staticmethod
+    def merge(highlights: list[Highlight]) -> list[Highlight]:
+        if len(highlights) < 2:
+            return highlights
+
+        highlights.sort()
+
+        drop = []
+
+        last = None
+        for index, highlight in enumerate(highlights):
+            if last is None:
+                last = highlight
+                continue
+
+            last_len = last.length or 0
+            curr_len = highlight.length or 0
+            if (last.column + last_len) >= highlight.column and not last.hint and not highlight.hint:
+                last.length = last_len + curr_len
+                drop.append(index)
+            else:
+                last = highlight
+
+        for index in reversed(drop):
+            del highlights[index]
+
+        return highlights
+
+    @staticmethod
+    def unpack(highlights: list[Highlight]):
+        result = []
+
+        by_line = collections.defaultdict(list)
+        for highlight in highlights:
+            by_line[highlight.lineno].append(highlight)
+        for lineno, hls in by_line.items():
+            rest = []
+            for highlight in hls:
+                if highlight.hint:
+                    result.append((lineno, [highlight]))
+                else:
+                    rest.append(highlight)
+            if rest:
+                result.append((lineno, rest))
+
+        return result
+
 
 @dataclass
 class Error:
@@ -204,24 +252,88 @@ def _colorize_error_text(self, error: Error) -> str:
         return f"\x1b[{color}m{error.text}\x1b[0m"
 
 
+class Frame:
+    __slots__ = "file", "error", "colorize"
+
+    def __init__(self, file: File, error: Error, *, colorize: bool = False) -> None:
+        self.file = file
+        self.error = error
+        self.colorize = colorize
+
+    @property
+    def _path(self) -> str:
+        items: list[str | int] = [self.file.path]
+        for highlight in self.error.highlights:
+            items.append(highlight.lineno)
+            items.append(highlight.column)
+            break
+        path = ':'.join(map(str, items))
+        return path if not self.colorize else f"\x1b[;97m{path}\x1b[0m"
+
+    def _build_code_sublines(self, highlights: list[Highlight]):
+        subline = ''
+        hint = ''
+        for highlight in highlights:
+            if highlight.hint:
+                if hint:
+                    hint += ', '
+                hint += highlight.hint
+            if len(subline) < highlight.column - 1:
+                subline += ' ' * (highlight.column - 1 - len(subline))
+            subline += '^' * (highlight.length or 1)
+        if hint:
+            subline += f"  \x1b[3;94m{hint}\x1b[0m"
+        yield subline
+
+    def _build_code_lines(self, lineno: int, arrows: List[Highlight]):
+        assert arrows, "No highlights to build line from"
+
+        arrows = Highlight.merge(arrows)
+        arrows = Highlight.unpack(arrows)
+        print("Unpacked", arrows)
+
+        for lineno, highlights in arrows:  # type: ignore
+            yield f" {lineno:>5} | {self.file[lineno,].translated}"
+
+            for subline in self._build_code_sublines(highlights):
+                yield f" {' ':>5} | \x1b[;91m{subline}\x1b[0m"
+
+    def __str__(self):
+        lines = []
+        lines.append(self._path + f" {self.error.name}")
+
+        last = None
+        arrows = []
+        for highlight in sorted(self.error.highlights):
+            if highlight.length is None:
+                continue
+            if last and last.lineno == highlight.lineno:
+                arrows.append(highlight)
+            else:
+                if last:
+                    code = self._build_code_lines(last.lineno, arrows)
+                    lines.extend(code)
+                arrows = [highlight]
+            last = highlight
+        if last:
+            code = self._build_code_lines(last.lineno, arrows)
+            lines.extend(code)
+
+        if len(lines) == 1:
+            lines[0] += f" {self.error.text}"
+        else:
+            lines[0] += f" \x1b[0;91m{self.error.text}\x1b[0m"
+
+        return '\n'.join(lines)
+
+
 class HumanizedErrorsFormatter(_formatter):
     def __str__(self) -> str:
         output = ''
         for file in self.files:
             for error in file.errors:
-                highlight = error.highlights[0]
-                # Location
-                output += f"\x1b[;97m{file.path}:{highlight.lineno}:{highlight.column}\x1b[0m"
-                output += ' ' + error.name
-                if not highlight.length:
-                    output += ' ' + error.text
-                if highlight.length:
-                    # Line
-                    output += f"\n {highlight.lineno:>5} | {file[highlight.lineno,].translated}"
-                    # Arrow
-                    output += "\n       | " + ' ' * (highlight.column - 1)
-                    output += f"\x1b[0;91m{'^' * (highlight.length or 0)} {highlight.hint or error.text}\x1b[0m"
-                output += '\n'
+                frame = Frame(file, error, colorize=self.use_colors)
+                output += str(frame) + '\n'
         return output