skilleter-thingy 0.0.22__py3-none-any.whl

skilleter_thingy/git_br.py

@@ -0,0 +1,180 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy 'git-br' command - output branch information
+
+    Author: John Skilleter
+
+    Licence: GPL v3 or later
+
+    TODO: Command line options for list of fields to output
+    TODO: Command line options for sort order
+    TODO: Debate the delete option, which currently isn't implemented
+"""
+################################################################################
+
+import sys
+import argparse
+import fnmatch
+import datetime
+
+from dateutil.parser import parse
+from dateutil.relativedelta import relativedelta
+
+from skilleter_thingy import git
+from skilleter_thingy import colour
+
+################################################################################
+
+def parse_command_line():
+    """ Parse the command line """
+
+    parser = argparse.ArgumentParser(description='List or delete branches that have been merged')
+
+    parser.add_argument('-a', '--all', action='store_true', help='List all branches, including remotes')
+    parser.add_argument('-d', '--delete', action='store_true',
+                        help='Delete the specified branch(es), even if it is the current one (list of branches to delete must be supplied as parameters)')
+    parser.add_argument('branches', nargs='*', help='Filter the list of branches according to one or more patterns')
+
+    args = parser.parse_args()
+
+    if args.delete and not args.branches:
+        colour.error('[RED:ERROR]: You must specify the branches to delete')
+
+    return args
+
+################################################################################
+
+def branch_match(ref, matching_branches):
+    """ Return True if ref matches an entry in matching_branches """
+
+    if matching_branches:
+        for branch in matching_branches:
+            if '?' in branch or '*' in branch:
+                if branch[0] not in ['?', '*']:
+                    branch = f'*{branch}'
+                if branch[-1] not in ['?', '*']:
+                    branch = f'{branch}*'
+
+                if fnmatch.fnmatch(ref, branch):
+                    return True
+            elif branch in ref:
+                return True
+
+        return False
+
+    return True
+
+################################################################################
+
+def get_matching_branches(args):
+    """ Get a list of branches matching those specified in the script arguments  """
+
+    # Get the SHA1, date, author and name of the tip commit on each branch, including remotes
+    # and keep track of the maximum length of each field
+
+    branches = []
+
+    for ref in git.ref(sort='-committerdate', fields=('objectname:short', 'committerdate', 'authorname', 'refname:short'), remotes=args.all):
+        if branch_match(ref[3], args.branches):
+            branches.append(ref)
+
+    return branches
+
+################################################################################
+
+def list_branches(branches):
+    """ List branches. """
+
+    max_len = [0] * len(branches[0])
+
+    user = git.config_get('user', 'name')
+
+    # Output the fields in columns, highlighting user's own branches and those owned by Jenkins
+    # Replacing references to today and yesterday's dates with 'today' and 'yesterday' and
+    # reformatting dates and time for readability.
+
+    today = datetime.date.today()
+    yesterday = today - relativedelta(days=1)
+
+    all_output = []
+
+    current_branch = git.branch()
+
+    for branch in branches:
+        output = []
+
+        for i, field in enumerate(branch):
+            if i==1:
+                field = parse(field)
+                time_str = field.strftime('%H:%M:%S')
+
+                if field.date() == today:
+                    field = 'today      ' + time_str
+                elif field.date() == yesterday:
+                    field = 'yesterday  ' + time_str
+                else:
+                    field = field.date().strftime('%d/%m/%Y') + ' ' + time_str
+
+            output.append('%-*s' % (max_len[i], field))
+            max_len[i] = max(max_len[i], len(field))
+
+        highlight = 'GREEN' if branch[3] in ('master', 'main', 'develop') \
+                    else 'BOLD' if branch[3] == current_branch \
+                    else 'BLUE' if branch[2] == user \
+                    else 'NORMAL'
+
+        all_output.append({'highlight': highlight, 'output': output})
+
+    for output in all_output:
+        line = []
+        for i, field in enumerate(output['output']):
+            line.append('%-*s' % (max_len[i], field))
+
+        colour.write('[%s:%s]' % (output['highlight'], '  '.join(line).rstrip()))
+
+################################################################################
+
+def delete_branches(branches):
+    """ Delete matching branches. Report an error if no branches specified """
+
+    if not branches:
+        print('ERROR: The branches to delete must be specified')
+        sys.exit(1)
+
+    print('TODO: Deleting %s' % branches)
+
+    # TODO: List branches, prompt user, delete each branch - if current branch then checkout develop, main or master first
+
+################################################################################
+
+def main():
+    """ Main function """
+
+    args = parse_command_line()
+
+    branches = get_matching_branches(args)
+
+    if args.delete:
+        delete_branches(branches)
+    else:
+        list_branches(branches)
+
+################################################################################
+
+def git_br():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+    except git.GitError as exc:
+        colour.error(f'[RED:ERROR]: {exc.msg}', status=exc.status)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_br()

skilleter_thingy/git_ca.py

@@ -0,0 +1,142 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy "git-ca" command - an intelligent version of "git commit --amend"
+
+    Copyright (C) 2017-18 John Skilleter
+
+    Licence: GPL v3 or later
+
+    TODO: Handle attempt to amend commit in newly-initialised repo with no commits in.
+    TODO: Fix failure with "fatal: pathspec "FILENAME" did not match any files" whilst amending a commit to include a deleted file.
+"""
+################################################################################
+
+import os
+import argparse
+import sys
+
+from skilleter_thingy import colour
+from skilleter_thingy import git
+from skilleter_thingy import logger
+
+################################################################################
+
+def main():
+    """ Amend a comment, updating modified files that are already committed and
+        adding files that are listed on the command line """
+
+    # Files to add to git before committing and files to commit
+
+    files_to_add = []
+    files_to_commit = []
+
+    # Parse the command line
+
+    parser = argparse.ArgumentParser(
+        description='Amend changes to the current commit. Updates files that are already in the commit and, optionally, adds additional files.')
+
+    parser.add_argument('-A', '--added', action='store_true', help='Update files in the current commit, including files added with "git add"')
+    parser.add_argument('-a', '--all', action='store_true', help='Append all locally-modified, tracked files to the current commit')
+    parser.add_argument('-e', '--everything', action='store_true', help='Append all modified and untracked files to the current commit (implies --all)')
+    parser.add_argument('-i', '--ignored', action='store_true', dest='ignored', help='Include files normally hidden by .gitignore')
+    parser.add_argument('-p', '--patch', action='store_true', help='Use the interactive patch selection interface to chose which changes to commit.')
+    parser.add_argument('-v', '--verbose', action='store_true', help='Verbose mode')
+    parser.add_argument('-D', '--dry-run', action='store_true', help='Dry-run')
+
+    parser.add_argument('files', nargs='*', help='List of files to add to the commit')
+
+    args = parser.parse_args()
+
+    # Configure logger
+
+    log = logger.init(__name__)
+
+    if args.verbose:
+        log.setLevel(logger.INFO)
+        log.info('Debug logging enabled')
+
+    # 'Add' implies 'all'
+
+    if args.everything:
+        args.all = True
+
+    # If there are any files on the command line then add them
+    # to the list of files to be committed
+
+    if args.files:
+        for filename in args.files:
+            rel_path = git.tree_path(filename)
+            files_to_add.append(rel_path)
+
+    # Move to the working tree
+
+    working_tree = git.working_tree()
+
+    if not working_tree:
+        colour.error('fatal: not a git repository (or any of the parent directories)')
+
+    os.chdir(working_tree)
+
+    # Get the list of files modified in the most recent commit
+
+    current_commit = git.commit_info('HEAD', 'HEAD^')
+
+    # Get the list of locally-modified and untracked files, including
+    # files matching .gitignore, if necessary
+
+    log.info('Getting list of changed files')
+    local_changes = git.status_info(args.ignored)
+
+    for change in local_changes:
+        log.info('Changed: %s (%s)', change, local_changes[change])
+
+        if change in current_commit or (args.added and local_changes[change][0] == 'A'):
+            # Locally changed and already in the commit or, optionally, added to it, so update it
+
+            files_to_commit.append(change)
+
+        elif args.all and (local_changes[change][1] in ('M', 'A', 'D', 'T') or local_changes[change][0] == 'D'):
+            # Tracked and 'all' option specified so add it to the commit
+
+            files_to_commit.append(change)
+
+        elif args.everything and local_changes[change][0] in ('!', '?'):
+            # Untracked and 'add' option specified so add it to Git and the commit
+
+            files_to_add.append(change)
+
+    if files_to_add:
+        try:
+            git.add(files_to_add)
+        except git.GitError as exc:
+            colour.error(exc.msg, status=exc.status)
+
+        files_to_commit += files_to_add
+
+    # Perform the commit running in the foreground in case the user is using a console
+    # mode text editor for commit comments.
+
+    log.info('Files to commit: %s', files_to_commit)
+
+    try:
+        git.commit(files_to_commit, amend=True, foreground=True, patch=args.patch, dry_run=args.dry_run)
+    except git.GitError as exc:
+        sys.exit(exc.status)
+
+################################################################################
+
+def git_ca():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_ca()

skilleter_thingy/git_cleanup.py

@@ -0,0 +1,287 @@
+#! /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 sys
+import argparse
+import logging
+
+from skilleter_thingy import git
+from skilleter_thingy 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('-d', '--delete', action='store_true', dest='delete', help='Delete all branches that have been merged')
+    parser.add_argument('-m', '--master', '--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('-f', '--force', action='store_true', dest='force', help='Allow protected branches (e.g. master) to be removed')
+    parser.add_argument('-u', '--unmerged', action='store_true', dest='list_unmerged', help='List branches that have NOT been merged')
+    parser.add_argument('-y', '--yes', 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('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)
+
+    # Get the list of all local branches
+
+    try:
+        all_branches = [branch for branch in 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 umerged 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)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_cleanup()