Merge pull request #107 from syl20bnr/vi-mode-plugin

.gitignore

@@ -1,3 +1,4 @@
 custom/*
 
-.DS_Store
+.DS_Store
+*.pyc

plugins/vi-mode/README.md

@@ -0,0 +1,62 @@
+# vi-mode
+Basic vi key bindings emulation for fish.
+
+## Install
+Add `vi-mode` to your list of fish plugins in your `config.fish`.
+
+Example:
+
+    set fish_plugins autojump vi-mode
+
+## Configuration
+### Default mode
+The default vi mode can be set by defining the variable `vi_mode_default` in
+your `config.fish`.
+If used, this variable must be set before loading `oh-my-fish`.
+Its default value is `vi_mode_insert`.
+
+To set normal mode as default:
+
+    set vi_mode_default vi_mode_normal
+
+### Mode indicator
+The mode indicator is stored in the variable `vi_mode`.
+
+See the oh-my-fish theme `simplevi` for an example of integration of the
+indicator into the prompt.
+
+### User key bindings
+User additional key bindings can be defined with the function
+`vi_mode_user_key_bindings`. If used, this function must be defined before
+loading `oh-my-fish`.
+
+Example:
+
+    function vi_mode_user_key_bindings
+        bind \el  suppress-autosuggestion
+    end
+
+## Not implemented
+- bind 2 vi-arg-digit
+- bind y yank-direction
+- bind g magic :-P
+- bind ^a increment next number
+- bind ^x decrement next number
+- bind /?nN search (jk kind of does this)
+- registers (maybe try to make sensible integration into X, like an
+  explicit yank with y goes to an X selection, while an implicit
+  delete with x etc. doesn't. "\* and "+ should natually go to the
+  appropriate X selection if possible)
+- etc.
+
+## Author
+This mode has been created by [Ian Munsie][ian_github], the original file can
+be found [here][original].
+It has been adapted for oh-my-fish by [Sylvain Benner][syl_github].
+
+[ian_github]: https://github.com/DarkStarSword
+[original]: https://github.com/DarkStarSword/junk/blob/master/vi-mode.fish
+[syl_github]: https://github.com/syl20bnr
+
+
+

plugins/vi-mode/vi-mode-impl.py

@@ -0,0 +1,198 @@
+# This script is part of the vi-mode plugin for fish
+# author: Ian Munsie
+# Adapted for oh-my-fish by Sylvain Benner
+
+import sys
+from functools import reduce
+
+command = sys.argv[1]
+direction = sys.argv[2]
+new_pos = pos = int(sys.argv[3])
+lineno = int(sys.argv[4]) - 1
+cmdline_list = sys.argv[5:]
+cmdline = '\n'.join(cmdline_list)
+
+def start():
+    return (0, 0)
+def end():
+    return (len(cmdline), -1)
+class not_found(Exception): pass
+
+def dir_0():
+    return (reduce(lambda a,b: a + len(b) + 1, cmdline_list[:lineno], 0), 0)
+
+def dir_eol(): # end of line
+    before_len = reduce(lambda a,b: a + len(b) + 1, cmdline_list[:lineno], 0)
+    line_len = len(cmdline_list[lineno]) or 1
+    return (before_len + line_len, -1)
+
+# These routines are all similar, they can probably be combined into one, but
+# I'll make sure I get all working and understand the differences first
+def dir_fnw(): # First Non-Whitespace
+    import re
+    len_before = reduce(lambda a,b: a + len(b) + 1, cmdline_list[:lineno], 0)
+    match = re.search('^\s*[^\s]', cmdline_list[lineno])
+    if not match:
+        return start()
+    return (len_before + match.end()-1, 0)
+dir__ = dir_fnw # XXX: I always used _ as this, but turns out that might not be quite right
+
+def _dir_w(regexp):
+    import re
+
+    searchpart = cmdline[pos:]
+    match = re.search(regexp, searchpart)
+    if not match:
+        return end()
+    return (pos + match.end()-1, 0)
+
+def _dir_e(regexp):
+    import re
+
+    searchpart = cmdline[pos+1:]
+    match = re.search(regexp, searchpart)
+    if not match:
+        return end()
+    return (pos+2 + match.start(), -1)
+
+def _dir_b(regexp):
+    import re
+
+    if pos == 0:
+        return start()
+
+    # Reverse the string instead of matching to right:
+    searchpart = cmdline[pos-1::-1]
+    match = re.search(regexp, searchpart)
+    if not match:
+        return start()
+    return (len(searchpart) - (match.start()+1), 0)
+
+def _dir_ge(regexp):
+    import re
+
+    if pos == 0:
+        return start()
+
+    # Reverse the string instead of matching to right:
+    searchpart = cmdline[pos::-1]
+    match = re.search(regexp, searchpart)
+    if not match:
+        return start()
+    return (len(searchpart) - (match.end()), 0)
+
+# Simple, but not inclusive enough:
+# def dir_w(): return _dir_w(r'[^\w]\w')
+# def dir_e(): return _dir_e(r'\w[^\w]')
+
+# Slightly too inclusive, e.g. fi--sh matches both '-' characters, but should only match one:
+_dir_w_regexp = r'[^\w][^\s]|\w[^\w\s]'
+_dir_e_regexp = r'[^\s][^\w]|[^\w\s]\w'
+_dir_W_regexp = r'\s[^\s]'
+_dir_E_regexp = r'[^\s]\s'
+
+def dir_w(): return _dir_w(_dir_w_regexp)
+def dir_W(): return _dir_w(_dir_W_regexp)
+def dir_e(): return _dir_e(_dir_e_regexp)
+def dir_E(): return _dir_e(_dir_E_regexp)
+def dir_b(): return _dir_b(_dir_e_regexp)
+def dir_B(): return _dir_b(_dir_E_regexp)
+def dir_ge(): return _dir_ge(_dir_w_regexp)
+def dir_gE(): return _dir_ge(_dir_W_regexp)
+def dir_cw(): return _dir_w(_dir_e_regexp)
+def dir_cW(): return _dir_w(_dir_E_regexp)
+
+def dir_h():
+    if pos: return (pos-1, 0)
+    return start()
+
+def dir_l():
+    return (pos+1, 0)
+
+def dir_t(char):
+    new_pos = cmdline.find(char, pos+1)
+    if new_pos < 0:
+        raise not_found
+    return (new_pos, -1)
+
+def dir_T(char):
+    new_pos = cmdline.rfind(char, 0, pos)
+    if new_pos < 0:
+        raise not_found
+    return (new_pos+1, 0)
+
+def dir_f(char): return (dir_t(char)[0]+1, -1)
+def dir_F(char): return (dir_T(char)[0]-1, 0)
+
+def cmd_delete():
+    dst_pos = dir(direction)
+    if dst_pos >= pos:
+        new_cmdline = cmdline[:pos] + cmdline[dst_pos:]
+        return (new_cmdline, pos)
+    new_cmdline = cmdline[:dst_pos] + cmdline[pos:]
+    return (new_cmdline, dst_pos)
+
+def cmd_change():
+    # 'Special case: 'cw' and 'cW' are treated like 'ce' and 'cE' if the cursor
+    # is on a non-blank.  This is because 'cw' is interpreted as change-word,
+    # and a word does not include the following white space.'
+    #
+    # Note: Even with this special case the behaviour does not quite match what
+    # vim actually does in practice - try with the cursor on punctuation, or on
+    # the last character in a word. Specifically, the behaviour of cw differs
+    # from ce when the cursor is already on the last character of a 'word', for
+    # vim's definition of word.
+    #
+    # Because of this, we use a special direction to handle this case.
+    global direction
+    if direction in 'wW' and not cmdline[pos].isspace():
+        direction = direction.replace('w', 'cw').replace('W', 'cW')
+    return cmd_delete()
+
+def cmd_o():
+    above = '\n'.join(cmdline_list[:lineno + 1])
+    below = '\n'.join(cmdline_list[lineno + 1:])
+    return (above + '\n\n' + below, len(above)+1)
+
+def cmd_O():
+    above = '\n'.join(cmdline_list[:lineno])
+    below = '\n'.join(cmdline_list[lineno:])
+    return (above + '\n\n' + below, len(above)+1)
+
+def _dir_cmd_func(func):
+    (pos1, pos2) = (pos, dir(direction))
+    if pos2 < pos:
+        (pos1, pos2) = (pos2, pos1)
+    new_cmdline = cmdline[:pos1] + func(cmdline[pos1:pos2]) + cmdline[pos2:]
+    return (new_cmdline, pos1)
+
+# XXX: automagic completion sometimes hides the results of changing the case in these commands:
+def cmd_upper(): return _dir_cmd_func(str.upper)
+def cmd_lower(): return _dir_cmd_func(str.lower)
+def cmd_swapcase():  return _dir_cmd_func(str.swapcase)
+
+def dir(d, cursor = False):
+    def validate(pos):
+        if pos < 0: return 0
+        if pos > len(cmdline): return len(cmdline)
+        return pos
+    a = ()
+    if ':' in d:
+        (d, a) = d.split(':', 1)
+    (new_pos, cursor_off) = globals()['dir_%s' % d](*a)
+    if cursor:
+        return validate(new_pos + cursor_off)
+    return validate(new_pos)
+
+def cmd(c): return globals()['cmd_%s' % c]()
+
+def cmd_normal():
+    return (None, dir(direction, True))
+
+try:
+    (cmdline, new_pos) = cmd(command)
+    if cmdline is not None:
+        print ( cmdline )
+except not_found:
+    new_pos = pos
+print ( new_pos )

plugins/vi-mode/vi-mode.load

@@ -0,0 +1,306 @@
+# vi:noexpandtab:sw=4:ts=4
+#
+# vi-mode for fish
+# author: Ian Munsie
+# Adapted for oh-my-fish by Sylvain Benner
+#
+# Requirements: fish 2.0+
+
+# I'm thinking about changing these to separate out the colours from the text.
+# I'm undecided on this though - when I support count arguments there may be
+# some benefit from displaying the count here, but that would also make the
+# size of these strings vary, which I'd rather not do...
+set -l cn (set_color normal 2>/dev/null)
+set -g vi_mode_normal  (set_color blue 2>/dev/null)'n'$cn
+set -g vi_mode_replace (set_color red 2>/dev/null)'r'$cn
+set -g vi_mode_REPLACE (set_color --background=red 2>/dev/null)'R'$cn
+set -g vi_mode_insert  (set_color green 2>/dev/null)'i'$cn
+set -g vi_mode_delete  (set_color red 2>/dev/null)'d'$cn
+set -g vi_mode_change  (set_color yellow 2>/dev/null)'c'$cn
+set -g vi_mode_g       (set_color blue 2>/dev/null)'g'$cn
+set -g vi_mode_lower   (set_color blue 2>/dev/null)'u'$cn
+set -g vi_mode_upper   (set_color blue 2>/dev/null)'U'$cn
+set -g vi_mode_swapcase (set_color blue 2>/dev/null)'~'$cn
+
+set -g __vi_mode_undo_cmdline ''
+set -g __vi_mode_undo_cmdline_pos 0
+
+# default vi mode
+if test -z $vi_mode_default
+    set -g vi_mode_default vi_mode_insert
+end
+
+# additional user key bindings go in vi_mode_user_key_bindings
+function __vi_mode_user_key_bindings
+    if functions | grep "vi_mode_user_key_bindings" > /dev/null
+        vi_mode_user_key_bindings
+    end
+end
+
+function __vi_mode_direction_command
+    # commandline should always be last
+    set ret (python (dirname (status -f))/vi-mode-impl.py $argv[1] $argv[2] (commandline -C) (commandline -L) (commandline))
+    set new_pos $ret[-1]
+    set -e ret[-1] # Guessing that deleting last element is likely to be faster than deleting first
+    if test (count $ret) -gt 0
+        commandline -- $ret
+    end
+    commandline -C $new_pos
+end
+
+function __vi_mode_common_emacs -d "common key bindings for all vi-like modes that are identical to the emacs mode"
+    # Feel free to expand this list for anything that makes sense, this is just
+    # a couple of hand-picked ones that seemed useful and/or I use :)
+
+    bind \e\[A up-or-search
+    bind \e\[B down-or-search
+    bind -k down down-or-search
+    bind -k up up-or-search
+
+    bind \e\[C forward-char
+    bind \e\[D backward-char
+    bind -k right forward-char
+    bind -k left backward-char
+
+    bind \e\[H beginning-of-line
+    bind \e\[F end-of-line
+    # OS X SnowLeopard doesn't have these keys. Don't show an annoying error message.
+    bind -k home beginning-of-line 2> /dev/null
+    bind -k end end-of-line 2> /dev/null
+
+    bind \cl 'clear; commandline -f repaint'
+    bind \cd delete-or-exit
+end
+
+function __vi_mode_common -d "common key bindings for all vi-like modes"
+    __vi_mode_common_emacs
+
+    bind \e vi_mode_normal
+
+    # Can we put commandline into history when pressing ^C?
+    bind \cc '__vi_mode_save_cmdline; for i in (seq (count (commandline))); echo; end; commandline ""; vi_mode_insert'
+
+    bind \n "commandline -f execute; "$vi_mode_default
+    __vi_mode_user_key_bindings
+end
+
+function __vi_mode_common_insert -d "common key bindings for all insert vi-like modes"
+    __vi_mode_common
+    bind \e 'commandline -f backward-char; vi_mode_normal'
+    if functions -q vi_mode_user
+        vi_mode_user insert
+    end
+end
+
+function __vi_mode_bind_directions
+    __vi_mode $argv[1]
+
+    for direction in W w E e B b 0 _ h l
+        bind $direction "$argv[3]; __vi_mode_direction_command '$argv[1]' $direction; $argv[2]"
+    end
+    bind \$ "$argv[3]; __vi_mode_direction_command '$argv[1]' eol; $argv[2]"
+    bind \^ "$argv[3]; __vi_mode_direction_command '$argv[1]' fnw; $argv[2]"
+    for direction in f F t T
+        bind $direction "__vi_mode_bind_all '$argv[3]; __vi_mode_direction_command %q$argv[1]%q {$direction}:%k; $argv[2]'"
+    end
+
+    bind g "__vi_mode_bind_directions_g $argv"
+end
+
+function __vi_mode_bind_directions_g
+    for direction in e E
+        bind $direction "$argv[3]; __vi_mode_direction_command '$argv[1]' g$direction; $argv[2]"
+    end
+end
+
+function __vi_mode_bind_all
+    # There seems to be some magic that doesn't work properly without this:
+    bind '' self-insert
+
+    python -c "
+command = '''$argv'''
+for c in map(chr, range(0x20, 0x7f)):
+    q = '\"' # Enclose command in these
+    Q = '\'' # Other quote - for quotes inside command
+    if c == '\"':
+        l = r = r'\\%s' % c
+        (q, Q) = (Q, q) # Swap quotes
+    elif c in ['(', ')', '<', '>', ';', '|', '\'']:
+        l = r = r'\%s' % c
+    elif c == '\\\\':
+        l = r'\\\\'
+        r = r'\\\\\\\\'
+    elif c == '\$':
+        l = '\%s' % c
+        r = r\"'\%s'\" % c
+    else:
+        l = r = \"'%s'\" % c
+    print ( 'bind %s %s%s%s' % (l, q, command.replace('%k', r).replace('%q', Q), q))
+    " | .
+end
+
+function __vi_mode
+    # Is there a way to do this without eval?
+    # We really want something like a dictionary...
+    eval set -g vi_mode \$vi_mode_{$argv}
+    commandline -f repaint
+end
+
+function __vi_mode_replace
+    __vi_mode replace
+    bind --erase --all
+    __vi_mode_common
+
+    # backward-char should happen last, but only works if specified first
+    # (guess I should dig through the C code and figure out what is going
+    # on):
+    # __vi_mode_bind_all "commandline -f delete-char; commandline -i %k; commandline -f backward-char; vi_mode_normal"
+    __vi_mode_bind_all "__vi_mode_save_cmdline; commandline -f backward-char delete-char; commandline -i %k; vi_mode_normal"
+
+    if functions -q vi_mode_user
+        vi_mode_user replace
+    end
+end
+
+function __vi_mode_overwrite
+    __vi_mode REPLACE
+    bind --erase --all
+    __vi_mode_common_insert
+    __vi_mode_save_cmdline
+
+    __vi_mode_bind_all "commandline -f delete-char; commandline -i %k"
+    if functions -q vi_mode_user
+        vi_mode_user overwrite
+    end
+end
+
+function __vi_mode_save_cmdline
+    # Only vi style single level for now, patch to suppport vim style
+    # multi-level undo history welcome
+    set -g __vi_mode_undo_cmdline (commandline)
+    set -g __vi_mode_undo_cmdline_pos (commandline -C)
+end
+
+function __vi_mode_undo
+    set -l cmdline (commandline)
+    set -l pos (commandline -C)
+    commandline $__vi_mode_undo_cmdline
+    commandline -C $__vi_mode_undo_cmdline_pos
+    set -g __vi_mode_undo_cmdline $cmdline
+    set -g __vi_mode_undo_cmdline_pos $pos
+end
+
+function __vi_mode_g -d "vi-like key bindings for fish (commands starting with g)"
+    __vi_mode g
+    bind --erase --all
+    __vi_mode_bind_all 'vi_mode_normal'
+    __vi_mode_common
+
+    bind I '__vi_mode_save_cmdline; commandline -f beginning-of-line; vi_mode_insert'
+    # XXX: automagic completion sometimes hides the results of changing the case in these commands:
+    bind u '__vi_mode_bind_directions lower vi_mode_normal __vi_mode_save_cmdline'
+    bind U '__vi_mode_bind_directions upper vi_mode_normal __vi_mode_save_cmdline'
+    bind \~ '__vi_mode_bind_directions swapcase vi_mode_normal __vi_mode_save_cmdline'
+    # TODO: The rest of the g commands + directions.
+
+    __vi_mode_bind_directions_g normal vi_mode_normal ''
+
+    if functions -q vi_mode_user
+        vi_mode_user g
+    end
+end
+
+function vi_mode_normal -d "WIP vi-like key bindings for fish (normal mode)"
+    __vi_mode normal
+
+    bind --erase --all
+
+    # NOTE: bind '' self-insert seems to be required to allow the
+    # prompt to change, but we don't want unbound keys to be able to
+    # self-insert, so set the default binding, but bind everything to
+    # do nothing (which is wasteful, but seems to work):
+    __vi_mode_bind_all ''
+
+    __vi_mode_common
+
+    # Fish recently gained support for this, redirect to /dev/null so it
+    # doesn't fall over if running an old version of fish:
+    commandline -f suppress-autosuggestion 2>/dev/null
+
+    bind i '__vi_mode_save_cmdline; vi_mode_insert'
+    bind I '__vi_mode_save_cmdline; __vi_mode_direction_command normal fnw; vi_mode_insert'
+    bind a '__vi_mode_save_cmdline; commandline -f forward-char; vi_mode_insert'
+    bind A '__vi_mode_save_cmdline; commandline -f end-of-line; vi_mode_insert'
+    bind o '__vi_mode_save_cmdline; __vi_mode_direction_command o ""; vi_mode_insert'
+    bind O '__vi_mode_save_cmdline; __vi_mode_direction_command O ""; vi_mode_insert'
+
+    # Cool, these functions are pretty close to what I wanted:
+    # FIXME: Cursor not placed in correct position, but moving it prevents further searching
+    bind j down-or-search
+    bind k up-or-search
+
+    bind x '__vi_mode_save_cmdline; commandline -f delete-char'
+    bind D '__vi_mode_save_cmdline; commandline -f kill-line'
+    # bind Y 'commandline -f kill-whole-line yank'
+    bind P '__vi_mode_save_cmdline; commandline -f yank'
+    bind p '__vi_mode_save_cmdline; commandline -f yank forward-char' # Yes, this is reversed. Otherwise it does the wrong thing. Go figure.
+    bind C '__vi_mode_save_cmdline; commandline -f kill-line; vi_mode_insert'
+    bind S '__vi_mode_save_cmdline; commandline -f kill-whole-line; vi_mode_insert'
+    bind s '__vi_mode_save_cmdline; commandline -f delete-char; vi_mode_insert'
+    bind r __vi_mode_replace
+    bind R __vi_mode_overwrite
+
+    # XXX: The automagic completion sometimes displays the case from the
+    # command it wants to complete instead of the case actually on the
+    # commandline, so even though this works, it may not always appear to work.
+    # I'm not sure if I can do anything about that, I'll need to look at the
+    # code. Ideally I would turn off automagic completion whenever I'm not in
+    # insert mode.
+    bind \~ '__vi_mode_save_cmdline; commandline -f forward-char; __vi_mode_direction_command swapcase l'
+
+    __vi_mode_bind_directions normal vi_mode_normal ''
+    bind d '__vi_mode_bind_directions delete vi_mode_normal __vi_mode_save_cmdline'
+    bind c '__vi_mode_bind_directions change vi_mode_insert __vi_mode_save_cmdline'
+
+    # Override generic direction code for simple things that have a close
+    # match in fish's builtin commands, which should be faster:
+    bind h backward-char
+    bind l forward-char
+    bind 0 beginning-of-line
+    # bind \$ end-of-line #FIXME: Cursor position
+    # bind b backward-word # Note: built-in implementation only recently fixed. Also, before enabling this override, determine if this matches on the right characters
+
+    bind g __vi_mode_g # MUST BE AFTER BIND_DIRECTIONS... I'm thinking about changing it so that this is all handled by bind_directions
+    bind u __vi_mode_undo
+
+    # NOT IMPLEMENTED:
+    # bind 2 vi-arg-digit
+    # bind y yank-direction
+    # bind g magic :-P
+    # bind ^a increment next number
+    # bind ^x decrement next number
+    # bind /?nN search (jk kind of does this)
+    # registers (maybe try to make sensible integration into X, like an
+    #   explicit yank with y goes to an X selection, while an implicit
+    #   delete with x etc. doesn't. "* and "+ should natually go to the
+    #   appropriate X selection if possible)
+    # etc.
+
+    if functions -q vi_mode_user
+        vi_mode_user normal
+    end
+end
+
+function vi_mode_insert -d "vi-like key bindings for fish (insert mode)"
+    __vi_mode insert
+
+    fish_default_key_bindings
+
+    __vi_mode_common_insert
+end
+
+function fish_user_key_bindings
+  eval $vi_mode_default
+end
+
+# vi:noexpandtab:sw=4:ts=4

themes/simplevi/README.md

@@ -0,0 +1,12 @@
+fish_prompt-simplevi
+====================
+
+The stock prompt with the vi indicator appended.
+It is meant to be used with the `vi-mode` plugin.
+
+Screenshots:
+
+![normal mode](https://raw.github.com/syl20bnr/fish_prompt-simplevi/master/prompt_fish-simplevi-n.png)
+
+![insert mode](https://raw.github.com/syl20bnr/fish_prompt-simplevi/master/prompt_fish-simplevi-i.png)
+

themes/simplevi/fish_prompt.fish

@@ -0,0 +1,4 @@
+# name: simplevi
+function fish_prompt -d "Write out the prompt"
+  printf '%s@%s%s%s%s [%s]> ' (whoami) (hostname|cut -d . -f 1) (set_color $fish_color_cwd) (prompt_pwd) (set_color normal) $vi_mode
+end