init

#!/usr/bin/env python3
# vim: set fileencoding=utf-8 filetype=python :
"""Link configs for tools defined here to $HOME.

Why this script?
================
The obvious alternative would be a directory like this::

    configs/.bashrc
    configs/.vimrc
    configs/.vim/

- A simple ls does not work.
- File managers need to display hidden files.
- Need to type dot when navigating on the commandline.

Nested Files
============
Normally tool directories contain an rc file and a directory, e.g.

bash/bash --> ~/.bash
bash/bashrc --> ~/.bashrc

But xfce4 configs are deeply nested in XDG_CONFIG_HOME (`~/.config`), e.g.

_nested/config/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml
--> ~/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml

This is a special case, because I only want files very selectively.
"""
import logging
import os
from os import listdir, chdir
from os.path import abspath, dirname, isdir, join
import shutil
import subprocess
from optparse import OptionParser

IGNORED_DIRS = ['.git', '_nested', '_tests']

# everything happens relative to this file's parent dir
here = abspath(dirname(__file__))
chdir(here)
checkout_dirname = os.path.basename(here)

OVERRIDE_PREVIOUS = False
HOME = os.environ['HOME']
BACKUP_DIR = join(HOME, 'bak', checkout_dirname)

log = logging.getLogger('init')
loglevel = os.environ.get('LOGLEVEL', 'WARNING').upper()
logging.basicConfig(level=loglevel, format='%(levelname)-7s %(message)s')


def run(cmd):
    "Run command as if in shell. Blocking."
    p = subprocess.Popen(cmd, shell=True)
    p.wait()


def makelink(src, dest):
    "Think ln -s"
    log.debug('link %s %s', src, dest)
    if OVERRIDE_PREVIOUS:
        if os.path.islink(dest):
            log.debug('Removing link '+dest)
            os.unlink(dest)
        elif os.path.isdir(dest) or os.path.isfile(dest):
            log.warning("mv %s %s", dest, BACKUP_DIR)
            shutil.move(dest, BACKUP_DIR)
    src = join(os.getcwd(), src)
    try:
        os.symlink(src, dest)
        log.debug('Linked %s to %s' % (src, dest))
    except OSError as e:
        if e.strerror != 'File exists':
            raise
        else:
            log.info('%s: %s' % (e.strerror, dest))


def handle_tool(tooldir):
    """
    Given:

        vim/vimrc
        vim/vim/file1

    It runs:

        ln -s vim/vimrc $HOME/.vimrc
        ln -s vim/vim $HOME/.vim
    """
    log.info('Initializing ' + tooldir)
    files = listdir(tooldir)
    for fname in files:
        src = join(tooldir, fname)
        dest = join(HOME, '.'+fname)
        makelink(src, dest)


def get_tool_dirs():
    result = filter(isdir, listdir(here))
    return set(result) - set(IGNORED_DIRS)


def gen_git_config(email=None, name=None):
    path = join(HOME, '.gitconfig.d', 'user')

    if email is None:
        email = input("git email: ")
    if name is None:
        name = input("git name: ")

    cfg = """\
[user]
  email = {email}
  name = {name}
""".format(**locals())

    if not os.path.exists(path):
        with open(path, 'w') as f:
            f.write(cfg)
        log.info("Wrote {0}".format(path))


def _iter_nested():
    for root, dirs, files in os.walk('_nested'):
        for f in files:
            walkparts = [root] + [f]
            src = os.path.join(*walkparts)
            log.debug('src: %s', src)
            parts = src.split('/')
            log.debug('parts: %s', parts)
            tmp = os.path.join(*parts[1:])
            log.debug('tmp: %s', tmp)
            dest = os.path.join(HOME, '.' + tmp)
            # _nested/foo/bar --> .foo/bar (note the dot)
            log.info('{0} --> {1}'.format(src, dest))
            yield src, dest


def handle_nested():
    log.info('handling nested files')
    # compute up-front
    xs = list(_iter_nested())
    for src, dest in xs:
        # create directory if it does not exist
        mkdir_p(os.path.dirname(dest))
        makelink(src, dest)


def mkdir_p(dirname):
    log.debug('mkdir_p(%s)', dirname)
    if not isdir(dirname):
        os.makedirs(dirname)


def main():
    run('git submodule update --init')
    for tool in get_tool_dirs():
        handle_tool(tool)
    handle_nested()


if __name__ == '__main__':
    parser = OptionParser()
    parser.add_option("-f", "--force",
                      action="store_true", dest="force", default=False,
                      help="force overriding old options. Removes links and\
                            moves dirs/files to $HOME/bak")
    parser.add_option("-e", "--email",
                      action="store", dest="email",
                      help="email for git")
    parser.add_option("-n", "--name",
                      action="store", dest="name",
                      help='name for git, e.g. "Felix Hummel"')
    parser.add_option("-v", "--verbose",
                      action="store_true", dest="verbose", default=False,
                      help="info logging")
    parser.add_option("-d", "--debug",
                      action="store_true", dest="debug", default=False,
                      help="debug logging")

    (options, args) = parser.parse_args()
    if options.debug:
        log.setLevel(logging.DEBUG)
    elif options.verbose:
        log.setLevel(logging.INFO)
    OVERRIDE_PREVIOUS = options.force
    # if we may need backups, create BACKUP_DIR
    if OVERRIDE_PREVIOUS:
        mkdir_p(BACKUP_DIR)
    main()
    if options.email or options.name:
        gen_git_config(options.email, options.name)