suplemon-editor 0.3.0__py3-none-any.whl

suplemon/__main__.py

@@ -0,0 +1,3 @@
+# -*- encoding: utf-8
+from .cli import main
+main()

suplemon/cli.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# -*- encoding: utf-8
+"""
+Start a Suplemon instance in the current window
+"""
+
+import sys
+
+try:
+    import argparse
+except ImportError:
+    # Python < 2.7
+    argparse = False
+
+from .main import App, __version__
+
+
+def print_debug_notice(app):
+    """Explain the log that debug mode just printed, and how to turn it off.
+
+    Without this the messages look like something went wrong, when they are
+    only shown because debug mode asked for them.
+    """
+    print(
+        "\nThe messages above are Suplemon's debug log, shown because debug mode is on.\n"
+        'Set "debug": false in {0} to stop showing them.'.format(app.config.path()),
+        file=sys.stderr
+    )
+
+
+def main():
+    """Handle CLI invocation"""
+    # Parse our CLI arguments
+    config_file = None
+    log_level = None
+    if argparse:
+        parser = argparse.ArgumentParser(description="Console text editor with multi cursor support")
+        parser.add_argument("filenames", metavar="filename", type=str, nargs="*", help="files to open")
+        parser.add_argument("--version", action="version", version=__version__)
+        parser.add_argument("--config", type=str, help="configuration file path")
+        parser.add_argument("--log-level", type=int, help="debug logging level")
+        args = parser.parse_args()
+        filenames = args.filenames
+        config_file = args.config
+        log_level = args.log_level
+    else:
+        # Python < 2.7 fallback
+        filenames = sys.argv[1:]
+
+    # Generate and start our application
+    app = App(filenames=filenames, config_file=config_file, log_level=log_level)
+    if app.init():
+        app.run()
+
+    # Output log info
+    if app.debug:
+        for logger_handler in app.logger.handlers:
+            logger_handler.close()
+        # Only explain the log if there was actually something to show
+        if any(getattr(handler, "flushed_records", 0) for handler in app.logger.handlers):
+            print_debug_notice(app)
+
+
+if __name__ == "__main__":
+    main()

suplemon/config/defaults.json

@@ -0,0 +1,153 @@
+// Suplemon Default Config
+
+// This file contains the default config for Suplemon and should not be edited.
+// If the file doesn't exist, or if it has errors Suplemon can't run.
+// Suplemon supports single line comments in JSON as seen here.
+
+// There are three main groups for settings:
+// - app: Global settings
+// - editor: Editor behaviour
+// - display: How the UI looks
+
+{
+    // Global settings
+    "app": {
+        // Print the debug log to the terminal when Suplemon exits.
+        // The log is written to output.log next to this file either way.
+        "debug": false,
+        // Debug log level (0: Notset, 10: Debug, 20: Info, 30: Warning, 40: Error, 50: Critical)
+        "debug_level": 20,
+        // How long curses will wait to detect ESC key
+        "escdelay": 50,
+        // Whether to use special unicode symbols for decoration
+        "use_unicode_symbols": true,
+        // If your $TERM ends in -256color and this is true, 'xterm-256color'
+        // will be used instead, working around an issue with curses.
+        "imitate_256color": false
+    },
+    // Editor settings
+    "editor": {
+        // Indent new lines to same level as previous line
+        "auto_indent_newline": true,
+        // Character to use for end of line
+        "end_of_line": "\n",
+        // Unindent with backspace
+        "backspace_unindent": true,
+        // Cursor style. 'reverse' or 'underline'
+        "cursor_style": "reverse",
+        // Encoding for reading and writing files
+        "default_encoding": "utf-8",
+        // Use hard tabs (insert actual tabulator character instead of spaces)
+        "hard_tabs": 0,
+        // Number of spaces to insert when pressing tab
+        "tab_width": 4,
+        // Amount of undo states to store
+        "max_history": 50,
+        // Characters considered to separate words
+        "punctuation": " (){}[]<>$@!%'\"=+-/*.:,;_\n\r",
+        // Character drawn at the end of each line when line ends are shown.
+        // Line ends are hidden at startup; F10 toggles them.
+        // Default is U+21B5, a downwards arrow with tip leftwards.
+        "line_end_char": "\u21B5",
+        // White space characters and their visual matches
+        "white_space_map": {
+            // Null byte as null symbol
+            "\u0000": "\u2400",
+            // Space as interpunct
+            " ": "\u00B7",
+            // Tab as tab symbol
+            "\t": "\u21B9",
+            // Nonbreaking space as open box
+            "\u00A0": "\u237D",
+            // Soft hyphen as letter shelf
+            "\u00AD": "\u2423",
+
+            // Other special unicode spaces shown as a space symbol (s/p)
+            // See here for details: http://www.cs.tut.fi/~jkorpela/chars/spaces.html
+
+            // no-break space
+            "\u00A0": "\u2420",
+            // mongolian vowel separator
+            "\u180E": "\u2420",
+            // en quad
+            "\u2000": "\u2420",
+            // em quad
+            "\u2001": "\u2420",
+            // en space
+            "\u2002": "\u2420",
+            // em space
+            "\u2003": "\u2420",
+            // three-per-em space
+            "\u2004": "\u2420",
+            // four-per-em space
+            "\u2005": "\u2420",
+            // six-per-em space
+            "\u2006": "\u2420",
+            // figure space
+            "\u2007": "\u2420",
+            // punctuation space
+            "\u2008": "\u2420",
+            // thin space
+            "\u2009": "\u2420",
+            // hair space
+            "\u200A": "\u2420",
+            // zero width space
+            "\u200B": "\u2420",
+            // narrow no-break space
+            "\u202F": "\u2420",
+            // medium mathematical space
+            "\u205F": "\u2420",
+            // ideographic space
+            "\u3000": "\u2420",
+            // zero width no-break space
+            "\uFEFF": "\u2420"
+        },
+        // Whether to visually show white space chars
+        "show_white_space": false,
+        // Show tab indicators in whitespace
+        "show_tab_indicators": true,
+        // Tab indicator charatrer
+        "tab_indicator_character": "\u203A",
+        // Highlight current line(s)
+        "highlight_current_line": true,
+        // Line numbering
+        "show_line_nums": true,
+        // Pad line numbers with spaces instead of zeros
+        "line_nums_pad_space": true,
+        // Color of the line numbers as a terminal color index (0-255).
+        // The grayscale ramp runs from 232 (near black) to 255 (near white),
+        // so raise this to make line numbers brighter, lower it to dim them.
+        // Only used on terminals that support 256 colors.
+        "line_number_color": 245,
+        // Naive line highlighting
+        "show_line_colors": true,
+        // Proper syntax highlighting
+        "show_highlighting": true,
+        // Syntax highlighting theme
+        "theme": "monokai",
+        // Listen for mouse events
+        "use_mouse": false,
+        // Whether to use copy/paste across multiple files
+        "use_global_buffer": true,
+        // Find with regex by default
+        "regex_find": false
+    },
+    // UI Display Settings
+    "display": {
+        // Show top status bar
+        "show_top_bar": true,
+        // Show app name and version in top bar
+        "show_app_name": true,
+        // Show list of open files in top bar
+        "show_file_list": true,
+        // Show indicator in the file list for files that are modified
+        // NOTE: if you experience performance issues, set this to false
+        "show_file_modified_indicator": true,
+        // Show the keyboard legend
+        "show_legend": true,
+        // Show the bottom status bar
+        "show_bottom_bar": true,
+        // Invert status bar colors (switch text and background colors)
+        "invert_status_bars": false
+    }
+}

suplemon/config/keymap.json

@@ -0,0 +1,63 @@
+// Suplemon Default Key Map
+
+// This file contains the default key map for Suplemon and should not be edited.
+// If the file doesn't exist, or if it has errors Suplemon can't run.
+// Suplemon supports single line comments in JSON as seen here.
+
+[
+    // App
+    {"keys": ["f1", "ctrl+h"],     "command": "help"},
+    {"keys": ["ctrl+s"],           "command": "save_file"},
+    {"keys": ["ctrl+e"],           "command": "run_command"},
+    {"keys": ["ctrl+f"],           "command": "find"},
+    {"keys": ["ctrl+g"],           "command": "go_to"},
+    {"keys": ["ctrl+o"],           "command": "open"},
+    {"keys": ["ctrl+w"],           "command": "close_file"},
+    {"keys": ["ctrl+n"],           "command": "new_file"},
+    {"keys": ["ctrl+q"],           "command": "ask_exit"},
+    {"keys": ["ctrl+p"],           "command": "comment"},
+    {"keys": ["f4", "ctrl+pageup", "ctrl+alt+pageup"],             "command": "next_file"},
+    {"keys": ["shift+f4", "ctrl+pagedown", "ctrl+alt+pagedown"],   "command": "prev_file"},
+    {"keys": ["f3"],               "command": "save_file_as"},
+    {"keys": ["f2"],               "command": "reload_file"},
+    {"keys": ["f7"],               "command": "toggle_whitespace"},
+    {"keys": ["f8"],               "command": "toggle_mouse"},
+    {"keys": ["f12"],              "command": "toggle_fullscreen"},
+    // Editor
+    {"keys": ["up"],               "command": "arrow_up"},
+    {"keys": ["down"],             "command": "arrow_down"},
+    {"keys": ["left"],             "command": "arrow_left"},
+    {"keys": ["right"],            "command": "arrow_right"},
+    {"keys": ["enter"],            "command": "enter"},
+    {"keys": ["backspace"],        "command": "backspace"},
+    {"keys": ["delete"],           "command": "delete"},
+    {"keys": ["tab"],              "command": "tab"},
+    {"keys": ["shift+tab"],        "command": "untab"},
+    {"keys": ["home"],             "command": "home"},
+    {"keys": ["end"],              "command": "end"},
+    {"keys": ["escape"],           "command": "escape"},
+    {"keys": ["pageup"],           "command": "page_up"},
+    {"keys": ["pagedown"],         "command": "page_down"},
+    {"keys": ["f5", "ctrl+z"],     "command": "undo"},
+    {"keys": ["f6", "ctrl+y"],     "command": "redo"},
+    {"keys": ["f9"],               "command": "toggle_line_nums"},
+    {"keys": ["f10"],              "command": "toggle_line_ends"},
+    {"keys": ["f11"],              "command": "toggle_highlight"},
+    {"keys": ["alt+up"],           "command": "new_cursor_up"},
+    {"keys": ["alt+down"],         "command": "new_cursor_down"},
+    {"keys": ["alt+left"],         "command": "new_cursor_left"},
+    {"keys": ["alt+right"],        "command": "new_cursor_right"},
+    {"keys": ["alt+pageup"],       "command": "push_up"},
+    {"keys": ["alt+pagedown"],     "command": "push_down"},
+    {"keys": ["ctrl+c"],           "command": "copy"},
+    {"keys": ["ctrl+x"],           "command": "cut"},
+    {"keys": ["ctrl+k"],           "command": "duplicate_line"},
+    {"keys": ["ctrl+v", "insert"], "command": "insert"},
+    {"keys": ["ctrl+d"],           "command": "find_next"},
+    {"keys": ["ctrl+a"],           "command": "find_all"},
+    {"keys": ["ctrl+left"],        "command": "jump_left"},
+    {"keys": ["ctrl+right"],       "command": "jump_right"},
+    {"keys": ["ctrl+up"],          "command": "jump_up"},
+    {"keys": ["ctrl+down"],        "command": "jump_down"},
+    {"keys": ["ctrl+t"],           "command": "strip"}
+]

suplemon/config.py

@@ -0,0 +1,324 @@
+# -*- encoding: utf-8
+"""
+Config handler.
+"""
+
+import os
+import json
+import logging
+
+from . import suplemon_module
+
+# Preamble written to the user config created on first run. The defaults file
+# has its own preamble saying it shouldn't be edited, which is the opposite of
+# what's wanted here, so it's replaced with this one.
+USER_CONFIG_HEADER = """\
+// Suplemon Config
+//
+// Created from Suplemon's defaults on first run, and safe to edit. Any
+// setting you change here overrides the default; anything you delete falls
+// back to it. Single line comments are supported, as seen here.
+//
+// There are three main groups for settings:
+// - app: Global settings
+// - editor: Editor behaviour
+// - display: How the UI looks
+
+"""
+
+
+class Config:
+    def __init__(self, app):
+        self.app = app
+        self.logger = logging.getLogger(__name__)
+        self.default_config_filename = "defaults.json"
+        self.default_keymap_filename = "keymap.json"
+        self.config_filename = "suplemon-config.json"
+        self.keymap_filename = "suplemon-keymap.json"
+        self.home_dir = os.path.expanduser("~")
+        self.config_dir = os.path.join(self.home_dir, ".config", "suplemon")
+
+        self.defaults = {}
+        self.keymap = {}
+        self.config = {}
+        self.key_bindings = {}
+
+    def init(self):
+        self.create_config_dir()
+        return self.load_defaults()
+
+    def path(self):
+        return os.path.join(self.config_dir, self.config_filename)
+
+    def keymap_path(self):
+        return os.path.join(self.config_dir, self.keymap_filename)
+
+    def set_path(self, path):
+        parts = os.path.split(path)
+        self.config_dir = parts[0]
+        self.config_filename = parts[1]
+
+    def load(self):
+        path = self.path()
+        config = False
+        if not os.path.exists(path):
+            self.logger.debug("Configuration file '{0}' doesn't exist.".format(path))
+            # First run. Give the user a documented config they can actually
+            # edit rather than running on defaults they can't see.
+            self.create_user_config()
+        if os.path.exists(path):
+            config = self.load_config_file(path)
+        if config is not False:
+            self.logger.debug("Loaded configuration file '{0}'".format(path))
+            self.config = self.merge_defaults(config)
+        else:
+            self.logger.info("Failed to load config file '{0}'.".format(path))
+            self.config = dict(self.defaults)
+        self.load_keys()
+        return config
+
+    def load_keys(self):
+        path = self.keymap_path()
+        keymap = []
+
+        # Reload the defaults first. self.keymap already holds the previous
+        # merge of defaults and user keymap, so appending to it again would
+        # keep bindings the user has since deleted from their keymap file.
+        self.load_default_keys()
+
+        if not os.path.exists(path):
+            self.logger.debug("Keymap file '{0}' doesn't exist.".format(path))
+        else:
+            keymap = self.load_config_file(path) or []
+            if not keymap:
+                self.logger.warning("Failed to load keymap file '{0}'.".format(path))
+
+        # Build the key bindings
+        # User keymap overwrites the defaults in the bindings
+        self.keymap = self.normalize_keys(self.keymap + keymap)
+        self.key_bindings = {}
+        for binding in self.keymap:
+            for key in binding["keys"]:
+                self.key_bindings[key] = binding["command"]
+
+        return True
+
+    def normalize_keys(self, keymap):
+        """Normalize the order of modifier keys in keymap."""
+        modifiers = ["shift", "ctrl", "alt", "meta"]  # The modifiers in correct order
+        for item in keymap:
+            new_keys = []
+            for key_item in item["keys"]:
+                parts = key_item.split("+")
+                key = parts[-1]
+                if len(parts) < 2:
+                    new_keys.append(key)
+                    continue
+                normalized = ""
+                for mod in modifiers:  # Add the used modifiers back in correct order
+                    if mod in parts:
+                        normalized += mod + "+"
+                normalized += key
+                new_keys.append(normalized)
+            item["keys"] = new_keys
+        return keymap
+
+    def load_defaults(self):
+        if not self.load_default_config() or not self.load_default_keys():
+            return False
+        return True
+
+    def default_config_path(self):
+        """Path of the default config file shipped with Suplemon."""
+        return os.path.join(self.app.path, "config", self.default_config_filename)
+
+    def create_user_config(self):
+        """Create the user config file by copying the defaults.
+
+        Run on first start so that the user gets a commented config file to
+        edit instead of silently running on built in defaults.
+
+        :return: True if the config file was created.
+        """
+        source = self.default_config_path()
+        target = self.path()
+        try:
+            with open(source) as f:
+                data = f.read()
+        except OSError:
+            self.logger.warning("Couldn't read default config '{0}'.".format(source))
+            return False
+        try:
+            with open(target, "w") as f:
+                f.write(self.build_user_config(data))
+        except OSError:
+            self.logger.warning("Couldn't create config file '{0}'.".format(target))
+            return False
+        self.logger.info("Created config file '{0}' from the defaults.".format(target))
+        return True
+
+    def build_user_config(self, data):
+        """Replace the default config's preamble with a user facing one.
+
+        Everything before the opening brace of the defaults is a comment block
+        stating the file shouldn't be edited. The settings themselves and the
+        comments documenting them are left untouched.
+
+        :param data: Contents of the default config file.
+        :return: Contents to write to the user config file.
+        """
+        lines = data.split("\n")
+        for i, line in enumerate(lines):
+            if line.lstrip().startswith("{"):
+                return USER_CONFIG_HEADER + "\n".join(lines[i:])
+        # Nothing that looks like a config body, copy it verbatim
+        return data
+
+    def load_default_config(self):
+        path = self.default_config_path()
+        config = self.load_config_file(path)
+        if not config:
+            self.logger.error("Failed to load default config file '{0}'!".format(path))
+            return False
+        self.defaults = config
+        return True
+
+    def load_module_configs(self):
+        module_config = {}
+        modules = self.app.modules.modules
+        for module_name in modules.keys():
+            module = modules[module_name]
+            conf = module.get_default_config()
+            module_config[module_name] = conf
+            self.logger.debug("Loading default config for module '%s': %s" % (module_name, str(conf)))
+        self.defaults["modules"] = module_config
+        self.config = self.merge_defaults(self.config)
+
+    def load_default_keys(self):
+        path = os.path.join(self.app.path, "config", self.default_keymap_filename)
+        config = self.load_config_file(path)
+        if not config:
+            self.logger.error("Failed to load default keymap file '{0}'!".format(path))
+            return False
+        self.keymap = config
+        return True
+
+    def reload(self):
+        """Reload the config file."""
+        return self.load()
+
+    def store(self):
+        """Write current config state to file.
+
+        :return: True if the config was written.
+        """
+        data = json.dumps(self.config, indent=4)
+        try:
+            with open(self.path(), "w", encoding="utf-8") as f:
+                f.write(data)
+        except OSError:
+            self.logger.warning("Couldn't write config file '{0}'.".format(self.path()))
+            return False
+        return True
+
+    def merge_defaults(self, config):
+        """Fill any missing config options with defaults."""
+        return self._merge_defaults(self.defaults, config)
+
+    def _merge_defaults(self, defaults, config):
+        """Recursivley merge two dicts."""
+        for key in defaults.keys():
+            item = defaults[key]
+            if key not in config.keys():
+                config[key] = item
+                continue
+            if not isinstance(item, dict):
+                continue
+            config[key] = self._merge_defaults(item, config[key])
+        return config
+
+    def load_config_file(self, path):
+        try:
+            f = open(path)
+            data = f.read()
+            f.close()
+            data = self.remove_config_comments(data)
+            config = json.loads(data)
+            return config
+        except (OSError, ValueError):
+            return False
+
+    def remove_config_comments(self, data):
+        """Remove comments from a 'pseudo' JSON config file.
+
+        Removes all lines that begin with '#' or '//' ignoring whitespace.
+
+        :param data: Commented JSON data to clean.
+        :return: Cleaned pure JSON.
+        """
+        lines = data.split("\n")
+        cleaned = []
+        for line in lines:
+            line = line.strip()
+            if line.startswith(("//", "#")):
+                continue
+            cleaned.append(line)
+        return "\n".join(cleaned)
+
+    def create_config_dir(self):
+        if not os.path.exists(self.config_dir):
+            try:
+                os.makedirs(self.config_dir)
+            except OSError:
+                self.app.logger.warning("Config folder '{0}' doesn't exist and couldn't be created.".format(
+                                        self.config_dir))
+
+    def __getitem__(self, i):
+        """Get a config variable."""
+        return self.config[i]
+
+    def __setitem__(self, i, v):
+        """Set a config variable."""
+        self.config[i] = v
+
+    def __str__(self):
+        """Convert entire config array to string."""
+        return str(self.config)
+
+    def __len__(self):
+        """Return length of top level config variables."""
+        return len(self.config)
+
+
+class ConfigModule(suplemon_module.Module):
+    """Helper for shortcut for opening config files."""
+    def init(self):
+        self.config_name = "defaults.json"
+        self.config_default_path = os.path.join(self.app.path, "config", self.config_name)
+        self.config_user_path = self.app.config.path()
+
+    def run(self, app, editor, args):
+        if args == "defaults":
+            # Open the default config in a new file only for viewing
+            self.open(app, self.config_default_path, read_only=True)
+        else:
+            self.open(app, self.config_user_path)
+
+    def open(self, app, path, read_only=False):
+        if read_only:
+            f = open(path)
+            data = f.read()
+            f.close()
+            file = app.new_file()
+            file.set_name(self.config_name)
+            file.set_data(data)
+            app.switch_to_file(app.last_file_index())
+        else:
+            # Open the user config file for editing
+            f = app.file_is_open(path)
+            if f:
+                app.switch_to_file(app.get_file_index(f))
+            else:
+                if not app.open_file(path):
+                    app.new_file(path)
+                app.switch_to_file(app.last_file_index())