ghw

#!/usr/bin/env python3
"""Get to GitHub really fast!

A simple command line interface to open GitHub repositories in a
web browser without ever leaving the terminal.
"""

import argparse
import subprocess
import sys
from pathlib import Path
from typing import Optional

DOTFILES_DIR = Path(Path.home(), ".dotfiles", "zfunc")
sys.path.insert(0, str(DOTFILES_DIR))

from gitUtils import get_git_username

VERSION = "0.1.0"
GITHUB_USERNAME = get_git_username()

# Templates for URL completion
URL_TEMPLATE = "https://github.com/{username}/{repo}/tree/{branch}"
GH_BASE = "https://github.com/{path}"


def open_url(url: str) -> None:
    """Use xdg-open to open a URL in the default browser."""
    subprocess.Popen(
        ["xdg-open", f"{url}"],
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
    )


def ssh_to_https(ssh_url: str) -> str:
    """Convert ssh remote scheme to https."""
    if "@" not in ssh_url:
        return ssh_url

    url = ssh_url.split("@")[1]
    url = url.replace(":", "/")
    url = f"https://{url}"

    return url


def get_current_branch() -> Optional[str]:
    """Get the branch of the current git repo.

    Uses a external call to a subprocess to grab the
    branch of the current git repository.

    Returns:
        branch: str name of branch
        None: failed to get a branch name
    """
    branch_name = subprocess.run(
        ["git", "branch", "--show-current"],
        capture_output=True,
    )
    if branch_name.stderr:
        return None

    return branch_name.stdout.decode().strip()


def get_remote_url(name: Optional[str] = None, branch_name: Optional[str] = None):
    """Convert name of repo to URL

    Converts either, the name of the repo, or the remote URL to a GitHub URL.

    Args:
        name: Optionally, get the URL of a GitHub repo from its name
        branch_name: Optionally, get the URL to the specific branch of a repo

    Returns:
        str: URL to repository

    Raises:
        None
    """
    # Get the right branch name, default to master.
    if not name:
        # Try and grab current git repo.
        # If there isn't one, just open profile.
        url = (
            subprocess.run(
                ["git", "config", "--get", "remote.origin.url"],
                capture_output=True,
            )
            .stdout.decode()
            .strip()
        )

        # Cleanup output
        if url == "":
            return GH_BASE.format(path=GITHUB_USERNAME)
        elif url.endswith(".git"):
            url = url[:-4]

        # Ensure URL is in proper HTTPS schema.
        url = ssh_to_https(url)
        branch_name = branch_name or get_current_branch()
    else:
        url = GH_BASE.format(path=f"{GITHUB_USERNAME}/{name}")

    if branch_name:
        url = f"{url}/tree/{branch_name}"

    return url


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description=__doc__,
    )
    group = parser.add_mutually_exclusive_group()

    parser.add_argument(
        "-v",
        "--version",
        action="version",
        version=f"%(prog)s {VERSION}",
    )
    parser.add_argument(
        "-d",
        "--dry-run",
        action="store_true",
        help="Just print the external URL.",
    )

    # Ensure you can't provide a qualified name and repo name simultaneously.
    group.add_argument(
        "repo",
        nargs="?",
        action="store",
        metavar="NAME",
        help="Name of repository to navigate to.",
    )
    group.add_argument(
        "-q",
        "--qualified",
        action="store",
        metavar="USER/REPO",
        help="Qualified name to navigate to",
    )
    parser.add_argument(
        "-b",
        "--branch",
        action="store",
        metavar="BRANCH",
        help="Branch of repository to navigate to.",
    )

    args = vars(parser.parse_args())
    if args["qualified"]:
        url = GH_BASE.format(path=args["qualified"])
        if args["branch"]:
            url = f"{url}/tree/{args['branch']}"
    else:
        url = get_remote_url(args["repo"], args["branch"])

    if args["dry_run"]:
        print(url)
    else:
        open_url(url)