suplemon-editor 0.3.0__py3-none-any.whl

suplemon/modules/comment.py

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8
+
+from suplemon import helpers
+from suplemon.suplemon_module import Module
+
+
+class Comment(Module):
+    """Toggle line commenting based on current file syntax."""
+
+    def run(self, app, editor, args):
+        """Comment the current line(s)."""
+        try:
+            # Try to get comment start and end syntax
+            comment = editor.syntax.get_comment()
+        except AttributeError:
+            return False
+        line_nums = editor.get_lines_with_cursors()
+        # Iterate through lines
+        for lnum in line_nums:
+            line = editor.lines[lnum]
+            if not len(line):
+                continue  # Skip empty lines
+            # Look for comment syntax in stripped line (TODO:Make this smarter)
+            target = str(line).strip()
+            w = helpers.whitespace(line)  # Amount of whitespace at line start
+            indent = helpers.leading_whitespace(line)  # That whitespace as written
+            # If the line starts with comment syntax
+            if target.startswith(comment[0]):
+                # Reconstruct the whitespace and add the line
+                new_line = indent + line[w+len(comment[0]):]
+                # If comment end syntax exists
+                if comment[1]:
+                    # Try to remove it from the end of the line
+                    if new_line.endswith(comment[1]):
+                        new_line = new_line[:-1*len(comment[1])]
+                # Store the modified line
+                # editor.lines[lnum] = Line(new_line)
+                editor.lines[lnum].set_data(new_line)
+            # If the line isn't commented
+            else:
+                # Slice out the prepended whitespace
+                new_line = line[w:]
+                # Add the whitespace and starting comment
+                new_line = indent + comment[0] + new_line
+                if comment[1]:
+                    # Add comment end syntax if needed
+                    new_line += comment[1]
+                # Store modified line
+                # editor.lines[lnum] = Line(new_line)
+                editor.lines[lnum].set_data(new_line)
+        # Keep cursors under control, same as usual...
+        editor.move_cursors()
+        editor.store_action_state("comment")
+
+
+module = {
+    "class": Comment,
+    "name": "comment",
+}

suplemon/modules/config.py

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8
+
+import os
+
+from suplemon import config
+
+
+class SuplemonConfig(config.ConfigModule):
+    """Shortcut for openning the 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()
+
+
+module = {
+    "class": SuplemonConfig,
+    "name": "config",
+}

suplemon/modules/date.py

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8
+
+import time
+
+from suplemon.suplemon_module import Module
+
+
+class Date(Module):
+    """Shows the current date without year in the top status bar."""
+
+    def get_status(self):
+        s = time.strftime("%Y-%m-%d")
+        if self.app.config["app"]["use_unicode_symbols"]:
+            return "" + s
+        return s
+
+
+module = {
+    "class": Date,
+    "name": "date",
+    "status": "top",
+}

suplemon/modules/diff.py

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8
+
+import difflib
+
+from suplemon.suplemon_module import Module
+
+
+class Diff(Module):
+    """View a diff of the current file compared to it's on disk version."""
+
+    def run(self, app, editor, args):
+        curr_file = app.get_file()
+        curr_path = curr_file.get_path()
+        if not curr_path:
+            self.app.set_status("File hasn't been saved, can't show diff.")
+            return False
+
+        current_data = editor.get_data()
+        f = open(curr_path)
+        original_data = f.read()
+        f.close()
+        diff = self.get_diff(original_data, current_data)
+
+        if not diff:
+            self.app.set_status("The file in the editor and on disk are identical.")
+            return False
+        file = app.new_file()
+        file.set_name(curr_file.get_name() + ".diff")
+        file.set_data(diff)
+        app.switch_to_file(app.last_file_index())
+
+    def get_diff(self, a, b):
+        a = a.splitlines(1)
+        b = b.splitlines(1)
+        diff = difflib.unified_diff(a, b)
+        return "".join(diff)
+
+
+module = {
+    "class": Diff,
+    "name": "diff",
+}

suplemon/modules/eval.py

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class Eval(Module):
+    """
+    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.
+    """
+
+    def run(self, app, editor, args):
+        if not args:
+            return self.evaluate_lines(editor)
+        else:
+            return self.evaluate_input(args)
+
+    def evaluate_input(self, inp):
+        try:
+            value = eval(inp)
+        except Exception:
+            self.app.set_status("Eval failed.")
+            return False
+        self.app.set_status("Result:{0}".format(value))
+        return True
+
+    def evaluate_lines(self, editor):
+        line_nums = editor.get_lines_with_cursors()
+        for num in line_nums:
+            line = editor.get_line(num)
+            try:
+                value = eval(line.get_data())
+            except Exception:
+                continue
+            line.set_data(str(value))
+
+
+module = {
+    "class": Eval,
+    "name": "eval",
+}

suplemon/modules/hostname.py

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8
+
+import socket
+
+from suplemon.suplemon_module import Module
+
+
+class Hostname(Module):
+    """Shows the machine hostname in the bottom status bar."""
+
+    def init(self):
+        self.hostname = ""
+        hostinfo = None
+        try:
+            hostinfo = socket.gethostbyaddr(socket.gethostname())
+        except OSError:
+            self.logger.debug("Failed to get hostname.")
+        if hostinfo:
+            self.hostname = hostinfo[0]
+            # Use shorter hostname if available
+            if hostinfo[1]:
+                self.hostname = hostinfo[1][0]
+
+    def get_status(self):
+        if self.hostname:
+            return "host:{0}".format(self.hostname)
+        return ""
+
+
+module = {
+    "class": Hostname,
+    "name": "hostname",
+    "status": "bottom",
+}

suplemon/modules/input_test.py

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class InputTest(Module):
+    """
+    Input event testing utility.
+    """
+
+    def handler(self, prompt, event):
+        self.app.set_status("InputEvent:" + str(event))
+        prompt.on_ready()
+        return True  # Disable normal key handling
+
+    def run(self, app, editor, args):
+        app.ui.query_filtered("Waiting for input...", handler=self.handler)
+
+
+module = {
+    "class": InputTest,
+    "name": "input_test",
+}

suplemon/modules/keymap.py

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8
+
+import os
+
+from suplemon import config
+
+
+class KeymapConfig(config.ConfigModule):
+    """Shortcut to openning the keymap config file."""
+
+    def init(self):
+        self.config_name = "keymap.json"
+        self.config_default_path = os.path.join(self.app.path, "config", self.config_name)
+        self.config_user_path = self.app.config.keymap_path()
+
+
+module = {
+    "class": KeymapConfig,
+    "name": "keymap",
+}

suplemon/modules/linter.py

@@ -0,0 +1,274 @@
+# -*- encoding: utf-8
+
+import re
+import os
+import threading
+import subprocess
+
+from suplemon.suplemon_module import Module
+
+
+class Linter(Module):
+    """Linter for suplemon."""
+
+    def init(self):
+        self.init_logging(__name__)
+
+        # TODO: Run linting in a seperate thread to avoid
+        # blocking the UI when the app is loading
+
+        # Lint all files after app is loaded
+        self.bind_event_after("app_loaded", self.on_loaded)
+        # Show linting messages in status bar
+        self.bind_event_after("mainloop", self.mainloop)
+        # Re-lint current file when appropriate
+        self.bind_event_after("save_file", self.lint_current_file)
+        self.bind_event_after("save_file_as", self.lint_current_file)
+        self.bind_event_after("reload_file", self.lint_current_file)
+        self.bind_event_after("open_file", self.lint_current_file)
+
+    def run(self, app, editor, args):
+        """Run the linting command."""
+        editor = self.app.get_file().get_editor()
+        count = self.get_msg_count(editor)
+        status = "{0} lines with linting errors in this file.".format(str(count))
+        self.app.set_status(status)
+
+    def on_loaded(self, event):
+        # Lint all files in a thread since it might take a while
+        thread = threading.Thread(target=self.lint_all_files, args=(event,))
+        # Use daemon mode to forcefully shutdown the thread on application exit.
+        # Python2 doesn't know the boolean daemon keyword argument to the Thread()
+        # constructor so we use the .daemon property instead.
+        thread.daemon = True
+        thread.start()
+
+    def mainloop(self, event):
+        """Run the linting command."""
+        file = self.app.get_file()
+        editor = file.get_editor()
+        cursor = editor.get_cursor()
+        if len(editor.cursors) > 1:
+            return False
+        line_no = cursor.y + 1
+        msg = self.get_msgs_on_line(editor, cursor.y)
+        if msg:
+            self.app.set_status("Line {0}: {1}".format(str(line_no), msg))
+
+    def lint_current_file(self, event):
+        self.lint_file(self.app.get_file())
+
+    def lint_all_files(self, event):
+        """Do linting check for all open files and store results."""
+        for file in self.app.files:
+            self.lint_file(file)
+        return False
+
+    def lint_file(self, file):
+        path = file.get_path()
+        if not path:  # Unsaved file
+            return False
+
+        ext = file.get_extension().lower()
+        linter = False
+        if ext == "py":
+            linter = PyLint(self.logger)
+        elif ext == "js":
+            linter = JsLint(self.logger)
+        elif ext == "php":
+            linter = PhpLint(self.logger)
+
+        if not linter:
+            return False
+
+        linting = linter.lint(path)
+        if linting is False:
+            return False
+
+        editor = file.get_editor()
+        for line_no in range(len(editor.lines)):
+            line = editor.lines[line_no]
+            if line_no+1 in linting.keys():
+                line.linting = linting[line_no+1]
+                line.set_number_color(1)
+            else:
+                line.linting = False
+                line.reset_number_color()
+
+    def get_msgs_on_line(self, editor, line_no):
+        line = editor.lines[line_no]
+        if not hasattr(line, "linting") or not line.linting:
+            return False
+        return line.linting[0][1]
+
+    def get_msg_count(self, editor):
+        count = 0
+        for line in editor.lines:
+            if hasattr(line, "linting"):
+                if line.linting:
+                    count += 1
+        return count
+
+
+class BaseLint:
+    def __init__(self, logger):
+        self.logger = logger
+
+    def lint(self, path):
+        pass
+
+    def get_file_linting(self, path):
+        """Do linting check for given file path."""
+        return {}
+
+    def get_output(self, cmd):
+        try:
+            fnull = open(os.devnull, "w")
+            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=fnull)
+            fnull.close()
+        except OSError:
+            self.logger.debug("Subprocess failed.")
+            return False
+        out, err = process.communicate()
+        return out
+
+
+class PyLint(BaseLint):
+    def __init__(self, logger):
+        BaseLint.__init__(self, logger)
+        # Error codes to ignore e.g. 'E501' (line too long)
+        self.ignore = []
+        # Max length of line
+        self.max_line_length = 120  # Default is 79
+
+    def lint(self, path):
+        if not self.has_flake8_support():
+            self.logger.warning("Flake8 not available. Can't show linting.")
+            return False
+        self.logger.debug(self.has_flake8_support())
+        return self.get_file_linting(path)
+
+    def has_flake8_support(self):
+        output = self.get_output(["flake8", "--version"])
+        return output
+
+    def get_file_linting(self, path):
+        """Do linting check for given file path."""
+        output = self.get_output(["flake8", "--max-line-length", str(self.max_line_length), path])
+        if output is False:
+            self.logger.warning("Failed to get linting for file '{0}'.".format(path))
+            return False
+        output = output.decode("utf-8")
+        # Remove file paths from output
+        output = output.replace(path+":", "")
+        lines = output.split("\n")
+        linting = {}
+        for line in lines:
+            if not line:
+                continue
+            try:
+                parts = line.split(":")
+                line_no = int(parts[0])
+                char_no = int(parts[1])
+                data = ":".join(parts[2:]).strip()
+                err_code = data.split(" ")[0]
+                if err_code in self.ignore:
+                    continue
+                if line_no not in linting.keys():
+                    linting[line_no] = []
+                linting[line_no].append((char_no, data, err_code))
+            except (IndexError, ValueError):
+                self.logger.debug("Failed to parse line:{0}".format(line))
+        return linting
+
+
+class JsLint(BaseLint):
+    def __init__(self, logger):
+        BaseLint.__init__(self, logger)
+
+    def lint(self, path):
+        return self.get_file_linting(path)
+
+    def get_file_linting(self, path):
+        """Do linting check for given file path."""
+        output = self.get_output(["jshint", path])
+        if output is False:
+            self.logger.warning("Failed to get linting for file '{0}'.".format(path))
+            return False
+        output = output.decode("utf-8")
+        # Remove file paths from output
+        output = output.replace(path+": ", "")
+        lines = output.split("\n")
+        linting = {}
+        for line in lines:
+            if not line:
+                continue
+            try:
+                parts = line.split(", ")
+                if len(parts) < 3:
+                    continue
+                line_no = int(re.sub(r"\D", "", parts[0]))
+                char_no = int(re.sub(r"\D", "", parts[1]))
+                data = parts[2]
+                err_code = None
+                if line_no not in linting.keys():
+                    linting[line_no] = []
+                linting[line_no].append((char_no, data, err_code))
+            except (IndexError, ValueError):
+                self.logger.debug("Failed to parse line:{0}".format(line))
+        return linting
+
+
+class PhpLint(BaseLint):
+    def __init__(self, logger):
+        BaseLint.__init__(self, logger)
+
+    def lint(self, path):
+        return self.get_file_linting(path)
+
+    def get_output(self, cmd, errors=False):
+        # Need to override this since php reports the errors to stderr
+        try:
+            fnull = open(os.devnull, "w")
+            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            fnull.close()
+        except OSError:
+            self.logger.debug("Subprocess failed.")
+            return False
+        out, err = process.communicate()
+        return err
+
+    def get_file_linting(self, path):
+        """Do linting check for given file path."""
+        output = self.get_output(["php", "-l", path])
+        if output is False:
+            self.logger.warning("Failed to get linting for file '{0}'.".format(path))
+            return False
+        output = output.decode("utf-8")
+        lines = output.split("\n")
+        linting = {}
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                parts = line.split(" in {0} on line ".format(path))
+                self.logger.debug(parts)
+                if len(parts) != 2:
+                    continue
+                line_no = int(parts[1])
+                char_no = 0
+                data = parts[0]
+                err_code = None
+                if line_no not in linting.keys():
+                    linting[line_no] = []
+                linting[line_no].append((char_no, data, err_code))
+            except (IndexError, ValueError):
+                self.logger.debug("Failed to parse line:{0}".format(line))
+        return linting
+
+
+module = {
+    "class": Linter,
+    "name": "linter",
+}

suplemon/modules/lower.py

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class Lower(Module):
+    """Transform current lines to lower 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)
+                new_data = editor.lines[cursor.y].get_data().lower()
+                editor.lines[cursor.y].data = new_data
+
+
+module = {
+    "class": Lower,
+    "name": "lower",
+}

suplemon/modules/lstrip.py

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class LStrip(Module):
+    """Trim whitespace from beginning of current lines."""
+
+    def run(self, app, editor, args):
+        # TODO: move cursors in sync with line contents
+        line_nums = editor.get_lines_with_cursors()
+        for n in line_nums:
+            line = editor.lines[n]
+            line.data = line.data.lstrip()
+
+
+module = {
+    "class": LStrip,
+    "name": "lstrip",
+}

suplemon/modules/paste.py

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class Paste(Module):
+    """Toggle paste mode (helpful when pasting over SSH if auto indent is enabled)"""
+
+    def init(self):
+        # Flag for paste mode
+        self.active = False
+        # Initial state of auto indent
+        self.auto_indent_active = self.app.config["editor"]["auto_indent_newline"]
+        # Listen for config changes
+        self.bind_event_after("config_loaded", self.config_loaded)
+
+    def run(self, app, editor, args):
+        # Simply toggle pastemode when the command is run
+        self.active = not self.active
+        self.set_paste_mode(self.active)
+        self.show_confirmation()
+        return True
+
+    def config_loaded(self, e):
+        # Refresh the auto indent state when config is reloaded
+        self.auto_indent_active = self.app.config["editor"]["auto_indent_newline"]
+
+    def get_status(self):
+        # Return the paste mode status for the statusbar
+        return "[PASTEMODE]" if self.active else ""
+
+    def show_confirmation(self):
+        # Show a status message when pastemode is toggled
+        state = "activated" if self.active else "deactivated"
+        self.app.set_status("Paste mode " + state)
+
+    def set_paste_mode(self, active):
+        # Enable or disable auto indent
+        if active:
+            self.app.config["editor"]["auto_indent_newline"] = False
+        else:
+            self.app.config["editor"]["auto_indent_newline"] = self.auto_indent_active
+
+
+module = {
+    "class": Paste,
+    "name": "paste",
+    "status": "bottom",
+}

suplemon/modules/reload.py

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class Reload(Module):
+    """Reload all add-on modules."""
+
+    def run(self, app, editor, args):
+        self.app.modules.load()
+
+
+module = {
+    "class": Reload,
+    "name": "reload",
+}

suplemon/modules/replace_all.py

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class ReplaceAll(Module):
+    """Replace all occurrences in all files of given text with given replacement."""
+
+    def run(self, app, editor, args):
+        r_from = self.app.ui.query("Replace text:")
+        if not r_from:
+            return False
+        r_to = self.app.ui.query("Replace with:")
+        if not r_to:
+            return False
+        for file in app.get_files():
+            file.editor.replace_all(r_from, r_to)
+
+
+module = {
+    "class": ReplaceAll,
+    "name": "replace_all",
+}