Source code for sqltrack.commands

"""
The SQLTrack command line utility.
It makes setting up databases for use with SQLTrack a bit easier.
"""
from __future__ import annotations

import argparse
import re

from .. import Client
from ..config import load_config
from .execute import execute
from .setup import setup, __doc__ as setup_doc
from .create import create, __doc__ as create_doc


def _prepare_docstring(s, _p_single_newline=re.compile(r"(?<!\n)\n(?!\n)")):
    return _p_single_newline.sub(" ", s.strip(' \n'))


def _update_config(config, args):
    config = dict(config)
    kwargs = dict(
        user=args.user,
        host=args.host,
        port=args.port,
        dbname=args.dbname,
    )
    for k, v in kwargs.items():
        if v is not None:
            config[k] = v
    return config


def _fill_config(config, kwargs):
    config = dict(config)
    for k, v in kwargs.items():
        if v is not None and (k not in config or config[k] is None):
            config[k] = v
    return config


def _add_arguments(parser):
    parser.add_argument(
        "-c", "--config-path",
        help="path to config file",
    )
    parser.add_argument(
        "-u", "--user",
        help="username",
    )
    parser.add_argument(
        "-n", "--host",
        help="Name of PostgreSQL host",
    )
    parser.add_argument(
        "-p", "--port",
        help="PostgreSQL port",
    )
    parser.add_argument(
        "-d", "--dbname",
        help="database name",
    )


def main():
    parser = argparse.ArgumentParser(
        prog="sqltrack",
        description=__doc__,
    )

    subparsers = parser.add_subparsers(
        dest="command",
        description="Available commands.",
        required=True,
    )

    # create command
    parser_create = subparsers.add_parser(
        "create",
        help="Print commands for user and database creation.",
        description=_prepare_docstring(create_doc),
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    _add_arguments(parser_create)
    parser_create.add_argument(
        "--password",
        help="Add user password (see note on passwords)",
        action='store_true',
    )
    parser_create.add_argument(
        "--plain-password",
        help="Allow printing passwords in plain text",
        action='store_true',
    )
    parser_create.add_argument(
        "--no-user",
        help="Do not print user creation command",
        action='store_true',
    )
    parser_create.add_argument(
        "--no-db",
        help="Do not print database creation command",
        action='store_true',
    )

    # execute
    parser_execute = subparsers.add_parser(
        "execute",
        help="Print commands for user and database creation.",
        description=_prepare_docstring(create_doc),
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    _add_arguments(parser_execute)
    parser_execute.add_argument(
        "queries",
        metavar="SQL",
        help="SQL query/queries to execute.",
        nargs="*",
    )

    # setup command
    parser_setup = subparsers.add_parser(
        "setup",
        help="Setup (and update) databases for use with SQLTrack.",
        conflict_handler='resolve',
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    _add_arguments(parser_setup)
    parser_setup.add_argument(
        "path",
        nargs="*",
        metavar="PATH",
        help="Optional SQL scripts, executed in the given order.",
    )
    parser_setup.add_argument(
        "-s", "--schema",
        help="schema name",
    )

    # run stuff
    args = parser.parse_args()
    config = load_config(args.config_path)
    try:
        if args.command == "create":
            kwargs = _fill_config(vars(args), config)
            create(config, **kwargs)
        elif args.command == "execute":
            client = Client(config)
            execute(client, *args.queries, **vars(args))
        elif args.command == "setup":
            config = _update_config(config, args)
            client = Client(config)
            setup(client, args.path)
    except KeyboardInterrupt:
        pass


if __name__ == "__main__":
    main()