suplemon-editor 0.3.0__py3-none-any.whl

suplemon/file.py

@@ -0,0 +1,193 @@
+# -*- encoding: utf-8
+"""
+File object for storing an opened file and editor.
+"""
+
+import os
+import time
+import logging
+
+from .helpers import parse_path
+
+
+class File:
+    def __init__(self, app=None):
+        self.app = app
+        self.logger = logging.getLogger(__name__)
+        self.name = ""
+        self.fpath = ""
+        self.data = None
+        self.read_only = False  # Currently unused
+        self.last_save = None  # Time of last save
+        self.opened = time.time()  # Time of last open
+        self.editor = None
+        self.writable = True
+        self.is_help = False
+
+    def _path(self):
+        """Get the full path of the file."""
+        return os.path.join(self.fpath, self.name)
+
+    def get_encoding(self):
+        """Get the encoding to read and write this file with.
+
+        Comes from the editor's default_encoding setting. Without this the
+        files were opened with whatever the locale happened to be, so the
+        setting did nothing and a non UTF-8 locale mangled the contents.
+
+        :return: Name of the encoding to use.
+        :rtype: str
+        """
+        default = "utf-8"
+        if self.app is None:
+            return default
+        try:
+            return self.app.config["editor"]["default_encoding"] or default
+        except (KeyError, TypeError):
+            return default
+
+    def path(self):
+        """Get the full path of the file."""
+        # TODO: deprecate in favour of get_path()
+        return self._path()
+
+    def get_name(self):
+        """Get the file name."""
+        return self.name
+
+    def get_path(self):
+        """Get the full path of the file."""
+        return self._path()
+
+    def get_extension(self):
+        parts = self.name.split(".")
+        if len(parts) < 2:
+            return ""
+        return parts[-1]
+
+    def get_editor(self):
+        """Get the associated editor."""
+        return self.editor
+
+    def set_name(self, name):
+        """Set the file name."""
+        # TODO: sanitize
+        self.name = name
+        self.update_editor_extension()
+
+    def set_path(self, path):
+        """Set the file path. Relative paths are sanitized."""
+        self.fpath, self.name = parse_path(path)
+        self.update_editor_extension()
+
+    def set_data(self, data):
+        """Set the file data and apply to editor if it exists."""
+        self.data = data
+        if self.editor:
+            self.editor.set_data(data)
+
+    def set_editor(self, editor):
+        """The editor instance set its file extension."""
+        self.editor = editor
+        self.update_editor_extension()
+
+    def on_load(self):
+        """Does checks after file is loaded."""
+        self.writable = os.access(self._path(), os.W_OK)
+        if not self.writable:
+            self.logger.info("File not writable.")
+
+    def update_editor_extension(self):
+        """Set the editor file extension from the current file name."""
+        if not self.editor:
+            return False
+        ext = self.get_extension()
+        if len(ext) >= 1:
+            self.editor.set_file_extension(ext)
+
+    def save(self):
+        """Write the editor data to file."""
+        data = self.editor.get_data()
+        try:
+            with open(self._path(), "w", encoding=self.get_encoding()) as f:
+                f.write(data)
+        except (OSError, LookupError, UnicodeError):
+            self.logger.exception('Failed writing file "{file}"'.format(file=self._path()))
+            return False
+        self.data = data
+        self.last_save = time.time()
+        self.writable = os.access(self._path(), os.W_OK)
+        return True
+
+    def load(self, read=True):
+        """Try to read the actual file and load the data into the editor instance."""
+        if not read:
+            return True
+        path = self._path()
+        if not os.path.isfile(path):
+            self.logger.debug("Given path isn't a file.")
+            return False
+        data = self._read(path)
+        if data is False:
+            return False
+        self.data = data
+        self.editor.set_data(data)
+        self.on_load()
+        return True
+
+    def _read(self, path):
+        data = self._read_text(path)
+        if data is False:
+            self.logger.warning("Normal file read failed.")
+            data = self._read_binary(path)
+        if data is False:
+            self.logger.warning("Fallback file read failed.")
+            return False
+        return data
+
+    def _read_text(self, file):
+        # Read text file
+        try:
+            with open(self._path(), encoding=self.get_encoding()) as f:
+                return f.read()
+        except (OSError, LookupError, UnicodeDecodeError):
+            self.logger.exception('Failed reading file "{file}"'.format(file=file))
+            return False
+
+    def _read_binary(self, file):
+        # Read binary file and try to autodetect encoding
+        try:
+            f = open(self._path(), "rb")
+            data = f.read()
+            f.close()
+            import chardet
+            detection = chardet.detect(data)
+            charenc = detection["encoding"]
+            if charenc is None:
+                self.logger.warning("Failed to detect file encoding.")
+                return False
+            self.logger.info("Trying to decode with encoding '{0}'".format(charenc))
+            return data.decode(charenc)
+        except Exception:
+            self.logger.warning("Failed reading binary file!", exc_info=True)
+        return False
+
+    def reload(self):
+        """Reload file data."""
+        return self.load()
+
+    def is_changed(self):
+        """Check if the editor data is different from the file."""
+        return self.editor.get_data() != self.data
+
+    def is_changed_on_disk(self):
+        path = self._path()
+        if os.path.isfile(path):
+            data = self._read(path)
+            if data != self.data:
+                return True
+        return False
+
+    def is_writable(self):
+        """Check if the file is writable."""
+        return self.writable

suplemon/help.py

@@ -0,0 +1,327 @@
+"""
+Help text for Suplemon
+"""
+
+help_text = """
+# Suplemon Help
+
+*Contents*
+1. General description
+2. User interface
+3. Selecting text
+4. Default keyboard shortcuts
+5. Commands
+
+## 1. General description
+Suplemon is designed to be an easy, intuitive and powerful text editor.
+It emulates some features from Sublime Text and the user interface of Nano.
+Multi cursor editing is a core feature. Suplemon also supports extensions
+so you can customize it to work how you want.
+
+## 2. User interface
+The user interface is designed to be as intuitive and informative as possible.
+There are two status bars, one at the top and one at the bottom. The top bar
+shows the program version, a clock, and a list of opened files. The bottom bar
+shows status messages and handles input for commands. Above the bottom status
+bar there is a list of most common keyboard shortcuts.
+
+## 3. Selecting text
+Suplemon has no text selection. There is no way to select a range of
+characters, with or without a mouse, and nothing highlights as you move.
+What it has instead is cursors, and the unit of work is the whole line.
+
+Copy (Ctrl + C) and cut (Ctrl + X) act on every line that has a cursor on
+it. Where the cursor sits within the line makes no difference: one cursor
+anywhere on a line copies that entire line. So "selecting" more text means
+putting more cursors down.
+
+ * Alt + Down / Up
+   > Add a cursor on the next or previous line. This is the usual way to
+   > take several lines: press Alt + Down twice, then Ctrl + C, to copy
+   > three lines.
+
+ * Ctrl + D
+   > Add a cursor at the next occurance of the word the cursor is on.
+   > Press it repeatedly to gather up matches one at a time.
+
+ * Ctrl + A
+   > Add a cursor at every occurance of the last search term at once.
+   > Search with Ctrl + F or Ctrl + D first to set the term.
+
+ * ESC
+   > Collapse back to a single cursor when you're done.
+
+Pasting (Ctrl + V) behaves in one of two ways. With a single cursor and
+several copied lines, the lines are inserted as new lines. With several
+cursors, or a single copied line, the text is inserted at each cursor
+position instead, and a single copied line is repeated into every cursor.
+That last case is what makes multi cursor editing useful: copy one line,
+put ten cursors down, and paste it into all ten at once.
+
+The practical consequence is that you cannot copy part of a line. If you
+need a fragment, copy the whole line and trim what you don't want after
+pasting it. This is the habit that takes the longest to unlearn if you're
+coming from an editor with ordinary selection.
+
+Copy and paste share text with other applications when a clipboard tool
+such as xsel, xclip, wl-clipboard or pbcopy is installed. Without one they
+still work, but only within Suplemon.
+
+
+## 4. Default keyboard shortcuts
+The default keyboard shortcuts imitate those of common graphical editors.
+Most shortcuts are also shown at the bottom in the legend area. Here's
+the complete reference.
+
+
+ * F1 / Ctrl + H
+   > Show this help. On terminals where the backspace key sends ^H, Ctrl + H
+   > arrives as backspace and can't reach the help, so F1 always works.
+
+ * Ctrl + Q
+   > Exit
+
+ * Ctrl + W
+   > Close file or tab
+
+ * Ctrl + C
+   > Copy line(s) to buffer
+
+ * Ctrl + X
+   > Cut line(s) to buffer
+
+ * Ctrl + V
+   > Insert buffer
+
+ * Ctrl + K
+   > Duplicate line
+
+ * Ctrl + G
+   > Go to line number or file (type the beginning of a filename to switch to it).
+   > You can also use 'filena:42' to go to line 42 in filename.py etc.
+
+ * Ctrl + F
+   > Search for a string or regular expression (configurable)
+
+ * Ctrl + D
+   > Search for next occurance or find the word the cursor is on. Adds a new cursor at each new occurance.
+
+ * Ctrl + A
+   > Add a cursor at every occurance of the last search term. Search with
+   > Ctrl + F or Ctrl + D first, otherwise there is no term to look for.
+
+ * Ctrl + T
+   > Trim whitespace
+
+ * Alt + Arrow Key
+   > Add new curor in arrow direction
+
+ * Ctrl + Left / Right
+   > Jump to previous or next word or line
+
+ * Ctrl + Up / Down
+   > Jump three lines up or down
+
+ * ESC
+   > Revert to a single cursor / Cancel input prompt
+
+ * Alt + Page Up
+   > Move line(s) up
+
+ * Alt + Page Down
+   > Move line(s) down
+
+ * Tab / Shift + Tab
+   > Indent or unindent line(s)
+
+ * Ctrl + S
+   > Save current file
+
+ * F3
+   > Save file with new name
+
+ * F2
+   > Reload current file
+
+ * Ctrl + N
+   > New empty file
+
+ * Ctrl + O
+   > Open file
+
+ * Ctrl + W
+   > Close file
+
+ * F4 / Ctrl + Page Up / Ctrl + Alt + Page Up
+   > Switch to next file. Wraps around, so F4 alone cycles through them all.
+
+ * Shift + F4 / Ctrl + Page Down / Ctrl + Alt + Page Down
+   > Switch to previous file. Terminals often keep Ctrl + Page Up and Down
+   > for their own tabs, hence the alternatives. Shift + F4 and the
+   > Ctrl + Alt pair need a terminfo entry that describes those keys, which
+   > older ones (FreeBSD's among them) do not have; F4 works everywhere.
+
+ * Ctrl + E
+   > Run a command.
+
+ * F5 / Ctrl + Z
+   > Undo
+
+ * F6 / Ctrl + Y
+   > Redo
+
+ * F7
+   > Toggle visible whitespace
+
+ * F8
+   > Toggle mouse mode
+
+ * F9
+   > Toggle line numbers
+
+ * F10
+   > Toggle visible line endings. They start hidden; the character drawn is
+   > the "line_end_char" setting in your config.
+
+ * F11
+   > Toggle syntax highlighting. Bound but not implemented yet, so pressing
+   > it currently does nothing.
+
+ * F12
+   > Toggle full screen
+
+### Mouse shortcuts
+
+ * Left Click
+   > Set cursor at mouse position. Reverts to a single cursor.
+
+ * Right Click
+   > Add a cursor at mouse position.
+
+ * Scroll Wheel Up / Down
+   > Scroll up & down.
+
+
+## 5. Commands
+Commands are special operations that can be performed (e.g. remove whitespace
+or convert line to uppercase). Each command can be run by pressing Ctrl + E
+and then typing the command name. Commands are extensions and are stored in
+the modules folder in the Suplemon installation.
+
+ * autocomplete
+
+    A simple autocompletion module.
+
+    This adds autocomplete support for the tab key. It uses a word
+    list scanned from all open files for completions. By default it suggests
+    the shortest possible match. If there are no matches, the tab action is
+    run normally.
+
+ * autodocstring
+
+    Simple module for adding docstring placeholders.
+
+    This module is intended to generate docstrings for Python functions.
+    It adds placeholders for descriptions, arguments and return data.
+    Function arguments are crudely parsed from the function definition
+    and return statements are scanned from the function body.
+
+ * bulk_delete
+
+    Bulk delete lines and characters.
+    Asks what direction to delete in by default.
+
+    Add 'up' to delete lines above highest cursor.
+    Add 'down' to delete lines below lowest cursor.
+    Add 'left' to delete characters to the left of all cursors.
+    Add 'right' to delete characters to the right of all cursors.
+
+ * comment
+
+    Toggle line commenting based on current file syntax.
+
+ * config
+
+    Shortcut for openning the config files.
+
+ * diff
+
+    View a diff of the current file compared to it's on disk version.
+
+ * eval
+
+    Evaluate a python expression and show the result in the status bar.
+
+    If no expression is provided the current line(s) are evaluated and
+    replaced with the evaluation result.
+
+ * keymap
+
+    Shortcut to openning the keymap config file.
+
+ * linter
+
+    Linter for suplemon.
+
+ * lower
+
+    Transform current lines to lower case.
+
+ * lstrip
+
+    Trim whitespace from beginning of current lines.
+
+ * paste
+
+    Toggle paste mode (helpful when pasting over SSH if auto indent is enabled)
+
+ * reload
+
+    Reload all add-on modules.
+
+ * replace_all
+
+    Replace all occurrences in all files of given text with given replacement.
+
+ * reverse
+
+    Reverse text on current line(s).
+
+ * rstrip
+
+    Trim whitespace from the end of lines.
+
+ * save
+
+    Save the current file.
+
+ * save_all
+
+    Save all currently open files. Asks for confirmation.
+
+ * sort_lines
+
+    Sort current lines.
+
+    Sorts alphabetically by default.
+    Add 'length' to sort by length.
+    Add 'reverse' to reverse the sorting.
+
+ * strip
+
+    Trim whitespace from start and end of lines.
+
+ * tabstospaces
+
+    Convert tab characters to spaces in the entire file.
+
+ * toggle_whitespace
+
+    Toggle visually showing whitespace.
+
+ * upper
+
+    Transform current lines to upper case.
+
+
+"""

suplemon/helpers.py

@@ -0,0 +1,104 @@
+# -*- encoding: utf-8
+"""
+Various helper constants and functions.
+"""
+
+import os
+import re
+import sys
+import time
+import traceback
+
+
+def curr_time():
+    """Current time in %H:%M"""
+    return time.strftime("%H:%M")
+
+
+def curr_time_sec():
+    """Current time in %H:%M:%S"""
+    return time.strftime("%H:%M:%S")
+
+
+def multisplit(data, delimiters):
+    pattern = "|".join(map(re.escape, delimiters))
+    return re.split(pattern, data)
+
+
+def get_error_info():
+    """Return info about last error."""
+    msg = "{0}\n{1}".format(str(traceback.format_exc()), str(sys.exc_info()))
+    return msg
+
+
+def get_string_between(start, stop, s):
+    """Search string for a substring between two delimeters. False if not found."""
+    i1 = s.find(start)
+    if i1 == -1:
+        return False
+    s = s[i1 + len(start):]
+    i2 = s.find(stop)
+    if i2 == -1:
+        return False
+    s = s[:i2]
+    return s
+
+
+def whitespace(line):
+    """Return index of first non whitespace character on a line.
+
+    Tabs count as whitespace. Only spaces used to, which meant tab indented
+    files behaved as though they had no indentation at all.
+    """
+    i = 0
+    for char in str(line):
+        if char not in " \t":
+            break
+        i += 1
+    return i
+
+
+def leading_whitespace(line):
+    """Return the indentation of a line, as written.
+
+    Use this instead of whitespace() when the indentation is going to be
+    reproduced, so that tabs stay tabs and spaces stay spaces.
+    """
+    line = str(line)
+    return line[:whitespace(line)]
+
+
+def parse_path(path):
+    """Parse a relative path and return full directory and filename as a tuple.
+
+    expanduser handles a bare "~" as well as "~/...", which the previous
+    manual prefix check did not: "~" on its own was treated as a filename
+    in the current directory.
+    """
+    path = os.path.expanduser(path)
+    ab = os.path.abspath(path)
+    parts = os.path.split(ab)
+    return parts
+
+
+def get_filename_cursor_pos(name):
+    default = {
+        "name": name,
+        "row": 0,
+        "col": 0,
+    }
+
+    m = re.match(r"(.*?):(\d+):?(\d+)?", name)
+
+    if not m:
+        return default
+
+    groups = m.groups()
+    if not groups[0]:
+        return default
+
+    return {
+        "name": groups[0],
+        "row": abs(int(groups[1])-1) if groups[1] else 0,
+        "col": abs(int(groups[2])-1) if groups[2] else 0,
+    }

suplemon/hex2xterm.py

@@ -0,0 +1,23 @@
+
+# Default color levels for the color cube
+cubelevels = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
+# Generate a list of midpoints of the above list
+snaps = [(x+y)/2 for x, y in list(zip(cubelevels, [0]+cubelevels))[1:]]
+
+
+def hex_to_rgb(value):
+    value = value.lstrip("#")
+    lv = len(value)
+    return tuple(int(value[i:i + lv // 3], 16) for i in range(0, lv, lv // 3))
+
+
+def hex_to_xterm(hex):
+    """
+    Converts hex color values to the nearest equivalent xterm-256 color.
+    """
+    rgb = hex_to_rgb(hex)
+    r, g, b = rgb
+    # Using list of snap points, convert RGB value to cube indexes
+    r, g, b = map(lambda x: len(tuple(s for s in snaps if s < x)), (r, g, b))
+    # Simple colorcube transform
+    return r*36 + g*6 + b + 16