Adding History to fpp (Facebook PathPicker)

I’ve been a fan of `fpp` (Facebook PathPicker) since I first heard about it. I had long been looking for something like this and had even considered writing it myself. Fortunately someone else spared me the work and did a much better job than I would have.

It’s no exaggeration to say that I use this utility every day at $work. In fact I use it many times per hour. It’s part of my normal workflow now. For example, I like to pipe the output of `git status` to `fpp` and then pick and choose some unit tests I’ve edited and then run them. I may need to do this many times over the course of a day. The problem is that `fpp` doesn’t have a proper built in history. Having to go through this process of picking through the output of a `git status` many times per day is a bit of a time sink. It’s still maybe faster than what I would have done before, but it feels like jumping through hoops. I want to be able to replay any command I’ve just run. It should be easy, right?

As it happens, there’s already a file which `fpp` creates after each run. It’s found in `~/.fpp/.fpp.sh` and it’s executable. So, my first attempt at solving this problem was to add a shell alias: `alias redo=‘sh ~/.fpp/.fpp.sh’`. This lets me re-run the _very last_ command which I’ve just run via `fpp`. I now have instant replay.

However, if I’ve used `fpp` for something else in the meantime, the results of that command replace whatever was in `~/.fpp/.fpp.sh`. I can’t magically get back to the penultimate command which I ran, since it’s now lost forever. After playing with this for a few hours, I realized that I really do need to be able to replay my entire history, since I want to be able to pick an arbitrary command and re-run it. Having to remember exactly what I did last before running `redo` was getting to be frustrating.

As part of the process, I found an open Github issue for `fpp` history. After I commented it on it, @pcottle made the following very helpful suggestion, which was to alias `fpp` and wrap it with my own history logic. That seemed like a good idea. So let’s look at what we have to work with.

On my machines, `~/.fpp/.fpp.sh` generally looks something like this, where the _second last_ line in the file contains the line which I want to re-execute. (There’s a blank line which starts the file, but my syntax highlighter seems to be stripping it away here).

vim -O './README.md'
exit;

I figured I could pretty easily grab this line from `~/.fpp/.fpp.sh` and log it to my own history file. I’d then add a little functionality to make it all easier to work with. I had thought about doing this in Perl, but just keeping everything in my `.bashrc` file felt like it was going to be the most portable solution. I didn’t want to have to do anything more complicated than updating and sourcing my dot files in order to get this to work.

The code which I came up with does the following:

• Appends the second last line of `~/.fpp/.fpp.sh` to my own history file every time `fpp` is run
• Adds a `–redo` flag, which execs the last line of the history file, when there are no accompanying arguments
• Adds a `–history` flag which will print the contents of this history file to the screen, with accompanying line numbers
• Execs an arbitrary line from the history file if `–redo` is supplied with a positive integer. (The integers correspond to the line numbers provided by `fpp –history`). So, `fpp –redo 10` execs line 10 from `fpp –history`. It’s a bit like `!10` to get to command 10 after running `history` in your shell.
• Execs an arbitrary line from the history file (moving backwards) if `–redo` is supplied with a negative integer. ie `fpp –redo -1` execs the last line in the file. `fpp –redo -2` execs the second last line etc

I’m not by any stretch an expert in shell scripting, so I did a lot of searching on StackOverflow, copy/pasting and bugging my colleagues at $work. Eventually and quite happily I’ve come up with an incantation which suits my needs.

This is what I added to my ` .bashrc`. Usage is contained inline, in the comments.

function fpp() {
    local fpp=$(type -fp fpp)

    HISTORY_FILE="$HOME/.fpp/.fpp_history"
    FPP_CACHE="$HOME/.fpp/.fpp.sh"

    touch $HISTORY_FILE

    # fpp --history just displays entire history prefixed by line numbers
    # fpp --redo will re-exec the last entry in the history file
    # fpp --redo -1 will also re-exec the last entry in the history file
    # fpp --redo -2 will re-exec the second last line in the history file
    # fpp --redo 11 will re-exec entry number 11 in the history file
    case "$1" in
        --history)
        cat -n $HISTORY_FILE
        return 1
        ;;
        --redo)
        if [ $2 ] ; then
            if [ $2 \> 0 ] ; then
                LAST_HISTORY_LINE=$(head -n $2 $HISTORY_FILE |tail -n 1)
            else
                LINE_NUMBER=$(( $2 * -1))
                LAST_HISTORY_LINE=$(tail -n $LINE_NUMBER $HISTORY_FILE | head -n 1)
            fi
        else
            LAST_HISTORY_LINE=$(tail -n 1 $HISTORY_FILE )
        fi

        eval $LAST_HISTORY_LINE
        return 1
        ;;
    esac

    LAST_HISTORY_LINE=$(tail -n 1 $HISTORY_FILE)
    $fpp "$@"
    LAST_COMMAND=$(tail -n 2 $FPP_CACHE | head -n 1)

    # Don't keep adding the same command to the history file.
    # Also, don't log a message about a no-op.

    if [[ ("$LAST_COMMAND" != 'echo "nothing to do!" && exit 1') && ("$LAST_COMMAND" != "$LAST_HISTORY_LINE") ]] ; then
        echo $LAST_COMMAND >> $HISTORY_FILE
    fi
}

This will get out of date over time, so the canonical version should always be found in my dot-files repo.

If you’d like to see something like this built into `fpp` itself, it wouldn’t hurt to bump the issue I mentioned above. I hope someone finds this helpful.