Elep

"""
CLI parsing for :command:`pysemver` command.

Each command in :command:`pysemver` is mapped to a ``cmd_`` function.
The :func:`main <semver.cli.main>` function calls
:func:`createparser <semver.cli.createparser>` and
:func:`process <semver.cli.process>` to parse and process
all the commandline options.

The result of each command is printed on stdout.
"""

import argparse
import sys
from typing import cast, List, Optional

from .version import Version
from .__about__ import __version__

def cmd_bump(args: argparse.Namespace) -> str:
    """
    Subcommand: Bumps a version.

Synopsis: bump <PART> <VERSION>
    <PART> can be major, minor, patch, prerelease, or build

:param args: The parsed arguments
    :return: the new, bumped version
    """
    maptable = {
        "major": "bump_major",
        "minor": "bump_minor",
        "patch": "bump_patch",
        "prerelease": "bump_prerelease",
        "build": "bump_build",
    }
    if args.bump is None:
        # When bump is called without arguments,
        # print the help and exit
        args.parser.parse_args(["bump", "-h"])

ver = Version.parse(args.version)
    # get the respective method and call it
    func = getattr(ver, maptable[cast(str, args.bump)])
    return str(func())

def cmd_check(args: argparse.Namespace) -> None:
    """
    Subcommand: Checks if a string is a valid semver version.

Synopsis: check <VERSION>

:param args: The parsed arguments
    """
    if Version.is_valid(args.version):
        return None
    raise ValueError("Invalid version %r" % args.version)

def cmd_compare(args: argparse.Namespace) -> str:
    """
    Subcommand: Compare two versions.

Synopsis: compare <VERSION1> <VERSION2>

:param args: The parsed arguments
    """
    ver1 = Version.parse(args.version1)
    return str(ver1.compare(args.version2))

def cmd_nextver(args: argparse.Namespace) -> str:
    """
    Subcommand: Determines the next version, taking prereleases into account.

Synopsis: nextver <VERSION> <PART>

:param args: The parsed arguments
    """
    version = Version.parse(args.version)
    return str(version.next_version(args.part))

def createparser() -> argparse.ArgumentParser:
    """
    Create an :class:`argparse.ArgumentParser` instance.

:return: parser instance
    """
    parser = argparse.ArgumentParser(prog=__package__, description=__doc__)

parser.add_argument(
        "--version", action="version", version="%(prog)s " + __version__
    )

s = parser.add_subparsers()
    # create compare subcommand
    parser_compare = s.add_parser("compare", help="Compare two versions")
    parser_compare.set_defaults(func=cmd_compare)
    parser_compare.add_argument("version1", help="First version")
    parser_compare.add_argument("version2", help="Second version")

# create bump subcommand
    parser_bump = s.add_parser("bump", help="Bumps a version")
    parser_bump.set_defaults(func=cmd_bump)
    sb = parser_bump.add_subparsers(title="Bump commands", dest="bump")

# Create subparsers for the bump subparser:
    for p in (
        sb.add_parser("major", help="Bump the major part of the version"),
        sb.add_parser("minor", help="Bump the minor part of the version"),
        sb.add_parser("patch", help="Bump the patch part of the version"),
        sb.add_parser("prerelease", help="Bump the prerelease part of the version"),
        sb.add_parser("build", help="Bump the build part of the version"),
    ):
        p.add_argument("version", help="Version to raise")

# Create the check subcommand
    parser_check = s.add_parser(
        "check", help="Checks if a string is a valid semver version"
    )
    parser_check.set_defaults(func=cmd_check)
    parser_check.add_argument("version", help="Version to check")

# Create the nextver subcommand
    parser_nextver = s.add_parser(
        "nextver", help="Determines the next version, taking prereleases into account."
    )
    parser_nextver.set_defaults(func=cmd_nextver)
    parser_nextver.add_argument("version", help="Version to raise")
    parser_nextver.add_argument(
        "part", help="One of 'major', 'minor', 'patch', or 'prerelease'"
    )
    return parser

def process(args: argparse.Namespace) -> str:
    """
    Process the input from the CLI.

:param args: The parsed arguments
    :param parser: the parser instance
    :return: result of the selected action
    """
    if not hasattr(args, "func"):
        args.parser.print_help()
        raise SystemExit()

# Call the respective function object:
    return args.func(args)

def main(cliargs: Optional[List[str]] = None) -> int:
    """
    Entry point for the application script.

:param list cliargs: Arguments to parse or None (=use :class:`sys.argv`)
    :return: error code
    """
    try:
        parser = createparser()
        args = parser.parse_args(args=cliargs)
        # Save parser instance:
        args.parser = parser
        result = process(args)
        if result is not None:
            print(result)
        return 0

except (ValueError, TypeError) as err:
        print("ERROR", err, file=sys.stderr)
        return 2