changes to warnings (#30)

* changes to warnings

* fix tests

* more tests

* improve coverage

Author: samuelcolvin

devtools/debug.py

@@ -3,10 +3,9 @@
 import os
 import pdb
 import re
-import warnings
 from pathlib import Path
 from textwrap import dedent, indent
-from typing import Generator, List, Optional, Tuple, Type
+from typing import Generator, List, Optional, Tuple
 
 from .ansi import isatty, sformat
 from .prettier import PrettyFormat, env_true
@@ -57,13 +56,14 @@ class DebugOutput:
     Represents the output of a debug command.
     """
     arg_class = DebugArgument
-    __slots__ = 'filename', 'lineno', 'frame', 'arguments'
+    __slots__ = 'filename', 'lineno', 'frame', 'arguments', 'warning'
 
-    def __init__(self, *, filename: str, lineno: int, frame: str, arguments: List[DebugArgument]):
+    def __init__(self, *, filename: str, lineno: int, frame: str, arguments: List[DebugArgument], warning=None):
         self.filename = filename
         self.lineno = lineno
         self.frame = frame
         self.arguments = arguments
+        self.warning = warning
 
     def str(self, highlight=False) -> str:
         if highlight:
@@ -72,8 +72,12 @@ def str(self, highlight=False) -> str:
                 sformat(self.lineno, sformat.green),
                 sformat(self.frame, sformat.green, sformat.italic)
             )
+            if self.warning:
+                prefix += sformat(' ({})'.format(self.warning), sformat.dim)
         else:
             prefix = '{0.filename}:{0.lineno} {0.frame}'.format(self)
+            if self.warning:
+                prefix += ' ({})'.format(self.warning)
         return prefix + '\n    ' + '\n    '.join(a.str(highlight) for a in self.arguments)
 
     def __str__(self) -> str:
@@ -127,15 +131,15 @@ def _process(self, args, kwargs, func_regex) -> DebugOutput:
         curframe = inspect.currentframe()
         try:
             frames = inspect.getouterframes(curframe, context=self._frame_context_length)
-        except IndexError as e:
+        except IndexError:
             # NOTICE: we should really catch all conceivable errors here, if you find one please report.
             # IndexError happens in odd situations such as code called from within jinja templates
-            self._warn('error parsing code, {0.__class__.__name__}: {0}'.format(e), SyntaxWarning)
             return self.output_class(
                 filename='<unknown>',
                 lineno=0,
                 frame='',
-                arguments=list(self._args_inspection_failed(args, kwargs))
+                arguments=list(self._args_inspection_failed(args, kwargs)),
+                warning=self._show_warnings and 'error parsing code, IndexError',
             )
         # BEWARE: this must be called by a method which in turn is called "directly" for the frame to be correct
         call_frame = frames[2]
@@ -150,22 +154,23 @@ def _process(self, args, kwargs, func_regex) -> DebugOutput:
                 pass
 
         if call_frame.code_context:
-            func_ast, code_lines, lineno = self._parse_code(call_frame, func_regex, filename)
+            func_ast, code_lines, lineno, warning = self._parse_code(call_frame, func_regex, filename)
             if func_ast:
                 arguments = list(self._process_args(func_ast, code_lines, args, kwargs))
             else:
                 # parsing failed
                 arguments = list(self._args_inspection_failed(args, kwargs))
         else:
             lineno = call_frame.lineno
-            self._warn('no code context for debug call, code inspection impossible')
+            warning = 'no code context for debug call, code inspection impossible'
             arguments = list(self._args_inspection_failed(args, kwargs))
 
         return self.output_class(
             filename=filename,
             lineno=lineno,
             frame=call_frame.function,
-            arguments=arguments
+            arguments=arguments,
+            warning=self._show_warnings and warning,
         )
 
     def _args_inspection_failed(self, args, kwargs):
@@ -206,17 +211,22 @@ def _process_args(self, func_ast, code_lines, args, kwargs) -> Generator[DebugAr
         for name, value in kwargs.items():
             yield self.output_class.arg_class(value, name=name, variable=kw_arg_names.get(name))
 
-    def _parse_code(self, call_frame, func_regex, filename) -> Tuple[Optional[ast.AST], Optional[List[str]], int]:
+    def _parse_code(
+        self, call_frame, func_regex, filename
+    ) -> Tuple[Optional[ast.AST], Optional[List[str]], int, Optional[str]]:
         call_lines = []
         for line in range(call_frame.index, -1, -1):
-            new_line = call_frame.code_context[line]
+            try:
+                new_line = call_frame.code_context[line]
+            except IndexError:  # pragma: no cover
+                return None, None, line, 'error passing code. line not found'
             call_lines.append(new_line)
             if re.search(func_regex, new_line):
                 break
         call_lines.reverse()
         lineno = call_frame.lineno - len(call_lines) + 1
 
-        original_code = code = dedent(''.join(call_lines))
+        code = dedent(''.join(call_lines))
         func_ast = None
         tail_index = call_frame.index
         try:
@@ -238,18 +248,16 @@ def _parse_code(self, call_frame, func_regex, filename) -> Tuple[Optional[ast.AS
                     break
 
             if not func_ast:
-                self._warn('error passing code:\n"{}"\nError: {}'.format(original_code, e1), SyntaxWarning)
-                return None, None, lineno
+                return None, None, lineno, 'error passing code. Error: {}'.format(e1)
 
         if not isinstance(func_ast, ast.Call):
-            self._warn('error passing code, found {} not Call'.format(func_ast.__class__), SyntaxWarning)
-            return None, None, lineno
+            return None, None, lineno, 'error passing code, found {} not Call'.format(func_ast.__class__)
 
         code_lines = [l for l in code.split('\n') if l]
         # this removes the trailing bracket from the lines of code meaning it doesn't appear in the
         # representation of the last argument
         code_lines[-1] = code_lines[-1][:-1]
-        return func_ast, code_lines, lineno
+        return func_ast, code_lines, lineno, None
 
     @staticmethod
     def _wrap_parse(code, filename):
@@ -271,9 +279,5 @@ def _get_offsets(func_ast):
         for kw in func_ast.keywords:
             yield kw.value.lineno - 2, kw.value.col_offset - len(kw.arg) - 2
 
-    def _warn(self, msg, category: Type[Warning] = RuntimeWarning):
-        if self._show_warnings:
-            warnings.warn(msg, category)
-
 
 debug = Debug()

tests/test_expr_render.py

@@ -169,47 +169,39 @@ def test_multiple_trailing_lines():
 
 def test_syntax_warning():
     # exceed the 4 extra lines which are normally checked
-    with pytest.warns(SyntaxWarning) as warning_checker:
-        v = debug.format(
+    v = debug.format(
+        abs(
             abs(
                 abs(
                     abs(
-                        abs(
-                            -1
-                        )
+                        -1
                     )
                 )
             )
         )
-    assert len(warning_checker) == 1
-    warning = warning_checker.list[0]
-    print(warning.message)
-    assert 'Error: unexpected EOF while parsing (test_expr_render.py' in str(warning.message)
+    )
     # check only the original code is included in the warning
-    assert '-1\n"' in str(warning.message)
     s = re.sub(r':\d{2,}', ':<line no>', str(v))
-    assert (
-        'tests/test_expr_render.py:<line no> test_syntax_warning\n    1 (int)'
-    ) == s
+    assert s.startswith('tests/test_expr_render.py:<line no> test_syntax_warning (error passing code. '
+                        'Error: unexpected EOF while')
 
 
 def test_no_syntax_warning():
     # exceed the 4 extra lines which are normally checked
     debug_ = Debug(warnings=False)
-    with pytest.warns(None) as warning_checker:
-        v = debug_.format(
+    v = debug_.format(
+        abs(
             abs(
                 abs(
                     abs(
-                        abs(
-                            -1
-                        )
+                        -1
                     )
                 )
             )
         )
-        assert 'test_no_syntax_warning\n    1 (int)' in str(v)
-    assert len(warning_checker) == 0
+    )
+    assert '(error passing code' not in str(v)
+    assert 'test_no_syntax_warning' in str(v)
 
 
 def test_await():

tests/test_main.py

@@ -90,17 +90,17 @@ def test_small_call_frame():
 
 def test_small_call_frame_warning():
     debug_ = Debug(frame_context_length=2)
-    with pytest.warns(SyntaxWarning):
-        v = debug_.format(
-            1,
-            2,
-            3,
-        )
+    v = debug_.format(
+        1,
+        2,
+        3,
+    )
     assert re.sub(r':\d{2,}', ':<line no>', str(v)) == (
-        'tests/test_main.py:<line no> test_small_call_frame_warning\n'
-        '    1 (int)\n'
-        '    2 (int)\n'
-        '    3 (int)'
+        "tests/test_main.py:<line no> test_small_call_frame_warning "
+        "(error passing code, found <class '_ast.Tuple'> not Call)\n"
+        "    1 (int)\n"
+        "    2 (int)\n"
+        "    3 (int)"
     )
 
 
@@ -157,10 +157,9 @@ class Bar:
 
 
 def test_eval():
-    with pytest.warns(RuntimeWarning):
-        v = eval('debug.format(1)')
+    v = eval('debug.format(1)')
 
-    assert str(v) == '<string>:1 <module>\n    1 (int)'
+    assert str(v) == '<string>:1 <module> (no code context for debug call, code inspection impossible)\n    1 (int)'
 
 
 def test_warnings_disabled():
@@ -174,27 +173,25 @@ def test_warnings_disabled():
 
 
 def test_eval_kwargs():
-    with pytest.warns(RuntimeWarning):
-        v = eval('debug.format(1, apple="pear")')
+    v = eval('debug.format(1, apple="pear")')
 
     assert set(str(v).split('\n')) == {
-        "<string>:1 <module>",
+        "<string>:1 <module> (no code context for debug call, code inspection impossible)",
         "    1 (int)",
         "    apple: 'pear' (str) len=4",
     }
 
 
 def test_exec(capsys):
-    with pytest.warns(RuntimeWarning):
-        exec(
-            'a = 1\n'
-            'b = 2\n'
-            'debug(b, a + b)'
-        )
+    exec(
+        'a = 1\n'
+        'b = 2\n'
+        'debug(b, a + b)'
+    )
 
     stdout, stderr = capsys.readouterr()
     assert stdout == (
-        '<string>:3 <module>\n'
+        '<string>:3 <module> (no code context for debug call, code inspection impossible)\n'
         '    2 (int)\n'
         '    3 (int)\n'
     )
@@ -209,12 +206,21 @@ def test_colours():
     assert s2 == v.str(), repr(s2)
 
 
+def test_colours_warnings(mocker):
+    mocked_getouterframes = mocker.patch('inspect.getouterframes')
+    mocked_getouterframes.side_effect = IndexError()
+    v = debug.format('x')
+    s = re.sub(r':\d{2,}', ':<line no>', v.str(True))
+    assert s.startswith('\x1b[35m<unknown>'), repr(s)
+    s2 = strip_ansi(s)
+    assert s2 == v.str(), repr(s2)
+
+
 def test_inspect_error(mocker):
     mocked_getouterframes = mocker.patch('inspect.getouterframes')
     mocked_getouterframes.side_effect = IndexError()
-    with pytest.warns(SyntaxWarning):
-        v = debug.format('x')
-    assert str(v) == "<unknown>:0 \n    'x' (str) len=1"
+    v = debug.format('x')
+    assert str(v) == "<unknown>:0  (error parsing code, IndexError)\n    'x' (str) len=1"
 
 
 def test_breakpoint(mocker):

tests/test_timer.py

@@ -1,4 +1,5 @@
 import io
+import re
 from time import sleep
 
 import pytest
@@ -12,7 +13,7 @@ def test_simple():
     with t:
         sleep(0.01)
     v = f.getvalue()
-    assert v == 'foobar: 0.010s elapsed\n'
+    assert re.fullmatch(r'foobar: 0\.01[012]s elapsed\n', v)
 
 
 def test_multiple():