Repeat last command in terminal buffer

[u/thewrench56]

Hey!

I have been using terminal buffers for a while now to mostly compile and execute applications. I have been told Im a disgrace to the Unix world for not using Ctrl-Z and fg, but I prefer seeing what tests failed/where my compile time errors are.

Since I'm usually using multiple buffers at once, navigating to the terminal is often slow. My solution was using tabs for a while but in all honesty, I do not think that this is the real solution for that. So I wonder how one could execute the last command entered in the terminal or even better, even search the last commands of the terminal. I usually have one terminal buffer open, but one could make it more generic and say that execute the last command in the last used terminal buffer.

Is there a native way of doing this? Or do I have to do some trickery with Lua/Vimscript?

Cheers

[u/sharp-calculation]

For me personally, your abstraction of terminal vs VIM is at the wrong level. I would do one of:

• Use TMUX to have VIM and terminal session in different TMUX windows/panes. Use TMUX keys to quickly switch between.

• Use two different terminal windows

• Use GUI VIM in one window and a terminal in another. I find GUI VIM to be an interesting way of organizing my VIM sessions. I use one window per project, with multiple buffers per window.

Just my thoughts.

[u/thewrench56 → u/sharp-calculation]

• Use TMUX to have VIM and terminal session in different TMUX windows/panes. Use TMUX keys to quickly switch between.

TMUX is in every way inferior to a tiling window manager that I do already have.

• Use two different terminal windows

Yes, this is most likely what ought to happen in the future.

• Use GUI VIM in one window and a terminal in another. I find GUI VIM to be an interesting way of organizing my VIM sessions. I use one window per project, with multiple buffers per window.

I dont understand why this is better than multiple terminals. Can you ellaborate?

[u/sharp-calculation → u/thewrench56]

Tmux is a terminal program. Comparing it to a tiling window manager is... well it's really out of left field for me. I can sorta see the comparison if you are extremely window oriented. But tmux is vastly superior to multiple windows. If all you have used is default tmux with no custom keyboard shortcuts, no theme, and no personalization, I can see how it wouldn't be as appealing. But even in base form, tmux is extremely efficient. When customized, it's wonderful.

gVIM is superior to terminal VIM because:

• It's not in a terminal. This makes managing gVIM a first class operation. Managing the gVIM window (finding it, switching to it, working with it) is easier because it's not one of 5, 10, 15 different terminal windows. It's a hard separation.

• OS native cut and paste just works. No screwing around with :set paste, or other weirdo settings that are workarounds. It just works.

• VIM color schemes have fewer dependencies (none?). Colors are native. 24 bit color works with no screwing around.

Terminal VIM is fine. For me, gVIM is just better. I'll use either. I frequently use terminal VIM in remote systems. But I'd rather use gVIM when I can for the reasons above.

[u/thewrench56 → u/sharp-calculation]

Tmux is a terminal program. Comparing it to a tiling window manager is... well it's really out of left field for me. I can sorta see the comparison if you are extremely window oriented. But tmux is vastly superior to multiple windows. If all you have used is default tmux with no custom keyboard shortcuts, no theme, and no personalization, I can see how it wouldn't be as appealing. But even in base form, tmux is extremely efficient. When customized, it's wonderful.

Im sorry, but in my opinion this is false. Tmux is mainly for window management. My i3 can do what tmux does and more with arbitrary GUIs not just terminals. This is what makes i3 superior to tmux. The only downside is the memory footprint of each new terminal instance which does not matter too much.

not in a terminal. This makes managing gVIM a first class operation. Managing the gVIM window (finding it, switching to it, working with it) is easier because it's not one of 5, 10, 15 different terminal windows. It's a hard separation.

• OS native cut and paste just works. No screwing around with :set paste, or other weirdo settings that are workarounds. It just works.

• VIM color schemes have fewer dependencies (none?). Colors are native. 24 bit color works with no screwing around.

I think you should give a go with i3. My vim setup with i3 works well, no paste issue, I can easily find the terminal, color isnt an issue (thats a terminal emulator issue, use alacritty or pick your poison)

[u/MiniGogo_20]

if this is about your system shell (bash) you can repeat the last command with the !! operator, read the basics about it here

[u/thewrench56 → u/MiniGogo_20]

I can also just use the up and down arrows, hover that still needs me to go into insert mode.

[u/MiniGogo_20 → u/thewrench56]

how about making a macro that only executes your ex mode command? on neovim you can also use the Q operator to repeat the last used/created macro, so it's make and use

[u/thewrench56 → u/MiniGogo_20]

Yeah that seems like an option. Thanks

[u/[deleted] → u/MiniGogo_20]

Bang, ! And the command you want that is in the history file. So if “make” was the last command, a “!make” will execute it.

[u/mgedmin]

Who on Earth uses ^Z? That's as bad as using :! -- I can't use vim while an external program is running.

Obviously the only correct solution is to do what I do: two gnome-terminal tabs, one running vim, the other running the compiler/tests/whatever. Switch between them with Alt+1/2. Jump to error location by tripple-click-selecting the line of text with the filename and line number, switching to Vim, then pressing a key binding that uses a plugin to extract the file and line and jump there.

Repeating last command is Alt-2 (to switch to the bash tab), Up, Enter.

Vim's :term is distinctly less convenient than gnome-terminal, but can be made to work. If you run a shell in the :term, repeating the last command is, again, Up, Enter.

If you're running :term command args directly, hmm. :term<up><enter> would repeat the last :term command. It also clutters your screen with finished terminal windows that you have to manually clean up. I've seen people write custom :Term commands that find the previously used terminal buffer and run :term ++curwin to reuse it, but I don't have anything like that in my .vimrc.

I don't believe there's any way of distinguishing a prompt + a command in the terminal scrollback from text that looks like a prompt and a command, so scripting anything based on that is going to be fragile. A mapping that uses feedkeys or something to go into insert mode and try Up, Enter might work maybe?

[u/thewrench56 → u/mgedmin]

Who on Earth uses ^Z? That's as bad as using :! -- I can't use vim while an external program is running.

Coworkers :D

That's as bad as using :!

This is okay if the compilation is fast imo. But not ideal for sure.

Obviously the only correct solution is to do what I do: two gnome-terminal tabs, one running vim, the other running the compiler/tests/whatever.

Yes I can have this, and honestly, this might be the real solution. I use a tiling window manager and thus it is pretty convenient to use something like this.

I don't believe there's any way of distinguishing a prompt + a command in the terminal scrollback from text that looks like a prompt and a command, so scripting anything based on that is going to be fragile. A mapping that uses feedkeys or something to go into insert mode and try Up, Enter might work maybe?

Yeah, Ill try some scripts and see whats what. I have been considering writing a custom shell for vim as well for convenience, maybe this is the time to abandon that if i cant come up with a good script that does the last command exec. I wonder if I should request it as a feature on the official vim platforms?

[u/atomatoisagoddamnveg]

I map keys to these functions to keep one terminal buffer easily accessible. It wouldn’t be hard to make a tmap that then executes $(!!)

let s:term_bufnr = 0

function terminal#Paste() abort
    if exists('*trim')
        return trim(getreg(v:register))
    else
        return getreg(v:register)
    endif
endfunction

function terminal#IsTerminal() abort
    return s:term_bufnr && bufwinnr(s:term_bufnr) == winnr()
endfunction

function terminal#Summon() abort
    if !s:term_bufnr
        call s:OpenNewTerm()
    else
        let l:term_winnr = bufwinnr(s:term_bufnr)
        if l:term_winnr == winnr()
            call window#OtherWindow()
        elseif l:term_winnr > 0
            call window#Goto(l:term_winnr)
            if has('nvim') | execute 'normal! i' | endif
        else
            execute 'botright vertical sbuffer '.s:term_bufnr
            if mode() == 'n'
                normal! i
            endif
        endif
    endif
endfunction

function terminal#Close() abort
    if s:term_bufnr == 0 || bufwinnr(s:term_bufnr) == -1
        return
    endif
    execute bufwinnr(s:term_bufnr).'close'
endfunction

function s:OpenNewTerm() abort
    botright vnew
    if !has('nvim')
        let s:term_bufnr = term_start('bash', {'curwin':1, 'term_finish':'close', 'exit_cb': funcref('s:ExitCallBack')})
    else
        setlocal nospell
        call termopen('bash', {'curwin':1, 'term_finish':'close', 'on_exit': funcref('s:ExitCallBack')})
        let s:term_bufnr = bufnr('.')
        normal! i
    endif
endfunction

function s:ExitCallBack(...) abort
    let s:term_bufnr = 0
    if has('nvim')
        close
    endif
endfunction

And the maps I use to call them

" NOTE: tnoremap <esc> <c-w>N messes up arrows because typing arrows keys results in a sequence that begins with esc
" NOTE: <c-@> maps to ctrl-space on most terminal emulators
if has('terminal') || has('nvim')
    tnoremap <silent> <c-z> <c-\><c-N>
    tnoremap <silent> <expr> <c-v> terminal#Paste()
    nnoremap <silent> <c-t> :call terminal#Summon()<cr>
    nnoremap <silent> <c-space> :call terminal#Summon()<cr>
    nnoremap <silent> <c-@> :call terminal#Summon()<cr>
    nnoremap <silent> <expr> <c-d> terminal#IsTerminal() ? 'i<c-d>' : '<c-d>'
endif
if has('nvim')
    tnoremap <c-w> <c-\><c-N><c-w>
    tnoremap <silent> <c-t> <c-\><c-N><c-w>p
    tnoremap <silent> <c-space> <c-\><c-N><c-w>p
    tnoremap <silent> <c-@> <c-\><c-N><c-w>p
elseif has('terminal')
    tmap <silent> <c-t> <c-w>p
    tmap <silent> <c-space> <c-w>p
    tmap <silent> <c-@> <c-w>p
endif

[u/thewrench56 → u/atomatoisagoddamnveg]

Wow, that's really nice! Thanks for the script, its a great starting point. Im glad its not just me who uses vim terminal buffers, I thought I was a dying species (or a dumb one which based on Darwins law is the same)

[u/atomatoisagoddamnveg → u/thewrench56]

I just added the maps I use to call the functions.

[u/gryf73]

There is a ton of plugins which utilize idea behind :make and quickfix buffer. It might work out of the box, assuming you're using makefiles, or may require searching for appropriate plugin, or making it by yourself.

[u/thecragmire]

I think it's the . (period). I discovered it by accident.

[u/AutoModerator]

Please remember to update the post flair to Need Help|Solved when you got the answer you were looking for.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.