setup

#!/usr/bin/env python3

import os
import pathlib
import tempfile
import sys

import waflibs


script_dir = waflibs.filedir.get_parent_directory(pathlib.Path(__file__))
dotfiles_dir = pathlib.Path(script_dir, "dotfiles")

wf_parser = waflibs.arg_parse.parser()
wf_parser.enable_verbose_logging()
wf_parser.enable_dry_run()
parser = wf_parser.get_parser()
parser.add_argument(
    "-f",
    "--force",
    action="store_true",
    help="do not force commands",
)
parser.add_argument(
    "-t",
    "-e",
    "--test",
    "--dev",
    action="store_true",
    help="dev/test mode",
)
parser.add_argument(
    "-c",
    "--config",
    "--config-file",
    type=str,
    help="config file",
    default=f"{script_dir}/config.yaml",
)
parser.add_argument(
    "-i",
    "--home-dir",
    "--home-directory",
    "--directory",
    help="destination directory to use",
    default=pathlib.Path(os.environ["HOME"]).absolute(),
)
parser.add_argument(
    "-o",
    "--dotfiles-dir",
    help="dotfiles dir",
    default=dotfiles_dir,
)
parser.add_argument(
    "-u",
    "--no-custom",
    action="store_true",
    help="do not run custom setup",
)
parser.add_argument(
    "-s",
    "--only-custom",
    action="store_true",
    help="only run custom setup",
)
parser.add_argument(
        "-b",
        "--stdout",
    action="store_true",
    help="print stderr to stdout for easier paging",
        )
args = parser.parse_args()

force = args.force
home_dir = args.home_dir
test = args.test
dry_run = args.dry_run
dotfiles_dir = args.dotfiles_dir
no_custom = args.no_custom
only_custom = args.only_custom
config_file = args.config

if test:
    dotfiles_dir = pathlib.Path(script_dir, "test")
    real_config_file = pathlib.Path(script_dir, "config.yaml")

    temp_dir = tempfile.mkdtemp()
    home_dir = pathlib.Path(temp_dir).absolute()

    args.verbose = True
else:
    real_config_file = config_file

logger = waflibs.log.logger(args).get_logger()
verbose = args.verbose

logger.debug(f"config file from arg: {config_file}")
logger.debug(f"real config file: {real_config_file}")
config = waflibs.config.parse_yaml_file(real_config_file)
logger.debug(f"config: {config}")
if test:
    for d, sub_dir in config["append"].items():
        real_dir = f"{home_dir}/.{d}"
        logger.debug(f"creating test dir {real_dir}")

        os.mkdir(real_dir)
        if sub_dir:
            for sd in sub_dir:
                real_sub_dir = f"{real_dir}/{sd}"
                logger.debug(f"creating test sub dir {real_sub_dir}")

                os.mkdir(real_sub_dir)


logger.debug(f"using home dir: {home_dir}")
logger.debug(f"dotfiles dir: {dotfiles_dir}")

logger.debug("args: {}".format(args))

def eprint(*print_args, **kwargs):
    if args.stdout:
        logger.debug("stdout arg set to true")

        kwargs["stdout"] = True

    waflibs.text.eprint(*print_args, **kwargs)

if only_custom:
    logger.debug(f"only custom is {only_custom}... ONLY running custom script")
else:
    os.chdir(dotfiles_dir)

    eprint(
        "updating repo... ",
        newline=False,
    )
    cmd = "git pull"
    logger.debug("command to run: {}".format(cmd))
    pull_stdout, pull_stderr, _ = waflibs.shell.command(
        cmd.split(" "),
        cwd=dotfiles_dir,
    )
    eprint("done.")
    logger.debug("pull stdout: {}".format(pull_stdout))
    logger.debug("pull stderr: {}".format(pull_stderr))

    eprint(
        "running submodule init... ",
        newline=False,
    )
    cmd = "git submodule init"
    logger.debug("command to run: {}".format(cmd))
    init_stdout, init_stderr, _ = waflibs.shell.command(
        cmd.split(" "),
        cwd=dotfiles_dir,
    )
    logger.debug("init stdout: {}".format(init_stdout))
    logger.debug("init stderr: {}".format(init_stderr))
    eprint("done.")

    eprint(
        "running submodule sync... ",
        newline=False,
    )
    cmd = "git submodule sync"
    logger.debug("command to run: {}".format(cmd))
    sync_stdout, sync_stderr, _ = waflibs.shell.command(
        cmd.split(" "),
        cwd=dotfiles_dir,
    )
    logger.debug("sync stdout: {}".format(sync_stdout))
    logger.debug("sync stderr: {}".format(sync_stderr))
    eprint("done.")

    eprint(
        "running submodule update... ",
        newline=False,
    )
    cmd = "git submodule update"
    logger.debug("command to run: {}".format(cmd))
    update_stdout, update_stderr, _ = waflibs.shell.command(
        cmd.split(" "),
        cwd=dotfiles_dir,
    )
    eprint("done.")
    logger.debug("update stdout: {}".format(update_stdout))
    logger.debug("update stderr: {}".format(update_stderr))

    eprint(
        "setting up dotfiles... ",
        newline=False,
    )
    root_entries = [re for re in dotfiles_dir.glob("*")]
    root_entries.sort()
    for root_entry in root_entries:
        root_entry_name = root_entry.name
        logger.debug(f"root entry name is {root_entry_name}")
        logger.debug(f"root entry is {root_entry}")

        if root_entry_name.endswith(("swp",)):
            logger.debug(f"ignoring entry... ends with - {root_entry}")

            continue

        root_dest_dir = waflibs.filedir.get_parent_directory(
            waflibs.filedir.get_dest_location(
                root_entry,
                target_dir=home_dir,
            )
        )
        if not root_dest_dir.is_dir():
            logger.debug(
                f"{root_dest_dir} directory does not exist, creating..."
            )

            root_dest_dir.mkdir()

        logger.debug(f"root entry is dir: {root_entry}")

        append_dirs = config["append"]
        logger.debug(f"append dirs: {append_dirs}")
        if root_entry_name in append_dirs:
            logger.debug(f"will append to root directory {root_entry}")

            entries = [e for e in root_entry.glob("*")]
            entries.sort()
            logger.debug(f"entries: {entries}")
            for entry in entries:
                logger.debug(f"append entry is {entry}")

                dest = waflibs.filedir.get_dest_location(
                    entry,
                    target_dir=home_dir,
                )
                logger.debug(f"append dest is {dest}")

                append_dirs_entry = append_dirs[root_entry_name]
                logger.debug(f"append dirs entry: {append_dirs_entry}")
                if isinstance(append_dirs_entry, list):
                    waflibs.filedir.backup(dest, dry_run=dry_run)

                    print(entry.name)
                else:
                    waflibs.filedir.backup_and_remove(dest, dry_run=dry_run)

                    logger.debug(
                        f"appending root entry {entry} to dest {dest}"
                    )
                    waflibs.filedir.copy(entry, dest, dry_run=dry_run)

                logger.debug(waflibs.text.divider(char="*", times=66))
        else:
            logger.debug(f"not appending {root_entry} to root dir")

            dest = waflibs.filedir.get_dest_location(
                root_entry,
                target_dir=home_dir,
            )
            logger.debug("dest is {}".format(dest))

            waflibs.filedir.backup_and_remove(dest, dry_run=dry_run)

            d_p_dir = dest.parent
            logger.debug(f"dest parent dir: {d_p_dir}")
            if not pathlib.Path(d_p_dir).exists():
                logger.debug(
                    f"dest parent dir {d_p_dir} does not exist... creating dir"
                )

                pathlib.Path(d_p_dir).mkdir()
            logger.debug(f"copying root entry {root_entry} to dest {dest}")
            waflibs.filedir.copy(root_entry, dest, dry_run=dry_run)

            logger.debug(waflibs.text.divider(char="*", times=66))
    else:
        dest = waflibs.filedir.get_dest_location(
            root_entry,
            target_dir=home_dir,
        )
        logger.debug("dest is {}".format(dest))

        waflibs.filedir.backup_and_remove(dest, dry_run=dry_run)

        logger.debug(f"copying root entry {root_entry} to dest {dest}")
        waflibs.filedir.copy(root_entry, dest, dry_run=dry_run)
    logger.debug(waflibs.text.divider(char="-", times=66))
    eprint("done.")

if not no_custom or only_custom:
    logger.debug(f"will run custom setup script")

    for custom_setup_script in config["custom_setup_scripts"]:
        custom_setup_script = pathlib.Path(os.path.expandvars(custom_setup_script))
        logger.debug(f"custom setup script path: {custom_setup_script}")
        if custom_setup_script.is_file():
            eprint(waflibs.text.divider(char="*", times=77))

            eprint(
                f"running custom setup script {custom_setup_script}"
            )

            cmd = [
                str(custom_setup_script),
            ]
            if verbose:
                cmd.append("-vvvvvv")
            if force:
                cmd.append("-ffffff")
            logger.debug(f"command to run: `{cmd}`")
            custom_stdout, custom_stderr, _ = waflibs.shell.command(
                cmd,
            )
            logger.debug("custom stdout: {}".format(custom_stdout))
            logger.debug("custom stderr: {}".format(custom_stderr))
else:
    logger.debug(
        f"no custom run is {no_custom} or only custom is {only_custom}... not running custom setup script"
    )

if test:
    print(home_dir)