skilleter-thingy 0.3.14__py3-none-any.whl

skilleter_thingy/git_cleanup.py

@@ -0,0 +1,297 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy 'git-cleanup' command - list or delete branches that have been merged.
+
+    Author: John Skilleter
+
+    Licence: GPL v3 or later
+"""
+################################################################################
+
+import os
+import sys
+import argparse
+import logging
+
+from skilleter_modules import git
+from skilleter_modules import colour
+
+################################################################################
+# Constants
+
+# Branches that we will never delete
+
+PROTECTED_BRANCHES = ['develop', 'master', 'main', 'release', 'hotfix']
+
+################################################################################
+
+def parse_command_line():
+    """ Parse the command line, returning the arguments """
+
+    parser = argparse.ArgumentParser(
+        description='List or delete branches that have been merged.\nWhen deleting branches, also delete tracking branches that are not longer on the remote.')
+
+    parser.add_argument('--delete', '-d', action='store_true', dest='delete', help='Delete all branches that have been merged')
+    parser.add_argument('--master', '-m', '--main', dest='master',
+                        help='Specify the master branch (Attempts to read this from GitLab or defaults to "develop" if present or "master" or "main" otherwise')
+    parser.add_argument('--force', '-f', action='store_true', dest='force', help='Allow protected branches (e.g. master) to be removed')
+    parser.add_argument('--unmerged', '-u', action='store_true', dest='list_unmerged', help='List branches that have NOT been merged')
+    parser.add_argument('--yes', '-y', action='store_true', dest='force', help='Assume "yes" in response to any prompts (e.g. to delete branches)')
+    parser.add_argument('--debug', action='store_true', help='Enable debug output')
+    parser.add_argument('--path', '-C', nargs=1, type=str, default=None,
+                        help='Run the command in the specified directory')
+
+    parser.add_argument('branches', nargs='*', help='List of branches to check (default is all branches)')
+
+    return parser.parse_args()
+
+################################################################################
+
+def validate_options(args, all_branches):
+    """ Check that the command line options make sense """
+
+    # If the master branch has not been specified try to get it from GitLab and then default to either 'develop', 'main', or 'master'
+
+    if not args.master:
+        args.master = git.default_branch()
+
+    if not args.master:
+        if 'develop' in all_branches:
+            args.master = 'develop'
+        elif 'main' in all_branches:
+            args.master = 'main'
+        elif 'master' in all_branches:
+            args.master = 'master'
+        else:
+            colour.error('You must specify a master branch as the repo contains no obvious master branch')
+
+    # Check that the master branch actually exists
+
+    if args.master not in all_branches:
+        colour.error('The "%s" branch does not exist in the repo' % args.master)
+
+    # Check that the user isn't trying to remove a branch that is normally sacrosanct
+
+    if not args.force and args.branches:
+        for branch in all_branches:
+            if branch in PROTECTED_BRANCHES:
+                colour.error('You must use the "--force" option to delete protected branches (%s)' % ', '.join(PROTECTED_BRANCHES))
+
+    # If no list of branches to check has been specified, use all the branches
+
+    if not args.branches:
+        args.branches = all_branches
+
+################################################################################
+
+def main():
+    """ Entry point """
+
+    # Handle the command line
+
+    args = parse_command_line()
+
+    # Enable logging if requested
+
+    if args.debug:
+        logging.basicConfig(level=logging.INFO)
+
+    # Change directory, if specified
+
+    if args.path:
+        os.chdir(args.path[0])
+
+    # Get the list of all local branches
+
+    try:
+        all_branches = git.branches()
+    except git.GitError as exc:
+        colour.error(exc.msg, status=exc.status)
+
+    logging.info('Branches=%s', all_branches)
+
+    # Check that the command line options are sensible, including the list of branches (if any)
+
+    validate_options(args, all_branches)
+
+    # Checkout and update the master branch then switch back
+
+    logging.info('Checking out %s branch', args.master)
+
+    try:
+        git.checkout(args.master)
+
+        logging.info('Running git pull')
+
+        git.pull()
+
+        logging.info('Checking out previous branch')
+
+        git.checkout('-')
+
+    except git.GitError as exc:
+        colour.error(exc.msg, status=exc.status)
+
+    # 'reported' is True when we've reported something so we can put a blank line before the
+    # next item (if there is one).
+
+    reported = False
+
+    # List of branches that we will delete (if we aren't just listing possibilities)
+
+    logging.info('Determining whether any branches can be deleted (not master branch, not protected and no outstanding commits)')
+
+    branches_to_delete = []
+
+    # Iterate through the branches, ignoring protected branches and the current master
+
+    for branch in args.branches:
+        if branch not in PROTECTED_BRANCHES and branch not in args.master:
+
+            # Has the branch got commits that haven't been merged to the master branch?
+
+            logging.info('Checking for unmerged commits on %s (against %s)', branch, args.master)
+
+            try:
+                unmerged = git.git(['log', '--no-merges', '--oneline', branch, '^%s' % args.master, '--'])
+            except git.GitError as exc:
+                sys.stderr.write('%s\n' % exc.msg)
+                sys.exit(exc.status)
+
+            # Either mark merged branches to be deleted or list unmerged or merged ones
+
+            if args.delete:
+                # Mark the branch as deleteable if the branch doesn't have unmerged commits
+                # and it either isn't protected or we're forcing
+
+                if not unmerged and (args.force or branch not in PROTECTED_BRANCHES):
+                    logging.info('Branch %s can be deleted', branch)
+
+                    branches_to_delete.append(branch)
+
+            elif args.list_unmerged:
+                if unmerged:
+                    # if the branch has commits that are not on the master branch then list it as unmerged
+
+                    if reported:
+                        print()
+                    else:
+                        colour.write('Branches that have not been merged to [BLUE:%s]:' % args.master)
+
+                    colour.write('    [BLUE:%s]: [BOLD:%d] unmerged commits' % (branch, len(unmerged)))
+
+                    for commit in unmerged:
+                        print('        %s' % commit)
+
+                    reported = True
+
+            elif not unmerged:
+                # If the branch hasn't got unique commits then it has been merged (or is empty)
+
+                if not reported:
+                    colour.write('Branches that have %sbeen merged to [BLUE:%s]' % ('not ' if args.list_unmerged else '', args.master))
+
+                colour.write('    [BLUE:%s]' % branch)
+
+                reported = True
+
+    # If we have branches to delete then delete them
+
+    if args.delete:
+        if branches_to_delete:
+
+            logging.info('Deleting branch(es): %s', branches_to_delete)
+
+            if not args.force:
+                colour.write('The following branches have already been merged to the [BLUE:%s] branch and can be deleted:' % args.master)
+                for branch in branches_to_delete:
+                    colour.write('    [BLUE:%s]' % branch)
+
+                print()
+                confirm = input('Are you sure that you want to delete these branches? ')
+
+                if confirm.lower() not in ('y', 'yes'):
+                    colour.error('**aborted**')
+
+                print()
+
+            # Delete the branches, switching to the master branch before attempting to delete the current one
+
+            for branch in branches_to_delete:
+                if branch == git.branch():
+                    colour.write('Switching to [BLUE:%s] branch before deleting current branch.' % args.master)
+                    git.checkout(args.master)
+
+                try:
+                    logging.info('Deleting %s', branch)
+
+                    git.delete_branch(branch, force=True)
+                except git.GitError as exc:
+                    colour.error(str(exc), status=exc.status)
+
+                colour.write('Deleted [BLUE:%s]' % branch)
+        else:
+            colour.write('There are no branches that have been merged to the [BLUE:%s] branch.' % args.master)
+
+    # Finally run remote pruning (note that we don't have an option to
+    # list branches that *can't* be pruned (yet))
+
+    reported = False
+    prunable = False
+
+    # Look for prunable branches and report them
+
+    logging.info('Looking for remote tracking branches that can be pruned')
+
+    for remote in git.remotes():
+        for prune in git.remote_prune(remote, dry_run=True):
+            if not reported:
+                print()
+                if args.force:
+                    print('Deleting remote tracking branches:')
+                else:
+                    print('Remote tracking branches that can be deleted:')
+                reported = True
+
+            colour.write('    [BLUE:%s]' % prune)
+            prunable = True
+
+    # If we are deleting things and have things to delete then delete things
+
+    if args.delete and prunable:
+        if not args.force:
+            print()
+            confirm = input('Are you sure that you want to prune these branches? ')
+
+            if confirm.lower() not in ('y', 'yes'):
+                colour.error('**aborted**')
+
+            print()
+
+        for remote in git.remotes():
+            logging.info('Pruning remote branches from %s', remote)
+
+            pruned = git.remote_prune(remote)
+
+            for branch in pruned:
+                colour.write('Deleted [BLUE:%s]' % branch)
+
+################################################################################
+
+def git_cleanup():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+    except git.GitError as exc:
+        colour.error(exc.msg, status=exc.status, prefix=True)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_cleanup()

skilleter_thingy/git_co.py

@@ -0,0 +1,227 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Enhanced version of 'git checkout'
+
+    Currently only supports the '-b' option in addition to the default
+    behaviour (may be extended to other options later, but otherwise, just
+    use the 'git checkout' command as normal.
+
+    Differs from standard checkout in that if the branch name specified is not
+    an exact match for an existing local or remote branch it will look for
+    branches where the specified name is a substring (e.g. '12345' will match
+    'feature/fix-1234567') and, if there is a unique match, it will check that
+    out. If there are multiple matches it will just list them.
+
+    Note - partial matching ONLY works for branch names - tag names only
+           do full matching and commits only match against the start of the SHA1
+
+    TODO: Should prioritise branch names over SHA1 - for instance git co 69772
+"""
+################################################################################
+
+import os
+import logging
+import sys
+import argparse
+
+from skilleter_modules import git
+from skilleter_modules import colour
+
+assert sys.version_info.major >= 3 and sys.version_info.minor >= 6
+
+################################################################################
+
+DESCRIPTION = \
+"""
+Enhanced version of 'git checkout'
+
+Differs from standard checkout in that if the branch name specified is
+not an exact match for an existing branch it will look for branches
+where the specified name is a substring (e.g. '12345' will match
+'feature/fix-1234567')
+
+If there is a single match, it will check that out.
+
+If there are multiple matches it will just list them.
+
+If no local branches match, it will match against remote branches.
+
+If no matching branches exist will will try commit IDs or tags.
+
+Currently only supports the '-b' option in addition to the default
+behaviour (may be extended to other options later, but otherwise, just
+use the 'git checkout' command as normal).
+"""
+
+################################################################################
+
+def parse_arguments():
+    """ Parse and return command line arguments """
+
+    parser = argparse.ArgumentParser(description=DESCRIPTION, formatter_class=argparse.RawTextHelpFormatter, epilog='Note that the "owner" of a branch is deemed to be the person who made the most-recent commit on that branch')
+    parser.add_argument('--branch', '-b', action='store_true', help='Create the specified branch')
+    parser.add_argument('--update', '-u', action='store_true', help='If a remote branch exists, and the branch isn\'t owned by the current user, delete any local branch and check out the remote version')
+    parser.add_argument('--rebase', '-r', action='store_true', help='Rebase the branch onto its parent after checking it out')
+    parser.add_argument('--force', '-f', action='store_true',
+                        help='When using the update option, recreate the local branch even if it is owned by the current user')
+    parser.add_argument('--exact', '-e', action='store_true', help='Do not use branch name matching - check out the branch as specified (if it exists)')
+    parser.add_argument('--debug', action='store_true', help='Enable debug output')
+    parser.add_argument('branchname', nargs=1, type=str,
+                        help='The branch name (or a partial name that matches uniquely against a local branch, remote branch, commit ID or tag)')
+    parser.add_argument('--path', '-C', nargs=1, type=str, default=None,
+                        help='Run the command in the specified directory')
+
+    args = parser.parse_args()
+
+    # Enable logging if requested
+
+    if args.debug:
+        logging.basicConfig(level=logging.INFO)
+
+    if args.path:
+        os.chdir(args.path[0])
+
+    if args.force and not args.update:
+        colour.error('The --force option only works with the --update option')
+
+    return args
+
+################################################################################
+
+def checkout_matching_branch(args, branchname):
+    """ Look for a commit matching the specified name and check it out if it is
+        an exact match or there is only one partial match.
+        If there are multiple branches that match, just list them
+        """
+
+    # If we are doing an update, then make sure we have all the remote info up-to-date
+
+    if args.update:
+        colour.write('Fetching updates from remote server(s)')
+        git.fetch(all=True)
+
+    # Get the list of matching commits.
+    # * If an exact match to the branch, tag or SHA branch exists use it without checking partial matches
+    # * Otherwise, unless --exact was specified, check for a partial match
+
+    if git.iscommit(branchname, remote=True):
+        commits = [branchname]
+
+        logging.info('Exact match found for %s', branchname)
+    elif not args.exact:
+        commits = git.matching_branch(branchname)
+
+        if not commits:
+            commits = git.matching_commit(branchname)
+
+        logging.info('Commits matching %s = %s', branchname, commits)
+
+    # Can't do anything with multiple/no matching commits/branches
+
+    if not commits:
+        colour.error(f'[BOLD]No branches or commits matching [NORMAL][BLUE]{branchname}[NORMAL]')
+    elif len(commits) > 1:
+        colour.write(f'[RED:ERROR]: [BOLD]Multiple matches for [NORMAL][BLUE]{branchname}[NORMAL]:')
+        for item in commits:
+            colour.write(f'    {item}')
+        sys.exit(1)
+
+    # If we have one match, then we can do stuff
+
+    logging.info('Only one matching commit: %s', commits[0])
+
+    commit = commits[0]
+
+    if args.update:
+        # TODO: Should check all remotes if more than one
+
+        remote = git.remote_names()[0]
+
+        if commit.startswith(f'{remote}/'):
+            remote_branch = commit
+        else:
+            remote_branch = f'remotes/{remote}/{commit}'
+
+        logging.info('Remote branch: %s', remote_branch)
+
+        # If the remote branch exists, then update, delete the local branch and re-create it
+
+        if git.isbranch(remote_branch):
+            logging.info('Remote branch exists')
+
+            default_branch = git.default_branch()
+
+            colour.write(f'Updating the [BLUE:{default_branch}] branch')
+
+            git.checkout(default_branch)
+            git.merge(f'{remote}/{default_branch}')
+
+            # If the local branch exists, delete it
+
+            # TODO: Should prompt rather than using force
+
+            if git.isbranch(commit):
+                logging.info('Local branch %s exists', commit)
+
+                # Don't overwrite our own branches, just to be on the safe side
+
+                if not args.force:
+                    author = git.author(commit)
+                    if author == git.config_get('user', 'name'):
+                        colour.write(f'ERROR: Most recent commit on {commit} is {author} - Use the --force option to force-update your own branch!')
+                        sys.exit(1)
+
+                colour.write('Removing existing [BLUE:{commit}] branch')
+                git.delete_branch(commit, force=True)
+        else:
+            colour.write(f'No corresponding remote branch [BLUE:{remote_branch}] exists')
+            return
+
+    # Check out the commit and report the name (branch, tag, or if nowt else, commit ID)
+
+    logging.info('Checking out %s', commit)
+
+    git.checkout(commit)
+    colour.write('[BOLD]Checked out [NORMAL][BLUE]%s[NORMAL]' % (git.branch() or git.tag() or git.current_commit()))
+
+    if args.rebase:
+        colour.write('Rebasing branch against its parent')
+
+        output = git.update()
+
+        for text in output:
+            print(text)
+
+################################################################################
+
+def main():
+    """ Main function - parse the command line and create or attempt to checkout
+        the specified branch """
+
+    args = parse_arguments()
+
+    if args.branch:
+        git.checkout(args.branchname[0], create=True)
+    else:
+        checkout_matching_branch(args, args.branchname[0])
+
+################################################################################
+
+def git_co():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+    except git.GitError as exc:
+        colour.error(exc.msg, status=exc.status, prefix=True)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_co()

skilleter_thingy/git_common.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+"""
+Report the oldest commit in common in the history of two commits
+"""
+
+################################################################################
+
+import os
+import sys
+import argparse
+
+from skilleter_modules import colour
+from skilleter_modules import git
+
+################################################################################
+
+def main():
+    """ Main function """
+
+    parser = argparse.ArgumentParser(description='Find the most recent common ancestor for two commits')
+
+    parser.add_argument('--short', '-s', action='store_true', help='Just output the ancestor commit ID')
+    parser.add_argument('--long', '-l', action='store_true', help='Output the log entry for the commit')
+    parser.add_argument('--path', '-C', nargs=1, type=str, default=None,
+                        help='Run the command in the specified directory')
+    parser.add_argument('commit1', nargs='?', default='HEAD', help='First commit (default=HEAD)')
+    parser.add_argument('commit2', nargs='?', default='master', help='Second commit (default=master)')
+
+    args = parser.parse_args()
+
+    if args.long and args.short:
+        colour.error('The [BLUE:--long] and [BLUE:--short] options cannot be used together', prefix=True)
+
+    # Change directory, if specified
+
+    if args.path:
+        os.chdir(args.path[0])
+
+    ancestor = git.find_common_ancestor(args.commit1, args.commit2)
+
+    if args.short:
+        print(ancestor)
+    elif args.long:
+        print('\n'.join(git.log(ancestor)))
+    else:
+        colour.write(f'Last common commit between [BLUE:{args.commit1}] and [BLUE:{args.commit2}] is [BLUE:{ancestor}]')
+
+################################################################################
+# Entry point
+
+def git_common():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+    except git.GitError as exc:
+        colour.error(exc.msg, status=exc.status, prefix=True)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_common()