VER Roadmap

This roadmap is not sorted in order of importance, it’s more like a verbose todo- and wish-list.

Features should be removed once they are implemented.

If you have any non-trivial bugs or ideas, add them here.

Sessions

Storing the current state of VER on disk for next startup. Right now we (re)store the filenames of open views, the position of the insert mark, and any bookmarks. Modes are not stored, as they could cause very tricky bugs. However, that shouldn’t be a big problem for most people, i hope. Please suggest other things we can persist.

VCS integration

Mostly shortcuts for various source control systems. These could simply open a terminal and execute a command. Example can be the git plugin.

org-mode / remember

Something to get things done and be reminded of them.

Code folding

Exapnd sections of code, we can start out by the folding rules specified by the tm bundle preferences. Eventually this would be useful for other things like Viki.

Notebook tabs

Using ttk::notebook we could implement tabs instead of the tiling view, or combine the two.

We did that, but that’s not very useful without the ability to see more than one tab at a time. Next idea is to have a layout that provides a list of notebooks and assigns a view to one of them based on some heuristic. Then we can wrap all of that into a tiling layout. Keybindings for that should be fun… we can use awesome as reference.

Markdown

The current tm syntax simply doesn’t compile to a clean oniguruma regexp, try to fix it.

Dictionary

Looking up dictionaries… translation. Maybe using something like google translate API when online?

Support mirror and mirror transformation for snippets

The most powerful snipets are using mirror and mirror transformations. In order to provide full support, we need to implement that.

Improve integration of scope selectors and bundles

Right now we are doing a very simple matching of scope selectors, just to get things started. I’d like to improve on that by applying correct precedence for matching scopes.

Improve integration of Bundles

Allowing bundles to bind keychains to commands. Might be problematic, as the keychains are specific for the TM environment, so it’s very OSX specific and will conflict with e.g. emacs or vim keymaps.

Maybe we need a separate TM keymap and define a common prefix to the keychains in other keymaps.

Update keymaps

All the keymaps (apart from vim) need to be fixed to match current major/minor mode structure.

Move queries to the global VER status

The current text status should be more flexible than a simple Entry and it can be confusing to be asked for entry in different locations. By doing this, we can insert custom widgets into the text status. Both vim and emacs do it this way, and it seems to work fine.

Add specs

We should add specs for as many things as possible.

Help system

Using YARD, we could nicely present documentation for every constant and method with intelligent linking between them.

# a short example of how to access YARD docs.
require 'yard'
YARD::Registry.load_yardoc
YARD::Registry.at('VER').docstring
# "This is the doc for VER"

Of course we need to make browsing better than the current HTML browsers.

Equivalent to vim : or emacs M-x

Executor is fun, but it’s not powerful enough yet. We have bound to a simple eval query right now, which is also nice, but not helping much if you have no idea what to eval. So what we need, is a mix of Executor::Method and eval, which is quite a challenge. What we could do, is go through all the Action instances of the major and minor modes for the buffer and make completion based on this. I have no idea how that would be best presented, but in the worst case we can rip something off.

I also really like the way emacs does the fast-forward completion in a not-too-annoying way, that’s going to be another tough challenge.

Power to the Modes

Major and minor modes are working out well, they are precise and fast, but still lack some power over the buffer outside of events fired by the user. It would be nice, for example, to have a minor mode that can act like a wiki templating engine, which is needed for org-mode. It needs to elide some text, inserting other text instead of that, and keep everything sane at the same time, making sure that the right version of the buffer is stored to a file can also be tricky…

Dired alike

One common task I always go to the terminal for is creating directories, renaming or moving files around, it would be both useful and a testament to the power of VER to implement a dired alike. I’m still hoping that some day we can get that Finder from lianj, but it’s just not the same.

Simulatanous file overwrite protection

When two instances of VER edit the same file, there is no mechanism to detect that fact. This can cause serious problems that VER should be able to handle. Emacs protects against it by creating a symlink that points to the emacs instance that has the file open.

A link looks like this: `lrwxrwxrwx 1 manveru users 36 Jan 30 02:28 .#AUTHORS → manveru@delta.local.28003:1264265541`

When another instance opens the same file, it can check the symlink and knows who’s editing. It may then replace the symlink to “steal” ownership, ignore the lock, or forbid modification.

Another safeguard is to check the file mtime when opening, and see whether it’s still the same before writing the file to disk again. This allows for a small race-condition, but it’s still vastly better than no protection at all.

A major mode per bundle

Right now, a major mode is a compilation of minor modes plus a keymap of its own. What we would like is a major mode that takes responsibility of the syntax/snippets/preferences (bundle) being used. The hard part about this is that we would have to know which major mode name is associated with a bundle. We face a bit of a bootstrapping problem, for emacs this is no issue, as lots of code monkeys wrote lots of major modes for their favorite languages. We don’t have that benefit, all we have is a bunch of bundles from TM that we can scavange. We could create our own kind of Bundle format.

config/bundles/Ruby config/bundles/Ruby/keymaps/vim.rb config/bundles/Ruby/syntax.rb config/bundles/Ruby/preferences.rb config/bundles/Ruby/snippets.rb

this way, to share a bundle you can simply tar up the folder and put it somewhere. This also makes it easier to keep bundles outside of the VER folder structure, in another git repo, for example, and just point VER to that location.

Text => .syntax Text => .preferences Text => .snippets

WidgetMajorMode(widget, major) => MajorMode(name) => Ruby(Syntax, preferences, snippets)