skilleter-thingy 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

skilleter_thingy/thingy/git.py

@@ -1,9 +1,9 @@
 #! /usr/bin/env python3
 
 ################################################################################
-""" Git module
+""" Git module V2 - now implemented as a wrapper around pygit2 (work in progress)
 
-    Copyright (C) 2017-18 John Skilleter
+    Copyright (C) 2023 John Skilleter
 
     Licence: GPL v3 or later
 
@@ -15,8 +15,8 @@
     * Functions will raise exceptions on error. If the underlying git command
       returns an error, a git.GitError() exception is raised.
 
-    * TODO: Cache list of branches when git.branches/isbranch called
-    * TODO: commit_info() doesn't like files that are renamed *and* changed
+    * TODO: [ ] Cache list of branches when git.branches/isbranch called
+    * TODO: [ ] API change - git_run_status should raise an exception on failure and just return the git output
 """
 ################################################################################
 
@@ -28,6 +28,8 @@ import logging
 import fnmatch
 import subprocess
 
+import pygit2
+
 import thingy.run as run
 import thingy.gitlab as gitlab
 
@@ -36,6 +38,11 @@ import thingy.gitlab as gitlab
 
 (WORKTREE, LOCAL, GLOBAL, SYSTEM) = list(range(4))
 
+# Options always passed to Git (disable autocorrect to stop it running the wrong command
+# if an invalid command name has been specified).
+
+STANDARD_GIT_OPTIONS = ['-c', 'help.autoCorrect=never']
+
 # Default default branches (can be overridden in .gitconfig via skilleter-thingy.defaultBranches
 
 DEFAULT_DEFAULT_BRANCHES = 'develop,main,master'
@@ -43,61 +50,84 @@ DEFAULT_DEFAULT_BRANCHES = 'develop,main,master'
 ################################################################################
 
 class GitError(run.RunError):
-    """ Run exception """
+    """Run exception."""
 
-    def __init__(self, msg, status=1):
-        super().__init__(msg, status)
+    def __init__(self, msg, exit_status=1):
+        super().__init__(msg, exit_status)
 
 ################################################################################
 
-def git(cmd, stdout=None, stderr=None):
-    """ Wrapper for thingy.run.run that raises a GitError instead of RunError
+def git(cmd, stdout=None, stderr=None, path=None):
+    """ Wrapper for run.run that raises a GitError instead of RunError
         so that Git module users do not to include the run module just
         to get the exception.
         Optionally redirect stdout and stderr as specified. """
 
-    logging.debug('Running git %s', ' '.join(cmd))
+    git_cmd = ['git'] + STANDARD_GIT_OPTIONS
+
+    if path:
+        git_cmd += ['-C', path]
+
+    git_cmd += cmd if isinstance(cmd, list) else [cmd]
+
+    logging.debug('Running %s', ' '.join(git_cmd))
+
+    sys.stdout.flush()
+    sys.stderr.flush()
 
     try:
-        return run.run(['git'] + cmd, stdout=stdout, stderr=stderr)
+        return run.run(git_cmd, stdout=stdout, stderr=stderr)
     except run.RunError as exc:
-        raise GitError(exc.msg, exc.status)
+        raise GitError(exc.msg, exc.status) from exc
     except FileNotFoundError as exc:
         raise GitError(exc, 1)
 
 ################################################################################
 
-def git_run_status(cmd, stdout=None, stderr=None):
+def git_run_status(cmd, stdout=None, stderr=None, path=None, redirect=True):
     """ Wrapper for run.run that returns the output and status, and
         does not raise an exception on error.
         Optionally redirect stdout and stderr as specified. """
 
     logging.debug('Running git %s', ' '.join(cmd))
 
-    result = subprocess.run(['git'] + cmd,
-                            stdout=stdout or subprocess.PIPE,
-                            stderr=stderr or subprocess.PIPE,
-                            text=True,
-                            errors='ignore',
-                            universal_newlines=True)
+    git_cmd = ['git'] + STANDARD_GIT_OPTIONS
+
+    if path:
+        git_cmd += ['-C', path]
+
+    git_cmd += cmd if isinstance(cmd, list) else [cmd]
+
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    if redirect:
+        result = subprocess.run(git_cmd,
+                                stdout=stdout or subprocess.PIPE,
+                                stderr=stderr or subprocess.PIPE,
+                                text=True, check=False,
+                                errors='ignore',
+                                universal_newlines=True)
+    else:
+        result = subprocess.run(git_cmd, check=False)
 
     return (result.stdout or result.stderr), result.returncode
 
 ################################################################################
 
-def clone(reponame, directory=None):
+def clone(reponame, working_tree=None):
     """ Clone a repo """
 
     cmd = ['clone', reponame]
 
-    if directory:
-        cmd.append(directory)
+    if working_tree:
+        cmd.append(working_tree)
 
     return git(cmd)
 
 ################################################################################
 
-def init(reponame, bare=False):
+def init(reponame, bare=False, path=None):
     """ Initialise a new working tree """
 
     cmd = ['init']
@@ -107,11 +137,11 @@ def init(reponame, bare=False):
 
     cmd.append(reponame)
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def iscommit(commit, remote=False, remote_only=False):
+def iscommit(commit, remote=False, remote_only=False, path=None):
     """ Return True if "commit" is a valid SHA1, branch or tag
         If remote==True then if there are no direct matches it will also
         check for a matching remote branch
@@ -122,7 +152,7 @@ def iscommit(commit, remote=False, remote_only=False):
     if not remote_only:
         cmd = ['cat-file', '-t', commit]
         try:
-            result = git(cmd)[0]
+            result = git(cmd, path=path)[0]
 
             return result in ('commit', 'tag')
         except GitError:
@@ -131,7 +161,7 @@ def iscommit(commit, remote=False, remote_only=False):
     # Optionally look for matching remote branch
 
     if remote or remote_only:
-        for branch in branches(all=True):
+        for branch in branches(all=True, path=path):
             if branch.startswith('remotes/'):
                 localbranch = '/'.join(branch.split('/')[2:])
 
@@ -142,48 +172,59 @@ def iscommit(commit, remote=False, remote_only=False):
 
 ################################################################################
 
-def branch(branchname='HEAD'):
+def branch(branchname='HEAD', path=None):
     """ Return the name of the current git branch or None"""
 
     try:
-        return git(['symbolic-ref', '--short', '-q', branchname])[0]
+        return git(['symbolic-ref', '--short', '-q', branchname], path=path)[0]
     except GitError:
         return None
 
 ################################################################################
 
-def tag():
+def tag(path=None):
     """ If the current commit is tagged, return the tag(s) or None """
 
     try:
-        return git(['describe', '--tags', '--exact-match'])[0]
+        return git(['describe', '--tags', '--exact-match'], path=path)[0]
     except GitError:
         return None
 
 ################################################################################
 
-def tags():
+def tags(path=None):
     """ Return the list of tags in the current repo """
 
-    return git(['tag'])
+    return git(['tag', '--list'], path=path)
 
 ################################################################################
 
-def tag_apply(tag, commit):
-    """ Apply a tag to a commit """
+def tag_delete(tag, push=False, path=None):
+    """Delete a tag, optionally pushing the deletion"""
+
+    git(['tag', '-d', tag], path=path)
 
-    return git(['tag', tag, commit])
+    if push:
+        git(['push', 'origin', '--delete', tag], path=path)
 
 ################################################################################
 
-def tag_delete(tag):
-    """ Delete a tag """
+def tag_apply(tag, commit=None, push=False, path=None):
+    """Apply a tag, optionally pushing it"""
+
+    cmd = ['tag', tag]
+
+    if commit:
+        cmd.append(commit)
+
+    git(cmd, path=path)
 
-    return git(['tag', '--delete', tag])
+    if push:
+        git(['push', 'origin', tag], path=path)
 
 ################################################################################
 
-def current_commit(short=False):
+def current_commit(short=False, path=None):
     """ Return the SHA1 of the current commit """
 
     cmd = ['rev-parse']
@@ -193,11 +234,11 @@ def current_commit(short=False):
 
     cmd.append('HEAD')
 
-    return git(cmd)[0]
+    return git(cmd, path=path)[0]
 
 ################################################################################
 
-def pull(repo=None, all=False):
+def pull(repo=None, all=False, path=None):
     """ Run a git pull """
 
     cmd = ['pull']
@@ -208,11 +249,11 @@ def pull(repo=None, all=False):
     if repo:
         cmd.append(repo)
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def checkout(branch, create=False, commit=None):
+def checkout(branch, create=False, commit=None, path=None):
     """ Checkout a branch (optionally creating it or creating it from the
         specified commit) """
 
@@ -226,27 +267,27 @@ def checkout(branch, create=False, commit=None):
     if commit:
         cmd.append(commit)
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def merge(branch):
+def merge(branch, path=None):
     """ Merge a branch """
 
     cmd = ['merge', branch]
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def abort_merge():
+def abort_merge(path=None):
     """ Abort the current merge """
 
-    return git(['merge', '--abort'])
+    return git(['merge', '--abort'], path=path)
 
 ################################################################################
 
-def set_upstream(branch, upstream=None):
+def set_upstream(branch, upstream=None, path=None):
     """ Set the default upstream branch """
 
     if not upstream:
@@ -254,11 +295,11 @@ def set_upstream(branch, upstream=None):
 
     cmd = ['branch', f'--set-upstream-to={upstream}', branch]
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def fetch(all=False):
+def fetch(all=False, path=None):
     """ Run git fetch """
 
     cmd = ['fetch']
@@ -266,11 +307,11 @@ def fetch(all=False):
     if all:
         cmd.append('--all')
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def rebase_required(branch, parent):
+def rebase_required(branch, parent, path=None):
     """ Return True if the specified branch needs to be rebased against its
         parent.
     """
@@ -278,8 +319,8 @@ def rebase_required(branch, parent):
     # Find the latest commit on the parent branch and the most recent commit
     # that both branches have in common.
 
-    parent_tip = git(['show-ref', '--heads', '-s', parent])
-    common_commit = git(['merge-base', parent, branch])
+    parent_tip = git(['show-ref', '--heads', '-s', parent], path=path)
+    common_commit = git(['merge-base', parent, branch], path=path)
 
     # Different commits, so rebase is required
 
@@ -287,83 +328,77 @@ def rebase_required(branch, parent):
 
 ################################################################################
 
-def rebase(branch):
+def rebase(branch, path=None):
     """ Rebase the current branch against the specified branch """
 
-    return git_run_status(['rebase', branch])
+    return git_run_status(['rebase', branch], path=path)
 
 ################################################################################
 
-def abort_rebase():
+def abort_rebase(path=None):
     """ Abort the current rebase """
 
-    return git(['rebase', '--abort'])
+    return git(['rebase', '--abort'], path=path)
 
 ################################################################################
 
-def rebasing():
+def rebasing(path=None):
     """ Return True if currently rebasing, False otherwise """
 
-    gitdir = git_dir()
+    gitdir = git_dir(path=path)
 
     return os.path.isdir(os.path.join(gitdir, 'rebase-apply')) or \
         os.path.isdir(os.path.join(gitdir, 'rebase-merge'))
 
 ################################################################################
 
-def bisecting():
+def bisecting(path=None):
     """ Return True if currently rebasing, False otherwise """
 
-    gitdir = git_dir()
+    gitdir = git_dir(path=path)
 
     return os.path.isfile(os.path.join(gitdir, 'BISECT_START'))
 
 ################################################################################
 
-def merging():
+def merging(path=None):
     """ Return True if currently merging, False otherwise """
 
-    gitdir = git_dir()
+    gitdir = git_dir(path=path)
 
     return os.path.isfile(os.path.join(gitdir, 'MERGE_MODE'))
 
 ################################################################################
 
-def remotes():
+def remotes(path=None):
     """ Return the list of git remotes """
 
-    results = git(['remote', '-v'])
+    repo = pygit2.Repository(git_dir(path=path))
 
     git_remotes = {}
 
-    for result in results:
-        if result:
-            remote_name, remote_url = result.split('\t')
-
-            if remote_url.endswith(' (fetch)'):
-                remote_url = remote_url[:-8]
-            elif remote_url.endswith(' (push)'):
-                remote_url = remote_url[:-7]
-
-            git_remotes[remote_name] = remote_url
+    for name in repo.remotes.names():
+        git_remotes[name] = repo.remotes[name].url
 
     return git_remotes
 
 ################################################################################
 
-def remote_names():
+def remote_names(path=None):
     """ Return the list of remote names """
 
-    results = git(['remote'])
+    repo = pygit2.Repository(git_dir(path=path))
+
+    results = list(repo.remotes.names())
 
     return results
 
 ################################################################################
 
-def project(short=False):
+def project(short=False, path=None):
     """ Return the name of the current git project """
 
-    git_remotes = remotes()
+    git_remotes = remotes(path=path)
     name = ''
 
     for remote in git_remotes:
@@ -389,7 +424,7 @@ def project(short=False):
 
 ################################################################################
 
-def status_info(ignored=False, untracked=False):
+def status_info(ignored=False, untracked=False, path=None):
     """ Git status, optionally include files ignored in .gitignore and/or
         untracked files.
         Returns data in the same dictionary format as used by commit_info() """
@@ -402,7 +437,7 @@ def status_info(ignored=False, untracked=False):
     if untracked:
         cmd.append('--untracked-files=all')
 
-    results = git(cmd)
+    results = git(cmd, path=path)
 
     # Dictionary of results, indexed by filename where the status is 2 characters
     # the first representing the state of the file in the index and the second the state
@@ -413,12 +448,12 @@ def status_info(ignored=False, untracked=False):
     info = {}
 
     if results:
-        result_list = results[0].split('\0')
+        result = results[0].split('\0')
 
-        for result in result_list:
-            if len(result) > 3 and result[2] == ' ':
-                git_status = result[0:2]
-                name = result[3:]
+        for r in result:
+            if len(r) > 3 and r[2] == ' ':
+                git_status = r[0:2]
+                name = r[3:]
 
                 info[name] = git_status
 
@@ -426,7 +461,7 @@ def status_info(ignored=False, untracked=False):
 
 ################################################################################
 
-def status(ignored=False, untracked=False):
+def status(ignored=False, untracked=False, path=None):
     """ Git status, optionally include files ignored in .gitignore and/or
         untracked files.
         Similar to status_info, but returns data as a list, rather than a
@@ -440,7 +475,7 @@ def status(ignored=False, untracked=False):
     if untracked:
         cmd.append('--untracked-files=all')
 
-    results = git(cmd)
+    results = git(cmd, path=path)
 
     # Nested list of results. For each entry:
     # item 0 is the status where: M=modified, A=added, D=deleted, R=renamed, C=copied, U=unmerged, ?=untracked, !=ignored
@@ -456,6 +491,9 @@ def status(ignored=False, untracked=False):
         stats = []
         stats.append(result[0:2])
 
+        if not untracked and result[0] == '?':
+            continue
+
         name = result[3:]
         if ' -> ' in name:
             stats += name.split(' -> ', 1)
@@ -468,34 +506,39 @@ def status(ignored=False, untracked=False):
 
 ################################################################################
 
-def working_tree():
+def working_tree(path=None):
     """ Location of the current working tree or None if we are not in a working tree """
 
-    try:
-        return git(['rev-parse', '--show-toplevel'])[0]
-    except GitError:
-        return None
+    repo_dir = git_dir(path=path)
+
+    if repo_dir:
+        return os.path.abspath(os.path.join(repo_dir, os.pardir))
+
+    return None
 
 ################################################################################
 
-def git_dir():
+def git_dir(path=None):
     """ Return the relative path to the .git directory """
 
-    return git(['rev-parse', '--git-dir'])[0]
+    if not path:
+        path = os.getcwd()
+
+    return pygit2.discover_repository(path)
 
 ################################################################################
 
-def tree_path(filename):
+def tree_path(filename, path=None):
     """ Normalise a filename (absolute or relative to the current directory)
         so that it is relative to the top-level directory of the working tree """
 
-    git_tree = working_tree()
+    git_tree = working_tree(path=path)
 
     return os.path.relpath(filename, git_tree)
 
 ################################################################################
 
-def difftool(commit_1=None, commit_2=None, files=None, tool=None):
+def difftool(commit_1=None, commit_2=None, files=None, tool=None, path=None):
     """ Run git difftool """
 
     cmd = ['difftool']
@@ -517,7 +560,7 @@ def difftool(commit_1=None, commit_2=None, files=None, tool=None):
         else:
             cmd += files
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
@@ -528,7 +571,7 @@ def difftool(commit_1=None, commit_2=None, files=None, tool=None):
 _DIFF_OUTPUT_RE = re.compile(r'(-|\d+)\s+(-|\d+)\s+(.*)')
 _DIFF_OUTPUT_RENAME_RE = re.compile(r'(.*)\{(.*) => (.*)\}(.*)')
 
-def commit_info(commit_1=None, commit_2=None, paths=None, diff_stats=False):
+def commit_info(commit_1=None, commit_2=None, paths=None, diff_stats=False, path=None):
     """ Return details of changes either in single commit (defaulting to the most
         recent one) or between two commits, optionally restricted a path or paths
         and optionally returning diff statistics, with and/or without taking
@@ -584,7 +627,7 @@ def commit_info(commit_1=None, commit_2=None, paths=None, diff_stats=False):
         else:
             params += paths
 
-    results = git(['diff', '--name-status'] + params)
+    results = git(['diff', '--name-status'] + params, path=path)
 
     # Parse the output
 
@@ -611,7 +654,7 @@ def commit_info(commit_1=None, commit_2=None, paths=None, diff_stats=False):
         # Run git diff to get stats, and add them to the info
         # TODO: Need to extract old name of renamed files
 
-        results = git(['diff', '--numstat'] + params)
+        results = git(['diff', '--numstat'] + params, path=path)
 
         for result in results:
             old_filename, new_filename, lines_ins, lines_del = parse_diff_output(result)
@@ -621,7 +664,7 @@ def commit_info(commit_1=None, commit_2=None, paths=None, diff_stats=False):
 
         # Run git diff to get stats ignoring whitespace changes and add them
 
-        results = git(['diff', '--numstat', '--ignore-all-space', '--ignore-blank-lines'] + params)
+        results = git(['diff', '--numstat', '--ignore-all-space', '--ignore-blank-lines'] + params, path=path)
 
         for result in results:
             old_filename, new_filename, lines_ins, lines_del = parse_diff_output(result)
@@ -642,7 +685,7 @@ def commit_info(commit_1=None, commit_2=None, paths=None, diff_stats=False):
 
 ################################################################################
 
-def diff(commit=None, renames=True, copies=True, relative=False):
+def diff(commit=None, renames=True, copies=True, relative=False, path=None):
     """ Return a list of differences between two commits, working tree and a commit or working tree and head """
 
     if commit:
@@ -668,17 +711,17 @@ def diff(commit=None, renames=True, copies=True, relative=False):
 
     cmd += commit
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def diff_status(commit1, commit2='HEAD'):
+def diff_status(commit1, commit2='HEAD', path=None):
     """ Return True if there is no difference between the two commits, False otherwise """
 
     cmd = ['diff', '--no-patch', '--exit-code', commit1, commit2]
 
     try:
-        git(cmd)
+        git(cmd, path=path)
     except GitError:
         return False
 
@@ -686,30 +729,31 @@ def diff_status(commit1, commit2='HEAD'):
 
 ################################################################################
 
-def show(revision, filename, outfile=None):
+def show(revision, filename, outfile=None, path=None):
     """ Return the output from git show revision:filename """
 
-    return git(['show', f'{revision}:{filename}'], stdout=outfile)
+    return git(['show', f'{revision}:{filename}'], stdout=outfile, path=path)
 
 ################################################################################
 
-def add(files):
+def add(files, path=None):
     """ Add file to git """
 
-    return git(['add'] + files)
+    return git(['add'] + files, path=path)
 
 ################################################################################
 
-def rm(files):
+def rm(files, path=None):
     """ Remove files from git """
 
-    return git(['rm'] + files)
+    return git(['rm'] + files, path=path)
 
 ################################################################################
 
 def commit(files=None,
            message=None,
-           all=False, amend=False, foreground=False, patch=False, dry_run=False):
+           all=False, amend=False, foreground=False, patch=False, dry_run=False,
+           path=None):
     """ Commit files to git """
 
     cmd = ['commit']
@@ -734,16 +778,17 @@ def commit(files=None,
         cmd += ['-m', message]
 
     if foreground:
-        return git(cmd, stdout=sys.stdout, stderr=sys.stderr)
+        return git(cmd, stdout=sys.stdout, stderr=sys.stderr, path=path)
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
 def push(all=False, mirror=False, tags=False, atomic=False, dry_run=False,
          follow_tags=False, receive_pack=False, repo=None, force=False, delete=False,
-         prune=False, verbose=False, set_upstream=False, push_options=[], signed=None,
-         force_with_lease=False, no_verify=False, repository=None, refspec=None):
+         prune=False, verbose=False, set_upstream=False, push_options=None, signed=None,
+         force_with_lease=False, no_verify=False, repository=None, refspec=None,
+         path=None):
     """ Push commits to a remote """
 
     cmd = ['push']
@@ -807,18 +852,18 @@ def push(all=False, mirror=False, tags=False, atomic=False, dry_run=False,
         for ref in refspec:
             cmd.append(ref)
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def reset(sha1):
+def reset(sha1, path=None):
     """ Run git reset """
 
-    return git(['reset', sha1])
+    return git(['reset', sha1], path=path)
 
 ################################################################################
 
-def config_get(section, key, source=None, defaultvalue=None):
+def config_get(section, key, source=None, defaultvalue=None, path=None):
     """ Return the specified configuration entry
         Returns a default value if no matching configuration entry exists """
 
@@ -836,13 +881,13 @@ def config_get(section, key, source=None, defaultvalue=None):
     cmd += ['--get', f'{section}.{key}']
 
     try:
-        return git(cmd)[0]
+        return git(cmd, path=path)[0]
     except GitError:
         return defaultvalue
 
 ################################################################################
 
-def config_set(section, key, value, source=None):
+def config_set(section, key, value, source=None, path=None):
     """ Set a configuration entry """
 
     cmd = ['config']
@@ -858,11 +903,11 @@ def config_set(section, key, value, source=None):
 
     cmd += ['--replace-all', f'{section}.{key}', value]
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def config_rm(section, key, source=LOCAL):
+def config_rm(section, key, source=LOCAL, path=None):
     """ Remove a configuration entry """
 
     cmd = ['config']
@@ -874,11 +919,11 @@ def config_rm(section, key, source=LOCAL):
 
     cmd += ['--unset', f'{section}.{key}']
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def ref(fields=('objectname'), sort=None, remotes=False):
+def ref(fields=('objectname'), sort=None, remotes=False, path=None):
     """ Wrapper for git for-each-ref """
 
     cmd = ['for-each-ref']
@@ -895,12 +940,12 @@ def ref(fields=('objectname'), sort=None, remotes=False):
     if remotes:
         cmd.append('refs/remotes/origin')
 
-    for output in git(cmd):
+    for output in git(cmd, path=path):
         yield output.split('\0')
 
 ################################################################################
 
-def branches(all=False):
+def branches(all=False, path=None):
     """ Return a list of all the branches in the current repo """
 
     cmd = ['branch']
@@ -909,7 +954,7 @@ def branches(all=False):
         cmd.append('--all')
 
     results = []
-    for output in git(cmd):
+    for output in git(cmd, path=path):
         if ' -> ' not in output and '(HEAD detached at ' not in output:
             results.append(output[2:])
 
@@ -917,7 +962,7 @@ def branches(all=False):
 
 ################################################################################
 
-def delete_branch(branch, force=False, remote=False):
+def delete_branch(branch, force=False, remote=False, path=None):
     """ Delete a branch, optionally forcefully and/or including the
         remote tracking branch """
 
@@ -931,11 +976,11 @@ def delete_branch(branch, force=False, remote=False):
 
     cmd.append(branch)
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def remote_prune(remote, dry_run=False):
+def remote_prune(remote, dry_run=False, path=None):
     """ Return a list of remote tracking branches that no longer exist on the
         specified remote """
 
@@ -944,7 +989,7 @@ def remote_prune(remote, dry_run=False):
     if dry_run:
         cmd.append('--dry-run')
 
-    results = git(cmd)
+    results = git(cmd, path=path)
 
     prunable_branches = []
 
@@ -959,43 +1004,43 @@ def remote_prune(remote, dry_run=False):
 
 ################################################################################
 
-def get_commits(commit1, commit2):
+def get_commits(commit1, commit2, path=None):
     """ Get a list of commits separating two commits """
 
-    return git(['rev-list', commit1, f'^{commit2}'])
+    return git(['rev-list', commit1, f'^{commit2}'], path=path)
 
 ################################################################################
 
-def commit_count(commit1, commit2):
+def commit_count(commit1, commit2, path=None):
     """ Get a count of the number of commits between two commits """
 
-    return int(git(['rev-list', '--count', commit1, f'^{commit2}'])[0])
+    return int(git(['rev-list', '--count', commit1, f'^{commit2}'], path=path)[0])
 
 ################################################################################
 
-def branch_name(branch):
+def branch_name(branch, path=None):
     """ Return the full name of a branch given an abbreviation - e.g. @{upstream}
         for the upstream branch """
 
-    return git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', branch])[0]
+    return git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', branch], path=path)[0]
 
 ################################################################################
 
-def author(commit):
+def author(commit, path=None):
     """ Return the author of a commit """
 
-    return git(['show', '--format=format:%an', commit])[0]
+    return git(['show', '--format=format:%an', commit], path=path)[0]
 
 ################################################################################
 
-def commit_changes(commit='HEAD'):
+def commit_changes(commit='HEAD', path=None):
     """Return a list of the files changed in a commit"""
 
-    return git(['show', '--name-only', '--pretty=format:', commit])
+    return git(['show', '--name-only', '--pretty=format:', commit], path=path)
 
 ################################################################################
 
-def files(dir=None):
+def files(dir=None, path=None):
     """ Return the output from 'git ls-files' """
 
     cmd = ['ls-files']
@@ -1003,20 +1048,20 @@ def files(dir=None):
     if dir:
         cmd.append(dir)
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def stash():
+def stash(path=None):
     """ Return the list of stashed items (if any) """
 
     cmd = ['stash', 'list']
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def parents(commit=None, ignore=None):
+def parents(commit=None, ignore=None, path=None):
     """ Look at the commits down the history of the specified branch,
         looking for another branch or branches that also contain the same commit.
         The first found is the parent (or equally-likely parents) of the
@@ -1028,16 +1073,16 @@ def parents(commit=None, ignore=None):
 
     # Get the history of the branch
 
-    current_branch = commit or branch('HEAD')
+    current_branch = commit or branch('HEAD', path=path)
 
-    current_history = git(['rev-list', current_branch])
+    current_history = git(['rev-list', current_branch], path=path)
 
     # Look down the commits on the current branch for other branches that have
     # the same commit, using the ignore pattern if there is one.
 
     for distance, ancestor in enumerate(current_history):
         branches = []
-        for brnch in git(['branch', '--contains', ancestor]):
+        for brnch in git(['branch', '--contains', ancestor], path=path):
             brnch = brnch[2:]
             if brnch != current_branch and '(HEAD detached at' not in brnch:
                 if not ignore or (ignore and not fnmatch.fnmatch(brnch, ignore)):
@@ -1052,13 +1097,11 @@ def parents(commit=None, ignore=None):
 
 ################################################################################
 
-def find_common_ancestor(branch1='HEAD', branch2='master'):
+def find_common_ancestor(branch1='HEAD', branch2='master', path=None):
     """ Find the first (oldest) commit that the two branches have in common
         i.e. the point where one branch was forked from the other """
 
-    common = git(['merge-base', branch1, branch2])[0]
-
-    return common
+    return git(['merge-base', branch1, branch2], path=path)[0]
 
 ################################################################################
 
@@ -1068,7 +1111,7 @@ _GREP_OPTLIST = \
     (
         ('color', '--color=always'),
         ('count', '--count'),
-        ('folow', '--follow'),
+        ('follow', '--follow'),
         ('unmatch', '-I'),
         ('textconf', '--textconv'),
         ('ignore_case', '--ignore-case'),
@@ -1084,10 +1127,8 @@ _GREP_OPTLIST = \
         ('files_without_match', '--files-without-match'),
         ('names_only', '--names-only'),
         ('null', '--null'),
-        ('count', '--count'),
         ('all_match', '--all-match'),
         ('quiet', '--quiet'),
-        ('color', '--color=always'),
         ('no_color', '--no-color'),
         ('break', '--break'),
         ('heading', '--heading'),
@@ -1110,7 +1151,7 @@ _GREP_NON_BOOL_OPTLIST = \
         ('parent_basename', '--parent-basename')
     )
 
-def grep(pattern, git_dir=None, work_tree=None, options=None, wildcards=None):
+def grep(pattern, git_dir=None, work_tree=None, options=None, wildcards=None, path=None):
     """ Run git grep - takes a painfully large number of options passed
         as a dictionary. """
 
@@ -1147,30 +1188,30 @@ def grep(pattern, git_dir=None, work_tree=None, options=None, wildcards=None):
         cmd.append('--')
         cmd += wildcards
 
-    return git_run_status(cmd)
+    return git_run_status(cmd, path=path)
 
 ################################################################################
 
-def isbranch(branchname):
+def isbranch(branchname, path=None):
     """ Return true if the specified branch exists """
 
-    return branchname in branches(True)
+    return branchname in branches(True, path=path)
 
 ################################################################################
 
-def default_branch():
+def default_branch(path=None):
     """ Return the name of the default branch, attempting to interrogate GitLab
         if the repo appears to have been cloned from there and falling back to
         returning whichever one of 'develop', 'main' or 'master' exists. """
 
-    remote_list = remotes()
+    remote_list = remotes(path=path)
     if remote_list:
         for name in remote_list:
             if 'gitlab' in remote_list[name]:
                 url = remote_list[name].split('@')[1].split(':')[0]
                 repo = remote_list[name].split(':')[1]
 
-                if not url.startswith('http://') or not url.startswith('https://'):
+                if not url.startswith('http://') and not url.startswith('https://'):
                     url = f'https://{url}'
 
                 if repo.endswith('.git'):
@@ -1183,8 +1224,8 @@ def default_branch():
                 except gitlab.GitLabError:
                     return None
 
-    git_branches = branches()
-    default_branches = config_get('skilleter-thingy', 'defaultBranches', defaultvalue=DEFAULT_DEFAULT_BRANCHES).split(',')
+    git_branches = branches(path=path)
+    default_branches = config_get('skilleter-thingy', 'defaultBranches', defaultvalue=DEFAULT_DEFAULT_BRANCHES, path=path).split(',')
 
     for branch in default_branches:
         if branch in git_branches:
@@ -1194,7 +1235,7 @@ def default_branch():
 
 ################################################################################
 
-def matching_branch(branchname, case=False):
+def matching_branch(branchname, case=False, path=None):
     """ Look for a branch matching the specified name and return it
         out if it is an exact match or there is only one partial
         match. If there are multiple branches that match, return them
@@ -1206,7 +1247,7 @@ def matching_branch(branchname, case=False):
         otherwise, it just checks for a branches containing the branchname
         as a substring. """
 
-    all_branches = branches(all=True)
+    all_branches = branches(all=True, path=path)
 
     # Always return exact matches
 
@@ -1258,7 +1299,7 @@ def matching_branch(branchname, case=False):
 
 ################################################################################
 
-def update(clean=False, all=False):
+def update(clean=False, all=False, path=None):
     """ Run git update (which is a thingy command, and may end up as a module
         but for the moment, we'll treat it as any other git command) """
 
@@ -1270,18 +1311,18 @@ def update(clean=False, all=False):
     if all:
         cmd.append('--all')
 
-    return git(cmd)
+    return git(cmd, path=path)
 
 ################################################################################
 
-def object_type(name):
+def object_type(name, path=None):
     """ Return the git object type (commit, tag, blob, ...) """
 
-    return git(['cat-file', '-t', name])[0]
+    return git(['cat-file', '-t', name], path=path)[0]
 
 ################################################################################
 
-def matching_commit(name):
+def matching_commit(name, path=None):
     """ Similar to matching_branch() (see above).
         If the name uniquely matches a branch, return that
         If it matches multiple branches return a list
@@ -1292,12 +1333,12 @@ def matching_commit(name):
 
     # First, look for exact matching object
 
-    if iscommit(name):
+    if iscommit(name, path=path):
         return [name]
 
     # Look for at least one matching branch
 
-    matches = matching_branch(name)
+    matches = matching_branch(name, path=path)
 
     if matches:
         return matches
@@ -1305,7 +1346,7 @@ def matching_commit(name):
     # Look for at least one matching tag
 
     matches = []
-    for tag in tags():
+    for tag in tags(path=path):
         if name in tag:
             matches.append(tag)
 
@@ -1315,7 +1356,7 @@ def matching_commit(name):
     # Look for a matching commit
 
     try:
-        commit_type = object_type(name)
+        commit_type = object_type(name, path=path)
 
         if commit_type == 'commit':
             matches = [name]
@@ -1326,7 +1367,7 @@ def matching_commit(name):
 
 ################################################################################
 
-def log(branch1, branch2=None):
+def log(branch1, branch2=None, path=None):
     """ Return the git log between the given commits """
 
     if branch2:
@@ -1334,7 +1375,38 @@ def log(branch1, branch2=None):
     else:
         cmd = ['log', '-n1', branch1]
 
-    return git(cmd)
+    return git(cmd, path=path)
+
+################################################################################
+
+def clean(recurse=False, force=False, dry_run=False, quiet=False,
+          exclude=None, ignore_rules=False, remove_only_ignored=False, path=None):
+    """ Run git clean """
+
+    cmd = ['clean']
+
+    if recurse:
+        cmd.append('-d')
+
+    if force:
+        cmd.append('--force')
+
+    if dry_run:
+        cmd.append('--dry-run')
+
+    if quiet:
+        cmd.append('--quiet')
+
+    if exclude:
+        cmd += ['--exclude', exclude]
+
+    if ignore_rules:
+        cmd.append('-x')
+
+    if remove_only_ignored:
+        cmd.append('-X')
+
+    return git(cmd, path=path)
 
 ################################################################################
 
@@ -1376,7 +1448,7 @@ def run_tests():
 
         print('')
 
-        with open('newfile.txt', 'w') as newfile:
+        with open('newfile.txt', 'w', encoding='utf8') as newfile:
             newfile.write('THIS IS A TEST')
 
         print('Adding and committing "newfile.txt"')
@@ -1398,7 +1470,7 @@ def run_tests():
         print('Commit info for HEAD  %s' % commit_info('HEAD'))
 
     except GitError as exc:
-        sys.stderr.write('ERROR: %s' % exc.msg)
+        sys.stderr.write(f'ERROR: {exc.msg}')
         sys.exit(1)
 
     finally: