Merge branch 'develop'

feat: Return an error if the remote type cannot be detected

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: hakoerber

CONTRIBUTING.md

@@ -1,49 +1,3 @@
-# Contributing
-
-GRM is still in very early development. I started GRM mainly to scratch my own
-itches (and am heavily dogfooding it). If you have a new use case for GRM, go
-for it!
-
-The branching strategy is a simplified
-[git-flow](https://nvie.com/posts/a-successful-git-branching-model/).
-
-* `master` is the "production" branch. Each commit is a new release.
-* `develop` is the branch where new stuff is coming in.
-* feature branches branch off of `develop` and merge back into it.
-
-So to contribute, just fork the repo and create a pull request against
-`develop`. If you plan bigger changes, please consider opening an issue first,
-so we can discuss it.
-
-If you want, add yourself to the `CONTRIBUTORS` file in your pull request.
-
-## Code formatting
-
-For Rust, just use `cargo fmt`. For Python, use
-[black](https://github.com/psf/black). I'd rather not spend any effort in
-configuring the formatters (not possible for black anyway).
-
-## Tooling
-
-GRM uses [`just`](https://github.com/casey/just) as a command runner. See
-[here](https://github.com/casey/just#installation) for installation
-instructions (it's most likely just a simple `cargo install just`).
-
-## Testing
-
-There are two distinct test suites: One for unit test (`just test-unit`) and
-integration tests (`just test-integration`) that is part of the rust crate, and
-a separate e2e test suite in python (`just test-e2e`).
-
-To run all tests, run `just test`.
-
-When contributing, consider whether it makes sense to add tests which could
-prevent regressions in the future. When fixing bugs, it makes sense to add
-tests that expose the wrong behaviour beforehand.
-
-## Documentation
-
-The documentation lives in `docs` and uses
-[mdBook](https://github.com/rust-lang/mdBook). Please document new user-facing
-features here!
-
+Check out [the developer
+documentation](https://hakoerber.github.io/git-repo-manager/developing.html) it
+you want to contribute!

CONTRIBUTORS

@@ -1 +1,3 @@
 nonnominandus
+Maximilian Volk
+Baptiste (@BapRx)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "git-repo-manager"
-version = "0.7.2"
+version = "0.7.14"
 edition = "2021"
 
 authors = [
@@ -23,12 +23,12 @@ repository = "https://github.com/hakoerber/git-repo-manager"
 readme = "README.md"
 
 # Required for `std::path::Path::is_symlink()`. Will be released with 1.57.
-rust-version = "1.57"
+rust-version = "1.58"
 
 license = "GPL-3.0-only"
 
 [profile.e2e-tests]
-inherits = "release"
+inherits = "dev"
 
 [lib]
 name = "grm"
@@ -41,36 +41,36 @@ path = "src/grm/main.rs"
 [dependencies]
 
 [dependencies.toml]
-version = "=0.5.9"
+version = "=0.7.6"
 
 [dependencies.serde]
-version = "=1.0.137"
+version = "=1.0.183"
 features = ["derive"]
 
 [dependencies.git2]
-version = "=0.14.4"
+version = "=0.17.2"
 
 [dependencies.shellexpand]
-version = "=2.1.0"
+version = "=3.1.0"
 
 [dependencies.clap]
-version = "=3.1.18"
+version = "=4.3.21"
 features = ["derive", "cargo"]
 
 [dependencies.console]
-version = "=0.15.0"
+version = "=0.15.7"
 
 [dependencies.regex]
-version = "=1.5.6"
+version = "=1.9.3"
 
 [dependencies.comfy-table]
-version = "=6.0.0"
+version = "=7.0.1"
 
 [dependencies.serde_yaml]
-version = "=0.8.24"
+version = "=0.9.25"
 
 [dependencies.serde_json]
-version = "=1.0.81"
+version = "=1.0.104"
 
 [dependencies.isahc]
 version = "=1.7.2"
@@ -78,7 +78,7 @@ default-features = false
 features = ["json", "http2", "text-decoding"]
 
 [dependencies.parse_link_header]
-version = "=0.3.2"
+version = "=0.3.3"
 
 [dependencies.url-escape]
 version = "=0.1.1"

Justfile

@@ -1,65 +1,89 @@
 set positional-arguments
 
-target := "x86_64-unknown-linux-musl"
+set shell := ["/bin/bash", "-c"]
+
+static_target := "x86_64-unknown-linux-musl"
+
+cargo := "cargo"
 
 check: fmt-check lint test
-    cargo check
-    cargo fmt --check
-    cargo clippy --no-deps -- -Dwarnings
+    {{cargo}} check
+
+clean:
+    {{cargo}} clean
+    git clean -f -d -X
 
 fmt:
-    cargo fmt
+    {{cargo}} fmt
+    git ls-files | grep '\.py$' | xargs isort
     git ls-files | grep '\.py$' | xargs black
+    git ls-files | grep '\.sh$' | xargs -L 1 shfmt --indent 4 --write
 
 fmt-check:
-    cargo fmt --check
+    {{cargo}} fmt --check
     git ls-files | grep '\.py$' | xargs black --check
+    git ls-files | grep '\.sh$' | xargs -L 1 shfmt --indent 4 --diff
 
 lint:
-    cargo clippy --no-deps -- -Dwarnings
+    {{cargo}} clippy --no-deps -- -Dwarnings
+    git ls-files | grep '\.py$' | xargs ruff --ignore E501
+    git ls-files | grep '\.sh$' | xargs -L 1 shellcheck --norc
 
 lint-fix:
-    cargo clippy --no-deps --fix
+    {{cargo}} clippy --no-deps --fix
 
-release:
-    cargo build --release --target {{target}}
+build-release:
+    {{cargo}} build --release
+
+build-release-static:
+    {{cargo}} build --release --target {{static_target}} --features=static-build
+
+pushall:
+    for r in $(git remote) ; do \
+        for branch in develop master ; do \
+            git push $r $branch ; \
+        done ; \
+    done
+
+release-patch:
+    ./release.sh patch
 
 test-binary:
     env \
         GITHUB_API_BASEURL=http://rest:5000/github \
         GITLAB_API_BASEURL=http://rest:5000/gitlab \
-        cargo build --target {{target}} --profile e2e-tests --features=static-build
+        {{cargo}} build --profile e2e-tests --target {{static_target}} --features=static-build
 
 install:
-    cargo install --path .
+    {{cargo}} install --path .
 
 install-static:
-    cargo install --target {{target}} --features=static-build --path .
+    {{cargo}} install --target {{static_target}} --features=static-build --path .
 
 build:
-    cargo build
+    {{cargo}} build
 
 build-static:
-    cargo build --target {{target}} --features=static-build
+    {{cargo}} build --target {{static_target}} --features=static-build
 
 test: test-unit test-integration test-e2e
 
 test-unit +tests="":
-    cargo test --lib --bins -- --show-output {{tests}}
+    {{cargo}} test --lib --bins -- --show-output {{tests}}
 
 test-integration:
-    cargo test --test "*"
+    {{cargo}} test --test "*"
 
 test-e2e +tests=".": test-binary
     cd ./e2e_tests \
-    && docker-compose rm --stop -f \
-    && docker-compose build \
-    && docker-compose run \
+    && docker compose rm --stop -f \
+    && docker compose build \
+    && docker compose run \
         --rm \
-        -v $PWD/../target/{{target}}/e2e-tests/grm:/grm \
+        -v $PWD/../target/x86_64-unknown-linux-musl/e2e-tests/grm:/grm \
             pytest \
-            "GRM_BINARY=/grm ALTERNATE_DOMAIN=alternate-rest python3 -m pytest -p no:cacheprovider --color=yes "$@"" \
-    && docker-compose rm --stop -f
+            "GRM_BINARY=/grm ALTERNATE_DOMAIN=alternate-rest python3 -m pytest --exitfirst -p no:cacheprovider --color=yes "$@"" \
+    && docker compose rm --stop -f
 
 update-dependencies: update-cargo-dependencies
 
@@ -69,3 +93,6 @@ update-cargo-dependencies:
     && . ./venv/bin/activate \
     && pip --disable-pip-version-check install -r ./requirements.txt > /dev/null \
     && ./update-cargo-dependencies.py
+
+wait:
+    read -p "[ENTER] to continue "

README.md

@@ -1,7 +1,10 @@
 # GRM — Git Repository Manager
 
 GRM helps you manage git repositories in a declarative way. Configure your
-repositories in a [TOML](https://toml.io/) file, GRM does the rest.
+repositories in a [TOML](https://toml.io/) or YAML file, GRM does the rest.
+
+Also, GRM can be used to work with git worktrees in an opinionated,
+straightforward fashion.
 
 **Take a look at the [official documentation](https://hakoerber.github.io/git-repo-manager/)
 for installation & quickstart.**
@@ -34,23 +37,26 @@ like Terraform for your local git repositories. Write a config, run the tool, an
 your repos are ready. The only thing that is tracked by git it the list of
 repositories itself.
 
-# Future & Ideas
-
-* Operations over all repos (e.g. pull)
-* Show status of managed repositories (dirty, compare to remotes, ...)
-
-# Optional Features
-
-* Support multiple file formats (YAML, JSON).
-* Add systemd timer unit to run regular syncs
-
 # Crates
 
-* [`toml`](https://docs.rs/toml/) for the configuration file
-* [`serde`](https://docs.rs/serde/) because we're using Rust, after all
-* [`git2`](https://docs.rs/git2/), a safe wrapper around `libgit2`, for all git operations
-* [`clap`](https://docs.rs/clap/), [`console`](https://docs.rs/console/) and [`shellexpand`](https://docs.rs/shellexpand) for good UX
+* [`toml`](https://docs.rs/toml/) for the configuration file.
+* [`serde`](https://docs.rs/serde/), together with
+  [`serde_yaml`](https://docs.rs/serde_yaml/) and
+  [`serde_json`](https://docs.rs/serde_json/). Because we're using Rust, after
+  all.
+* [`git2`](https://docs.rs/git2/), a safe wrapper around `libgit2`, for all git operations.
+* [`clap`](https://docs.rs/clap/), [`console`](https://docs.rs/console/), [`comfy_table`](https://docs.rs/comfy-table/) and [`shellexpand`](https://docs.rs/shellexpand) for good UX.
+* [`isahc`](https://docs.rs/isahc/) as the HTTP client for forge integrations.
 
 # Links
 
 * [crates.io](https://crates.io/crates/git-repo-manager)
+
+# Mirrors
+
+This repository can be found on multiple forges:
+
+* https://github.com/hakoerber/git-repo-manager
+* https://code.hkoerber.de/hannes/git-repo-manager/
+* https://codeberg.org/hakoerber/git-repo-manager
+* https://git.sr.ht/~hkoerber/git-repo-manager

depcheck/update-cargo-dependencies.py

@@ -1,9 +1,8 @@
 #!/usr/bin/env python3
 
-import subprocess
-import os
 import json
-import sys
+import os
+import subprocess
 
 import semver
 import tomlkit
@@ -94,15 +93,7 @@ for tier in ["dependencies", "dev-dependencies"]:
 
             try:
                 cmd = subprocess.run(
-                    [
-                        "cargo",
-                        "update",
-                        "-Z",
-                        "no-index-update",
-                        "--aggressive",
-                        "--package",
-                        name,
-                    ],
+                    ["cargo", "update", "--offline", "--aggressive", "--package", name],
                     check=True,
                     capture_output=True,
                     text=True,
@@ -136,15 +127,7 @@ while True:
         spec = f"{package['name']}:{package['version']}"
         try:
             cmd = subprocess.run(
-                [
-                    "cargo",
-                    "update",
-                    "-Z",
-                    "no-index-update",
-                    "--aggressive",
-                    "--package",
-                    spec,
-                ],
+                ["cargo", "update", "--offline", "--aggressive", "--package", spec],
                 check=True,
                 capture_output=True,
                 text=True,

docs/book.toml

@@ -7,3 +7,8 @@ title = "Git Repo Manager"
 
 [output.html]
 mathjax-support = true
+
+# [output.linkcheck]
+# follow-web-links = true
+# traverse-parent-directories = false
+# warning-policy = "error"

docs/src/SUMMARY.md

@@ -1,9 +1,20 @@
 # Summary
 
-- [Overview](./overview.md)
+[Overview](./overview.md)
+
 - [Installation](./installation.md)
-- [Repository trees](./repos.md)
+- [Tutorial](./tutorial.md)
+- [Managing Repositories](./repos.md)
+  - [Local Configuration](./local_configuration.md)
+  - [Forge Integrations](./forge_integration.md)
 - [Git Worktrees](./worktrees.md)
-- [Forge Integrations](./forge_integration.md)
+  - [Working with Worktrees](./worktree_working.md)
+  - [Worktrees and Remotes](./worktree_remotes.md)
+  - [Behavior Details](./worktree_behavior.md)
 - [FAQ](./faq.md)
-- [Contributing](./contributing.md)
+- [Developer Documentation](./developing.md)
+  - [Testing](./testing.md)
+  - [Dependency updates](./dependency_updates.md)
+  - [Releases](./releases.md)
+  - [Formatting & Style](./formatting_and_style.md)
+  - [The Docs Themselves](./documentation.md)

docs/src/contributing.md

@@ -1 +0,0 @@
-../../CONTRIBUTING.md

docs/src/dependency_updates.md

@@ -0,0 +1,10 @@
+# Dependency updates
+
+Rust has the same problem as the node ecosystem, just a few magnitudes smaller:
+Dependency sprawl. GRM has a dozen direct dependencies, but over 150 transitive
+ones.
+
+To keep them up to date, there is a script:
+`depcheck/update-cargo-dependencies.py`. It updates direct dependencies to the
+latest stable version and updates transitive dependencies where possible. To run
+it, use `just update-dependencies`, which will create commits for each update.

docs/src/developing.md

@@ -0,0 +1,54 @@
+# Overview
+
+GRM is still in very early development. I started GRM mainly to scratch my own
+itches (and am heavily dogfooding it). If you have a new use case for GRM, go
+for it!
+
+## Contributing
+
+To contribute, just fork the repo and create a pull request against `develop`.
+If you plan bigger changes, please consider opening an issue first, so we can
+discuss it.
+
+If you want, add yourself to the `CONTRIBUTORS` file in your pull request.
+
+## Branching strategy
+
+The branching strategy is a simplified
+[git-flow](https://nvie.com/posts/a-successful-git-branching-model/).
+
+* `master` is the "production" branch. Each commit is a new release.
+* `develop` is the branch where new stuff is coming in.
+* feature branches branch off of `develop` and merge back into it.
+
+Feature branches are not required, there are also changes happening directly on
+`develop`.
+
+## Required tooling
+
+You will need the following tools:
+
+* Rust (obviously) (easiest via `rustup`)
+* Python3
+* [`just`](https://github.com/casey/just), a command runner like `make`. See
+  [here](https://github.com/casey/just#installation) for installation
+  instructions (it's most likely just a simple `cargo install just`).
+* Docker & docker-compose for the e2e tests
+* `isort`, `black` and `shfmt` for formatting.
+* `ruff` and `shellcheck` for linting.
+* `mdbook` for the documentation
+
+Here are the tools:
+
+| Distribution  | Command                                                                                             |
+| ------------- | --------------------------------------------------------------------------------------------------- |
+| Arch Linux    | `pacman -S --needed python3 rustup just docker docker-compose python-black shfmt shellcheck mdbook` |
+| Ubuntu/Debian | `apt-get install --no-install-recommends python3 docker.io docker-compose black shellcheck`         |
+
+Note that you will have to install `just` and `mdbook` manually on Ubuntu (e.g.
+via `cargo install just mdbook` if your rust build environment is set up
+correctly). Same for `shfmt`, which may just be a `go install
+mvdan.cc/sh/v3/cmd/shfmt@latest`, depending on your go build environment.
+
+For details about rustup and the toolchains, see [the installation
+section](./installation.md).

docs/src/documentation.md

@@ -0,0 +1,11 @@
+# Documentation
+
+The documentation lives in the `docs` folder and uses
+[mdBook](https://github.com/rust-lang/mdBook). Please document new user-facing
+features here!
+
+Using [GitHub actions](https://github.com/features/actions), the documentation
+on `master` is automatically published to [the project
+homepage](https://hakoerber.github.io/git-repo-manager/) via GitHub pages. See
+`.github/workflows/gh-pages.yml` for the configuration of GitHub Actions.
+

docs/src/faq.md

@@ -1,10 +1,3 @@
 # FAQ
 
-## Why is the nightly toolchain required?
-
-Building GRM currently requires nightly features due to the usage of
-[`std::path::Path::is_symlink()`](https://doc.rust-lang.org/std/fs/struct.FileType.html#method.is_symlink).
-See the [tracking issue](https://github.com/rust-lang/rust/issues/85748).
-
-`is_symlink()` is actually available in rustc 1.57, so it will be on stable in
-the near future. This would mean that GRM can be built using the stable toolchain!
+Currently empty, as there are no questions that are asked frequently :D

docs/src/forge_integration.md

@@ -1,19 +1,20 @@
 # Forge Integrations
 
-In addition to manging repositories locally, `grm` also integrates with source
+In addition to managing repositories locally, `grm` also integrates with source
 code hosting platforms. Right now, the following platforms are supported:
 
 * [GitHub](https://github.com/)
 * [GitLab](https://gitlab.com/)
 
-Imagine you are just starting out with `grm` and want to clone all your repositories
-from GitHub. This is as simple as:
+Imagine you are just starting out with `grm` and want to clone all your
+repositories from GitHub. This is as simple as:
 
 ```bash
 $ grm repos sync remote --provider github --owner --token-command "pass show github_grm_access_token" --path ~/projects
 ```
 
-You will end up with your projects cloned into `~/projects/{your_github_username}/`
+You will end up with your projects cloned into
+`~/projects/{your_github_username}/`
 
 ## Authentication
 
@@ -34,8 +35,8 @@ See the GitLab documentation for personal access tokens:
 
 The required scopes are a bit weird. Actually, the following should suffice:
 
-* * `read_user` to get user information (required to get the current authenticated
-  user name for the `--owner` filter.
+* `read_user` to get user information (required to get the current
+  authenticated user name for the `--owner` filter.
 * A scope that allows reading private repositories. (`read_repository` is just
   for *cloning* private repos). This unfortunately does not exist.
 
@@ -106,7 +107,7 @@ The options in the file map to the command line options of the `grm repos sync
 remote` command.
 
 You'd then run the `grm repos sync` command the same way as with a list of
-repositories in a config:
+repositories in a configuration:
 
 ```bash
 $ grm repos sync --config example.config.toml
@@ -120,11 +121,11 @@ $ grm repos find config --config example.config.toml > repos.toml
 $ grm repos sync config --config repos.toml
 ```
 
-## Using with selfhosted GitLab
+## Using with self-hosted GitLab
 
 By default, `grm` uses the default GitLab API endpoint
-([https://gitlab.com](https://gitlab.com)). You can override the
-endpoint by specifying the `--api-url` parameter. Like this:
+([https://gitlab.com](https://gitlab.com)). You can override the endpoint by
+specifying the `--api-url` parameter. Like this:
 
 ```bash
 $ grm repos sync remote --provider gitlab --api-url https://gitlab.example.com [...]
@@ -138,26 +139,28 @@ can be overridden with the `--force-ssh` switch.
 ## About the token command
 
 To ensure maximum flexibility, `grm` has a single way to get the token it uses
-to authenticate: Specify a command that returns the token via stdout. This easily
-integrates with password managers like [`pass`](https://www.passwordstore.org/).
+to authenticate: Specify a command that returns the token via stdout. This
+easily integrates with password managers like
+[`pass`](https://www.passwordstore.org/).
 
 Of course, you are also free to specify something like `echo mytoken` as the
-command, as long as you are ok with the security implications (like having the
-token in cleartext in your shell history). It may be better to have the token
+command, as long as you are OK with the security implications (like having the
+token in clear text in your shell history). It may be better to have the token
 in a file instead and read it: `cat ~/.gitlab_token`.
 
-Generally, use whatever you want. The command just has to return sucessfully and
-return the token as the first line of stdout.
+Generally, use whatever you want. The command just has to return successfully
+and return the token as the first line of stdout.
 
 ## Examples
 
-Maybe you just want to locally clone all repos from your github user?
+Maybe you just want to locally clone all repos from your GitHub user?
 
 ```bash
 $ grm repos sync remote --provider github --owner --root ~/github_projects --token-command "pass show github_grm_access_token"
 ```
 
-This will clone all repositories into `~/github_projects/{your_github_username}`.
+This will clone all repositories into
+`~/github_projects/{your_github_username}`.
 
 If instead you want to clone **all** repositories you have access to (e.g. via
 organizations or other users' private repos you have access to), just change the
@@ -172,12 +175,13 @@ $ grm repos sync remote --provider github --access --root ~/github_projects --to
 ### GitHub
 
 Unfortunately, GitHub does not have a nice API endpoint to get **private**
-repositories for a certain user ([`/users/{user}/repos/`](https://docs.github.com/en/rest/repos/repos#list-repositories-for-a-user) only returns public
-repositories).
+repositories for a certain user
+([`/users/{user}/repos/`](https://docs.github.com/en/rest/repos/repos#list-repositories-for-a-user)
+only returns public repositories).
 
 Therefore, using `--user {user}` will only show public repositories for GitHub.
-Note that this does not apply to `--access`: If you have access to another user's
-private repository, it will be listed.
+Note that this does not apply to `--access`: If you have access to another
+user's private repository, it will be listed.
 
 ## Adding integrations
 
@@ -197,9 +201,9 @@ Each repo has to have the following properties:
 
 * A name (which also acts as the identifier for diff between local and remote
   repositories)
-* An SSH url to push to
-* An HTTPS url to clone and fetch from
+* An SSH URL to push to
+* An HTTPS URL to clone and fetch from
 * A flag that marks the repository as private
 
-If you plan to implement another forge, please first open an issue so we can
-go through the required setup. I'm happy to help!
+If you plan to implement another forge, please first open an issue so we can go
+through the required setup. I'm happy to help!

docs/src/formatting_and_style.md

@@ -0,0 +1,45 @@
+# Formatting & Style
+
+## Code formatting
+
+I'm allergic to discussions about formatting. I'd rather make the computer do it
+for me.
+
+For Rust, just use `cargo fmt`. For Python, use
+[black](https://github.com/psf/black). I'd rather not spend any effort in
+configuring the formatters (not possible for black anyway). For shell scripts,
+use [`shfmt`](https://github.com/mvdan/sh).
+
+To autoformat all code, use `just fmt`
+
+## Style
+
+Honestly, no idea about style. I'm still learning Rust, so I'm trying to find a
+good style. Just try to keep it consistent when you add code.
+
+## Linting
+
+You can use `just lint` to run all lints.
+
+### Rust
+
+Clippy is the guard that prevents shitty code from getting into the code base.
+When running `just check`, any clippy suggestions will make the command fail.
+So make clippy happy! The easiest way:
+
+* Commit your changes (so clippy can change safely).
+* Run `cargo clippy --fix` to do the easy changes automatically.
+* Run `cargo clippy` and take a look at the messages.
+
+Until now, I had no need to override or silence any clippy suggestions.
+
+### Shell
+
+`shellcheck` lints all shell scripts. As they change very rarely, this is not
+too important.
+
+## Unsafe code
+
+Any `unsafe` code is forbidden for now globally via `#![forbid(unsafe_code)]`.
+I cannot think of any reason GRM may need `unsafe`. If it comes up, it needs to
+be discussed.

docs/src/installation.md

@@ -2,43 +2,44 @@
 
 ## Installation
 
-Building GRM currently requires the nightly Rust toolchain. The easiest way
-is using [`rustup`](https://rustup.rs/). Make sure that rustup is properly installed.
+Building GRM requires the Rust toolchain to be installed. The easiest way is
+using [`rustup`](https://rustup.rs/). Make sure that rustup is properly
+installed.
 
-Make sure that the nightly toolchain is installed:
+Make sure that the stable toolchain is installed:
 
 ```
-$ rustup toolchain install nightly
+$ rustup toolchain install stable
 ```
 
 Then, install the build dependencies:
 
 | Distribution  | Command                                                                        |
 | ------------- | ------------------------------------------------------------------------------ |
-| Archlinux     | `pacman -S --needed gcc openssl pkg-config`                                    |
+| Arch Linux    | `pacman -S --needed gcc openssl pkg-config`                                    |
 | Ubuntu/Debian | `apt-get install --no-install-recommends pkg-config gcc libssl-dev zlib1g-dev` |
 
 Then, it's a simple command to install the latest stable version:
 
 ```bash
-$ cargo +nightly install git-repo-manager
+$ cargo install git-repo-manager
 ```
 
 If you're brave, you can also run the development build:
 
 ```bash
-$ cargo +nightly install --git https://github.com/hakoerber/git-repo-manager.git --branch develop
+$ cargo install --git https://github.com/hakoerber/git-repo-manager.git --branch develop
 ```
 
 ## Static build
 
 Note that by default, you will get a  dynamically linked executable.
-Alternatively, you can also build a statically linked binary. For this, you
-will need `musl` and a few other build dependencies installed installed:
+Alternatively, you can also build a statically linked binary. For this, you will
+need `musl` and a few other build dependencies installed installed:
 
 | Distribution  | Command                                                                     |
 | ------------- | --------------------------------------------------------------------------- |
-| Archlinux     | `pacman -S --needed gcc musl perl make`                                     |
+| Arch Linux    | `pacman -S --needed gcc musl perl make`                                     |
 | Ubuntu/Debian | `apt-get install --no-install-recommends gcc musl-tools libc-dev perl make` |
 
 (`perl` and `make` are required for the OpenSSL build script)
@@ -46,11 +47,11 @@ will need `musl` and a few other build dependencies installed installed:
 The, add the musl target via `rustup`:
 
 ```
-$ rustup +nightly target add x86_64-unknown-linux-musl
+$ rustup target add x86_64-unknown-linux-musl
 ```
 
 Then, use a modified build command to get a statically linked binary:
 
 ```
-$ cargo +nightly install git-repo-manager --target x86_64-unknown-linux-musl --features=static-build
+$ cargo install git-repo-manager --target x86_64-unknown-linux-musl --features=static-build
 ```

docs/src/local_configuration.md

@@ -0,0 +1,90 @@
+# Local Configuration
+
+When managing multiple git repositories with GRM, you'll generally have a
+configuration file containing information about all the repos you have. GRM then
+makes sure that you repositories match that configuration. If they don't exist
+yet, it will clone them. It will also make sure that all remotes are configured
+properly.
+
+Let's try it out:
+
+## Get the example configuration
+
+```bash
+curl --proto '=https' --tlsv1.2 -sSfO https://raw.githubusercontent.com/hakoerber/git-repo-manager/master/example.config.toml
+```
+
+Then, you're ready to run the first sync. This will clone all configured
+repositories and set up the remotes.
+
+```bash
+$ grm repos sync config --config example.config.toml
+[⚙] Cloning into "/home/me/projects/git-repo-manager" from "https://code.hkoerber.de/hannes/git-repo-manager.git"
+[✔] git-repo-manager: Repository successfully cloned
+[⚙] git-repo-manager: Setting up new remote "github" to "https://github.com/hakoerber/git-repo-manager.git"
+[✔] git-repo-manager: OK
+[⚙] Cloning into "/home/me/projects/dotfiles" from "https://github.com/hakoerber/dotfiles.git"
+[✔] dotfiles: Repository successfully cloned
+[✔] dotfiles: OK
+```
+
+If you run it again, it will report no changes:
+
+```bash
+$ grm repos sync config -c example.config.toml
+[✔] git-repo-manager: OK
+[✔] dotfiles: OK
+```
+
+### Generate your own configuration
+
+Now, if you already have a few repositories, it would be quite laborious to
+write a configuration from scratch. Luckily, GRM has a way to generate a
+configuration from an existing file tree:
+
+```bash
+grm repos find local ~/your/project/root > config.toml
+```
+
+This will detect all repositories and remotes and write them to `config.toml`.
+
+You can exclude repositories from the generated configuration by providing
+a regex that will be test against the path of each discovered repository:
+
+```bash
+grm repos find local ~/your/project/root --exclude "^.*/subdir/match-(foo|bar)/.*$" > config.toml
+```
+
+### Show the state of your projects
+
+```bash
+$ grm repos status --config example.config.toml
+╭──────────────────┬──────────┬────────┬───────────────────┬────────┬─────────╮
+│ Repo             ┆ Worktree ┆ Status ┆ Branches          ┆ HEAD   ┆ Remotes │
+╞══════════════════╪══════════╪════════╪═══════════════════╪════════╪═════════╡
+│ git-repo-manager ┆          ┆ ✔      ┆ branch: master    ┆ master ┆ github  │
+│                  ┆          ┆        ┆ <origin/master> ✔ ┆        ┆ origin  │
+├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+│ dotfiles         ┆          ┆ ✔      ┆                   ┆ Empty  ┆ origin  │
+╰──────────────────┴──────────┴────────┴───────────────────┴────────┴─────────╯
+```
+
+You can also use `status` without `--config` to check the repository you're
+currently in:
+
+```bash
+$ cd ~/example-projects/dotfiles
+$ grm repos status
+╭──────────┬──────────┬────────┬──────────┬───────┬─────────╮
+│ Repo     ┆ Worktree ┆ Status ┆ Branches ┆ HEAD  ┆ Remotes │
+╞══════════╪══════════╪════════╪══════════╪═══════╪═════════╡
+│ dotfiles ┆          ┆ ✔      ┆          ┆ Empty ┆ origin  │
+╰──────────┴──────────┴────────┴──────────┴───────┴─────────╯
+```
+
+## YAML
+
+By default, the repo configuration uses TOML. If you prefer YAML, just give it a
+YAML file instead (file ending does not matter, `grm` will figure out the
+format). For generating a configuration, pass `--format yaml` to `grm repo
+find` which generates a YAML configuration instead of a TOML configuration.

docs/src/overview.md

@@ -1,8 +1,8 @@
 # Overview
 
 Welcome! This is the documentation for [Git Repo
-Manager](https://github.com/hakoerber/git-repo-manager/) (GRM for short), a
-tool that helps you manage git repositories.
+Manager](https://github.com/hakoerber/git-repo-manager/) (GRM for short), a tool
+that helps you manage git repositories in a declarative way.
 
 GRM helps you manage git repositories in a declarative way. Configure your
 repositories in a TOML or YAML file, GRM does the rest. Take a look at [the
@@ -12,12 +12,12 @@ to get a feel for the way you configure your repositories. See the [repository
 tree chapter](./repos.md) for details.
 
 GRM also provides some tooling to work with single git repositories using
-`git-worktree`. See [the worktree chapter](./worktree.md) for more details.
+`git-worktree`. See [the worktree chapter](./worktrees.md) for more details.
 
 ## Why use GRM?
 
-If you're working with a lot of git repositories, GRM can help you to manage them
-in an easy way:
+If you're working with a lot of git repositories, GRM can help you to manage
+them in an easy way:
 
 * You want to easily clone many repositories to a new machine.
 * You want to change remotes for multiple repositories (e.g. because your GitLab

docs/src/releases.md

@@ -0,0 +1,27 @@
+# Releases
+
+To make a release, make sure you are on a clean `develop` branch, sync your
+remotes and then run `./release (major|minor|patch)`. It will handle a
+git-flow-y release, meaning that it will perform a merge from `develop` to
+`master`, create a git tag, sync all remotes and run `cargo publish`.
+
+Make sure to run `just check` before releasing to make sure that nothing is
+broken.
+
+As GRM is still `v0.x`, there is not much consideration for backwards
+compatibility. Generally, update the patch version for small stuff and the minor
+version for bigger / backwards incompatible changes.
+
+Generally, it's good to regularly release a new patch release with [updated
+dependencies](./dependency_updates.md). As `./release.sh patch` is exposed as a
+Justfile target (`release-patch`), it's possible to do both in one step:
+
+```bash
+$ just update-dependencies check release-patch
+```
+
+## Release notes
+
+There are currently no release notes. Things are changing quite quickly and
+there is simply no need for a record of changes (except the git history of
+course).

docs/src/repos.md

@@ -1,82 +1,13 @@
-# Managing tree of git repositories
+# Managing Repositories
 
-When managing multiple git repositories with GRM, you'll generally have a
-configuration file containing information about all the repos you have. GRM then
-makes sure that you repositories match that config. If they don't exist yet, it
-will clone them. It will also make sure that all remotes are configured properly.
+GRM helps you manage a bunch of git repositories easily. There are generally two
+ways to go about that:
 
-Let's try it out:
+You can either manage a list of repositories in a TOML or YAML file, and use GRM
+to sync the configuration with the state of the repository.
 
-## Get the example configuration
+Or, you can pull repository information from a forge (e.g. GitHub, GitLab) and
+clone the repositories.
 
-```bash
-$ curl --proto '=https' --tlsv1.2 -sSfO https://raw.githubusercontent.com/hakoerber/git-repo-manager/master/example.config.toml
-```
-
-Then, you're ready to run the first sync. This will clone all configured repositories
-and set up the remotes.
-
-```bash
-$ grm repos sync config --config example.config.toml
-[⚙] Cloning into "/home/me/projects/git-repo-manager" from "https://code.hkoerber.de/hannes/git-repo-manager.git"
-[✔] git-repo-manager: Repository successfully cloned
-[⚙] git-repo-manager: Setting up new remote "github" to "https://github.com/hakoerber/git-repo-manager.git"
-[✔] git-repo-manager: OK
-[⚙] Cloning into "/home/me/projects/dotfiles" from "https://github.com/hakoerber/dotfiles.git"
-[✔] dotfiles: Repository successfully cloned
-[✔] dotfiles: OK
-```
-
-If you run it again, it will report no changes:
-
-```
-$ grm repos sync config -c example.config.toml
-[✔] git-repo-manager: OK
-[✔] dotfiles: OK
-```
-
-### Generate your own configuration
-
-Now, if you already have a few repositories, it would be quite laborious to write
-a configuration from scratch. Luckily, GRM has a way to generate a configuration
-from an existing file tree:
-
-```bash
-$ grm repos find local ~/your/project/root > config.toml
-```
-
-This will detect all repositories and remotes and write them to `config.toml`.
-
-### Show the state of your projects
-
-```bash
-$ grm repos status --config example.config.toml
-╭──────────────────┬──────────┬────────┬───────────────────┬────────┬─────────╮
-│ Repo             ┆ Worktree ┆ Status ┆ Branches          ┆ HEAD   ┆ Remotes │
-╞══════════════════╪══════════╪════════╪═══════════════════╪════════╪═════════╡
-│ git-repo-manager ┆          ┆ ✔      ┆ branch: master    ┆ master ┆ github  │
-│                  ┆          ┆        ┆ <origin/master> ✔ ┆        ┆ origin  │
-├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
-│ dotfiles         ┆          ┆ ✔      ┆                   ┆ Empty  ┆ origin  │
-╰──────────────────┴──────────┴────────┴───────────────────┴────────┴─────────╯
-```
-
-You can also use `status` without `--config` to check the repository you're currently
-in:
-
-```
-$ cd ~/example-projects/dotfiles
-$ grm repos status
-╭──────────┬──────────┬────────┬──────────┬───────┬─────────╮
-│ Repo     ┆ Worktree ┆ Status ┆ Branches ┆ HEAD  ┆ Remotes │
-╞══════════╪══════════╪════════╪══════════╪═══════╪═════════╡
-│ dotfiles ┆          ┆ ✔      ┆          ┆ Empty ┆ origin  │
-╰──────────┴──────────┴────────┴──────────┴───────┴─────────╯
-```
-
-## YAML
-
-By default, the repo configuration uses TOML. If you prefer YAML, just give it
-a YAML file instead (file ending does not matter, `grm` will figure out the format).
-For generating a configuration, pass `--format yaml` to `grm repo find`
-which generates a YAML config instead of a TOML configuration.
+There are also hybrid modes where you pull information from a forge and create a
+configuration file that you can use later.

docs/src/testing.md

@@ -0,0 +1,124 @@
+# Testing
+
+There are two distinct test suites: One for unit test (`just test-unit`) and
+integration tests (`just test-integration`) that is part of the rust crate, and
+a separate e2e test suite in python (`just test-e2e`).
+
+To run all tests, run `just test`.
+
+When contributing, consider whether it makes sense to add tests which could
+prevent regressions in the future. When fixing bugs, it makes sense to add tests
+that expose the wrong behavior beforehand.
+
+The unit and integration tests are very small and only test a few self-contained
+functions (like validation of certain input).
+
+## E2E tests
+
+The main focus of the testing setup lays on the e2e tests. Each user-facing
+behavior *should* have a corresponding e2e test. These are the most important
+tests, as they test functionality the user will use in the end.
+
+The test suite is written in python and uses
+[pytest](https://docs.pytest.org/en/stable/). There are helper functions that
+set up temporary git repositories and remotes in a `tmpfs`.
+
+Effectively, each tests works like this:
+
+* Set up some prerequisites (e.g. different git repositories or configuration
+  files)
+* Run `grm`
+* Check that everything is according to expected behavior (e.g. that `grm` had
+  certain output and exit code, that the target repositories have certain
+  branches, heads and remotes, ...)
+
+As there are many different scenarios, the tests make heavy use of the
+[`@pytest.mark.parametrize`](https://docs.pytest.org/en/stable/how-to/parametrize.html#pytest-mark-parametrize)
+decorator to get all permutations of input parameters (e.g. whether a
+configuration exists, what a config value is set to, how the repository looks
+like, ...)
+
+Whenever you write a new test, think about the different circumstances that can
+happen. What are the failure modes? What affects the behavior? Parametrize each
+of these behaviors.
+
+### Optimization
+
+Note: You will most likely not need to read this.
+
+Each test parameter will exponentially increase the number of tests that will be
+run. As a general rule, comprehensiveness is more important than test suite
+runtime (so if in doubt, better to add another parameter to catch every edge
+case). But try to keep the total runtime sane. Currently, the whole `just test-e2e`
+target runs ~8'000 tests and takes around 5 minutes on my machine, exlucding
+binary and docker build time. I'd say that keeping it under 10 minutes is a good
+idea.
+
+To optimize tests, look out for two patterns: Dependency and Orthogonality
+
+#### Dependency
+
+If a parameter depends on another one, it makes little sense to handle them
+independently. Example: You have a paramter that specifies whether a
+configuration is used, and another parameter that sets a certain value in that
+configuration file. It might look something like this:
+
+```python
+@pytest.mark.parametrize("use_config", [True, False])
+@pytest.mark.parametrize("use_value", ["0", "1"])
+def test(...):
+```
+
+This leads to 4 tests being instantiated. But there is little point in setting a
+configuration value when no config is used, so the combinations `(False, "0")`
+and `(False, "1")` are redundant. To remedy this, spell out the optimized
+permutation manually:
+
+```python
+@pytest.mark.parametrize("config", ((True, "0"), (True, "1"), (False, None)))
+def test(...):
+    (use_config, use_value) = config
+```
+
+This cuts down the number of tests by 25%. If you have more dependent parameters
+(e.g. additional configuration values), this gets even better.  Generally, this
+will cut down the number of tests to
+
+\\[ \frac{1}{o \cdot c} + \frac{1}{(o \cdot c) ^ {(n + 1)}} \\]
+
+with \\( o \\) being the number of values of a parent parameters a parameter is
+dependent on, \\( c \\) being the cardinality of the test input (so you can
+assume \\( o = 1 \\) and \\( c = 2 \\) for boolean parameters), and \\( n \\)
+being the number of parameters that are optimized, i.e. folded into their
+dependent parameter.
+
+As an example: Folding down two boolean parameters into one dependent parent
+boolean parameter will cut down the number of tests to 62.5%!
+
+#### Orthogonality
+
+If different test parameters are independent of each other, there is little
+point in testing their combinations. Instead, split them up into different test
+functions. For boolean parameters, this will cut the number of tests in half.
+
+So instead of this:
+
+```python
+@pytest.mark.parametrize("param1", [True, False])
+@pytest.mark.parametrize("param2", [True, False])
+def test(...):
+```
+
+Rather do this:
+
+```python
+@pytest.mark.parametrize("param1", [True, False])
+def test_param1(...):
+
+@pytest.mark.parametrize("param2", [True, False])
+def test_param2(...):
+```
+
+The tests are running in Docker via docker-compose. This is mainly needed to
+test networking functionality like GitLab integration, with the GitLab API being
+mocked by a simple flask container.

docs/src/tutorial.md

@@ -0,0 +1,183 @@
+# Tutorial
+
+Here, you'll find a quick overview over the most common functionality of GRM.
+
+## Managing existing repositories
+
+Let's say you have your git repositories at `~/code`. To start managing them via
+GRM, first create a configuration:
+
+```bash
+grm repos find local ~/code --format yaml > ~/code/config.yml
+```
+
+The result may look something like this:
+
+```yaml
+---
+trees:
+  - root: ~/code
+    repos:
+      - name: git-repo-manager
+        worktree_setup: true
+        remotes:
+          - name: origin
+            url: "https://github.com/hakoerber/git-repo-manager.git"
+            type: https
+```
+
+To apply the configuration and check whether all repositories are in sync, run
+the following:
+
+```bash
+$ grm repos sync config --config ~/code/config.yml
+[✔] git-repo-manager: OK
+```
+
+Well, obiously there are no changes. To check how changes would be applied,
+let's change the name of the remote (currently `origin`):
+
+```bash
+$ sed -i 's/name: origin/name: github/' ~/code/config.yml
+$ grm repos sync config --config ~/code/config.yml
+[⚙] git-repo-manager: Setting up new remote "github" to "https://github.com/hakoerber/git-repo-manager.git"
+[⚙] git-repo-manager: Deleting remote "origin"
+[✔] git-repo-manager: OK
+```
+
+GRM replaced the `origin` remote with `github`.
+
+The configuration (`~/code/config.yml` in this example) would usually be
+something you'd track in git or synchronize between machines via some other
+means. Then, on every machine, all your repositories are a single `grm repos
+sync` away!
+
+## Getting repositories from a forge
+
+Let's say you have a bunch of repositories on GitHub and you'd like to clone
+them all to your local machine.
+
+To authenticate, you'll need to get a personal access token, as described in
+[the forge documentation](./forge_integration.md#github). Let's assume you put
+your token into `~/.github_token` (please don't if you're doing this "for
+real"!)
+
+Let's first see what kind of repos we can find:
+
+```bash
+$ grm repos sync remote --provider github --token-command "cat ~/.github_token" --root ~/code/github.com/ --format yaml
+---
+trees: []
+$
+```
+
+Ummm, ok? No repos? This is because you have to *tell* GRM what to look for (if
+you don't, GRM will just relax, as it's lazy).
+
+There are different filters (see [the forge
+documentation](./forge_integration.md#filters) for more info). In our case,
+we'll just use the `--owner` filter to get all repos that belong to us:
+
+```bash
+$ grm repos find remote --provider github --token-command "cat ~/.github_token" --root ~/code/github.com/ --format yaml
+---
+trees:
+  - root: ~/code/github.com
+    repos:
+      - name: git-repo-manager
+        worktree_setup: false
+        remotes:
+          - name: origin
+            url: "https://github.com/hakoerber/git-repo-manager.git"
+            type: https
+```
+
+Nice! The format is the same as we got from `grm repos find local` above. So if
+we wanted, we could save this file and use it with `grm repos sync config` as
+above. But there is an even easier way: We can directly clone the repositories!
+
+```bash
+$ grm repos sync remote --provider github --token-command "cat ~/.github_token" --root ~/code/github.com/
+[⚙] Cloning into "~/code/github.com/git-repo-manager" from "https://github.com/hakoerber/git-repo-manager.git"
+[✔] git-repo-manager: Repository successfully cloned
+[✔] git-repo-manager: OK
+```
+
+Nice! Just to make sure, let's run the same command again:
+
+```bash
+$ grm repos sync remote --provider github --token-command "cat ~/.github_token" --root ~/code/github.com/
+[✔] git-repo-manager: OK
+```
+
+GRM saw that the repository is already there and did nothing (remember, it's
+lazy).
+
+## Using worktrees
+
+Worktrees are something that make it easier to work with multiple branches at
+the same time in a repository.  Let's say we wanted to hack on the codebase of
+GRM:
+
+```bash
+$ cd ~/code/github.com/git-repo-manager
+$ ls
+.gitignore
+Cargo.toml
+...
+```
+
+Well, this is just a normal git repository. But let's try worktrees! First, we
+have to convert the existing repository to use the special worktree setup. For
+all worktree operations, we will use `grm worktree` (or `grm wt` for short):
+
+```bash
+$ grm wt convert
+[✔] Conversion done
+$ ls
+$
+```
+
+So, the code is gone? Not really, there is just no active worktree right now. So
+let's add one for `master`:
+
+
+```bash
+$ grm wt add master --track origin/master
+[✔] Conversion done
+$ ls
+master
+$ (cd ./master && git status)
+On branch master
+nothing to commit, working tree clean
+```
+
+Now, a single worktree is kind of pointless (if we only have one, we could also
+just use the normal setup, without worktrees). So let's another one for
+`develop`:
+
+```bash
+$ grm wt add develop --track origin/develop
+[✔] Conversion done
+$ ls
+develop
+master
+$ (cd ./develop && git status)
+On branch develop
+nothing to commit, working tree clean
+```
+
+What's the point? The cool thing is that we can now start working in the
+`develop` worktree, without affecting the `master` worktree at all. If you're
+working on `develop` and want to quickly see what a certain file looks like in
+`master`, just look inside `./master`, it's all there!
+
+This becomes especially interesting when you have many feature branches and are
+working on multiple features at the same time.
+
+There are a lot of options that influence how worktrees are handled. Maybe you
+want to automatically track `origin/master` when you add a worktree called
+`master`?  Maybe you want your feature branches to have a prefix, so when you're
+working on the `feature1` worktree, the remote branch will be
+`origin/awesomefeatures/feature1`? Check out [the chapter on
+worktrees](./worktrees.md) for all the things that are possible.

docs/src/worktree_behavior.md

@@ -0,0 +1,32 @@
+# Behavior Details
+
+When working with worktrees and GRM, there is a lot going on under the hood.
+Each time you create a new worktree, GRM has to figure out what commit to set
+your new branch to and how to configure any potential remote branches.
+
+To state again, the most important guideline is the following:
+
+**The branch inside the worktree is always the same as the directory name of the
+worktree.**
+
+The second set of guidelines relates to the commit to check out, and the remote
+branches to use:
+
+* When a branch already exists, you will get a worktree for that branch
+* Existing local branches are never changed
+* Only do remote operations if specifically requested (via configuration file or
+  command line parameters)
+* When you specify `--track`, you will get that exact branch as the tracking
+  branch
+* When you specify `--no-track`, you will get no tracking branch
+
+Apart from that, GRM tries to do The Right Thing<sup>TM</sup>. It should be as
+little surprising as possible.
+
+In 99% of the cases, you will not have to care about the details, as the normal
+workflows are covered by the rules above. In case you want to know the exact
+behavior "specification", take a look at the [module documentation for
+`grm::worktree`](https://docs.rs/git-repo-manager/latest/grm/worktree/index.html).
+
+If you think existing behavior is super-duper confusing and you have a better
+idea, do not hesitate to open a GitHub issue to discuss this!

docs/src/worktree_remotes.md

@@ -0,0 +1,75 @@
+# Worktrees and Remotes
+
+To fetch all remote references from all remotes in a worktree setup, you can use
+the following command:
+
+```
+$ grm wt fetch
+[✔] Fetched from all remotes
+```
+
+This is equivalent to running `git fetch --all` in any of the worktrees.
+
+Often, you may want to pull all remote changes into your worktrees. For this,
+use the `git pull` equivalent:
+
+```
+$ grm wt pull
+[✔] master: Done
+[✔] my-cool-branch: Done
+```
+
+This will refuse when there are local changes, or if the branch cannot be fast
+forwarded. If you want to rebase your local branches, use the `--rebase` switch:
+
+```
+$ grm wt pull --rebase
+[✔] master: Done
+[✔] my-cool-branch: Done
+```
+
+As noted, this will fail if there are any local changes in your worktree. If you
+want to stash these changes automatically before the pull (and unstash them
+afterwards), use the `--stash` option.
+
+This will rebase your changes onto the upstream branch. This is mainly helpful
+for persistent branches that change on the remote side.
+
+There is a similar rebase feature that rebases onto the **default** branch
+instead:
+
+```
+$ grm wt rebase
+[✔] master: Done
+[✔] my-cool-branch: Done
+```
+
+This is super helpful for feature branches. If you want to incorporate changes
+made on the remote branches, use `grm wt rebase` and all your branches will be
+up to date. If you want to also update to remote tracking branches in one go,
+use the `--pull` flag, and `--rebase` if you want to rebase instead of aborting
+on non-fast-forwards:
+
+```
+$ grm wt rebase --pull --rebase
+[✔] master: Done
+[✔] my-cool-branch: Done
+```
+
+"So, what's the difference between `pull --rebase` and `rebase --pull`? Why the
+hell is there a `--rebase` flag in the `rebase` command?"
+
+Yes, it's kind of weird. Remember that `pull` only ever updates each worktree to
+their remote branch, if possible. `rebase` rebases onto the **default** branch
+instead. The switches to `rebase` are just convenience, so you do not have to
+run two commands.
+
+* `rebase --pull` is the same as `pull` && `rebase`
+* `rebase --pull --rebase` is the same as `pull --rebase` && `rebase`
+
+I understand that the UX is not the most intuitive. If you can think of an
+improvement, please let me know (e.g. via an GitHub issue)!
+
+As with `pull`, `rebase` will also refuse to run when there are changes in your
+worktree. And you can also use the `--stash` option to stash/unstash changes
+automatically.

docs/src/worktree_working.md

@@ -0,0 +1,173 @@
+# Working with Worktrees
+
+## Creating a new worktree
+
+To actually work, you'll first have to create a new worktree checkout. All
+worktree-related commands are available as subcommands of `grm worktree` (or
+`grm wt` for short):
+
+```
+$ grm wt add mybranch
+[✔] Worktree mybranch created
+```
+
+You'll see that there is now a directory called `mybranch` that contains a
+checkout of your repository, using the branch `mybranch`
+
+```bash
+$ cd ./mybranch && git status
+On branch mybranch
+nothing to commit, working tree clean
+```
+
+You can work in this repository as usual. Make changes, commit them, revert
+them, whatever you're up to :)
+
+Just note that you *should* not change the branch inside the worktree directory.
+There is nothing preventing you from doing so, but you will notice that you'll
+run into problems when trying to remove a worktree (more on that later). It may
+also lead to confusing behavior, as there can be no two worktrees that have the
+same branch checked out. So if you decide to use the worktree setup, go all in,
+let `grm` manage your branches and bury `git branch` (and `git checkout -b`).
+
+You will notice that there is no tracking branch set up for the new branch. You
+can of course set up one manually after creating the worktree, but there is an
+easier way, using the `--track` flag during creation. Let's create another
+worktree. Go back to the root of the repository, and run:
+
+```bash
+$ grm wt add mybranch2 --track origin/mybranch2
+[✔] Worktree mybranch2 created
+```
+
+You'll see that this branch is now tracking `mybranch` on the `origin` remote:
+
+```bash
+$ cd ./mybranch2 && git status
+On branch mybranch
+
+Your branch is up to date with 'origin/mybranch2'.
+nothing to commit, working tree clean
+```
+
+The behavior of `--track` differs depending on the existence of the remote
+branch:
+
+* If the remote branch already exists, `grm` uses it as the base of the new
+  local branch.
+* If the remote branch does not exist (as in our example), `grm` will create a
+  new remote tracking branch, using the default branch (either `main` or
+  `master`) as the base
+
+Often, you'll have a workflow that uses tracking branches by default. It would
+be quite tedious to add `--track` every single time. Luckily, the `grm.toml`
+file supports defaults for the tracking behavior. See this for an example:
+
+```toml
+[track]
+default = true
+default_remote = "origin"
+```
+
+This will set up a tracking branch on `origin` that has the same name as the
+local branch.
+
+Sometimes, you might want to have a certain prefix for all your tracking
+branches.  Maybe to prevent collisions with other contributors. You can simply
+set `default_remote_prefix` in `grm.toml`:
+
+```toml
+[track]
+default = true
+default_remote = "origin"
+default_remote_prefix = "myname"
+```
+
+When using branch `my-feature-branch`, the remote tracking branch would be
+`origin/myname/my-feature-branch` in this case.
+
+Note that `--track` overrides any configuration in `grm.toml`. If you want to
+disable tracking, use `--no-track`.
+
+## Showing the status of your worktrees
+
+There is a handy little command that will show your an overview over all
+worktrees in a repository, including their status (i.e. changes files). Just run
+the following in the root of your repository:
+
+```
+$ grm wt status
+╭───────────┬────────┬──────────┬──────────────────╮
+│ Worktree  ┆ Status ┆ Branch   ┆ Remote branch    │
+╞═══════════╪════════╪══════════╪══════════════════╡
+│ mybranch  ┆ ✔      ┆ mybranch ┆                  │
+│ mybranch2 ┆ ✔      ┆ mybranch ┆ origin/mybranch2 │
+╰───────────┴────────┴──────────┴──────────────────╯
+```
+
+The "Status" column would show any uncommitted changes (new / modified / deleted
+files) and the "Remote branch" would show differences to the remote branch (e.g.
+if there are new pushes to the remote branch that are not yet incorporated into
+your local branch).
+
+
+## Deleting worktrees
+
+If you're done with your worktrees, use `grm wt delete` to delete them. Let's
+start with `mybranch2`:
+
+```
+$ grm wt delete mybranch2
+[✔] Worktree mybranch2 deleted
+```
+
+Easy. On to `mybranch`:
+
+```
+$ grm wt delete mybranch
+[!] Changes in worktree: No remote tracking branch for branch mybranch found. Refusing to delete
+```
+
+Hmmm. `grm` tells you:
+
+"Hey, there is no remote branch that you could have pushed your changes to. I'd
+rather not delete work that you cannot recover."
+
+Note that `grm` is very cautious here. As your repository will not be deleted,
+you could still recover the commits via
+[`git-reflog`](https://git-scm.com/docs/git-reflog).  But better safe than
+sorry! Note that you'd get a similar error message if your worktree had any
+uncommitted files, for the same reason. Now you can either commit & push your
+changes, or your tell `grm` that you know what you're doing:
+
+```
+$ grm wt delete mybranch --force
+[✔] Worktree mybranch deleted
+```
+
+If you just want to delete all worktrees that do not contain any changes, you
+can also use the following:
+
+```
+$ grm wt clean
+```
+
+Note that this will not delete the default branch of the repository. It can of
+course still be delete with `grm wt delete` if necessary.
+
+### Converting an existing repository
+
+It is possible to convert an existing directory to a worktree setup, using `grm
+wt convert`. This command has to be run in the root of the repository you want
+to convert:
+
+```
+$ grm wt convert
+[✔] Conversion successful
+```
+
+This command will refuse to run if you have any changes in your repository.
+Commit them and try again!
+
+Afterwards, the directory is empty, as there are no worktrees checked out yet.
+Now you can use the usual commands to set up worktrees.

docs/src/worktrees.md

@@ -1,58 +1,60 @@
 # Git Worktrees
 
 ## Why?
+The default workflow when using git is having your repository in a single
+directory.  Then, you can check out a certain reference (usually a branch),
+which will update the files in the directory to match the state of that
+reference. Most of the time, this is exactly what you need and works perfectly.
+But especially when you're working with branches a lot, you may notice that
+there is a lot of work required to make everything run smoothly.
 
-The default workflow when using git is having your repository in a single directory.
-Then, you can check out a certain reference (usually a branch), which will update
-the files in the directory to match the state of that reference. Most of the time,
-this is exactly what you need and works perfectly. But especially when you're working
-with branches a lot, you may notice that there is a lot of work required to make
-everything run smoothly.
-
-Maybe you have experienced the following: You're working on a feature branch. Then,
-for some reason, you have to change branches (maybe to investigate some issue).
-But you get the following:
+Maybe you have experienced the following: You're working on a feature branch.
+Then, for some reason, you have to change branches (maybe to investigate some
+issue).  But you get the following:
 
 ```
 error: Your local changes to the following files would be overwritten by checkout
 ```
 
-Now you can create a temporary commit or stash your changes. In any case, you have
-some mental overhead before you can work on something else. Especially with stashes,
-you'll have to remember to do a `git stash pop` before resuming your work (I
-cannot count the number of times where I "rediscovered" some code hidden in some
-old stash I forgot about.
+Now you can create a temporary commit or stash your changes. In any case, you
+have some mental overhead before you can work on something else. Especially with
+stashes, you'll have to remember to do a `git stash pop` before resuming your
+work (I cannot count the number of times where I "rediscovered" some code hidden
+in some old stash I forgot about). Also, conflicts on a `git stash pop` are just
+horrible.
 
-And even worse: If you're currently in the process of resolving merge conflicts or an
-interactive rebase, there is just no way to "pause" this work to check out a
-different branch.
+And even worse: If you're currently in the process of resolving merge conflicts
+or an interactive rebase, there is just no way to "pause" this work to check out
+a different branch.
 
-Sometimes, it's crucial to have an unchanging state of your repository until some
-long-running process finishes. I'm thinking of Ansible and Terraform runs. I'd
-rather not change to a different branch while ansible or Terraform are running as
-I have no idea how those tools would behave (and I'm not too eager to find out).
+Sometimes, it's crucial to have an unchanging state of your repository until
+some long-running process finishes. I'm thinking of Ansible and Terraform runs.
+I'd rather not change to a different branch while ansible or Terraform are
+running as I have no idea how those tools would behave (and I'm not too eager to
+find out).
 
 In any case, Git Worktrees are here for the rescue:
 
 ## What are git worktrees?
 
-[Git Worktrees](https://git-scm.com/docs/git-worktree) allow you to have multiple
-independent checkouts of your repository on different directories. You can have
-multiple directories that correspond to different references in your repository.
-Each worktree has it's independent working tree (duh) and index, so there is no
-way to run into conflicts. Changing to a different branch is just a `cd` away (if
-the worktree is already set up).
+[Git Worktrees](https://git-scm.com/docs/git-worktree) allow you to have
+multiple independent checkouts of your repository on different directories. You
+can have multiple directories that correspond to different references in your
+repository.  Each worktree has it's independent working tree (duh) and index, so
+there is no way to run into conflicts. Changing to a different branch is just a
+`cd` away (if the worktree is already set up).
 
 ## Worktrees in GRM
 
-GRM exposes an opinionated way to use worktrees in your repositories. Opinionated,
-because there is a single invariant that makes reasoning about your worktree
-setup quite easy:
+GRM exposes an opinionated way to use worktrees in your repositories.
+Opinionated, because there is a single invariant that makes reasoning about your
+worktree setup quite easy:
 
-**The branch inside the worktree is always the same as the directory name of the worktree.**
+**The branch inside the worktree is always the same as the directory name of the
+worktree.**
 
-In other words: If you're checking out branch `mybranch` into a new worktree, the
-worktree directory will be named `mybranch`.
+In other words: If you're checking out branch `mybranch` into a new worktree,
+the worktree directory will be named `mybranch`.
 
 GRM can be used with both "normal" and worktree-enabled repositories. But note
 that a single repository can be either the former or the latter. You'll have to
@@ -67,303 +69,27 @@ name = "git-repo-manager"
 worktree_setup = true
 ```
 
-Now, when you run a `grm sync`, you'll notice that the directory of the repository
-is empty! Well, not totally, there is a hidden directory called `.git-main-working-tree`.
-This is where the repository actually "lives" (it's a bare checkout).
+Now, when you run a `grm sync`, you'll notice that the directory of the
+repository is empty! Well, not totally, there is a hidden directory called
+`.git-main-working-tree`.  This is where the repository actually "lives" (it's a
+bare checkout).
 
 Note that there are few specific things you can configure for a certain
-workspace.  This is all done in an optional `grm.toml` file right in the root
-of the worktree. More on that later.
+workspace.  This is all done in an optional `grm.toml` file right in the root of
+the worktree. More on that later.
 
-### Creating a new worktree
 
-To actually work, you'll first have to create a new worktree checkout. All
-worktree-related commands are available as subcommands of `grm worktree` (or
-`grm wt` for short):
+## Manual access
 
-```
-$ grm wt add mybranch
-[✔] Worktree mybranch created
-```
-
-You'll see that there is now a directory called `mybranch` that contains a checkout
-of your repository, using the branch `mybranch`
-
-```bash
-$ cd ./mybranch && git status
-On branch mybranch
-nothing to commit, working tree clean
-```
-
-You can work in this repository as usual. Make changes, commit them, revert them,
-whatever you're up to :)
-
-Just note that you *should* not change the branch inside the worktree
-directory.  There is nothing preventing you from doing so, but you will notice
-that you'll run into problems when trying to remove a worktree (more on that
-later). It may also lead to confusing behaviour, as there can be no two
-worktrees that have the same branch checked out. So if you decide to use the
-worktree setup, go all in, let `grm` manage your branches and bury `git branch`
-(and `git checkout -b`).
-
-You will notice that there is no tracking branch set up for the new branch. You
-can of course set up one manually after creating the worktree, but there is an
-easier way, using the `--track` flag during creation. Let's create another
-worktree. Go back to the root of the repository, and run:
-
-```bash
-$ grm wt add mybranch2 --track origin/mybranch2
-[✔] Worktree mybranch2 created
-```
-
-You'll see that this branch is now tracking `mybranch` on the `origin` remote:
-
-```bash
-$ cd ./mybranch2 && git status
-On branch mybranch
-
-Your branch is up to date with 'origin/mybranch2'.
-nothing to commit, working tree clean
-```
-
-The behaviour of `--track` differs depending on the existence of the remote branch:
-
-* If the remote branch already exists, `grm` uses it as the base of the new
-  local branch.
-* If the remote branch does not exist (as in our example), `grm` will create a
-  new remote tracking branch, using the default branch (either `main` or `master`)
-  as the base
-
-Often, you'll have a workflow that uses tracking branches by default. It would
-be quite tedious to add `--track` every single time. Luckily, the `grm.toml` file
-supports defaults for the tracking behaviour. See this for an example:
-
-```toml
-[track]
-default = true
-default_remote = "origin"
-```
-
-This will set up a tracking branch on `origin` that has the same name as the local
-branch.
-
-Sometimes, you might want to have a certain prefix for all your tracking branches.
-Maybe to prevent collissions with other contributors. You can simply set
-`default_remote_prefix` in `grm.toml`:
-
-```toml
-[track]
-default = true
-default_remote = "origin"
-default_remote_prefix = "myname"
-```
-
-When using branch `my-feature-branch`, the remote tracking branch would be
-`origin/myname/my-feature-branch` in this case.
-
-Note that `--track` overrides any configuration in `grm.toml`. If you want to
-disable tracking, use `--no-track`.
-
-### Showing the status of your worktrees
-
-There is a handy little command that will show your an overview over all worktrees
-in a repository, including their status (i.e. changes files). Just run the following
-in the root of your repository:
-
-```
-$ grm wt status
-╭───────────┬────────┬──────────┬──────────────────╮
-│ Worktree  ┆ Status ┆ Branch   ┆ Remote branch    │
-╞═══════════╪════════╪══════════╪══════════════════╡
-│ mybranch  ┆ ✔      ┆ mybranch ┆                  │
-│ mybranch2 ┆ ✔      ┆ mybranch ┆ origin/mybranch2 │
-╰───────────┴────────┴──────────┴──────────────────╯
-```
-
-The "Status" column would show any uncommitted changes (new / modified / deleted
-files) and the "Remote branch" would show differences to the remote branch (e.g.
-if there are new pushes to the remote branch that are not yet incorporated into
-your local branch).
-
-
-### Deleting worktrees
-
-If you're done with your worktrees, use `grm wt delete` to delete them. Let's
-start with `mybranch2`:
-
-```
-$ grm wt delete mybranch2
-[✔] Worktree mybranch2 deleted
-```
-
-Easy. On to `mybranch`:
-
-```
-$ grm wt delete mybranch
-[!] Changes in worktree: No remote tracking branch for branch mybranch found. Refusing to delete
-```
-
-Hmmm. `grm` tells you:
-
-"Hey, there is no remote branch that you could have pushed
-your changes to. I'd rather not delete work that you cannot recover."
-
-Note that `grm` is very cautious here. As your repository will not be deleted,
-you could still recover the commits via [`git-reflog`](https://git-scm.com/docs/git-reflog).
-But better safe than sorry! Note that you'd get a similar error message if your
-worktree had any uncommitted files, for the same reason. Now you can either
-commit & push your changes, or your tell `grm` that you know what you're doing:
-
-```
-$ grm wt delete mybranch --force
-[✔] Worktree mybranch deleted
-```
-
-If you just want to delete all worktrees that do not contain any changes, you
-can also use the following:
-
-```
-$ grm wt clean
-```
-
-Note that this will not delete the default branch of the repository. It can of
-course still be delete with `grm wt delete` if neccessary.
-
-### Persistent branches
-
-You most likely have a few branches that are "special", that you don't want to
-clean up and that are the usual target for feature branches to merge into. GRM
-calls them "persistent branches" and treats them a bit differently:
-
-* Their worktrees will never be deleted by `grm wt clean`
-* If the branches in other worktrees are merged into them, they will be cleaned
-  up, even though they may not be in line with their upstream. Same goes for
-  `grm wt delete`, which will not require a `--force` flag. Note that of
-  course, actual changes in the worktree will still block an automatic cleanup!
-* As soon as you enable persistent branches, non-persistent branches will only
-  ever be cleaned up when merged into a persistent branch.
-
-To elaborate: This is mostly relevant for a feature-branch workflow. Whenever a
-feature branch is merged, it can usually be thrown away. As merging is usually
-done on some remote code management platform (GitHub, GitLab, ...), this means
-that you usually keep a branch around until it is merged into one of the "main"
-branches (`master`, `main`, `develop`, ...)
-
-Enable persistent branches by setting the following in the `grm.toml` in the
-worktree root:
-
-```toml
-persistent_branches = [
-    "master",
-    "develop",
-]
-```
-
-Note that setting persistent branches will disable any detection of "default"
-branches. The first entry will be considered your repositories' default branch.
-
-### Converting an existing repository
-
-It is possible to convert an existing directory to a worktree setup, using `grm
-wt convert`. This command has to be run in the root of the repository you want
-to convert:
-
-```
-$ grm wt convert
-[✔] Conversion successful
-```
-
-This command will refuse to run if you have any changes in your repository.
-Commit them and try again!
-
-Afterwards, the directory is empty, as there are no worktrees checked out yet.
-Now you can use the usual commands to set up worktrees.
-
-### Working with remotes
-
-To fetch all remote references from all remotes in a worktree setup, you can
-use the following command:
-
-```
-$ grm wt fetch
-[✔] Fetched from all remotes
-```
-
-This is equivalent to running `git fetch --all` in any of the worktrees.
-
-Often, you may want to pull all remote changes into your worktrees. For this,
-use the `git pull` equivalent:
-
-```
-$ grm wt pull
-[✔] master: Done
-[✔] my-cool-branch: Done
-```
-
-This will refuse when there are local changes, or if the branch cannot be fast
-forwarded. If you want to rebase your local branches, use the `--rebase` switch:
-
-```
-$ grm wt pull --rebase
-[✔] master: Done
-[✔] my-cool-branch: Done
-```
-
-As noted, this will fail if there are any local changes in your worktree. If you
-want to stash these changes automatically before the pull (and unstash them
-afterwards), use the `--stash` option.
-
-This will rebase your changes onto the upstream branch. This is mainly helpful
-for persistent branches that change on the remote side.
-
-There is a similar rebase feature that rebases onto the **default** branch instead:
-
-```
-$ grm wt rebase
-[✔] master: Done
-[✔] my-cool-branch: Done
-```
-
-This is super helpful for feature branches. If you want to incorporate changes
-made on the remote branches, use `grm wt rebase` and all your branches will
-be up to date. If you want to also update to remote tracking branches in one go,
-use the `--pull` flag, and `--rebase` if you want to rebase instead of aborting
-on non-fast-forwards:
-
-```
-$ grm wt rebase --pull --rebase
-[✔] master: Done
-[✔] my-cool-branch: Done
-```
-
-"So, what's the difference between `pull --rebase` and `rebase --pull`? Why the
-hell is there a `--rebase` flag in the `rebase` command?"
-
-Yes, it's kind of weird. Remember that `pull` only ever updates each worktree
-to their remote branch, if possible. `rebase` rebases onto the **default** branch
-instead. The switches to `rebase` are just convenience, so you do not have to
-run two commands.
-
-* `rebase --pull` is the same as `pull` && `rebase`
-* `rebase --pull --rebase` is the same as `pull --rebase` && `rebase`
-
-I understand that the UX is not the most intuitive. If you can think of an
-improvement, please let me know (e.g. via an GitHub issue)!
-
-As with `pull`, `rebase` will also refuse to run when there are changes in your
-worktree. And you can also use the `--stash` option to stash/unstash changes
-automatically.
-
-### Manual access
-
-GRM isn't doing any magic, it's just git under the hood. If you need to have access
-to the underlying git repository, you can always do this:
+GRM isn't doing any magic, it's just git under the hood. If you need to have
+access to the underlying git repository, you can always do this:
 
 ```
 $ git --git-dir ./.git-main-working-tree [...]
 ```
 
 This should never be required (whenever you have to do this, you can consider
-this a bug in GRM and open an [issue](https://github.com/hakoerber/git-repo-manager/issues/new),
-but it may help in a pinch.
+this a bug in GRM and open an
+[issue](https://github.com/hakoerber/git-repo-manager/issues/new), but it may
+help in a pinch.
 

e2e_tests/conftest.py

@@ -6,3 +6,7 @@ def pytest_configure(config):
     os.environ["GIT_AUTHOR_EMAIL"] = "user@example.com"
     os.environ["GIT_COMMITTER_NAME"] = "Example user"
     os.environ["GIT_COMMITTER_EMAIL"] = "user@example.com"
+
+
+def pytest_unconfigure(config):
+    pass

e2e_tests/docker-rest/flask/app.py

@@ -3,5 +3,5 @@ from flask import Flask
 app = Flask(__name__)
 app.url_map.strict_slashes = False
 
-import github
-import gitlab
+import github  # noqa: E402,F401
+import gitlab  # noqa: E402,F401

e2e_tests/docker-rest/flask/github.py

@@ -1,10 +1,8 @@
 import os.path
 
-from app import app
-
-from flask import Flask, request, abort, jsonify, make_response
-
 import jinja2
+from app import app
+from flask import abort, jsonify, make_response, request
 
 
 def check_headers():
@@ -48,7 +46,7 @@ def add_pagination(response, page, last_page):
 
 def read_project_files(namespaces=[]):
     last_page = 4
-    page = username = int(request.args.get("page", "1"))
+    page = int(request.args.get("page", "1"))
     response_file = f"./github_api_page_{page}.json.j2"
     if not os.path.exists(response_file):
         return jsonify([])

e2e_tests/docker-rest/flask/gitlab.py

@@ -1,10 +1,8 @@
 import os.path
 
-from app import app
-
-from flask import Flask, request, abort, jsonify, make_response
-
 import jinja2
+from app import app
+from flask import abort, jsonify, make_response, request
 
 
 def check_headers():
@@ -48,7 +46,7 @@ def add_pagination(response, page, last_page):
 
 def read_project_files(namespaces=[]):
     last_page = 4
-    page = username = int(request.args.get("page", "1"))
+    page = int(request.args.get("page", "1"))
     response_file = f"./gitlab_api_page_{page}.json"
     if not os.path.exists(response_file):
         return jsonify([])

e2e_tests/docker/Dockerfile

@@ -1,7 +1,7 @@
 FROM docker.io/debian:11.3
 
 RUN apt-get update \
-    && apt-get install -y \
+    && apt-get install -y --no-install-recommends \
         python3-pytest \
         python3-toml \
         python3-git \

e2e_tests/helpers.py

@@ -1,20 +1,34 @@
 #!/usr/bin/env python3
 
+import hashlib
+import inspect
 import os
 import os.path
+import shutil
 import subprocess
 import tempfile
-import hashlib
 
 import git
 
 binary = os.environ["GRM_BINARY"]
 
 
+def funcname():
+    return inspect.stack()[1][3]
+
+
+def copytree(src, dest):
+    shutil.copytree(src, dest, dirs_exist_ok=True)
+
+
+def get_temporary_directory(dir=None):
+    return tempfile.TemporaryDirectory(dir=dir)
+
+
 def grm(args, cwd=None, is_invalid=False):
     cmd = subprocess.run([binary] + args, cwd=cwd, capture_output=True, text=True)
     if not is_invalid:
-        assert "USAGE" not in cmd.stderr
+        assert "usage" not in cmd.stderr.lower()
     print(f"grmcmd: {args}")
     print(f"stdout:\n{cmd.stdout}")
     print(f"stderr:\n{cmd.stderr}")
@@ -25,8 +39,12 @@ def grm(args, cwd=None, is_invalid=False):
 
 
 def shell(script):
-    script = "set -o errexit\nset -o nounset\n" + script
-    subprocess.run(["bash"], input=script, text=True, check=True)
+    script = "set -o errexit\nset -o nounset\nset -o pipefail\n" + script
+    cmd = subprocess.run(["bash"], input=script, text=True, capture_output=True)
+    if cmd.returncode != 0:
+        print(cmd.stdout)
+        print(cmd.stderr)
+    cmd.check_returncode()
 
 
 def checksum_directory(path):
@@ -112,78 +130,203 @@ def checksum_directory(path):
 class TempGitRepository:
     def __init__(self, dir=None):
         self.dir = dir
-        pass
 
     def __enter__(self):
-        self.tmpdir = tempfile.TemporaryDirectory(dir=self.dir)
-        self.remote_1_dir = tempfile.TemporaryDirectory()
-        self.remote_2_dir = tempfile.TemporaryDirectory()
-        shell(
-            f"""
+        self.tmpdir = get_temporary_directory(self.dir)
+        self.remote_1 = get_temporary_directory()
+        self.remote_2 = get_temporary_directory()
+        cmd = f"""
             cd {self.tmpdir.name}
-            git init
+            git -c init.defaultBranch=master init
             echo test > root-commit
             git add root-commit
             git commit -m "root-commit"
-            git remote add origin file://{self.remote_1_dir.name}
-            git remote add otherremote file://{self.remote_2_dir.name}
+            git remote add origin file://{self.remote_1.name}
+            git remote add otherremote file://{self.remote_2.name}
         """
-        )
+
+        shell(cmd)
         return self.tmpdir.name
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        del self.tmpdir
-        del self.remote_1_dir
-        del self.remote_2_dir
+        pass
+
+
+class TempGitRemote:
+    obj = {}
+
+    def __init__(self, tmpdir, remoteid=None):
+        self.tmpdir = tmpdir
+        self.remoteid = remoteid
+
+    @classmethod
+    def get(cls, cachekey=None, initfunc=None):
+        if cachekey is None:
+            tmpdir = get_temporary_directory()
+            shell(
+                f"""
+                cd {tmpdir.name}
+                git -c init.defaultBranch=master init --bare
+            """
+            )
+            newobj = cls(tmpdir)
+            remoteid = None
+            if initfunc is not None:
+                remoteid = newobj.init(initfunc)
+            newobj.remoteid = remoteid
+            return newobj, remoteid
+        else:
+            if cachekey not in cls.obj:
+                tmpdir = get_temporary_directory()
+                shell(
+                    f"""
+                    cd {tmpdir.name}
+                    git -c init.defaultBranch=master init --bare
+                """
+                )
+                newobj = cls(tmpdir)
+                remoteid = newobj.init(initfunc)
+                newobj.remoteid = remoteid
+                cls.obj[cachekey] = newobj
+            return cls.clone(cls.obj[cachekey])
+
+    @classmethod
+    def clone(cls, source):
+        new_remote = get_temporary_directory()
+        copytree(source.tmpdir.name, new_remote.name)
+        return cls(new_remote, source.remoteid), source.remoteid
+
+    def init(self, func):
+        return func(self.tmpdir.name)
+
+    def __enter__(self):
+        return self.tmpdir
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
 
 
 class TempGitRepositoryWorktree:
-    def __init__(self):
-        pass
+    obj = {}
+
+    def __init__(self, remotes, tmpdir, commit, remote1, remote2, remote1id, remote2id):
+        self.remotes = remotes
+        self.tmpdir = tmpdir
+        self.commit = commit
+        self.remote1 = remote1
+        self.remote2 = remote2
+        self.remote1id = remote1id
+        self.remote2id = remote2id
+
+    @classmethod
+    def get(cls, cachekey, branch=None, remotes=2, basedir=None, remote_setup=None):
+        if cachekey not in cls.obj:
+            tmpdir = get_temporary_directory()
+            shell(
+                f"""
+                cd {tmpdir.name}
+                git -c init.defaultBranch=master init
+                echo test > root-commit-in-worktree-1
+                git add root-commit-in-worktree-1
+                git commit -m "root-commit-in-worktree-1"
+                echo test > root-commit-in-worktree-2
+                git add root-commit-in-worktree-2
+                git commit -m "root-commit-in-worktree-2"
+
+                git ls-files | xargs rm -rf
+                mv .git .git-main-working-tree
+                git --git-dir .git-main-working-tree config core.bare true
+            """
+            )
+
+            repo = git.Repo(f"{tmpdir.name}/.git-main-working-tree")
+
+            commit = repo.head.commit.hexsha
+            if branch is not None:
+                repo.create_head(branch)
+
+            remote1 = None
+            remote2 = None
+            remote1id = None
+            remote2id = None
+
+            if remotes >= 1:
+                cachekeyremote, initfunc = (remote_setup or ((None, None),))[0]
+                remote1, remote1id = TempGitRemote.get(
+                    cachekey=cachekeyremote, initfunc=initfunc
+                )
+                remote1 = remote1
+                remote1id = remote1id
+                shell(
+                    f"""
+                    cd {tmpdir.name}
+                    git --git-dir .git-main-working-tree remote add origin file://{remote1.tmpdir.name}
+                """
+                )
+                repo.remotes.origin.fetch()
+                repo.remotes.origin.push("master")
+
+            if remotes >= 2:
+                cachekeyremote, initfunc = (remote_setup or (None, (None, None)))[1]
+                remote2, remote2id = TempGitRemote.get(
+                    cachekey=cachekeyremote, initfunc=initfunc
+                )
+                remote2 = remote2
+                remote2id = remote2id
+                shell(
+                    f"""
+                    cd {tmpdir.name}
+                    git --git-dir .git-main-working-tree remote add otherremote file://{remote2.tmpdir.name}
+                """
+                )
+                repo.remotes.otherremote.fetch()
+                repo.remotes.otherremote.push("master")
+
+            cls.obj[cachekey] = cls(
+                remotes, tmpdir, commit, remote1, remote2, remote1id, remote2id
+            )
+
+        return cls.clone(cls.obj[cachekey], remote_setup=remote_setup)
+
+    @classmethod
+    def clone(cls, source, remote_setup):
+        newdir = get_temporary_directory()
+
+        copytree(source.tmpdir.name, newdir.name)
+
+        remote1 = None
+        remote2 = None
+        remote1id = None
+        remote2id = None
+        repo = git.Repo(os.path.join(newdir.name, ".git-main-working-tree"))
+        if source.remotes >= 1:
+            cachekey, initfunc = (remote_setup or ((None, None),))[0]
+            remote1, remote1id = TempGitRemote.get(cachekey=cachekey, initfunc=initfunc)
+            if remote1id != source.remote1id:
+                repo.remotes.origin.fetch()
+                repo.remotes.origin.push("master")
+        if source.remotes >= 2:
+            cachekey, initfunc = (remote_setup or (None, (None, None)))[1]
+            remote2, remote2id = TempGitRemote.get(cachekey=cachekey, initfunc=initfunc)
+            if remote2id != source.remote2id:
+                repo.remotes.otherremote.fetch()
+                repo.remotes.otherremote.push("master")
+
+        return cls(
+            source.remotes,
+            newdir,
+            source.commit,
+            remote1,
+            remote2,
+            remote1id,
+            remote2id,
+        )
 
     def __enter__(self):
-        self.tmpdir = tempfile.TemporaryDirectory()
-        self.remote_1_dir = tempfile.TemporaryDirectory()
-        self.remote_2_dir = tempfile.TemporaryDirectory()
-        shell(
-            f"""
-            cd {self.remote_1_dir.name}
-            git init --bare
-        """
-        )
-        shell(
-            f"""
-            cd {self.remote_2_dir.name}
-            git init --bare
-        """
-        )
-        shell(
-            f"""
-            cd {self.tmpdir.name}
-            git init
-            echo test > root-commit-in-worktree-1
-            git add root-commit-in-worktree-1
-            git commit -m "root-commit-in-worktree-1"
-            echo test > root-commit-in-worktree-2
-            git add root-commit-in-worktree-2
-            git commit -m "root-commit-in-worktree-2"
-            git remote add origin file://{self.remote_1_dir.name}
-            git remote add otherremote file://{self.remote_2_dir.name}
-            git push origin HEAD:master
-            git ls-files | xargs rm -rf
-            mv .git .git-main-working-tree
-            git --git-dir .git-main-working-tree config core.bare true
-        """
-        )
-        commit = git.Repo(
-            f"{self.tmpdir.name}/.git-main-working-tree"
-        ).head.commit.hexsha
-        return (self.tmpdir.name, commit)
+        return (self.tmpdir.name, self.commit)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        del self.tmpdir
-        del self.remote_1_dir
-        del self.remote_2_dir
+        pass
 
 
 class RepoTree:
@@ -191,7 +334,7 @@ class RepoTree:
         pass
 
     def __enter__(self):
-        self.root = tempfile.TemporaryDirectory()
+        self.root = get_temporary_directory()
         self.config = tempfile.NamedTemporaryFile()
         with open(self.config.name, "w") as f:
             f.write(
@@ -222,7 +365,7 @@ class EmptyDir:
         pass
 
     def __enter__(self):
-        self.tmpdir = tempfile.TemporaryDirectory()
+        self.tmpdir = get_temporary_directory()
         return self.tmpdir.name
 
     def __exit__(self, exc_type, exc_val, exc_tb):
@@ -234,7 +377,7 @@ class NonGitDir:
         pass
 
     def __enter__(self):
-        self.tmpdir = tempfile.TemporaryDirectory()
+        self.tmpdir = get_temporary_directory()
         shell(
             f"""
             cd {self.tmpdir.name}
@@ -254,11 +397,11 @@ class TempGitFileRemote:
         pass
 
     def __enter__(self):
-        self.tmpdir = tempfile.TemporaryDirectory()
+        self.tmpdir = get_temporary_directory()
         shell(
             f"""
             cd {self.tmpdir.name}
-            git init
+            git -c init.defaultBranch=master init
             echo test > root-commit-in-remote-1
             git add root-commit-in-remote-1
             git commit -m "root-commit-in-remote-1"

e2e_tests/test_basic.py

@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 
-from helpers import *
+from helpers import grm
 
 
 def test_invalid_command():
     cmd = grm(["whatever"], is_invalid=True)
-    assert "USAGE" in cmd.stderr
+    assert "usage" in cmd.stderr.lower()
 
 
 def test_help():
     cmd = grm(["--help"])
-    assert "USAGE" in cmd.stdout
+    assert "usage" in cmd.stdout.lower()

e2e_tests/test_repos_find.py

@@ -1,12 +1,13 @@
 #!/usr/bin/env python3
 
+import os
+import re
 import tempfile
 
-import toml
 import pytest
+import toml
 import yaml
-
-from helpers import *
+from helpers import NonExistentPath, TempGitRepository, grm, shell
 
 
 def test_repos_find_nonexistent():
@@ -40,7 +41,7 @@ def test_repos_find_invalid_format():
         )
         assert cmd.returncode != 0
         assert len(cmd.stdout) == 0
-        assert "isn't a valid value" in cmd.stderr
+        assert "invalid value 'invalidformat'" in cmd.stderr
 
 
 def test_repos_find_non_git_repos():
@@ -63,9 +64,10 @@ def test_repos_find_non_git_repos():
         assert len(cmd.stderr) != 0
 
 
-@pytest.mark.parametrize("default", [True, False])
+@pytest.mark.parametrize("default_format", [True, False])
 @pytest.mark.parametrize("configtype", ["toml", "yaml"])
-def test_repos_find(configtype, default):
+@pytest.mark.parametrize("exclude", [None, "^.*/repo2$", "^not_matching$"])
+def test_repos_find(configtype, exclude, default_format):
     with tempfile.TemporaryDirectory() as tmpdir:
         shell(
             f"""
@@ -73,7 +75,7 @@ def test_repos_find(configtype, default):
             mkdir repo1
             (
                 cd ./repo1
-                git init
+                git -c init.defaultBranch=master init
                 echo test > test
                 git add test
                 git commit -m "commit1"
@@ -83,7 +85,7 @@ def test_repos_find(configtype, default):
             mkdir repo2
             (
                 cd ./repo2
-                git init
+                git -c init.defaultBranch=master init
                 git checkout -b main
                 echo test > test
                 git add test
@@ -99,13 +101,19 @@ def test_repos_find(configtype, default):
         )
 
         args = ["repos", "find", "local", tmpdir]
-        if not default:
+        if not default_format:
             args += ["--format", configtype]
+        if exclude:
+            args += ["--exclude", exclude]
         cmd = grm(args)
         assert cmd.returncode == 0
-        assert len(cmd.stderr) == 0
+        if exclude == "^.*/repo2$":
+            assert re.match(r"^.*\[skipped\] .*\/repo2$", cmd.stderr.lower())
+            assert "repo2" in cmd.stderr.lower()
+        else:
+            assert len(cmd.stderr) == 0
 
-        if default or configtype == "toml":
+        if default_format or configtype == "toml":
             output = toml.loads(cmd.stdout)
         elif configtype == "yaml":
             output = yaml.safe_load(cmd.stdout)
@@ -120,7 +128,7 @@ def test_repos_find(configtype, default):
             assert set(tree.keys()) == {"root", "repos"}
             assert tree["root"] == tmpdir
             assert isinstance(tree["repos"], list)
-            assert len(tree["repos"]) == 2
+            assert len(tree["repos"]) == (1 if exclude == "^.*/repo2$" else 2)
 
             repo1 = [r for r in tree["repos"] if r["name"] == "repo1"][0]
             assert repo1["worktree_setup"] is False
@@ -137,30 +145,32 @@ def test_repos_find(configtype, default):
             assert someremote["type"] == "ssh"
             assert someremote["url"] == "ssh://example.com/repo2.git"
 
-            repo2 = [r for r in tree["repos"] if r["name"] == "repo2"][0]
-            assert repo2["worktree_setup"] is False
-            assert isinstance(repo1["remotes"], list)
-            assert len(repo2["remotes"]) == 1
+            if exclude == "^.*/repo2$":
+                assert [r for r in tree["repos"] if r["name"] == "repo2"] == []
+            else:
+                repo2 = [r for r in tree["repos"] if r["name"] == "repo2"][0]
+                assert repo2["worktree_setup"] is False
+                assert isinstance(repo1["remotes"], list)
+                assert len(repo2["remotes"]) == 1
 
-            origin = [r for r in repo2["remotes"] if r["name"] == "origin"][0]
-            assert set(origin.keys()) == {"name", "type", "url"}
-            assert origin["type"] == "https"
-            assert origin["url"] == "https://example.com/repo2.git"
+                origin = [r for r in repo2["remotes"] if r["name"] == "origin"][0]
+                assert set(origin.keys()) == {"name", "type", "url"}
+                assert origin["type"] == "https"
+                assert origin["url"] == "https://example.com/repo2.git"
 
 
-@pytest.mark.parametrize("default", [True, False])
+@pytest.mark.parametrize("default_format", [True, False])
 @pytest.mark.parametrize("configtype", ["toml", "yaml"])
-def test_repos_find_in_root(configtype, default):
+def test_repos_find_in_root(configtype, default_format):
     with TempGitRepository() as repo_dir:
-
         args = ["repos", "find", "local", repo_dir]
-        if not default:
+        if not default_format:
             args += ["--format", configtype]
         cmd = grm(args)
         assert cmd.returncode == 0
         assert len(cmd.stderr) == 0
 
-        if default or configtype == "toml":
+        if default_format or configtype == "toml":
             output = toml.loads(cmd.stdout)
         elif configtype == "yaml":
             output = yaml.safe_load(cmd.stdout)
@@ -194,8 +204,8 @@ def test_repos_find_in_root(configtype, default):
 
 
 @pytest.mark.parametrize("configtype", ["toml", "yaml"])
-@pytest.mark.parametrize("default", [True, False])
-def test_repos_find_with_invalid_repo(configtype, default):
+@pytest.mark.parametrize("default_format", [True, False])
+def test_repos_find_with_invalid_repo(configtype, default_format):
     with tempfile.TemporaryDirectory() as tmpdir:
         shell(
             f"""
@@ -203,7 +213,7 @@ def test_repos_find_with_invalid_repo(configtype, default):
             mkdir repo1
             (
                 cd ./repo1
-                git init
+                git -c init.defaultBranch=master init
                 echo test > test
                 git add test
                 git commit -m "commit1"
@@ -213,7 +223,7 @@ def test_repos_find_with_invalid_repo(configtype, default):
             mkdir repo2
             (
                 cd ./repo2
-                git init
+                git -c init.defaultBranch=master init
                 git checkout -b main
                 echo test > test
                 git add test
@@ -229,13 +239,13 @@ def test_repos_find_with_invalid_repo(configtype, default):
         )
 
         args = ["repos", "find", "local", tmpdir]
-        if not default:
+        if not default_format:
             args += ["--format", configtype]
         cmd = grm(args)
         assert cmd.returncode == 0
         assert "broken" in cmd.stderr
 
-        if default or configtype == "toml":
+        if default_format or configtype == "toml":
             output = toml.loads(cmd.stdout)
         elif configtype == "yaml":
             output = yaml.safe_load(cmd.stdout)

e2e_tests/test_repos_find_remote.py

@@ -1,14 +1,13 @@
 #!/usr/bin/env python3
 
-import re
 import os
+import re
+import tempfile
 
-import toml
 import pytest
+import toml
 import yaml
-
-from helpers import *
-
+from helpers import grm
 
 ALTERNATE_DOMAIN = os.environ["ALTERNATE_DOMAIN"]
 PROVIDERS = ["github", "gitlab"]
@@ -44,7 +43,9 @@ def test_repos_find_remote_invalid_provider(use_config):
     assert cmd.returncode != 0
     assert len(cmd.stdout) == 0
     if not use_config:
-        assert re.match(".*isn't a valid value for.*provider", cmd.stderr)
+        assert re.match(
+            ".*invalid value 'thisproviderdoesnotexist' for.*provider", cmd.stderr
+        )
 
 
 @pytest.mark.parametrize("provider", PROVIDERS)
@@ -67,7 +68,7 @@ def test_repos_find_remote_invalid_format(provider):
     )
     assert cmd.returncode != 0
     assert len(cmd.stdout) == 0
-    assert "isn't a valid value" in cmd.stderr
+    assert "invalid value 'invalidformat'" in cmd.stderr
 
 
 @pytest.mark.parametrize("provider", PROVIDERS)
@@ -166,7 +167,7 @@ def test_repos_find_remote_no_filter(provider, configtype, default, use_config):
         cmd = grm(args)
 
     assert cmd.returncode == 0
-    assert len(cmd.stderr) == 0
+    assert "did not specify any filters" in cmd.stderr.lower()
 
     if default or configtype == "toml":
         output = toml.loads(cmd.stdout)
@@ -248,6 +249,7 @@ def test_repos_find_remote_user_empty(
 @pytest.mark.parametrize("force_ssh", [True, False])
 @pytest.mark.parametrize("use_alternate_endpoint", [True, False])
 @pytest.mark.parametrize("use_config", [True, False])
+@pytest.mark.parametrize("override_remote_name", [True, False])
 def test_repos_find_remote_user(
     provider,
     configtype,
@@ -258,6 +260,7 @@ def test_repos_find_remote_user(
     force_ssh,
     use_alternate_endpoint,
     use_config,
+    override_remote_name,
 ):
     if use_config:
         with tempfile.NamedTemporaryFile() as config:
@@ -273,7 +276,9 @@ def test_repos_find_remote_user(
                 if not worktree_default:
                     cfg += f"worktree = {str(worktree).lower()}\n"
                 if force_ssh:
-                    cfg += f"force_ssh = true\n"
+                    cfg += "force_ssh = true\n"
+                if override_remote_name:
+                    cfg += 'remote_name = "otherremote"\n'
                 if use_owner:
                     cfg += """
                         [filters]
@@ -310,6 +315,8 @@ def test_repos_find_remote_user(
             args += ["--user", "myuser1"]
         if force_ssh:
             args += ["--force-ssh"]
+        if override_remote_name:
+            args += ["--remote-name", "otherremote"]
         if not worktree_default:
             args += ["--worktree", str(worktree).lower()]
         if use_alternate_endpoint:
@@ -350,7 +357,10 @@ def test_repos_find_remote_user(
         assert repo["worktree_setup"] is (not worktree_default and worktree)
         assert isinstance(repo["remotes"], list)
         assert len(repo["remotes"]) == 1
-        assert repo["remotes"][0]["name"] == provider
+        if override_remote_name:
+            assert repo["remotes"][0]["name"] == "otherremote"
+        else:
+            assert repo["remotes"][0]["name"] == "origin"
         if force_ssh or i == 1:
             assert (
                 repo["remotes"][0]["url"]
@@ -466,7 +476,7 @@ def test_repos_find_remote_group(
                 if not worktree_default:
                     cfg += f"worktree = {str(worktree).lower()}\n"
                 if force_ssh:
-                    cfg += f"force_ssh = true\n"
+                    cfg += "force_ssh = true\n"
                 if use_alternate_endpoint:
                     cfg += f'api_url = "http://{ALTERNATE_DOMAIN}:5000/{provider}"\n'
                 cfg += """
@@ -535,14 +545,14 @@ def test_repos_find_remote_group(
         assert isinstance(repo["remotes"], list)
         assert len(repo["remotes"]) == 1
         if force_ssh or i == 1:
-            assert repo["remotes"][0]["name"] == provider
+            assert repo["remotes"][0]["name"] == "origin"
             assert (
                 repo["remotes"][0]["url"]
                 == f"ssh://git@example.com/mygroup1/myproject{i}.git"
             )
             assert repo["remotes"][0]["type"] == "ssh"
         else:
-            assert repo["remotes"][0]["name"] == provider
+            assert repo["remotes"][0]["name"] == "origin"
             assert (
                 repo["remotes"][0]["url"]
                 == f"https://example.com/mygroup1/myproject{i}.git"
@@ -582,7 +592,7 @@ def test_repos_find_remote_user_and_group(
                 if not worktree_default:
                     cfg += f"worktree = {str(worktree).lower()}\n"
                 if force_ssh:
-                    cfg += f"force_ssh = true\n"
+                    cfg += "force_ssh = true\n"
                 if use_alternate_endpoint:
                     cfg += f'api_url = "http://{ALTERNATE_DOMAIN}:5000/{provider}"\n'
                 cfg += """
@@ -659,7 +669,7 @@ def test_repos_find_remote_user_and_group(
         assert repo["worktree_setup"] is (not worktree_default and worktree)
         assert isinstance(repo["remotes"], list)
         assert len(repo["remotes"]) == 1
-        assert repo["remotes"][0]["name"] == provider
+        assert repo["remotes"][0]["name"] == "origin"
         if force_ssh or i == 1:
             assert (
                 repo["remotes"][0]["url"]
@@ -684,7 +694,7 @@ def test_repos_find_remote_user_and_group(
         assert repo["worktree_setup"] is (not worktree_default and worktree)
         assert isinstance(repo["remotes"], list)
         assert len(repo["remotes"]) == 1
-        assert repo["remotes"][0]["name"] == provider
+        assert repo["remotes"][0]["name"] == "origin"
         if force_ssh or i == 1:
             assert (
                 repo["remotes"][0]["url"]
@@ -733,7 +743,7 @@ def test_repos_find_remote_owner(
                 if not worktree_default:
                     cfg += f"worktree = {str(worktree).lower()}\n"
                 if force_ssh:
-                    cfg += f"force_ssh = true\n"
+                    cfg += "force_ssh = true\n"
                 if use_alternate_endpoint:
                     cfg += f'api_url = "http://{ALTERNATE_DOMAIN}:5000/{provider}"\n'
                 cfg += """
@@ -814,7 +824,7 @@ def test_repos_find_remote_owner(
             assert repo["worktree_setup"] is (not worktree_default and worktree)
             assert isinstance(repo["remotes"], list)
             assert len(repo["remotes"]) == 1
-            assert repo["remotes"][0]["name"] == provider
+            assert repo["remotes"][0]["name"] == "origin"
             if force_ssh or i == 1:
                 assert (
                     repo["remotes"][0]["url"]
@@ -837,7 +847,7 @@ def test_repos_find_remote_owner(
             assert repo["worktree_setup"] is (not worktree_default and worktree)
             assert isinstance(repo["remotes"], list)
             assert len(repo["remotes"]) == 1
-            assert repo["remotes"][0]["name"] == provider
+            assert repo["remotes"][0]["name"] == "origin"
             if force_ssh or i == 1:
                 assert (
                     repo["remotes"][0]["url"]
@@ -861,16 +871,14 @@ def test_repos_find_remote_owner(
     assert repo["worktree_setup"] is (not worktree_default and worktree)
     assert isinstance(repo["remotes"], list)
     assert len(repo["remotes"]) == 1
-    assert repo["remotes"][0]["name"] == provider
+    assert repo["remotes"][0]["name"] == "origin"
     if force_ssh:
         assert (
-            repo["remotes"][0]["url"] == f"ssh://git@example.com/myuser2/myproject3.git"
+            repo["remotes"][0]["url"] == "ssh://git@example.com/myuser2/myproject3.git"
         )
         assert repo["remotes"][0]["type"] == "ssh"
     else:
-        assert (
-            repo["remotes"][0]["url"] == f"https://example.com/myuser2/myproject3.git"
-        )
+        assert repo["remotes"][0]["url"] == "https://example.com/myuser2/myproject3.git"
         assert repo["remotes"][0]["type"] == "https"
 
     group_namespace_1 = [t for t in output["trees"] if t["root"] == "/myroot/mygroup1"][
@@ -890,7 +898,7 @@ def test_repos_find_remote_owner(
             assert repo["worktree_setup"] is (not worktree_default and worktree)
             assert isinstance(repo["remotes"], list)
             assert len(repo["remotes"]) == 1
-            assert repo["remotes"][0]["name"] == provider
+            assert repo["remotes"][0]["name"] == "origin"
             if force_ssh or i == 1:
                 assert (
                     repo["remotes"][0]["url"]
@@ -910,17 +918,17 @@ def test_repos_find_remote_owner(
         assert repo["worktree_setup"] is (not worktree_default and worktree)
         assert isinstance(repo["remotes"], list)
         assert len(repo["remotes"]) == 1
-        assert repo["remotes"][0]["name"] == provider
+        assert repo["remotes"][0]["name"] == "origin"
         if force_ssh:
             assert (
                 repo["remotes"][0]["url"]
-                == f"ssh://git@example.com/mygroup1/myproject4.git"
+                == "ssh://git@example.com/mygroup1/myproject4.git"
             )
             assert repo["remotes"][0]["type"] == "ssh"
         else:
             assert (
                 repo["remotes"][0]["url"]
-                == f"https://example.com/mygroup1/myproject4.git"
+                == "https://example.com/mygroup1/myproject4.git"
             )
             assert repo["remotes"][0]["type"] == "https"
 
@@ -936,15 +944,14 @@ def test_repos_find_remote_owner(
     assert repo["worktree_setup"] is (not worktree_default and worktree)
     assert isinstance(repo["remotes"], list)
     assert len(repo["remotes"]) == 1
-    assert repo["remotes"][0]["name"] == provider
+    assert repo["remotes"][0]["name"] == "origin"
     if force_ssh:
         assert (
-            repo["remotes"][0]["url"]
-            == f"ssh://git@example.com/mygroup2/myproject5.git"
+            repo["remotes"][0]["url"] == "ssh://git@example.com/mygroup2/myproject5.git"
         )
         assert repo["remotes"][0]["type"] == "ssh"
     else:
         assert (
-            repo["remotes"][0]["url"] == f"https://example.com/mygroup2/myproject5.git"
+            repo["remotes"][0]["url"] == "https://example.com/mygroup2/myproject5.git"
         )
         assert repo["remotes"][0]["type"] == "https"

e2e_tests/test_repos_status.py

@@ -1,8 +1,6 @@
 #!/usr/bin/env python3
 
-import tempfile
-
-from helpers import *
+from helpers import RepoTree, grm
 
 
 def test_repos_sync_worktree_clone():

e2e_tests/test_repos_sync.py

@@ -1,14 +1,21 @@
 #!/usr/bin/env python3
 
-import tempfile
+import os
 import re
+import subprocess
+import tempfile
 import textwrap
 
-import pytest
-import toml
 import git
-
-from helpers import *
+import pytest
+from helpers import (
+    NonExistentPath,
+    TempGitFileRemote,
+    TempGitRepository,
+    checksum_directory,
+    grm,
+    shell,
+)
 
 templates = {
     "repo_simple": {
@@ -291,7 +298,9 @@ def test_repos_sync_unmanaged_repos(configtype):
                 # this removes the prefix (root) from the path (unmanaged_repo)
                 unmanaged_repo_name = os.path.relpath(unmanaged_repo, root)
                 regex = f".*unmanaged.*{unmanaged_repo_name}"
-                assert any([re.match(regex, l) for l in cmd.stderr.lower().split("\n")])
+                assert any(
+                    [re.match(regex, line) for line in cmd.stderr.lower().split("\n")]
+                )
 
 
 @pytest.mark.parametrize("configtype", ["toml", "yaml"])
@@ -303,7 +312,7 @@ def test_repos_sync_root_is_file(configtype):
 
             cmd = grm(["repos", "sync", "config", "--config", config.name])
             assert cmd.returncode != 0
-            assert "not a directory" in cmd.stderr.lower()
+            assert "notadirectory" in cmd.stderr.lower()
 
 
 @pytest.mark.parametrize("configtype", ["toml", "yaml"])
@@ -374,7 +383,7 @@ def test_repos_sync_repo_in_subdirectory(configtype):
                     assert urls[0] == f"file://{remote}"
 
                 cmd = grm(["repos", "sync", "config", "--config", config.name])
-                assert not "found unmanaged repository" in cmd.stderr.lower()
+                assert "found unmanaged repository" not in cmd.stderr.lower()
 
 
 @pytest.mark.parametrize("configtype", ["toml", "yaml"])
@@ -419,7 +428,7 @@ def test_repos_sync_nested_clone(configtype):
                     cmd = grm(["repos", "sync", "config", "--config", config.name])
                     print(cmd.stdout)
                     print(cmd.stderr)
-                    assert not "found unmanaged repository" in cmd.stderr.lower()
+                    assert "found unmanaged repository" not in cmd.stderr.lower()
 
 
 @pytest.mark.parametrize("configtype", ["toml", "yaml"])
@@ -720,14 +729,14 @@ def test_repos_sync_invalid_syntax(configtype):
         with open(config.name, "w") as f:
             if configtype == "toml":
                 f.write(
-                    f"""
+                    """
                     [[trees]]
                     root = invalid as there are no quotes ;)
                 """
                 )
             elif configtype == "yaml":
                 f.write(
-                    f"""
+                    """
                     trees:
                     wrong:
                     indentation:
@@ -779,8 +788,6 @@ def test_repos_sync_normal_change_to_worktree(configtype):
                     cmd = grm(["repos", "sync", "config", "--config", config.name])
                     assert cmd.returncode == 0
 
-                    git_dir = os.path.join(target, "test")
-
                     with open(config.name, "w") as f:
                         f.write(
                             templates["worktree_repo_with_remote"][configtype].format(
@@ -810,8 +817,6 @@ def test_repos_sync_worktree_change_to_normal(configtype):
                     cmd = grm(["repos", "sync", "config", "--config", config.name])
                     assert cmd.returncode == 0
 
-                    git_dir = os.path.join(target, "test")
-
                     with open(config.name, "w") as f:
                         f.write(
                             templates["repo_with_remote"][configtype].format(

e2e_tests/test_worktree_clean.py

@@ -1,12 +1,21 @@
 #!/usr/bin/env python3
 
-import pytest
+import os
 
-from helpers import *
+import pytest
+from helpers import (
+    NonGitDir,
+    TempGitRepository,
+    TempGitRepositoryWorktree,
+    checksum_directory,
+    funcname,
+    grm,
+    shell,
+)
 
 
 def test_worktree_clean():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test", "--track", "origin/test"], cwd=base_dir)
         assert cmd.returncode == 0
         assert "test" in os.listdir(base_dir)
@@ -17,7 +26,7 @@ def test_worktree_clean():
 
 
 def test_worktree_clean_refusal_no_tracking_branch():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test"], cwd=base_dir)
         assert cmd.returncode == 0
 
@@ -31,7 +40,7 @@ def test_worktree_clean_refusal_no_tracking_branch():
 
 
 def test_worktree_clean_refusal_uncommited_changes_new_file():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test", "--track", "origin/test"], cwd=base_dir)
         assert cmd.returncode == 0
 
@@ -47,7 +56,7 @@ def test_worktree_clean_refusal_uncommited_changes_new_file():
 
 
 def test_worktree_clean_refusal_uncommited_changes_changed_file():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test", "--track", "origin/test"], cwd=base_dir)
         assert cmd.returncode == 0
 
@@ -63,7 +72,7 @@ def test_worktree_clean_refusal_uncommited_changes_changed_file():
 
 
 def test_worktree_clean_refusal_uncommited_changes_cleand_file():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test", "--track", "origin/test"], cwd=base_dir)
         assert cmd.returncode == 0
 
@@ -81,7 +90,7 @@ def test_worktree_clean_refusal_uncommited_changes_cleand_file():
 
 
 def test_worktree_clean_refusal_commited_changes():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test", "--track", "origin/test"], cwd=base_dir)
         assert cmd.returncode == 0
 
@@ -99,7 +108,7 @@ def test_worktree_clean_refusal_commited_changes():
 
 
 def test_worktree_clean_refusal_tracking_branch_mismatch():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test", "--track", "origin/test"], cwd=base_dir)
         assert cmd.returncode == 0
 
@@ -117,7 +126,7 @@ def test_worktree_clean_refusal_tracking_branch_mismatch():
 
 
 def test_worktree_clean_fail_from_subdir():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test"], cwd=base_dir)
         assert cmd.returncode == 0
 
@@ -148,18 +157,18 @@ def test_worktree_clean_non_git():
 def test_worktree_clean_configured_default_branch(
     configure_default_branch, branch_list_empty
 ):
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         if configure_default_branch:
             with open(os.path.join(base_dir, "grm.toml"), "w") as f:
                 if branch_list_empty:
                     f.write(
-                        f"""
+                        """
                         persistent_branches = []
                     """
                     )
                 else:
                     f.write(
-                        f"""
+                        """
                         persistent_branches = [
                             "mybranch"
                         ]

e2e_tests/test_worktree_config_presistent_branch.py

@@ -2,11 +2,12 @@
 
 import os.path
 
-from helpers import *
+import git
+from helpers import TempGitRepositoryWorktree, checksum_directory, funcname, grm, shell
 
 
 def test_worktree_never_clean_persistent_branches():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         with open(os.path.join(base_dir, "grm.toml"), "w") as f:
             f.write(
                 """
@@ -33,7 +34,7 @@ def test_worktree_never_clean_persistent_branches():
 
 
 def test_worktree_clean_branch_merged_into_persistent():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         with open(os.path.join(base_dir, "grm.toml"), "w") as f:
             f.write(
                 """
@@ -72,7 +73,7 @@ def test_worktree_clean_branch_merged_into_persistent():
 
 
 def test_worktree_no_clean_unmerged_branch():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         with open(os.path.join(base_dir, "grm.toml"), "w") as f:
             f.write(
                 """
@@ -105,7 +106,7 @@ def test_worktree_no_clean_unmerged_branch():
 
 
 def test_worktree_delete_branch_merged_into_persistent():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         with open(os.path.join(base_dir, "grm.toml"), "w") as f:
             f.write(
                 """

e2e_tests/test_worktree_conversion.py

@@ -1,8 +1,16 @@
 #!/usr/bin/env python3
 
-import tempfile
+import os
 
-from helpers import *
+from helpers import (
+    EmptyDir,
+    NonGitDir,
+    TempGitRepository,
+    TempGitRepositoryWorktree,
+    checksum_directory,
+    funcname,
+    grm,
+)
 
 
 def test_convert():
@@ -23,7 +31,7 @@ def test_convert():
 
 
 def test_convert_already_worktree():
-    with TempGitRepositoryWorktree() as (git_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (git_dir, _commit):
         before = checksum_directory(git_dir)
 
         cmd = grm(["wt", "convert"], cwd=git_dir)

e2e_tests/test_worktree_fetch.py

@@ -1,15 +1,21 @@
 #!/usr/bin/env python3
 
-from helpers import *
-
 import re
 
-import pytest
 import git
+import pytest
+from helpers import (
+    EmptyDir,
+    TempGitFileRemote,
+    TempGitRepositoryWorktree,
+    funcname,
+    grm,
+    shell,
+)
 
 
 def test_worktree_fetch():
-    with TempGitRepositoryWorktree() as (base_dir, root_commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, root_commit):
         with TempGitFileRemote() as (remote_path, _remote_sha):
             shell(
                 f"""
@@ -56,7 +62,7 @@ def test_worktree_fetch():
 @pytest.mark.parametrize("has_changes", [True, False])
 @pytest.mark.parametrize("stash", [True, False])
 def test_worktree_pull(rebase, ffable, has_changes, stash):
-    with TempGitRepositoryWorktree() as (base_dir, root_commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, root_commit):
         with TempGitFileRemote() as (remote_path, _remote_sha):
             shell(
                 f"""

e2e_tests/test_worktree_rebase.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 
-from helpers import *
-
+import os
 import re
 
-import pytest
 import git
+import pytest
+from helpers import TempGitRepositoryWorktree, funcname, grm, shell
 
 
 @pytest.mark.parametrize("pull", [True, False])
@@ -14,7 +14,7 @@ import git
 @pytest.mark.parametrize("has_changes", [True, False])
 @pytest.mark.parametrize("stash", [True, False])
 def test_worktree_rebase(pull, rebase, ffable, has_changes, stash):
-    with TempGitRepositoryWorktree() as (base_dir, _root_commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _root_commit):
         with open(os.path.join(base_dir, "grm.toml"), "w") as f:
             f.write('persistent_branches = ["mybasebranch"]')
 

e2e_tests/test_worktree_status.py

@@ -1,15 +1,22 @@
 #!/usr/bin/env python3
 
+import os
 import re
 
-from helpers import *
-
 import pytest
+from helpers import (
+    NonGitDir,
+    TempGitRepository,
+    TempGitRepositoryWorktree,
+    funcname,
+    grm,
+    shell,
+)
 
 
 @pytest.mark.parametrize("has_config", [True, False])
 def test_worktree_status(has_config):
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         if has_config:
             with open(os.path.join(base_dir, "grm.toml"), "w") as f:
                 f.write("")
@@ -24,7 +31,7 @@ def test_worktree_status(has_config):
 
 
 def test_worktree_status_fail_from_subdir():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test"], cwd=base_dir)
         assert cmd.returncode == 0
 
@@ -51,7 +58,7 @@ def test_worktree_status_non_git():
 
 
 def test_worktree_status_warn_with_non_worktree_dir():
-    with TempGitRepositoryWorktree() as (base_dir, _commit):
+    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, _commit):
         cmd = grm(["wt", "add", "test"], cwd=base_dir)
         assert cmd.returncode == 0
 

release.sh

@@ -0,0 +1,163 @@
+#!/usr/bin/env bash
+
+set -o nounset
+set -o errexit
+set -o pipefail
+
+usage() {
+    printf '%s\n' "usage: $0 (major|minor|patch)" >&2
+}
+
+if (($# != 1)); then
+    usage
+    exit 1
+fi
+
+current_version="$(grep '^version \?=' Cargo.toml | head -1 | cut -d '=' -f 2 | tr -d " '"'"')"
+
+major="$(printf '%s' "${current_version}" | grep -oP '^\d+')"
+minor="$(printf '%s' "${current_version}" | grep -oP '\.\d+\.' | tr -d '.')"
+patch="$(printf '%s' "${current_version}" | grep -oP '\d+$' | tr -d '.')"
+
+case "$1" in
+major)
+    ((major++)) || true
+    minor=0
+    patch=0
+
+    printf '%s\n' "Are you sure you want to release 1.x?" >&2
+    exit 1
+    ;;
+minor)
+    ((minor++)) || true
+    patch=0
+    ;;
+patch)
+    ((patch++)) || true
+    ;;
+*)
+    usage
+    exit 1
+    ;;
+esac
+
+new_version="${major}.${minor}.${patch}"
+
+if ! [[ "${new_version}" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+    printf '%s\n' 'Version has to a complete semver' >&2
+    exit 1
+fi
+
+current_branch="$(git rev-parse --abbrev-ref HEAD)"
+if [[ "${current_branch}" != "develop" ]]; then
+    printf '%s\n' 'You need to be on develop' >&2
+    exit 1
+fi
+
+gitstatus="$(git status --porcelain)"
+if [[ -n "${gitstatus}" ]]; then
+    printf '%s\n' 'There are uncommitted changes' >&2
+    exit 1
+fi
+
+if git tag --list "v${new_version}" | grep -q .; then
+    printf 'Tag %s already exists\n' "v${new_version}" >&2
+    exit 1
+fi
+
+for remote in $(git remote); do
+    if git ls-remote --tags "${remote}" | grep -q "refs/tags/v${new_version}$"; then
+        printf 'Tag %s already exists on %s\n' "v${new_version}" "${remote}" >&2
+        exit 1
+    fi
+done
+
+git fetch --all
+
+for remote in $(git remote); do
+    for branch in master develop; do
+        if ! git diff --quiet "${remote}/${branch}..${branch}"; then
+            printf 'Remote branch %s/%s not up to date, synchronize first!\n' "${remote}" "${branch}" >&2
+            exit 1
+        fi
+    done
+done
+
+if ! git merge-base --is-ancestor master develop; then
+    printf '%s\n' 'Develop is not a straight descendant of master, rebase!' >&2
+    exit 1
+fi
+
+changes="$(git log --oneline master..develop | wc -l)"
+if ((changes == 0)); then
+    printf '%s\n' 'No changes between master and develop?' >&2
+    exit 1
+fi
+
+sed -i "0,/^version/{s/^version.*$/version = \"${new_version}\"/}" Cargo.toml
+
+cargo update --package git-repo-manager --precise "${new_version}"
+
+diff="$(git diff --numstat)"
+if (($(printf '%s\n' "${diff}" | wc -l || true) != 2)); then
+    printf '%s\n' 'Weird changes detected, bailing' >&2
+    exit 1
+fi
+
+if ! printf '%s\n' "${diff}" | grep -Pq '^1\s+1\s+Cargo.lock$'; then
+    printf '%s\n' 'Weird changes detected, bailing' >&2
+    exit 1
+fi
+
+if ! printf '%s\n' "${diff}" | grep -Pq '^1\s+1\s+Cargo.toml$'; then
+    printf '%s\n' 'Weird changes detected, bailing' >&2
+    exit 1
+fi
+
+git add Cargo.lock Cargo.toml
+
+git commit -m "Release v${new_version}"
+
+git switch master 2>/dev/null || { [[ -d "../master" ]] && cd "../master"; } || {
+    printf '%s\n' 'Could not change to master' >&2
+    exit 1
+}
+
+current_branch="$(git rev-parse --abbrev-ref HEAD)"
+if [[ "${current_branch}" != "master" ]]; then
+    printf '%s\n' 'Looks like branch switching to master did not work' >&2
+    exit 1
+fi
+
+git merge --no-ff --no-edit develop
+git tag "v${new_version}"
+
+for remote in $(git remote); do
+    while ! git push "${remote}" "v${new_version}" master; do
+        :
+    done
+done
+
+git switch develop 2>/dev/null || { [[ -d "../develop" ]] && cd "../develop"; } || {
+    printf '%s\n' 'Could not change to develop' >&2
+    exit 1
+}
+
+current_branch="$(git rev-parse --abbrev-ref HEAD)"
+if [[ "${current_branch}" != "develop" ]]; then
+    printf '%s\n' 'Looks like branch switching to develop did not work' >&2
+    exit 1
+fi
+
+git merge --ff-only master
+
+for remote in $(git remote); do
+    while ! git push "${remote}" develop; do
+        :
+    done
+done
+
+cargo publish
+
+printf 'Published %s successfully\n' "${new_version}"
+exit 0

rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "stable"
+targets = ["x86_64-unknown-linux-musl"]

src/config.rs

@@ -33,6 +33,7 @@ pub struct ConfigTrees {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct ConfigProviderFilter {
     pub access: Option<bool>,
     pub owner: Option<bool>,
@@ -41,6 +42,7 @@ pub struct ConfigProviderFilter {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct ConfigProvider {
     pub provider: RemoteProvider,
     pub token_command: String,
@@ -52,7 +54,8 @@ pub struct ConfigProvider {
     pub api_url: Option<String>,
 
     pub worktree: Option<bool>,
-    pub init_worktree: Option<bool>,
+
+    pub remote_name: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -180,6 +183,12 @@ impl Config {
                     filters.access.unwrap_or(false),
                 );
 
+                if filter.empty() {
+                    print_warning(
+                        "The configuration does not contain any filters, so no repos will match",
+                    );
+                }
+
                 let repos = match config.provider {
                     RemoteProvider::Github => {
                         match provider::Github::new(filter, token, config.api_url) {
@@ -192,6 +201,7 @@ impl Config {
                         .get_repos(
                             config.worktree.unwrap_or(false),
                             config.force_ssh.unwrap_or(false),
+                            config.remote_name,
                         )?
                     }
                     RemoteProvider::Gitlab => {
@@ -205,6 +215,7 @@ impl Config {
                         .get_repos(
                             config.worktree.unwrap_or(false),
                             config.force_ssh.unwrap_or(false),
+                            config.remote_name,
                         )?
                     }
                 };
@@ -237,7 +248,7 @@ impl Config {
 
     pub fn normalize(&mut self) {
         if let Config::ConfigTrees(config) = self {
-            let home = path::env_home().display().to_string();
+            let home = path::env_home();
             for tree in &mut config.trees_mut().iter_mut() {
                 if tree.root.starts_with(&home) {
                     // The tilde is not handled differently, it's just a normal path component for `Path`.
@@ -295,7 +306,7 @@ pub fn read_config<'a, T>(path: &str) -> Result<T, String>
 where
     T: for<'de> serde::Deserialize<'de>,
 {
-    let content = match std::fs::read_to_string(&path) {
+    let content = match std::fs::read_to_string(path) {
         Ok(s) => s,
         Err(e) => {
             return Err(format!(

src/grm/cmd.rs

@@ -1,4 +1,4 @@
-use clap::{AppSettings, Parser};
+use clap::Parser;
 
 #[derive(Parser)]
 #[clap(
@@ -7,7 +7,6 @@ use clap::{AppSettings, Parser};
     author = clap::crate_authors!("\n"),
     about = clap::crate_description!(),
     long_version = clap::crate_version!(),
-    global_setting(AppSettings::DeriveDisplayOrder),
     propagate_version = true,
 )]
 pub struct Opts {
@@ -65,7 +64,15 @@ pub struct FindLocalArgs {
     pub path: String,
 
     #[clap(
-        arg_enum,
+        short,
+        long,
+        help = "Exclude repositories that match the given regex",
+        name = "REGEX"
+    )]
+    pub exclude: Option<String>,
+
+    #[clap(
+        value_enum,
         short,
         long,
         help = "Format to produce",
@@ -85,7 +92,7 @@ pub struct FindConfigArgs {
     pub config: String,
 
     #[clap(
-        arg_enum,
+        value_enum,
         short,
         long,
         help = "Format to produce",
@@ -100,11 +107,14 @@ pub struct FindRemoteArgs {
     #[clap(short, long, help = "Path to the configuration file")]
     pub config: Option<String>,
 
-    #[clap(arg_enum, short, long, help = "Remote provider to use")]
+    #[clap(value_enum, short, long, help = "Remote provider to use")]
     pub provider: RemoteProvider,
 
+    #[clap(short, long, help = "Name of the remote to use")]
+    pub remote_name: Option<String>,
+
     #[clap(
-        multiple_occurrences = true,
+        action = clap::ArgAction::Append,
         name = "user",
         long,
         help = "Users to get repositories from"
@@ -112,7 +122,7 @@ pub struct FindRemoteArgs {
     pub users: Vec<String>,
 
     #[clap(
-        multiple_occurrences = true,
+        action = clap::ArgAction::Append,
         name = "group",
         long,
         help = "Groups to get repositories from"
@@ -135,7 +145,7 @@ pub struct FindRemoteArgs {
     pub root: String,
 
     #[clap(
-        arg_enum,
+        value_enum,
         short,
         long,
         help = "Format to produce",
@@ -146,11 +156,10 @@ pub struct FindRemoteArgs {
     #[clap(
         long,
         help = "Use worktree setup for repositories",
-        possible_values = &["true", "false"],
+        value_parser = ["true", "false"],
         default_value = "false",
         default_missing_value = "true",
-        min_values = 0,
-        max_values = 1,
+        num_args = 0..=1,
     )]
     pub worktree: String,
 
@@ -171,12 +180,11 @@ pub struct Config {
 
     #[clap(
         long,
+        value_parser = ["true", "false"],
         help = "Check out the default worktree after clone",
-        possible_values = &["true", "false"],
         default_value = "true",
         default_missing_value = "true",
-        min_values = 0,
-        max_values = 1,
+        num_args = 0..=1,
     )]
     pub init_worktree: String,
 }
@@ -186,11 +194,14 @@ pub type RemoteProvider = super::provider::RemoteProvider;
 #[derive(Parser)]
 #[clap()]
 pub struct SyncRemoteArgs {
-    #[clap(arg_enum, short, long, help = "Remote provider to use")]
+    #[clap(value_enum, short, long, help = "Remote provider to use")]
     pub provider: RemoteProvider,
 
+    #[clap(short, long, help = "Name of the remote to use")]
+    pub remote_name: Option<String>,
+
     #[clap(
-        multiple_occurrences = true,
+        action = clap::ArgAction::Append,
         name = "user",
         long,
         help = "Users to get repositories from"
@@ -198,7 +209,7 @@ pub struct SyncRemoteArgs {
     pub users: Vec<String>,
 
     #[clap(
-        multiple_occurrences = true,
+        action = clap::ArgAction::Append,
         name = "group",
         long,
         help = "Groups to get repositories from"
@@ -223,11 +234,10 @@ pub struct SyncRemoteArgs {
     #[clap(
         long,
         help = "Use worktree setup for repositories",
-        possible_values = &["true", "false"],
+        value_parser = ["true", "false"],
         default_value = "false",
         default_missing_value = "true",
-        min_values = 0,
-        max_values = 1,
+        num_args = 0..=1,
     )]
     pub worktree: String,
 
@@ -237,11 +247,10 @@ pub struct SyncRemoteArgs {
     #[clap(
         long,
         help = "Check out the default worktree after clone",
-        possible_values = &["true", "false"],
+        value_parser = ["true", "false"],
         default_value = "true",
         default_missing_value = "true",
-        min_values = 0,
-        max_values = 1,
+        num_args = 0..=1,
     )]
     pub init_worktree: String,
 }
@@ -253,7 +262,7 @@ pub struct OptionalConfig {
     pub config: Option<String>,
 }
 
-#[derive(clap::ArgEnum, Clone)]
+#[derive(clap::ValueEnum, Clone)]
 pub enum ConfigFormat {
     Yaml,
     Toml,
@@ -293,7 +302,7 @@ pub struct WorktreeAddArgs {
     #[clap(short = 't', long = "track", help = "Remote branch to track")]
     pub track: Option<String>,
 
-    #[clap(long = "--no-track", help = "Disable tracking")]
+    #[clap(long = "no-track", help = "Disable tracking")]
     pub no_track: bool,
 }
 #[derive(Parser)]
@@ -322,22 +331,19 @@ pub struct WorktreeFetchArgs {}
 
 #[derive(Parser)]
 pub struct WorktreePullArgs {
-    #[clap(long = "--rebase", help = "Perform a rebase instead of a fast-forward")]
+    #[clap(long = "rebase", help = "Perform a rebase instead of a fast-forward")]
     pub rebase: bool,
-    #[clap(long = "--stash", help = "Stash & unstash changes before & after pull")]
+    #[clap(long = "stash", help = "Stash & unstash changes before & after pull")]
     pub stash: bool,
 }
 
 #[derive(Parser)]
 pub struct WorktreeRebaseArgs {
-    #[clap(long = "--pull", help = "Perform a pull before rebasing")]
+    #[clap(long = "pull", help = "Perform a pull before rebasing")]
     pub pull: bool,
-    #[clap(long = "--rebase", help = "Perform a rebase when doing a pull")]
+    #[clap(long = "rebase", help = "Perform a rebase when doing a pull")]
     pub rebase: bool,
-    #[clap(
-        long = "--stash",
-        help = "Stash & unstash changes before & after rebase"
-    )]
+    #[clap(long = "stash", help = "Stash & unstash changes before & after rebase")]
     pub stash: bool,
 }
 

src/grm/main.rs

@@ -1,3 +1,5 @@
+#![forbid(unsafe_code)]
+
 use std::path::Path;
 use std::process;
 
@@ -36,7 +38,7 @@ fn main() {
                             }
                         }
                         Err(error) => {
-                            print_error(&format!("Error syncing trees: {}", error));
+                            print_error(&format!("Sync error: {}", error));
                             process::exit(1);
                         }
                     }
@@ -53,6 +55,10 @@ fn main() {
                     let filter =
                         provider::Filter::new(args.users, args.groups, args.owner, args.access);
 
+                    if filter.empty() {
+                        print_warning("You did not specify any filters, so no repos will match");
+                    }
+
                     let worktree = args.worktree == "true";
 
                     let repos = match args.provider {
@@ -60,21 +66,29 @@ fn main() {
                             match provider::Github::new(filter, token, args.api_url) {
                                 Ok(provider) => provider,
                                 Err(error) => {
-                                    print_error(&format!("Error: {}", error));
+                                    print_error(&format!("Sync error: {}", error));
                                     process::exit(1);
                                 }
                             }
-                            .get_repos(worktree, args.force_ssh)
+                            .get_repos(
+                                worktree,
+                                args.force_ssh,
+                                args.remote_name,
+                            )
                         }
                         cmd::RemoteProvider::Gitlab => {
                             match provider::Gitlab::new(filter, token, args.api_url) {
                                 Ok(provider) => provider,
                                 Err(error) => {
-                                    print_error(&format!("Error: {}", error));
+                                    print_error(&format!("Sync error: {}", error));
                                     process::exit(1);
                                 }
                             }
-                            .get_repos(worktree, args.force_ssh)
+                            .get_repos(
+                                worktree,
+                                args.force_ssh,
+                                args.remote_name,
+                            )
                         }
                     };
 
@@ -102,13 +116,13 @@ fn main() {
                                     }
                                 }
                                 Err(error) => {
-                                    print_error(&format!("Error syncing trees: {}", error));
+                                    print_error(&format!("Sync error: {}", error));
                                     process::exit(1);
                                 }
                             }
                         }
                         Err(error) => {
-                            print_error(&format!("Error: {}", error));
+                            print_error(&format!("Sync error: {}", error));
                             process::exit(1);
                         }
                     }
@@ -185,7 +199,8 @@ fn main() {
                         }
                     };
 
-                    let (found_repos, warnings) = match find_in_tree(&path) {
+                    let (found_repos, warnings) = match find_in_tree(&path, args.exclude.as_deref())
+                    {
                         Ok((repos, warnings)) => (repos, warnings),
                         Err(error) => {
                             print_error(&error);
@@ -268,6 +283,10 @@ fn main() {
                         filters.access.unwrap_or(false),
                     );
 
+                    if filter.empty() {
+                        print_warning("You did not specify any filters, so no repos will match");
+                    }
+
                     let repos = match config.provider {
                         provider::RemoteProvider::Github => {
                             match match provider::Github::new(filter, token, config.api_url) {
@@ -280,6 +299,7 @@ fn main() {
                             .get_repos(
                                 config.worktree.unwrap_or(false),
                                 config.force_ssh.unwrap_or(false),
+                                config.remote_name,
                             ) {
                                 Ok(provider) => provider,
                                 Err(error) => {
@@ -299,6 +319,7 @@ fn main() {
                             .get_repos(
                                 config.worktree.unwrap_or(false),
                                 config.force_ssh.unwrap_or(false),
+                                config.remote_name,
                             ) {
                                 Ok(provider) => provider,
                                 Err(error) => {
@@ -371,6 +392,10 @@ fn main() {
                     let filter =
                         provider::Filter::new(args.users, args.groups, args.owner, args.access);
 
+                    if filter.empty() {
+                        print_warning("You did not specify any filters, so no repos will match");
+                    }
+
                     let worktree = args.worktree == "true";
 
                     let repos = match args.provider {
@@ -382,7 +407,11 @@ fn main() {
                                     process::exit(1);
                                 }
                             }
-                            .get_repos(worktree, args.force_ssh)
+                            .get_repos(
+                                worktree,
+                                args.force_ssh,
+                                args.remote_name,
+                            )
                         }
                         cmd::RemoteProvider::Gitlab => {
                             match provider::Gitlab::new(filter, token, args.api_url) {
@@ -392,7 +421,11 @@ fn main() {
                                     process::exit(1);
                                 }
                             }
-                            .get_repos(worktree, args.force_ssh)
+                            .get_repos(
+                                worktree,
+                                args.force_ssh,
+                                args.remote_name,
+                            )
                         }
                     };
 
@@ -463,6 +496,9 @@ fn main() {
 
             match args.action {
                 cmd::WorktreeAction::Add(action_args) => {
+                    if action_args.track.is_some() && action_args.no_track {
+                        print_warning("You are using --track and --no-track at the same time. --track will be ignored");
+                    }
                     let track = match &action_args.track {
                         Some(branch) => {
                             let split = branch.split_once('/');
@@ -484,29 +520,20 @@ fn main() {
                         None => None,
                     };
 
-                    let mut name: &str = &action_args.name;
-                    let subdirectory;
-                    let split = name.split_once('/');
-                    match split {
-                        None => subdirectory = None,
-                        Some(split) => {
-                            if split.0.is_empty() || split.1.is_empty() {
-                                print_error("Worktree name cannot start or end with a slash");
-                                process::exit(1);
-                            } else {
-                                (subdirectory, name) = (Some(Path::new(split.0)), split.1);
-                            }
-                        }
-                    }
-
                     match worktree::add_worktree(
                         &cwd,
-                        name,
-                        subdirectory,
+                        &action_args.name,
                         track,
                         action_args.no_track,
                     ) {
-                        Ok(_) => print_success(&format!("Worktree {} created", &action_args.name)),
+                        Ok(warnings) => {
+                            if let Some(warnings) = warnings {
+                                for warning in warnings {
+                                    print_warning(&warning);
+                                }
+                            }
+                            print_success(&format!("Worktree {} created", &action_args.name));
+                        }
                         Err(error) => {
                             print_error(&format!("Error creating worktree: {}", error));
                             process::exit(1);
@@ -514,8 +541,6 @@ fn main() {
                     }
                 }
                 cmd::WorktreeAction::Delete(action_args) => {
-                    let worktree_dir = cwd.join(&action_args.name);
-
                     let worktree_config = match repo::read_worktree_root_config(&cwd) {
                         Ok(config) => config,
                         Err(error) => {
@@ -533,8 +558,9 @@ fn main() {
                     });
 
                     match repo.remove_worktree(
+                        &cwd,
                         &action_args.name,
-                        &worktree_dir,
+                        Path::new(&action_args.name),
                         action_args.force,
                         &worktree_config,
                     ) {

src/lib.rs

@@ -1,5 +1,4 @@
-#![feature(io_error_more)]
-#![feature(const_option_ext)]
+#![forbid(unsafe_code)]
 
 use std::path::Path;
 
@@ -13,19 +12,27 @@ pub mod table;
 pub mod tree;
 pub mod worktree;
 
-const BRANCH_NAMESPACE_SEPARATOR: &str = "/";
-
 /// Find all git repositories under root, recursively
 ///
 /// The bool in the return value specifies whether there is a repository
 /// in root itself.
 #[allow(clippy::type_complexity)]
-fn find_repos(root: &Path) -> Result<Option<(Vec<repo::Repo>, Vec<String>, bool)>, String> {
+fn find_repos(
+    root: &Path,
+    exclusion_pattern: Option<&str>,
+) -> Result<Option<(Vec<repo::Repo>, Vec<String>, bool)>, String> {
     let mut repos: Vec<repo::Repo> = Vec::new();
     let mut repo_in_root = false;
     let mut warnings = Vec::new();
 
+    let exlusion_regex: regex::Regex = regex::Regex::new(exclusion_pattern.unwrap_or(r"^$"))
+        .map_err(|e| format!("invalid regex: {e}"))?;
     for path in tree::find_repo_paths(root)? {
+        if exclusion_pattern.is_some() && exlusion_regex.is_match(&path::path_as_string(&path)) {
+            warnings.push(format!("[skipped] {}", &path::path_as_string(&path)));
+            continue;
+        }
+
         let is_worktree = repo::RepoHandle::detect_worktree(&path);
         if path == root {
             repo_in_root = true;
@@ -64,12 +71,13 @@ fn find_repos(root: &Path) -> Result<Option<(Vec<repo::Repo>, Vec<String>, bool)
                             let name = remote.name();
                             let url = remote.url();
                             let remote_type = match repo::detect_remote_type(&url) {
-                                Some(t) => t,
-                                None => {
+                                Ok(t) => t,
+                                Err(e) => {
                                     warnings.push(format!(
-                                        "{}: Could not detect remote type of \"{}\"",
+                                        "{}: Could not handle URL {}. Reason: {}",
                                         &path::path_as_string(&path),
-                                        &url
+                                        &url,
+                                        e
                                     ));
                                     continue;
                                 }
@@ -107,7 +115,7 @@ fn find_repos(root: &Path) -> Result<Option<(Vec<repo::Repo>, Vec<String>, bool)
                         },
                     )
                 } else {
-                    let name = path.strip_prefix(&root).unwrap();
+                    let name = path.strip_prefix(root).unwrap();
                     let namespace = name.parent().unwrap();
                     (
                         if namespace != Path::new("") {
@@ -131,10 +139,14 @@ fn find_repos(root: &Path) -> Result<Option<(Vec<repo::Repo>, Vec<String>, bool)
     Ok(Some((repos, warnings, repo_in_root)))
 }
 
-pub fn find_in_tree(path: &Path) -> Result<(tree::Tree, Vec<String>), String> {
+pub fn find_in_tree(
+    path: &Path,
+    exclusion_pattern: Option<&str>,
+) -> Result<(tree::Tree, Vec<String>), String> {
     let mut warnings = Vec::new();
 
-    let (repos, repo_in_root): (Vec<repo::Repo>, bool) = match find_repos(path)? {
+    let (repos, repo_in_root): (Vec<repo::Repo>, bool) = match find_repos(path, exclusion_pattern)?
+    {
         Some((vec, mut repo_warnings, repo_in_root)) => {
             warnings.append(&mut repo_warnings);
             (vec, repo_in_root)

src/path.rs

@@ -47,9 +47,9 @@ pub fn path_as_string(path: &Path) -> String {
     path.to_path_buf().into_os_string().into_string().unwrap()
 }
 
-pub fn env_home() -> PathBuf {
+pub fn env_home() -> String {
     match std::env::var("HOME") {
-        Ok(path) => Path::new(&path).to_path_buf(),
+        Ok(path) => path,
         Err(e) => {
             print_error(&format!("Unable to read HOME: {}", e));
             process::exit(1);
@@ -58,16 +58,12 @@ pub fn env_home() -> PathBuf {
 }
 
 pub fn expand_path(path: &Path) -> PathBuf {
-    fn home_dir() -> Option<PathBuf> {
-        Some(env_home())
-    }
-
     let expanded_path = match shellexpand::full_with_context(
         &path_as_string(path),
-        home_dir,
+        || Some(env_home()),
         |name| -> Result<Option<String>, &'static str> {
             match name {
-                "HOME" => Ok(Some(path_as_string(home_dir().unwrap().as_path()))),
+                "HOME" => Ok(Some(env_home())),
                 _ => Ok(None),
             }
         },

src/provider/github.rs

@@ -8,10 +8,11 @@ use super::JsonError;
 use super::Project;
 use super::Provider;
 
-const PROVIDER_NAME: &str = "github";
 const ACCEPT_HEADER_JSON: &str = "application/vnd.github.v3+json";
-const GITHUB_API_BASEURL: &str =
-    option_env!("GITHUB_API_BASEURL").unwrap_or("https://api.github.com");
+const GITHUB_API_BASEURL: &str = match option_env!("GITHUB_API_BASEURL") {
+    Some(url) => url,
+    None => "https://api.github.com",
+};
 
 #[derive(Deserialize)]
 pub struct GithubProject {
@@ -88,10 +89,6 @@ impl Provider for Github {
         })
     }
 
-    fn name(&self) -> &str {
-        PROVIDER_NAME
-    }
-
     fn filter(&self) -> &Filter {
         &self.filter
     }

src/provider/gitlab.rs

@@ -8,9 +8,11 @@ use super::JsonError;
 use super::Project;
 use super::Provider;
 
-const PROVIDER_NAME: &str = "gitlab";
 const ACCEPT_HEADER_JSON: &str = "application/json";
-const GITLAB_API_BASEURL: &str = option_env!("GITLAB_API_BASEURL").unwrap_or("https://gitlab.com");
+const GITLAB_API_BASEURL: &str = match option_env!("GITLAB_API_BASEURL") {
+    Some(url) => url,
+    None => "https://gitlab.com",
+};
 
 #[derive(Deserialize)]
 #[serde(rename_all = "lowercase")]
@@ -105,10 +107,6 @@ impl Provider for Gitlab {
         })
     }
 
-    fn name(&self) -> &str {
-        PROVIDER_NAME
-    }
-
     fn filter(&self) -> &Filter {
         &self.filter
     }

src/provider/mod.rs

@@ -14,7 +14,9 @@ use super::repo;
 
 use std::collections::HashMap;
 
-#[derive(Debug, Deserialize, Serialize, clap::ArgEnum, Clone)]
+const DEFAULT_REMOTE_NAME: &str = "origin";
+
+#[derive(Debug, Deserialize, Serialize, clap::ValueEnum, Clone)]
 pub enum RemoteProvider {
     #[serde(alias = "github", alias = "GitHub")]
     Github,
@@ -87,6 +89,10 @@ impl Filter {
             access,
         }
     }
+
+    pub fn empty(&self) -> bool {
+        self.users.is_empty() && self.groups.is_empty() && !self.owner && !self.access
+    }
 }
 
 pub enum ApiErrorResponse<T>
@@ -122,7 +128,6 @@ pub trait Provider {
     where
         Self: Sized;
 
-    fn name(&self) -> &str;
     fn filter(&self) -> &Filter;
     fn secret_token(&self) -> &auth::AuthToken;
     fn auth_header_key() -> &'static str;
@@ -213,6 +218,7 @@ pub trait Provider {
         &self,
         worktree_setup: bool,
         force_ssh: bool,
+        remote_name: Option<String>,
     ) -> Result<HashMap<Option<String>, Vec<repo::Repo>>, String> {
         let mut repos = vec![];
 
@@ -268,12 +274,16 @@ pub trait Provider {
         }
 
         for group in &self.filter().groups {
-            let group_projects = self
-                .get_group_projects(group)
-                .map_err(|error| match error {
-                    ApiErrorResponse::Json(x) => x.to_string(),
-                    ApiErrorResponse::String(s) => s,
-                })?;
+            let group_projects = self.get_group_projects(group).map_err(|error| {
+                format!(
+                    "group \"{}\": {}",
+                    group,
+                    match error {
+                        ApiErrorResponse::Json(x) => x.to_string(),
+                        ApiErrorResponse::String(s) => s,
+                    }
+                )
+            })?;
             for group_project in group_projects {
                 let mut already_present = false;
                 for repo in &repos {
@@ -292,10 +302,12 @@ pub trait Provider {
 
         let mut ret: HashMap<Option<String>, Vec<repo::Repo>> = HashMap::new();
 
+        let remote_name = remote_name.unwrap_or_else(|| DEFAULT_REMOTE_NAME.to_string());
+
         for repo in repos {
             let namespace = repo.namespace();
 
-            let mut repo = repo.into_repo_config(self.name(), worktree_setup, force_ssh);
+            let mut repo = repo.into_repo_config(&remote_name, worktree_setup, force_ssh);
 
             // Namespace is already part of the hashmap key. I'm not too happy
             // about the data exchange format here.

src/repo.rs

@@ -233,7 +233,7 @@ impl Worktree {
                     let operation = operation.map_err(convert_libgit2_error)?;
 
                     // This is required to preserve the commiter of the rebased
-                    // commits, which is the expected behaviour.
+                    // commits, which is the expected behavior.
                     let rebased_commit = repo
                         .0
                         .find_commit(operation.id())
@@ -357,7 +357,7 @@ impl Worktree {
             let operation = operation.map_err(convert_libgit2_error)?;
 
             // This is required to preserve the commiter of the rebased
-            // commits, which is the expected behaviour.
+            // commits, which is the expected behavior.
             let rebased_commit = repo
                 .0
                 .find_commit(operation.id())
@@ -406,50 +406,78 @@ mod tests {
     fn check_ssh_remote() {
         assert_eq!(
             detect_remote_type("ssh://git@example.com"),
-            Some(RemoteType::Ssh)
+            Ok(RemoteType::Ssh)
         );
-        assert_eq!(detect_remote_type("git@example.git"), Some(RemoteType::Ssh));
+        assert_eq!(detect_remote_type("git@example.git"), Ok(RemoteType::Ssh));
     }
 
     #[test]
     fn check_https_remote() {
         assert_eq!(
             detect_remote_type("https://example.com"),
-            Some(RemoteType::Https)
+            Ok(RemoteType::Https)
         );
         assert_eq!(
             detect_remote_type("https://example.com/test.git"),
-            Some(RemoteType::Https)
+            Ok(RemoteType::Https)
         );
     }
 
     #[test]
     fn check_file_remote() {
-        assert_eq!(
-            detect_remote_type("file:///somedir"),
-            Some(RemoteType::File)
-        );
+        assert_eq!(detect_remote_type("file:///somedir"), Ok(RemoteType::File));
     }
 
     #[test]
     fn check_invalid_remotes() {
-        assert_eq!(detect_remote_type("https//example.com"), None);
-        assert_eq!(detect_remote_type("https:example.com"), None);
-        assert_eq!(detect_remote_type("ssh//example.com"), None);
-        assert_eq!(detect_remote_type("ssh:example.com"), None);
-        assert_eq!(detect_remote_type("git@example.com"), None);
+        assert_eq!(
+            detect_remote_type("https//example.com"),
+            Err(String::from(
+                "The remote URL starts with an unimplemented protocol"
+            ))
+        );
+        assert_eq!(
+            detect_remote_type("https:example.com"),
+            Err(String::from(
+                "The remote URL starts with an unimplemented protocol",
+            ))
+        );
+        assert_eq!(
+            detect_remote_type("ssh//example.com"),
+            Err(String::from(
+                "The remote URL starts with an unimplemented protocol",
+            ))
+        );
+        assert_eq!(
+            detect_remote_type("ssh:example.com"),
+            Err(String::from(
+                "The remote URL starts with an unimplemented protocol",
+            ))
+        );
+        assert_eq!(
+            detect_remote_type("git@example.com"),
+            Err(String::from(
+                "The remote URL starts with an unimplemented protocol",
+            ))
+        );
     }
 
     #[test]
-    #[should_panic]
     fn check_unsupported_protocol_http() {
-        detect_remote_type("http://example.com");
+        assert_eq!(
+            detect_remote_type("http://example.com"),
+            Err(String::from(
+                "Remotes using HTTP protocol are not supported",
+            ))
+        );
     }
 
     #[test]
-    #[should_panic]
     fn check_unsupported_protocol_git() {
-        detect_remote_type("git://example.com");
+        assert_eq!(
+            detect_remote_type("git://example.com"),
+            Err(String::from("Remotes using git protocol are not supported"))
+        );
     }
 
     #[test]
@@ -473,27 +501,31 @@ mod tests {
     }
 }
 
-pub fn detect_remote_type(remote_url: &str) -> Option<RemoteType> {
+pub fn detect_remote_type(remote_url: &str) -> Result<RemoteType, String> {
     let git_regex = regex::Regex::new(r"^[a-zA-Z]+@.*$").unwrap();
     if remote_url.starts_with("ssh://") {
-        return Some(RemoteType::Ssh);
+        return Ok(RemoteType::Ssh);
     }
     if git_regex.is_match(remote_url) && remote_url.ends_with(".git") {
-        return Some(RemoteType::Ssh);
+        return Ok(RemoteType::Ssh);
     }
     if remote_url.starts_with("https://") {
-        return Some(RemoteType::Https);
+        return Ok(RemoteType::Https);
     }
     if remote_url.starts_with("file://") {
-        return Some(RemoteType::File);
+        return Ok(RemoteType::File);
     }
     if remote_url.starts_with("http://") {
-        unimplemented!("Remotes using HTTP protocol are not supported");
+        return Err(String::from(
+            "Remotes using HTTP protocol are not supported",
+        ));
     }
     if remote_url.starts_with("git://") {
-        unimplemented!("Remotes using git protocol are not supported");
+        return Err(String::from("Remotes using git protocol are not supported"));
     }
-    None
+    Err(String::from(
+        "The remote URL starts with an unimplemented protocol",
+    ))
 }
 
 pub struct RepoHandle(git2::Repository);
@@ -785,7 +817,7 @@ impl RepoHandle {
             ))
         })?;
 
-        for entry in match std::fs::read_dir(&root_dir) {
+        for entry in match std::fs::read_dir(root_dir) {
             Ok(iterator) => iterator,
             Err(error) => {
                 return Err(WorktreeConversionFailureReason::Error(format!(
@@ -1153,18 +1185,21 @@ impl RepoHandle {
 
     pub fn remove_worktree(
         &self,
+        base_dir: &Path,
         name: &str,
         worktree_dir: &Path,
         force: bool,
         worktree_config: &Option<WorktreeRootConfig>,
     ) -> Result<(), WorktreeRemoveFailureReason> {
-        if !worktree_dir.exists() {
+        let fullpath = base_dir.join(worktree_dir);
+
+        if !fullpath.exists() {
             return Err(WorktreeRemoveFailureReason::Error(format!(
                 "{} does not exist",
                 name
             )));
         }
-        let worktree_repo = RepoHandle::open(worktree_dir, false).map_err(|error| {
+        let worktree_repo = RepoHandle::open(&fullpath, false).map_err(|error| {
             WorktreeRemoveFailureReason::Error(format!("Error opening repo: {}", error))
         })?;
 
@@ -1176,12 +1211,11 @@ impl RepoHandle {
             WorktreeRemoveFailureReason::Error(format!("Failed getting name of branch: {}", error))
         })?;
 
-        if branch_name != name
-            && !branch_name.ends_with(&format!("{}{}", super::BRANCH_NAMESPACE_SEPARATOR, name))
-        {
+        if branch_name != name {
             return Err(WorktreeRemoveFailureReason::Error(format!(
-                "Branch \"{}\" is checked out in worktree, this does not look correct",
-                &branch_name
+                "Branch \"{}\" is checked out in worktree \"{}\", this does not look correct",
+                &branch_name,
+                &worktree_dir.display(),
             )));
         }
 
@@ -1251,13 +1285,46 @@ impl RepoHandle {
             }
         }
 
-        if let Err(e) = std::fs::remove_dir_all(&worktree_dir) {
+        // worktree_dir is a relative path, starting from base_dir. We walk it
+        // upwards (from subdirectory to parent directories) and remove each
+        // component, in case it is empty. Only the leaf directory can be
+        // removed unconditionally (as it contains the worktree itself).
+        if let Err(e) = std::fs::remove_dir_all(&fullpath) {
             return Err(WorktreeRemoveFailureReason::Error(format!(
                 "Error deleting {}: {}",
                 &worktree_dir.display(),
                 e
             )));
         }
+
+        if let Some(current_dir) = worktree_dir.parent() {
+            for current_dir in current_dir.ancestors() {
+                let current_dir = base_dir.join(current_dir);
+                if current_dir
+                    .read_dir()
+                    .map_err(|error| {
+                        WorktreeRemoveFailureReason::Error(format!(
+                            "Error reading {}: {}",
+                            &current_dir.display(),
+                            error
+                        ))
+                    })?
+                    .next()
+                    .is_none()
+                {
+                    if let Err(e) = std::fs::remove_dir(&current_dir) {
+                        return Err(WorktreeRemoveFailureReason::Error(format!(
+                            "Error deleting {}: {}",
+                            &worktree_dir.display(),
+                            e
+                        )));
+                    }
+                } else {
+                    break;
+                }
+            }
+        }
+
         self.prune_worktree(name)
             .map_err(WorktreeRemoveFailureReason::Error)?;
         branch
@@ -1308,9 +1375,15 @@ impl RepoHandle {
                 },
             })
         {
-            let repo_dir = &directory.join(&worktree.name());
+            let repo_dir = &directory.join(worktree.name());
             if repo_dir.exists() {
-                match self.remove_worktree(worktree.name(), repo_dir, false, &config) {
+                match self.remove_worktree(
+                    directory,
+                    worktree.name(),
+                    Path::new(worktree.name()),
+                    false,
+                    &config,
+                ) {
                     Ok(_) => print_success(&format!("Worktree {} deleted", &worktree.name())),
                     Err(error) => match error {
                         WorktreeRemoveFailureReason::Changes(changes) => {
@@ -1346,12 +1419,12 @@ impl RepoHandle {
             .map_err(|error| format!("Getting worktrees failed: {}", error))?;
 
         let mut unmanaged_worktrees = Vec::new();
-        for entry in std::fs::read_dir(&directory).map_err(|error| error.to_string())? {
+        for entry in std::fs::read_dir(directory).map_err(|error| error.to_string())? {
             let dirname = path::path_as_string(
                 entry
                     .map_err(|error| error.to_string())?
                     .path()
-                    .strip_prefix(&directory)
+                    .strip_prefix(directory)
                     // that unwrap() is safe as each entry is
                     // guaranteed to be a subentry of &directory
                     .unwrap(),
@@ -1435,7 +1508,7 @@ impl<'a> Branch<'a> {
     }
 }
 
-impl Branch<'_> {
+impl<'a> Branch<'a> {
     pub fn commit(&self) -> Result<Commit, String> {
         Ok(Commit(
             self.0
@@ -1445,6 +1518,15 @@ impl Branch<'_> {
         ))
     }
 
+    pub fn commit_owned(self) -> Result<Commit<'a>, String> {
+        Ok(Commit(
+            self.0
+                .into_reference()
+                .peel_to_commit()
+                .map_err(convert_libgit2_error)?,
+        ))
+    }
+
     pub fn set_upstream(&mut self, remote_name: &str, branch_name: &str) -> Result<(), String> {
         self.0
             .set_upstream(Some(&format!("{}/{}", remote_name, branch_name)))
@@ -1538,7 +1620,7 @@ impl RemoteHandle<'_> {
 
     pub fn is_pushable(&self) -> Result<bool, String> {
         let remote_type = detect_remote_type(self.0.url().expect("Remote name is not valid utf-8"))
-            .ok_or_else(|| String::from("Could not detect remote type"))?;
+            .expect("Could not detect remote type");
         Ok(matches!(remote_type, RemoteType::Ssh | RemoteType::File))
     }
 

src/table.rs

@@ -111,7 +111,7 @@ pub fn get_worktree_status_table(
 
     add_worktree_table_header(&mut table);
     for worktree in &worktrees {
-        let worktree_dir = &directory.join(&worktree.name());
+        let worktree_dir = &directory.join(worktree.name());
         if worktree_dir.exists() {
             let repo = match repo::RepoHandle::open(worktree_dir, false) {
                 Ok(repo) => repo,
@@ -185,7 +185,11 @@ pub fn get_status_table(config: config::Config) -> Result<(Vec<Table>, Vec<Strin
                 }
             };
 
-            add_repo_status(&mut table, &repo.name, &repo_handle, repo.worktree_setup)?;
+            if let Err(err) =
+                add_repo_status(&mut table, &repo.name, &repo_handle, repo.worktree_setup)
+            {
+                errors.push(format!("{}: Couldn't add repo status: {}", &repo.name, err));
+            }
         }
 
         tables.push(table);

src/tree.rs

@@ -60,7 +60,11 @@ pub fn sync_trees(config: config::Config, init_worktree: bool) -> Result<bool, S
 
         match find_unmanaged_repos(&root_path, &repos) {
             Ok(repos) => {
-                unmanaged_repos_absolute_paths.extend(repos);
+                for path in repos.into_iter() {
+                    if !unmanaged_repos_absolute_paths.contains(&path) {
+                        unmanaged_repos_absolute_paths.push(path);
+                    }
+                }
             }
             Err(error) => {
                 print_error(&format!("Error getting unmanaged repos: {}", error));
@@ -124,8 +128,6 @@ pub fn find_repo_paths(path: &Path) -> Result<Vec<PathBuf>, String> {
                     "Failed to open \"{}\": {}",
                     &path.display(),
                     match e.kind() {
-                        std::io::ErrorKind::NotADirectory =>
-                            String::from("directory expected, but path is not a directory"),
                         std::io::ErrorKind::NotFound => String::from("not found"),
                         _ => format!("{:?}", e.kind()),
                     }
@@ -222,7 +224,7 @@ fn sync_repo(root_path: &Path, repo: &repo::Repo, init_worktree: bool) -> Result
     if newly_created && repo.worktree_setup && init_worktree {
         match repo_handle.default_branch() {
             Ok(branch) => {
-                worktree::add_worktree(&repo_path, &branch.name()?, None, None, false)?;
+                worktree::add_worktree(&repo_path, &branch.name()?, None, false)?;
             }
             Err(_error) => print_repo_error(
                 &repo.name,

src/worktree.rs

@@ -1,30 +1,584 @@
+//! This handles worktrees for repositories. Some considerations to take care
+//! of:
+//!
+//! * Which branch to check out / create
+//! * Which commit to check out
+//! * Whether to track a remote branch, and which
+//!
+//! There are a general rules. The main goal is to do the least surprising thing
+//! in each situation, and to never change existing setups (e.g. tracking,
+//! branch states) except when explicitly told to. In 99% of all cases, the
+//! workflow will be quite straightforward.
+//!
+//! * The name of the worktree (and therefore the path) is **always** the same
+//!   as the name of the branch.
+//! * Never modify existing local branches
+//! * Only modify tracking branches for existing local branches if explicitly
+//!   requested
+//! * By default, do not do remote operations. This means that we do no do any
+//!   tracking setup (but of course, the local branch can already have a
+//!   tracking branch set up, which will just be left alone)
+//! * Be quite lax with finding a remote tracking branch (as using an existing
+//!   branch is most likely preferred to creating a new branch)
+//!
+//! There are a few different options that can be given:
+//!
+//! * Explicit track (`--track`) and explicit no-track (`--no-track`)
+//! * A configuration may specify to enable tracking a remote branch by default
+//! * A configuration may specify a prefix for remote branches
+//!
+//! # How to handle the local branch?
+//!
+//! That one is easy: If a branch with the desired name already exists, all is
+//! well. If not, we create a new one.
+//!
+//! # Which commit should be checked out?
+//!
+//! The most imporant rule: If the local branch already existed, just leave it
+//! as it is. Only if a new branch is created do we need to answer the question
+//! which commit to set it to. Generally, we set the branch to whatever the
+//! "default" branch of the repository is (something like "main" or "master").
+//! But there are a few cases where we can use remote branches to make the
+//! result less surprising.
+//!
+//! First, if tracking is explicitly disabled, we still try to guess! But we
+//! *do* ignore `--track`, as this is how it's done everywhere else.
+//!
+//! As an example: If `origin/foobar` exists and we run `grm worktree add foobar
+//! --no-track`, we create a new worktree called `foobar` that's on the same
+//! state as `origin/foobar` (but we will not set up tracking, see below).
+//!
+//! If tracking is explicitly requested to a certain state, we use that remote
+//! branch. If it exists, easy. If not, no more guessing!
+//!
+//! Now, it's important to select the correct remote. In the easiest case, there
+//! is only one remote, so we just use that one. If there is more than one
+//! remote, we check whether there is a default remote configured via
+//! `track.default_remote`. If yes, we use that one. If not, we have to do the
+//! selection process below *for each of them*.  If only one of them returns
+//! some branch to track, we use that one. If more than one remote returns
+//! information, we only use it if it's identical for each. Otherwise we bail,
+//! as there is no point in guessing.
+//!
+//! The commit selection process looks like this:
+//!
+//! * If a prefix is specified in the configuration, we look for
+//!   `{remote}/{prefix}/{worktree_name}`
+//!
+//! * We look for `{remote}/{worktree_name}` (yes, this means that even when a
+//!   prefix is configured, we use a branch *without* a prefix if one with
+//!   prefix does not exist)
+//!
+//! Note that we may select different branches for different remotes when
+//! prefixes is used. If remote1 has a branch with a prefix and remote2 only has
+//! a branch *without* a prefix, we select them both when a prefix is used. This
+//! could lead to the following situation:
+//!
+//! * There is `origin/prefix/foobar` and `remote2/foobar`, with different
+//!   states
+//! * You set `track.default_prefix = "prefix"` (and no default remote!)
+//! * You run `grm worktree add `prefix/foobar`
+//! * Instead of just picking `origin/prefix/foobar`, grm will complain because
+//!   it also selected `remote2/foobar`.
+//!
+//! This is just emergent behavior of the logic above. Fixing it would require
+//! additional logic for that edge case. I assume that it's just so rare to get
+//! that behavior that it's acceptable for now.
+//!
+//! Now we either have a commit, we aborted, or we do not have commit. In the
+//! last case, as stated above, we check out the "default" branch.
+//!
+//! # The remote tracking branch
+//!
+//! First, the only remote operations we do is branch creation! It's
+//! unfortunately not possible to defer remote branch creation until the first
+//! `git push`, which would be ideal. The remote tracking branch has to already
+//! exist, so we have to do the equivalent of `git push --set-upstream` during
+//! worktree creation.
+//!
+//! Whether (and which) remote branch to track works like this:
+//!
+//! * If `--no-track` is given, we never track a remote branch, except when
+//!   branch already has a tracking branch. So we'd be done already!
+//!
+//! * If `--track` is given, we always track this branch, regardless of anything
+//!   else. If the branch exists, cool, otherwise we create it.
+//!
+//! If neither is given, we only set up tracking if requested in the
+//! configuration file (`track.default = true`)
+//!
+//! The rest of the process is similar to the commit selection above. The only
+//! difference is the remote selection.  If there is only one, we use it, as
+//! before. Otherwise, we try to use `default_remote` from the configuration, if
+//! available.  If not, we do not set up a remote tracking branch. It works like
+//! this:
+//!
+//! * If a prefix is specified in the configuration, we use
+//!   `{remote}/{prefix}/{worktree_name}`
+//!
+//! * If no prefix is specified in the configuration, we use
+//!   `{remote}/{worktree_name}`
+//!
+//! Now that we have a remote, we use the same process as above:
+//!
+//! * If a prefix is specified in the configuration, we use for
+//!   `{remote}/{prefix}/{worktree_name}`
+//! * We use for `{remote}/{worktree_name}`
+//!
+//! ---
+//!
+//! All this means that in some weird situation, you may end up with the state
+//! of a remote branch while not actually tracking that branch. This can only
+//! happen in repositories with more than one remote. Imagine the following:
+//!
+//! The repository has two remotes (`remote1` and `remote2`) which have the
+//! exact same remote state. But there is no `default_remote` in the
+//! configuration (or no configuration at all). There is a remote branch
+//! `foobar`. As both `remote1/foobar` and `remote2/foobar` as the same, the new
+//! worktree will use that as the state of the new branch. But as `grm` cannot
+//! tell which remote branch to track, it will not set up remote tracking. This
+//! behavior may be a bit confusing, but first, there is no good way to resolve
+//! this, and second, the situation should be really rare (when having multiple
+//! remotes, you would generally have a `default_remote` configured).
+//!
+//! # Implementation
+//!
+//! To reduce the chance of bugs, the implementation uses the [typestate
+//! pattern](http://cliffle.com/blog/rust-typestate/). Here are the states we
+//! are moving through linearily:
+//!
+//! * Init
+//! * A local branch name is set
+//! * A local commit to set the new branch to is selected
+//! * A remote tracking branch is selected
+//! * The new branch is created with all the required settings
+//!
+//! Don't worry about the lifetime stuff: There is only one single lifetime, as
+//! everything (branches, commits) is derived from the single repo::Repo
+//! instance
+//!
+//! # Testing
+//!
+//! There are two types of input to the tests:
+//!
+//! 1) The parameters passed to `grm`, either via command line or via
+//!    configuration file
+//! 2) The circumstances in the repository and remotes
+//!
+//! ## Parameters
+//!
+//! * The name of the worktree
+//!   * Whether it contains slashes or not
+//!   * Whether it is invalid
+//! * `--track` and `--no-track`
+//! * Whether there is a configuration file and what it contains
+//!   * Whether `track.default` is enabled or disabled
+//!   * Whether `track.default_remote_prefix` is there or missing
+//!   * Whether `track.default_remote` is there or missing
+//!     * Whether that remote exists or not
+//!
+//! ## Situations
+//!
+//! ### The local branch
+//!
+//! * Whether the branch already exists
+//! * Whether the branch has a remote tracking branch and whether it differs
+//!   from the desired tracking branch (i.e. `--track` or config)
+//!
+//! ### Remotes
+//!
+//! * How many remotes there are, if any
+//! * If more than two remotes exist, whether their desired tracking branch
+//!   differs
+//!
+//! ### The remote tracking branch branch
+//!
+//! * Whether a remote branch with the same name as the worktree exists
+//! * Whether a remote branch with the same name as the worktree plus prefix
+//!   exists
+//!
+//! ## Outcomes
+//!
+//! We have to check the following afterwards:
+//!
+//! * Does the worktree exist in the correct location?
+//! * Does the local branch have the same name as the worktree?
+//! * Does the local branch have the correct commit?
+//! * Does the local branch track the correct remote branch?
+//! * Does that remote branch also exist?
+use std::cell::RefCell;
 use std::path::Path;
 
-use super::output::*;
+// use super::output::*;
 use super::repo;
 
 pub const GIT_MAIN_WORKTREE_DIRECTORY: &str = ".git-main-working-tree";
 
-// The logic about the base branch and the tracking branch is as follows:
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn invalid_worktree_names() {
+        assert!(add_worktree(Path::new("/tmp/"), "/leadingslash", None, false).is_err());
+        assert!(add_worktree(Path::new("/tmp/"), "trailingslash/", None, false).is_err());
+        assert!(add_worktree(Path::new("/tmp/"), "//", None, false).is_err());
+        assert!(add_worktree(Path::new("/tmp/"), "test//test", None, false).is_err());
+        assert!(add_worktree(Path::new("/tmp/"), "test test", None, false).is_err());
+        assert!(add_worktree(Path::new("/tmp/"), "test\ttest", None, false).is_err());
+    }
+}
+
+struct Init;
+
+struct WithLocalBranchName<'a> {
+    local_branch_name: String,
+    /// Outer option: Is there a computed value?
+    /// Inner option: Is there actually a branch?
+    ///
+    /// None => No computed value yet
+    /// Some(None) => No branch
+    /// Some(Some(_)) => Branch
+    local_branch: RefCell<Option<Option<repo::Branch<'a>>>>,
+}
+
+struct WithLocalTargetSelected<'a> {
+    local_branch_name: String,
+    local_branch: Option<repo::Branch<'a>>,
+    target_commit: Option<Box<repo::Commit<'a>>>,
+}
+
+struct WithRemoteTrackingBranch<'a> {
+    local_branch_name: String,
+    local_branch: Option<repo::Branch<'a>>,
+    target_commit: Option<Box<repo::Commit<'a>>>,
+    remote_tracking_branch: Option<(String, String)>,
+    prefix: Option<String>,
+}
+
+struct Worktree<'a, S: WorktreeState> {
+    repo: &'a repo::RepoHandle,
+    extra: S,
+}
+
+impl<'a> WithLocalBranchName<'a> {
+    fn new(name: String) -> Self {
+        Self {
+            local_branch_name: name,
+            local_branch: RefCell::new(None),
+        }
+    }
+}
+
+trait WorktreeState {}
+
+impl WorktreeState for Init {}
+impl<'a> WorktreeState for WithLocalBranchName<'a> {}
+impl<'a> WorktreeState for WithLocalTargetSelected<'a> {}
+impl<'a> WorktreeState for WithRemoteTrackingBranch<'a> {}
+
+impl<'a> Worktree<'a, Init> {
+    fn new(repo: &'a repo::RepoHandle) -> Self {
+        Self {
+            repo,
+            extra: Init {},
+        }
+    }
+
+    fn set_local_branch_name(self, name: &str) -> Worktree<'a, WithLocalBranchName<'a>> {
+        Worktree::<WithLocalBranchName> {
+            repo: self.repo,
+            extra: WithLocalBranchName::new(name.to_string()),
+        }
+    }
+}
+
+impl<'a, 'b> Worktree<'a, WithLocalBranchName<'b>>
+where
+    'a: 'b,
+{
+    fn check_local_branch(&self) {
+        let mut branchref = self.extra.local_branch.borrow_mut();
+        if branchref.is_none() {
+            let branch = self.repo.find_local_branch(&self.extra.local_branch_name);
+            *branchref = Some(if let Ok(branch) = branch {
+                Some(branch)
+            } else {
+                None
+            });
+        }
+    }
+
+    fn local_branch_already_exists(&self) -> bool {
+        if let Some(branch) = &*self.extra.local_branch.borrow() {
+            return branch.is_some();
+        }
+        self.check_local_branch();
+        // As we just called `check_local_branch`, we can be sure that
+        // `self.extra.local_branch` is set to some `Some` value
+        (*self.extra.local_branch.borrow())
+            .as_ref()
+            .unwrap()
+            .is_some()
+    }
+
+    fn select_commit(
+        self,
+        commit: Option<Box<repo::Commit<'b>>>,
+    ) -> Worktree<'a, WithLocalTargetSelected<'b>> {
+        self.check_local_branch();
+
+        Worktree::<'a, WithLocalTargetSelected> {
+            repo: self.repo,
+            extra: WithLocalTargetSelected::<'b> {
+                local_branch_name: self.extra.local_branch_name,
+                // As we just called `check_local_branch`, we can be sure that
+                // `self.extra.local_branch` is set to some `Some` value
+                local_branch: self.extra.local_branch.into_inner().unwrap(),
+                target_commit: commit,
+            },
+        }
+    }
+}
+
+impl<'a> Worktree<'a, WithLocalTargetSelected<'a>> {
+    fn set_remote_tracking_branch(
+        self,
+        branch: Option<(&str, &str)>,
+        prefix: Option<&str>,
+    ) -> Worktree<'a, WithRemoteTrackingBranch<'a>> {
+        Worktree::<WithRemoteTrackingBranch> {
+            repo: self.repo,
+            extra: WithRemoteTrackingBranch {
+                local_branch_name: self.extra.local_branch_name,
+                local_branch: self.extra.local_branch,
+                target_commit: self.extra.target_commit,
+                remote_tracking_branch: branch.map(|(s1, s2)| (s1.to_string(), s2.to_string())),
+                prefix: prefix.map(|prefix| prefix.to_string()),
+            },
+        }
+    }
+}
+
+impl<'a> Worktree<'a, WithRemoteTrackingBranch<'a>> {
+    fn create(self, directory: &Path) -> Result<Option<Vec<String>>, String> {
+        let mut warnings: Vec<String> = vec![];
+
+        let mut branch = if let Some(branch) = self.extra.local_branch {
+            branch
+        } else {
+            self.repo.create_branch(
+                &self.extra.local_branch_name,
+                // TECHDEBT
+                // We must not call this with `Some()` without a valid target.
+                // I'm sure this can be improved, just not sure how.
+                &self.extra.target_commit.unwrap(),
+            )?
+        };
+
+        if let Some((remote_name, remote_branch_name)) = self.extra.remote_tracking_branch {
+            let remote_branch_with_prefix = if let Some(ref prefix) = self.extra.prefix {
+                if let Ok(remote_branch) = self
+                    .repo
+                    .find_remote_branch(&remote_name, &format!("{prefix}/{remote_branch_name}"))
+                {
+                    Some(remote_branch)
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+            let remote_branch_without_prefix = if let Ok(remote_branch) = self
+                .repo
+                .find_remote_branch(&remote_name, &remote_branch_name)
+            {
+                Some(remote_branch)
+            } else {
+                None
+            };
+
+            let remote_branch = if let Some(ref _prefix) = self.extra.prefix {
+                remote_branch_with_prefix
+            } else {
+                remote_branch_without_prefix
+            };
+
+            match remote_branch {
+                Some(remote_branch) => {
+                    if branch.commit()?.id().hex_string()
+                        != remote_branch.commit()?.id().hex_string()
+                    {
+                        warnings.push(format!("The local branch \"{}\" and the remote branch \"{}/{}\" differ. Make sure to push/pull afterwards!", &self.extra.local_branch_name, &remote_name, &remote_branch_name));
+                    }
+
+                    branch.set_upstream(&remote_name, &remote_branch.basename()?)?;
+                }
+                None => {
+                    let mut remote = match self.repo.find_remote(&remote_name)? {
+                        Some(remote) => remote,
+                        None => return Err(format!("Remote \"{remote_name}\" not found")),
+                    };
+
+                    if !remote.is_pushable()? {
+                        return Err(format!(
+                            "Cannot push to non-pushable remote \"{remote_name}\""
+                        ));
+                    }
+
+                    if let Some(prefix) = self.extra.prefix {
+                        remote.push(
+                            &self.extra.local_branch_name,
+                            &format!("{}/{}", prefix, remote_branch_name),
+                            self.repo,
+                        )?;
+
+                        branch.set_upstream(
+                            &remote_name,
+                            &format!("{}/{}", prefix, remote_branch_name),
+                        )?;
+                    } else {
+                        remote.push(
+                            &self.extra.local_branch_name,
+                            &remote_branch_name,
+                            self.repo,
+                        )?;
+
+                        branch.set_upstream(&remote_name, &remote_branch_name)?;
+                    }
+                }
+            }
+        }
+
+        // We have to create subdirectories first, otherwise adding the worktree
+        // will fail
+        if self.extra.local_branch_name.contains('/') {
+            let path = Path::new(&self.extra.local_branch_name);
+            if let Some(base) = path.parent() {
+                // This is a workaround of a bug in libgit2 (?)
+                //
+                // When *not* doing this, we will receive an error from the `Repository::worktree()`
+                // like this:
+                //
+                // > failed to make directory '/{repo}/.git-main-working-tree/worktrees/dir/test
+                //
+                // This is a discrepancy between the behavior of libgit2 and the
+                // git CLI when creating worktrees with slashes:
+                //
+                // The git CLI will create the worktree's configuration directory
+                // inside {git_dir}/worktrees/{last_path_component}. Look at this:
+                //
+                // ```
+                // $ git worktree add 1/2/3 -b 1/2/3
+                // $ ls .git/worktrees
+                // 3
+                // ```
+                //
+                // Interesting: When adding a worktree with a different name but the
+                // same final path component, git starts adding a counter suffix to
+                // the worktree directories:
+                //
+                // ```
+                // $ git worktree add 1/3/3 -b 1/3/3
+                // $ git worktree add 1/4/3 -b 1/4/3
+                // $ ls .git/worktrees
+                // 3
+                // 31
+                // 32
+                // ```
+                //
+                // I *guess* that the mapping back from the worktree directory under .git to the actual
+                // worktree directory is done via the `gitdir` file inside `.git/worktrees/{worktree}.
+                // This means that the actual directory would not matter. You can verify this by
+                // just renaming it:
+                //
+                // ```
+                // $ mv .git/worktrees/3 .git/worktrees/foobar
+                // $ git worktree list
+                // /tmp/       fcc8a2a7 [master]
+                // /tmp/1/2/3  fcc8a2a7 [1/2/3]
+                // /tmp/1/3/3  fcc8a2a7 [1/3/3]
+                // /tmp/1/4/3  fcc8a2a7 [1/4/3]
+                // ```
+                //
+                // => Still works
+                //
+                // Anyway, libgit2 does not do this: It tries to create the worktree
+                // directory inside .git with the exact name of the worktree, including
+                // any slashes. It should be this code:
+                //
+                // https://github.com/libgit2/libgit2/blob/f98dd5438f8d7bfd557b612fdf1605b1c3fb8eaf/src/libgit2/worktree.c#L346
+                //
+                // As a workaround, we can create the base directory manually for now.
+                //
+                // Tracking upstream issue: https://github.com/libgit2/libgit2/issues/6327
+                std::fs::create_dir_all(
+                    directory
+                        .join(GIT_MAIN_WORKTREE_DIRECTORY)
+                        .join("worktrees")
+                        .join(base),
+                )
+                .map_err(|error| error.to_string())?;
+                std::fs::create_dir_all(base).map_err(|error| error.to_string())?;
+            }
+        }
+
+        self.repo.new_worktree(
+            &self.extra.local_branch_name,
+            &directory.join(&self.extra.local_branch_name),
+            &branch,
+        )?;
+
+        Ok(if warnings.is_empty() {
+            None
+        } else {
+            Some(warnings)
+        })
+    }
+}
+
+/// A branch name must never start or end with a slash, and it cannot have two
+/// consecutive slashes
+fn validate_worktree_name(name: &str) -> Result<(), String> {
+    if name.starts_with('/') || name.ends_with('/') {
+        return Err(format!(
+            "Invalid worktree name: {}. It cannot start or end with a slash",
+            name
+        ));
+    }
+
+    if name.contains("//") {
+        return Err(format!(
+            "Invalid worktree name: {}. It cannot contain two consecutive slashes",
+            name
+        ));
+    }
+
+    if name.contains(char::is_whitespace) {
+        return Err(format!(
+            "Invalid worktree name: {}. It cannot contain whitespace",
+            name
+        ));
+    }
+
+    Ok(())
+}
+
+// TECHDEBT
 //
-// * If a branch with the same name does not exist and no track is given, use the default
-//   branch
-//
-// * If a branch with the same name exists and no track is given, use that
-//
-// * If a branch with the same name does not exist and track is given, use the
-//   local branch that tracks that branch
-//
-// * If a branch with the same name exists and track is given, use the locally
-//   existing branch. If the locally existing branch is not the local branch to
-//   the remote tracking branch, issue a warning
+// Instead of opening the repo & reading configuration inside the function, it
+// should be done by the caller and given as a parameter
 pub fn add_worktree(
     directory: &Path,
     name: &str,
-    subdirectory: Option<&Path>,
     track: Option<(&str, &str)>,
     no_track: bool,
-) -> Result<(), String> {
+) -> Result<Option<Vec<String>>, String> {
+    let mut warnings: Vec<String> = vec![];
+
+    validate_worktree_name(name)?;
+
     let repo = repo::RepoHandle::open(directory, true).map_err(|error| match error.kind {
         repo::RepoErrorKind::NotFound => {
             String::from("Current directory does not contain a worktree setup")
@@ -32,171 +586,195 @@ pub fn add_worktree(
         _ => format!("Error opening repo: {}", error),
     })?;
 
+    let remotes = &repo.remotes()?;
+
     let config = repo::read_worktree_root_config(directory)?;
 
     if repo.find_worktree(name).is_ok() {
         return Err(format!("Worktree {} already exists", &name));
     }
 
-    let path = match subdirectory {
-        Some(dir) => directory.join(dir).join(name),
-        None => directory.join(Path::new(name)),
-    };
+    let track_config = config.and_then(|config| config.track);
+    let prefix = track_config
+        .as_ref()
+        .and_then(|track| track.default_remote_prefix.as_ref());
+    let enable_tracking = track_config.as_ref().map_or(false, |track| track.default);
+    let default_remote = track_config
+        .as_ref()
+        .map(|track| track.default_remote.clone());
 
-    let mut remote_branch_exists = false;
+    // Note that we have to define all variables that borrow from `repo`
+    // *first*, otherwise we'll receive "borrowed value does not live long
+    // enough" errors. This is due to the `repo` reference inside `Worktree` that is
+    // passed through each state type.
+    //
+    // The `commit` variable will be dropped at the end of the scope, together with all
+    // worktree variables. It will be done in the opposite direction of delcaration (FILO).
+    //
+    // So if we define `commit` *after* the respective worktrees, it will be dropped first while
+    // still being borrowed by `Worktree`.
+    let default_branch_head = repo.default_branch()?.commit_owned()?;
 
-    let mut target_branch = match repo.find_local_branch(name) {
-        Ok(branchref) => {
-            if !no_track {
-                if let Some((remote_name, remote_branch_name)) = track {
-                    let remote_branch = repo.find_remote_branch(remote_name, remote_branch_name);
-                    if let Ok(remote_branch) = remote_branch {
-                        remote_branch_exists = true;
-                        if let Ok(local_upstream_branch) = branchref.upstream() {
-                            if remote_branch.name()? != local_upstream_branch.name()? {
-                                print_warning(&format!(
-                                    "You specified a tracking branch ({}/{}) for an existing branch ({}), but \
-                                    it differs from the current upstream ({}). Will keep current upstream"
-                                , remote_name, remote_branch_name, branchref.name()?, local_upstream_branch.name()?))
-                            }
-                        }
-                    }
-                }
-            }
-            branchref
-        }
-        Err(_) => {
-            let default_checkout = || repo.default_branch()?.to_commit();
+    let worktree = Worktree::<Init>::new(&repo).set_local_branch_name(name);
 
-            let checkout_commit;
-
-            if no_track {
-                checkout_commit = default_checkout()?;
-            } else {
-                match track {
-                    Some((remote_name, remote_branch_name)) => {
-                        let remote_branch =
-                            repo.find_remote_branch(remote_name, remote_branch_name);
-                        match remote_branch {
-                            Ok(branch) => {
-                                remote_branch_exists = true;
-                                checkout_commit = branch.to_commit()?;
-                            }
-                            Err(_) => {
-                                remote_branch_exists = false;
-                                checkout_commit = default_checkout()?;
-                            }
-                        }
-                    }
-                    None => match &config {
-                        None => checkout_commit = default_checkout()?,
-                        Some(config) => match &config.track {
-                            None => checkout_commit = default_checkout()?,
-                            Some(track_config) => {
-                                if track_config.default {
-                                    let remote_branch =
-                                        repo.find_remote_branch(&track_config.default_remote, name);
-                                    match remote_branch {
-                                        Ok(branch) => {
-                                            remote_branch_exists = true;
-                                            checkout_commit = branch.to_commit()?;
-                                        }
-                                        Err(_) => {
-                                            checkout_commit = default_checkout()?;
-                                        }
-                                    }
-                                } else {
-                                    checkout_commit = default_checkout()?;
-                                }
-                            }
-                        },
-                    },
-                };
-            }
-
-            repo.create_branch(name, &checkout_commit)?
+    let get_remote_head = |remote_name: &str,
+                           remote_branch_name: &str|
+     -> Result<Option<Box<repo::Commit>>, String> {
+        if let Ok(remote_branch) = repo.find_remote_branch(remote_name, remote_branch_name) {
+            Ok(Some(Box::new(remote_branch.commit_owned()?)))
+        } else {
+            Ok(None)
         }
     };
 
-    fn push(
-        remote: &mut repo::RemoteHandle,
-        branch_name: &str,
-        remote_branch_name: &str,
-        repo: &repo::RepoHandle,
-    ) -> Result<(), String> {
-        if !remote.is_pushable()? {
-            return Err(format!(
-                "Cannot push to non-pushable remote {}",
-                remote.url()
-            ));
+    let worktree = if worktree.local_branch_already_exists() {
+        worktree.select_commit(None)
+    } else if let Some((remote_name, remote_branch_name)) = if no_track { None } else { track } {
+        if let Ok(remote_branch) = repo.find_remote_branch(remote_name, remote_branch_name) {
+            worktree.select_commit(Some(Box::new(remote_branch.commit_owned()?)))
+        } else {
+            worktree.select_commit(Some(Box::new(default_branch_head)))
         }
-        remote.push(branch_name, remote_branch_name, repo)
-    }
-
-    if !no_track {
-        if let Some((remote_name, remote_branch_name)) = track {
-            if remote_branch_exists {
-                target_branch.set_upstream(remote_name, remote_branch_name)?;
-            } else {
-                let mut remote = repo
-                    .find_remote(remote_name)
-                    .map_err(|error| format!("Error getting remote {}: {}", remote_name, error))?
-                    .ok_or_else(|| format!("Remote {} not found", remote_name))?;
-
-                push(
-                    &mut remote,
-                    &target_branch.name()?,
-                    remote_branch_name,
-                    &repo,
-                )?;
-
-                target_branch.set_upstream(remote_name, remote_branch_name)?;
-            }
-        } else if let Some(config) = config {
-            if let Some(track_config) = config.track {
-                if track_config.default {
-                    let remote_name = track_config.default_remote;
-                    if remote_branch_exists {
-                        target_branch.set_upstream(&remote_name, name)?;
+    } else {
+        match remotes.len() {
+            0 => worktree.select_commit(Some(Box::new(default_branch_head))),
+            1 => {
+                let remote_name = &remotes[0];
+                let commit: Option<Box<repo::Commit>> = ({
+                    if let Some(prefix) = prefix {
+                        get_remote_head(remote_name, &format!("{prefix}/{name}"))?
                     } else {
-                        let remote_branch_name = match track_config.default_remote_prefix {
-                            Some(prefix) => {
-                                format!("{}{}{}", &prefix, super::BRANCH_NAMESPACE_SEPARATOR, &name)
-                            }
-                            None => name.to_string(),
-                        };
-
-                        let mut remote = repo
-                            .find_remote(&remote_name)
-                            .map_err(|error| {
-                                format!("Error getting remote {}: {}", remote_name, error)
-                            })?
-                            .ok_or_else(|| format!("Remote {} not found", remote_name))?;
-
-                        if !remote.is_pushable()? {
-                            return Err(format!(
-                                "Cannot push to non-pushable remote {}",
-                                remote.url()
-                            ));
-                        }
-                        push(
-                            &mut remote,
-                            &target_branch.name()?,
-                            &remote_branch_name,
-                            &repo,
-                        )?;
-
-                        target_branch.set_upstream(&remote_name, &remote_branch_name)?;
+                        None
                     }
+                })
+                .or(get_remote_head(remote_name, name)?)
+                .or_else(|| Some(Box::new(default_branch_head)));
+
+                worktree.select_commit(commit)
+            }
+            _ => {
+                let commit = if let Some(ref default_remote) = default_remote {
+                    if let Some(ref prefix) = prefix {
+                        if let Ok(remote_branch) = repo
+                            .find_remote_branch(default_remote, &format!("{prefix}/{name}"))
+                        {
+                            Some(Box::new(remote_branch.commit_owned()?))
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                    .or({
+                        if let Ok(remote_branch) =
+                            repo.find_remote_branch(default_remote, name)
+                        {
+                            Some(Box::new(remote_branch.commit_owned()?))
+                        } else {
+                            None
+                        }
+                    })
+                } else {
+                    None
+                }.or({
+                    let mut commits = vec![];
+                    for remote_name in remotes.iter() {
+                        let remote_head: Option<Box<repo::Commit>> = ({
+                            if let Some(ref prefix) = prefix {
+                                if let Ok(remote_branch) = repo.find_remote_branch(
+                                    remote_name,
+                                    &format!("{prefix}/{name}"),
+                                ) {
+                                    Some(Box::new(remote_branch.commit_owned()?))
+                                } else {
+                                    None
+                                }
+                            } else {
+                                None
+                            }
+                        })
+                        .or({
+                            if let Ok(remote_branch) =
+                                repo.find_remote_branch(remote_name, name)
+                            {
+                                Some(Box::new(remote_branch.commit_owned()?))
+                            } else {
+                                None
+                            }
+                        })
+                        .or(None);
+                        commits.push(remote_head);
+                    }
+
+                    let mut commits = commits
+                        .into_iter()
+                        .flatten()
+                        // have to collect first because the `flatten()` return
+                        // typedoes not implement `windows()`
+                        .collect::<Vec<Box<repo::Commit>>>();
+                    // `flatten()` takes care of `None` values here. If all
+                    // remotes return None for the branch, we do *not* abort, we
+                    // continue!
+                    if commits.is_empty() {
+                        Some(Box::new(default_branch_head))
+                    } else if commits.len() == 1 {
+                        Some(commits.swap_remove(0))
+                    } else if commits.windows(2).any(|window| {
+                        let c1 = &window[0];
+                        let c2 = &window[1];
+                        (*c1).id().hex_string() != (*c2).id().hex_string()
+                    }) {
+                        warnings.push(
+                            // TODO this should also include the branch
+                            // name. BUT: the branch name may be different
+                            // between the remotes. Let's just leave it
+                            // until I get around to fix that inconsistency
+                            // (see module-level doc about), which might be
+                            // never, as it's such a rare edge case.
+                            "Branch exists on multiple remotes, but they deviate. Selecting default branch instead".to_string()
+                        );
+                        Some(Box::new(default_branch_head))
+                    } else {
+                        Some(commits.swap_remove(0))
+                    }
+                });
+                worktree.select_commit(commit)
+            }
+        }
+    };
+
+    let worktree = if no_track {
+        worktree.set_remote_tracking_branch(None, prefix.map(|s| s.as_str()))
+    } else if let Some((remote_name, remote_branch_name)) = track {
+        worktree.set_remote_tracking_branch(
+            Some((remote_name, remote_branch_name)),
+            None, // Always disable prefixing when explicitly given --track
+        )
+    } else if !enable_tracking {
+        worktree.set_remote_tracking_branch(None, prefix.map(|s| s.as_str()))
+    } else {
+        match remotes.len() {
+            0 => worktree.set_remote_tracking_branch(None, prefix.map(|s| s.as_str())),
+            1 => worktree
+                .set_remote_tracking_branch(Some((&remotes[0], name)), prefix.map(|s| s.as_str())),
+            _ => {
+                if let Some(default_remote) = default_remote {
+                    worktree.set_remote_tracking_branch(
+                        Some((&default_remote, name)),
+                        prefix.map(|s| s.as_str()),
+                    )
+                } else {
+                    worktree.set_remote_tracking_branch(None, prefix.map(|s| s.as_str()))
                 }
             }
         }
-    }
+    };
 
-    if let Some(subdirectory) = subdirectory {
-        std::fs::create_dir_all(subdirectory).map_err(|error| error.to_string())?;
-    }
-    repo.new_worktree(name, &path, &target_branch)?;
+    worktree.create(directory)?;
 
-    Ok(())
+    Ok(if warnings.is_empty() {
+        None
+    } else {
+        Some(warnings)
+    })
 }