skilleter-thingy 0.0.22__py3-none-any.whl

skilleter_thingy/git_co.py

@@ -0,0 +1,220 @@
+#! /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 logging
+import sys
+import argparse
+
+from skilleter_thingy import git
+from skilleter_thingy 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)
+    parser.add_argument('-b', '--branch', action='store_true', help='Create the specified branch')
+    parser.add_argument('-u', '--update', action='store_true', help='If a remote branch exists, delete any local branch and check out the remote version')
+    parser.add_argument('-r', '--rebase', action='store_true', help='Rebase the branch onto its parent after checking it out')
+    parser.add_argument('-f', '--force', action='store_true',
+                        help='When using the update option, recreate the local branch even if it is owned by the current user (based on the author of the most recent commit)')
+    parser.add_argument('-e', '--exact', 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)')
+
+    args = parser.parse_args()
+
+    # Enable logging if requested
+
+    if args.debug:
+        logging.basicConfig(level=logging.INFO)
+
+    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 --exact specified, use the specified commit if it exists
+    # * Otherwise, if an exact match (branch, tag or SHA) exists, use that
+    # * Otherwise, look for a partial match
+
+    if args.exact:
+        commits = [branchname] if git.iscommit(branchname, remote=True) else []
+
+        logging.info(f'Exact match required: {commits}')
+    elif git.iscommit(branchname, remote=True):
+        commits = [branchname]
+
+        logging.info(f'Exact match found for {branchname}')
+    else:
+        commits = git.matching_branch(branchname)
+
+        if not commits:
+            commits = git.matching_commit(branchname)
+
+        logging.info('Commits matching %s = %s', branchname, commits)
+
+    # If we have one match, then we can do stuff
+
+    if len(commits) == 1:
+        logging.info('Only one matching commit')
+
+        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:%s] branch' % commit)
+                    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)
+
+    elif not commits:
+        colour.write('[BOLD]No branches or commits matching [NORMAL][BLUE]%s[NORMAL]' % branchname)
+    else:
+        colour.write('[BOLD]Multiple matches for [NORMAL][BLUE]%s[NORMAL]: %s' % (branchname, ', '.join(commits)))
+
+################################################################################
+
+def main():
+    """ Main function - parse the command line and create or attempt to checkout
+        the specified branch """
+
+    args = parse_arguments()
+
+    try:
+        if args.branch:
+            git.checkout(args.branchname[0], create=True)
+        else:
+            checkout_matching_branch(args, args.branchname[0])
+
+    except git.GitError as exc:
+        colour.error(exc.msg, exc.status)
+
+################################################################################
+
+def git_co():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_co()

skilleter_thingy/git_common.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+"""
+Report the oldest commit in common in the history of two commits
+"""
+
+################################################################################
+
+import sys
+import argparse
+
+from skilleter_thingy import colour
+from skilleter_thingy 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('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('[RED:ERROR]: The [BLUE:--long] and [BLUE:--short] options cannot be used together')
+
+    try:
+        ancestor = git.find_common_ancestor(args.commit1, args.commit2)
+    except git.GitError as exc:
+        colour.error(f'[RED:ERROR]: {exc}', status=exc.status)
+
+    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)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_common()

skilleter_thingy/git_hold.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Archive one or more branches by tagging the branch then deleting it
+   The branch tag is 'archive/BRANCH_NAME'"""
+
+import sys
+import argparse
+import fnmatch
+
+from skilleter_thingy import colour
+from skilleter_thingy import git
+
+################################################################################
+# Prefix for tags representing archived branches
+
+ARCHIVE_PREFIX = 'archive/'
+
+################################################################################
+
+def archive_tag_name(branch):
+    """Return the tag name for an archive branch"""
+
+    return f'{ARCHIVE_PREFIX}{branch}'
+
+################################################################################
+
+def archive_branch_name(tag):
+    """Return the branch name for an archive tag"""
+
+    if not tag.startswith(ARCHIVE_PREFIX):
+        raise git.GitError(f'{tag} is not an archive tag')
+
+    return tag[len(ARCHIVE_PREFIX):]
+
+################################################################################
+
+def archive_tags():
+    """Return the list of current archive tags"""
+
+    return [tag for tag in git.tags() if tag.startswith(ARCHIVE_PREFIX)]
+
+################################################################################
+
+def archive_branches(branches):
+    """Archive one or more branches"""
+
+    tags = archive_tags()
+    current_branch = git.branch()
+
+    for branch in branches:
+        if not git.isbranch(branch):
+            colour.error(f'[RED:ERROR:] Branch {branch} does not exist')
+
+        if archive_tag_name(branch) in tags:
+            colour.error(f'[RED:ERROR:] An archive tag already exists for branch {branch}')
+
+        if branch == current_branch:
+            colour.error(f'[RED:ERROR:] Cannot archive the current branch')
+
+    for branch in branches:
+        tag_name = archive_tag_name(branch)
+
+        git.set_tag(tag_name, branch)
+        git.delete_branch(branch, force=True)
+
+    for remote in git.remotes():
+        git.push(repository=remote, tags=True)
+
+################################################################################
+
+def list_archive_branches(branches):
+    """List archive branches, optionally only those matching entries in the
+       branches parameter"""
+
+    tags = archive_tags()
+
+    if branches:
+        report = set()
+
+        for branch in branches:
+            for tag in tags:
+                branch_name = archive_branch_name(tag)
+                if branch_name not in report and fnmatch.fnmatch(branch_name, branch):
+                    report.add(branch_name)
+    else:
+        report = set(tags)
+
+    for branch_name in sorted(report):
+        print(branch_name)
+
+################################################################################
+
+def restore_archive_branches(branches):
+    """Restore archived branches"""
+
+    tags = archive_tags()
+
+    for branch in branches:
+        if not archive_tag_name(branch) in tags:
+            colour.error(f'[RED:ERROR:] Archive branch {branch} does not exist')
+
+    archive_tag_names = []
+
+    for branch in branches:
+        archive_tag = archive_tag_name(branch)
+        archive_tag_names.append(archive_tag)
+
+        git.checkout(branch, commit=archive_tag)
+        git.delete_tag(archive_tag)
+
+    for remote in git.remotes():
+        git.push(repository=remote, delete=True, refspec=archive_tag_names)
+
+################################################################################
+
+def main():
+    """Main function"""
+
+    parser = argparse.ArgumentParser(description='Archive, list or recover one or more Git branches')
+    parser.add_argument('--list', '-l', action='store_true', help='List archived branches')
+    parser.add_argument('--restore', '-r', action='store_true', help='Restore archived branches')
+    parser.add_argument('branches', nargs='*', help='Branches')
+
+    args = parser.parse_args()
+
+    if args.list and args.restore:
+        colour.error('[RED:ERROR:] The list and restore options cannot be specified together')
+
+    if not args.branches and not args.list:
+        colour.error('[RED:ERROR:] No branches specified')
+
+    if args.list:
+        list_archive_branches(args.branches)
+    elif args.restore:
+        restore_archive_branches(args.branches)
+    else:
+        archive_branches(args.branches)
+
+################################################################################
+
+def git_hold():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_hold()

skilleter_thingy/git_mr.py

@@ -0,0 +1,92 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Push to Gitlab and create a merge request at the same time """
+################################################################################
+
+import logging
+import sys
+import argparse
+
+from skilleter_thingy import git
+from skilleter_thingy import colour
+
+################################################################################
+
+DESCRIPTION = 'Push a feature branch to GitLab and create a merge request'
+
+################################################################################
+
+def parse_arguments():
+    """ Parse and return command line arguments """
+
+    parser = argparse.ArgumentParser(description=DESCRIPTION, formatter_class=argparse.RawTextHelpFormatter)
+
+    parser.add_argument('--debug', action='store_true', help='Enable debug output')
+    parser.add_argument('-f', '--force', action='store_true', help='Force-push the branch')
+    parser.add_argument('--parent', '-p', action='store', help='Override the default parent and specify the branch to merge onto')
+    parser.add_argument('--reviewer', '-r', action='store', help='Specify the name of the reviewer for the merge request')
+    parser.add_argument('--keep', '-k', action='store_true', help='Keep the source branch after the merge (default is to delete it).')
+
+    args = parser.parse_args()
+
+    # Enable logging if requested
+
+    if args.debug:
+        logging.basicConfig(level=logging.INFO)
+
+    return args
+
+################################################################################
+
+def main():
+    """ Main function - parse the command line and perform the pushing """
+
+    args = parse_arguments()
+
+    if args.parent:
+        parents = [args.parent]
+    else:
+        parents, _ = git.parents()
+
+        if len(parents) > 1:
+            parent_list = ', '.join(parents)
+            colour.error(
+                f'Branch has multiple potential parents: [BLUE]{parent_list}[NORMAL]. Use the [BLUE]--parent[NORMAL] option to specify the appropriate one.')
+        elif not parents:
+            colour.error('Unable to determine parent branch. Use the [BLUE]--parent[NORMAL] option to specify the appropriate one.')
+
+    options = ['merge_request.create', f'merge_request.target={parents[0]}']
+
+    if args.reviewer:
+        options.append(f'merge_request.assign={args.reviewer}')
+
+    if not args.keep:
+        options.append('merge_request.remove_source_branch')
+
+    logging.debug('Running git push with:')
+    logging.debug('  force: %s', args.force)
+    logging.debug('  push options: %s', options)
+
+    result = git.push(force_with_lease=args.force, push_options=options)
+
+    for text in result:
+        print(text)
+
+################################################################################
+
+def git_mr():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_mr()

skilleter_thingy/git_parent.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+
+"""
+Attempt to determine the parent branch of a commit by tracking down
+the branch commit history and looking for other branches that share
+the same commit. Can optionally ignore feature branches and/or report
+the distance to the potential parent.
+"""
+
+import argparse
+import sys
+
+from skilleter_thingy import git
+from skilleter_thingy import colour
+
+################################################################################
+
+def main():
+    """ Main function """
+
+    parser = argparse.ArgumentParser(description='Attempt to determine the parent branch for the specified branch (defaulting to the current one)')
+    parser.add_argument('-a', '--all', action='store_true', help='Include feature branches as possible parents')
+    parser.add_argument('-v', '--verbose', action='store_true', help='Report verbose results (includes number of commits between branch and parent)')
+    parser.add_argument('branch', action='store', nargs='?', type=str, default='HEAD', help='Branch, commit or commit')
+
+    args = parser.parse_args()
+
+    try:
+        if args.all:
+            any_parents, any_distance = git.parents(args.branch)
+        else:
+            any_parents = []
+
+        parents, distance = git.parents(args.branch, ignore='feature/*')
+
+        # If we have feature and non-feature branch candidates, decide which to report
+        # (one or both) based on distance.
+
+        if parents and any_parents:
+            if any_distance < distance:
+                parents = any_parents
+                distance = any_distance
+            elif any_distance == distance:
+                for more in any_parents:
+                    if more not in parents:
+                        parents.append(more)
+
+    except git.GitError as exc:
+        colour.error(f'[RED:ERROR:] {exc.msg}', status=exc.status)
+
+    if parents:
+        if args.verbose:
+            if len(parents) == 1:
+                colour.write(f'Parent branch [BLUE:{parents[0]}] is [BLUE:{distance}] commits away from [BLUE:{args.branch}]')
+            else:
+                colour.write(f'Parent branches [BLUE:%s] are [BLUE:{distance}] commits away from [BLUE:{args.branch}[' % (', '.join(parents)))
+        else:
+            print(', '.join(parents))
+    else:
+        colour.error('[RED:Could not determine parent branch]\n')
+
+################################################################################
+
+def git_parent():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    git_parent()