• vim (see that previous post);
• mutt (idem);
• zsh;
• dircolors;
• git (a bit).

zsh

See this file to setup the colors. Then in my prompt I have stuff like:

PS1=$'${vcs_info_msg_0_}$FG[067]%(1j.$myjobs% $FX[reset].$FX[reset])$FG[179]%#$FX[reset] '
RPS1="$RPSL%$MAXMID<...<$mypath$RPSR$FG[239]$FX[bold]$__ZH$FX[reset]${vcs_info_msg_1_}"
RPSR=$'$FX[reset]$FG[009]%(0?.$FG[reset]. $E)$FX[reset]'

For zsh I have two files that make up my prompt:

• zprompt, primary prompt setup;
• zvcs, version control vcs_info stuff.

Also see this older blog post on this setup. This leads to a prompt looking like this (click for larger):

The normal prompt is very plain. Almost nothing is shown, left the prompt % and on the right the PWD ~:

When logging in to a remote server, the hostname appears on the right:

When a program ends abnormally the exitcode is shown, in words (-INT) and red when it isn't zero:

When you background an app. the number of bg jobs appear in blue. The one with the + is the current job. Multiple jobs are separated with commas:

When you enter a git/svn/hg directory, the right side shows the type (git, svn, hg) and on the left you get the current branch.

dircolors

Modified from Solarized, not quite finished, but certainly looks nice (IMHO). See this dircolors file, I use it like:

eval $(dircolors ./dircolors)

git

The alias section from my .gitconfig:

[alias]
        st = status
        ci = commit
        br = branch
        co = checkout
        df = diff
        lg = log -p
        pl = pull
        ps = push
        timeline = log --graph \"--pretty=format:%C(192)%h%Creset by %C(bold 239)%an%Creset (%ar)%C(182)%d%Creset%n%s%n%b\" --all

The colors are selected with %C(number).

You are aware of (shell)file which contains a interesting line and you think: "I want to execute this line on the command prompt". Most people will do the following:

% more <file>
[select interesting bit with your mouse]
[paste]<enter>

And the code gets executed.

I propose the following function: f(), which does the following:

1. It opens the file in $EDITOR (:= vim of course);
2. You delete everything you don't want to execute;
3. What's left gets executed;
4. And it is added to your shell's history.

The code of the function looks like this:

1 int main(int c) {
2     printf("This is nice");
3     exit(1);
4 }

It should either be possible to use this verbatim in bash or make it work with a few tweaks.

% perl -e 'print "a" x 5, "\n"'
aaaaa

With that you can easily create a separator string consisting out of 60 spaces.

I always missed this in my shell - until now.

In Zsh have the following expansion:

l:expr::string1::string2:

Pad the resulting words on the left. Each word will be truncated if
required and placed in a field expr characters wide.

See zsh.dotsrc.org. There is also a r: variant which operates in the same way.

And lo and behold:

% echo ${(r:40::-:)A}
----------------------------------------

No more:

A="------------------------------------"

% ls -ld Joe_Cocker_-_The_Definitive_Collection 
drwxr-xr-x 2 miekg admin 4.0K Jul 20 22:20 Joe_Cocker_-_The_Definitive_Collection/
% cd *joe*
cd: no such file or directory: *joe*
% unsetop case_glob 
% cd *joe*
% pwd
/shared/vol/music/J/Joe_Cocker_-_The_Definitive_Collection

I always login under my own account (miekg) and if I do change accounts, I probably will be forced to use bash. So showing the current user name is quite useless.

Showing the host you are logged into is also only worth showing when you ssh-ing to a remote host.

So my default prompt now only shows the prompt (%) on the left and the current directory (~) on the right, like this:

Very clean.

When logging into a remote system, the hostname of the system is added (in grey) to the right side of the prompt, like so: (I'm ssh-ing to my other host called elektron, which is electron in Dutch)

The code to do this:

[[ -n "$SSH_CLIENT" ]] && __ZH=$HOST

if $SSH_CLIENT is set, set $__ZH to the current hostname, then use $__ZH in your prompt.

Next I wanted some git support in my prompt, there are lots of sites which can help you. I stole code from all of them :)

There was however one annoying thing. I store my entire home directory in git, but I don't want to see git information about it all the time. So I created the following function to detect if my the current git repository was the one from my home directory:

zsh_git_home() {
# I have my homedir in git, quite annoying to see 'master' all the time
git_dir=$(git rev-parse --git-dir 2> /dev/null)
[[ -z "$git_dir" ]] && return 0
[[ $(realpath "$git_dir") == $HOME/.git ]] && return 0
return 1
}

If I enter a git repository the current branch is put into the prompt at the left side, here I enter a repository with the master branch. (Note: as the window is very small my path is truncated)

Code is from Bart.

One other thing I added is that if the working directory is not clean (i.e. you have made some changes) an exclamation mark is added. Like so:

The code for this can be found on the sites listed above.

Of course my other prompt features still work. Here is a shot with one background job. Notice that ^Z suspends this program and leaves an exit code of 20, which is shown in red:

I'm still figuring out ways to get even more colors in the prompt :)

From the bash manpage:

[[ expression ]]
          Return a status of 0 or 1 depending on  the  evaluation  of  the
          conditional  expression expression.  Expressions are composed of
          the primaries described  below  under  CONDITIONAL  EXPRESSIONS.

          Word  splitting  and pathname expansion are not performed on the

          words between the [[ and  ]];  tilde  expansion,  parameter  and
          variable  expansion, arithmetic expansion, command substitution,
          process substitution, and quote removal are  performed.   Condi‐
          tional operators such as -f must be unquoted to be recognized as
          primaries.

So no word splitting and pathname expansion.

A little example

First we have some setting up to do

$ mkdir ~/tmp/zz
$ touch ~/tmp/zz/111
$ echo ~/tmp/zz/*
/home/miekg/tmp/zz

Well, lets test [[

$ if [[  tmp/zz/* = tmp/zz/111 ]]; then echo OK; else echo NOK; fi
NOK

NOK - that's correct, because [[ will not do pathname expansion.

The other way around

$ if [[  tmp/zz/111 = tmp/zz/* ]]; then echo OK; else echo NOK; fi
OK

Huh, OK?

Why

To see why bash behaves as it does, the best explanation comes from the ksh manual. Yes, the K shell. In the section 'Conditional Expressions' of ksh's manual page

string = pattern        True, if string matches pattern.

Aha, so the right side of a = test is a pattern and a such it is expanded even though we put it in a [[ construct.

In the bash manual we just have

string1 == string2
True if the strings are equal.  = may be used
in place of == for strict POSIX compliance.

Which is not entirely correct.

In zsh (which is of course the shell) in the section 'CONDITIONAL EXPRESSIONS' it is also correct

string = pattern
string == pattern
    true if string matches pattern.  The ‘==’ form is the  preferred
    one.   The  ‘=’ form is for backward compatibility and should be
    considered obsolete.

So this might be something worth considering.

That's why I've made zsh display this in the prompt. You get a m@ when a connection is a master connection and an @ if it is a slave.

setting up

The check if we are a master works by creating a file which has $SSH_CLIENT as the name, as the following snippet shows.

# ssh stuff
# check if we are the master or a slave connection
# this must be sourced before .zprompt is

# print @-sign before the hostname if we got into this host via SSH
if [ -z $SSH_TTY ]; then
ZSSH=
else
if [[ ! -e ~/.ssh/${SSH_CLIENT// /_} ]]; then
    # file does not exist, we are a master
    touch ~/.ssh/${SSH_CLIENT// /_}
    ZSSH="m@"
else
    # slave connection
    ZSSH="@"
fi
fi

tearing down

Make zsh remove the file when it exits.

TRAPEXIT() {
echo $PWD > ~/.zpwd
# $ZSSH has @ for slaves and M@ for masters
[[ $ZSSH == "m@" ]] && rm ~/.ssh/${SSH_CLIENT// /_}
}

You can now use $ZSSH in your prompt.

code

#!/bin/zsh
# a wrapper around git and vi
# expands $Hash$ to $Hash: file short_hash epoch committer $
# git checkout HEAD $file? when would I need this
# TODO: spaces in filename

[[ ! -x =git ]] && exit 1

who=$SUDO_USER
who=${who:-$LOGNAME}

function search_git_dir {
    gpath="$1"

    [[ -d "$gpath/.git" ]] && echo "$gpath" && return
    [[ -z "$gpath" ]] && echo "" && return

    # strip that last path component and try again
    search_git_dir "${gpath%/*}"
}

for file in "$@"; do
dir=$(dirname $file); cd $dir
base=$(basename $file)

if [[ -z $(search_git_dir $PWD) ]]; then
    # make a new one in $PWD
    git init || exit 1
else
    #echo FOUND ONE
fi
chmod +w $base 2> /dev/null

if vi $base; then
    [[ ! -e $base ]] && exit 0
    git add $base
    # collapse $Hash: id $ line
    sed -i -e 's/\$Hash:.*\$/$Hash$/' $base
    git commit $base
fi

id=$(git-show -s --pretty=format:$base\ %h\ %ct\ $who%n -- $base) 
[[ -z $id ]] && exit 1

# re-add $Hash: sha1hash$ line
sed -i -e 's/\$Hash\$'/\$Hash:\ $id\ \$/ $base

chmod a-w $base 2> /dev/null
done

manpage

And ofcourse the manpage.

'\" t
.TH GITVI 1 "27 Dec 2008" "0.1.0" "gitvi"

.SH NAME
gitvi \- a wrapper around git and vi(m)

.SH SYNOPSIS
gitvi [\fIFILE\fR]

.SH DESCRIPTION
Edit files and commit them to a git repository. If FILE is not
given nothing is done.

All the directories from the current one up to the root are
search for a previous .git directory. If no directory is found
a new git repository is created in the current directory. A
new repository will never be created in the root directory.
.PP
The special sequence $Hash$ is expanded by \fBgit-vi\fR to 

.RS
$Hash: sha1hash filename epoch committer $
.RE
.PP
This expanded $Hash$ syntax is \fInot\fR commited to git, this
is done after the commit has taken place.

.SH OPTIONS
There are no options as of yet.

.SH AUTHOR
Miek Gieben <miek@miek.nl>

.SH SEE ALSO
vim(1), git(1).

It is a wrapper around git, which will create a new git repository, add the file and commit it when changed.

The script will also expand $Hash$ to

$Hash: basename-of-file short-commit-hash epoch committer`

a typical example is

$Hash: motd.tail 2ebb8e9 1230404370 miekg $

This is somewhat the same as the $Id$ tag from svn/CVS, but with a different tag. I always found this tagging from subversion useful, esp. when you -- as a human -- needs to tell if a file is under version control.

To avoid accidental edits the file is set to read-only.

I think I'm gonna dump cfengine and just use this script, cfengine is great, but somewhat of a overkill for my home setup.

Sourcecode of the script

The script uses zsh, but can be easily converted to bash or any other shell.

#!/bin/zsh
# a wrapper around git and vi
# expands $Hash$ to $Hash: file short_hash epoch committer $
# git checkout HEAD $file? when would I need this

[[ ! -x =git ]] && exit 1

who=$SUDO_USER
who=${who:-$LOGNAME}

for file in "$@"; do

dir=$(dirname $file); cd $dir

chmod +w $file 2> /dev/null

if [[ ! -d .git ]]; then
    git init || exit 1
fi

if vi $file; then
    [[ ! -e $file ]] && exit 0
    git add $file
    # collapse $Hash: id $ line
    sed -i -e 's/\$Hash:.*\$/$Hash$/' $file
    git commit $file
fi

id=$(git-show -s --pretty=format:$(basename $file)\ %h\ %ct\ $who%n -- $file) 
[[ -z $id ]] && exit 1

# re-add $Hash: sha1hash$ line
sed -i -e 's/\$Hash\$'/\$Hash:\ $id\ \$/ $file

chmod a-w $file 2> /dev/null
done

update

I just thought of something, what if there already is a git repository in a higher directory....Hmmm. This means the script should look for a git repository higher up and work from there....

This is also something that is done much better in zsh.

Why do want this? SPEED!

Shell scripting is a very easy way to program, but forking all these helper programs takes a lot of time. So one way to speed up your shell program is to load these programs into the shell and making them a builtin.

bash

I needed the bash source for this to work. So download it and compile it. Then in the examples/loadables you have some new builtins, like cat, cut, head and then some.

Making cat a builtin, you need the enable command

$ type cat
cat is /bin/cat

$ enable -f /tmp/bash-3.2/examples/loadables/cat cat
$ cat type
cat is a shell builtin

Same goes for other executables. When updating my site with nanoblogger, using cat and others as builtins made the update much quicker. I shaved off some 20 seconds on a total of 250 seconds; so it may be worth the effort.

zsh

Here everything worked out of the box, but there is currently no cat builtin for zsh (I created one). But there are other interesting builtins.

What you need: man zshmodules and zmodload. With zmodload you can create new builtins.

For example, I made a cat builtin. Next I copy the cat.so to /usr/lib/zsh/4.3.4/zsh

% type cat
cat is /bin/cat

% zmodload zsh/cat
% type cat
cat is a shell builtin

Unload with zmodload -u. Works like a charm.