add wrapper around interpreter for handling ast parsing

Author: frcl

after/syntax/python.vim

@@ -1 +1 @@
-syntax match evalMarker /#?\s*$/ conceal cchar=#
+"syntax match evalMarker /#?\s*$/ conceal cchar=#

rplugin/python3/mokka/__init__.py

@@ -1,7 +1,7 @@
 import re
 
 import neovim
-from .interpreter import Interpreter
+from .wrapper import Wrapper
 
 
 @neovim.plugin
@@ -26,23 +26,15 @@ def eval_until_current(self, args):
         lineno, _ = self.nvim.current.window.cursor
         buf = self.nvim.current.buffer
 
-        # match current indention level and
-        # append spaces if last line end with ':'
-        spaces = re.match(r'^(\s*)', buf[lineno-2]).group(1)
-        spaces += '    ' if buf[lineno-2].strip().endswith(':') else ''
+        wrapper = Wrapper(buf)
 
-        interpreter = Interpreter(filename=buf.name)
+        try:
+            rep = wrapper.eval_line(lineno)
+        except ValueError:
+            return
+
+        maxlen = 64
+        short = rep[:maxlen-3] + '...' if len(rep) > maxlen else rep
+        # TODO: get window width for dynamic lenght
 
-        # run with `pass` appended using precalulated spaces
-        source = '\n'.join(buf[0:lineno-1]+[spaces+'pass'])
-
-        error_status = interpreter.exec(source)
-        if error_status:
-            buf[lineno-1] = buf[lineno-1] + ' # ' + str(error_status)
-            # TODO: reformat error message (no filename if current file
-        else:
-            value = interpreter.eval(buf[lineno-1])
-            rep = str(value).replace('\n', '')
-            if len(rep) > 32:
-                rep = rep[:29]+'...'
-            buf[lineno-1] = buf[lineno-1] + ' # ' + rep
+        buf[lineno-1] = buf[lineno-1] + ' # ' + short

rplugin/python3/mokka/interpreter.py

@@ -1,5 +1,7 @@
+# pylint: disable=eval-used,exec-used,broad-except
 import types
-from typing import Optional
+import ast
+from typing import Optional, Union
 
 
 class Interpreter(object):
@@ -12,7 +14,7 @@ def __init__(self, filename: str) -> None:
         self.locals = {'__name__': '__console__', '__doc__': None}
         self.filename = filename
 
-    def compile(self, source: str, mode: str) -> types.CodeType:
+    def compile(self, source: Union[ast.AST, str], mode: str) -> types.CodeType:
         """
         Wrapper around builtin compile function.
 
@@ -40,8 +42,22 @@ def eval(self, source: str) -> object:
             code = self.compile(source, 'eval')
         except (OverflowError, SyntaxError, ValueError) as exc:
             return exc
+            # TODO: remove line number and filename from error, it's confusing
 
-        return eval(code, self.locals)
+        return self.eval_code(code)
+
+    def eval_code(self, code: types.CodeType) -> object:
+        """
+        Evaluate a compiled expression in the context of the virtual
+        interpreter.
+
+        Returns:
+        - the object resulting from evaluation if the expression is valid
+        """
+        try:
+            return eval(code, self.locals)
+        except Exception as exc:
+            return exc
 
     def exec(self, source: str) -> Optional[Exception]:
         """
@@ -57,6 +73,19 @@ def exec(self, source: str) -> Optional[Exception]:
         except (OverflowError, SyntaxError, ValueError) as exc:
             return exc
 
-        # TODO: handle other exceptions?
-        exec(code, self.locals)
-        return None
+        return self.exec_code(code)
+
+    def exec_code(self, code: types.CodeType) -> Optional[Exception]:
+        """
+        Execute the source inside the virtual interpreter.
+
+        Returns:
+        - None if the execution was sucessfull
+        - an exception if there is a SyntaxError, ValueError or OverflowError
+        """
+        try:
+            exec(code, self.locals)
+        except Exception as exc:
+            return exc
+        else:
+            return None

rplugin/python3/mokka/wrapper.py

@@ -0,0 +1,98 @@
+import ast
+from .interpreter import Interpreter
+
+
+class Wrapper(object):
+    """
+    wrapper around Interpreter that parses the source and aranges for special
+    syntax elements like assignments, for loops and with statements to be
+    evaluated in a specific sence
+    """
+    ignored_tokens = ('import', 'def', 'for', 'with')
+
+    def __init__(self, buf) -> None:
+        self.filename = buf.name
+        self.buf = buf # TODO: is this necessary?
+
+        try:
+            self.ast = ast.parse('\n'.join(buf))
+            self.msg = None
+        except SyntaxError as exc:
+            self.ast = None
+            self.msg = self._format_exc(exc)
+
+    def _format_exc(self, exc: Exception) -> str:
+        if isinstance(exc, SyntaxError):
+            # text = exc.text.replace("\n", "")
+            # return ('{0.__class__.__name__}: {1}, line {0.lineno}'
+                    # .format(exc, text))
+            return '{0.__class__.__name__}, line {0.lineno}'.format(exc)
+
+        return '{0.__class__.__name__}: {0}'.format(exc)
+
+    def _format_value(self, value: object) -> str:
+        return repr(value).replace('\n', '')
+
+    def eval_line(self, number: int) -> object:
+        """
+        Evaluate a line by number
+
+        Arguments:
+        - number: int
+            number of line to evaluate
+
+        Returns:
+        - result of evaluating the line
+        """
+
+        if self.ast:
+            interpreter = Interpreter(self.filename)
+
+            cur_line = self.buf[number-1].strip()
+            if (not cur_line) or any(cur_line.startswith(token)
+                                     for token in self.ignored_tokens):
+                raise ValueError()
+
+            # constuction area:
+            # =================
+            pre_nodes = []
+
+            def find_cur_node(node):
+                if hasattr(node, 'lineno') and node.lineno == number:
+                    return node
+
+                if hasattr(node, 'body'):
+                    for subn in node.body:
+                        if subn.lineno > number:
+                            break
+                        pre_nodes.append(subn)
+                        nextn = subn
+                else:
+                    return None
+
+                pre_nodes.pop()
+                return find_cur_node(nextn)
+
+            node = find_cur_node(self.ast)
+
+            compiled = interpreter.compile(ast.Module(pre_nodes), 'exec')
+            interpreter.exec_code(compiled)
+
+            if isinstance(node, ast.If):
+                source = node.test
+            else:
+                source = node.value
+
+            compiled = interpreter.compile(ast.Expression(source), 'eval')
+            value = interpreter.eval_code(compiled)
+            # =================
+
+            return self._format_value(value)
+        else:
+            return self.msg
+
+    def eval_range(self, start: int, end: int) -> object:
+        """
+        experimental
+        """
+        pass