Managing Dotfiles with GNU Stow

Dotfiles are textual suppose files which might maybe well well be accepted to configure applications you speed on the
repeat line (in a terminal). They’d describe your editor what colours to exercise,
or what ambiance variables must smooth be outlined for your shell.

It is going to be very helpful so that you simply can simply deploy them all the device by a whole lot of machines,
so that the applications you make exercise of behave persistently.

Managing your dotfiles, the sequence of these configuration files, is then a
ravishing ingredient to create.
GitHub even has a net sites dedicated to a quantity of techniques of organising and
deploying them.
I unbiased recently adopted what I feel is good technique of doing it, and doesn’t appear to be
that traditional, so I believed I’d fragment what I’m doing, why, and the technique you might maybe most doubtless also
organise your dotfiles in the equivalent technique.

The dotfiles repository ?

Let’s converse you might maybe most doubtless in actual fact maintain a machine that you simply exercise most of your time on, nonetheless
infrequently you login in to just a few server someplace.
For your local machine, you’ve bought a series dotfiles sitting for your private dwelling
directory, esteem ~/.bashrc, nonetheless they’re no longer on the server. What can you create?

A in reality traditional technique is to originate a git repository, converse in a folder known as
~/.dotfiles, after which to originate symbolic links (or ‘symlinks’) from the
files in the repository to your dwelling directory.
Having the folder be a git repository makes it very straight forward to synchronise the
files between machines.

Let’s originate the git repository and add a dummy dotfile.

$ mkdir ~/.dotfiles

$ cd ~/.dotfiles

$ git init .

$ echo "Here's a dotfile." > mydotfile

$ git add mydotfile

$ git commit -m "Compose dotfiles repository"

Now now we maintain a repository and a dotfile within it, we unbiased maintain to originate the
symbolic link.

$ cd ~

$ ln -s .dotfiles/mydotfile .mydotfile

$ ls -la | grep mydotfile

lrwxr-xr-x    1 apearce  workers      19 12 Feb 17: 05 .mydotfile -> .dotfiles/mydotfile

The final observe repeat presentations that now we maintain a symbolic link known as .mydotfile
pointing to the file in the dotfiles repository. We are in a position to be aware and edit the
link as if it had been the staunch file, nonetheless if we delete the link the staunch file
stays as it was as soon as.

Here’s essence of a dotfiles repository. But, as you might maybe most doubtless also imagine, manually
linking dotfiles quickly turns into laborious and error-prone. One solution is to
originate a script that links the files for you, nonetheless I feel there’s a better technique.

GNU stow ?

GNU stow, or simply stow, is a symbolic link manager. To cite their
homepage:

GNU Stow is a symlink farm manager which takes certain packages of instrument
and/or records located in separate directories on the filesystem, and makes them
appear to be installed in the equivalent space.

I didn’t perceive what this supposed when I first read it. I feel it’s fully
explained with an example.

Let’s converse we’re inner our ~/.dotfiles folder, nonetheless now we’ve added some files
and restructured it unbiased a little.
We are in a position to exercise the tree repeat to recursively existing the contents of the
directory as tree-esteem development in disagreeable textual suppose. (It’s no longer installed on OS X by
default, nonetheless you simply install it with Homebrew with brew install tree.) The -a flag tells tree to level hidden files.

$ tree -a ~/.dotfiles

.

??? bash

?   ??? .bashrc

?   ??? .profile

??? vim

    ??? .vimrc

Now we’ve bought some staunch dotfiles: a pair for the Bash shell, and one for
vim, the editor.

We might maybe well most doubtless symlink these to our dwelling directory in the equivalent technique as sooner than, or we
might maybe well most doubtless let stow create it for us!

$ cd ~/.dotfiles

$ stow vim

Now let’s take a behold at what’s in our dwelling directory.

$ ls -la ~ | grep vimrc

lrwxr-xr-x    1 apearce  workers      20  7 Jan 12: 35 .vimrc -> .dotfiles/vim/.vimrc

Stow has created the symlink for us! Magic. So what’s in actuality occurring?

1. We ran the repeat stow , where was as soon as the name of a folder
   whose whole contents we wished symbolic links for in our dwelling directory.
2. Stow looked in the folder , the vim/ folder on this case, and stumbled on
   one file: .vimrc
3. Stow created a symbolic link to vim/.vimrc one folder above where the
   stow repeat was as soon as speed.

The final observe step is the cold bit. Stow assumes that the contents of the

$ mkdir /usr/local/stow

$ cd /usr/local/stow

$ mkdir -p foo1.3/bin

$ mkdir -p foo2.0/bin

$ mv /usr/local/bin/foo1.3 foo1.3/bin/foo

$ mv /usr/local/bin/foo2.0 foo2.0/bin/foo

$ cd /usr/local/stow

$ stow foo1.3

$ ls -la /usr/local/bin | grep foo

lrwxr-xr-x    1 apearce  workers      20  7 Jan 12: 35 foo -> ../stow/foo1.3/bin/foo

$ tree -a ~/.dotfiles

.

??? bash

?   ??? .bashrc

?   ??? .profile

??? foo

?   ??? .config

?       ??? foo

?           ??? somefile

??? vim

    ??? .vimrc