spyder-okvim 0.9__py3-none-any.whl

spyder_okvim/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Spyder Project Contributors
+#
+# Licensed under the terms of the MIT License
+# (see LICENSE.txt for details)
+# -----------------------------------------------------------------------------
+"""Spyder OkVim Plugin."""
+
+__version__ = "0.0.1-dev0"

spyder_okvim/conftest.py

@@ -0,0 +1,153 @@
+"""Conftest."""
+# Standard library imports
+import os
+import os.path as osp
+from unittest.mock import Mock
+
+# Third party imports
+import pytest
+import requests
+from pytestqt.plugin import QtBot
+from qtpy.QtGui import QFont
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+from spyder.config.manager import CONF
+from spyder.plugins.editor.widgets.editorstack import EditorStack
+
+# Local imports
+from spyder_okvim.spyder.config import CONF_DEFAULTS, CONF_SECTION
+from spyder_okvim.spyder.plugin import OkVim
+
+LOCATION = osp.realpath(osp.join(os.getcwd(), osp.dirname(__file__)))
+
+
+class VimTesting(OkVim):
+    CONF_FILE = False
+    CONF_SECTION = CONF_SECTION
+
+
+class EditorMock(QWidget):
+    """Editor plugin mock."""
+
+    def __init__(self, editor_stack):
+        """Editor Mock constructor."""
+        QWidget.__init__(self, None)
+        self.editor_stack = editor_stack
+        self.editorsplitter = self.editor_stack
+        self.open_action = Mock()
+        self.new_action = Mock()
+        self.save_action = Mock()
+        self.close_action = Mock()
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.editor_stack)
+        self.setLayout(layout)
+
+    def get_widget(self):
+        """Return self, mimicking Spyder 6 API."""
+        return self
+
+    def get_current_editorstack(self):
+        """Return EditorStack instance."""
+        return self.editor_stack
+
+
+class StatusBarMock(QWidget):
+    """Stausbar mock."""
+
+    def __init__(self):
+        QWidget.__init__(self, None)
+        self.layout = QVBoxLayout()
+        self.setLayout(self.layout)
+
+    def add_status_widget(self, widget):
+        self.layout.addWidget(widget)
+
+
+class MainMock(QWidget):
+    """Spyder MainWindow mock."""
+
+    def __init__(self, editor_stack, qtbot_module):
+        """Main Window Mock constructor."""
+        QWidget.__init__(self, None)
+        self.main = QWidget()
+        self.plugin_focus_changed = Mock()
+        self.editor = EditorMock(editor_stack)
+        self.status_bar = StatusBarMock()
+        self.projects = Mock()
+        self.open_file = Mock()
+        self.projects.get_active_project_path = lambda: None
+        layout = QVBoxLayout()
+        layout.addWidget(self.editor)
+        layout.addWidget(self.status_bar)
+        self.setLayout(layout)
+
+        for name, dict_info in CONF_DEFAULTS:
+            if name != CONF_SECTION:
+                continue
+            for key, val in dict_info.items():
+                CONF.set(name, key, val)
+
+        self.add_dockwidget = Mock()
+
+        qtbot_module.add_widget(self.main)
+        qtbot_module.add_widget(self.editor)
+        qtbot_module.add_widget(self.status_bar)
+
+    def get_plugin(self, dummy, error=True):
+        return self.status_bar
+
+
+@pytest.fixture(scope="session")
+def qtbot_module(qapp, request):
+    """Module fixture for qtbot."""
+    result = QtBot(request)
+    return result
+
+
+@pytest.fixture(scope="session", autouse=True)
+def vim_bot(qtbot_module):
+    """Editorstack pytest fixture."""
+    text = (
+        "   123\n" "line 1\n" "line 2\n" "line 3\n" "line 4"
+    )  # a newline is added at end
+    editor_stack = EditorStack(None, [])
+
+    # Fix the area of the selection
+    font = QFont("Courier New")
+    font.setPointSize(10)
+    editor_stack.set_default_font(font)
+    editor_stack.setMinimumWidth(400)
+    editor_stack.setMinimumHeight(400)
+
+    editor_stack.set_find_widget(Mock())
+    editor_stack.set_io_actions(Mock(), Mock(), Mock(), Mock())
+    finfo0 = editor_stack.new(osp.join(LOCATION, "foo.py"), "utf-8", text)
+    finfo1 = editor_stack.new(osp.join(LOCATION, "foo1.py"), "utf-8", text)
+    finfo2 = editor_stack.new(osp.join(LOCATION, "foo2.py"), "utf-8", text)
+    finfo3 = editor_stack.new(osp.join(LOCATION, "foo3.py"), "utf-8", text)
+    main = MainMock(editor_stack, qtbot_module)
+
+    vim = VimTesting(main, None)
+    vim.on_initialize()
+
+    qtbot_module.addWidget(editor_stack)
+    qtbot_module.addWidget(finfo0.editor)
+    qtbot_module.addWidget(finfo1.editor)
+    qtbot_module.addWidget(finfo2.editor)
+    qtbot_module.addWidget(finfo3.editor)
+    qtbot_module.addWidget(main)
+
+    # Show GUI
+    main.show()
+    yield main, editor_stack, finfo0.editor, vim, qtbot_module
+
+    finfo0.editor.close()
+    finfo1.editor.close()
+    finfo2.editor.close()
+    finfo3.editor.close()
+    finfo0.deleteLater()
+    finfo1.deleteLater()
+    finfo2.deleteLater()
+    finfo3.deleteLater()
+    editor_stack.deleteLater()
+

spyder_okvim/executor/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+"""Excecutor __init__."""
+# %% Import
+# Local imports
+from .executor_normal import ExecutorNormalCmd
+from .executor_visual import ExecutorVisualCmd
+from .executor_vline import ExecutorVlineCmd
+from .executor_leader import ExecutorLeaderKey

spyder_okvim/executor/executor_base.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""."""
+# %% Import
+# Standard library imports
+from typing import NamedTuple, Any, List
+
+# Local imports
+from spyder_okvim.utils.helper_motion import HelperMotion
+from spyder_okvim.utils.helper_action import HelperAction
+
+FUNC_INFO = NamedTuple("FUNC_INFO", [("func", Any), ("has_arg", bool)])
+RETURN_EXECUTOR_METHOD_INFO = NamedTuple(
+    "RETURN_EXECUTOR_METHOD_INFO", [("sub_mode", Any), ("clear_command_line", bool)]
+)
+
+
+class ExecutorBase:
+    """Baseclass Executor."""
+
+    SYMBOLS_REPLACEMENT = {
+        "!": "exclamation",
+        "?": "question",
+        "<": "less",
+        ">": "greater",
+        "|": "pipe",
+        " ": "space",
+        "\b": "backspace",
+        "\r": "enter",
+        "@": "at",
+        "$": "dollar",
+        "0": "zero",
+        "^": "caret",
+        '"': "quote",
+        "%": "percent",
+        "~": "tilde",
+        ":": "colon",
+        "/": "slash",
+        ";": "semicolon",
+        ",": "comma",
+        ".": "dot",
+        "[": "opensquarebracket",
+        "]": "closesquarebracket",
+        "*": "asterisk",
+        "#": "sharp",
+    }
+
+    def __init__(self, vim_status):
+        """__init__.
+
+        Parameters
+        ----------
+        vim_status : spyder_okvim.utils.vim_status.VimStatus
+            vim status
+
+        """
+        self.vim_status = vim_status
+        self.get_cursor = vim_status.get_cursor
+        self.set_cursor = vim_status.set_cursor
+        self.get_editor = vim_status.get_editor
+        self.get_editorstack = vim_status.get_editorstack
+        self.get_block_no_start_in_selection = (
+            vim_status.get_block_no_start_in_selection
+        )
+        self.get_block_no_end_in_selection = vim_status.get_block_no_end_in_selection
+        self.get_pos_start_in_selection = vim_status.get_pos_start_in_selection
+        self.get_pos_end_in_selection = vim_status.get_pos_end_in_selection
+        self.set_cursor_pos = vim_status.cursor.set_cursor_pos
+        self.helper_motion = HelperMotion(vim_status)
+        self.helper_action = HelperAction(vim_status)
+
+        self.has_zero_cmd = True
+        self.pattern_cmd = None
+        self.allow_leaderkey = True
+
+    def update_input_cmd_info(self, num_str, cmd, input_txt):
+        """Update input cmd to vim_status."""
+        self.vim_status.input_cmd_prev.set(self.vim_status.input_cmd)
+        self.vim_status.input_cmd.num_str = num_str
+        self.vim_status.input_cmd.cmd = cmd
+
+    def set_parent_info_to_submode(self, submode, num, num_str):
+        """Set info to submode."""
+        submode.parent_num = [num]
+        submode.parent_num_str = [num_str]
+
+    def __call__(self, txt):
+        """Parse txt and executor command.
+
+        Returns
+        -------
+        bool
+            if return is True, Clear command line
+
+        """
+        if self.has_zero_cmd and txt == "0":
+            # Special case to simplify regexp
+            key = "0"
+            num_str = "1"
+        else:
+            match = self.pattern_cmd.match(txt)
+            if not match:
+                if txt.isdigit():
+                    return False
+                else:
+                    self.vim_status.sub_mode = None
+                    return True
+
+            num_str, key = match.groups()
+
+        num = int(num_str) if num_str else 1
+        self.update_input_cmd_info(num_str, key, txt)
+
+        key = self.SYMBOLS_REPLACEMENT.get(key, key)
+
+        ret = None
+        try:
+            method = self.__getattribute__(key)
+        except AttributeError:
+            print("unknown key", key)
+        else:
+            ret = method(num=num, num_str=num_str)
+
+        return self.process_return(ret)
+
+    def process_return(self, ret: Any):
+        """Process return of method."""
+        if ret:
+            self.vim_status.sub_mode = ret.sub_mode
+            return ret.clear_command_line
+        else:
+            self.vim_status.sub_mode = None
+            return True
+
+
+class ExecutorSubBase(ExecutorBase):
+    """Baseclass for submode of executor."""
+
+    def __init__(self, vim_status):
+        super().__init__(vim_status)
+
+        self.has_zero_cmd = False
+        self.parent_num = []
+        self.parent_num_str = []
+        self.func_list_deferred: List[FUNC_INFO] = []
+        self.return_deferred: Any = None
+
+    def set_parent_info_to_submode(self, submode, num, num_str):
+        """Set parent and self into to submode."""
+        submode.parent_num = self.parent_num.copy()
+        submode.parent_num_str = self.parent_num_str.copy()
+
+        submode.parent_num.append(num)
+        submode.parent_num_str.append(num_str)
+
+    def set_func_list_deferred(self, f_list: List[FUNC_INFO], ret: Any = None):
+        """Set func list."""
+        self.func_list_deferred = f_list
+        self.return_deferred = ret
+
+    def execute_func_deferred(self, arg=None):
+        """Execute method passed in from previous executor."""
+        for func_info in self.func_list_deferred:
+            if func_info.has_arg:
+                func_info.func(arg)
+            else:
+                func_info.func()
+        return self.return_deferred
+
+    def update_input_cmd_info(self, num_str, cmd, input_txt):
+        """Add input cmd to vim_status."""
+        self.vim_status.input_cmd.cmd += input_txt

spyder_okvim/executor/executor_colon.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+"""."""
+# Local imports
+from spyder_okvim.executor.executor_base import ExecutorSubBase
+
+
+class ExecutorColon(ExecutorSubBase):
+    """Execute the method by enter."""
+
+    def __init__(self, vim_status):
+        super().__init__(vim_status)
+        self.allow_leaderkey = False
+
+        self.editor_widget = vim_status.editor_widget
+
+    def __call__(self, txt):
+        """Parse txt and executor command.
+
+        Returns
+        -------
+        bool
+            if return is True, Clear command line
+
+        """
+        if txt[-1] == "\b":
+            cmd_line = self.vim_status.cmd_line
+            if len(txt) <= 2:
+                self.vim_status.sub_mode = None
+                return True
+            else:
+                cmd_line.setText(txt[:-2])
+        if txt[-1] != "\r":
+            return False
+
+        if txt[0] != ":" or len(txt) <= 2:
+            self.vim_status.sub_mode = None
+            return True
+
+        # ':' is saved to input cmd_info at ExecutorBase.
+        # So we need only txt[1:].
+        self.update_input_cmd_info(None, None, txt[1:])
+
+        txt = txt[1:-1]  # remove :, \r
+        cmd = txt.split(None, 1)
+        args = cmd[1] if len(cmd) > 1 else ""
+        cmd = cmd[0]
+
+        for symbol, text in self.SYMBOLS_REPLACEMENT.items():
+            cmd = cmd.replace(symbol, text)
+
+        try:
+            method = self.__getattribute__(cmd)
+        except AttributeError:
+            print("unknown command", cmd)
+        else:
+            method(args)
+
+        self.vim_status.sub_mode = None
+
+        return True
+
+    def w(self, arg=""):
+        """Save current file."""
+        self.editor_widget.get_widget().save_action.trigger()
+        self.vim_status.cursor.draw_vim_cursor()
+
+    def q(self, arg=""):
+        """Close current file."""
+        self.editor_widget.get_widget().close_action.trigger()
+        self.vim_status.set_focus_to_vim()
+
+    def qexclamation(self, arg=""):
+        """Close current file without saving."""
+        # TODO :
+        self.editor_widget.get_widget().close_action.trigger()
+        self.vim_status.set_focus_to_vim()
+
+    def wq(self, arg=""):
+        """Save and close current file."""
+        self.w(arg)
+        self.q()
+
+    def n(self, args=""):
+        """Create new file."""
+        self.editor_widget.get_widget().new_action.trigger()
+        self.vim_status.set_focus_to_vim()