suplemon-editor 0.3.0__py3-none-any.whl

suplemon/modules/reverse.py

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class Reverse(Module):
+    """Reverse text on current line(s)."""
+
+    def run(self, app, editor, args):
+        line_nums = []
+        for cursor in editor.cursors:
+            if cursor.y not in line_nums:
+                line_nums.append(cursor.y)
+                # Reverse string
+                data = editor.lines[cursor.y].data[::-1]
+                editor.lines[cursor.y].set_data(data)
+
+
+module = {
+    "class": Reverse,
+    "name": "upper",
+}

suplemon/modules/rstrip.py

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class RStrip(Module):
+    """Trim whitespace from the end of lines."""
+
+    def run(self, app, editor, args):
+        line_nums = editor.get_lines_with_cursors()
+        for n in line_nums:
+            line = editor.lines[n]
+            line.set_data(line.data.rstrip())
+
+
+module = {
+    "class": RStrip,
+    "name": "rstrip",
+}

suplemon/modules/save.py

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class Save(Module):
+    """Save the current file."""
+
+    def run(self, app, editor, args):
+        return app.save_file()
+
+
+module = {
+    "class": Save,
+    "name": "save",
+}

suplemon/modules/save_all.py

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class SaveAll(Module):
+    """Save all currently open files. Asks for confirmation."""
+
+    def run(self, app, editor, args):
+        if not self.app.ui.query_bool("Save all files?", False):
+            return False
+        for file in app.get_files():
+            file.save()
+
+
+module = {
+    "class": SaveAll,
+    "name": "save_all",
+}

suplemon/modules/sort_lines.py

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class SortLines(Module):
+    """
+    Sort current lines.
+
+    Sorts alphabetically by default.
+    Add 'length' to sort by length.
+    Add 'reverse' to reverse the sorting.
+    """
+
+    def sort_normal(self, line):
+        return line.data
+
+    def sort_length(self, line):
+        return len(line.data)
+
+    def run(self, app, editor, args):
+        args = args.lower()
+
+        sorter = self.sort_normal
+        reverse = True if "reverse" in args else False
+        if "length" in args:
+            sorter = self.sort_length
+
+        indices = editor.get_lines_with_cursors()
+        lines = [editor.get_line(i) for i in indices]
+
+        sorted_lines = sorted(lines, key=sorter, reverse=reverse)
+
+        for i, line in enumerate(sorted_lines):
+            editor.lines[indices[i]] = line
+
+
+module = {
+    "class": SortLines,
+    "name": "sort_lines",
+}

suplemon/modules/strip.py

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class Strip(Module):
+    """Trim whitespace from start and end of lines."""
+
+    def run(self, app, editor, args):
+        line_nums = editor.get_lines_with_cursors()
+        for n in line_nums:
+            line = editor.lines[n]
+            line.set_data(line.data.strip())
+
+
+module = {
+    "class": Strip,
+    "name": "strip",
+}

suplemon/modules/system_clipboard.py

@@ -0,0 +1,121 @@
+# -*- encoding: utf-8
+
+import os
+import shutil
+import subprocess
+from platform import system
+
+from suplemon.suplemon_module import Module
+
+# Windows and WSL both reach the Windows clipboard through powershell
+POWERSHELL = ["powershell.exe", "-noprofile", "-command"]
+
+
+def is_wsl():
+    """Detect WSL, where the Windows clipboard is reachable via powershell.exe."""
+    if system() != "Linux" or not os.path.isfile("/proc/version"):
+        return False
+    try:
+        with open("/proc/version") as f:
+            return "microsoft" in f.read().lower()
+    except OSError:
+        return False
+
+
+class SystemClipboard(Module):
+    """Integrates the system clipboard with suplemon."""
+
+    def init(self):
+        self.init_logging(__name__)
+        self.clipboard = self.detect_clipboard()
+        if not self.clipboard:
+            # No clipboard tool is normal on a headless or minimal system, and
+            # suplemon's own copy/paste works regardless, so this isn't a
+            # warning. Kept at debug level so it stays out of the way.
+            self.logger.debug(
+                "No system clipboard tool found. Install 'xsel', 'xclip', 'wl-clipboard', "
+                "'pbcopy' or 'termux-api' to share the clipboard with other applications.")
+            return False
+        self.bind_event_before("insert", self.insert)
+        self.bind_event_after("copy", self.copy)
+        self.bind_event_after("cut", self.copy)
+
+    def detect_clipboard(self):
+        """Find the commands for the first usable clipboard tool.
+
+        Ordered so the native mechanism wins where more than one is present:
+        Windows and WSL first, then Wayland, then the X11 tools, then Termux.
+
+        :return: Dict with "get" and "set" commands, or False if none found.
+        """
+        if (system() == "Windows" or is_wsl()) and shutil.which("powershell.exe"):
+            return {
+                "get": POWERSHELL + ["Get-Clipboard"],
+                "set": POWERSHELL + ["Set-Clipboard"],
+            }
+        if os.environ.get("WAYLAND_DISPLAY") and shutil.which("wl-copy"):
+            return {"get": ["wl-paste", "-n"], "set": ["wl-copy"]}
+        # xsel and xclip are X11 clients. Being installed isn't enough: with no
+        # DISPLAY they exit with "Can't open display" on every copy and paste.
+        if os.environ.get("DISPLAY"):
+            if shutil.which("xsel"):
+                return {"get": ["xsel", "-b"], "set": ["xsel", "-i", "-b"]}
+            if shutil.which("xclip"):
+                return {
+                    "get": ["xclip", "-selection", "clipboard", "-out"],
+                    "set": ["xclip", "-selection", "clipboard", "-in"],
+                }
+        if shutil.which("pbcopy"):
+            return {"get": ["pbpaste", "-Prefer", "txt"], "set": ["pbcopy"]}
+        if shutil.which("termux-clipboard-get"):
+            return {"get": ["termux-clipboard-get"], "set": ["termux-clipboard-set"]}
+        return False
+
+    def copy(self, event):
+        lines = self.app.get_editor().get_buffer()
+        data = "\n".join([str(line) for line in lines])
+        self.set_clipboard(data)
+
+    def insert(self, event):
+        data = self.get_clipboard()
+        if data is False:
+            # Reading the clipboard failed, leave suplemon's own buffer alone
+            return
+        lines = data.split("\n")
+        self.app.get_editor().set_buffer(lines)
+
+    def get_clipboard(self):
+        try:
+            # stderr is discarded on purpose. curses owns the screen, so
+            # anything a clipboard tool prints lands on top of the editor and
+            # corrupts the display.
+            return subprocess.check_output(
+                self.clipboard["get"],
+                stderr=subprocess.DEVNULL,
+                universal_newlines=True,
+            )
+        except (OSError, subprocess.CalledProcessError):
+            return False
+
+    def set_clipboard(self, data):
+        try:
+            # Both streams go to /dev/null rather than being inherited, for
+            # the same reason as in get_clipboard. Not PIPE: xsel forks a
+            # background process to own the selection, which keeps a piped
+            # stdout open, and communicate() would wait for it forever.
+            p = subprocess.Popen(
+                self.clipboard["set"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            out, err = p.communicate(input=bytes(data, "utf-8"))
+            return out
+        except (OSError, subprocess.CalledProcessError):
+            return False
+
+
+module = {
+    "class": SystemClipboard,
+    "name": "system_clipboard",
+}

suplemon/modules/tabstospaces.py

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class TabsToSpaces(Module):
+    """Convert tab characters to spaces in the entire file."""
+
+    def run(self, app, editor, args):
+        for i, line in enumerate(editor.lines):
+            new = line.data.replace("\t", " "*editor.config["tab_width"])
+            editor.lines[i].set_data(new)
+
+
+module = {
+    "class": TabsToSpaces,
+    "name": "tabstospaces",
+}

suplemon/modules/toggle_whitespace.py

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class ToggleWhitespace(Module):
+    """Toggle visually showing whitespace."""
+
+    def run(self, app, editor, args):
+        # Toggle the boolean
+        new_value = not self.app.config["editor"]["show_white_space"]
+        self.app.config["editor"]["show_white_space"] = new_value
+
+
+module = {
+    "class": ToggleWhitespace,
+    "name": "toggle_whitespace",
+}

suplemon/modules/upper.py

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class Upper(Module):
+    """Transform current lines to upper case."""
+
+    def run(self, app, editor, args):
+        line_nums = []
+        for cursor in editor.cursors:
+            if cursor.y not in line_nums:
+                line_nums.append(cursor.y)
+                data = editor.lines[cursor.y].get_data().upper()
+                editor.lines[cursor.y].set_data(data)
+
+
+module = {
+    "class": Upper,
+    "name": "upper",
+}

suplemon/prompt.py

@@ -0,0 +1,319 @@
+# -*- encoding: utf-8
+"""
+Promts based on the Editor class for querying user input.
+"""
+
+import os
+
+from .editor import Editor
+from .line import Line
+
+
+class Prompt(Editor):
+    """An input prompt based on the Editor."""
+    def __init__(self, app, window):
+        Editor.__init__(self, app, window)
+        self.ready = False
+        self.canceled = False
+        self.input_func = lambda: False
+        self.caption = ""
+
+    def init(self):
+        Editor.init(self)
+        # Remove the find feature, otherwise it can be invoked recursively
+        del self.operations["find"]
+
+    def set_config(self, config):
+        """Set the configuration for the editor."""
+        # Override showing line numbers
+        config["show_line_nums"] = False
+        Editor.set_config(self, config)
+
+    def set_input_source(self, input_func):
+        # Set the input function to use while looping for input
+        self.input_func = input_func
+
+    def on_ready(self):
+        """Accepts the current input."""
+        self.ready = True
+        return
+
+    def on_cancel(self):
+        """Cancels the input prompt."""
+        self.set_data("")
+        self.ready = True
+        self.canceled = True
+        return
+
+    def line_offset(self):
+        """Get the x coordinate of beginning of line."""
+        return len(self.caption)+1
+
+    def render_line_contents(self, line, pos, x_offset, max_len):
+        """Render the prompt line."""
+        x_offset = self.line_offset()
+        # Render the caption
+        self.window.addstr(pos[1], 0, self.caption)
+        # Render input
+        self.render_line_normal(line, pos, x_offset, max_len)
+
+    def handle_input(self, event):
+        """Handle special bindings for the prompt."""
+        if event.key_name in ["ctrl+c", "escape"]:
+            self.on_cancel()
+            return False
+        if event.key_name == "enter":
+            self.on_ready()
+            return False
+
+        return Editor.handle_input(self, event)
+
+    def get_input(self, caption="", initial=""):
+        """Get text input from the user via the prompt."""
+        self.caption = caption
+        self.set_data(initial)
+        self.end()  # Move to the end of the initial text
+
+        self.refresh()
+        success = self.input_loop()
+        if success:
+            return self.get_data()
+        return False
+
+    def input_loop(self):
+        # Run the input loop until ready
+        while not self.ready:
+            event = self.input_func(True)  # blocking
+            if event:
+                self.handle_input(event)
+            self.refresh()
+        if not self.canceled:
+            return True
+
+
+class PromptBool(Prompt):
+    """An input prompt for booleans based on Prompt."""
+
+    def set_value(self, value):
+        self.value = value
+
+    def handle_input(self, event):
+        """Handle special bindings for the prompt."""
+        name = event.key_name
+        if name.lower() == "y":
+            self.set_value(True)
+            self.on_ready()
+            return False
+        if name.lower() == "n":
+            self.set_value(False)
+            self.on_ready()
+            return False
+        Prompt.handle_input(self, event)
+
+    def get_input(self, caption="", initial=False):
+        """Get a boolean value from the user via the prompt."""
+
+        indicator = "[y/N]"
+        if initial:
+            indicator = "[Y/n]"
+
+        self.caption = caption + " " + indicator
+        self.set_value(initial)
+        self.end()  # Move to the end of the initial text
+
+        self.refresh()
+
+        # Run the input loop until ready
+        success = self.input_loop()
+        if success:
+            return self.value
+        return False
+
+
+class PromptPassword(Prompt):
+    """An input prompt for passwords based on Prompt."""
+
+    def render_line_contents(self, line, pos, x_offset, max_len):
+        obscured = Line("*" * len(line))
+        Prompt.render_line_contents(self, obscured, pos, x_offset, max_len)
+
+
+class PromptFiltered(Prompt):
+    """An input prompt that allows intercepting and filtering input events."""
+
+    def __init__(self, app, window, handler=None):
+        Prompt.__init__(self, app, window)
+        self.prompt_handler = handler
+
+    def handle_input(self, event):
+        """Handle special bindings for the prompt."""
+        # The cancel and accept keys are kept for concistency
+        if event.key_name in ["ctrl+c", "escape"]:
+            self.on_cancel()
+            return False
+        if event.key_name == "enter":
+            self.on_ready()
+            return False
+
+        if self.prompt_handler and self.prompt_handler(self, event):
+            # If the prompt handler returns True the default action is skipped
+            return True
+
+        return Editor.handle_input(self, event)
+
+
+class PromptAutocmp(Prompt):
+    """An input prompt with basic autocompletion."""
+
+    def __init__(self, app, window, initial_items=None):
+        Prompt.__init__(self, app, window)
+        # Whether the autocomplete feature is active
+        self.complete_active = False
+        # Index of last item that was autocompleted
+        self.complete_index = 0
+        # Input data to use for autocompletion (stored when autocompletion is activated)
+        self.complete_data = ""
+        # Default autocompletable items
+        self.complete_items = [] if initial_items is None else initial_items
+
+    def handle_input(self, event):
+        """Handle special bindings for the prompt."""
+        name = event.key_name
+        if self.complete_active:
+            # Allow accepting completed directories with enter
+            if name == "enter":
+                if self.has_match():
+                    self.deactivate_autocomplete()
+                    return False
+            # Revert autocompletion with esc
+            if name == "escape":
+                self.revert_autocomplete()
+                self.deactivate_autocomplete()
+                return False
+        if name == "tab":
+            # Run autocompletion when tab is pressed
+            self.autocomplete()
+            # Don't pass the event to the parent class
+            return False
+        elif name == "shift+tab":
+            # Go to previous item when shift+tab is pressed
+            self.autocomplete(previous=True)
+            # Don't pass the event to the parent class
+            return False
+        else:
+            # If any key other than tab is pressed deactivate the autocompleter
+            self.deactivate_autocomplete()
+        Prompt.handle_input(self, event)
+
+    def autocomplete(self, previous=False):
+        data = self.get_data()  # Use the current input by default
+        if self.complete_active:  # If the completer is active use the its initial input value
+            data = self.complete_data
+
+        name = self.get_completable_name(data)
+        items = self.get_completable_items(data)
+
+        # Filter the items by name if the input path contains a name
+        if name:
+            items = self.filter_items(items, name)
+        if not items:
+            # Deactivate completion if there's nothing to complete
+            self.deactivate_autocomplete()
+            return False
+
+        if not self.complete_active:
+            # Initialize the autocompletor
+            self.complete_active = True
+            self.complete_data = data
+            self.complete_index = 0
+        else:
+            # Increment the selected item countor
+            if previous:
+                # Go back
+                self.complete_index -= 1
+                if self.complete_index < 0:
+                    self.complete_index = len(items)-1
+            else:
+                # Go forward
+                self.complete_index += 1
+                if self.complete_index > len(items)-1:
+                    self.complete_index = 0
+
+        item = items[self.complete_index]
+        new_data = self.get_full_completion(data, item)
+        if len(items) == 1:
+            self.deactivate_autocomplete()
+        # Set the input data to the completion and move cursor to the end
+        self.set_data(new_data)
+        self.end()
+
+    def get_completable_name(self, data=""):
+        return data
+
+    def get_completable_items(self, data=""):
+        return self.complete_items
+
+    def get_full_completion(self, data, item):
+        return item
+
+    def has_match(self):
+        return False
+
+    def deactivate_autocomplete(self):
+        self.complete_active = False
+        self.complete_index = 0
+        self.complete_data = ""
+
+    def revert_autocomplete(self):
+        if self.complete_data:
+            self.set_data(self.complete_data)
+
+    def filter_items(self, items, name):
+        """Remove items that don't begin with name. Not case sensitive."""
+        if not name:
+            return items
+        name = name.lower()
+        return [item for item in items if item.lower().startswith(name)]
+
+
+class PromptFile(PromptAutocmp):
+    """An input prompt with path autocompletion based on PromptAutocmp."""
+
+    def __init__(self, app, window):
+        PromptAutocmp.__init__(self, app, window)
+
+    def has_match(self):
+        return os.path.isdir(os.path.expanduser(self.get_data()))
+
+    def get_completable_name(self, data=""):
+        return os.path.basename(data)
+
+    def get_completable_items(self, data=""):
+        return self.get_path_contents(data)  # Get directory listing of input path
+
+    def get_full_completion(self, data, item):
+        return os.path.join(os.path.dirname(data), item)
+
+    def get_path_contents(self, path):
+        path = os.path.dirname(os.path.expanduser(path))
+        # If we get an empty path use the current directory
+        if not path:
+            try:
+                path = os.getcwd()
+            except FileNotFoundError:
+                # This might happen if the cwd has been
+                # removed after starting suplemon.
+                return []
+        # In case we don't have sufficent permissions
+        try:
+            contents = os.listdir(path)
+        except OSError:
+            return []
+        contents.sort()
+        items = []
+        # Append directory separator to directories
+        for item in contents:
+            if os.path.isdir(os.path.join(path, item)):
+                item = item + os.sep
+            items.append(item)
+        return items