When moving to a line shorter than the x coordinate of the cursor the x coordinate is reverted to the length of the line.
Instead suplemon should remember the x coordinate and use it when the line is long enough.

I think there should be a setting to hide the keyboard shortcuts in the status bar. Once you know all the hotkeys, there's not much point in displaying them always, IMHO.

A non-breaking space can be inserted with AltGr + Space, but it's not shown as whitespace. Should be shown with a visible symbol in show_whitespace mode.

Trying to autofind a dot character results in finding any character, since it's interpreted as a regex.

Could be useful for emphasizing special comments or lines.
For example comments with 'TODO' or 'FIXME' could be marked with red line numbers.

Trying to run suplemon causes an instant crash on Python 3.2.3:

python3 main.py main.py

Traceback (most recent call last):                                           
  File "main.py", line 490, in <module>                                      
    ui.wrapper(main)                                                         
  File "/home/pi/suplemon/ui.py", line 20, in wrapper                        
    curses.wrapper(func)                                                     
  File "/usr/lib/python3.2/curses/wrapper.py", line 43, in wrapper           
    return func(stdscr, *args, **kwds)                                       
  File "main.py", line 486, in main                                          
    app.run()                                                                
  File "main.py", line 97, in run                                            
    self.load()                                                              
  File "main.py", line 86, in load                                           
    self.ui.load()                                                           
  File "/home/pi/suplemon/ui.py", line 90, in load                           
    curses.curs_set(0)                                                       
_curses.error: curs_set() returned ERR

Two workarounds at the moment:

1. Run the following command in terminal to enable using Ctrl+S:

   stty -ixon

2. Press Ctrl+E in the editor and use the save command.

Apparently curses messes up the exit code, even if trying to force it with sys.exit(0). Easiest fix is to use Ctrl-X instead of Ctrl-C for exiting.

suplemon renders colors perfectly in a graphical terminal, yet it does not issue colors in a standard TTY on my machine. It may have to be double checked as my machine could be unusual.

Reproduce by:

1. Select all (Regex find '.' and press Ctrl+A)
2. Press END key
3. Press Delete until it crashes

I stumbled across the ctrl+k command when attempting to delete a line as in Sublime Text (i.e. ctrl+k,ctrl+k). This seems to be bound to a "Close File" command but it isn't respecting when I say "N":

Opened new file:

Pressed ctrl+k:

Typed N and pressed enter:

Expected behavior: File does not close

Actual behavior: Buffer resets or file closes (not sure which)

OS information: Running on [email protected](1) on Linux Mint 17.1 64 bit

Hi! Huge fan of the work you're doing.

If you change the #! to be "#!/usr/bin/env python3" suplemon will work on OS X (assuming python3, of course) without changes.

Great editor! One small issue - on my Mac the Backspace key produces ^?. Is there a config file where I can change that behavior?

Thanks
Mike

Results in only one insertion above the top most cursor.
Should insert the single line at each cursor position.

One of the easiest ways to get this in the hands of a lot of users is creating a Homebrew formula - well, once OS X support is working 100% :)

I'm erring on the side of being overly detailed here - apologies if I'm covering familiar ground!

1. Homebrew relies on semver; I notice you went from "0.1.11" to "0.1.2" which, in semver, would be a step backwards. (0.1.2 < 0.1.11 < 0.1.12 < 0.1.20)
2. Homebrew requires a stable release - it's possible to also have a HEAD and Devel channel, but packages that only have HEAD/Devel are not available by default to users. The easiest way to accomplish this is by tagging releases - if you tag a release as 0.1.3 GitHub will automatically create a tarball.
3. Some kind of launcher script is necessary - it's possible to embed that in to the Homebrew formula, but it's frowned upon.

A formula for Suplemon would probably look like the following - copied and pasted from the Homebrew formula template.

class Suplemon < Formula
  desc "Console text editor with multi cursor support. Suplemon replicates Sublime Text style functionality in the terminal."
  homepage "https://github.com/richrd/suplemon"
  version "0.1.3"
  url "https://github.com/richrd/suplemon/archive/0.1.3.tar.gz"
  head "https://github.com/richrd/suplemon.git"

  devel do
    url "https://github.com/richrd/suplemon.git", :using => :git, :branch => "dev"
    version "dev"
  end

  depends_on 'python3'
  depends_on 'coreutils' # greadlink for greadlink -f

  def install
    libexec.install Dir["*.py"]
    libexec.install Dir["modules"]
    libexec.install Dir["linelight"]
    bin.install "supl"
  end

end

Homebrew works by creating a series of symlinked repositories of various versions, etc - anything not specified during the install step is removed. (The formula spec makes a lot more sense when your last step is make install.) Here, I'm dumping everything in to libexec except for the supl launcher command; anything put in bin ends up on the user's path.

With this formula, a user could...

1. brew install suplemon to get 0.1.3
2. brew install suplemon --HEAD to get whatever is at the tip of master.
3. brew install suplemon --devel to get whatever is at the tip of dev. (--devel is supposed to be for alpha/canary versions; --HEAD is supposed to be for the literal bleeding edge - it might make sense to not support --devel and have --HEAD point to the dev branch.)

The supl command would probably look like...

#!/bin/sh
TARGET=`greadlink -f $0`
`dirname $TARGET`/../libexec/cli.py $*

The real thing should probably be a bit more intelligent (and useful for non-Homebrew users, of course. :)

Currently only setting a single cursor is possible.

Suplemon "redraws" the entire screen on each update, even if only one character or line has changed. This means that any change sends the entire view to the terminal. This causes flickering and sometimes slows down the app on a slow connection. Should optimize rendering to only redraw lines that changed.

Sometimes restores wrong state.

If the file has no name the save command should fallback on save_as.

I cloned the project and typed python3.4 main.py in Terminal. The ui has loaded, but it had no response when I typed anything. The cursor could not blink and move.

When I typed Ctrl + C to kill it. It printed:

Traceback (most recent call last):
  File "/home/devis/suplemon/main.py", line 443, in <module>
    ui.wrapper(main)
  File "/home/devis/suplemon/ui.py", line 22, in wrapper
    curses.wrapper(func)
  File "/usr/local/lib/python3.4/curses/__init__.py", line 94, in wrapper
    return func(stdscr, *args, **kwds)
  File "/home/devis/suplemon/main.py", line 436, in main
    app.run()
  File "/home/devis/suplemon/main.py", line 70, in run
    self.main_loop()
  File "/home/devis/suplemon/main.py", line 78, in main_loop
    self.ui.update()
  File "/home/devis/suplemon/ui.py", line 164, in update
    self.check_resize()
KeyboardInterrupt

but sometimes it printed:

Traceback (most recent call last):
  File "/home/devis/suplemon/main.py", line 443, in <module>
    ui.wrapper(main)
  File "/home/devis/suplemon/ui.py", line 22, in wrapper
    curses.wrapper(func)
  File "/usr/local/lib/python3.4/curses/__init__.py", line 94, in wrapper
    return func(stdscr, *args, **kwds)
  File "/home/devis/suplemon/main.py", line 436, in main
    app.run()
  File "/home/devis/suplemon/main.py", line 70, in run
    self.main_loop()
  File "/home/devis/suplemon/main.py", line 80, in main_loop
    event = self.ui.get_input()
KeyboardInterrupt

It is so strange.

Cutting with cursors on multiple lines fails. Instead only lines at the first cursor are cut.
Example:
Cutting lines 1 and 4 actually cuts 1 and 2.

|1 line one
2 line two
3 line three
|4 line four

Result:

|3 line three
|4 line four

Expected:

|2 line two
3 line three
| 

As useful a quick F1 is, I can't save with suplemon out-of-the-box in a MATE terminal, because F1 invokes help. ctrl+S or ^S is very common and people are used to it, let's use this too.

Autocomplete with words in open files, and possibly a word database.

I'll try to dig deeper but figured I'd post this in case it's obvious.

Normal editing works great; prompts (e.g. Save As / Exit Without Saving) do not support backspace.

Python version 3.4.3; built with Homebrew; 5913e4e

To reproduce, just open a file, press F1 to Save As, and attempt to backspace; nothing happens - not even a bell.

Reproduced on iTerm2 and on Apple Terminal.

I'm trying to replace my use of nano and ST3 with suplemon; one thing that would be really helpful (and I'm currently hacking around with aliases) would be a launcher script in the style of "subl" for Sublime Text.

Currently, if I symlink cli.py to /usr/local/bin/supl it, of course, fails; this has the side effect of making it hard to write a Homebrew formula (which might get a lot of extra users of suplemon. :)

Something as simple as:

#!/bin/sh
TARGET=`readlink $0`
`dirname $TARGET`/cli.py $*

might work. Note that normally readlink -f $0 would be ideal but the -f flag isn't supported on OS X. http://stackoverflow.com/questions/1055671/how-can-i-get-the-behavior-of-gnus-readlink-f-on-a-mac goes in to a lot of detail.

When opening Suplemon without specifying a file it opens a new empty file. The file is treated as modified (not saved) and the exit confirmation is triggered.

ncurses getch is called twice when pressing a multi byte character. Example: pressing ä results in ä.

When trying to cancel the Find input with Control - C the entire editor quits. This happens because of the change to input handling to support special characters.

Tabs should be shown as spaces even if show_whitespace is off. Causes cursor to be shown in the wrong place and sometimes causes a crash.

Define way to specify status priority to use for ordering statuses properly.

I have been digging around the source code a little bit and seeing some room for improvement. The general direction of the project is good but I think things might be smoother with a nudge in the right direction.

Larger items

Language choice

The project's goal is to be a CLI clone of Sublime Text and everyone talks to Sublime Text via it's Python plugin system. Great choice with regard to Python 👍

File architecture

It's usually not the best idea to keep most files in the root project folder. At some point, there become too many files and you feel like you are drowning. In Python projects, people usually relocate them into a folder with the project's name:

• suplemon/ - Git repo folder
  • suplemon/ - Container for all code related project files
    • main.py - Starting point for our application
    • linelight/ - Syntax highlighting files
    • ...

CLI invocation

The current method of starting suplemon is great for a proof of concept but doesn't allow for a lot of flexibility with CLI arguments (e.g. handling --version).

I suggest creating a bin/ folder and a suplemon.py script there. From this point, there are 2 approaches I have seen:

• Use argparse and perform all logic for interpretting arguments/setting up a config here

import argparse

parser = argparse.ArgumentParser(...)

• Create a suplemon/cli.py next to main.py which exposes a function cli() to parse arguments

# Inside `cli.py`
import argparse

def cli():
    parser = argparse.ArgumentParser(...)

# Inside `bin/suplemon.py`
from cli import cli
cli()

In both cases, we:

1. Interpret CLI arguments and initialize App() with our customized configuration (i.e. App(config))
2. If there were any files requested, invoke appropriate commands on App() to load them up

Pythonic anti-patterns

Using import * is a very big bad Pythonic anti-pattern. It makes it harder to find out where a function comes from which slows down new contributors. Please consider removing those =/

Linting/tests

There is no linting/tests. For new contributors, a lack of tests is a deterent because there is no way to verify they haven't broken anything.

As for linting, it saves a ton of time on PRs for people missing docstrings/using incorrect quotes. Additionally, it makes the project feel consistent which means code can be shifted around more easily. I recommend using flake8 and flake8-quotes; it's not overwhelming with its linting and has a nice extension system.

https://pypi.python.org/pypi/flake8

https://github.com/zheller/flake8-quotes

Command consistency with Sublime Text

A good amount of commands are consistent with Sublime Text. This is great because it makes the APIs/plugins easier to reuse between the systems. However, there are a few that are straying (e.g. prev_file vs prev_view):

https://github.com/randy3k/sublime-default/blob/5c296d63820968a1fe1e0c9a54cb0a2cd7c65595/Default%20%28Linux%29.sublime-keymap#L90-L91

Additionally, for things like scrolling we can input custom arguments to the commands (actually keyword arguments/kwargs):

https://github.com/randy3k/sublime-default/blob/5c296d63820968a1fe1e0c9a54cb0a2cd7c65595/Default%20%28Linux%29.sublime-keymap#L87-L88

Shortcut consistency with Sublime Text

We already discussed this in #49 but to reiterate, it would be nice to be as close to Sublime Text to make switching contexts easier.

https://github.com/randy3k/sublime-default/blob/5c296d63820968a1fe1e0c9a54cb0a2cd7c65595/Default (Linux).sublime-keymap

Breakdown App

main.py has grown quite large. We should consider breaking out the sections into classes that mixin or are modules themselves.

https://github.com/richrd/suplemon/blob/915c0c0485dcae795c577f2e57329c5031d5c8d1/main.py

Use Python logging library

While generating a custom logger works, it isn't as practical/error proof as Python's built in logger. We should consider using the logging module instead.

https://github.com/richrd/suplemon/blob/915c0c0485dcae795c577f2e57329c5031d5c8d1/logger.py

https://docs.python.org/3.4/library/logging.html

Configuration management

Use a ~/.config/suplemon/ folder for multiple files over a single file at ~/.suplemon-config.json. There are a few reasons for this:

• Not compatible with Sublime Text
• Combined files become larger which makes it harder to search through as a user
• People hate more files in their ~ folder (hence ~/.config)

As for where we keep the defaults, I suggest removing them from config and storing them as .json files along side in a suplemon/config/ folder. This will keep the paradigms consistent between ~/.config/ and suplemon itself.

Small items

app.log method

Both redefining logger methods on app and passing in log_type as a parameter are unnecessary conventions. Python's logging library has multiple methods for each different level (e.g. logger.info, logger.debug). We should move the logging and pick up those methods for free. Additionally, redefining the methods on app is impractical and leads to redundant code:

app.logger.info("Hello World!")

Always use interpolation or .format

Python has built in suport for making concatenated strings presentable via interpolation. We should stop using concatenation and move to interpolation as it's more Pythonic:

self.logger.log("Looking for command '{cmd}'".format(cmd=cmd), LOG_INFO)

Coding consistency

You are always using always using double quotes for strings. That is great to see as it leads to the project feeling more consistent as a whole 👍

Most functions have docstrings which is great. One note on this, you might want to consider using Sphinx notation for documenting parameters/return values as well:

http://sphinx-doc.org/domains.html#info-field-lists

Inconsistent spacing sometimes

You are pretty good with your spacing being consistent (e.g. spaces before/after +, ==). However, there were a few spots that didn't have consistency. Typically a linter will catch this.

self.logger.log("Looking for command '" + cmd +"'", LOG_INFO)
# should be
self.logger.log("Looking for command '" + cmd + "'", LOG_INFO)

self.log("Loading: "+str(item), LOG_INFO)
# should be
self.log("Loading: " + str(item), LOG_INFO)

Use key bindings from app for legend

The show_legend command isn't using the key bindings from app/config. This could lead to inconsistencies later on.

Syntax highlighting

Our current syntax highlighter is pretty naive (e.g. doesn't handle lines with multiple commands well). We should consider using a more fully fledged one like pygments with a custom formatter:

https://github.com/richrd/suplemon/blob/915c0c0485dcae795c577f2e57329c5031d5c8d1/linelight/js.py

http://pygments.org/docs/formatters/

Key bindings

Our current key bindings like kNXT5 are cryptic. We should aim for a setup closer to Sublime Text (e.g. ctrl+pageup)

https://github.com/randy3k/sublime-default/blob/5c296d63820968a1fe1e0c9a54cb0a2cd7c65595/Default%20%28Linux%29.sublime-keymap#L91

Should reload highlighting if filename changes.

Incomplete list of additional bindings:

App

kNXT5: prev_file
kPRV5: next_file

Editor

^I: tab
kDN3: new_cursor_down
kUP3: new_cursor_up
kRIT5: jump_right
kLFT5: jump_left

The current Control + K shortcut always asks wether file should be closed. Instead it should only ask to close if the file is modified, else just close automatically.

Hi, nice work on the editor! You should consider this when refactoring the code- currently in line 606, file editor.py there is a huge conditional with lots of branches for comparing the keys. What I suggest is that you instead use a dictionary to hold all the callbacks, i.e.

class Editor(Viewer):
    key_mappings = {}
    #...

Editor.key_mappings.update({
    curses.KEY_RIGHT: dispatch('arrow_right')
})

Where dispatch is a function that returns a closure that when called with an instance, it dispatches to the enclosed attribute. Then the code in handle_input would be easier to implement as well:

def handle_input(self, event):
    if event.type == "mouse":
        return False
    key = event.key_code
    if key in self.key_mappings:
        self.key_mappings[key]()
        return
    try:
        self.type(key)
    except:
        pass

Pragmatic considerations aside, this also trades space for time, as the conditional runs in O(n), where n is relative to the key. This implementation runs in O(1), and also allows plugins to map keys to their own callbacks, a la Vim. Also it reflects the mental model of the editor being a program that just responds to events and acts on the text. You can also use a list to store the callbacks to be invoked when keys are pressed, but that's another story.

Gives error on line 225 in self.window.addstr(...
Occurs on Mac.

Jumping between words works, but nothing happens when jumping left at line start or jumping right at line end.

Should to jump to beginning of next line or end of previous line.

'utf-8' codec can't decode byte 0x92 in position 10: invalid start byte

Should be light gray.

Should do nothing by default, and maybe open all files in directory if configured to do so.