Bash – Automatically open text files in editor instead of attempting to run them

bashshellzsh

When I accidentally type the name of a text file without some kind of editor command, and the text file is not a shell script, I get a "permission denied" error*, since the file is not executable, and the first token in the command line is taken to be the command to execute.

However, invariably this just means that I've inadvertently forgotten to type my editor command, so it would be convenient if the shell could somehow recognize that the first token is an extant text file without the "execute" bit set and automatically open it with either $EDITOR or $VISUAL.

Is there a way to accomplish this in Bash or Zsh? (I use Bash but am thinking of switching anyway.) It would be a little like Bash's autocd option, which automatically detects whether the first token is a directory and attempts to cd into it rather than giving the standard "Is a directory" error.

Ideally, if I give a list of files (e.g. with a glob) or any other set of arguments, all of these arguments would be passed to the editor command.

* Of course I can also get a "command not found" error if I'm specifying a file in the current directory without ./.

Best Answer

In zsh, as long as your text files have a file name extension (file.ext), you can work with suffix aliases. They are defined by alias -s name=value and are run as value text.name anytime the first word on the command line matches text.name where text is any non-empty string.

For example:

If you define

alias -s txt=vim

then typing

$ foo.txt

on the command line will run

vim foo.txt

This works for anything matching ?*.txt, even words with wildcards:

$ *.txt

will run

vim *.txt

It also checks only on the first word of the command, but will pass the whole command line as argument, even if there are suffix aliases for the other words:

$ foo.txt bar.c baz.vim

will run

vim foo.txt bar.c baz.vim

Important: This also affects any command with a matching extension, including those in PATH. Should you, for example, set

alias -s sh=vim

and you have a command named something.sh and you want to run

something.sh -p1 -p2 arg1 arg2

it would instead run

vim something.sh -p1 -p2 arg1 arg2

To disable this feature for one command, just prepend the command builtin:

command something.sh -p1 -p2 arg1 arg2

The obvious drawbacks are:

it works only on files with a file name extension
you have to define the alias explicitly for every extension

On the plus side:

it works only on files with a file name extension, so most executables in /bin and /usr/bin are save from being replaced by an alias.
you can define a (different) alias for any extension, so *.jpg or *.o files will not suddenly be opened with vim

Related Solutions

Bash – Combine two commands in .bash_profile

aliases do not support input parameters, and there's no need to wrap functions in aliases. Simply use a function:

pd() {
    pushd "$@"
    set_title_tab
}

pd ~/Documents

Bash – edit-and-execute-command interrupted by SIGTSTP

If I had accidentally hit Ctrl-Z and still wanted to execute the script in the temporary file still open by the editor, what would be the best way of doing that?

You could try using and editor wrapper which would save the last command somewhere, and a readline binding which could bring it back. Example which saves the last buffer to ~/.last_fcedit and binds Esc-/ (Alt-/) to replace the command line with it:

LAST_FCEDIT=$HOME/.last_fcedit
fc(){ case $1 in -e) _fce=$2; set -- "$@" -e _fcedit; esac; command fc "$@"; }
_fcedit()("$_fce" "$@"; s=$?; test -f "$1" && mv "$1" "$LAST_FCEDIT"; exit "$s")
bind -x '"\e/":READLINE_LINE=$(<"$LAST_FCEDIT")'

Then

$ echo FOO<Ctrl-X Ctrl-E>
... in editor ...
<Ctrl-Z>
[1]+  Stopped                 ( "$_fce" "$@"; s=$?; mv "$1" "$LAST_FCEDIT"; exit "$s" )
$ fg<Enter>
... edit FOO to BAR and exit the editor ...
( "$_fce" "$@"; s=$?; mv "$1" "$LAST_FCEDIT"; exit "$s" )
$ <Alt-/>echo BAR<Enter>
BAR

Why does this happen?

I'm not able to find a convincing rationale for it, but it's the same with plain fc (and related keybindings) on all the shell implementations I could check.

My idea is that it has do with the shell not being able to recursively background or foreground itself, but only its child jobs (process groups). The same thing you could notice with:

$ foo(){ cat; echo DONE; }
$ foo
^Z
[1]+  Stopped                 cat
DONE  # but cat is still running!
$ fg
cat
^D
$

$ foo=$(cat)
^Z^Z^Z^Z^Z^Z # no way to suspend it!

Unlike in bash, the first example will actually "work" in ksh93 or zsh; but the second will be unkillable in ksh93 or zsh ;-)

Best Answer

Related Solutions

Bash – Combine two commands in .bash_profile

Bash – edit-and-execute-command interrupted by SIGTSTP

Related Question