suplemon-editor 0.3.2__tar.gz → 0.3.4__tar.gz

{suplemon_editor-0.3.2/suplemon_editor.egg-info → suplemon_editor-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: suplemon-editor
-Version: 0.3.2
+Version: 0.3.4
 Summary: Console text editor with multi cursor support. Maintained fork of Suplemon.
 Home-page: https://github.com/leancode/suplemon/
 Author: Richard Lewis
@@ -67,10 +67,11 @@ https://github.com/leancode/suplemon
 This is an actively maintained fork of [richrd/suplemon](https://github.com/richrd/suplemon).
 
 The original is a genuinely good editor and none of the design here is ours.
-Upstream simply stopped: the last commit to `master` landed in January 2021,
-the `dev` branch in June 2020, and 25 issues and 5 pull requests are still
-open, some since 2016. Suplemon had also stopped running altogether on
-Python 3.12 and newer, which is what prompted the fork.
+Upstream simply stopped. The last change of any substance to `master` was on
+11 December 2019; the only two commits since were README image URL edits in
+January 2021. The `dev` branch last moved in June 2020. 25 issues and 5 pull
+requests are still open, some since 2016. Suplemon had also stopped running
+altogether on Python 3.12 and newer, which is what prompted the fork.
 
 Since then this fork has:
 
@@ -196,13 +197,31 @@ That works because the launcher hard-codes an absolute path to the source
 tree. `$HOME` is root's under sudo, so a launcher written in terms of
 `$HOME` would look for the interpreter in the wrong place.
 
-If you do this often, either add `~/.local/bin` to `secure_path` in
-`visudo`, or use `sudoedit`, which copies the file to a temporary location,
+If you do this often, link the launcher somewhere sudo already looks.
+`/usr/local/bin` is on `secure_path` on every system I know of, so this makes
+`sudo suplemon` work by name:
+
+    sudo ln -sf ~/.local/bin/suplemon /usr/local/bin/suplemon && sudo ln -sf ~/.local/bin/suplemon /usr/local/bin/se
+
+`install.sh` prints this command for you, and skips it if something that is
+not ours already sits at either name — a stream editor called `se` exists, and
+silently replacing it would be rude.
+
+Links rather than copies, so re-running `install.sh` keeps them current; a
+copy would quietly go stale. The launcher holds an absolute path to your own
+source tree, so these run your checkout whoever invokes them: fine on a
+single-user machine, probably not on a shared one. `uninstall.sh` will not
+remove them, since it only touches `~/.local`, but it does tell you they are
+there.
+
+The alternative is `sudoedit`, which copies the file to a temporary location,
 opens it as you rather than as root, and copies it back:
 
     SUDO_EDITOR=~/.local/bin/suplemon sudoedit /etc/hosts
 
-`sudoedit` is the safer of the two: the editor never runs as root.
+`sudoedit` is the safest of the three: the editor never runs as root at all,
+so nothing it loads — modules, your config, a theme — is running with
+privileges.
 
 
 ### Notes
@@ -535,3 +554,25 @@ have a too steep learning curve. For them (like for me) nano was the weapon of
 choice. But nano feels clunky and it has its limitations. That's why
 I wrote my own editor with built in multi cursor support to fix the situation.
 Another reason is that developing Suplemon is simply fun to do.
+
+### Why this fork exists
+
+*— leancode*
+
+I had a shared FreeBSD account with nano on it and nothing else. I normally
+use [ne](https://ne.di.unimi.it/), but there was no binary I could install
+without a compiler or a package manager, and a shared account gives you
+neither. What it did have was Python 3.
+
+That turns out to be the interesting thing about Suplemon. Most of the good
+terminal editors — kakoune, helix, micro — ship as compiled binaries, so on
+a locked down box you are back to whatever the host chose to install for
+you. Anywhere Python 3 runs, `pip install suplemon-editor` gets you a real
+editor with multiple cursors, and that covers a lot of machines where you
+are not allowed to build anything.
+
+I liked it enough to keep it working. It had stopped running on Python 3.12
+when `imp` was removed, and the upstream repository had been quiet since
+2019, so this fork picks it up rather than switching to something else.
+Needing a feature and being able to write it, or hitting a bug and being
+able to fix it that afternoon, is the rest of the appeal.

{suplemon_editor-0.3.2 → suplemon_editor-0.3.4}/README.md

@@ -26,10 +26,11 @@ https://github.com/leancode/suplemon
 This is an actively maintained fork of [richrd/suplemon](https://github.com/richrd/suplemon).
 
 The original is a genuinely good editor and none of the design here is ours.
-Upstream simply stopped: the last commit to `master` landed in January 2021,
-the `dev` branch in June 2020, and 25 issues and 5 pull requests are still
-open, some since 2016. Suplemon had also stopped running altogether on
-Python 3.12 and newer, which is what prompted the fork.
+Upstream simply stopped. The last change of any substance to `master` was on
+11 December 2019; the only two commits since were README image URL edits in
+January 2021. The `dev` branch last moved in June 2020. 25 issues and 5 pull
+requests are still open, some since 2016. Suplemon had also stopped running
+altogether on Python 3.12 and newer, which is what prompted the fork.
 
 Since then this fork has:
 
@@ -155,13 +156,31 @@ That works because the launcher hard-codes an absolute path to the source
 tree. `$HOME` is root's under sudo, so a launcher written in terms of
 `$HOME` would look for the interpreter in the wrong place.
 
-If you do this often, either add `~/.local/bin` to `secure_path` in
-`visudo`, or use `sudoedit`, which copies the file to a temporary location,
+If you do this often, link the launcher somewhere sudo already looks.
+`/usr/local/bin` is on `secure_path` on every system I know of, so this makes
+`sudo suplemon` work by name:
+
+    sudo ln -sf ~/.local/bin/suplemon /usr/local/bin/suplemon && sudo ln -sf ~/.local/bin/suplemon /usr/local/bin/se
+
+`install.sh` prints this command for you, and skips it if something that is
+not ours already sits at either name — a stream editor called `se` exists, and
+silently replacing it would be rude.
+
+Links rather than copies, so re-running `install.sh` keeps them current; a
+copy would quietly go stale. The launcher holds an absolute path to your own
+source tree, so these run your checkout whoever invokes them: fine on a
+single-user machine, probably not on a shared one. `uninstall.sh` will not
+remove them, since it only touches `~/.local`, but it does tell you they are
+there.
+
+The alternative is `sudoedit`, which copies the file to a temporary location,
 opens it as you rather than as root, and copies it back:
 
     SUDO_EDITOR=~/.local/bin/suplemon sudoedit /etc/hosts
 
-`sudoedit` is the safer of the two: the editor never runs as root.
+`sudoedit` is the safest of the three: the editor never runs as root at all,
+so nothing it loads — modules, your config, a theme — is running with
+privileges.
 
 
 ### Notes
@@ -494,3 +513,25 @@ have a too steep learning curve. For them (like for me) nano was the weapon of
 choice. But nano feels clunky and it has its limitations. That's why
 I wrote my own editor with built in multi cursor support to fix the situation.
 Another reason is that developing Suplemon is simply fun to do.
+
+### Why this fork exists
+
+*— leancode*
+
+I had a shared FreeBSD account with nano on it and nothing else. I normally
+use [ne](https://ne.di.unimi.it/), but there was no binary I could install
+without a compiler or a package manager, and a shared account gives you
+neither. What it did have was Python 3.
+
+That turns out to be the interesting thing about Suplemon. Most of the good
+terminal editors — kakoune, helix, micro — ship as compiled binaries, so on
+a locked down box you are back to whatever the host chose to install for
+you. Anywhere Python 3 runs, `pip install suplemon-editor` gets you a real
+editor with multiple cursors, and that covers a lot of machines where you
+are not allowed to build anything.
+
+I liked it enough to keep it working. It had stopped running on Python 3.12
+when `imp` was removed, and the upstream repository had been quiet since
+2019, so this fork picks it up rather than switching to something else.
+Needing a feature and being able to write it, or hitting a bug and being
+able to fix it that afternoon, is the rest of the appeal.

{suplemon_editor-0.3.2 → suplemon_editor-0.3.4}/suplemon/editor.py

@@ -56,6 +56,9 @@ class Editor(Viewer):
         self.current_state = 0
         # Last editor action that was used (for undo/redo)
         self.last_action = None
+        # True while a bracketed paste is being inserted. Auto indent
+        # and per-keystroke undo states are both wrong during one.
+        self.pasting = False
 
     def init(self):
         Viewer.init(self)
@@ -109,14 +112,22 @@ class Editor(Viewer):
 
     def store_action_state(self, action, state=None):
         """Store the editor state if a new action is taken."""
+        if self.pasting:
+            # The whole paste is one action. Its state was stored before
+            # insertion began, so undo puts back what was there before.
+            return
         if self.last_action != action:
             self.last_action = action
             self.store_state(state)
-        else:
-            # FIXME: This if is here just for safety.
-            # FIXME: current_state might be wrong ;.<
-            if self.current_state < len(self.history)-1:
-                self.history[self.current_state].store(self)
+        elif self.current_state > 0:
+            # Same action continuing, so fold it into the state this run
+            # already created rather than making a new one. The guard used
+            # to be current_state < len(history)-1, which is never true
+            # while editing forwards: store_state leaves current_state at
+            # the end of the history. So a run was only ever recorded as
+            # its first keystroke, and the next different action left an
+            # undo point holding one character of what the user had typed.
+            self.history[self.current_state].store(self)
 
     def store_state(self, state=None, action=None):
         """Store the current editor state for undo/redo."""
@@ -364,7 +375,7 @@ class Editor(Viewer):
             # Leave the beginning of the line
             self.lines[cursor.y].set_data(start)
             wspace = ""
-            if self.config["auto_indent_newline"]:
+            if self.config["auto_indent_newline"] and not self.pasting:
                 wspace = helpers.leading_whitespace(self.lines[cursor.y])
             self.lines.insert(cursor.y+1, Line(wspace+end))
             self.move_y_cursors(cursor.y, 1)
@@ -531,6 +542,32 @@ class Editor(Viewer):
         # Add a restore point if previous action != type
         self.store_action_state("type")
 
+    def insert_text(self, text):
+        """Insert pasted text literally, without auto indent.
+
+        A paste arrives as ordinary keystrokes, so auto indent fires on
+        every newline and prepends the previous line's whitespace to a line
+        that already carries its own. Over a block of text that compounds
+        line by line into a staircase. The terminal tells us where a paste
+        starts and ends, so suppress it for the duration.
+
+        :param str text: Text to insert at the cursor(s).
+        """
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+        self.pasting = True
+        try:
+            for i, line in enumerate(text.split("\n")):
+                if i:
+                    self.enter()
+                if line:
+                    self.type(line)
+        finally:
+            self.pasting = False
+        # Stored once, after the insertion, the same way type() and enter()
+        # do it. The flag kept the per-keystroke stores from piling up, so
+        # one undo steps over the whole paste rather than part of it.
+        self.store_action_state("paste")
+
     def type_at_cursor(self, cursor, data):
         """Insert data at specified cursor."""
         line = self.lines[cursor.y]

{suplemon_editor-0.3.2 → suplemon_editor-0.3.4}/suplemon/main.py

@@ -6,6 +6,7 @@ The main class that starts and runs Suplemon.
 
 
 import os
+import curses
 import sys
 
 from . import ui
@@ -18,7 +19,13 @@ from .logger import logger
 from .config import Config
 from .editor import Editor
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"
+
+
+# ncurses only defines BUTTON5 when built with NCURSES_MOUSE_VERSION 2.
+# Without it there is no wheel-down event to match, so scrolling down is
+# simply unavailable rather than mismatched.
+BUTTON5_PRESSED = getattr(curses, "BUTTON5_PRESSED", 0)
 
 
 class App:
@@ -307,8 +314,22 @@ class App:
             return self.handle_key(event)
         elif event.type == "mouse":
             return self.handle_mouse(event)
+        elif event.type == "paste":
+            return self.handle_paste(event)
         return False
 
+    def handle_paste(self, event):
+        """Insert text the terminal reported as a paste.
+
+        :param event: Event instance carrying the text in .data.
+        :return: Boolean indicating if the event was handled.
+        :rtype: boolean
+        """
+        if not event.data:
+            return False
+        self.get_editor().insert_text(event.data)
+        return True
+
     def handle_key(self, event):
         """Handle a key input event.
 
@@ -340,13 +361,18 @@ class App:
         :rtype: boolean
         """
         editor = self.get_editor()
-        if event.mouse_code == 1:                    # Left mouse button release
+        code = event.mouse_code
+        # These were hardcoded integers matching NCURSES_MOUSE_VERSION 1,
+        # which gave each button six bits. Version 2 packs them into five to
+        # make room for button 5, so every value except BUTTON1_RELEASED
+        # moved and only left click still worked. Ask curses instead.
+        if code & curses.BUTTON1_RELEASED:
             editor.set_single_cursor(event.mouse_pos)
-        elif event.mouse_code == 4096:               # Right mouse button release
+        elif code & curses.BUTTON3_RELEASED:
             editor.add_cursor(event.mouse_pos)
-        elif event.mouse_code == 524288:             # Wheel up
+        elif code & curses.BUTTON4_PRESSED:          # Wheel up
             editor.jump_up()
-        elif event.mouse_code == 134217728:          # Wheel down(and unfortunately left button drag)
+        elif BUTTON5_PRESSED and code & BUTTON5_PRESSED:
             editor.jump_down()
         else:
             return False

{suplemon_editor-0.3.2 → suplemon_editor-0.3.4}/suplemon/ui.py

@@ -4,6 +4,7 @@ Curses user interface.
 """
 
 import os
+import sys
 import logging
 from wcwidth import wcswidth
 
@@ -15,6 +16,13 @@ from .key_mappings import key_map
 curses = None
 
 
+# What the terminal wraps a paste in when bracketed paste mode is on.
+# curses has no terminfo entry for these, so they arrive as plain
+# characters and have to be recognised here.
+PASTE_START = "\x1b[200~"
+PASTE_END = "\x1b[201~"
+
+
 class InputEvent:
     """Represents a keyboard or mouse event."""
     def __init__(self):
@@ -24,6 +32,7 @@ class InputEvent:
         self.is_typeable = False
         self.curses_key_name = None
         self.mouse_code = None
+        self.data = None  # Pasted text, for events of type 'paste'
         self.mouse_pos = (0, 0)
         self.logger = logging.getLogger("{0}.InputEvent".format(__name__))
 
@@ -39,6 +48,12 @@ class InputEvent:
         self.type = "key"
         self.key_name = name
 
+    def set_paste_data(self, data):
+        """Turn this into a paste event carrying the pasted text."""
+        self.type = "paste"
+        self.data = data
+        return self
+
     def parse_mouse_state(self, state):
         """Parse curses mouse events."""
         self.type = "mouse"
@@ -166,15 +181,35 @@ class UI:
 
         self.current_yx = self.screen.getmaxyx()  # For checking resize
         self.setup_mouse()
+        self.setup_bracketed_paste(True)
         self.setup_windows()
 
+    def setup_bracketed_paste(self, enable):
+        """Turn the terminal's bracketed paste mode on or off.
+
+        With it on, a paste arrives wrapped in ESC[200~ and ESC[201~ so it
+        can be told apart from typing. Terminals that don't support it
+        ignore the sequence and nothing changes.
+
+        :param bool enable: True to turn it on, False to turn it off.
+        """
+        try:
+            sys.stdout.write("\033[?2004h" if enable else "\033[?2004l")
+            sys.stdout.flush()
+        except (OSError, ValueError):
+            # Not fatal: without it, pastes are simply indistinguishable
+            # from typing, which is how it behaved before.
+            self.logger.debug("Could not set bracketed paste mode.")
+
     def unload(self):
         """Unload curses."""
+        # Leave the terminal as we found it. Without this the shell keeps
+        # receiving paste markers after suplemon exits.
+        self.setup_bracketed_paste(False)
         # Don't call curses.endwin() here. self.run() drives the app via
         # curses.wrapper(), which always calls endwin() itself when it
         # returns. Ending the screen twice makes modern ncurses return ERR,
         # which Python raises as _curses.error on exit.
-        pass
 
     def setup_mouse(self):
         # Mouse support
@@ -623,11 +658,73 @@ class UI:
                 if state:
                     event.parse_mouse_state(state)
                     return event
+            elif char == "\x1b" and self.match_sequence(PASTE_START[1:]):
+                return event.set_paste_data(self.read_paste())
             else:
                 event.parse_key_code(char)
                 return event
         return False
 
+    def match_sequence(self, rest):
+        """Check whether the characters after ESC are `rest`.
+
+        Reads without blocking and pushes back anything that does not
+        match, so an ESC that starts something else, or a lone ESC key
+        press, is handed on untouched.
+
+        :param str rest: Expected characters following the escape.
+        :return: True if they were consumed, False if pushed back.
+        :rtype: boolean
+        """
+        seen = ""
+        self.screen.nodelay(1)
+        try:
+            for expected in rest:
+                try:
+                    c = self.screen.get_wch()
+                except (curses.error, KeyboardInterrupt):
+                    c = None
+                if c != expected:
+                    if c is not None:
+                        seen += str(c)
+                    for ch in reversed(seen):
+                        try:
+                            curses.unget_wch(ch)
+                        except (curses.error, TypeError):
+                            pass
+                    return False
+                seen += str(c)
+        finally:
+            self.screen.nodelay(0)
+        return True
+
+    def read_paste(self):
+        """Read a paste up to the closing marker and return its text.
+
+        :return: The pasted text, without the markers.
+        :rtype: str
+        """
+        data = []
+        while True:
+            try:
+                c = self.screen.get_wch()
+            except KeyboardInterrupt:
+                break
+            except curses.error:
+                break
+            if c == "\x1b":
+                if self.match_sequence(PASTE_END[1:]):
+                    break
+                # An ESC inside the payload is content, not a marker.
+                data.append(c)
+                continue
+            if isinstance(c, int):
+                # A translated key code cannot appear in pasted text;
+                # ignore rather than corrupt the payload with a number.
+                continue
+            data.append(c)
+        return "".join(data)
+
     def is_mouse(self, key):
         """Check for mouse events"""
         return key == curses.KEY_MOUSE

{suplemon_editor-0.3.2 → suplemon_editor-0.3.4/suplemon_editor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: suplemon-editor
-Version: 0.3.2
+Version: 0.3.4
 Summary: Console text editor with multi cursor support. Maintained fork of Suplemon.
 Home-page: https://github.com/leancode/suplemon/
 Author: Richard Lewis
@@ -67,10 +67,11 @@ https://github.com/leancode/suplemon
 This is an actively maintained fork of [richrd/suplemon](https://github.com/richrd/suplemon).
 
 The original is a genuinely good editor and none of the design here is ours.
-Upstream simply stopped: the last commit to `master` landed in January 2021,
-the `dev` branch in June 2020, and 25 issues and 5 pull requests are still
-open, some since 2016. Suplemon had also stopped running altogether on
-Python 3.12 and newer, which is what prompted the fork.
+Upstream simply stopped. The last change of any substance to `master` was on
+11 December 2019; the only two commits since were README image URL edits in
+January 2021. The `dev` branch last moved in June 2020. 25 issues and 5 pull
+requests are still open, some since 2016. Suplemon had also stopped running
+altogether on Python 3.12 and newer, which is what prompted the fork.
 
 Since then this fork has:
 
@@ -196,13 +197,31 @@ That works because the launcher hard-codes an absolute path to the source
 tree. `$HOME` is root's under sudo, so a launcher written in terms of
 `$HOME` would look for the interpreter in the wrong place.
 
-If you do this often, either add `~/.local/bin` to `secure_path` in
-`visudo`, or use `sudoedit`, which copies the file to a temporary location,
+If you do this often, link the launcher somewhere sudo already looks.
+`/usr/local/bin` is on `secure_path` on every system I know of, so this makes
+`sudo suplemon` work by name:
+
+    sudo ln -sf ~/.local/bin/suplemon /usr/local/bin/suplemon && sudo ln -sf ~/.local/bin/suplemon /usr/local/bin/se
+
+`install.sh` prints this command for you, and skips it if something that is
+not ours already sits at either name — a stream editor called `se` exists, and
+silently replacing it would be rude.
+
+Links rather than copies, so re-running `install.sh` keeps them current; a
+copy would quietly go stale. The launcher holds an absolute path to your own
+source tree, so these run your checkout whoever invokes them: fine on a
+single-user machine, probably not on a shared one. `uninstall.sh` will not
+remove them, since it only touches `~/.local`, but it does tell you they are
+there.
+
+The alternative is `sudoedit`, which copies the file to a temporary location,
 opens it as you rather than as root, and copies it back:
 
     SUDO_EDITOR=~/.local/bin/suplemon sudoedit /etc/hosts
 
-`sudoedit` is the safer of the two: the editor never runs as root.
+`sudoedit` is the safest of the three: the editor never runs as root at all,
+so nothing it loads — modules, your config, a theme — is running with
+privileges.
 
 
 ### Notes
@@ -535,3 +554,25 @@ have a too steep learning curve. For them (like for me) nano was the weapon of
 choice. But nano feels clunky and it has its limitations. That's why
 I wrote my own editor with built in multi cursor support to fix the situation.
 Another reason is that developing Suplemon is simply fun to do.
+
+### Why this fork exists
+
+*— leancode*
+
+I had a shared FreeBSD account with nano on it and nothing else. I normally
+use [ne](https://ne.di.unimi.it/), but there was no binary I could install
+without a compiler or a package manager, and a shared account gives you
+neither. What it did have was Python 3.
+
+That turns out to be the interesting thing about Suplemon. Most of the good
+terminal editors — kakoune, helix, micro — ship as compiled binaries, so on
+a locked down box you are back to whatever the host chose to install for
+you. Anywhere Python 3 runs, `pip install suplemon-editor` gets you a real
+editor with multiple cursors, and that covers a lot of machines where you
+are not allowed to build anything.
+
+I liked it enough to keep it working. It had stopped running on Python 3.12
+when `imp` was removed, and the upstream repository had been quiet since
+2019, so this fork picks it up rather than switching to something else.
+Needing a feature and being able to write it, or hitting a bug and being
+able to fix it that afternoon, is the rest of the appeal.