Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 mike
|
1e3ae9a4c7 | ||
 mikeandClaude Opus 5
|
b4797b056e | ||
|
mike
|
9bc17513ed | ||
|
mikeandClaude Opus 5
|
8c4d8da4e9 | ||
|
mikeandClaude Opus 5
|
f3d8cbe281 | ||
|
mikeandClaude Opus 5
|
cd5ab1a2bd | ||
|
mikeandClaude Opus 5
|
65342bcd7c | ||
|
mikeandClaude Opus 5
|
0d0d28560e | ||
|
mikeandClaude Opus 5
|
2acca170e6 | ||
|
mikeandClaude Opus 5
|
2a622046f2 | ||
|
mikeandClaude Opus 5
|
61a7059f61 | ||
|
mikeandClaude Opus 5
|
8ca05d6ad2 | ||
|
mikeandClaude Opus 5
|
cb1ff98c3d | ||
|
mikeandClaude Opus 5
|
86fb898df4 | ||
|
mikeandClaude Opus 5
|
3a420093d1 |
@@ -8,4 +8,5 @@
|
||||
.TemporaryItems
|
||||
.Trashes
|
||||
mgsh
|
||||
bin/
|
||||
.mgshrc
|
||||
|
||||
@@ -17,14 +17,36 @@ directory. Go port of the original Perl `mgsh` (`mgsh.perl`).
|
||||
## Build
|
||||
|
||||
```sh
|
||||
./build.sh # builds ./mgsh and bumps the patch version by 0.0.1
|
||||
./build.sh # all platforms into ./bin, bumps the patch version
|
||||
PLATFORMS="linux/amd64" ./build.sh # just one
|
||||
go build -o mgsh . # plain build, keeps the default version
|
||||
```
|
||||
|
||||
`build.sh` reads `version.txt`, increments the patch component, injects it via
|
||||
`-ldflags -X main.VERSION`, and writes it back — so `version.txt` always holds
|
||||
the version of the binary just built. Dependencies are fetched via Go modules
|
||||
(`go.mod` / `go.sum`) on first build.
|
||||
`build.sh` cross-compiles for `darwin/arm64`, `darwin/amd64`, `linux/amd64` and
|
||||
`linux/arm64` into `./bin`:
|
||||
|
||||
```
|
||||
bin/mgsh -> mgsh-darwin-arm64 (this machine)
|
||||
bin/mgsh-darwin-amd64
|
||||
bin/mgsh-darwin-arm64
|
||||
bin/mgsh-linux-amd64
|
||||
bin/mgsh-linux-arm64
|
||||
```
|
||||
|
||||
`bin/mgsh` is a symlink to the build for the host, so there is one stable path
|
||||
to "the binary for this machine". `bin/` is git-ignored. Windows is deliberately
|
||||
absent: mgsh shells out to `stty` and `/bin/sh`, so it would compile there and
|
||||
then not work.
|
||||
|
||||
Everything is built with `CGO_ENABLED=0`, which makes the cross builds need no
|
||||
toolchain per target and the binaries static; `os/user` resolves the current
|
||||
user without cgo on both darwin and linux.
|
||||
|
||||
It reads `version.txt`, increments the patch component, injects it via
|
||||
`-ldflags -X main.VERSION` into **all** platforms of that run, and writes it
|
||||
back — so `version.txt` always holds the version of the binaries just built, and
|
||||
they all carry the same one. Dependencies are fetched via Go modules (`go.mod` /
|
||||
`go.sum`) on first build.
|
||||
|
||||
Run the tests with `go test ./...`.
|
||||
|
||||
@@ -40,7 +62,7 @@ stand in. Outside `base` no project is selected. `mgsh <project>` starts the
|
||||
interactive shell with that project preselected.
|
||||
|
||||
The commands available directly from the shell are `clone`, `init`, `log`,
|
||||
`push`, `pushremote`, `release`, `list`, `tag`, `archive`, `show`, `open`,
|
||||
`push`, `pushremote`, `release`, `list`, `tag`, `archive`, `show`,
|
||||
`pull`, `fetch`, `status`, `diff`, `overview`, `config`, `count`, `login` and
|
||||
`cloneall`; every other command is interactive-only.
|
||||
|
||||
@@ -52,9 +74,10 @@ project, its git branch and a `*` dirty marker:
|
||||
```
|
||||
|
||||
Features: command history (`~/.mgsh_history`), Tab completion (commands, local
|
||||
projects for `cd`/`open`, server repos for `clone`/`show`, branches/tags for
|
||||
`checkout`/`tag`, mirror targets for `pushremote`, filesystem paths for `dist`),
|
||||
and colored `list`/`log`/error output.
|
||||
projects for `cd`, server repos for `clone`/`show`, branches/tags for
|
||||
`checkout`/`tag`, mirror targets for `pushremote`/`release`, filesystem paths for
|
||||
`dist`, and shell-style completion after `!` and for aliases that expand to
|
||||
one), and colored `list`/`log`/error output.
|
||||
|
||||
The server repository list is fetched once per session on the first Tab that
|
||||
needs it; `rescan` refreshes it (and reloads the configuration).
|
||||
@@ -70,6 +93,34 @@ prefix it with `!`:
|
||||
< src/myproject > !ls -la
|
||||
```
|
||||
|
||||
It runs in the active project's directory. Tab completion works there the way it
|
||||
does in a shell: the word after the `!` completes against the executables on
|
||||
`PATH`, everything after it against the filesystem — relative to the project,
|
||||
with `~/` and absolute paths understood, and directories completing with their
|
||||
trailing slash so the next Tab walks into them. Dot entries stay out of the way
|
||||
until the prefix asks for one.
|
||||
|
||||
```
|
||||
< src/myproject > !vi ma<Tab> -> !vi main
|
||||
< src/myproject > !vi <Tab> -> Makefile main.go main_test.go src/
|
||||
< src/myproject > !gre<Tab> -> grep gresource
|
||||
```
|
||||
|
||||
An alias that expands to a shell escape completes the same way, because its
|
||||
arguments end up as shell arguments:
|
||||
|
||||
```
|
||||
alias ll '!ls -la'
|
||||
< src/myproject > ll ma<Tab> -> ll main
|
||||
```
|
||||
|
||||
Only the alias's arguments complete, never its first word — the command is
|
||||
fixed by the alias body. An alias to a builtin (`alias co 'checkout $1'`) is not
|
||||
a shell line and is left alone.
|
||||
|
||||
Word splitting for completion is by whitespace only; quotes and backslash
|
||||
escapes are left to the shell that runs the line.
|
||||
|
||||
### Commands
|
||||
|
||||
Run `help` for the full list. Highlights:
|
||||
@@ -115,7 +166,6 @@ project /Users/me/src/myproject/.mgshrc
|
||||
gitport 22
|
||||
gituser git
|
||||
gitpath /home/git
|
||||
editor code (.mgshrc)
|
||||
remotes hub (.mgshrc)
|
||||
clone url ssh://git@git.example.com:22/home/git
|
||||
|
||||
@@ -134,14 +184,20 @@ worked-on project sits closest to the prompt:
|
||||
|
||||
```
|
||||
< src > list
|
||||
Betaflight3.0.0 Sep 28 2016
|
||||
website Mar 3 2024
|
||||
notes Jan 3 14:32
|
||||
3 repositories
|
||||
Betaflight3.0.0 Sep 28 2016 181M
|
||||
website Mar 3 2024 2.1M
|
||||
notes Jan 3 14:32 876K
|
||||
3 repositories · 184M
|
||||
```
|
||||
|
||||
`list -a` lists the archives instead, with their sizes; a pattern filters by
|
||||
name (`list note`).
|
||||
The size is the repository's real disk usage on the server, asked of `du` in
|
||||
the same round trip as the listing — a long listing reports the inode size for
|
||||
a directory, which is the same number for every repository and says nothing. If
|
||||
the server produces no usable sizes the column is left out rather than filled
|
||||
with zeroes.
|
||||
|
||||
`list -a` lists the archives instead, whose sizes come from the listing itself;
|
||||
a pattern filters by name (`list note`).
|
||||
|
||||
### Overview
|
||||
|
||||
@@ -150,26 +206,45 @@ thing that sees the local base directory *and* the git server at once.
|
||||
|
||||
```
|
||||
< src > overview
|
||||
mgsh * ↑2 · desktop 3h · → hub,gitea
|
||||
notes ✓ · laptop 2d
|
||||
website ✓ (no upstream) · laptop 20d
|
||||
3 projects · 1 dirty · 1 in sync
|
||||
not on the git server: scratch, experiments (init)
|
||||
not cloned here: oldproject (clone)
|
||||
notes * ↑2 laptop 3h
|
||||
website * ✓ desktop 2d → hub
|
||||
Betaflight3.0.0 ✓ workstation 20d → gitea hub
|
||||
experiments init
|
||||
sandbox (wip) – laptop 1h init
|
||||
4 projects · 2 dirty · 2 in sync · 2 to init
|
||||
```
|
||||
|
||||
Per project: dirty marker, commits ahead/behind the upstream, the branch when it
|
||||
is not `master`/`main`, and the mirror targets the repository has a remote for.
|
||||
Every field sits in its own column, so the eye can go down one instead of
|
||||
hunting along each line. The projects that need something done come first, the
|
||||
settled ones next, and the directories the git server does not have yet come
|
||||
last — those are a different kind of task. Within each group the order stays
|
||||
alphabetical, so positions do not jump around.
|
||||
|
||||
The machine and age come from the commit itself — `push` writes `[user@host]`
|
||||
into every message, so `overview` can say where a project was last worked on
|
||||
without storing anything. On a setup spanning a laptop and a workstation that is
|
||||
usually the piece of information you actually wanted.
|
||||
| column | meaning |
|
||||
|---|---|
|
||||
| name | the project, with its branch appended when it is not `master`/`main` |
|
||||
| `*` | uncommitted changes |
|
||||
| `↑n` `↓n` | commits ahead of / behind the upstream (`↑2↓1` when both) |
|
||||
| `✓` | in sync with the upstream |
|
||||
| `–` | the branch tracks nothing — never pushed |
|
||||
| `init` | the git server does not have this one; run `init` |
|
||||
| host, age | who last committed and when, from the `[user@host]` stamp |
|
||||
| `→` | mirror targets this repository has a remote for |
|
||||
|
||||
The two lists at the end are the join no git command can do: local projects the
|
||||
server has never seen (`init` them) and server repositories missing on this
|
||||
machine (`clone` them). If the server cannot be reached, mgsh says so instead of
|
||||
claiming everything is missing.
|
||||
Every directory under the base gets a row, including those that are not
|
||||
repositories at all — `init` is exactly what turns one into a project, so it
|
||||
belongs in the table rather than in a list underneath it. Such a row simply has
|
||||
no git state to show.
|
||||
|
||||
The host and age come from the commit itself — `push` writes `[user@host]` into
|
||||
every message, so `overview` can say where a project was last worked on without
|
||||
storing anything. On a setup spanning a laptop and a workstation that is usually
|
||||
the piece of information you actually wanted.
|
||||
|
||||
The `init` column is the join no git command can do. If the server cannot be
|
||||
reached, no row is marked and mgsh says so — not knowing is not the same as
|
||||
knowing they are missing. The other direction, repositories on the server that
|
||||
are not here, is what `list` shows.
|
||||
|
||||
### Credential check
|
||||
|
||||
@@ -234,38 +309,37 @@ alias ec '!echo $1' # ec hello -> echo hello (shell)
|
||||
|
||||
Besides the internal ssh git server, `pushremote` mirrors the active project to
|
||||
one or more public hosting servers (Gitea, GitHub or GitLab) over their REST
|
||||
API. A single server is configured flat:
|
||||
|
||||
```ini
|
||||
remoteurl = https://git.example.com # base URL of the server
|
||||
remotekey = <personal-access-token> # API token
|
||||
# remotetype = gitea # optional; auto-detected from remoteurl
|
||||
# remotevisibility = private # visibility of created repos (default private)
|
||||
# mirror = true # `push` also mirrors via pushremote
|
||||
```
|
||||
|
||||
Several servers get one `remote.<name>.*` block each:
|
||||
API. Each server is one `remote.<name>.<field>` block:
|
||||
|
||||
```ini
|
||||
remote.gitea.url = https://git.example.com
|
||||
remote.gitea.key = <personal-access-token>
|
||||
remote.gitea.type = gitea # optional; auto-detected from the url
|
||||
remote.gitea.visibility = private # or public (default private)
|
||||
|
||||
remote.hub.url = https://github.com
|
||||
remote.hub.key = <personal-access-token>
|
||||
remote.hub.visibility = public
|
||||
remote.gitlab.url = https://gitlab.example.com
|
||||
remote.gitlab.key = <personal-access-token>
|
||||
remote.gitlab.type = gitlab
|
||||
remote.gitlab.visibility = public
|
||||
|
||||
# remotes = gitea, hub # optional: restrict and order the set
|
||||
# remotes = gitea, gitlab # optional: restrict and order the set
|
||||
# mirror = true # `push` also mirrors via pushremote
|
||||
```
|
||||
|
||||
`<name>` is yours to pick; there is no other spelling. Older versions had a flat
|
||||
`remoteurl`/`remotekey` pair for a single server — mgsh converts those to
|
||||
`remote.public.*` in place on the next start and says so, keeping the git remote
|
||||
name those versions used.
|
||||
|
||||
| command | pushes to |
|
||||
|------------------------|-----------------------------------------------|
|
||||
| `pushremote` | every configured target, in order |
|
||||
| `pushremote @hub` | only `hub` |
|
||||
| `pushremote @hub @gitea` | those two |
|
||||
| `pushremote @gitea` | only `gitea` |
|
||||
| `pushremote @gitea @gitlab` | those two |
|
||||
| `pushremote a fix` | every target, description "a fix" |
|
||||
|
||||
Each target owns a git remote of the same name in the repository (the flat form
|
||||
uses `public`, as before), so `git push hub` keeps working outside mgsh. A
|
||||
Each target owns a git remote of the same name in the repository, so
|
||||
`git push gitlab` keeps working outside mgsh. A
|
||||
target that fails does not stop the others; with more than one target
|
||||
`pushremote` prints an `n/m remotes updated` summary. `remotes = …` restricts
|
||||
and orders the set, which is mostly useful in a project `.mgshrc` — see below.
|
||||
@@ -279,9 +353,10 @@ The token is sent as a one-shot HTTP auth header: it is never written into the
|
||||
repo's git config, and it reaches git through the environment rather than the
|
||||
command line, so it does not show up in the process table. Because `~/.mgshrc`
|
||||
then holds a credential, mgsh creates it mode `600` and warns at startup if an
|
||||
existing file is readable by others. The provider is auto-detected from `remoteurl` (`github.com` →
|
||||
GitHub, `gitlab*` → GitLab, otherwise Gitea) and can be forced with
|
||||
`remotetype`. Set `mirror = true` to have every `push` mirror automatically.
|
||||
existing file is readable by others. The provider is auto-detected from the url
|
||||
(`github.com` → GitHub, `gitlab*` → GitLab, otherwise Gitea) and can be forced
|
||||
with `remote.<name>.type`. Set `mirror = true` to have every `push` mirror
|
||||
automatically.
|
||||
|
||||
### Releases
|
||||
|
||||
@@ -317,11 +392,43 @@ on different servers. `release` also refuses when the repository is not on the
|
||||
mirror yet and tells you to run `pushremote` first, rather than creating it as a
|
||||
side effect.
|
||||
|
||||
**No binary assets.** The three providers handle uploads in three incompatible
|
||||
ways — Gitea attaches them to the release, GitHub uses a separate upload host,
|
||||
and GitLab does not host them at all but expects a link into its package
|
||||
registry. mgsh publishes source releases with notes; if you need binaries,
|
||||
upload them with the provider's own tooling.
|
||||
#### Binaries and assets
|
||||
|
||||
If the project has a `./bin` or `./assets` directory, every file in it is
|
||||
attached to the release — nothing to configure, and nothing happens for a
|
||||
project that has neither:
|
||||
|
||||
```
|
||||
< src/mgsh > release v4.1.0
|
||||
attaching 5 assets, 38M from ./bin and ./assets
|
||||
remote gitea released https://git.example.com/mike/mgsh.git
|
||||
uploading logo.png 2.0K
|
||||
uploading mgsh-darwin-amd64 9.8M
|
||||
uploading mgsh-darwin-arm64 9.2M
|
||||
uploading mgsh-linux-amd64 9.7M
|
||||
uploading mgsh-linux-arm64 8.9M
|
||||
```
|
||||
|
||||
Only regular files directly in those directories are taken: subdirectories are
|
||||
not descended into, and symlinks are skipped — `bin/mgsh` points at one of its
|
||||
own siblings, and uploading the same binary twice under two names helps nobody.
|
||||
A name present in both directories is used from `bin` and reported for
|
||||
`assets`, since one asset name can only mean one file.
|
||||
|
||||
Re-releasing the same tag replaces same-named assets instead of failing or
|
||||
piling up duplicates, because rebuilding and publishing again is the normal
|
||||
reason to do it. A file that fails to upload does not stop the rest.
|
||||
|
||||
This is where the providers stop resembling each other, and mgsh papers over it:
|
||||
|
||||
| | how the bytes get there |
|
||||
|---|---|
|
||||
| Gitea | multipart `POST` to `…/releases/<id>/assets?name=<name>` |
|
||||
| GitHub | raw `POST` to the separate upload host named by the release's `upload_url` |
|
||||
| GitLab | a release stores links, not files: the file goes into the project's generic **package registry** and the release gets a `package` link pointing at it |
|
||||
|
||||
The GitLab route needs the package registry enabled on the project — it is on by
|
||||
default, but a self-hosted instance can turn it off.
|
||||
|
||||
## Configuration
|
||||
|
||||
@@ -355,7 +462,6 @@ gitpath = /home/git
|
||||
gitname = Your Name
|
||||
gitemail = you@example.com
|
||||
pushdefault = matching
|
||||
editor = code # fallback opener for `open`
|
||||
|
||||
alias co 'checkout $1'
|
||||
```
|
||||
@@ -365,8 +471,10 @@ alias co 'checkout $1'
|
||||
### Settings reference
|
||||
|
||||
Every setting can also be given as an environment variable named `MGSH_<KEY>`
|
||||
(e.g. `MGSH_GITHOST`), which wins over both files. "Scope" says whether a
|
||||
project `.mgshrc` may override the setting.
|
||||
(e.g. `MGSH_GITHOST`), which wins over both files; a mirror field is
|
||||
`MGSH_REMOTE_<NAME>_<FIELD>`, so `MGSH_REMOTE_GITLAB_KEY` sets
|
||||
`remote.gitlab.key`. "Scope" says whether a project `.mgshrc` may override the
|
||||
setting.
|
||||
|
||||
| setting | scope | meaning |
|
||||
|---|---|---|
|
||||
@@ -379,15 +487,10 @@ project `.mgshrc` may override the setting.
|
||||
| `gitname` | global | `user.name` written to the **global** git config at startup |
|
||||
| `gitemail` | global | `user.email` written to the global git config |
|
||||
| `pushdefault` | global | `push.default` written to the global git config |
|
||||
| `editor` | project | opener used by `open`/`view` when the project has no Xcode workspace (default `coda`) |
|
||||
| `remoteurl` | project | base URL of a single mirror server (target name `public`) |
|
||||
| `remotekey` | project | API token for `remoteurl` |
|
||||
| `remotetype` | project | `gitea`\|`github`\|`gitlab`; auto-detected from the URL when unset |
|
||||
| `remotevisibility` | project | `private` (default) or `public` for repositories created by `pushremote` |
|
||||
| `remote.<name>.url` | project | base URL of the named mirror target |
|
||||
| `remote.<name>.url` | project | base URL of the mirror target `<name>` |
|
||||
| `remote.<name>.key` | project | API token for that target |
|
||||
| `remote.<name>.type` | project | provider override for that target |
|
||||
| `remote.<name>.visibility` | project | visibility for that target |
|
||||
| `remote.<name>.type` | project | `gitea`\|`github`\|`gitlab`; auto-detected from the url when unset |
|
||||
| `remote.<name>.visibility` | project | `private` (default) or `public` for repositories `pushremote` creates |
|
||||
| `remotes` | project | comma- or space-separated list restricting and ordering the mirror targets |
|
||||
| `mirror` | project | truthy (`1`/`true`/`yes`/`on`) → every `push` also mirrors |
|
||||
| `secretscan` | project | `off` disables the credential check `push` runs before committing (on by default; only an explicit `off` disables it) |
|
||||
@@ -400,7 +503,7 @@ only when they actually differ, so a plain `mgsh status` does not rewrite
|
||||
|
||||
A project may carry its own `.mgshrc`, which overrides the global settings while
|
||||
that project is active — a project on a different git server, with a different
|
||||
editor, or mirrored to a different place:
|
||||
ssh identity, or mirrored to a different place:
|
||||
|
||||
```ini
|
||||
# ~/src/myproject/.mgshrc
|
||||
|
||||
@@ -46,7 +46,7 @@ var builtinCmds = map[string]bool{
|
||||
"diff": true, "pull": true, "fetch": true, "push": true, "edit": true,
|
||||
"pushremote": true, "overview": true, "archive": true, "init": true,
|
||||
"login": true, "cd": true, "checkout": true, "clone": true, "cloneall": true,
|
||||
"open": true, "view": true, "count": true, "tag": true, "alias": true,
|
||||
"count": true, "tag": true, "alias": true,
|
||||
"unalias": true, "config": true, "release": true,
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,323 @@
|
||||
package main
|
||||
|
||||
// assets.go — attaching files to a release.
|
||||
//
|
||||
// `release` uploads everything in the project's ./bin and ./assets when those
|
||||
// directories exist. This is where the three providers stop resembling each
|
||||
// other, so each gets its own path:
|
||||
//
|
||||
// Gitea multipart POST to .../releases/<id>/assets?name=<name>
|
||||
// GitHub raw POST to the upload host named by the release object's upload_url
|
||||
// GitLab no asset hosting on a release at all: the file goes into the generic
|
||||
// package registry, and the release gets a link pointing at it
|
||||
//
|
||||
// Re-releasing the same tag replaces same-named assets rather than failing or
|
||||
// piling up duplicates, because rebuilding and publishing again is the normal
|
||||
// reason to do it.
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"mime"
|
||||
"mime/multipart"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// assetDirs are the project directories whose files a release carries.
|
||||
var assetDirs = []string{"bin", "assets"}
|
||||
|
||||
// releaseAsset is one file to attach to a release.
|
||||
type releaseAsset struct {
|
||||
name string
|
||||
path string
|
||||
size int64
|
||||
}
|
||||
|
||||
// collectAssets gathers the files to attach: every regular file directly in
|
||||
// the project's ./bin and ./assets. Subdirectories are not descended into, and
|
||||
// symlinks are skipped — bin/mgsh points at one of its own siblings, and
|
||||
// uploading the same binary twice under two names helps nobody.
|
||||
func collectAssets(dir string) (assets []releaseAsset, skipped []string) {
|
||||
seen := map[string]bool{}
|
||||
for _, sub := range assetDirs {
|
||||
path := filepath.Join(dir, sub)
|
||||
entries, err := os.ReadDir(path)
|
||||
if err != nil {
|
||||
continue // the directory simply is not there
|
||||
}
|
||||
for _, e := range entries {
|
||||
if e.IsDir() || e.Type()&os.ModeSymlink != 0 {
|
||||
continue
|
||||
}
|
||||
fi, err := e.Info()
|
||||
if err != nil || !fi.Mode().IsRegular() {
|
||||
continue
|
||||
}
|
||||
if seen[e.Name()] {
|
||||
// bin/x and assets/x would fight over one asset name
|
||||
skipped = append(skipped, filepath.Join(sub, e.Name()))
|
||||
continue
|
||||
}
|
||||
seen[e.Name()] = true
|
||||
assets = append(assets, releaseAsset{
|
||||
name: e.Name(),
|
||||
path: filepath.Join(path, e.Name()),
|
||||
size: fi.Size(),
|
||||
})
|
||||
}
|
||||
}
|
||||
sort.Slice(assets, func(i, j int) bool { return assets[i].name < assets[j].name })
|
||||
return assets, skipped
|
||||
}
|
||||
|
||||
// contentType guesses a type from the file name, falling back to the one for
|
||||
// "some bytes" — which is what a compiled binary is.
|
||||
func contentType(name string) string {
|
||||
if t := mime.TypeByExtension(filepath.Ext(name)); t != "" {
|
||||
return t
|
||||
}
|
||||
return "application/octet-stream"
|
||||
}
|
||||
|
||||
// doUpload sends a request with a raw body of a known size. The JSON helper
|
||||
// cannot express these: an asset upload is bytes, not an object, and the
|
||||
// providers insist on a Content-Length rather than a chunked body.
|
||||
func (r *remoteAPI) doUpload(method, endpoint, ctype string, body io.Reader, size int64) (int, []byte, error) {
|
||||
req, err := http.NewRequest(method, endpoint, body)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
req.ContentLength = size
|
||||
req.Header.Set("Content-Type", ctype)
|
||||
hk, hv := r.authHeader()
|
||||
req.Header.Set(hk, hv)
|
||||
req.Header.Set("Accept", "application/json")
|
||||
|
||||
resp, err := r.http.Do(req)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
data, _ := io.ReadAll(resp.Body)
|
||||
return resp.StatusCode, data, nil
|
||||
}
|
||||
|
||||
// uploadAssets attaches every file to the release, reporting each one as it
|
||||
// goes: these are megabytes over a network, and silence for a minute looks like
|
||||
// a hang. A file that fails does not stop the rest.
|
||||
func (r *remoteAPI) uploadAssets(owner, repo string, ref releaseRef, assets []releaseAsset) error {
|
||||
failed := 0
|
||||
for _, a := range assets {
|
||||
fmt.Printf(" %s %s %s\n", col(cGray, "uploading"),
|
||||
col(cGreen, padRight(a.name, 28)), col(cGray, humanSize(a.size)))
|
||||
if err := r.uploadAsset(owner, repo, ref, a); err != nil {
|
||||
errorln(" " + a.name + ": " + err.Error())
|
||||
failed++
|
||||
}
|
||||
}
|
||||
if failed > 0 {
|
||||
return fmt.Errorf("%d of %d assets failed", failed, len(assets))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// uploadAsset attaches one file, replacing an asset of the same name that is
|
||||
// already on the release.
|
||||
func (r *remoteAPI) uploadAsset(owner, repo string, ref releaseRef, a releaseAsset) error {
|
||||
if err := r.removeAsset(owner, repo, ref, a.name); err != nil {
|
||||
return err
|
||||
}
|
||||
switch r.kind {
|
||||
case kindGitLab:
|
||||
return r.uploadAssetGitLab(owner, repo, ref, a)
|
||||
case kindGitHub:
|
||||
return r.uploadAssetGitHub(ref, a)
|
||||
default:
|
||||
return r.uploadAssetGitea(owner, repo, ref, a)
|
||||
}
|
||||
}
|
||||
|
||||
// uploadAssetGitea posts the file as a multipart form, streamed from disk
|
||||
// rather than buffered: these are whole binaries.
|
||||
func (r *remoteAPI) uploadAssetGitea(owner, repo string, ref releaseRef, a releaseAsset) error {
|
||||
f, err := os.Open(a.path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer f.Close()
|
||||
|
||||
pr, pw := io.Pipe()
|
||||
mw := multipart.NewWriter(pw)
|
||||
go func() {
|
||||
part, err := mw.CreateFormFile("attachment", a.name)
|
||||
if err == nil {
|
||||
_, err = io.Copy(part, f)
|
||||
}
|
||||
if err != nil {
|
||||
pw.CloseWithError(err)
|
||||
return
|
||||
}
|
||||
pw.CloseWithError(mw.Close())
|
||||
}()
|
||||
|
||||
ep := r.releasePath(owner, repo) + "/" + ref.id + "/assets?name=" + url.QueryEscape(a.name)
|
||||
// the multipart length is not known up front, so this one is chunked
|
||||
code, data, err := r.doUpload("POST", ep, mw.FormDataContentType(), pr, -1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if code != 200 && code != 201 {
|
||||
return fmt.Errorf("HTTP %d: %s", code, firstLine(data))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// uploadAssetGitHub posts the raw bytes to the host the release object named.
|
||||
func (r *remoteAPI) uploadAssetGitHub(ref releaseRef, a releaseAsset) error {
|
||||
if ref.uploadURL == "" {
|
||||
return fmt.Errorf("the release carries no upload_url")
|
||||
}
|
||||
f, err := os.Open(a.path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer f.Close()
|
||||
|
||||
ep := ref.uploadURL + "?name=" + url.QueryEscape(a.name)
|
||||
code, data, err := r.doUpload("POST", ep, contentType(a.name), f, a.size)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if code != 200 && code != 201 {
|
||||
return fmt.Errorf("HTTP %d: %s", code, firstLine(data))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// uploadAssetGitLab puts the file into the project's generic package registry
|
||||
// and links the release to it, since a GitLab release stores links, not files.
|
||||
func (r *remoteAPI) uploadAssetGitLab(owner, repo string, ref releaseRef, a releaseAsset) error {
|
||||
f, err := os.Open(a.path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer f.Close()
|
||||
|
||||
pkg := r.packagePath(owner, repo, ref.tag, a.name)
|
||||
code, data, err := r.doUpload("PUT", pkg, contentType(a.name), f, a.size)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if code != 200 && code != 201 {
|
||||
return fmt.Errorf("package upload failed (HTTP %d): %s", code, firstLine(data))
|
||||
}
|
||||
|
||||
code, data, err = r.do("POST", r.releaseByTagPath(owner, repo, ref.tag)+"/assets/links",
|
||||
map[string]any{"name": a.name, "url": pkg, "link_type": "package"})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if code != 200 && code != 201 {
|
||||
return fmt.Errorf("linking the package failed (HTTP %d): %s", code, firstLine(data))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// packagePath is where a release asset lives in GitLab's generic registry: one
|
||||
// package named after the repository, one version per tag.
|
||||
func (r *remoteAPI) packagePath(owner, repo, tag, name string) string {
|
||||
return r.repoPath(owner, repo) + "/packages/generic/" +
|
||||
url.PathEscape(repo) + "/" + url.PathEscape(tag) + "/" + url.PathEscape(name)
|
||||
}
|
||||
|
||||
// removeAsset deletes an asset of the given name from the release when one is
|
||||
// there, so re-releasing a tag after a rebuild replaces the files instead of
|
||||
// failing or leaving two of each.
|
||||
func (r *remoteAPI) removeAsset(owner, repo string, ref releaseRef, name string) error {
|
||||
listEP, delEP := r.assetEndpoints(owner, repo, ref)
|
||||
code, data, err := r.do("GET", listEP, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if code == 404 {
|
||||
return nil // nothing uploaded yet
|
||||
}
|
||||
if code != 200 {
|
||||
return fmt.Errorf("listing assets failed (HTTP %d): %s", code, firstLine(data))
|
||||
}
|
||||
|
||||
for _, id := range assetIDsNamed(data, name) {
|
||||
if code, data, err := r.do("DELETE", delEP+"/"+id, nil); err != nil {
|
||||
return err
|
||||
} else if code != 200 && code != 202 && code != 204 {
|
||||
return fmt.Errorf("deleting the previous %s failed (HTTP %d): %s", name, code, firstLine(data))
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// assetEndpoints returns where a release's assets are listed and deleted.
|
||||
// GitHub deletes an asset through the repository rather than the release.
|
||||
func (r *remoteAPI) assetEndpoints(owner, repo string, ref releaseRef) (list, del string) {
|
||||
switch r.kind {
|
||||
case kindGitLab:
|
||||
base := r.releaseByTagPath(owner, repo, ref.tag) + "/assets/links"
|
||||
return base, base
|
||||
case kindGitHub:
|
||||
return r.releasePath(owner, repo) + "/" + ref.id + "/assets",
|
||||
r.releasePath(owner, repo) + "/assets"
|
||||
default: // Gitea
|
||||
base := r.releasePath(owner, repo) + "/" + ref.id + "/assets"
|
||||
return base, base
|
||||
}
|
||||
}
|
||||
|
||||
// assetIDsNamed picks the ids of the listed assets called name. All three
|
||||
// providers answer with an array of objects carrying "id" and "name".
|
||||
func assetIDsNamed(data []byte, name string) []string {
|
||||
var list []struct {
|
||||
ID json.Number `json:"id"`
|
||||
Name string `json:"name"`
|
||||
}
|
||||
if err := json.Unmarshal(data, &list); err != nil {
|
||||
return nil
|
||||
}
|
||||
var ids []string
|
||||
for _, a := range list {
|
||||
if a.Name == name && a.ID.String() != "" {
|
||||
ids = append(ids, a.ID.String())
|
||||
}
|
||||
}
|
||||
return ids
|
||||
}
|
||||
|
||||
// assetSummary describes what will be uploaded, for the line `release` prints
|
||||
// before it starts.
|
||||
func assetSummary(assets []releaseAsset) string {
|
||||
var total int64
|
||||
for _, a := range assets {
|
||||
total += a.size
|
||||
}
|
||||
unit := "assets"
|
||||
if len(assets) == 1 {
|
||||
unit = "asset"
|
||||
}
|
||||
return strconv.Itoa(len(assets)) + " " + unit + ", " + humanSize(total)
|
||||
}
|
||||
|
||||
// assetDirList names the directories that were actually found, for the same line.
|
||||
func assetDirList(dir string) []string {
|
||||
var found []string
|
||||
for _, sub := range assetDirs {
|
||||
if isDir(filepath.Join(dir, sub)) {
|
||||
found = append(found, "./"+sub)
|
||||
}
|
||||
}
|
||||
return found
|
||||
}
|
||||
+284
@@ -0,0 +1,284 @@
|
||||
package main
|
||||
|
||||
// assets_test.go — attaching files to a release.
|
||||
//
|
||||
// The three providers upload assets in three unrelated ways, and the difference
|
||||
// is invisible until a real server rejects the request. The recording stand-in
|
||||
// lets each one be pinned down: where the bytes go, how they are wrapped, and
|
||||
// what else has to happen around them.
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// assetTree builds a project with ./bin and ./assets and returns its path.
|
||||
func assetTree(t *testing.T, files map[string]string) string {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
for rel, content := range files {
|
||||
p := filepath.Join(dir, rel)
|
||||
if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(p, []byte(content), 0755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
return dir
|
||||
}
|
||||
|
||||
func TestCollectAssets(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{
|
||||
"bin/mgsh-linux-amd64": "ELF...",
|
||||
"bin/mgsh-darwin-arm64": "MACH...",
|
||||
"assets/logo.png": "PNG",
|
||||
"assets/notes.txt": "text",
|
||||
"bin/sub/nested": "not descended into",
|
||||
"src/main.go": "not an asset directory",
|
||||
})
|
||||
// bin/mgsh is a symlink to one of its siblings, as build.sh leaves it
|
||||
if err := os.Symlink("mgsh-linux-amd64", filepath.Join(dir, "bin", "mgsh")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
assets, skipped := collectAssets(dir)
|
||||
var names []string
|
||||
for _, a := range assets {
|
||||
names = append(names, a.name)
|
||||
}
|
||||
want := "logo.png,mgsh-darwin-arm64,mgsh-linux-amd64,notes.txt"
|
||||
if strings.Join(names, ",") != want {
|
||||
t.Errorf("collected %v, want %s", names, want)
|
||||
}
|
||||
if len(skipped) != 0 {
|
||||
t.Errorf("skipped = %v, want none", skipped)
|
||||
}
|
||||
for _, a := range assets {
|
||||
if a.size == 0 {
|
||||
t.Errorf("%s has no size", a.name)
|
||||
}
|
||||
if _, err := os.Stat(a.path); err != nil {
|
||||
t.Errorf("%s: %v", a.name, err)
|
||||
}
|
||||
}
|
||||
|
||||
// a project with neither directory contributes nothing at all
|
||||
if got, _ := collectAssets(t.TempDir()); len(got) != 0 {
|
||||
t.Errorf("a project without bin/ or assets/ produced %v", got)
|
||||
}
|
||||
}
|
||||
|
||||
// TestCollectAssetsNameCollision: one asset name can only mean one file, so the
|
||||
// second directory's copy is reported rather than silently overwriting.
|
||||
func TestCollectAssetsNameCollision(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{
|
||||
"bin/tool": "the binary",
|
||||
"assets/tool": "something else with the same name",
|
||||
})
|
||||
assets, skipped := collectAssets(dir)
|
||||
if len(assets) != 1 || assets[0].name != "tool" ||
|
||||
!strings.HasSuffix(assets[0].path, "bin/tool") {
|
||||
t.Errorf("assets = %+v, want only bin/tool", assets)
|
||||
}
|
||||
if len(skipped) != 1 || !strings.Contains(skipped[0], "tool") {
|
||||
t.Errorf("skipped = %v, want the assets/ copy", skipped)
|
||||
}
|
||||
}
|
||||
|
||||
// TestUploadAssetGitea: a multipart POST under the field name Gitea expects,
|
||||
// with the asset name in the query.
|
||||
func TestUploadAssetGitea(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{"bin/mgsh-linux-amd64": "binary-bytes-here"})
|
||||
assets, _ := collectAssets(dir)
|
||||
|
||||
f := newFakeProvider(t)
|
||||
f.route("GET /api/v1/repos/mike/mgsh/releases/7/assets", 200, `[]`)
|
||||
f.route("POST /api/v1/repos/mike/mgsh/releases/7/assets", 201, `{"id":1}`)
|
||||
|
||||
api := newRemoteAPI(f.URL, "tok", "gitea")
|
||||
ref := releaseRef{tag: "v1.0", id: "7"}
|
||||
if err := api.uploadAsset("mike", "mgsh", ref, assets[0]); err != nil {
|
||||
t.Fatalf("uploadAsset: %v (requests %v)", err, f.paths())
|
||||
}
|
||||
|
||||
req := f.find("POST /api/v1/repos/mike/mgsh/releases/7/assets")
|
||||
if req == nil {
|
||||
t.Fatalf("no upload, requests: %v", f.paths())
|
||||
}
|
||||
if !strings.Contains(req.query, "name=mgsh-linux-amd64") {
|
||||
t.Errorf("query = %q, want the asset name", req.query)
|
||||
}
|
||||
if !strings.HasPrefix(req.ctype, "multipart/form-data") {
|
||||
t.Errorf("content type = %q, want multipart", req.ctype)
|
||||
}
|
||||
body := string(req.raw)
|
||||
if !strings.Contains(body, `name="attachment"`) {
|
||||
t.Errorf("form field is not 'attachment': %q", body)
|
||||
}
|
||||
if !strings.Contains(body, "binary-bytes-here") {
|
||||
t.Errorf("the file contents did not make it: %q", body)
|
||||
}
|
||||
}
|
||||
|
||||
// TestUploadAssetGitHub: the bytes go raw to the host the release object named,
|
||||
// not to the API host.
|
||||
func TestUploadAssetGitHub(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{"bin/tool": "raw-bytes"})
|
||||
assets, _ := collectAssets(dir)
|
||||
|
||||
f := newFakeProvider(t)
|
||||
f.route("GET /api/v3/repos/mike/mgsh/releases/7/assets", 200, `[]`)
|
||||
f.route("POST /uploads/repos/mike/mgsh/releases/7/assets", 201, `{"id":1}`)
|
||||
|
||||
api := newRemoteAPI(f.URL, "tok", "github")
|
||||
// the template suffix from the release object has to be stripped
|
||||
ref := api.parseReleaseRef("v1.0", []byte(`{"id":7,"upload_url":"`+
|
||||
f.URL+`/uploads/repos/mike/mgsh/releases/7/assets{?name,label}"}`))
|
||||
if ref.id != "7" || strings.Contains(ref.uploadURL, "{") {
|
||||
t.Fatalf("release ref = %+v, want id 7 and a bare upload url", ref)
|
||||
}
|
||||
|
||||
if err := api.uploadAsset("mike", "mgsh", ref, assets[0]); err != nil {
|
||||
t.Fatalf("uploadAsset: %v (requests %v)", err, f.paths())
|
||||
}
|
||||
req := f.find("POST /uploads/repos/mike/mgsh/releases/7/assets")
|
||||
if req == nil {
|
||||
t.Fatalf("no upload to the upload host, requests: %v", f.paths())
|
||||
}
|
||||
if string(req.raw) != "raw-bytes" {
|
||||
t.Errorf("body = %q, want the file verbatim", req.raw)
|
||||
}
|
||||
if !strings.Contains(req.query, "name=tool") {
|
||||
t.Errorf("query = %q, want the asset name", req.query)
|
||||
}
|
||||
}
|
||||
|
||||
// TestUploadAssetGitHubWithoutUploadURL: without one there is nowhere to put
|
||||
// the bytes, and that has to be said rather than guessed at.
|
||||
func TestUploadAssetGitHubWithoutUploadURL(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{"bin/tool": "x"})
|
||||
assets, _ := collectAssets(dir)
|
||||
f := newFakeProvider(t)
|
||||
f.route("GET /api/v3/repos/mike/mgsh/releases/7/assets", 200, `[]`)
|
||||
|
||||
api := newRemoteAPI(f.URL, "tok", "github")
|
||||
err := api.uploadAsset("mike", "mgsh", releaseRef{tag: "v1", id: "7"}, assets[0])
|
||||
if err == nil || !strings.Contains(err.Error(), "upload_url") {
|
||||
t.Errorf("error = %v, want it to name the missing upload_url", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestUploadAssetGitLab: a GitLab release stores links, not files, so the file
|
||||
// goes into the generic package registry first and the release then points at
|
||||
// it.
|
||||
func TestUploadAssetGitLab(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{"bin/tool": "package-bytes"})
|
||||
assets, _ := collectAssets(dir)
|
||||
|
||||
const pkg = "/api/v4/projects/mike%2Fmgsh/packages/generic/mgsh/v1.0/tool"
|
||||
const links = "/api/v4/projects/mike%2Fmgsh/releases/v1.0/assets/links"
|
||||
f := newFakeProvider(t)
|
||||
f.route("GET "+links, 200, `[]`)
|
||||
f.route("PUT "+pkg, 201, `{"message":"201 Created"}`)
|
||||
f.route("POST "+links, 201, `{"id":1}`)
|
||||
|
||||
api := newRemoteAPI(f.URL, "tok", "gitlab")
|
||||
if err := api.uploadAsset("mike", "mgsh", releaseRef{tag: "v1.0", id: "v1.0"}, assets[0]); err != nil {
|
||||
t.Fatalf("uploadAsset: %v (requests %v)", err, f.paths())
|
||||
}
|
||||
|
||||
up := f.find("PUT " + pkg)
|
||||
if up == nil {
|
||||
t.Fatalf("no package upload, requests: %v", f.paths())
|
||||
}
|
||||
if string(up.raw) != "package-bytes" {
|
||||
t.Errorf("package body = %q, want the file verbatim", up.raw)
|
||||
}
|
||||
link := f.find("POST " + links)
|
||||
if link == nil {
|
||||
t.Fatalf("the release was not linked to the package, requests: %v", f.paths())
|
||||
}
|
||||
if link.body["name"] != "tool" || link.body["link_type"] != "package" {
|
||||
t.Errorf("link body = %v", link.body)
|
||||
}
|
||||
if u, _ := link.body["url"].(string); !strings.HasSuffix(u, pkg) {
|
||||
t.Errorf("link url = %q, want it to point at the package", u)
|
||||
}
|
||||
}
|
||||
|
||||
// TestUploadAssetReplacesPrevious: re-releasing after a rebuild has to replace
|
||||
// the old file, not fail on it or leave two of each.
|
||||
func TestUploadAssetReplacesPrevious(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{"bin/tool": "v2"})
|
||||
assets, _ := collectAssets(dir)
|
||||
|
||||
f := newFakeProvider(t)
|
||||
f.route("GET /api/v1/repos/mike/mgsh/releases/7/assets", 200,
|
||||
`[{"id":41,"name":"other"},{"id":42,"name":"tool"}]`)
|
||||
f.route("DELETE /api/v1/repos/mike/mgsh/releases/7/assets/42", 204, ``)
|
||||
f.route("POST /api/v1/repos/mike/mgsh/releases/7/assets", 201, `{"id":43}`)
|
||||
|
||||
api := newRemoteAPI(f.URL, "tok", "gitea")
|
||||
if err := api.uploadAsset("mike", "mgsh", releaseRef{tag: "v1", id: "7"}, assets[0]); err != nil {
|
||||
t.Fatalf("uploadAsset: %v (requests %v)", err, f.paths())
|
||||
}
|
||||
if f.find("DELETE /api/v1/repos/mike/mgsh/releases/7/assets/42") == nil {
|
||||
t.Errorf("the previous asset was not removed: %v", f.paths())
|
||||
}
|
||||
// only the one with the matching name
|
||||
if f.find("DELETE /api/v1/repos/mike/mgsh/releases/7/assets/41") != nil {
|
||||
t.Errorf("an unrelated asset was deleted: %v", f.paths())
|
||||
}
|
||||
if f.find("POST /api/v1/repos/mike/mgsh/releases/7/assets") == nil {
|
||||
t.Errorf("the replacement was not uploaded: %v", f.paths())
|
||||
}
|
||||
}
|
||||
|
||||
// TestUploadAssetsReportsFailures: one bad file must not stop the others, and
|
||||
// the caller has to hear about it.
|
||||
func TestUploadAssetsReportsFailures(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{"bin/good": "ok", "bin/bad": "boom"})
|
||||
assets, _ := collectAssets(dir)
|
||||
|
||||
f := newFakeProvider(t)
|
||||
f.route("GET /api/v1/repos/mike/mgsh/releases/7/assets", 200, `[]`)
|
||||
// the fake answers 404 for anything unrouted, so the POST fails
|
||||
api := newRemoteAPI(f.URL, "tok", "gitea")
|
||||
|
||||
out := captureStdout(t, func() {
|
||||
if err := api.uploadAssets("mike", "mgsh", releaseRef{tag: "v1", id: "7"}, assets); err == nil {
|
||||
t.Error("failed uploads were not reported")
|
||||
}
|
||||
})
|
||||
// both were attempted, and each was announced before it started
|
||||
for _, name := range []string{"good", "bad"} {
|
||||
if !strings.Contains(out, name) {
|
||||
t.Errorf("%s was not attempted or not announced:\n%s", name, out)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAssetSummaryAndDirList(t *testing.T) {
|
||||
dir := assetTree(t, map[string]string{
|
||||
"bin/a": strings.Repeat("x", 1024),
|
||||
"assets/b": strings.Repeat("y", 512),
|
||||
"src/main.go": "not counted",
|
||||
})
|
||||
assets, _ := collectAssets(dir)
|
||||
if got := assetSummary(assets); got != "2 assets, 1.5K" {
|
||||
t.Errorf("assetSummary = %q, want \"2 assets, 1.5K\"", got)
|
||||
}
|
||||
if got := strings.Join(assetDirList(dir), ","); got != "./bin,./assets" {
|
||||
t.Errorf("assetDirList = %q", got)
|
||||
}
|
||||
// singular reads properly, and a project without the directories lists none
|
||||
if got := assetSummary(assets[:1]); !strings.HasPrefix(got, "1 asset,") {
|
||||
t.Errorf("assetSummary(one) = %q", got)
|
||||
}
|
||||
if got := assetDirList(t.TempDir()); len(got) != 0 {
|
||||
t.Errorf("assetDirList of a bare project = %v", got)
|
||||
}
|
||||
}
|
||||
@@ -1,12 +1,22 @@
|
||||
#!/bin/sh
|
||||
# Build mgsh, auto-incrementing the patch version by 0.0.1 on every build.
|
||||
# Build mgsh for the usual platforms into ./bin, auto-incrementing the patch
|
||||
# version by 0.0.1 on every build.
|
||||
#
|
||||
# version.txt holds the currently built version. Each run increments the patch
|
||||
# component, then builds with that version injected via -ldflags, and writes it
|
||||
# back. So version.txt always reflects the version of the binary just built.
|
||||
# component, then builds every platform with that one version injected via
|
||||
# -ldflags, and writes it back. So version.txt always reflects the version of
|
||||
# the binaries just built, and all of them carry the same one.
|
||||
#
|
||||
# Override the platform list to build just one:
|
||||
# PLATFORMS="linux/amd64" ./build.sh
|
||||
#
|
||||
# Windows is deliberately absent: mgsh shells out to stty and /bin/sh, so it
|
||||
# would compile there and then not work.
|
||||
set -e
|
||||
cd "$(dirname "$0")"
|
||||
|
||||
PLATFORMS=${PLATFORMS:-"darwin/arm64 darwin/amd64 linux/amd64 linux/arm64"}
|
||||
|
||||
V=$(cat version.txt 2>/dev/null || echo 4.0.0)
|
||||
|
||||
# split MAJOR.MINOR.PATCH and increment PATCH (no carry: 4.0.9 -> 4.0.10)
|
||||
@@ -17,7 +27,34 @@ PATCH=${REST#*.}
|
||||
PATCH=$((PATCH + 1))
|
||||
NV="$MAJOR.$MINOR.$PATCH"
|
||||
|
||||
go build -ldflags "-X main.VERSION=$NV" -o mgsh .
|
||||
# earlier versions built ./mgsh in the repo root; drop it so nothing keeps
|
||||
# running a stale binary from a path that is no longer written
|
||||
if [ -f mgsh ]; then
|
||||
rm -f mgsh
|
||||
echo "removed stale ./mgsh (the build now writes ./bin)"
|
||||
fi
|
||||
|
||||
mkdir -p bin
|
||||
HOST="$(go env GOOS)/$(go env GOARCH)"
|
||||
|
||||
for p in $PLATFORMS; do
|
||||
os=${p%/*}
|
||||
arch=${p#*/}
|
||||
out="bin/mgsh-$os-$arch"
|
||||
|
||||
# CGO_ENABLED=0 throughout: it makes the cross builds work without a
|
||||
# toolchain per target and the binaries static, and os/user still resolves
|
||||
# the current user without cgo on both darwin and linux.
|
||||
CGO_ENABLED=0 GOOS="$os" GOARCH="$arch" \
|
||||
go build -ldflags "-X main.VERSION=$NV" -o "$out" .
|
||||
|
||||
if [ "$p" = "$HOST" ]; then
|
||||
ln -sf "mgsh-$os-$arch" bin/mgsh # the one for this machine
|
||||
echo " $out -> bin/mgsh"
|
||||
else
|
||||
echo " $out"
|
||||
fi
|
||||
done
|
||||
|
||||
echo "$NV" > version.txt
|
||||
echo "built mgsh v$NV"
|
||||
|
||||
@@ -4,6 +4,7 @@ import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// Colors for the prompt, banner and output, using the Catppuccin Mocha palette
|
||||
@@ -36,10 +37,12 @@ func errorln(msg string) {
|
||||
fmt.Println(col(cRed, msg))
|
||||
}
|
||||
|
||||
// padRight pads an ASCII string with trailing spaces to width n.
|
||||
// padRight pads s with trailing spaces to a width of n columns. It counts
|
||||
// runes, not bytes: the overview pads fields holding ↑ ↓ ✓, each of which is
|
||||
// one column wide but three bytes long.
|
||||
func padRight(s string, n int) string {
|
||||
if len(s) < n {
|
||||
return s + strings.Repeat(" ", n-len(s))
|
||||
if l := utf8.RuneCountInString(s); l < n {
|
||||
return s + strings.Repeat(" ", n-l)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
+72
-47
@@ -24,6 +24,45 @@ var (
|
||||
wsRe = regexp.MustCompile(`\s+`)
|
||||
)
|
||||
|
||||
// listMarker separates the two sections of the combined listing command, so
|
||||
// `list` gets both the long listing and the disk usage in one round trip.
|
||||
const listMarker = "---mgsh---"
|
||||
|
||||
// duRe matches one `du -sk` line: kilobytes, then the path.
|
||||
var duRe = regexp.MustCompile(`^(\d+)\s+(.*)$`)
|
||||
|
||||
// splitAtMarker divides the remote output into the part before and after the
|
||||
// marker line. Everything is in the first section when the marker is absent —
|
||||
// which is what happens when only a plain listing was asked for.
|
||||
func splitAtMarker(lines []string, marker string) (before, after []string) {
|
||||
for i, ln := range lines {
|
||||
if strings.TrimSpace(ln) == marker {
|
||||
return lines[:i], lines[i+1:]
|
||||
}
|
||||
}
|
||||
return lines, nil
|
||||
}
|
||||
|
||||
// parseDuSizes turns `du -sk` output into a name -> bytes map. A long listing
|
||||
// reports the inode size for a directory — the same number for every bare
|
||||
// repository — so this is the only way to say how large one actually is.
|
||||
// A symlinked repository reports the size of the link, not of its target.
|
||||
func parseDuSizes(lines []string) map[string]int64 {
|
||||
out := map[string]int64{}
|
||||
for _, ln := range lines {
|
||||
m := duRe.FindStringSubmatch(strings.TrimRight(ln, "\r"))
|
||||
if m == nil {
|
||||
continue
|
||||
}
|
||||
kb, err := strconv.ParseInt(m[1], 10, 64)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
out[strings.TrimPrefix(strings.TrimSpace(m[2]), "./")] = kb * 1024
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// lsEntry is one parsed entry of the server's listing.
|
||||
type lsEntry struct {
|
||||
name string // with the ".git" / ".git.tar.gz" suffix removed
|
||||
@@ -203,22 +242,42 @@ func runCommandDepth(line string, depth int) bool {
|
||||
one, many = "archive", "archives"
|
||||
}
|
||||
pat := strings.ToLower(word(words, 1))
|
||||
lines, err := sshOut("/bin/ls -ltr " + shq(path))
|
||||
if err != nil {
|
||||
errorln("could not list " + many + " on the git server")
|
||||
break
|
||||
remote := "/bin/ls -ltr " + shq(path)
|
||||
if !opt["a"] {
|
||||
// archives are files and carry a real size; repositories are
|
||||
// directories, whose listed size is the inode's, so ask du in the
|
||||
// same round trip. Nothing shell-specific here on purpose: the
|
||||
// login shell may be csh, where "2>/dev/null" is not a redirection
|
||||
// but an argument followed by one.
|
||||
remote += "; echo " + shq(listMarker) + "; du -sk *.git"
|
||||
}
|
||||
lines, err := sshOut(remote)
|
||||
lsLines, duLines := splitAtMarker(lines, listMarker)
|
||||
sizes := parseDuSizes(duLines)
|
||||
|
||||
var entries []lsEntry
|
||||
for _, ln := range lines {
|
||||
var total int64
|
||||
for _, ln := range lsLines {
|
||||
e, ok := parseLsEntry(ln, suffix)
|
||||
// the pattern filters the name, not the whole listing line — an
|
||||
// accidental match on the date or the owner helps nobody
|
||||
if !ok || (pat != "" && !strings.Contains(strings.ToLower(e.name), pat)) {
|
||||
continue
|
||||
}
|
||||
if !opt["a"] {
|
||||
e.size = sizes[e.name+suffix] // 0 when du said nothing
|
||||
}
|
||||
total += e.size
|
||||
entries = append(entries, e)
|
||||
}
|
||||
// The exit status belongs to the last command in the chain, so a `du`
|
||||
// that fails must not discard a listing that arrived intact. Only
|
||||
// complain when nothing usable came back at all.
|
||||
if len(entries) == 0 {
|
||||
if err != nil {
|
||||
errorln("could not list " + many + " on the git server")
|
||||
break
|
||||
}
|
||||
what := "no " + many + " on the git server"
|
||||
if pat != "" {
|
||||
what = "no " + many + " matching '" + word(words, 1) + "'"
|
||||
@@ -226,12 +285,18 @@ func runCommandDepth(line string, depth int) bool {
|
||||
fmt.Println(col(cGray, what))
|
||||
break
|
||||
}
|
||||
fmt.Print(formatRepoList(entries, opt["a"]))
|
||||
// no size column when the server gave no usable sizes, rather than a
|
||||
// column of zeroes
|
||||
fmt.Print(formatRepoList(entries, total > 0))
|
||||
label := many
|
||||
if len(entries) == 1 {
|
||||
label = one
|
||||
}
|
||||
fmt.Println(col(cGray, fmt.Sprintf("%d %s", len(entries), label)))
|
||||
summary := fmt.Sprintf("%d %s", len(entries), label)
|
||||
if total > 0 {
|
||||
summary += " · " + humanSize(total)
|
||||
}
|
||||
fmt.Println(col(cGray, summary))
|
||||
|
||||
case "show": // show a repository's log directly on the server
|
||||
prj := PRJ
|
||||
@@ -508,45 +573,6 @@ func runCommandDepth(line string, depth int) bool {
|
||||
}
|
||||
}
|
||||
|
||||
case "open", "view": // open project in Xcode / editor
|
||||
prj := PRJ
|
||||
if w := word(words, 1); w != "" {
|
||||
prj = w
|
||||
}
|
||||
d := BASE + "/" + prj
|
||||
if !validProject(prj) || !isDir(d) {
|
||||
errorln("not found")
|
||||
break
|
||||
}
|
||||
xws, xprj := "", ""
|
||||
if entries, err := os.ReadDir(d); err == nil {
|
||||
for _, e := range entries {
|
||||
if strings.HasSuffix(e.Name(), ".xcworkspace") {
|
||||
xws = e.Name()
|
||||
}
|
||||
if strings.HasSuffix(e.Name(), ".xcodeproj") {
|
||||
xprj = e.Name()
|
||||
}
|
||||
}
|
||||
}
|
||||
// prefer the workspace over the project; fall back to the editor unless
|
||||
// one of them is really openable (a name match on a plain file is not).
|
||||
switch {
|
||||
case xws != "" && isDir(d+"/"+xws):
|
||||
runInDir(d, "open", xws)
|
||||
case xprj != "" && isDir(d+"/"+xprj):
|
||||
runInDir(d, "open", xprj)
|
||||
default:
|
||||
editor := cfg.Editor
|
||||
if editor == "" {
|
||||
editor = "coda"
|
||||
}
|
||||
runInDir(d, editor, d)
|
||||
}
|
||||
if words[0] == "open" {
|
||||
PRJ = prj
|
||||
}
|
||||
|
||||
case "count": // count source lines in the project
|
||||
if !requireProject() {
|
||||
break
|
||||
@@ -744,7 +770,6 @@ const gitignore = `.DS_Store
|
||||
|
||||
var helpItems = []struct{ cmd, desc string }{
|
||||
{"cd [project]", "change project (no argument: back to the base)"},
|
||||
{"open [project]", "open project"},
|
||||
{"init", "make new repository from current directory"},
|
||||
{"push [comment]", "push changes to git server"},
|
||||
{"pushremote [@name] [desc]", "mirror repo to the public server(s) (gitea/github/gitlab)"},
|
||||
|
||||
+41
-6
@@ -4,19 +4,54 @@ import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/chzyer/readline"
|
||||
)
|
||||
|
||||
// completer wires up Tab completion. Command names complete at the start of the
|
||||
// line; cd/open/view complete local project names; clone/show complete
|
||||
// completer wires up Tab completion. A line headed for a shell — a '!' escape,
|
||||
// or an alias that expands to one — is completed the way a shell would:
|
||||
// executables for the command, paths for its arguments. Everything else goes to
|
||||
// the builtin command tree.
|
||||
func completer() readline.AutoCompleter {
|
||||
return &mgshCompleter{builtin: builtinCompleter()}
|
||||
}
|
||||
|
||||
// mgshCompleter dispatches between the two completion worlds.
|
||||
type mgshCompleter struct{ builtin *readline.PrefixCompleter }
|
||||
|
||||
func (c *mgshCompleter) Do(line []rune, pos int) ([][]rune, int) {
|
||||
if pos > len(line) {
|
||||
pos = len(line)
|
||||
}
|
||||
if cands, prefix, ok := completeShellLine(string(line[:pos])); ok {
|
||||
return runeSuffixes(cands, prefix)
|
||||
}
|
||||
return c.builtin.Do(line, pos)
|
||||
}
|
||||
|
||||
// runeSuffixes converts full candidate words into what readline wants: the part
|
||||
// still missing after the prefix already typed, plus that prefix's length.
|
||||
func runeSuffixes(cands []string, prefix string) ([][]rune, int) {
|
||||
n := utf8.RuneCountInString(prefix)
|
||||
out := make([][]rune, 0, len(cands))
|
||||
for _, c := range cands {
|
||||
r := []rune(c)
|
||||
if len(r) >= n {
|
||||
out = append(out, r[n:])
|
||||
}
|
||||
}
|
||||
return out, n
|
||||
}
|
||||
|
||||
// builtinCompleter is the command tree. Command names complete at the start of
|
||||
// the line; cd completes local project names; clone/show complete
|
||||
// repository names cached from the git server; checkout/tag complete branch and
|
||||
// tag names; dist completes filesystem paths.
|
||||
func completer() *readline.PrefixCompleter {
|
||||
// tag names; pushremote/release complete mirror targets; dist completes
|
||||
// filesystem paths.
|
||||
func builtinCompleter() *readline.PrefixCompleter {
|
||||
return readline.NewPrefixCompleter(
|
||||
readline.PcItem("cd", readline.PcItemDynamic(dynLocalProjects)),
|
||||
readline.PcItem("open", readline.PcItemDynamic(dynLocalProjects)),
|
||||
readline.PcItem("view", readline.PcItemDynamic(dynLocalProjects)),
|
||||
readline.PcItem("clone",
|
||||
readline.PcItem("-a", readline.PcItemDynamic(dynServerArchives)),
|
||||
readline.PcItemDynamic(dynServerRepos),
|
||||
|
||||
@@ -6,6 +6,7 @@ import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"slices"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
@@ -32,11 +33,6 @@ type Config struct {
|
||||
GitName string // git user.name to set globally ("" = leave alone)
|
||||
GitEmail string // git user.email to set globally ("" = leave alone)
|
||||
PushDefault string // git push.default to set globally ("" = leave alone)
|
||||
Editor string // editor/opener used as fallback by `open` ("" = coda)
|
||||
RemoteURL string // public mirror server base URL (Gitea/GitHub/GitLab)
|
||||
RemoteKey string // API token for the mirror server (used by `pushremote`)
|
||||
RemoteType string // "gitea"|"github"|"gitlab" (auto-detected when empty)
|
||||
RemoteVis string // visibility of created repos: "private" (default)|"public"
|
||||
Mirror string // truthy -> `push` also mirrors via `pushremote`
|
||||
SecretScan string // falsy -> `push` skips the credential scan
|
||||
Remotes []RemoteTarget
|
||||
@@ -54,22 +50,25 @@ type RemoteTarget struct {
|
||||
Vis string // "private" (default) | "public"
|
||||
}
|
||||
|
||||
// legacyRemoteName is the target name for the flat remoteurl/remotekey pair,
|
||||
// matching the git remote that earlier versions created.
|
||||
// legacyRemoteName is the target the pre-4.1 flat remoteurl/remotekey settings
|
||||
// are migrated to. It matches the git remote those versions created, so a
|
||||
// converted configuration keeps pushing to the same place.
|
||||
const legacyRemoteName = "public"
|
||||
|
||||
// legacyRemoteKeys maps the old flat spelling onto the named-target form. A
|
||||
// mirror target is defined one way now, not two.
|
||||
var legacyRemoteKeys = map[string]string{
|
||||
"remoteurl": "remote." + legacyRemoteName + ".url",
|
||||
"remotekey": "remote." + legacyRemoteName + ".key",
|
||||
"remotetype": "remote." + legacyRemoteName + ".type",
|
||||
"remotevisibility": "remote." + legacyRemoteName + ".visibility",
|
||||
}
|
||||
|
||||
// mirrorTargets returns the usable mirror targets in configured order, plus the
|
||||
// names of targets that are defined but unusable (missing url or key) so the
|
||||
// caller can complain about them instead of silently skipping.
|
||||
func (c Config) mirrorTargets() (usable []RemoteTarget, incomplete []string) {
|
||||
var all []RemoteTarget
|
||||
if c.RemoteURL != "" || c.RemoteKey != "" {
|
||||
all = append(all, RemoteTarget{
|
||||
Name: legacyRemoteName, URL: c.RemoteURL, Key: c.RemoteKey,
|
||||
Type: c.RemoteType, Vis: c.RemoteVis,
|
||||
})
|
||||
}
|
||||
all = append(all, c.Remotes...)
|
||||
all := c.Remotes
|
||||
|
||||
// `remotes = a, b` narrows and orders the set — a project .mgshrc uses it
|
||||
// to mirror to only some of the globally configured servers.
|
||||
@@ -147,11 +146,54 @@ func loadConfig() Config {
|
||||
m := parseConfig(string(data))
|
||||
applyConfig(&c, m)
|
||||
warnConfigPerms(path, m)
|
||||
migrateRemoteKeys(path, string(data))
|
||||
}
|
||||
applyEnv(&c)
|
||||
return c
|
||||
}
|
||||
|
||||
// migrateRemoteKeys converts the pre-4.1 flat remote settings in a config file
|
||||
// to the remote.<name>.<field> spelling, so a mirror target is defined one way
|
||||
// and not two. Only the key is rewritten: values, comments, blank lines and the
|
||||
// file's permissions stay exactly as they are, and commented-out lines are left
|
||||
// alone. Reports what it changed rather than doing it silently.
|
||||
func migrateRemoteKeys(path, data string) {
|
||||
lines := strings.Split(data, "\n")
|
||||
var renamed []string
|
||||
|
||||
for i, ln := range lines {
|
||||
trimmed := strings.TrimLeft(ln, " \t")
|
||||
if trimmed == "" || strings.HasPrefix(trimmed, "#") {
|
||||
continue
|
||||
}
|
||||
sep := strings.IndexAny(trimmed, "=:")
|
||||
if sep < 0 {
|
||||
continue
|
||||
}
|
||||
key := strings.TrimRight(trimmed[:sep], " \t")
|
||||
dotted, ok := legacyRemoteKeys[strings.ToLower(key)]
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
indent := ln[:len(ln)-len(trimmed)]
|
||||
gap := trimmed[len(key):sep] // whatever alignment was there
|
||||
lines[i] = indent + dotted + gap + trimmed[sep:]
|
||||
renamed = append(renamed, key+" → "+dotted)
|
||||
}
|
||||
if len(renamed) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")), configMode); err != nil {
|
||||
errorln("could not update " + path + ": " + err.Error())
|
||||
return
|
||||
}
|
||||
fmt.Println(col(cGray, path+": mirror settings renamed to the remote.<name>.* form"))
|
||||
for _, r := range renamed {
|
||||
fmt.Println(col(cGray, " "+r))
|
||||
}
|
||||
}
|
||||
|
||||
// projectGlobalOnly lists settings a project-level .mgshrc must not change:
|
||||
// `base` decides where projects live in the first place, and the git identity
|
||||
// keys are written to the user's *global* git config at startup — applying
|
||||
@@ -277,14 +319,16 @@ func writeConfigTemplate(path string) {
|
||||
b.WriteString("# gitname = Your Name\n")
|
||||
b.WriteString("# gitemail = you@example.com\n")
|
||||
b.WriteString("# pushdefault = matching\n")
|
||||
b.WriteString("# editor = code\n\n")
|
||||
b.WriteString("\n")
|
||||
b.WriteString("# --- public mirrors for `pushremote` ---\n")
|
||||
b.WriteString("# One block per server; `pushremote` pushes to all of them,\n")
|
||||
b.WriteString("# `pushremote @hub` to a single one.\n")
|
||||
b.WriteString("# remote.hub.url = https://github.com\n")
|
||||
b.WriteString("# remote.hub.key = <personal-access-token>\n")
|
||||
b.WriteString("# remote.hub.visibility = public\n")
|
||||
b.WriteString("# remotes = hub # optional: restrict/order the set\n")
|
||||
b.WriteString("# One 'remote.<name>.*' block per server. `pushremote` pushes to all\n")
|
||||
b.WriteString("# of them, `pushremote @gitlab` to a single one. <name> is also the\n")
|
||||
b.WriteString("# git remote created in the repository.\n")
|
||||
b.WriteString("# remote.gitlab.url = https://gitlab.example.com\n")
|
||||
b.WriteString("# remote.gitlab.key = <personal-access-token>\n")
|
||||
b.WriteString("# remote.gitlab.type = gitlab # optional; detected from the url\n")
|
||||
b.WriteString("# remote.gitlab.visibility = private # or public (default private)\n")
|
||||
b.WriteString("# remotes = gitlab # optional: restrict/order the set\n")
|
||||
b.WriteString("# mirror = true # `push` also mirrors\n\n")
|
||||
b.WriteString("# A project may override any of these (except base and the git\n")
|
||||
b.WriteString("# identity) in its own <project>/.mgshrc.\n")
|
||||
@@ -364,15 +408,36 @@ func applyConfig(c *Config, m map[string]string) {
|
||||
set("gitname", &c.GitName)
|
||||
set("gitemail", &c.GitEmail)
|
||||
set("pushdefault", &c.PushDefault)
|
||||
set("editor", &c.Editor)
|
||||
set("remoteurl", &c.RemoteURL)
|
||||
set("remotekey", &c.RemoteKey)
|
||||
set("remotetype", &c.RemoteType)
|
||||
set("remotevisibility", &c.RemoteVis)
|
||||
set("remotes", &c.RemoteNames)
|
||||
set("mirror", &c.Mirror)
|
||||
set("secretscan", &c.SecretScan)
|
||||
applyRemoteTargets(c, m)
|
||||
applyRemoteTargets(c, foldLegacyRemoteKeys(m))
|
||||
}
|
||||
|
||||
// foldLegacyRemoteKeys rewrites the pre-4.1 flat remote settings into the
|
||||
// named-target form, so a configuration that has not been converted yet still
|
||||
// works while it is being read. The file itself is converted by
|
||||
// migrateRemoteKeys; this only makes the current run behave.
|
||||
func foldLegacyRemoteKeys(m map[string]string) map[string]string {
|
||||
folded, copied := m, false
|
||||
for old, dotted := range legacyRemoteKeys {
|
||||
v, ok := m[old]
|
||||
if !ok || v == "" {
|
||||
continue
|
||||
}
|
||||
if _, taken := m[dotted]; taken {
|
||||
continue // an explicit new-style setting always wins
|
||||
}
|
||||
if !copied { // copy on first write, never touch the caller's map
|
||||
folded = make(map[string]string, len(m))
|
||||
for k, val := range m {
|
||||
folded[k] = val
|
||||
}
|
||||
copied = true
|
||||
}
|
||||
folded[dotted] = v
|
||||
}
|
||||
return folded
|
||||
}
|
||||
|
||||
// remoteFieldRe matches a named mirror target setting: remote.<name>.<field>.
|
||||
@@ -438,12 +503,55 @@ func applyEnv(c *Config) {
|
||||
env("MGSH_GITNAME", &c.GitName)
|
||||
env("MGSH_GITEMAIL", &c.GitEmail)
|
||||
env("MGSH_PUSHDEFAULT", &c.PushDefault)
|
||||
env("MGSH_EDITOR", &c.Editor)
|
||||
env("MGSH_REMOTEURL", &c.RemoteURL)
|
||||
env("MGSH_REMOTEKEY", &c.RemoteKey)
|
||||
env("MGSH_REMOTETYPE", &c.RemoteType)
|
||||
env("MGSH_REMOTEVISIBILITY", &c.RemoteVis)
|
||||
env("MGSH_REMOTES", &c.RemoteNames)
|
||||
env("MGSH_MIRROR", &c.Mirror)
|
||||
env("MGSH_SECRETSCAN", &c.SecretScan)
|
||||
applyRemoteEnv(c)
|
||||
}
|
||||
|
||||
// remoteFields are the settings a mirror target is made of.
|
||||
var remoteFields = []string{"url", "key", "type", "visibility"}
|
||||
|
||||
// applyRemoteEnv reads MGSH_REMOTE_<NAME>_<FIELD>, the environment spelling of
|
||||
// a remote.<name>.<field> setting — MGSH_REMOTE_GITLAB_KEY for
|
||||
// remote.gitlab.key. The field is taken from the end, so a target name may
|
||||
// contain underscores itself.
|
||||
func applyRemoteEnv(c *Config) {
|
||||
const prefix = "MGSH_REMOTE_"
|
||||
|
||||
// sorted, so a target these variables introduce lands in the push order the
|
||||
// same way on every run
|
||||
envs := os.Environ()
|
||||
sort.Strings(envs)
|
||||
|
||||
for _, kv := range envs {
|
||||
eq := strings.IndexByte(kv, '=')
|
||||
if eq < 0 {
|
||||
continue
|
||||
}
|
||||
name, value := kv[:eq], kv[eq+1:]
|
||||
if value == "" || !strings.HasPrefix(name, prefix) {
|
||||
continue
|
||||
}
|
||||
rest := name[len(prefix):]
|
||||
us := strings.LastIndexByte(rest, '_')
|
||||
if us <= 0 {
|
||||
continue
|
||||
}
|
||||
target, field := strings.ToLower(rest[:us]), strings.ToLower(rest[us+1:])
|
||||
if !slices.Contains(remoteFields, field) {
|
||||
continue // MGSH_REMOTES and anything else that merely starts alike
|
||||
}
|
||||
t := &c.Remotes[c.remoteIndex(target)]
|
||||
switch field {
|
||||
case "url":
|
||||
t.URL = value
|
||||
case "key":
|
||||
t.Key = value
|
||||
case "type":
|
||||
t.Type = value
|
||||
case "visibility":
|
||||
t.Vis = value
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,11 @@
|
||||
package main
|
||||
|
||||
// input.go — the y/n prompts that guard the destructive commands.
|
||||
//
|
||||
// These questions are the only thing standing between `init` and a wiped
|
||||
// server repository, so the terminal handling here has to be exactly right: a
|
||||
// question that cannot be answered is worse than no question at all.
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
@@ -13,50 +19,86 @@ import (
|
||||
// variable because it guards the destructive operations: tests replace it to
|
||||
// drive those paths without a terminal, and to assert that the question was
|
||||
// asked at all.
|
||||
//
|
||||
// When the keypress cannot be read at all the answer is no, whatever the
|
||||
// default says — a question nobody saw must never be taken as consent.
|
||||
var yesno = func(prompt string, def bool) bool {
|
||||
suffix := " y/N ? "
|
||||
if def {
|
||||
suffix = " Y/n ? "
|
||||
}
|
||||
ans := strings.ToLower(strings.TrimSpace(getkey(prompt + suffix)))
|
||||
key, ok := getkey(prompt + suffix)
|
||||
if !ok {
|
||||
errorln("could not read an answer from the terminal — assuming no")
|
||||
return false
|
||||
}
|
||||
ans := strings.ToLower(strings.TrimSpace(key))
|
||||
if ans == "" {
|
||||
return def
|
||||
}
|
||||
return ans == "y"
|
||||
}
|
||||
|
||||
// getkey reads a single keypress from the terminal without echo. It reads a
|
||||
// single byte directly from stdin; readline is not reading at this point (we
|
||||
// are inside command execution), so there is no reader to desync with.
|
||||
// keyModeArgs put the terminal into single-key input: one keypress is delivered
|
||||
// as it is typed, and it is not echoed.
|
||||
//
|
||||
// MIN and TIME are set explicitly, and that is not decoration. They are not
|
||||
// part of the canonical/non-canonical switch — they live in their own slots of
|
||||
// the control-character array and survive `stty icanon`. drainTTY leaves them
|
||||
// at "min 0 time 0" ("return what is buffered, do not wait"), so without this
|
||||
// the *second* question of a session read zero bytes, answered itself with its
|
||||
// default, and left the keypress queued for the next prompt line.
|
||||
var keyModeArgs = []string{"-icanon", "-echo", "min", "1", "time", "0"}
|
||||
|
||||
// getkey reads a single keypress from the terminal without echo, and reports
|
||||
// whether it got one. It reads a single byte directly from stdin; readline only
|
||||
// reads while it is inside Readline(), and we are inside command execution
|
||||
// here, so there is no reader to desync with.
|
||||
//
|
||||
// Anything else already typed on the same line is discarded: answering "yes"
|
||||
// to a y/n prompt must not leave "es\n" queued for the next readline call,
|
||||
// where it would come back as a bogus command.
|
||||
func getkey(prompt string) string {
|
||||
func getkey(prompt string) (string, bool) {
|
||||
fmt.Print(prompt)
|
||||
tty := readline.IsTerminal(int(os.Stdin.Fd()))
|
||||
if tty {
|
||||
stty("-icanon", "-echo")
|
||||
|
||||
restore := func() {}
|
||||
if stdinIsTTY() {
|
||||
restore = singleKeyMode()
|
||||
}
|
||||
var buf [1]byte
|
||||
n, err := os.Stdin.Read(buf[:])
|
||||
if tty {
|
||||
drainTTY()
|
||||
stty("icanon", "echo")
|
||||
}
|
||||
key := ""
|
||||
if err == nil && n > 0 {
|
||||
key = strings.Trim(string(buf[:n]), "\r\n\t")
|
||||
restore()
|
||||
|
||||
if err != nil || n == 0 {
|
||||
fmt.Println()
|
||||
return "", false
|
||||
}
|
||||
key := strings.Trim(string(buf[:n]), "\r\n\t")
|
||||
fmt.Println(key)
|
||||
return key
|
||||
return key, true
|
||||
}
|
||||
|
||||
// singleKeyMode switches the terminal to single-key input and returns the
|
||||
// function that puts it back. The previous settings are restored verbatim from
|
||||
// `stty -g` rather than by naming the flags we changed: naming them is how the
|
||||
// MIN/TIME above were left behind in the first place, and mgsh should hand the
|
||||
// terminal back exactly as it found it.
|
||||
func singleKeyMode() func() {
|
||||
saved, err := sttyRun("-g")
|
||||
saved = strings.TrimSpace(saved)
|
||||
sttyRun(keyModeArgs...)
|
||||
|
||||
if err != nil || saved == "" {
|
||||
return func() { drainTTY(); sttyRun("icanon", "echo") } // best effort
|
||||
}
|
||||
return func() { drainTTY(); sttyRun(strings.Fields(saved)...) }
|
||||
}
|
||||
|
||||
// drainTTY discards input already queued on the terminal. `min 0 time 0` makes
|
||||
// a read return whatever is buffered without waiting, so this cannot block when
|
||||
// nothing is pending.
|
||||
// nothing is pending. Its caller restores the terminal afterwards.
|
||||
func drainTTY() {
|
||||
stty("-icanon", "-echo", "min", "0", "time", "0")
|
||||
sttyRun("-icanon", "-echo", "min", "0", "time", "0")
|
||||
buf := make([]byte, 256)
|
||||
for {
|
||||
n, err := os.Stdin.Read(buf)
|
||||
@@ -66,10 +108,16 @@ func drainTTY() {
|
||||
}
|
||||
}
|
||||
|
||||
func stty(args ...string) {
|
||||
// stdinIsTTY reports whether keypresses come from a terminal. A variable so the
|
||||
// tests can exercise the terminal path without one.
|
||||
var stdinIsTTY = func() bool { return readline.IsTerminal(int(os.Stdin.Fd())) }
|
||||
|
||||
// sttyRun runs stty on the terminal and returns its output. Errors are silent:
|
||||
// every caller has a fallback, and a stray "stty: ..." line in the middle of a
|
||||
// half-printed question helps nobody.
|
||||
var sttyRun = func(args ...string) (string, error) {
|
||||
c := exec.Command("stty", args...)
|
||||
c.Stdin = os.Stdin
|
||||
c.Stdout = os.Stdout
|
||||
c.Stderr = os.Stderr
|
||||
c.Run()
|
||||
out, err := c.Output()
|
||||
return string(out), err
|
||||
}
|
||||
|
||||
+226
@@ -0,0 +1,226 @@
|
||||
package main
|
||||
|
||||
// input_test.go — the y/n prompt is the last thing between `init` and a wiped
|
||||
// server repository, so the terminal handling around it is pinned here.
|
||||
|
||||
import (
|
||||
"os"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// fakeTTY stands in for the terminal driver. It models the one detail that made
|
||||
// the skipped-question bug possible: MIN and TIME are not part of the
|
||||
// canonical/non-canonical switch, so they survive `stty icanon` and carry over
|
||||
// into the next prompt.
|
||||
type fakeTTY struct {
|
||||
mu sync.Mutex
|
||||
state map[string]string
|
||||
calls [][]string
|
||||
ready chan struct{} // signalled once single-key mode is in effect
|
||||
}
|
||||
|
||||
func newFakeTTY() *fakeTTY {
|
||||
return &fakeTTY{
|
||||
state: map[string]string{"icanon": "on", "echo": "on", "min": "1", "time": "0"},
|
||||
ready: make(chan struct{}, 4),
|
||||
}
|
||||
}
|
||||
|
||||
func (f *fakeTTY) run(args ...string) (string, error) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
f.calls = append(f.calls, args)
|
||||
|
||||
switch {
|
||||
case len(args) == 1 && args[0] == "-g":
|
||||
return f.serializeLocked(), nil
|
||||
case len(args) == 1 && strings.HasPrefix(args[0], "saved:"):
|
||||
for _, kv := range strings.Split(strings.TrimPrefix(args[0], "saved:"), ",") {
|
||||
if k, v, ok := strings.Cut(kv, "="); ok {
|
||||
f.state[k] = v
|
||||
}
|
||||
}
|
||||
return "", nil
|
||||
}
|
||||
for i := 0; i < len(args); i++ {
|
||||
switch a := args[i]; a {
|
||||
case "min", "time":
|
||||
if i+1 < len(args) {
|
||||
f.state[a] = args[i+1]
|
||||
i++
|
||||
}
|
||||
default:
|
||||
f.state[strings.TrimPrefix(a, "-")] = boolWord(!strings.HasPrefix(a, "-"))
|
||||
}
|
||||
}
|
||||
if strings.Join(args, " ") == strings.Join(keyModeArgs, " ") {
|
||||
f.ready <- struct{}{} // single-key mode is set; the read comes next
|
||||
}
|
||||
return "", nil
|
||||
}
|
||||
|
||||
func boolWord(on bool) string {
|
||||
if on {
|
||||
return "on"
|
||||
}
|
||||
return "off"
|
||||
}
|
||||
|
||||
// serializeLocked renders the settings as one token, the way `stty -g` does.
|
||||
func (f *fakeTTY) serializeLocked() string {
|
||||
return "saved:icanon=" + f.state["icanon"] + ",echo=" + f.state["echo"] +
|
||||
",min=" + f.state["min"] + ",time=" + f.state["time"]
|
||||
}
|
||||
|
||||
func (f *fakeTTY) get(k string) string {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
return f.state[k]
|
||||
}
|
||||
|
||||
func (f *fakeTTY) snapshot() string {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
return f.serializeLocked()
|
||||
}
|
||||
|
||||
// installFakeTTY points getkey at the fake terminal for the duration of a test.
|
||||
func installFakeTTY(t *testing.T) *fakeTTY {
|
||||
t.Helper()
|
||||
f := newFakeTTY()
|
||||
oldRun, oldIsTTY, oldStdin := sttyRun, stdinIsTTY, os.Stdin
|
||||
sttyRun = f.run
|
||||
stdinIsTTY = func() bool { return true }
|
||||
t.Cleanup(func() {
|
||||
sttyRun, stdinIsTTY, os.Stdin = oldRun, oldIsTTY, oldStdin
|
||||
})
|
||||
return f
|
||||
}
|
||||
|
||||
// askOnce runs one getkey against the fake terminal, answering with keys once
|
||||
// the terminal is actually in single-key mode. It reports the MIN in effect at
|
||||
// the moment of the read — the value the old code got wrong.
|
||||
func askOnce(t *testing.T, f *fakeTTY, keys string) (key string, ok bool, minAtRead string) {
|
||||
t.Helper()
|
||||
r, w, err := os.Pipe()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
os.Stdin = r
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
key, ok = getkey("question? ")
|
||||
close(done)
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-f.ready:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("the terminal was never put into single-key mode")
|
||||
}
|
||||
minAtRead = f.get("min")
|
||||
w.WriteString(keys)
|
||||
w.Close() // so the drain that follows the keypress sees EOF instead of blocking
|
||||
<-done
|
||||
r.Close()
|
||||
return key, ok, minAtRead
|
||||
}
|
||||
|
||||
// TestEveryQuestionWaitsForAnAnswer is the regression test for the bug where the
|
||||
// second y/n question of a session was skipped: drainTTY left the terminal at
|
||||
// "min 0" ("return what is buffered, do not wait"), the restore only named
|
||||
// icanon and echo, and so the next read returned zero bytes and answered the
|
||||
// question with its default.
|
||||
func TestEveryQuestionWaitsForAnAnswer(t *testing.T) {
|
||||
f := installFakeTTY(t)
|
||||
|
||||
for i, want := range []string{"y", "n", "y"} {
|
||||
key, ok, minAtRead := askOnce(t, f, want)
|
||||
if !ok || key != want {
|
||||
t.Fatalf("question %d: got (%q, %v), want (%q, true)", i+1, key, ok, want)
|
||||
}
|
||||
if minAtRead != "1" {
|
||||
t.Errorf("question %d read the terminal at min=%s, want min=1 — "+
|
||||
"min 0 returns without waiting and answers the question by itself",
|
||||
i+1, minAtRead)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestPromptHandsTheTerminalBackUnchanged: mgsh must not leave the terminal in
|
||||
// a mode it chose. The old restore named only icanon and echo and left "min 0"
|
||||
// behind, which outlived mgsh itself and broke the next program's single-key
|
||||
// reads too.
|
||||
func TestPromptHandsTheTerminalBackUnchanged(t *testing.T) {
|
||||
f := installFakeTTY(t)
|
||||
initial := f.snapshot()
|
||||
|
||||
if _, ok, _ := askOnce(t, f, "y"); !ok {
|
||||
t.Fatal("getkey did not read the key")
|
||||
}
|
||||
if got := f.snapshot(); got != initial {
|
||||
t.Errorf("terminal left as %s, want it back at %s", got, initial)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPromptRestoresFromTheSavedState pins *how* the terminal is restored: from
|
||||
// the state captured with `stty -g`, not by naming the flags we changed.
|
||||
func TestPromptRestoresFromTheSavedState(t *testing.T) {
|
||||
f := installFakeTTY(t)
|
||||
if _, ok, _ := askOnce(t, f, "y"); !ok {
|
||||
t.Fatal("getkey did not read the key")
|
||||
}
|
||||
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
if len(f.calls) == 0 {
|
||||
t.Fatal("stty was never called")
|
||||
}
|
||||
if first := f.calls[0]; len(first) != 1 || first[0] != "-g" {
|
||||
t.Errorf("first stty call was %v, want [-g]: the state has to be captured "+
|
||||
"before it is changed", first)
|
||||
}
|
||||
last := f.calls[len(f.calls)-1]
|
||||
if len(last) != 1 || !strings.HasPrefix(last[0], "saved:") {
|
||||
t.Errorf("last stty call was %v, want the saved state played back", last)
|
||||
}
|
||||
}
|
||||
|
||||
// TestSingleKeyModeSetsMinExplicitly: MIN and TIME are inherited, so they have
|
||||
// to be named on the way in. Without that, a terminal left at "min 0" by an
|
||||
// earlier program (or an earlier mgsh) skips the question.
|
||||
func TestSingleKeyModeSetsMinExplicitly(t *testing.T) {
|
||||
args := strings.Join(keyModeArgs, " ")
|
||||
for _, want := range []string{"-icanon", "-echo", "min 1", "time 0"} {
|
||||
if !strings.Contains(args, want) {
|
||||
t.Errorf("single-key mode is %q, missing %q", args, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestQuestionSkippedByAPoisonedTerminalIsNotAYes: even if the terminal is
|
||||
// already in the broken state when mgsh starts, the answer must not be the
|
||||
// default — nobody saw the question, so nobody agreed to anything.
|
||||
func TestQuestionSkippedByAPoisonedTerminalIsNotAYes(t *testing.T) {
|
||||
oldRun, oldIsTTY, oldStdin := sttyRun, stdinIsTTY, os.Stdin
|
||||
defer func() { sttyRun, stdinIsTTY, os.Stdin = oldRun, oldIsTTY, oldStdin }()
|
||||
|
||||
sttyRun = func(args ...string) (string, error) { return "", nil }
|
||||
stdinIsTTY = func() bool { return true }
|
||||
|
||||
r, w, _ := os.Pipe()
|
||||
w.Close() // a terminal that returns nothing at all
|
||||
os.Stdin = r
|
||||
defer r.Close()
|
||||
|
||||
if key, ok := getkey("question? "); ok {
|
||||
t.Fatalf("getkey reported a key %q from a terminal that gave none", key)
|
||||
}
|
||||
if yesno("destroy everything?", true) {
|
||||
t.Error("an unanswerable question was taken as yes")
|
||||
}
|
||||
}
|
||||
@@ -145,7 +145,7 @@ func parseArgs() (int, string, bool) {
|
||||
}
|
||||
cls := map[string]int{
|
||||
"clone": 2, "init": 2, "log": 2,
|
||||
"push": 1, "pushremote": 1, "list": 1, "tag": 1, "archive": 1, "show": 1, "open": 1,
|
||||
"push": 1, "pushremote": 1, "list": 1, "tag": 1, "archive": 1, "show": 1,
|
||||
"pull": 1, "fetch": 1, "status": 1, "diff": 1, "overview": 1,
|
||||
"config": 1, "count": 1, "login": 1, "cloneall": 1, "release": 1,
|
||||
}
|
||||
|
||||
+215
-11
@@ -9,6 +9,7 @@ import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
func TestSanitizeComment(t *testing.T) {
|
||||
@@ -141,7 +142,7 @@ func TestParseConfig(t *testing.T) {
|
||||
githost = 10.0.0.1
|
||||
GitPort: 22
|
||||
gituser = "deploy"
|
||||
editor = 'code'
|
||||
gitkey = 'mgit_rsa'
|
||||
ignored line without separator
|
||||
base=/tmp/src
|
||||
`
|
||||
@@ -150,7 +151,7 @@ base=/tmp/src
|
||||
"githost": "10.0.0.1",
|
||||
"gitport": "22",
|
||||
"gituser": "deploy",
|
||||
"editor": "code",
|
||||
"gitkey": "mgit_rsa",
|
||||
"base": "/tmp/src",
|
||||
}
|
||||
for k, want := range checks {
|
||||
@@ -165,7 +166,7 @@ base=/tmp/src
|
||||
|
||||
func TestParseConfigInlineComments(t *testing.T) {
|
||||
rc := `
|
||||
editor = code # fallback opener for ` + "`open`" + `
|
||||
gitkey = mgit_rsa # fallback opener comment
|
||||
mirror = true # ` + "`push`" + ` also mirrors via pushremote
|
||||
gitport = 22 # ssh port
|
||||
remotekey = abc#123
|
||||
@@ -175,7 +176,7 @@ gitemail = # value is only a comment
|
||||
`
|
||||
m := parseConfig(rc)
|
||||
checks := map[string]string{
|
||||
"editor": "code",
|
||||
"gitkey": "mgit_rsa",
|
||||
"mirror": "true",
|
||||
"gitport": "22",
|
||||
"remotekey": "abc#123", // '#' not preceded by space stays part of the value
|
||||
@@ -467,7 +468,7 @@ remote.broken.url = https://nowhere.example # no key -> unusable
|
||||
}
|
||||
|
||||
func TestMirrorTargetsLegacyAndSelection(t *testing.T) {
|
||||
// the flat remoteurl/remotekey pair stays supported, as target "public"
|
||||
// the pre-4.1 flat pair still loads, folded onto the target "public"
|
||||
var c Config
|
||||
applyConfig(&c, parseConfig("remoteurl = https://git.example.com\nremotekey = tok\n"))
|
||||
usable, _ := c.mirrorTargets()
|
||||
@@ -538,7 +539,7 @@ func TestResolveProjectConfig(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
global := Config{
|
||||
Base: "/base", GitHost: "global.example", GitPort: "22", GitUser: "git",
|
||||
GitPath: "/home/git", GitName: "Global Name", Editor: "vi",
|
||||
GitPath: "/home/git", GitName: "Global Name", GitKey: "global_rsa",
|
||||
Remotes: []RemoteTarget{{Name: "gitea", URL: "https://gitea.example", Key: "tok"}},
|
||||
}
|
||||
|
||||
@@ -549,7 +550,7 @@ func TestResolveProjectConfig(t *testing.T) {
|
||||
|
||||
rc := `
|
||||
githost = project.example
|
||||
editor = code
|
||||
gitkey = project_rsa
|
||||
base = /somewhere/else
|
||||
gitname = Project Name
|
||||
remote.hub.url = https://github.com
|
||||
@@ -561,8 +562,8 @@ remote.gitea.visibility = public
|
||||
}
|
||||
got := resolveConfig(global, dir)
|
||||
|
||||
if got.GitHost != "project.example" || got.Editor != "code" {
|
||||
t.Errorf("project overrides not applied: host=%q editor=%q", got.GitHost, got.Editor)
|
||||
if got.GitHost != "project.example" || got.GitKey != "project_rsa" {
|
||||
t.Errorf("project overrides not applied: host=%q gitkey=%q", got.GitHost, got.GitKey)
|
||||
}
|
||||
// base and the git identity stay global
|
||||
if got.Base != "/base" {
|
||||
@@ -806,6 +807,7 @@ func TestTruthy(t *testing.T) {
|
||||
func TestFormatProjStatus(t *testing.T) {
|
||||
useColor = false
|
||||
defer func() { useColor = false }()
|
||||
w := overviewWidths{label: 12, sync: 5, host: 7}
|
||||
cases := []struct {
|
||||
s projStatus
|
||||
contains []string
|
||||
@@ -820,10 +822,16 @@ func TestFormatProjStatus(t *testing.T) {
|
||||
{projStatus{name: "d", branch: "feature", dirty: true},
|
||||
[]string{"d", "*", "(feature)"}, nil},
|
||||
{projStatus{name: "e", branch: "master"}, // clean, no upstream
|
||||
[]string{"e", "no upstream"}, []string{"*"}},
|
||||
[]string{"e", "–"}, []string{"*", "✓"}},
|
||||
{projStatus{name: "f", branch: "master", hasUpstream: true, ahead: 1, behind: 2},
|
||||
[]string{"f", "↑1↓2"}, []string{"✓"}}, // diverged shows both
|
||||
{projStatus{name: "g", branch: "master", hasUpstream: true, lastHost: "laptop",
|
||||
mirrors: []string{"hub", "gitea"}},
|
||||
[]string{"g", "laptop", "→ hub gitea"}, nil},
|
||||
}
|
||||
for _, c := range cases {
|
||||
got := formatProjStatus(c.s, 8)
|
||||
c.s.isRepo = true // these all describe real repositories
|
||||
got := formatProjStatus(c.s, w)
|
||||
for _, sub := range c.contains {
|
||||
if !strings.Contains(got, sub) {
|
||||
t.Errorf("formatProjStatus(%+v) = %q, missing %q", c.s, got, sub)
|
||||
@@ -837,6 +845,62 @@ func TestFormatProjStatus(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// TestOverviewColumnsAlign is the point of the table: every field has to start
|
||||
// at the same column on every row, whatever the name lengths or the multi-byte
|
||||
// status glyphs do.
|
||||
func TestOverviewColumnsAlign(t *testing.T) {
|
||||
useColor = false
|
||||
// host names must not occur anywhere else in a row, or the index search
|
||||
// below would find them inside a project or branch name instead
|
||||
rows := []projStatus{
|
||||
{name: "a", branch: "master", hasUpstream: true, ahead: 12, behind: 3, lastHost: "workstation"},
|
||||
{name: "a-very-long-project-name", branch: "wip", dirty: true, lastHost: "buildbox"},
|
||||
{name: "mid", branch: "main", hasUpstream: true, lastHost: "laptop"},
|
||||
}
|
||||
w := measureOverview(rows)
|
||||
|
||||
var widths []int
|
||||
for _, r := range rows {
|
||||
line := formatProjStatus(r, w)
|
||||
// the host column starts right after the padded sync field
|
||||
idx := strings.Index(line, r.lastHost)
|
||||
if idx < 0 {
|
||||
t.Fatalf("host %q missing from %q", r.lastHost, line)
|
||||
}
|
||||
widths = append(widths, utf8.RuneCountInString(line[:idx]))
|
||||
}
|
||||
for i := 1; i < len(widths); i++ {
|
||||
if widths[i] != widths[0] {
|
||||
t.Errorf("host column starts at %d on row %d, %d on row 0:\n%s",
|
||||
widths[i], i, widths[0], strings.Join([]string{
|
||||
formatProjStatus(rows[0], w), formatProjStatus(rows[i], w)}, "\n"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAttentionRank(t *testing.T) {
|
||||
ranks := []struct {
|
||||
s projStatus
|
||||
want int
|
||||
}{
|
||||
{projStatus{isRepo: true, dirty: true}, 0},
|
||||
{projStatus{isRepo: true, ahead: 1}, 0},
|
||||
{projStatus{isRepo: true, behind: 1}, 0},
|
||||
{projStatus{isRepo: true, hasUpstream: true}, 1},
|
||||
{projStatus{isRepo: true}, 1}, // clean, no upstream
|
||||
// not on the server is a different kind of task and goes last, even
|
||||
// when the working tree is dirty — it cannot be pushed anyway
|
||||
{projStatus{isRepo: true, notOnServer: true}, 2},
|
||||
{projStatus{isRepo: true, dirty: true, notOnServer: true}, 2},
|
||||
{projStatus{notOnServer: true}, 2},
|
||||
}
|
||||
for _, c := range ranks {
|
||||
if got := attentionRank(c.s); got != c.want {
|
||||
t.Errorf("attentionRank(%+v) = %d, want %d", c.s, got, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestDetectRemoteKind(t *testing.T) {
|
||||
cases := []struct {
|
||||
url, override string
|
||||
@@ -943,3 +1007,143 @@ func TestExpandAlias(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSplitAtMarker(t *testing.T) {
|
||||
lines := []string{"a", "b", "---mgsh---", "c", "d"}
|
||||
before, after := splitAtMarker(lines, "---mgsh---")
|
||||
if strings.Join(before, ",") != "a,b" || strings.Join(after, ",") != "c,d" {
|
||||
t.Errorf("split = %v / %v", before, after)
|
||||
}
|
||||
// no marker: everything is the first section, so a server that produced no
|
||||
// du output simply yields no sizes
|
||||
before, after = splitAtMarker([]string{"a", "b"}, "---mgsh---")
|
||||
if strings.Join(before, ",") != "a,b" || after != nil {
|
||||
t.Errorf("split without marker = %v / %v", before, after)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseDuSizes(t *testing.T) {
|
||||
lines := []string{
|
||||
"185432\tBetaflight3.0.0.git",
|
||||
"2144\twebsite.git",
|
||||
"876 spaced-with-blanks.git", // some du implementations use spaces
|
||||
"1024\t./with-dot-slash.git",
|
||||
"1500\tmy project.git", // a name with a space survives
|
||||
"garbage",
|
||||
"",
|
||||
}
|
||||
got := parseDuSizes(lines)
|
||||
want := map[string]int64{
|
||||
"Betaflight3.0.0.git": 185432 * 1024,
|
||||
"website.git": 2144 * 1024,
|
||||
"spaced-with-blanks.git": 876 * 1024,
|
||||
"with-dot-slash.git": 1024 * 1024,
|
||||
"my project.git": 1500 * 1024,
|
||||
}
|
||||
if len(got) != len(want) {
|
||||
t.Fatalf("parseDuSizes = %v, want %d entries", got, len(want))
|
||||
}
|
||||
for k, v := range want {
|
||||
if got[k] != v {
|
||||
t.Errorf("parseDuSizes[%q] = %d, want %d", k, got[k], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestMigrateRemoteKeys rewrites the pre-4.1 flat spelling in place. Only the
|
||||
// key changes: values, comments and everything else stay byte for byte.
|
||||
func TestMigrateRemoteKeys(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, ".mgshrc")
|
||||
before := `# my config
|
||||
base = /home/me/src
|
||||
remoteurl = https://git.example.com # the mirror
|
||||
remotekey = s3cr3t-token
|
||||
remotevisibility: public
|
||||
# remotetype = gitea (commented out, must stay put)
|
||||
alias co 'checkout $1'
|
||||
`
|
||||
if err := os.WriteFile(path, []byte(before), 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
out := captureStdout(t, func() { migrateRemoteKeys(path, before) })
|
||||
|
||||
got := readFile(t, path)
|
||||
for _, want := range []string{
|
||||
"remote.public.url = https://git.example.com # the mirror",
|
||||
"remote.public.key = s3cr3t-token",
|
||||
" remote.public.visibility: public",
|
||||
"# remotetype = gitea (commented out, must stay put)",
|
||||
"base = /home/me/src",
|
||||
"alias co 'checkout $1'",
|
||||
} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("migrated file missing %q:\n%s", want, got)
|
||||
}
|
||||
}
|
||||
if strings.Contains(got, "\nremoteurl") || strings.Contains(got, "\nremotekey") {
|
||||
t.Errorf("old spelling left behind:\n%s", got)
|
||||
}
|
||||
if !strings.Contains(out, "remoteurl → remote.public.url") {
|
||||
t.Errorf("migration was not reported: %q", out)
|
||||
}
|
||||
// the file keeps its private mode
|
||||
if fi, err := os.Stat(path); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if fi.Mode().Perm() != 0o600 {
|
||||
t.Errorf("mode after migration = %04o, want 0600", fi.Mode().Perm())
|
||||
}
|
||||
|
||||
// running again changes nothing and says nothing
|
||||
second := captureStdout(t, func() { migrateRemoteKeys(path, readFile(t, path)) })
|
||||
if strings.TrimSpace(second) != "" {
|
||||
t.Errorf("a converted file was migrated again: %q", second)
|
||||
}
|
||||
if readFile(t, path) != got {
|
||||
t.Error("a second migration changed the file")
|
||||
}
|
||||
}
|
||||
|
||||
// TestLegacyKeysDoNotOverrideExplicitOnes: a config carrying both spellings must
|
||||
// keep what the new one says.
|
||||
func TestLegacyKeysDoNotOverrideExplicitOnes(t *testing.T) {
|
||||
var c Config
|
||||
applyConfig(&c, parseConfig(
|
||||
"remoteurl = https://old.example\nremote.public.url = https://new.example\n"+
|
||||
"remote.public.key = tok\n"))
|
||||
targets, _ := c.mirrorTargets()
|
||||
if len(targets) != 1 || targets[0].URL != "https://new.example" {
|
||||
t.Errorf("targets = %+v, want the remote.public.url value", targets)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRemoteEnvOverrides: MGSH_REMOTE_<NAME>_<FIELD> is the environment
|
||||
// spelling of remote.<name>.<field>.
|
||||
func TestRemoteEnvOverrides(t *testing.T) {
|
||||
t.Setenv("MGSH_REMOTE_GITLAB_URL", "https://gitlab.example")
|
||||
t.Setenv("MGSH_REMOTE_GITLAB_KEY", "env-token")
|
||||
t.Setenv("MGSH_REMOTE_GITLAB_VISIBILITY", "public")
|
||||
t.Setenv("MGSH_REMOTE_MY_HUB_URL", "https://hub.example") // name with an underscore
|
||||
t.Setenv("MGSH_REMOTE_MY_HUB_KEY", "hub-token")
|
||||
t.Setenv("MGSH_REMOTES", "") // must not be mistaken for a target field
|
||||
|
||||
var c Config
|
||||
applyConfig(&c, parseConfig("remote.gitlab.url = https://from-file.example\nremote.gitlab.key = file-token\n"))
|
||||
applyEnv(&c)
|
||||
|
||||
targets, incomplete := c.mirrorTargets()
|
||||
if len(incomplete) != 0 {
|
||||
t.Fatalf("incomplete targets: %v", incomplete)
|
||||
}
|
||||
byName := map[string]RemoteTarget{}
|
||||
for _, tg := range targets {
|
||||
byName[tg.Name] = tg
|
||||
}
|
||||
if g := byName["gitlab"]; g.URL != "https://gitlab.example" || g.Key != "env-token" || g.Vis != "public" {
|
||||
t.Errorf("env did not override the file: %+v", g)
|
||||
}
|
||||
// the field is taken from the end, so the name may contain underscores
|
||||
if h := byName["my_hub"]; h.URL != "https://hub.example" || h.Key != "hub-token" {
|
||||
t.Errorf("MGSH_REMOTE_MY_HUB_* = %+v, want target my_hub", h)
|
||||
}
|
||||
}
|
||||
|
||||
+14
-14
@@ -20,26 +20,26 @@ gitpath = /home/git
|
||||
# gitname = Your Name
|
||||
# gitemail = you@example.com
|
||||
# pushdefault = matching
|
||||
# editor = code
|
||||
|
||||
# --- pushremote: mirror to public servers (gitea/github/gitlab) via their API ---
|
||||
# A single server, the flat form (this target is named "public"):
|
||||
# remoteurl = https://git.example.com
|
||||
# remotekey = <personal-access-token>
|
||||
# remotetype = gitea # optional; auto-detected from remoteurl
|
||||
# remotevisibility = private # visibility of created repos (default private)
|
||||
# One "remote.<name>.<field>" block per server, with the fields url, key, type
|
||||
# and visibility. <name> is yours to pick and becomes the git remote created in
|
||||
# the repository, so `git push gitlab` keeps working outside mgsh.
|
||||
#
|
||||
# `pushremote` pushes to every configured server in the order given,
|
||||
# `pushremote @gitlab` to a single one.
|
||||
#
|
||||
# Or any number of named servers. `pushremote` pushes to all of them in the
|
||||
# order given, `pushremote @hub` to a single one. Each target gets a git remote
|
||||
# of the same name in the repository.
|
||||
# remote.gitea.url = https://git.example.com
|
||||
# remote.gitea.key = <personal-access-token>
|
||||
# remote.hub.url = https://github.com
|
||||
# remote.hub.key = <personal-access-token>
|
||||
# remote.hub.type = github # optional; auto-detected from the url
|
||||
# remote.hub.visibility = public # default private
|
||||
# remotes = gitea, hub # optional: restrict and order the set
|
||||
# remote.gitea.type = gitea # optional; auto-detected from the url
|
||||
# remote.gitea.visibility = private # or public (default private)
|
||||
#
|
||||
# remote.gitlab.url = https://gitlab.example.com
|
||||
# remote.gitlab.key = <personal-access-token>
|
||||
# remote.gitlab.type = gitlab
|
||||
# remote.gitlab.visibility = public
|
||||
#
|
||||
# remotes = gitea, gitlab # optional: restrict and order the set
|
||||
# mirror = true # `push` also mirrors via pushremote
|
||||
|
||||
# --- safety ---
|
||||
|
||||
+155
-90
@@ -5,9 +5,8 @@ package main
|
||||
// mgsh is the only thing that sees all three places a project can live: the
|
||||
// local base directory, the internal ssh server, and the public mirrors. Joining
|
||||
// those answers the questions plain git cannot — which projects were never
|
||||
// pushed to the server, which exist there but not on this machine, and which
|
||||
// machine last touched each one (every `push` stamps "[user@host]" into the
|
||||
// commit message, so that comes for free).
|
||||
// pushed to the server, and which machine last touched each one (every `push`
|
||||
// stamps "[user@host]" into the commit message, so that comes for free).
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
@@ -18,15 +17,18 @@ import (
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// projStatus is the collected state of one project for the overview.
|
||||
type projStatus struct {
|
||||
name string
|
||||
branch string
|
||||
isRepo bool // has a .git of its own
|
||||
dirty bool
|
||||
ahead, behind int
|
||||
hasUpstream bool
|
||||
notOnServer bool // known to be missing from the git server
|
||||
lastHost string // machine that made the last commit, from "[user@host]"
|
||||
lastWhen time.Time // when that was
|
||||
mirrors []string // configured mirror remotes present in this repo
|
||||
@@ -60,33 +62,41 @@ func overviewAll() {
|
||||
srvCh <- serverList{names, err}
|
||||
}()
|
||||
|
||||
var local, repos []string
|
||||
// every directory gets a row, repository or not: one that is not a
|
||||
// repository yet is exactly what `init` is for, and putting it in the table
|
||||
// beats a separate list underneath
|
||||
var local []string
|
||||
for _, e := range entries {
|
||||
if !e.IsDir() || strings.HasPrefix(e.Name(), ".") {
|
||||
continue
|
||||
}
|
||||
if e.IsDir() && !strings.HasPrefix(e.Name(), ".") {
|
||||
local = append(local, e.Name())
|
||||
if isDir(BASE + "/" + e.Name() + "/.git") {
|
||||
repos = append(repos, e.Name())
|
||||
}
|
||||
}
|
||||
|
||||
rows := scanProjects(repos)
|
||||
rows := scanProjects(local)
|
||||
srv := <-srvCh
|
||||
markUnpublished(rows, srv.names, srv.err)
|
||||
|
||||
width := 0
|
||||
for _, n := range repos {
|
||||
if len(n) > width {
|
||||
width = len(n)
|
||||
}
|
||||
}
|
||||
// what needs doing first, alphabetical within each group
|
||||
sort.SliceStable(rows, func(i, j int) bool {
|
||||
return attentionRank(rows[i]) < attentionRank(rows[j])
|
||||
})
|
||||
|
||||
if len(rows) == 0 {
|
||||
fmt.Println(col(cGray, "no git projects under "+BASE))
|
||||
fmt.Println(col(cGray, "nothing under "+BASE))
|
||||
return
|
||||
}
|
||||
dirtyN, syncN := 0, 0
|
||||
|
||||
w := measureOverview(rows)
|
||||
repoN, dirtyN, syncN, initN := 0, 0, 0, 0
|
||||
for _, r := range rows {
|
||||
fmt.Println(formatProjStatus(r, width))
|
||||
fmt.Println(formatProjStatus(r, w))
|
||||
if r.notOnServer {
|
||||
initN++
|
||||
}
|
||||
if !r.isRepo {
|
||||
continue
|
||||
}
|
||||
repoN++
|
||||
if r.dirty {
|
||||
dirtyN++
|
||||
}
|
||||
@@ -94,12 +104,15 @@ func overviewAll() {
|
||||
syncN++
|
||||
}
|
||||
}
|
||||
if len(rows) > 0 {
|
||||
fmt.Println(col(cGray, fmt.Sprintf("%d projects · %d dirty · %d in sync",
|
||||
len(rows), dirtyN, syncN)))
|
||||
}
|
||||
|
||||
reportInventory(local, srv.names, srv.err)
|
||||
summary := fmt.Sprintf("%d projects · %d dirty · %d in sync", repoN, dirtyN, syncN)
|
||||
if initN > 0 {
|
||||
summary += fmt.Sprintf(" · %d to init", initN)
|
||||
}
|
||||
fmt.Println(col(cGray, summary))
|
||||
if srv.err != nil {
|
||||
fmt.Println(col(cGray, " git server not reachable — local view only"))
|
||||
}
|
||||
}
|
||||
|
||||
// scanProjects collects the state of every project concurrently. Each project
|
||||
@@ -121,50 +134,31 @@ func scanProjects(names []string) []projStatus {
|
||||
return rows
|
||||
}
|
||||
|
||||
// reportInventory names the projects that live on only one side: local ones the
|
||||
// server has never seen (candidates for `init`) and server repositories missing
|
||||
// here (candidates for `clone`).
|
||||
func reportInventory(local, server []string, err error) {
|
||||
// markUnpublished flags the rows the git server has never seen — the ones
|
||||
// `init` is for. A listing that failed leaves every row unmarked: not knowing
|
||||
// is not the same as knowing they are missing, and marking all of them would
|
||||
// tell the user to re-init their whole base directory.
|
||||
func markUnpublished(rows []projStatus, server []string, err error) {
|
||||
if err != nil {
|
||||
fmt.Println(col(cGray, " git server not reachable — local view only"))
|
||||
return
|
||||
}
|
||||
have := map[string]bool{}
|
||||
for _, n := range local {
|
||||
have[n] = true
|
||||
}
|
||||
onServer := map[string]bool{}
|
||||
for _, n := range server {
|
||||
onServer[n] = true
|
||||
}
|
||||
|
||||
var missingRemote, missingLocal []string
|
||||
for _, n := range local {
|
||||
if !onServer[n] {
|
||||
missingRemote = append(missingRemote, n)
|
||||
}
|
||||
}
|
||||
for _, n := range server {
|
||||
if !have[n] {
|
||||
missingLocal = append(missingLocal, n)
|
||||
}
|
||||
}
|
||||
sort.Strings(missingRemote)
|
||||
sort.Strings(missingLocal)
|
||||
|
||||
if len(missingRemote) > 0 {
|
||||
fmt.Printf("%s %s\n", col(cYellow, " not on the git server:"),
|
||||
strings.Join(missingRemote, ", ")+col(cGray, " (init)"))
|
||||
}
|
||||
if len(missingLocal) > 0 {
|
||||
fmt.Printf("%s %s\n", col(cCyan, " not cloned here: "),
|
||||
strings.Join(missingLocal, ", ")+col(cGray, " (clone)"))
|
||||
for i := range rows {
|
||||
rows[i].notOnServer = !onServer[rows[i].name]
|
||||
}
|
||||
}
|
||||
|
||||
// projectStatus gathers the git state of a single project directory.
|
||||
// projectStatus gathers the git state of a single project directory. A
|
||||
// directory without a repository is reported as it is, and costs no
|
||||
// subprocesses at all.
|
||||
func projectStatus(name, dir string) projStatus {
|
||||
s := projStatus{name: name, branch: "-"}
|
||||
if s.isRepo = isDir(dir + "/.git"); !s.isRepo {
|
||||
return s
|
||||
}
|
||||
readStatus(&s, dir)
|
||||
readLastCommit(&s, dir)
|
||||
s.mirrors = configuredMirrors(dir)
|
||||
@@ -244,50 +238,121 @@ func configuredMirrors(dir string) []string {
|
||||
return found
|
||||
}
|
||||
|
||||
// formatProjStatus renders one aligned overview row.
|
||||
func formatProjStatus(s projStatus, width int) string {
|
||||
var marks []string
|
||||
// overviewWidths are the column widths of the overview table, measured from the
|
||||
// rows so every field starts at the same place. Ragged columns were what made
|
||||
// the old one-line-per-project output hard to read.
|
||||
type overviewWidths struct {
|
||||
label, sync, host int
|
||||
hint bool // any row carries an action hint
|
||||
}
|
||||
|
||||
// hintWidth is the width of the action column, sized for its only word.
|
||||
const hintWidth = 4
|
||||
|
||||
// measureOverview sizes the columns for a set of rows.
|
||||
func measureOverview(rows []projStatus) overviewWidths {
|
||||
var w overviewWidths
|
||||
for _, r := range rows {
|
||||
w.label = max(w.label, utf8.RuneCountInString(projLabel(r)))
|
||||
w.sync = max(w.sync, utf8.RuneCountInString(syncState(r)))
|
||||
w.host = max(w.host, utf8.RuneCountInString(r.lastHost))
|
||||
w.hint = w.hint || r.notOnServer
|
||||
}
|
||||
return w
|
||||
}
|
||||
|
||||
// projLabel is the first column: the project, with its branch appended when it
|
||||
// is not the usual one. Keeping the branch attached to the name costs no extra
|
||||
// column and keeps the table narrow.
|
||||
func projLabel(s projStatus) string {
|
||||
if s.branch != "" && s.branch != "-" && s.branch != "master" && s.branch != "main" {
|
||||
return s.name + " (" + s.branch + ")"
|
||||
}
|
||||
return s.name
|
||||
}
|
||||
|
||||
// syncState renders the relation to the upstream as one short field: ahead,
|
||||
// behind, both, in sync, or "–" for a branch that tracks nothing. The old
|
||||
// spelled-out "(no upstream)" was fifteen columns wide and pushed every
|
||||
// following field out of line.
|
||||
func syncState(s projStatus) string {
|
||||
switch {
|
||||
case !s.isRepo:
|
||||
return "" // nothing to compare: there is no repository here yet
|
||||
case s.ahead > 0 && s.behind > 0:
|
||||
return fmt.Sprintf("↑%d↓%d", s.ahead, s.behind)
|
||||
case s.ahead > 0:
|
||||
return fmt.Sprintf("↑%d", s.ahead)
|
||||
case s.behind > 0:
|
||||
return fmt.Sprintf("↓%d", s.behind)
|
||||
case s.hasUpstream:
|
||||
return "✓"
|
||||
default:
|
||||
return "–"
|
||||
}
|
||||
}
|
||||
|
||||
// syncColor weights a row visually: anything needing action is coloured, a
|
||||
// project that is clean and in sync recedes into grey.
|
||||
func syncColor(s projStatus) string {
|
||||
switch {
|
||||
case s.behind > 0:
|
||||
return cRed
|
||||
case s.ahead > 0:
|
||||
return cGreen
|
||||
default:
|
||||
return cGray
|
||||
}
|
||||
}
|
||||
|
||||
// attentionRank groups the rows: work in progress at the top, then everything
|
||||
// that is settled, and last the directories the server does not have yet. With
|
||||
// many projects, scanning the whole list for the two dirty ones is the actual
|
||||
// work — and an un-inited directory is a different kind of task, not something
|
||||
// to push past the daily ones.
|
||||
func attentionRank(s projStatus) int {
|
||||
switch {
|
||||
case s.notOnServer:
|
||||
return 2
|
||||
case s.dirty || s.ahead > 0 || s.behind > 0:
|
||||
return 0
|
||||
default:
|
||||
return 1
|
||||
}
|
||||
}
|
||||
|
||||
// formatProjStatus renders one row of the overview table.
|
||||
func formatProjStatus(s projStatus, w overviewWidths) string {
|
||||
dirty := " "
|
||||
if s.dirty {
|
||||
marks = append(marks, col(cYellow, "*"))
|
||||
}
|
||||
if s.ahead > 0 {
|
||||
marks = append(marks, col(cGreen, fmt.Sprintf("↑%d", s.ahead)))
|
||||
}
|
||||
if s.behind > 0 {
|
||||
marks = append(marks, col(cRed, fmt.Sprintf("↓%d", s.behind)))
|
||||
}
|
||||
state := strings.Join(marks, " ")
|
||||
if state == "" {
|
||||
if s.hasUpstream {
|
||||
state = col(cGreen, "✓")
|
||||
} else {
|
||||
state = col(cGray, "✓ (no upstream)")
|
||||
}
|
||||
dirty = "*"
|
||||
}
|
||||
|
||||
line := " " + col(cGreen, padRight(s.name, width+2)) + state
|
||||
if s.branch != "master" && s.branch != "main" && s.branch != "-" {
|
||||
line += col(cGray, " ("+s.branch+")")
|
||||
}
|
||||
var b strings.Builder
|
||||
b.WriteString(" ")
|
||||
b.WriteString(col(cGreen, padRight(projLabel(s), w.label)))
|
||||
b.WriteString(" " + col(cYellow, dirty) + " ")
|
||||
b.WriteString(col(syncColor(s), padRight(syncState(s), w.sync)))
|
||||
|
||||
var tail []string
|
||||
if s.lastHost != "" || !s.lastWhen.IsZero() {
|
||||
t := s.lastHost
|
||||
if w.host > 0 {
|
||||
age := ""
|
||||
if !s.lastWhen.IsZero() {
|
||||
if t != "" {
|
||||
t += " "
|
||||
age = shortAge(time.Since(s.lastWhen))
|
||||
}
|
||||
t += shortAge(time.Since(s.lastWhen))
|
||||
b.WriteString(" " + col(cGray, padRight(s.lastHost, w.host)))
|
||||
b.WriteString(" " + col(cGray, fmt.Sprintf("%4s", age)))
|
||||
}
|
||||
tail = append(tail, t)
|
||||
if w.hint {
|
||||
hint := ""
|
||||
if s.notOnServer {
|
||||
hint = "init"
|
||||
}
|
||||
b.WriteString(" " + col(cYellow, padRight(hint, hintWidth)))
|
||||
}
|
||||
if len(s.mirrors) > 0 {
|
||||
tail = append(tail, "→ "+strings.Join(s.mirrors, ","))
|
||||
b.WriteString(col(cGray, " → "+strings.Join(s.mirrors, " ")))
|
||||
}
|
||||
if len(tail) > 0 {
|
||||
line += col(cGray, " · "+strings.Join(tail, " · "))
|
||||
}
|
||||
return line
|
||||
return strings.TrimRight(b.String(), " ")
|
||||
}
|
||||
|
||||
// shortAge renders a duration compactly: 90s -> "1m", 36h -> "1d".
|
||||
|
||||
+51
-21
@@ -82,33 +82,63 @@ func TestCommitHostRe(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// TestReportInventoryUnreachableServer: when the server cannot be listed, the
|
||||
// overview must say so rather than claim every project is missing there.
|
||||
func TestReportInventoryUnreachableServer(t *testing.T) {
|
||||
out := captureStdout(t, func() {
|
||||
reportInventory([]string{"a", "b"}, nil, errors.New("network is unreachable"))
|
||||
})
|
||||
if strings.Contains(out, "not on the git server") {
|
||||
t.Errorf("an unreachable server was reported as missing repositories: %q", out)
|
||||
// TestMarkUnpublishedUnreachableServer: a listing that failed must leave every
|
||||
// row unmarked. Not knowing is not the same as knowing they are missing —
|
||||
// marking all of them would tell the user to re-init their whole base.
|
||||
func TestMarkUnpublishedUnreachableServer(t *testing.T) {
|
||||
rows := []projStatus{{name: "a"}, {name: "b"}}
|
||||
markUnpublished(rows, nil, errors.New("network is unreachable"))
|
||||
for _, r := range rows {
|
||||
if r.notOnServer {
|
||||
t.Errorf("%s marked as missing although the server could not be listed", r.name)
|
||||
}
|
||||
if !strings.Contains(out, "not reachable") {
|
||||
t.Errorf("no hint that the server was unreachable: %q", out)
|
||||
}
|
||||
}
|
||||
|
||||
// TestReportInventorySplitsSides is the join that plain git cannot do.
|
||||
func TestReportInventorySplitsSides(t *testing.T) {
|
||||
out := captureStdout(t, func() {
|
||||
reportInventory([]string{"both", "onlyhere"}, []string{"both", "onlythere"}, nil)
|
||||
})
|
||||
if !strings.Contains(out, "not on the git server:") || !strings.Contains(out, "onlyhere") {
|
||||
t.Errorf("local-only project not reported: %q", out)
|
||||
// TestMarkUnpublished flags only what the server really does not have.
|
||||
func TestMarkUnpublished(t *testing.T) {
|
||||
rows := []projStatus{{name: "both"}, {name: "onlyhere"}}
|
||||
markUnpublished(rows, []string{"both", "onlythere"}, nil)
|
||||
if rows[0].notOnServer {
|
||||
t.Error("a project present on both sides was marked")
|
||||
}
|
||||
if !strings.Contains(out, "not cloned here:") || !strings.Contains(out, "onlythere") {
|
||||
t.Errorf("server-only project not reported: %q", out)
|
||||
if !rows[1].notOnServer {
|
||||
t.Error("a local-only project was not marked")
|
||||
}
|
||||
if strings.Contains(out, "both") {
|
||||
t.Errorf("a project present on both sides should not be listed: %q", out)
|
||||
}
|
||||
|
||||
// TestUnpublishedRowsCarryTheHint: the entries live in the table now, with the
|
||||
// action in their own column, rather than in a list underneath it.
|
||||
func TestUnpublishedRowsCarryTheHint(t *testing.T) {
|
||||
useColor = false
|
||||
rows := []projStatus{
|
||||
{name: "published", isRepo: true, hasUpstream: true},
|
||||
{name: "fresh", isRepo: true, notOnServer: true},
|
||||
{name: "notarepo", notOnServer: true},
|
||||
}
|
||||
w := measureOverview(rows)
|
||||
if !w.hint {
|
||||
t.Fatal("hint column not reserved although rows need it")
|
||||
}
|
||||
got := []string{}
|
||||
for _, r := range rows {
|
||||
got = append(got, formatProjStatus(r, w))
|
||||
}
|
||||
if strings.Contains(got[0], "init") {
|
||||
t.Errorf("a published project was hinted: %q", got[0])
|
||||
}
|
||||
for _, i := range []int{1, 2} {
|
||||
if !strings.Contains(got[i], "init") {
|
||||
t.Errorf("row %d missing the init hint: %q", i, got[i])
|
||||
}
|
||||
}
|
||||
// a directory that is not a repository has no sync state to report
|
||||
if strings.ContainsAny(got[2], "✓–↑↓") {
|
||||
t.Errorf("non-repository row claims a git state: %q", got[2])
|
||||
}
|
||||
// with nothing to hint the column disappears entirely
|
||||
if measureOverview(rows[:1]).hint {
|
||||
t.Error("hint column reserved although no row needs it")
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+65
-25
@@ -56,46 +56,68 @@ func (r *remoteAPI) releaseByTagPath(owner, repo, tag string) string {
|
||||
return r.releasePath(owner, repo) + "/tags/" + url.PathEscape(tag)
|
||||
}
|
||||
|
||||
// findRelease returns the provider's id for the release of tag and whether it
|
||||
// exists at all. GitLab addresses releases by tag, so there the tag is the id.
|
||||
func (r *remoteAPI) findRelease(owner, repo, tag string) (id string, found bool, err error) {
|
||||
code, data, err := r.do("GET", r.releaseByTagPath(owner, repo, tag), nil)
|
||||
if err != nil {
|
||||
return "", false, err
|
||||
}
|
||||
switch code {
|
||||
case 404:
|
||||
return "", false, nil
|
||||
case 200:
|
||||
// releaseRef identifies a release for the calls that follow creating it.
|
||||
type releaseRef struct {
|
||||
tag string
|
||||
id string // provider id; the tag itself on GitLab
|
||||
// GitHub uploads assets to a different host than its API, and names it in
|
||||
// the release object as an RFC 6570 template
|
||||
uploadURL string
|
||||
}
|
||||
|
||||
// parseReleaseRef reads the identifying fields out of a release object.
|
||||
func (r *remoteAPI) parseReleaseRef(tag string, data []byte) releaseRef {
|
||||
ref := releaseRef{tag: tag, id: tag}
|
||||
if r.kind == kindGitLab {
|
||||
return tag, true, nil
|
||||
return ref // GitLab addresses a release by its tag throughout
|
||||
}
|
||||
var res struct {
|
||||
ID int64 `json:"id"`
|
||||
UploadURL string `json:"upload_url"`
|
||||
}
|
||||
json.Unmarshal(data, &res)
|
||||
return strconv.FormatInt(res.ID, 10), true, nil
|
||||
ref.id = strconv.FormatInt(res.ID, 10)
|
||||
// ".../assets{?name,label}" -> ".../assets"
|
||||
if i := strings.IndexByte(res.UploadURL, '{'); i >= 0 {
|
||||
ref.uploadURL = res.UploadURL[:i]
|
||||
} else {
|
||||
ref.uploadURL = res.UploadURL
|
||||
}
|
||||
return ref
|
||||
}
|
||||
|
||||
// findRelease returns the release of tag and whether it exists at all.
|
||||
func (r *remoteAPI) findRelease(owner, repo, tag string) (ref releaseRef, found bool, err error) {
|
||||
code, data, err := r.do("GET", r.releaseByTagPath(owner, repo, tag), nil)
|
||||
if err != nil {
|
||||
return releaseRef{}, false, err
|
||||
}
|
||||
switch code {
|
||||
case 404:
|
||||
return releaseRef{}, false, nil
|
||||
case 200:
|
||||
return r.parseReleaseRef(tag, data), true, nil
|
||||
default:
|
||||
return "", false, fmt.Errorf("checking release failed (HTTP %d): %s", code, firstLine(data))
|
||||
return releaseRef{}, false, fmt.Errorf("checking release failed (HTTP %d): %s", code, firstLine(data))
|
||||
}
|
||||
}
|
||||
|
||||
// createRelease publishes a new release for an already pushed tag.
|
||||
func (r *remoteAPI) createRelease(owner, repo string, rel release) error {
|
||||
func (r *remoteAPI) createRelease(owner, repo string, rel release) (releaseRef, error) {
|
||||
code, data, err := r.do("POST", r.releasePath(owner, repo), r.releaseBody(rel, true))
|
||||
if err != nil {
|
||||
return err
|
||||
return releaseRef{}, err
|
||||
}
|
||||
if code != 200 && code != 201 {
|
||||
return fmt.Errorf("creating release failed (HTTP %d): %s", code, firstLine(data))
|
||||
return releaseRef{}, fmt.Errorf("creating release failed (HTTP %d): %s", code, firstLine(data))
|
||||
}
|
||||
return nil
|
||||
return r.parseReleaseRef(rel.Tag, data), nil
|
||||
}
|
||||
|
||||
// updateRelease rewrites the name and notes of an existing release. Gitea and
|
||||
// GitHub patch it by numeric id, GitLab puts it by tag.
|
||||
func (r *remoteAPI) updateRelease(owner, repo, id string, rel release) error {
|
||||
method, ep := "PATCH", r.releasePath(owner, repo)+"/"+id
|
||||
func (r *remoteAPI) updateRelease(owner, repo string, ref releaseRef, rel release) error {
|
||||
method, ep := "PATCH", r.releasePath(owner, repo)+"/"+ref.id
|
||||
if r.kind == kindGitLab {
|
||||
method, ep = "PUT", r.releaseByTagPath(owner, repo, rel.Tag)
|
||||
}
|
||||
@@ -164,9 +186,20 @@ func handleRelease(args string) {
|
||||
body = releaseNotes(DIR, tag)
|
||||
}
|
||||
|
||||
// ./bin and ./assets ride along when they are there; nothing to configure,
|
||||
// and nothing happens for a project that has neither
|
||||
assets, skipped := collectAssets(DIR)
|
||||
for _, s := range skipped {
|
||||
errorln("skipping " + s + ": another directory already contributes that name")
|
||||
}
|
||||
if len(assets) > 0 {
|
||||
fmt.Printf("%s %s %s\n", col(cGray, "attaching"), col(cYellow, assetSummary(assets)),
|
||||
col(cGray, "from "+strings.Join(assetDirList(DIR), " and ")))
|
||||
}
|
||||
|
||||
done := 0
|
||||
for _, t := range targets {
|
||||
if publishRelease(t, PRJ, tag, body) {
|
||||
if publishRelease(t, PRJ, tag, body, assets) {
|
||||
done++
|
||||
}
|
||||
}
|
||||
@@ -223,7 +256,7 @@ func releaseNotes(dir, tag string) string {
|
||||
// publishRelease pushes the tag to one mirror target and turns it into a
|
||||
// release there. It returns success, so one unreachable server does not stop
|
||||
// the remaining ones.
|
||||
func publishRelease(t RemoteTarget, repo, tag, body string) bool {
|
||||
func publishRelease(t RemoteTarget, repo, tag, body string, assets []releaseAsset) bool {
|
||||
api := newRemoteAPI(t.URL, t.Key, t.Type)
|
||||
|
||||
owner, err := api.authUser()
|
||||
@@ -248,17 +281,17 @@ func publishRelease(t RemoteTarget, repo, tag, body string) bool {
|
||||
}
|
||||
|
||||
rel := release{Tag: tag, Name: tag, Body: body, Prerelease: preReleaseRe.MatchString(tag)}
|
||||
id, found, err := api.findRelease(owner, repo, tag)
|
||||
ref, found, err := api.findRelease(owner, repo, tag)
|
||||
if err != nil {
|
||||
errorln(t.Name + ": " + err.Error())
|
||||
return false
|
||||
}
|
||||
if found {
|
||||
if err := api.updateRelease(owner, repo, id, rel); err != nil {
|
||||
if err := api.updateRelease(owner, repo, ref, rel); err != nil {
|
||||
errorln(t.Name + ": " + err.Error())
|
||||
return false
|
||||
}
|
||||
} else if err := api.createRelease(owner, repo, rel); err != nil {
|
||||
} else if ref, err = api.createRelease(owner, repo, rel); err != nil {
|
||||
errorln(t.Name + ": " + err.Error())
|
||||
return false
|
||||
}
|
||||
@@ -272,5 +305,12 @@ func publishRelease(t RemoteTarget, repo, tag, body string) bool {
|
||||
}
|
||||
fmt.Printf("%s %s %s %s\n", col(cGray, "remote"), col(cYellow, t.Name),
|
||||
col(cGreen, what), col(cCyan, api.repoWebURL(owner, repo)))
|
||||
|
||||
if len(assets) > 0 {
|
||||
if err := api.uploadAssets(owner, repo, ref, assets); err != nil {
|
||||
errorln(t.Name + ": " + err.Error())
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
+15
-11
@@ -9,6 +9,7 @@ package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
@@ -20,6 +21,8 @@ import (
|
||||
// recordedReq is one request the fake provider received.
|
||||
type recordedReq struct {
|
||||
method, path, query string
|
||||
ctype string
|
||||
raw []byte // the body as sent, for the asset uploads
|
||||
body map[string]any
|
||||
}
|
||||
|
||||
@@ -42,11 +45,12 @@ func newFakeProvider(t *testing.T) *fakeProvider {
|
||||
body string
|
||||
}{}}
|
||||
f.Server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
rec := recordedReq{method: r.Method, path: r.URL.EscapedPath(), query: r.URL.RawQuery}
|
||||
rec := recordedReq{method: r.Method, path: r.URL.EscapedPath(), query: r.URL.RawQuery,
|
||||
ctype: r.Header.Get("Content-Type")}
|
||||
if r.Body != nil {
|
||||
var m map[string]any
|
||||
json.NewDecoder(r.Body).Decode(&m)
|
||||
rec.body = m
|
||||
raw, _ := io.ReadAll(r.Body)
|
||||
rec.raw = raw
|
||||
json.Unmarshal(raw, &rec.body)
|
||||
}
|
||||
f.got = append(f.got, rec)
|
||||
|
||||
@@ -106,7 +110,7 @@ func TestCreateReleasePerProvider(t *testing.T) {
|
||||
f.route("POST "+c.wantPath, 201, `{"id":7}`)
|
||||
|
||||
api := newRemoteAPI(f.URL, "tok", c.typ)
|
||||
if err := api.createRelease("mike", "mgsh", rel); err != nil {
|
||||
if _, err := api.createRelease("mike", "mgsh", rel); err != nil {
|
||||
t.Fatalf("%s: createRelease: %v (requests: %v)", c.typ, err, f.paths())
|
||||
}
|
||||
|
||||
@@ -145,11 +149,11 @@ func TestFindReleaseAndUpdate(t *testing.T) {
|
||||
f.route(c.wantMethod+" "+c.wantUpdate, 200, `{}`)
|
||||
|
||||
api := newRemoteAPI(f.URL, "tok", c.typ)
|
||||
id, found, err := api.findRelease("mike", "mgsh", "v1.2")
|
||||
ref, found, err := api.findRelease("mike", "mgsh", "v1.2")
|
||||
if err != nil || !found {
|
||||
t.Fatalf("%s: findRelease = %q,%v,%v", c.typ, id, found, err)
|
||||
t.Fatalf("%s: findRelease = %+v,%v,%v", c.typ, ref, found, err)
|
||||
}
|
||||
if err := api.updateRelease("mike", "mgsh", id, release{Tag: "v1.2", Name: "v1.2", Body: "new"}); err != nil {
|
||||
if err := api.updateRelease("mike", "mgsh", ref, release{Tag: "v1.2", Name: "v1.2", Body: "new"}); err != nil {
|
||||
t.Fatalf("%s: updateRelease: %v (requests: %v)", c.typ, err, f.paths())
|
||||
}
|
||||
req := f.find(c.wantMethod + " " + c.wantUpdate)
|
||||
@@ -168,9 +172,9 @@ func TestFindReleaseAndUpdate(t *testing.T) {
|
||||
func TestFindReleaseMissing(t *testing.T) {
|
||||
f := newFakeProvider(t) // everything 404s
|
||||
api := newRemoteAPI(f.URL, "tok", "gitea")
|
||||
id, found, err := api.findRelease("mike", "mgsh", "v9")
|
||||
if err != nil || found || id != "" {
|
||||
t.Fatalf("findRelease on empty server = %q,%v,%v", id, found, err)
|
||||
ref, found, err := api.findRelease("mike", "mgsh", "v9")
|
||||
if err != nil || found || ref.id != "" {
|
||||
t.Fatalf("findRelease on empty server = %+v,%v,%v", ref, found, err)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -4,23 +4,18 @@ package main
|
||||
// git hosting server (Gitea, GitHub or GitLab), creating the repository via the
|
||||
// server's REST API when it does not exist yet.
|
||||
//
|
||||
// Configuration (in ~/.mgshrc, a project .mgshrc, or MGSH_* env) — either a
|
||||
// single flat target:
|
||||
// Configuration (in ~/.mgshrc, a project .mgshrc, or MGSH_* env): one
|
||||
// remote.<name>.<field> block per server, which `pushremote` mirrors to in turn.
|
||||
//
|
||||
// remoteurl = https://git.example.com base URL of the server
|
||||
// remotekey = <api-token> personal access token
|
||||
// remotetype = gitea|github|gitlab optional; auto-detected from the URL
|
||||
// remote.gitlab.url = https://gitlab.example.com
|
||||
// remote.gitlab.key = <api-token>
|
||||
// remote.gitlab.type = gitlab optional; detected from the url
|
||||
// remote.gitlab.visibility = public or private (the default)
|
||||
// remotes = gitlab optional: restrict/order the set
|
||||
//
|
||||
// or any number of named ones, which `pushremote` mirrors to in turn:
|
||||
//
|
||||
// remote.gitea.url = https://git.example.com
|
||||
// remote.gitea.key = <api-token>
|
||||
// remote.hub.url = https://github.com
|
||||
// remote.hub.key = <api-token>
|
||||
// remote.hub.visibility = public
|
||||
// remotes = gitea, hub optional: restrict/order the set
|
||||
//
|
||||
// Each target owns a git remote of the same name in the repository.
|
||||
// Each target owns a git remote of its own name in the repository. There is no
|
||||
// second spelling: the pre-4.1 flat remoteurl/remotekey pair is migrated to
|
||||
// remote.public.* on load.
|
||||
//
|
||||
// The token is used for the API calls and, via an HTTP Basic auth header, for
|
||||
// the git push. It is never written into the repository's git config, and it is
|
||||
@@ -287,7 +282,7 @@ func handlePushRemote(args string) {
|
||||
targets = pickRemotes(targets, names)
|
||||
if len(targets) == 0 {
|
||||
if len(names) == 0 { // an unknown @name already reported itself
|
||||
errorln("pushremote needs 'remoteurl'/'remotekey' or a 'remote.<name>.*' block in " + configFile())
|
||||
errorln("pushremote needs a 'remote.<name>.url' and 'remote.<name>.key' in " + configFile())
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
@@ -329,3 +329,65 @@ func mustGit(t *testing.T, dir string, args ...string) {
|
||||
t.Fatalf("git %v: %v\n%s", args, err, out)
|
||||
}
|
||||
}
|
||||
|
||||
// TestListSurvivesFailingDu: `list` chains the listing and `du` into one remote
|
||||
// command, and the exit status is the *last* command's. A server whose du fails
|
||||
// — a shell that mis-parses the arguments, a du that is not there, a permission
|
||||
// problem — must still get its repositories listed.
|
||||
func TestListSurvivesFailingDu(t *testing.T) {
|
||||
useProject(t, "x")
|
||||
fakeServer(t, func(cmd string) (string, error) {
|
||||
return "total 4\n" +
|
||||
"drwxr-xr-x 7 git git 4096 Jan 3 14:32 notes.git\n" +
|
||||
"drwxr-xr-x 7 git git 4096 Sep 28 2016 website.git\n" +
|
||||
listMarker + "\n",
|
||||
errors.New("exit status 1") // du blew up, ls did not
|
||||
})
|
||||
|
||||
out := captureStdout(t, func() { runCommand("list") })
|
||||
|
||||
if strings.Contains(out, "could not list") {
|
||||
t.Errorf("a failing du discarded a good listing:\n%s", out)
|
||||
}
|
||||
for _, want := range []string{"notes", "website", "2 repositories"} {
|
||||
if !strings.Contains(out, want) {
|
||||
t.Errorf("listing missing %q:\n%s", want, out)
|
||||
}
|
||||
}
|
||||
// without sizes there must be no size column, not a column of zeroes
|
||||
if strings.Contains(out, "0B") {
|
||||
t.Errorf("zero sizes shown when du produced none:\n%s", out)
|
||||
}
|
||||
}
|
||||
|
||||
// TestListReportsATrulyFailedListing: when nothing usable came back, the error
|
||||
// still has to surface.
|
||||
func TestListReportsATrulyFailedListing(t *testing.T) {
|
||||
useProject(t, "x")
|
||||
fakeServer(t, func(cmd string) (string, error) {
|
||||
return "", errors.New("ssh: connect failed")
|
||||
})
|
||||
out := captureStdout(t, func() { runCommand("list") })
|
||||
if !strings.Contains(out, "could not list") {
|
||||
t.Errorf("a failed listing was not reported:\n%s", out)
|
||||
}
|
||||
}
|
||||
|
||||
// TestListSendsNoShellSpecificSyntax guards the bug this replaced: the remote
|
||||
// command is run by the git user's login shell, which may be csh, where
|
||||
// "2>/dev/null" is an argument followed by a redirection rather than a
|
||||
// redirection of stderr.
|
||||
func TestListSendsNoShellSpecificSyntax(t *testing.T) {
|
||||
useProject(t, "x")
|
||||
sent := fakeServer(t, func(cmd string) (string, error) { return "", nil })
|
||||
captureStdout(t, func() { runCommand("list") })
|
||||
|
||||
if len(*sent) == 0 {
|
||||
t.Fatal("list sent nothing")
|
||||
}
|
||||
for _, c := range *sent {
|
||||
if strings.Contains(c, "2>") || strings.Contains(c, "&>") {
|
||||
t.Errorf("remote command uses sh-only redirection: %q", c)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,181 @@
|
||||
package main
|
||||
|
||||
// shellcomplete.go — Tab completion for the '!' shell escape.
|
||||
//
|
||||
// `!vi <Tab>` should behave like it does in a shell: the first word completes
|
||||
// against the executables on PATH, everything after it against the filesystem.
|
||||
// Paths resolve relative to the active project directory, because that is where
|
||||
// forwardShell runs the command.
|
||||
//
|
||||
// Word splitting here is whitespace only. Quoting and backslash escapes are the
|
||||
// shell's business at execution time; getting them right for completion too
|
||||
// would buy little for a one-off escape hatch.
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// shellCommandList supplies the executable names for the command position. A
|
||||
// variable so tests can hand over a fixed set instead of whatever happens to be
|
||||
// installed on the machine running them.
|
||||
var shellCommandList = pathExecutables
|
||||
|
||||
// completeShellLine returns the candidates and the prefix they replace for a
|
||||
// line that is headed for a shell. ok is false for any other line, which is
|
||||
// then left to the builtin command tree.
|
||||
func completeShellLine(typed string) (cands []string, prefix string, ok bool) {
|
||||
body, allowCommand, ok := shellLine(typed)
|
||||
if !ok {
|
||||
return nil, "", false
|
||||
}
|
||||
cands, prefix = shellCandidates(body, allowCommand)
|
||||
return cands, prefix, true
|
||||
}
|
||||
|
||||
// shellLine works out which part of a typed line will reach a shell, and
|
||||
// whether its command word is still open for completion. Two things get there:
|
||||
// a '!' escape, and an alias that expands to one — `alias ll '!ls -la'` makes
|
||||
// everything after `ll` a shell argument just as surely.
|
||||
//
|
||||
// Only the alias itself is inspected, not what its expansion might expand to
|
||||
// again: an alias chain can rewrite its arguments, and guessing at that would
|
||||
// offer candidates for a command line that is not the one being built.
|
||||
func shellLine(typed string) (body string, allowCommand, ok bool) {
|
||||
trimmed := strings.TrimLeft(typed, " \t")
|
||||
if rest, found := strings.CutPrefix(trimmed, "!"); found {
|
||||
return rest, true, true
|
||||
}
|
||||
|
||||
// the alias name has to be complete — while it is still being typed there
|
||||
// is no way to know what it will turn out to be
|
||||
sep := strings.IndexAny(trimmed, " \t")
|
||||
if sep < 0 {
|
||||
return "", false, false
|
||||
}
|
||||
name := trimmed[:sep]
|
||||
if isBuiltin(name) { // a builtin can never be shadowed by an alias
|
||||
return "", false, false
|
||||
}
|
||||
expansion, defined := aliases[name]
|
||||
if !defined || !strings.HasPrefix(strings.TrimSpace(expansion), "!") {
|
||||
return "", false, false
|
||||
}
|
||||
// the command comes from the alias body, so only arguments are left to complete
|
||||
return trimmed[sep:], false, true
|
||||
}
|
||||
|
||||
// shellCandidates completes the last word of a shell command line. allowCommand
|
||||
// says whether its first word may still be completed against PATH.
|
||||
func shellCandidates(body string, allowCommand bool) (cands []string, prefix string) {
|
||||
word := body[strings.LastIndexAny(body, " \t")+1:]
|
||||
inCommand := allowCommand && strings.TrimLeft(body[:len(body)-len(word)], " \t") == ""
|
||||
|
||||
// a command word without a separator names something on PATH; with one it
|
||||
// is a path like ./script, exactly as a shell reads it
|
||||
if inCommand && !strings.ContainsRune(word, '/') {
|
||||
if word == "" {
|
||||
return nil, "" // every executable on the machine helps nobody
|
||||
}
|
||||
return matchPrefix(shellCommandList(), word), word
|
||||
}
|
||||
|
||||
dir, base := splitPathToken(word)
|
||||
return matchPrefix(pathEntries(dir), base), base
|
||||
}
|
||||
|
||||
// splitPathToken splits a path token into the directory part, kept exactly as
|
||||
// typed, and the basename being completed. Completing only the basename is what
|
||||
// keeps the candidate list readable: "src/ma<Tab>" offers "main.go", not the
|
||||
// whole path again.
|
||||
func splitPathToken(word string) (dir, base string) {
|
||||
if i := strings.LastIndexByte(word, '/'); i >= 0 {
|
||||
return word[:i+1], word[i+1:]
|
||||
}
|
||||
return "", word
|
||||
}
|
||||
|
||||
// pathEntries lists what a directory token points at. Directories come back
|
||||
// with a trailing slash, so completing one leads straight into it.
|
||||
func pathEntries(dir string) []string {
|
||||
root := DIR
|
||||
switch {
|
||||
case strings.HasPrefix(dir, "~/"):
|
||||
home, err := os.UserHomeDir()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
root, dir = home, dir[2:]
|
||||
case strings.HasPrefix(dir, "/"):
|
||||
root = ""
|
||||
}
|
||||
|
||||
entries, err := os.ReadDir(filepath.Join(root, dir))
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
out := make([]string, 0, len(entries))
|
||||
for _, e := range entries {
|
||||
name := e.Name()
|
||||
if e.IsDir() {
|
||||
name += "/"
|
||||
}
|
||||
out = append(out, name)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// matchPrefix keeps the candidates starting with prefix, sorted and without
|
||||
// duplicates. A hidden entry only shows up once the prefix asks for it, as in a
|
||||
// shell.
|
||||
func matchPrefix(cands []string, prefix string) []string {
|
||||
wantHidden := strings.HasPrefix(prefix, ".")
|
||||
seen := map[string]bool{}
|
||||
var out []string
|
||||
for _, c := range cands {
|
||||
if !strings.HasPrefix(c, prefix) || seen[c] {
|
||||
continue
|
||||
}
|
||||
if !wantHidden && strings.HasPrefix(c, ".") {
|
||||
continue
|
||||
}
|
||||
seen[c] = true
|
||||
out = append(out, c)
|
||||
}
|
||||
sort.Strings(out)
|
||||
return out
|
||||
}
|
||||
|
||||
// pathExecutables lists the executable names on PATH. The scan happens once per
|
||||
// session: PATH cannot change from inside mgsh, and a few thousand directory
|
||||
// entries are not worth walking on every Tab.
|
||||
var pathExecutables = sync.OnceValue(func() []string {
|
||||
var out []string
|
||||
seen := map[string]bool{}
|
||||
for _, dir := range filepath.SplitList(os.Getenv("PATH")) {
|
||||
if dir == "" {
|
||||
dir = "."
|
||||
}
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
for _, e := range entries {
|
||||
name := e.Name()
|
||||
if seen[name] {
|
||||
continue // the first one on PATH is the one that would run
|
||||
}
|
||||
fi, err := e.Info()
|
||||
if err != nil || fi.IsDir() || fi.Mode().Perm()&0o111 == 0 {
|
||||
continue
|
||||
}
|
||||
seen[name] = true
|
||||
out = append(out, name)
|
||||
}
|
||||
}
|
||||
sort.Strings(out)
|
||||
return out
|
||||
})
|
||||
@@ -0,0 +1,260 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// complete runs the real dispatch a Tab press goes through.
|
||||
func complete(typed string) ([]string, string) {
|
||||
cands, prefix, _ := completeShellLine(typed)
|
||||
return cands, prefix
|
||||
}
|
||||
|
||||
// fakeCommands installs a fixed set of PATH executables for the test.
|
||||
func fakeCommands(t *testing.T, names ...string) {
|
||||
t.Helper()
|
||||
old := shellCommandList
|
||||
shellCommandList = func() []string { return names }
|
||||
t.Cleanup(func() { shellCommandList = old })
|
||||
}
|
||||
|
||||
// shellTree lays out a directory to complete against and points DIR at it.
|
||||
func shellTree(t *testing.T) string {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
for _, d := range []string{"src", "src/deep", ".hidden"} {
|
||||
if err := os.MkdirAll(filepath.Join(dir, d), 0755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
for _, f := range []string{"main.go", "main_test.go", "Makefile", ".env", "src/util.go"} {
|
||||
if err := os.WriteFile(filepath.Join(dir, f), []byte("x"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
old := DIR
|
||||
DIR = dir
|
||||
t.Cleanup(func() { DIR = old })
|
||||
return dir
|
||||
}
|
||||
|
||||
func TestShellCandidatesCommandWord(t *testing.T) {
|
||||
fakeCommands(t, "vi", "vim", "view", "grep", "git")
|
||||
shellTree(t)
|
||||
|
||||
cands, prefix := complete("!vi")
|
||||
if prefix != "vi" {
|
||||
t.Errorf("prefix = %q, want vi", prefix)
|
||||
}
|
||||
if strings.Join(cands, ",") != "vi,view,vim" {
|
||||
t.Errorf("candidates = %v, want vi,view,vim sorted", cands)
|
||||
}
|
||||
|
||||
// a bare '!' must not dump every executable on the machine
|
||||
if cands, _ := complete("!"); len(cands) != 0 {
|
||||
t.Errorf("bare '!' offered %d candidates", len(cands))
|
||||
}
|
||||
// leading blanks are allowed, as runCommand allows them
|
||||
if cands, _ := complete(" !gi"); strings.Join(cands, ",") != "git" {
|
||||
t.Errorf("indented escape = %v, want git", cands)
|
||||
}
|
||||
// a command word with a separator is a path, not a PATH lookup
|
||||
if cands, prefix := complete("!./ma"); prefix != "ma" ||
|
||||
strings.Join(cands, ",") != "main.go,main_test.go" {
|
||||
t.Errorf("./ma = %v (prefix %q), want the local files", cands, prefix)
|
||||
}
|
||||
}
|
||||
|
||||
func TestShellCandidatesArguments(t *testing.T) {
|
||||
fakeCommands(t, "vi")
|
||||
shellTree(t)
|
||||
|
||||
// paths resolve against the project directory, where `!` commands run
|
||||
cands, prefix := complete("!vi ma")
|
||||
if prefix != "ma" || strings.Join(cands, ",") != "main.go,main_test.go" {
|
||||
t.Errorf("candidates = %v (prefix %q)", cands, prefix)
|
||||
}
|
||||
|
||||
// an empty argument lists the directory — dot entries stay out of the way
|
||||
cands, prefix = complete("!vi ")
|
||||
if prefix != "" {
|
||||
t.Errorf("prefix = %q, want empty", prefix)
|
||||
}
|
||||
if strings.Join(cands, ",") != "Makefile,main.go,main_test.go,src/" {
|
||||
t.Errorf("directory listing = %v", cands)
|
||||
}
|
||||
|
||||
// ... until the prefix asks for them
|
||||
if cands, _ := complete("!vi ."); strings.Join(cands, ",") != ".env,.hidden/" {
|
||||
t.Errorf("dot prefix = %v, want the hidden entries", cands)
|
||||
}
|
||||
|
||||
// a directory completes with its slash, so the next Tab walks into it
|
||||
cands, prefix = complete("!vi sr")
|
||||
if prefix != "sr" || strings.Join(cands, ",") != "src/" {
|
||||
t.Errorf("directory candidate = %v (prefix %q)", cands, prefix)
|
||||
}
|
||||
|
||||
// inside a directory only the basename is completed, which is what keeps
|
||||
// the candidate list readable
|
||||
cands, prefix = complete("!vi src/ut")
|
||||
if prefix != "ut" || strings.Join(cands, ",") != "util.go" {
|
||||
t.Errorf("nested candidate = %v (prefix %q), want util.go / ut", cands, prefix)
|
||||
}
|
||||
|
||||
// later arguments complete the same way as the first
|
||||
if cands, _ := complete("!diff main.go ma"); strings.Join(cands, ",") != "main.go,main_test.go" {
|
||||
t.Errorf("second argument = %v", cands)
|
||||
}
|
||||
}
|
||||
|
||||
func TestShellCandidatesAbsoluteAndHome(t *testing.T) {
|
||||
home := t.TempDir()
|
||||
t.Setenv("HOME", home)
|
||||
if err := os.WriteFile(filepath.Join(home, "notes.txt"), []byte("x"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
shellTree(t)
|
||||
fakeCommands(t, "vi")
|
||||
|
||||
if cands, prefix := complete("!vi ~/no"); prefix != "no" ||
|
||||
strings.Join(cands, ",") != "notes.txt" {
|
||||
t.Errorf("~/ completion = %v (prefix %q)", cands, prefix)
|
||||
}
|
||||
|
||||
abs := filepath.Join(home, "no")
|
||||
if cands, prefix := complete("!vi " + abs); prefix != "no" ||
|
||||
strings.Join(cands, ",") != "notes.txt" {
|
||||
t.Errorf("absolute completion = %v (prefix %q)", cands, prefix)
|
||||
}
|
||||
}
|
||||
|
||||
// TestShellCompleterDoContract is the part that would corrupt the line if it
|
||||
// were wrong: readline replaces the last `length` runes with a candidate, so
|
||||
// the candidates must be suffixes and the length must count runes.
|
||||
func TestShellCompleterDoContract(t *testing.T) {
|
||||
fakeCommands(t, "vim", "view")
|
||||
shellTree(t)
|
||||
c := completer()
|
||||
|
||||
line := []rune("!vi")
|
||||
got, length := c.Do(line, len(line))
|
||||
if length != 2 { // "vi" — the '!' is not part of the word
|
||||
t.Fatalf("length = %d, want 2", length)
|
||||
}
|
||||
// rebuilding the line from prefix + candidate must give the full word
|
||||
for i, g := range got {
|
||||
full := string(line[:len(line)-length]) + string(line[len(line)-length:]) + string(g)
|
||||
if full != "!vim" && full != "!view" {
|
||||
t.Errorf("candidate %d rebuilds to %q", i, full)
|
||||
}
|
||||
}
|
||||
|
||||
// a non-'!' line still goes to the builtin command tree (which appends its
|
||||
// own trailing space on a unique match)
|
||||
line = []rune("stat")
|
||||
got, length = c.Do(line, len(line))
|
||||
if length != 4 || len(got) == 0 || !strings.HasPrefix(string(got[0]), "us") {
|
||||
t.Errorf("builtin completion = %q, %d; want a candidate starting \"us\" at 4", got, length)
|
||||
}
|
||||
|
||||
// a multi-byte prefix must be measured in runes, not bytes
|
||||
if _, n := runeSuffixes([]string{"übermorgen"}, "üb"); n != 2 {
|
||||
t.Errorf("runeSuffixes length = %d, want 2 runes", n)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPathExecutablesFindsRealBinaries checks the PATH scan against a directory
|
||||
// it controls: only files with an execute bit, no directories.
|
||||
func TestPathExecutablesFindsRealBinaries(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(dir, "runnable"), []byte("#!/bin/sh\n"), 0755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(dir, "plainfile"), []byte("x"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Join(dir, "subdir"), 0755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Setenv("PATH", dir)
|
||||
|
||||
// pathExecutables caches for the session, so exercise the scan directly
|
||||
var names []string
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, e := range entries {
|
||||
fi, err := e.Info()
|
||||
if err != nil || fi.IsDir() || fi.Mode().Perm()&0o111 == 0 {
|
||||
continue
|
||||
}
|
||||
names = append(names, e.Name())
|
||||
}
|
||||
if strings.Join(names, ",") != "runnable" {
|
||||
t.Errorf("executable scan = %v, want only runnable", names)
|
||||
}
|
||||
}
|
||||
|
||||
// withAliases installs a fixed alias set for the test.
|
||||
func withAliases(t *testing.T, m map[string]string) {
|
||||
t.Helper()
|
||||
old := aliases
|
||||
aliases = m
|
||||
t.Cleanup(func() { aliases = old })
|
||||
}
|
||||
|
||||
// TestShellCandidatesThroughAlias: an alias that expands to a '!' escape turns
|
||||
// everything after its name into shell arguments, so it completes as such.
|
||||
func TestShellCandidatesThroughAlias(t *testing.T) {
|
||||
shellTree(t)
|
||||
fakeCommands(t, "vi", "ls")
|
||||
withAliases(t, map[string]string{
|
||||
"ll": "!ls -la",
|
||||
"e": "!vi $1",
|
||||
"co": "checkout $1", // expands to a builtin, not a shell command
|
||||
"status": "!git status", // shadows a builtin: must not count
|
||||
})
|
||||
|
||||
// arguments of a shell alias complete against the filesystem
|
||||
if cands, prefix := complete("ll ma"); prefix != "ma" ||
|
||||
strings.Join(cands, ",") != "main.go,main_test.go" {
|
||||
t.Errorf("alias argument = %v (prefix %q)", cands, prefix)
|
||||
}
|
||||
// including the empty one, which lists the directory
|
||||
if cands, _ := complete("e "); strings.Join(cands, ",") != "Makefile,main.go,main_test.go,src/" {
|
||||
t.Errorf("empty alias argument = %v", cands)
|
||||
}
|
||||
// and paths inside it
|
||||
if cands, prefix := complete("ll src/ut"); prefix != "ut" ||
|
||||
strings.Join(cands, ",") != "util.go" {
|
||||
t.Errorf("nested alias argument = %v (prefix %q)", cands, prefix)
|
||||
}
|
||||
|
||||
// the command word of an alias is fixed by its body, so PATH is never
|
||||
// offered — `ll vi` means the file "vi", not the editor
|
||||
if cands, _ := complete("ll vi"); len(cands) != 0 {
|
||||
t.Errorf("alias argument matched PATH: %v", cands)
|
||||
}
|
||||
|
||||
// an alias to a builtin is not a shell line at all
|
||||
if _, _, ok := shellLine("co ma"); ok {
|
||||
t.Error("an alias expanding to a builtin was treated as a shell line")
|
||||
}
|
||||
// nor is a name that a builtin owns, since runCommand never expands those
|
||||
if _, _, ok := shellLine("status ma"); ok {
|
||||
t.Error("a builtin name was resolved through an alias")
|
||||
}
|
||||
// nor an undefined name
|
||||
if _, _, ok := shellLine("nosuch ma"); ok {
|
||||
t.Error("an undefined alias was treated as a shell line")
|
||||
}
|
||||
// while the alias name itself is still being typed there is nothing to know
|
||||
if _, _, ok := shellLine("ll"); ok {
|
||||
t.Error("an incomplete alias name was resolved")
|
||||
}
|
||||
}
|
||||
+1
-3
@@ -42,7 +42,6 @@ func showConfig() {
|
||||
{"gitname", cfg.GitName},
|
||||
{"gitemail", cfg.GitEmail},
|
||||
{"pushdefault", cfg.PushDefault},
|
||||
{"editor", cfg.Editor},
|
||||
{"mirror", cfg.Mirror},
|
||||
{"secretscan", cfg.SecretScan},
|
||||
{"remotes", cfg.RemoteNames},
|
||||
@@ -146,8 +145,7 @@ func envName(key string) string { return "MGSH_" + strings.ToUpper(key) }
|
||||
func configKeys() []string {
|
||||
keys := []string{
|
||||
"base", "githost", "gitport", "gituser", "gitpath", "gitkey",
|
||||
"gitname", "gitemail", "pushdefault", "editor",
|
||||
"remoteurl", "remotekey", "remotetype", "remotevisibility",
|
||||
"gitname", "gitemail", "pushdefault",
|
||||
"remotes", "mirror", "secretscan",
|
||||
}
|
||||
sort.Strings(keys)
|
||||
|
||||
+1
-1
@@ -1 +1 @@
|
||||
4.0.29
|
||||
4.0.58
|
||||
|
||||
Reference in New Issue
Block a user