Initial commit
118 changed files: +18715 −0
- +14 −0 .dockerignore
- +11 −0 .gitignore
- +36 −0 Dockerfile
- +99 −0 README.md
- +18 −0 compose.yaml
- +13 −0 dotnet-tools.json
- +502 −0 forge.Tests/AdvancedMergeTests.cs
- +325 −0 forge.Tests/GitLayerTests.cs
- +87 −0 forge.Tests/InsightsTests.cs
- +227 −0 forge.Tests/LocalizationTests.cs
- +326 −0 forge.Tests/MergeTests.cs
- +340 −0 forge.Tests/ParserTests.cs
- +218 −0 forge.Tests/SmartHttpTests.cs
- +59 −0 forge.Tests/Support/BranchScenario.cs
- +213 −0 forge.Tests/Support/ForgeHost.cs
- +96 −0 forge.Tests/Support/TestGit.cs
- +650 −0 forge.Tests/WebTests.cs
- +199 −0 forge.Tests/WebhookTests.cs
- +29 −0 forge.Tests/forge.Tests.csproj
- +4 −0 forge.slnx
- +25 −0 forge/Components/App.razor
- +32 −0 forge/Components/Avatar.razor
- +29 −0 forge/Components/Breadcrumbs.razor
- +22 −0 forge/Components/CloneBox.razor
- +55 −0 forge/Components/CommitList.razor
- +10 −0 forge/Components/Counter.razor
- +5 −0 forge/Components/Error.razor
- +7 −0 forge/Components/HighlightAssets.razor
- +40 −0 forge/Components/Highlighted.razor
- +59 −0 forge/Components/Icon.razor
- +30 −0 forge/Components/LanguageBar.razor
- +130 −0 forge/Components/MainLayout.razor
- +5 −0 forge/Components/NotFound.razor
- +53 −0 forge/Components/RefSwitcher.razor
- +72 −0 forge/Components/RepoHeader.razor
- +75 −0 forge/Components/RepoPageBase.cs
- +5 −0 forge/Components/Routes.razor
- +27 −0 forge/Components/StatusMessage.razor
- +11 −0 forge/Components/StatusPage.razor
- +8 −0 forge/Components/TimeAgo.razor
- +154 −0 forge/Data/Entities.cs
- +158 −0 forge/Data/ForgeDb.cs
- +333 −0 forge/Data/Migrations/20261115000224_Initial.Designer.cs
- +222 −0 forge/Data/Migrations/20261115000224_Initial.cs
- +525 −0 forge/Data/Migrations/20261115121154_PullRequestsAndBranchProtection.Designer.cs
- +142 −0 forge/Data/Migrations/20261115121154_PullRequestsAndBranchProtection.cs
- +527 −0 forge/Data/Migrations/ForgeDbModelSnapshot.cs
- +36 −0 forge/Features/Auth/AccountRules.cs
- +64 −0 forge/Features/Auth/CurrentUser.cs
- +82 −0 forge/Features/Auth/Login.razor
- +22 −0 forge/Features/Auth/RepoAccess.cs
- +119 −0 forge/Features/Auth/Setup.razor
- +105 −0 forge/Features/Auth/TokenService.cs
- +178 −0 forge/Features/Auth/Tokens.razor
- +168 −0 forge/Features/Browse/Activity.razor
- +193 −0 forge/Features/Browse/Blob.razor
- +34 −0 forge/Features/Browse/ContentCache.cs
- +80 −0 forge/Features/Browse/FileTypes.cs
- +115 −0 forge/Features/Browse/MarkdownRenderer.cs
- +127 −0 forge/Features/Browse/RawEndpoint.cs
- +179 −0 forge/Features/Browse/RepoInsights.cs
- +178 −0 forge/Features/Browse/Search.razor
- +328 −0 forge/Features/Browse/Tree.razor
- +101 −0 forge/Features/History/AtomEndpoint.cs
- +27 −0 forge/Features/History/BranchRules.cs
- +209 −0 forge/Features/History/Branches.razor
- +171 −0 forge/Features/History/Commit.razor
- +104 −0 forge/Features/History/Commits.razor
- +326 −0 forge/Features/History/Compare.razor
- +175 −0 forge/Features/History/Conflicts.razor
- +34 −0 forge/Features/History/DiffOptions.razor
- +156 −0 forge/Features/History/DiffRows.cs
- +208 −0 forge/Features/History/DiffView.razor
- +47 −0 forge/Features/History/MergeFields.razor
- +570 −0 forge/Features/History/RefService.cs
- +165 −0 forge/Features/History/Tags.razor
- +353 −0 forge/Features/Pulls/PullDetail.razor
- +103 −0 forge/Features/Pulls/PullList.razor
- +289 −0 forge/Features/Pulls/PullRequestService.cs
- +17 −0 forge/Features/Pulls/PullStatusBadge.razor
- +151 −0 forge/Features/Repos/BranchProtectionSettings.razor
- +198 −0 forge/Features/Repos/Home.razor
- +78 −0 forge/Features/Repos/NewRepo.razor
- +158 −0 forge/Features/Repos/RepoService.cs
- +196 −0 forge/Features/Repos/RepoSettings.razor
- +164 −0 forge/Features/SmartHttp/PushGuard.cs
- +163 −0 forge/Features/SmartHttp/PushRecorder.cs
- +428 −0 forge/Features/SmartHttp/SmartHttpEndpoints.cs
- +21 −0 forge/Features/Webhooks/DeliveryStatus.razor
- +227 −0 forge/Features/Webhooks/WebhookDetail.razor
- +150 −0 forge/Features/Webhooks/WebhookList.razor
- +202 −0 forge/Features/Webhooks/WebhookSender.cs
- +155 −0 forge/Features/Webhooks/WebhookWorker.cs
- +291 −0 forge/ForgeApp.cs
- +46 −0 forge/ForgeOptions.cs
- +23 −0 forge/Format.cs
- +288 −0 forge/Git/GitCli.cs
- +137 −0 forge/Git/GitModels.cs
- +609 −0 forge/Git/GitParsers.cs
- +558 −0 forge/Git/GitRepo.cs
- +149 −0 forge/Git/RefResolver.cs
- +41 −0 forge/Git/RepoPaths.cs
- +153 −0 forge/Localization/Localizer.cs
- +407 −0 forge/Localization/sk.json
- +17 −0 forge/Program.cs
- +23 −0 forge/Properties/launchSettings.json
- +51 −0 forge/Urls.cs
- +21 −0 forge/_Imports.razor
- +8 −0 forge/appsettings.Development.json
- +16 −0 forge/appsettings.json
- +33 −0 forge/forge.csproj
- +278 −0 forge/wwwroot/app.js
- bin forge/wwwroot/favicon.png
- +10 −0 forge/wwwroot/lib/highlight/github-dark.min.css
- +10 −0 forge/wwwroot/lib/highlight/github.min.css
- +1244 −0 forge/wwwroot/lib/highlight/highlight.min.js
- +706 −0 forge/wwwroot/style.css
- +15 −0 forge/wwwroot/theme.js
added .dockerignore +14 −0View file
| @@ -0,0 +1,14 @@ | ||
| 1 | +**/bin/ | |
| 2 | +**/obj/ | |
| 3 | +.git/ | |
| 4 | +.idea/ | |
| 5 | +.artifacts/ | |
| 6 | +*.user | |
| 7 | +forge.Tests/ | |
| 8 | + | |
| 9 | +# Local runtime data. Listed file by file: forge/Data (source) differs only in case. | |
| 10 | +forge/data/forge.db* | |
| 11 | +forge/data/repos/ | |
| 12 | +forge/data/tmp/ | |
| 13 | +forge/data/keys/ | |
| 14 | +forge/data/.config/ |
added .gitignore +11 −0View file
| @@ -0,0 +1,11 @@ | ||
| 1 | +bin/ | |
| 2 | +obj/ | |
| 3 | +.idea/ | |
| 4 | +*.user | |
| 5 | + | |
| 6 | +# Forge runtime data (SQLite database and bare repositories) | |
| 7 | +forge/data/forge.db* | |
| 8 | +forge/data/repos/ | |
| 9 | +forge/data/tmp/ | |
| 10 | +.artifacts/ | |
| 11 | +forge/data/keys/ |
added Dockerfile +36 −0View file
| @@ -0,0 +1,36 @@ | ||
| 1 | +# syntax=docker/dockerfile:1 | |
| 2 | + | |
| 3 | +# ---- build ---- | |
| 4 | +FROM mcr.microsoft.com/dotnet/sdk:11.0 AS build | |
| 5 | +WORKDIR /src | |
| 6 | + | |
| 7 | +# Restore first so the package layer is cached until the project file changes. | |
| 8 | +COPY forge/forge.csproj forge/ | |
| 9 | +RUN dotnet restore forge/forge.csproj | |
| 10 | + | |
| 11 | +COPY forge/ forge/ | |
| 12 | +RUN dotnet publish forge/forge.csproj -c Release -o /app --no-restore -p:UseAppHost=false | |
| 13 | + | |
| 14 | +# ---- runtime ---- | |
| 15 | +FROM mcr.microsoft.com/dotnet/aspnet:11.0 AS runtime | |
| 16 | + | |
| 17 | +# Forge runs the git executable for everything (needs 2.40+; it checks at startup). | |
| 18 | +RUN apt-get update \ | |
| 19 | + && apt-get install -y --no-install-recommends git ca-certificates \ | |
| 20 | + && rm -rf /var/lib/apt/lists/* | |
| 21 | + | |
| 22 | +WORKDIR /app | |
| 23 | +COPY --from=build /app . | |
| 24 | + | |
| 25 | +# Data folder owned by the image's non-root user, so a fresh named volume inherits that ownership. | |
| 26 | +RUN mkdir -p /data && chown $APP_UID:$APP_UID /data | |
| 27 | +VOLUME /data | |
| 28 | + | |
| 29 | +ENV ASPNETCORE_URLS=http://+:8080 \ | |
| 30 | + ASPNETCORE_ENVIRONMENT=Production \ | |
| 31 | + ASPNETCORE_FORWARDEDHEADERS_ENABLED=true \ | |
| 32 | + Forge__DataPath=/data | |
| 33 | + | |
| 34 | +USER $APP_UID | |
| 35 | +EXPOSE 8080 | |
| 36 | +ENTRYPOINT ["dotnet", "forge.dll"] |
added README.md +99 −0View file
| @@ -0,0 +1,99 @@ | ||
| 1 | +# Forge | |
| 2 | + | |
| 3 | +Forge is a self-hosted Git server with a web interface. It is built with ASP.NET Core (Blazor Server) and uses real bare Git repositories on disk, so any Git client can clone and push to it over HTTP(S). | |
| 4 | + | |
| 5 | +## Features | |
| 6 | + | |
| 7 | +- **Repositories:** create repos, browse files and folders, view blobs with syntax highlighting, and render Markdown previews. | |
| 8 | +- **History:** commit list and commit details, branch and tag pages, compare any two refs, and a file-level diff view. | |
| 9 | +- **Pull requests:** open, review and merge pull requests, with merge-conflict detection (`git merge-tree`) and branch protection rules. | |
| 10 | +- **Search:** find repositories, file names and file contents. | |
| 11 | +- **Activity:** weekly commit counts and contributors per repository. | |
| 12 | +- **Git over HTTP:** clone and push with the smart HTTP protocol. Authentication uses personal access tokens (read-only or read/write). | |
| 13 | +- **Webhooks:** signed deliveries for pushes and pull request events, with delivery status and retries. | |
| 14 | +- **Atom feeds:** commit feeds for each repository. | |
| 15 | +- **Accounts:** sign-up through a first-run setup page, login with rate limiting, and per-user repository access. | |
| 16 | +- **Languages:** English and Slovak. The language is chosen in the footer and remembered in a cookie, with the browser's `Accept-Language` as the fallback. | |
| 17 | + | |
| 18 | +## Requirements | |
| 19 | + | |
| 20 | +- [.NET SDK](https://dotnet.microsoft.com/download) with the version targeted in `forge/forge.csproj` | |
| 21 | +- Git 2.40 or newer (Forge uses `git merge-tree --merge-base`). Forge checks the version at startup and refuses to run with an older one. | |
| 22 | + | |
| 23 | +## Getting started | |
| 24 | + | |
| 25 | +```bash | |
| 26 | +dotnet run --project forge | |
| 27 | +``` | |
| 28 | + | |
| 29 | +The default development profile listens on `http://localhost:5207`. On first run, open `/setup` to create the administrator account. Then create a repository at `/new`. | |
| 30 | + | |
| 31 | +To clone a repository from Forge, use the URL shown on the repository page (`<BaseUrl>/<owner>/<name>.git`). Git asks for credentials: use your username, and a personal access token created at `/settings/tokens` as the password. | |
| 32 | + | |
| 33 | +## Configuration | |
| 34 | + | |
| 35 | +Settings live in `forge/appsettings.json` under the `Forge` section. Any of them can be overridden with environment variables (for example `Forge__BaseUrl`) or with user secrets during development. | |
| 36 | + | |
| 37 | +| Setting | Default | Meaning | | |
| 38 | +| --- | --- | --- | | |
| 39 | +| `Forge:DataPath` | `data` | Folder for `forge.db` and the `repos/` directory. Relative paths resolve against the working directory. | | |
| 40 | +| `Forge:BaseUrl` | `http://localhost:5207` | Public URL of the site. Used for clone URLs, feeds and webhook payloads. Must be an absolute http or https URL. | | |
| 41 | +| `Forge:MaxPushSizeMb` | `500` | Largest push Forge accepts, in megabytes. | | |
| 42 | +| `Forge:GitPath` | `git` | Git executable, a name on `PATH` or an absolute path. | | |
| 43 | + | |
| 44 | +Set `BaseUrl` to the address users actually visit. Using `https://` also makes the session and CSRF cookies `Secure`. | |
| 45 | + | |
| 46 | +## Deploying with Docker | |
| 47 | + | |
| 48 | +The `Dockerfile` builds an image with the app and git, running as a non-root user on port 8080, with all data in the `/data` volume. With Docker Compose: | |
| 49 | + | |
| 50 | +1. Set `Forge__BaseUrl` in `compose.yaml` to the public address of the server. | |
| 51 | +2. Run `docker compose up -d --build`. | |
| 52 | +3. Open `/setup` to create the administrator account. | |
| 53 | + | |
| 54 | +`compose.yaml` publishes the port on `127.0.0.1` only, for a reverse proxy that terminates HTTPS. Forwarded headers (`X-Forwarded-For`, `X-Forwarded-Proto`) are honored, so rate limiting sees real client addresses. Allow request bodies as large as `Forge:MaxPushSizeMb` in the proxy (for nginx, `client_max_body_size`), and pass WebSocket upgrades through, which Blazor Server uses. | |
| 55 | + | |
| 56 | +To update, pull the new code and run `docker compose up -d --build` again. Migrations run at startup. | |
| 57 | + | |
| 58 | +## Data and storage | |
| 59 | + | |
| 60 | +- `forge.db` is a SQLite database managed with Entity Framework Core. Migrations run automatically at startup. | |
| 61 | +- `repos/` holds the bare Git repositories. | |
| 62 | +- `keys/` holds the keys that protect login cookies. Losing them signs everyone out. | |
| 63 | +- Both live under `Forge:DataPath`. Back up that folder to back up the server. | |
| 64 | + | |
| 65 | +## Project layout | |
| 66 | + | |
| 67 | +``` | |
| 68 | +forge/ ASP.NET Core application | |
| 69 | + Components/ Shared Blazor components and layout | |
| 70 | + Features/ Feature folders: Auth, Browse, History, Pulls, Repos, SmartHttp, Webhooks | |
| 71 | + Git/ Thin wrapper around the git executable and its output parsers | |
| 72 | + Data/ EF Core model, DbContext and migrations | |
| 73 | + Localization/ Translation files (sk.json; English is the source language) | |
| 74 | + wwwroot/ Static assets (CSS, JavaScript, syntax highlighting) | |
| 75 | +forge.Tests/ xUnit tests, including end-to-end tests that run the app and real Git | |
| 76 | +``` | |
| 77 | + | |
| 78 | +## Development | |
| 79 | + | |
| 80 | +```bash | |
| 81 | +dotnet build forge.slnx | |
| 82 | +dotnet test forge.Tests | |
| 83 | +``` | |
| 84 | + | |
| 85 | +Adding a language means adding a JSON file to `forge/Localization/`, named after its culture code (for example `de.json`). Keys are the English strings exactly as they appear in the code. | |
| 86 | + | |
| 87 | +Database schema changes are made with the EF Core tools in `dotnet-tools.json`: | |
| 88 | + | |
| 89 | +```bash | |
| 90 | +dotnet ef migrations add <Name> --project forge | |
| 91 | +``` | |
| 92 | + | |
| 93 | +## Security notes | |
| 94 | + | |
| 95 | +- Passwords are hashed with ASP.NET Core Identity's `PasswordHasher`. | |
| 96 | +- Access tokens are used as the Git password. Read-only tokens cannot push. | |
| 97 | +- Responses set a strict Content-Security-Policy, `X-Frame-Options: DENY` and `nosniff`. | |
| 98 | +- Form posts are rate limited per client address. Rendered Markdown is sanitized. | |
| 99 | +- Webhook receivers are not followed on redirect, so signed payloads are never re-sent to another address. |
added compose.yaml +18 −0View file
| @@ -0,0 +1,18 @@ | ||
| 1 | +services: | |
| 2 | + forge: | |
| 3 | + build: . | |
| 4 | + image: forge | |
| 5 | + restart: unless-stopped | |
| 6 | + ports: | |
| 7 | + # Only on localhost: put a reverse proxy (Caddy, nginx, Traefik) in front for HTTPS. | |
| 8 | + # Use "8080:8080" instead to expose it directly. | |
| 9 | + - "127.0.0.1:8080:8080" | |
| 10 | + environment: | |
| 11 | + # The address users actually visit. https:// also makes cookies Secure. | |
| 12 | + Forge__BaseUrl: https://git.example.com | |
| 13 | + Forge__MaxPushSizeMb: 500 | |
| 14 | + volumes: | |
| 15 | + - forge-data:/data | |
| 16 | + | |
| 17 | +volumes: | |
| 18 | + forge-data: |
added dotnet-tools.json +13 −0View file
| @@ -0,0 +1,13 @@ | ||
| 1 | +{ | |
| 2 | + "version": 1, | |
| 3 | + "isRoot": true, | |
| 4 | + "tools": { | |
| 5 | + "dotnet-ef": { | |
| 6 | + "version": "11.0.0", | |
| 7 | + "commands": [ | |
| 8 | + "dotnet-ef" | |
| 9 | + ], | |
| 10 | + "rollForward": false | |
| 11 | + } | |
| 12 | + } | |
| 13 | +} | |
| No newline at end of file |
added forge.Tests/AdvancedMergeTests.cs +502 −0View file
| @@ -0,0 +1,502 @@ | ||
| 1 | +using System.Net; | |
| 2 | +using System.Text; | |
| 3 | +using Forge.Data; | |
| 4 | +using Forge.Features.History; | |
| 5 | +using Forge.Features.SmartHttp; | |
| 6 | +using Forge.Tests.Support; | |
| 7 | +using Microsoft.EntityFrameworkCore; | |
| 8 | +using Microsoft.Extensions.DependencyInjection; | |
| 9 | + | |
| 10 | +namespace Forge.Tests; | |
| 11 | + | |
| 12 | +public class DiffRowTests | |
| 13 | +{ | |
| 14 | + [Fact] | |
| 15 | + public void Compare_marks_what_lies_between_the_common_start_and_end() | |
| 16 | + { | |
| 17 | + var (old, @new) = DiffRows.Compare(" var total = count + 1;", " var total = count + 20;"); | |
| 18 | + Assert.Equal(new ChangeRange(24, 25), old); | |
| 19 | + Assert.Equal(new ChangeRange(24, 26), @new); | |
| 20 | + | |
| 21 | + // A pure insertion leaves an empty range on the old side. | |
| 22 | + (old, @new) = DiffRows.Compare("call(a);", "call(a, b);"); | |
| 23 | + Assert.Equal(new ChangeRange(6, 6), old); | |
| 24 | + Assert.Equal(new ChangeRange(6, 9), @new); | |
| 25 | + } | |
| 26 | + | |
| 27 | + [Fact] | |
| 28 | + public void Compare_gives_up_when_only_indentation_is_shared() | |
| 29 | + { | |
| 30 | + Assert.Equal((null, null), DiffRows.Compare(" left", " north")); | |
| 31 | + Assert.Equal((null, null), DiffRows.Compare("same", "same")); | |
| 32 | + Assert.Equal((null, null), DiffRows.Compare("abc", "xyz")); | |
| 33 | + } | |
| 34 | + | |
| 35 | + [Fact] | |
| 36 | + public void Pair_lines_up_removed_and_added_lines() | |
| 37 | + { | |
| 38 | + var hunk = new Git.DiffHunk { Header = "@@ -1,4 +1,4 @@" }; | |
| 39 | + hunk.Lines.AddRange( | |
| 40 | + [ | |
| 41 | + new(Git.DiffLineKind.Context, 1, 1, "keep"), | |
| 42 | + new(Git.DiffLineKind.Deleted, 2, null, "old a"), | |
| 43 | + new(Git.DiffLineKind.Deleted, 3, null, "old b"), | |
| 44 | + new(Git.DiffLineKind.Added, null, 2, "new a"), | |
| 45 | + new(Git.DiffLineKind.NoNewline, null, null, ""), | |
| 46 | + new(Git.DiffLineKind.Context, 4, 3, "end"), | |
| 47 | + ]); | |
| 48 | + | |
| 49 | + var rows = DiffRows.Pair(hunk); | |
| 50 | + | |
| 51 | + Assert.Equal(4, rows.Count); | |
| 52 | + Assert.Equal(("keep", "keep"), (rows[0].Left!.Line.Text, rows[0].Right!.Line.Text)); | |
| 53 | + Assert.Equal(("old a", "new a"), (rows[1].Left!.Line.Text, rows[1].Right!.Line.Text)); | |
| 54 | + Assert.NotNull(rows[1].Left!.Change); | |
| 55 | + Assert.Equal("old b", rows[2].Left!.Line.Text); | |
| 56 | + Assert.Null(rows[2].Right); | |
| 57 | + Assert.Equal("end", rows[3].Right!.Line.Text); | |
| 58 | + } | |
| 59 | +} | |
| 60 | + | |
| 61 | +public class PushGuardTests | |
| 62 | +{ | |
| 63 | + private static byte[] Request(params string[] commands) | |
| 64 | + { | |
| 65 | + var body = new MemoryStream(); | |
| 66 | + foreach (var command in commands) | |
| 67 | + { | |
| 68 | + body.Write(SmartHttpEndpoints.PktLine(command)); | |
| 69 | + } | |
| 70 | + | |
| 71 | + body.Write("0000PACK...rest of the push"u8); | |
| 72 | + return body.ToArray(); | |
| 73 | + } | |
| 74 | + | |
| 75 | + [Fact] | |
| 76 | + public async Task Command_list_is_read_and_the_stream_replays_everything() | |
| 77 | + { | |
| 78 | + var a = new string('a', 40); | |
| 79 | + var b = new string('b', 40); | |
| 80 | + var request = Request($"{a} {b} refs/heads/main\0report-status side-band-64k\n", $"{b} {a} refs/tags/v1\n"); | |
| 81 | + | |
| 82 | + var (refs, consumed, understood) = await PushGuard.ReadCommandsAsync(new MemoryStream(request), default); | |
| 83 | + Assert.True(understood); | |
| 84 | + Assert.Equal(["refs/heads/main", "refs/tags/v1"], refs); | |
| 85 | + Assert.EndsWith("0000", Encoding.ASCII.GetString(consumed)); | |
| 86 | + | |
| 87 | + BranchProtection[] rules = [new() { Pattern = "main" }, new() { Pattern = "release/*", BlockPush = true }]; | |
| 88 | + var (input, options) = await PushGuard.InspectAsync(new MemoryStream(request), rules, default); | |
| 89 | + Assert.Equal( | |
| 90 | + ["-c", "receive.hideRefs=refs/heads/release/", "-c", "receive.denyNonFastForwards=true", "-c", "receive.denyDeletes=true"], | |
| 91 | + options); | |
| 92 | + var replayed = new MemoryStream(); | |
| 93 | + await input.CopyToAsync(replayed); | |
| 94 | + Assert.Equal(request, replayed.ToArray()); | |
| 95 | + } | |
| 96 | + | |
| 97 | + [Fact] | |
| 98 | + public async Task Pushes_that_miss_protected_branches_are_left_alone_and_garbage_fails_closed() | |
| 99 | + { | |
| 100 | + var a = new string('a', 40); | |
| 101 | + BranchProtection[] rules = [new() { Pattern = "main" }]; | |
| 102 | + | |
| 103 | + var (_, options) = await PushGuard.InspectAsync(new MemoryStream(Request($"{a} {a} refs/heads/topic\n")), rules, default); | |
| 104 | + Assert.Empty(options); | |
| 105 | + | |
| 106 | + (_, options) = await PushGuard.InspectAsync(new MemoryStream("zzzz not pkt-lines"u8.ToArray()), rules, default); | |
| 107 | + Assert.Contains("receive.denyNonFastForwards=true", options); | |
| 108 | + } | |
| 109 | + | |
| 110 | + [Theory] | |
| 111 | + [InlineData("main", "main", true)] | |
| 112 | + [InlineData("main", "main2", false)] | |
| 113 | + [InlineData("main", "feature/main", false)] | |
| 114 | + [InlineData("release/*", "release/1.0", true)] | |
| 115 | + [InlineData("release/*", "release/1.0/hotfix", true)] | |
| 116 | + [InlineData("release/*", "release", false)] | |
| 117 | + [InlineData("release/*", "releases/1.0", false)] | |
| 118 | + public void Protection_patterns_match_names_and_prefixes(string pattern, string branch, bool expected) => | |
| 119 | + Assert.Equal(expected, BranchRules.Matches(pattern, branch)); | |
| 120 | +} | |
| 121 | + | |
| 122 | +public class AdvancedMergeTests(ForgeHost host) : IClassFixture<ForgeHost> | |
| 123 | +{ | |
| 124 | + private Task<T> DbAsync<T>(Func<ForgeDb, Task<T>> query) => | |
| 125 | + host.WithScopeAsync(sp => query(sp.GetRequiredService<ForgeDb>())); | |
| 126 | + | |
| 127 | + [Fact] | |
| 128 | + public async Task Diff_has_a_file_index_side_by_side_layout_and_within_line_changes() | |
| 129 | + { | |
| 130 | + var s = await BranchScenario.CreateAsync(host, "diff-view", diverge: true); | |
| 131 | + using var client = host.CreateClient(); | |
| 132 | + var url = s.Page("compare/main...feature/x"); | |
| 133 | + | |
| 134 | + var unified = await client.GetStringAsync(url); | |
| 135 | + Assert.Contains("href=\"#diff-0\"", unified); | |
| 136 | + Assert.Contains("id=\"diff-1\"", unified); | |
| 137 | + Assert.DoesNotContain("class=\"diff split\"", unified); | |
| 138 | + // "two" became "TWO from feature": nothing but indentation-free text in common, so the whole line is the change. | |
| 139 | + Assert.Contains($"href=\"/jessie/diff-view/blob/{s.FeatureSha}/b.txt\"", unified); | |
| 140 | + Assert.Contains("/lib/highlight/highlight.min.js", unified); | |
| 141 | + Assert.Contains("href=\"" + url + "?view=split\"", unified); | |
| 142 | + | |
| 143 | + var split = await client.GetStringAsync(url + "?view=split"); | |
| 144 | + Assert.Contains("class=\"diff split\"", split); | |
| 145 | + Assert.Contains("TWO from feature", split); | |
| 146 | + // The other options keep the chosen layout. | |
| 147 | + Assert.Contains("href=\"" + url + "?view=split&w=1\"", split); | |
| 148 | + Assert.Contains("href=\"/jessie/diff-view/compare/main..feature/x?view=split\"", split); | |
| 149 | + | |
| 150 | + // Two dots compare the tips directly, so main's own file shows up (as removed); three dots leave it out. | |
| 151 | + var direct = await client.GetStringAsync(s.Page("compare/main..feature/x")); | |
| 152 | + Assert.Contains("only on main", direct); | |
| 153 | + Assert.DoesNotContain("only on main", unified); | |
| 154 | + } | |
| 155 | + | |
| 156 | + [Fact] | |
| 157 | + public async Task Commit_page_marks_the_changed_part_of_a_line_and_can_ignore_whitespace() | |
| 158 | + { | |
| 159 | + var s = await BranchScenario.CreateAsync(host, "intraline"); | |
| 160 | + await File.WriteAllTextAsync(Path.Combine(s.Work, "calc.cs"), "class Calc\n{\n int total = count + 1;\n}\n"); | |
| 161 | + await host.Git.MustAsync(s.Work, "add", "-A"); | |
| 162 | + await host.Git.MustAsync(s.Work, "commit", "-m", "Add calc"); | |
| 163 | + await File.WriteAllTextAsync(Path.Combine(s.Work, "calc.cs"), "class Calc\n{\n int total = count + 20;\n}\n"); | |
| 164 | + await host.Git.MustAsync(s.Work, "commit", "-am", "Change the increment"); | |
| 165 | + var changed = await host.Git.MustAsync(s.Work, "rev-parse", "HEAD"); | |
| 166 | + await File.WriteAllTextAsync(Path.Combine(s.Work, "calc.cs"), "class Calc\n{\n int total = count + 20;\n}\n"); | |
| 167 | + await host.Git.MustAsync(s.Work, "commit", "-am", "Reindent"); | |
| 168 | + var reindented = await host.Git.MustAsync(s.Work, "rev-parse", "HEAD"); | |
| 169 | + await host.Git.MustAsync(s.Work, "push", s.Url, "main"); | |
| 170 | + using var client = host.CreateClient(); | |
| 171 | + | |
| 172 | + var page = await client.GetStringAsync(s.Page($"commit/{changed}")); | |
| 173 | + Assert.Contains("data-lang=\"csharp\"", page); | |
| 174 | + Assert.Contains("<span class=\"chg\">1</span>", page); | |
| 175 | + Assert.Contains("<span class=\"chg\">20</span>", page); | |
| 176 | + Assert.Contains("data-cs=\"24\" data-ce=\"26\"", page); | |
| 177 | + | |
| 178 | + var withWhitespace = await ForgeHost.TextAsync(await client.GetAsync(s.Page($"commit/{reindented}"))); | |
| 179 | + Assert.Contains("1 changed file", withWhitespace); | |
| 180 | + var ignoring = await ForgeHost.TextAsync(await client.GetAsync(s.Page($"commit/{reindented}?w=1"))); | |
| 181 | + Assert.Contains("0 changed files", ignoring); | |
| 182 | + } | |
| 183 | + | |
| 184 | + [Fact] | |
| 185 | + public async Task Rebase_replays_the_commits_on_top_of_the_base_keeping_their_authors() | |
| 186 | + { | |
| 187 | + var s = await BranchScenario.CreateAsync(host, "rebase", diverge: true); | |
| 188 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 189 | + | |
| 190 | + var merged = await ForgeHost.PostFormAsync(owner, s.Page("compare/main...feature/x"), "merge", new() { ["Method"] = "rebase" }); | |
| 191 | + Assert.Equal(HttpStatusCode.Redirect, merged.StatusCode); | |
| 192 | + | |
| 193 | + var log = (await s.ServerAsync("log", "--format=%s|%an|%cn|%P", "server/main")).Split('\n'); | |
| 194 | + Assert.Equal(4, log.Length); | |
| 195 | + Assert.StartsWith("More feature work|Test Author|jessie|", log[0]); | |
| 196 | + Assert.StartsWith("Feature work|Test Author|jessie|", log[1]); | |
| 197 | + Assert.Equal($"Main moves on|Test Author|Test Author|{await host.Git.MustAsync(s.Work, "rev-parse", s.MainSha + "~1")}", log[2]); | |
| 198 | + // Linear: every commit has exactly one parent, and the feature's first commit now sits on main's tip. | |
| 199 | + Assert.EndsWith("|" + s.MainSha, log[1]); | |
| 200 | + Assert.All(log.Take(3), line => Assert.DoesNotContain(' ', line.Split('|')[3])); | |
| 201 | + Assert.Equal("new file\nsecond line", await host.Git.MustAsync(s.Work, "show", "server/main:b.txt")); | |
| 202 | + Assert.Equal("only on main", await host.Git.MustAsync(s.Work, "show", "server/main:c.txt")); | |
| 203 | + // The feature branch itself is not rewritten. | |
| 204 | + Assert.Equal(s.FeatureSha, await host.Git.MustAsync(s.Work, "rev-parse", "server/feature/x")); | |
| 205 | + } | |
| 206 | + | |
| 207 | + [Fact] | |
| 208 | + public async Task Commits_can_be_reverted_and_cherry_picked_from_their_page() | |
| 209 | + { | |
| 210 | + var s = await BranchScenario.CreateAsync(host, "apply", diverge: true); | |
| 211 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 212 | + using var anonymous = host.CreateClient(); | |
| 213 | + var featureFirst = await host.Git.MustAsync(s.Work, "rev-parse", s.FeatureSha + "~1"); | |
| 214 | + | |
| 215 | + // Cherry-pick the feature's first commit onto main. | |
| 216 | + var picked = await ForgeHost.PostFormAsync(owner, s.Page($"commit/{featureFirst}"), "apply-commit", new() { ["Branch"] = "main", ["Action"] = "pick" }); | |
| 217 | + Assert.Equal(HttpStatusCode.Redirect, picked.StatusCode); | |
| 218 | + Assert.Equal("Feature work|Test Author|jessie", await s.ServerAsync("log", "-1", "--format=%s|%an|%cn", "server/main")); | |
| 219 | + Assert.Contains($"(cherry picked from commit {featureFirst})", await host.Git.MustAsync(s.Work, "log", "-1", "--format=%B", "server/main")); | |
| 220 | + Assert.Equal("new file", await host.Git.MustAsync(s.Work, "show", "server/main:b.txt")); | |
| 221 | + var pickedSha = await host.Git.MustAsync(s.Work, "rev-parse", "server/main"); | |
| 222 | + | |
| 223 | + // Picking it again changes nothing and says so. | |
| 224 | + var again = await ForgeHost.PostFormAsync(owner, s.Page($"commit/{featureFirst}"), "apply-commit", new() { ["Branch"] = "main", ["Action"] = "pick" }); | |
| 225 | + Assert.Contains("already contains this change", await ForgeHost.TextAsync(again)); | |
| 226 | + | |
| 227 | + // Revert it. | |
| 228 | + var reverted = await ForgeHost.PostFormAsync(owner, s.Page($"commit/{pickedSha}"), "apply-commit", new() { ["Branch"] = "main", ["Action"] = "revert" }); | |
| 229 | + Assert.Equal(HttpStatusCode.Redirect, reverted.StatusCode); | |
| 230 | + Assert.Equal("Revert \"Feature work\"", await s.ServerAsync("log", "-1", "--format=%s", "server/main")); | |
| 231 | + Assert.Equal("a.txt\nc.txt", await host.Git.MustAsync(s.Work, "ls-tree", "--name-only", "server/main")); | |
| 232 | + Assert.Equal("one\ntwo\nthree", await host.Git.MustAsync(s.Work, "show", "server/main:a.txt")); | |
| 233 | + | |
| 234 | + // A change that does not apply cleanly is refused with the files named. | |
| 235 | + var conflicting = await BranchScenario.CreateAsync(host, "apply-conflict", diverge: true, conflict: true); | |
| 236 | + var first = await host.Git.MustAsync(conflicting.Work, "rev-parse", conflicting.FeatureSha + "~1"); | |
| 237 | + var refused = await ForgeHost.PostFormAsync(owner, conflicting.Page($"commit/{first}"), "apply-commit", new() { ["Branch"] = "main", ["Action"] = "pick" }); | |
| 238 | + var refusedHtml = await ForgeHost.TextAsync(refused); | |
| 239 | + Assert.Contains("cannot be applied automatically", refusedHtml); | |
| 240 | + Assert.Contains("<code>a.txt</code>", refusedHtml); | |
| 241 | + Assert.Equal(conflicting.MainSha, await conflicting.ServerAsync("rev-parse", "server/main")); | |
| 242 | + | |
| 243 | + // Visitors get neither the form nor the effect. | |
| 244 | + Assert.DoesNotContain("apply-commit", await anonymous.GetStringAsync(s.Page($"commit/{s.FeatureSha}"))); | |
| 245 | + var sneaky = await ForgeHost.PostFormAsync(anonymous, s.Page($"commit/{s.FeatureSha}"), "apply-commit", new() { ["Branch"] = "main", ["Action"] = "pick" }); | |
| 246 | + Assert.False(sneaky.IsSuccessStatusCode); | |
| 247 | + } | |
| 248 | + | |
| 249 | + [Fact] | |
| 250 | + public async Task Conflicts_are_resolved_in_the_browser() | |
| 251 | + { | |
| 252 | + var s = await BranchScenario.CreateAsync(host, "resolve", diverge: true, conflict: true); | |
| 253 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 254 | + using var anonymous = host.CreateClient(); | |
| 255 | + var url = s.Page("conflicts/main...feature/x"); | |
| 256 | + | |
| 257 | + Assert.Contains("href=\"/jessie/resolve/conflicts/main...feature/x\"", await owner.GetStringAsync(s.Page("compare/main...feature/x"))); | |
| 258 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync(url)).StatusCode); | |
| 259 | + | |
| 260 | + var page = await ForgeHost.TextAsync(await owner.GetAsync(url)); | |
| 261 | + Assert.Contains("<code>a.txt</code>", page); | |
| 262 | + Assert.Contains("<<<<<<< ", page); | |
| 263 | + Assert.Contains("TWO from main", page); | |
| 264 | + Assert.Contains("TWO from feature", page); | |
| 265 | + | |
| 266 | + Dictionary<string, string> Form(string choice, string text = "") => new() | |
| 267 | + { | |
| 268 | + ["base_sha"] = s.MainSha, | |
| 269 | + ["head_sha"] = s.FeatureSha, | |
| 270 | + ["choice_0"] = choice, | |
| 271 | + ["text_0"] = text, | |
| 272 | + ["message"] = "", | |
| 273 | + }; | |
| 274 | + | |
| 275 | + // Leftover markers are refused. | |
| 276 | + var leftover = await ForgeHost.PostFormAsync(owner, url, "resolve", Form("edit", "one\r\n<<<<<<< main\r\nTWO\r\n>>>>>>> feature\r\nthree\r\n")); | |
| 277 | + Assert.Contains("still contains conflict markers", await ForgeHost.TextAsync(leftover)); | |
| 278 | + | |
| 279 | + // A stale page (the branch moved since) is refused. | |
| 280 | + var stale = Form("ours"); | |
| 281 | + stale["base_sha"] = s.FeatureSha; | |
| 282 | + Assert.Contains("changed in the meantime", await ForgeHost.TextAsync(await ForgeHost.PostFormAsync(owner, url, "resolve", stale))); | |
| 283 | + Assert.Equal(s.MainSha, await s.ServerAsync("rev-parse", "server/main")); | |
| 284 | + | |
| 285 | + // An edited resolution: browsers send CRLF, the file keeps its LF endings. | |
| 286 | + var resolved = await ForgeHost.PostFormAsync(owner, url, "resolve", Form("edit", "one\r\nTWO from both\r\nthree\r\n")); | |
| 287 | + Assert.Equal(HttpStatusCode.Redirect, resolved.StatusCode); | |
| 288 | + Assert.Equal($"{s.MainSha} {s.FeatureSha}", await s.ServerAsync("log", "-1", "--format=%P", "server/main")); | |
| 289 | + var bytes = await host.Git.RunAsync(s.Work, "cat-file", "blob", "server/main:a.txt"); | |
| 290 | + Assert.Equal("one\nTWO from both\nthree\n", bytes.StdOut); | |
| 291 | + // The non-conflicting part of the merge came along. | |
| 292 | + Assert.Equal("new file\nsecond line", await host.Git.MustAsync(s.Work, "show", "server/main:b.txt")); | |
| 293 | + | |
| 294 | + // Taking one side wholesale. | |
| 295 | + var theirs = await BranchScenario.CreateAsync(host, "resolve-theirs", diverge: true, conflict: true); | |
| 296 | + var taken = await ForgeHost.PostFormAsync(owner, theirs.Page("conflicts/main...feature/x"), "resolve", new() | |
| 297 | + { | |
| 298 | + ["base_sha"] = theirs.MainSha, | |
| 299 | + ["head_sha"] = theirs.FeatureSha, | |
| 300 | + ["choice_0"] = "theirs", | |
| 301 | + ["message"] = "Take the feature's version", | |
| 302 | + }); | |
| 303 | + Assert.Equal(HttpStatusCode.Redirect, taken.StatusCode); | |
| 304 | + Assert.Equal("Take the feature's version", await theirs.ServerAsync("log", "-1", "--format=%s", "server/main")); | |
| 305 | + Assert.Equal("one\nTWO from feature\nthree", await host.Git.MustAsync(theirs.Work, "show", "server/main:a.txt")); | |
| 306 | + } | |
| 307 | + | |
| 308 | + [Fact] | |
| 309 | + public async Task Pull_request_goes_from_open_to_merged_with_comments() | |
| 310 | + { | |
| 311 | + var s = await BranchScenario.CreateAsync(host, "pulls", diverge: true); | |
| 312 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 313 | + using var anonymous = host.CreateClient(); | |
| 314 | + var compare = s.Page("compare/main...feature/x"); | |
| 315 | + | |
| 316 | + // Opened from the compare page. | |
| 317 | + var opened = await ForgeHost.PostFormAsync(owner, compare, "open-pull", new() | |
| 318 | + { | |
| 319 | + ["Title"] = "Add the feature", | |
| 320 | + ["Description"] = "Adds **b.txt**.\n\n<script>alert(1)</script>", | |
| 321 | + }); | |
| 322 | + Assert.Equal("/jessie/pulls/pull/1", opened.Headers.Location?.PathAndQuery); | |
| 323 | + | |
| 324 | + // A second one for the same branches is refused, and the compare page points at the first. | |
| 325 | + var duplicate = await ForgeHost.PostFormAsync(owner, s.Page("compare/main..feature/x"), "open-pull", new() { ["Title"] = "Again" }); | |
| 326 | + Assert.False(duplicate.IsSuccessStatusCode && (await ForgeHost.TextAsync(duplicate)).Contains("Again")); | |
| 327 | + Assert.Contains("href=\"/jessie/pulls/pull/1\"", await owner.GetStringAsync(compare)); | |
| 328 | + | |
| 329 | + // Everyone who can read the repository can read the pull request. | |
| 330 | + var page = await ForgeHost.TextAsync(await anonymous.GetAsync(s.Page("pull/1"))); | |
| 331 | + Assert.Contains("Add the feature", page); | |
| 332 | + Assert.Contains("<strong>b.txt</strong>", page); | |
| 333 | + Assert.DoesNotContain("<script>alert(1)</script>", page); | |
| 334 | + Assert.Contains("More feature work", page); | |
| 335 | + Assert.Contains("TWO from feature", page); | |
| 336 | + Assert.Contains("2 commits", page); | |
| 337 | + Assert.DoesNotContain("name=\"Method\"", page); | |
| 338 | + Assert.Contains("Add the feature", await anonymous.GetStringAsync(s.Page("pulls"))); | |
| 339 | + | |
| 340 | + // Only the owner comments. | |
| 341 | + await ForgeHost.PostFormAsync(anonymous, s.Page("pull/1"), "comment", new() { ["Body"] = "drive-by" }); | |
| 342 | + var commented = await ForgeHost.PostFormAsync(owner, s.Page("pull/1"), "comment", new() { ["Body"] = "Looks *good*." }); | |
| 343 | + var commentedHtml = await ForgeHost.TextAsync(commented); | |
| 344 | + Assert.Contains("<em>good</em>", commentedHtml); | |
| 345 | + Assert.Contains("1 comment", commentedHtml); | |
| 346 | + Assert.DoesNotContain("drive-by", commentedHtml); | |
| 347 | + | |
| 348 | + // Close and reopen. | |
| 349 | + var closed = await ForgeHost.PostFormAsync(owner, s.Page("pull/1"), "pull-state", new() { ["Action"] = "close" }); | |
| 350 | + Assert.DoesNotContain("name=\"Method\"", await ForgeHost.TextAsync(closed)); | |
| 351 | + Assert.Equal(PullRequestStatus.Closed, (await DbAsync(db => db.PullRequests.SingleAsync(p => p.RepoId == s.Repo.Id))).Status); | |
| 352 | + Assert.Contains("Add the feature", await anonymous.GetStringAsync(s.Page("pulls?state=closed"))); | |
| 353 | + // A closed pull request still shows what it proposed. | |
| 354 | + Assert.Contains("TWO from feature", await anonymous.GetStringAsync(s.Page("pull/1"))); | |
| 355 | + var reopened = await ForgeHost.PostFormAsync(owner, s.Page("pull/1"), "pull-state", new() { ["Action"] = "reopen" }); | |
| 356 | + Assert.Contains("name=\"Method\"", await ForgeHost.TextAsync(reopened)); | |
| 357 | + | |
| 358 | + // Merge with a squash and delete the branch. | |
| 359 | + var merged = await ForgeHost.PostFormAsync(owner, s.Page("pull/1"), "merge", new() | |
| 360 | + { | |
| 361 | + ["Method"] = "squash", | |
| 362 | + ["Message"] = "Add the feature (#1)", | |
| 363 | + ["DeleteBranch"] = "true", | |
| 364 | + }); | |
| 365 | + var mergedHtml = await ForgeHost.TextAsync(merged); | |
| 366 | + Assert.Contains("Merged into main.", mergedHtml); | |
| 367 | + Assert.DoesNotContain("name=\"Method\"", mergedHtml); | |
| 368 | + | |
| 369 | + var pull = await DbAsync(db => db.PullRequests.SingleAsync(p => p.RepoId == s.Repo.Id)); | |
| 370 | + Assert.Equal(PullRequestStatus.Merged, pull.Status); | |
| 371 | + Assert.Equal(s.FeatureSha, pull.HeadSha); | |
| 372 | + Assert.Equal(pull.MergeCommitSha, await s.ServerAsync("rev-parse", "server/main")); | |
| 373 | + Assert.Equal("Add the feature (#1)", await host.Git.MustAsync(s.Work, "log", "-1", "--format=%s", "server/main")); | |
| 374 | + Assert.DoesNotContain("server/feature/x", await host.Git.MustAsync(s.Work, "branch", "-r")); | |
| 375 | + | |
| 376 | + // The branch is gone, but the merged pull request keeps its commits and diff. | |
| 377 | + var after = await anonymous.GetStringAsync(s.Page("pull/1")); | |
| 378 | + Assert.Contains("More feature work", after); | |
| 379 | + Assert.Contains("TWO from feature", after); | |
| 380 | + | |
| 381 | + // Title and description can be corrected afterwards; visitors cannot do it. | |
| 382 | + await ForgeHost.PostFormAsync(anonymous, s.Page("pull/1"), "edit-pull", new() { ["Title"] = "Hijacked" }); | |
| 383 | + var edited = await ForgeHost.PostFormAsync(owner, s.Page("pull/1"), "edit-pull", new() { ["Title"] = "Add the feature, renamed", ["Description"] = "New *text*." }); | |
| 384 | + var editedHtml = await ForgeHost.TextAsync(edited); | |
| 385 | + Assert.Contains("Add the feature, renamed", editedHtml); | |
| 386 | + Assert.Contains("<em>text</em>", editedHtml); | |
| 387 | + Assert.DoesNotContain("Hijacked", editedHtml); | |
| 388 | + | |
| 389 | + // Private repositories keep their pull requests to themselves. | |
| 390 | + var secret = await BranchScenario.CreateAsync(host, "pulls-private", visibility: Visibility.Private); | |
| 391 | + await ForgeHost.PostFormAsync(owner, secret.Page("compare/main...feature/x"), "open-pull", new() { ["Title"] = "Secret" }); | |
| 392 | + Assert.Equal(HttpStatusCode.OK, (await owner.GetAsync(secret.Page("pull/1"))).StatusCode); | |
| 393 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync(secret.Page("pull/1"))).StatusCode); | |
| 394 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync(secret.Page("pulls"))).StatusCode); | |
| 395 | + Assert.Equal(HttpStatusCode.NotFound, (await owner.GetAsync(s.Page("pull/99"))).StatusCode); | |
| 396 | + } | |
| 397 | + | |
| 398 | + [Fact] | |
| 399 | + public async Task Pull_request_notices_a_merge_made_with_git() | |
| 400 | + { | |
| 401 | + var s = await BranchScenario.CreateAsync(host, "pulls-external", diverge: true); | |
| 402 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 403 | + await ForgeHost.PostFormAsync(owner, s.Page("compare/main...feature/x"), "open-pull", new() { ["Title"] = "Merged elsewhere" }); | |
| 404 | + | |
| 405 | + await host.Git.MustAsync(s.Work, "merge", "--no-ff", "-m", "Merge locally", "feature/x"); | |
| 406 | + await host.Git.MustAsync(s.Work, "push", s.Url, "main"); | |
| 407 | + | |
| 408 | + Assert.Contains("Merged into main.", await ForgeHost.TextAsync(await owner.GetAsync(s.Page("pull/1")))); | |
| 409 | + Assert.Equal(PullRequestStatus.Merged, (await DbAsync(db => db.PullRequests.SingleAsync(p => p.RepoId == s.Repo.Id))).Status); | |
| 410 | + } | |
| 411 | + | |
| 412 | + [Fact] | |
| 413 | + public async Task Conflicting_pull_request_is_merged_through_the_conflict_page() | |
| 414 | + { | |
| 415 | + var s = await BranchScenario.CreateAsync(host, "pulls-conflict", diverge: true, conflict: true); | |
| 416 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 417 | + await ForgeHost.PostFormAsync(owner, s.Page("compare/main...feature/x"), "open-pull", new() { ["Title"] = "Needs a hand" }); | |
| 418 | + | |
| 419 | + var page = await owner.GetStringAsync(s.Page("pull/1")); | |
| 420 | + Assert.Contains("These branches have conflicts.", page); | |
| 421 | + Assert.Contains("href=\"/jessie/pulls-conflict/conflicts/main...feature/x\"", page); | |
| 422 | + Assert.DoesNotContain("name=\"Method\"", page); | |
| 423 | + | |
| 424 | + await ForgeHost.PostFormAsync(owner, s.Page("conflicts/main...feature/x"), "resolve", new() | |
| 425 | + { | |
| 426 | + ["base_sha"] = s.MainSha, | |
| 427 | + ["head_sha"] = s.FeatureSha, | |
| 428 | + ["choice_0"] = "ours", | |
| 429 | + }); | |
| 430 | + | |
| 431 | + var pull = await DbAsync(db => db.PullRequests.SingleAsync(p => p.RepoId == s.Repo.Id)); | |
| 432 | + Assert.Equal(PullRequestStatus.Merged, pull.Status); | |
| 433 | + Assert.Equal(pull.MergeCommitSha, await s.ServerAsync("rev-parse", "server/main")); | |
| 434 | + Assert.Equal("one\nTWO from main\nthree", await host.Git.MustAsync(s.Work, "show", "server/main:a.txt")); | |
| 435 | + } | |
| 436 | + | |
| 437 | + [Fact] | |
| 438 | + public async Task Protected_branch_refuses_force_pushes_and_deletion_but_not_ordinary_work() | |
| 439 | + { | |
| 440 | + var s = await BranchScenario.CreateAsync(host, "protected"); | |
| 441 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 442 | + var settings = s.Page("settings/branches"); | |
| 443 | + | |
| 444 | + var invalid = await ForgeHost.PostFormAsync(owner, settings, "add-rule", new() { ["Pattern"] = "--force" }); | |
| 445 | + Assert.Contains("This is not a valid branch name.", await ForgeHost.TextAsync(invalid)); | |
| 446 | + var added = await ForgeHost.PostFormAsync(owner, settings, "add-rule", new() { ["Pattern"] = "main" }); | |
| 447 | + Assert.Contains("<code>main</code>", await ForgeHost.TextAsync(added)); | |
| 448 | + | |
| 449 | + // An ordinary push still goes through. | |
| 450 | + await File.WriteAllTextAsync(Path.Combine(s.Work, "d.txt"), "more\n"); | |
| 451 | + await host.Git.MustAsync(s.Work, "add", "-A"); | |
| 452 | + await host.Git.MustAsync(s.Work, "commit", "-m", "Normal work"); | |
| 453 | + await host.Git.MustAsync(s.Work, "push", s.Url, "main"); | |
| 454 | + var tip = await host.Git.MustAsync(s.Work, "rev-parse", "HEAD"); | |
| 455 | + | |
| 456 | + // Rewriting history on it does not, and neither does deleting it. | |
| 457 | + await host.Git.MustAsync(s.Work, "commit", "--amend", "-m", "Rewritten"); | |
| 458 | + var forced = await host.Git.RunAsync(s.Work, "push", "--force", s.Url, "main"); | |
| 459 | + Assert.False(forced.Ok); | |
| 460 | + Assert.Contains("non-fast-forward", forced.StdErr); | |
| 461 | + await host.Git.MustAsync(s.Work, "push", s.Url, "feature/x:refs/heads/spare"); | |
| 462 | + Assert.False((await host.Git.RunAsync(s.Work, "push", s.Url, "--delete", "main")).Ok); | |
| 463 | + Assert.Equal(tip, await s.ServerAsync("rev-parse", "server/main")); | |
| 464 | + | |
| 465 | + // Branches that are not protected behave as before, in a push of their own. | |
| 466 | + await host.Git.MustAsync(s.Work, "push", "--force", s.Url, "main:refs/heads/spare"); | |
| 467 | + await host.Git.MustAsync(s.Work, "push", s.Url, "--delete", "spare"); | |
| 468 | + | |
| 469 | + // The rule can be removed again. | |
| 470 | + var ruleId = (await DbAsync(db => db.BranchProtections.SingleAsync(r => r.RepoId == s.Repo.Id))).Id; | |
| 471 | + await ForgeHost.PostFormAsync(owner, settings, "remove-rule", new() { ["RuleId"] = ruleId.ToString() }); | |
| 472 | + await host.Git.MustAsync(s.Work, "push", "--force", s.Url, "main"); | |
| 473 | + | |
| 474 | + using var anonymous = host.CreateClient(); | |
| 475 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync(settings)).StatusCode); | |
| 476 | + } | |
| 477 | + | |
| 478 | + [Fact] | |
| 479 | + public async Task Branch_closed_to_pushes_changes_only_through_the_web() | |
| 480 | + { | |
| 481 | + var s = await BranchScenario.CreateAsync(host, "web-only"); | |
| 482 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 483 | + await ForgeHost.PostFormAsync(owner, s.Page("settings/branches"), "add-rule", new() { ["Pattern"] = "release/*", ["BlockPush"] = "true" }); | |
| 484 | + await ForgeHost.PostFormAsync(owner, s.Page("branches"), "create-branch", new() { ["NewName"] = "release/1.0", ["From"] = "main" }); | |
| 485 | + | |
| 486 | + // Git may not push to it, even fast-forward… | |
| 487 | + var pushed = await host.Git.RunAsync(s.Work, "push", s.Url, "feature/x:refs/heads/release/1.0"); | |
| 488 | + Assert.False(pushed.Ok); | |
| 489 | + Assert.Contains("hidden ref", pushed.StdErr); | |
| 490 | + Assert.Equal(s.MainSha, await s.ServerAsync("rev-parse", "server/release/1.0")); | |
| 491 | + | |
| 492 | + // …the web may not delete it… | |
| 493 | + var deleted = await ForgeHost.PostFormAsync(owner, s.Page("branches"), "delete-branch", new() { ["DeleteName"] = "release/1.0" }); | |
| 494 | + Assert.Contains("This branch is protected and cannot be deleted.", await ForgeHost.TextAsync(deleted)); | |
| 495 | + | |
| 496 | + // …but a merge on the web moves it, and other branches still take pushes. | |
| 497 | + var merged = await ForgeHost.PostFormAsync(owner, s.Page("compare/release/1.0...feature/x"), "merge", new() { ["Method"] = "ff" }); | |
| 498 | + Assert.Equal(HttpStatusCode.Redirect, merged.StatusCode); | |
| 499 | + Assert.Equal(s.FeatureSha, await s.ServerAsync("rev-parse", "server/release/1.0")); | |
| 500 | + await host.Git.MustAsync(s.Work, "push", s.Url, "feature/x:refs/heads/main"); | |
| 501 | + } | |
| 502 | +} |
added forge.Tests/GitLayerTests.cs +325 −0View file
| @@ -0,0 +1,325 @@ | ||
| 1 | +using Forge.Git; | |
| 2 | +using Forge.Tests.Support; | |
| 3 | +using Microsoft.Extensions.Options; | |
| 4 | + | |
| 5 | +namespace Forge.Tests; | |
| 6 | + | |
| 7 | +/// <summary> | |
| 8 | +/// A real repository in a temp directory with the awkward cases in it: a branch with a slash, | |
| 9 | +/// annotated and lightweight tags, a binary file, a file with a space in its name, and a rename. | |
| 10 | +/// </summary> | |
| 11 | +public sealed class GitRepoFixture : IAsyncLifetime | |
| 12 | +{ | |
| 13 | + private readonly TempDir _temp = new(); | |
| 14 | + | |
| 15 | + public GitCli Cli { get; private set; } = null!; | |
| 16 | + public GitRepo Repo { get; private set; } = null!; | |
| 17 | + public RefResolver Resolver { get; private set; } = null!; | |
| 18 | + public string DataPath { get; private set; } = ""; | |
| 19 | + | |
| 20 | + /// <summary>The .git directory of the working repository; the git layer only needs a git dir.</summary> | |
| 21 | + public string RepoPath { get; private set; } = ""; | |
| 22 | + | |
| 23 | + public string FirstSha { get; private set; } = ""; | |
| 24 | + public string SecondSha { get; private set; } = ""; | |
| 25 | + public string FeatureSha { get; private set; } = ""; | |
| 26 | + | |
| 27 | + public async Task InitializeAsync() | |
| 28 | + { | |
| 29 | + DataPath = _temp.Sub("data"); | |
| 30 | + var options = Options.Create(new ForgeOptions { DataPath = DataPath, GitPath = TestGit.Executable }); | |
| 31 | + Cli = new GitCli(options); | |
| 32 | + Repo = new GitRepo(Cli); | |
| 33 | + Resolver = new RefResolver(Repo); | |
| 34 | + | |
| 35 | + var git = new TestGit(_temp.Sub("home")); | |
| 36 | + var work = _temp.Sub("work"); | |
| 37 | + await git.MustAsync(work, "init", "--initial-branch=main", "."); | |
| 38 | + | |
| 39 | + Directory.CreateDirectory(Path.Combine(work, "src")); | |
| 40 | + await File.WriteAllTextAsync(Path.Combine(work, "README.md"), "# Fixture\n"); | |
| 41 | + await File.WriteAllTextAsync(Path.Combine(work, "src", "a.cs"), "line one\nline two\nline three\n"); | |
| 42 | + await File.WriteAllTextAsync(Path.Combine(work, "file with space.txt"), "spaced\n"); | |
| 43 | + await File.WriteAllTextAsync(Path.Combine(work, "old.txt"), "this file will be renamed\nwithout changes\n"); | |
| 44 | + await File.WriteAllBytesAsync(Path.Combine(work, "binary.bin"), [1, 2, 0, 3, 4, 0, 255]); | |
| 45 | + await git.MustAsync(work, "add", "-A"); | |
| 46 | + await git.MustAsync(work, "commit", "-m", "First commit", "-m", "With a body.\nOn two lines."); | |
| 47 | + FirstSha = await git.MustAsync(work, "rev-parse", "HEAD"); | |
| 48 | + | |
| 49 | + await File.WriteAllTextAsync(Path.Combine(work, "src", "a.cs"), "line one\nline 2\nline three\nline four\n"); | |
| 50 | + await git.MustAsync(work, "mv", "old.txt", "new.txt"); | |
| 51 | + await git.MustAsync(work, "add", "-A"); | |
| 52 | + await git.MustAsync(work, "commit", "-m", "Second commit"); | |
| 53 | + SecondSha = await git.MustAsync(work, "rev-parse", "HEAD"); | |
| 54 | + | |
| 55 | + await git.MustAsync(work, "tag", "-a", "v1.0", "-m", "Release 1.0"); | |
| 56 | + await git.MustAsync(work, "tag", "light"); | |
| 57 | + | |
| 58 | + await git.MustAsync(work, "checkout", "-b", "feature/x"); | |
| 59 | + await File.WriteAllTextAsync(Path.Combine(work, "src", "feature.txt"), "feature\n"); | |
| 60 | + await git.MustAsync(work, "add", "-A"); | |
| 61 | + await git.MustAsync(work, "commit", "-m", "Feature commit"); | |
| 62 | + FeatureSha = await git.MustAsync(work, "rev-parse", "HEAD"); | |
| 63 | + await git.MustAsync(work, "checkout", "main"); | |
| 64 | + | |
| 65 | + RepoPath = Path.Combine(work, ".git"); | |
| 66 | + } | |
| 67 | + | |
| 68 | + public Task DisposeAsync() | |
| 69 | + { | |
| 70 | + _temp.Dispose(); | |
| 71 | + return Task.CompletedTask; | |
| 72 | + } | |
| 73 | +} | |
| 74 | + | |
| 75 | +public class GitLayerTests(GitRepoFixture fx) : IClassFixture<GitRepoFixture> | |
| 76 | +{ | |
| 77 | + [Fact] | |
| 78 | + public async Task Version_is_reported() | |
| 79 | + { | |
| 80 | + var version = await fx.Cli.GetVersionAsync(); | |
| 81 | + Assert.True(version >= ForgeApp.MinimumGitVersion, $"git {version} is older than {ForgeApp.MinimumGitVersion}"); | |
| 82 | + } | |
| 83 | + | |
| 84 | + [Fact] | |
| 85 | + public async Task Missing_git_gives_a_clear_error() | |
| 86 | + { | |
| 87 | + var cli = new GitCli(Options.Create(new ForgeOptions { DataPath = fx.DataPath, GitPath = "git-that-does-not-exist" })); | |
| 88 | + var ex = await Assert.ThrowsAsync<GitException>(() => cli.GetVersionAsync()); | |
| 89 | + Assert.Contains("git-that-does-not-exist", ex.Message); | |
| 90 | + } | |
| 91 | + | |
| 92 | + [Fact] | |
| 93 | + public async Task Refs_list_branches_and_tags() | |
| 94 | + { | |
| 95 | + var refs = await fx.Repo.ListRefsAsync(fx.RepoPath); | |
| 96 | + | |
| 97 | + var main = Assert.Single(refs, r => r is { Kind: RefKind.Branch, Name: "main" }); | |
| 98 | + Assert.Equal(fx.SecondSha, main.Sha); | |
| 99 | + Assert.Equal("Second commit", main.Subject); | |
| 100 | + Assert.NotNull(main.Date); | |
| 101 | + | |
| 102 | + var feature = Assert.Single(refs, r => r is { Kind: RefKind.Branch, Name: "feature/x" }); | |
| 103 | + Assert.Equal(fx.FeatureSha, feature.TargetSha); | |
| 104 | + | |
| 105 | + var annotated = Assert.Single(refs, r => r is { Kind: RefKind.Tag, Name: "v1.0" }); | |
| 106 | + Assert.Equal("tag", annotated.ObjectType); | |
| 107 | + Assert.NotEqual(fx.SecondSha, annotated.Sha); | |
| 108 | + Assert.Equal(fx.SecondSha, annotated.TargetSha); | |
| 109 | + Assert.Equal("Release 1.0", annotated.Subject); | |
| 110 | + | |
| 111 | + var light = Assert.Single(refs, r => r is { Kind: RefKind.Tag, Name: "light" }); | |
| 112 | + Assert.Equal(fx.SecondSha, light.Sha); | |
| 113 | + Assert.Null(light.PeeledSha); | |
| 114 | + } | |
| 115 | + | |
| 116 | + [Fact] | |
| 117 | + public async Task Tree_lists_root_and_subdirectory() | |
| 118 | + { | |
| 119 | + var rootSha = await fx.Repo.GetRootTreeShaAsync(fx.RepoPath, fx.SecondSha); | |
| 120 | + Assert.NotNull(rootSha); | |
| 121 | + var root = await fx.Repo.ListTreeAsync(fx.RepoPath, rootSha); | |
| 122 | + | |
| 123 | + Assert.Equal( | |
| 124 | + ["README.md", "binary.bin", "file with space.txt", "new.txt", "src"], | |
| 125 | + root.Select(e => e.Name).Order(StringComparer.Ordinal)); | |
| 126 | + Assert.True(root.Single(e => e.Name == "src").IsTree); | |
| 127 | + Assert.Equal(7, root.Single(e => e.Name == "binary.bin").Size); | |
| 128 | + | |
| 129 | + var src = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "src"); | |
| 130 | + Assert.True(src is { IsTree: true }); | |
| 131 | + var children = await fx.Repo.ListTreeAsync(fx.RepoPath, src.Sha); | |
| 132 | + Assert.Equal("a.cs", Assert.Single(children).Name); | |
| 133 | + } | |
| 134 | + | |
| 135 | + [Fact] | |
| 136 | + public async Task Entry_lookup_handles_spaces_and_missing_paths() | |
| 137 | + { | |
| 138 | + var spaced = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "file with space.txt"); | |
| 139 | + Assert.True(spaced is { IsBlob: true, Name: "file with space.txt" }); | |
| 140 | + | |
| 141 | + var nested = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "src/a.cs"); | |
| 142 | + Assert.Equal("a.cs", nested?.Name); | |
| 143 | + | |
| 144 | + Assert.Null(await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "nope.txt")); | |
| 145 | + // Pathspec magic and option-like paths are plain (missing) file names. | |
| 146 | + Assert.Null(await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, ":(glob)**")); | |
| 147 | + Assert.Null(await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "--name-only")); | |
| 148 | + } | |
| 149 | + | |
| 150 | + [Fact] | |
| 151 | + public async Task Blob_is_read_with_size_and_cap() | |
| 152 | + { | |
| 153 | + var entry = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "src/a.cs"); | |
| 154 | + Assert.NotNull(entry); | |
| 155 | + Assert.Equal(entry.Size, await fx.Repo.GetBlobSizeAsync(fx.RepoPath, entry.Sha)); | |
| 156 | + | |
| 157 | + var blob = await fx.Repo.ReadBlobAsync(fx.RepoPath, entry.Sha, 1024); | |
| 158 | + Assert.False(blob.Truncated); | |
| 159 | + Assert.False(blob.IsBinary); | |
| 160 | + Assert.Equal("line one\nline 2\nline three\nline four\n", blob.Text); | |
| 161 | + | |
| 162 | + var capped = await fx.Repo.ReadBlobAsync(fx.RepoPath, entry.Sha, 8); | |
| 163 | + Assert.True(capped.Truncated); | |
| 164 | + Assert.Equal("line one", capped.Text); | |
| 165 | + | |
| 166 | + var binary = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "binary.bin"); | |
| 167 | + Assert.True((await fx.Repo.ReadBlobAsync(fx.RepoPath, binary!.Sha, 1024)).IsBinary); | |
| 168 | + } | |
| 169 | + | |
| 170 | + [Fact] | |
| 171 | + public async Task Log_pages_and_filters_by_path() | |
| 172 | + { | |
| 173 | + var all = await fx.Repo.LogAsync(fx.RepoPath, fx.SecondSha); | |
| 174 | + Assert.Equal([fx.SecondSha, fx.FirstSha], all.Select(c => c.Sha)); | |
| 175 | + Assert.Equal("First commit", all[1].Subject); | |
| 176 | + Assert.Equal("With a body.\nOn two lines.", all[1].Body); | |
| 177 | + Assert.Equal("Test Author", all[1].AuthorName); | |
| 178 | + Assert.Equal("author@example.com", all[1].AuthorEmail); | |
| 179 | + Assert.Equal([fx.FirstSha], all[0].Parents); | |
| 180 | + | |
| 181 | + var second = await fx.Repo.LogAsync(fx.RepoPath, fx.SecondSha, skip: 1, take: 1); | |
| 182 | + Assert.Equal(fx.FirstSha, Assert.Single(second).Sha); | |
| 183 | + | |
| 184 | + var readme = await fx.Repo.LogAsync(fx.RepoPath, fx.SecondSha, "README.md"); | |
| 185 | + Assert.Equal(fx.FirstSha, Assert.Single(readme).Sha); | |
| 186 | + | |
| 187 | + var range = await fx.Repo.LogRangeAsync(fx.RepoPath, fx.FirstSha, fx.FeatureSha, 20); | |
| 188 | + Assert.Equal([fx.FeatureSha, fx.SecondSha], range.Select(c => c.Sha)); | |
| 189 | + } | |
| 190 | + | |
| 191 | + [Fact] | |
| 192 | + public async Task Commit_diff_has_stats_hunks_and_renames() | |
| 193 | + { | |
| 194 | + var commit = await fx.Repo.GetCommitAsync(fx.RepoPath, fx.SecondSha); | |
| 195 | + Assert.Equal("Second commit", commit?.Subject); | |
| 196 | + | |
| 197 | + var diff = await fx.Repo.GetDiffAsync(fx.RepoPath, fx.SecondSha); | |
| 198 | + | |
| 199 | + var stat = Assert.Single(diff.Stats, s => s.Path == "src/a.cs"); | |
| 200 | + Assert.Equal((2, 1), (stat.Added, stat.Deleted)); | |
| 201 | + var renameStat = Assert.Single(diff.Stats, s => s.Path == "new.txt"); | |
| 202 | + Assert.Equal("old.txt", renameStat.OldPath); | |
| 203 | + | |
| 204 | + var modified = Assert.Single(diff.Patch.Files, f => f.NewPath == "src/a.cs"); | |
| 205 | + Assert.Equal(FileChange.Modified, modified.Change); | |
| 206 | + var lines = modified.Hunks.SelectMany(h => h.Lines).ToList(); | |
| 207 | + Assert.Contains(new DiffLine(DiffLineKind.Deleted, 2, null, "line two"), lines); | |
| 208 | + Assert.Contains(new DiffLine(DiffLineKind.Added, null, 2, "line 2"), lines); | |
| 209 | + Assert.Contains(new DiffLine(DiffLineKind.Added, null, 4, "line four"), lines); | |
| 210 | + | |
| 211 | + var renamed = Assert.Single(diff.Patch.Files, f => f.Change == FileChange.Renamed); | |
| 212 | + Assert.Equal(("old.txt", "new.txt"), (renamed.OldPath, renamed.NewPath)); | |
| 213 | + } | |
| 214 | + | |
| 215 | + [Fact] | |
| 216 | + public async Task Root_commit_diff_marks_binary_files_and_reads_names_with_spaces() | |
| 217 | + { | |
| 218 | + var diff = await fx.Repo.GetDiffAsync(fx.RepoPath, fx.FirstSha); | |
| 219 | + | |
| 220 | + Assert.True(Assert.Single(diff.Stats, s => s.Path == "binary.bin").IsBinary); | |
| 221 | + var binary = Assert.Single(diff.Patch.Files, f => f.NewPath == "binary.bin"); | |
| 222 | + Assert.True(binary.IsBinary); | |
| 223 | + Assert.Equal(FileChange.Added, binary.Change); | |
| 224 | + | |
| 225 | + var spaced = Assert.Single(diff.Patch.Files, f => f.NewPath == "file with space.txt"); | |
| 226 | + Assert.Equal(FileChange.Added, spaced.Change); | |
| 227 | + Assert.Equal(1, spaced.Added); | |
| 228 | + } | |
| 229 | + | |
| 230 | + [Fact] | |
| 231 | + public async Task Ahead_behind_counts_both_sides() | |
| 232 | + { | |
| 233 | + Assert.Equal((1, 0), await fx.Repo.AheadBehindAsync(fx.RepoPath, fx.SecondSha, fx.FeatureSha)); | |
| 234 | + Assert.Equal((0, 2), await fx.Repo.AheadBehindAsync(fx.RepoPath, fx.FeatureSha, fx.FirstSha)); | |
| 235 | + } | |
| 236 | + | |
| 237 | + [Fact] | |
| 238 | + public async Task Resolver_handles_slashes_tags_shas_and_hostile_input() | |
| 239 | + { | |
| 240 | + var branch = await fx.Resolver.ResolveAsync(fx.RepoPath, "feature/x/src/feature.txt"); | |
| 241 | + Assert.Equal(new ResolvedRef("feature/x", ResolvedKind.Branch, fx.FeatureSha, "src/feature.txt"), branch); | |
| 242 | + | |
| 243 | + var tag = await fx.Resolver.ResolveAsync(fx.RepoPath, "v1.0/src"); | |
| 244 | + Assert.Equal(new ResolvedRef("v1.0", ResolvedKind.Tag, fx.SecondSha, "src"), tag); | |
| 245 | + | |
| 246 | + var sha = await fx.Resolver.ResolveAsync(fx.RepoPath, fx.FirstSha + "/README.md"); | |
| 247 | + Assert.Equal(new ResolvedRef(fx.FirstSha, ResolvedKind.Commit, fx.FirstSha, "README.md"), sha); | |
| 248 | + | |
| 249 | + Assert.Null(await fx.Resolver.ResolveAsync(fx.RepoPath, new string('0', 40))); | |
| 250 | + Assert.Null(await fx.Resolver.ResolveAsync(fx.RepoPath, "missing/README.md")); | |
| 251 | + | |
| 252 | + // The checklist case: a "ref" shaped like an option must resolve to nothing and run nothing. | |
| 253 | + var marker = Path.Combine(fx.DataPath, "pwned"); | |
| 254 | + Assert.Null(await fx.Resolver.ResolveAsync(fx.RepoPath, $"--upload-pack=touch {marker}")); | |
| 255 | + Assert.Null(await fx.Resolver.ResolveAsync(fx.RepoPath, "--output=" + marker)); | |
| 256 | + Assert.False(File.Exists(marker)); | |
| 257 | + } | |
| 258 | + | |
| 259 | + [Fact] | |
| 260 | + public async Task Commit_lookup_accepts_hex_only() | |
| 261 | + { | |
| 262 | + Assert.Equal(fx.SecondSha, await fx.Repo.ResolveCommitAsync(fx.RepoPath, fx.SecondSha[..10])); | |
| 263 | + Assert.Null(await fx.Repo.ResolveCommitAsync(fx.RepoPath, "main")); | |
| 264 | + Assert.Null(await fx.Repo.ResolveCommitAsync(fx.RepoPath, "--all")); | |
| 265 | + Assert.Null(await fx.Repo.ResolveCommitAsync(fx.RepoPath, "HEAD~1")); | |
| 266 | + } | |
| 267 | + | |
| 268 | + [Fact] | |
| 269 | + public async Task Init_creates_a_bare_repository_on_main_with_fsck_enabled() | |
| 270 | + { | |
| 271 | + var path = Path.Combine(fx.DataPath, "repos", "77.git"); | |
| 272 | + Directory.CreateDirectory(Path.GetDirectoryName(path)!); | |
| 273 | + | |
| 274 | + await fx.Repo.InitBareAsync(path); | |
| 275 | + | |
| 276 | + Assert.True(File.Exists(Path.Combine(path, "HEAD"))); | |
| 277 | + Assert.Equal("main", await fx.Repo.GetHeadBranchAsync(path)); | |
| 278 | + Assert.Empty(await fx.Repo.ListRefsAsync(path)); | |
| 279 | + var config = await fx.Cli.RunAsync(path, ["config", "--get", "receive.fsckObjects"]); | |
| 280 | + Assert.Equal("true", config.Text.Trim()); | |
| 281 | + var bare = await fx.Cli.RunAsync(path, ["rev-parse", "--is-bare-repository"]); | |
| 282 | + Assert.Equal("true", bare.Text.Trim()); | |
| 283 | + } | |
| 284 | + | |
| 285 | + [Fact] | |
| 286 | + public async Task Timeout_kills_the_process() | |
| 287 | + { | |
| 288 | + // cat-file --batch waits for stdin forever; a stream that never ends keeps it alive. | |
| 289 | + await using var never = new NeverEndingStream(); | |
| 290 | + await Assert.ThrowsAsync<GitTimeoutException>(() => | |
| 291 | + fx.Cli.RunAsync(fx.RepoPath, ["cat-file", "--batch"], stdin: never, timeout: TimeSpan.FromMilliseconds(500))); | |
| 292 | + } | |
| 293 | + | |
| 294 | + [Fact] | |
| 295 | + public async Task Cancellation_kills_the_process() | |
| 296 | + { | |
| 297 | + await using var never = new NeverEndingStream(); | |
| 298 | + using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(300)); | |
| 299 | + await Assert.ThrowsAnyAsync<OperationCanceledException>(() => | |
| 300 | + fx.Cli.RunAsync(fx.RepoPath, ["cat-file", "--batch"], stdin: never, ct: cts.Token)); | |
| 301 | + } | |
| 302 | + | |
| 303 | + private sealed class NeverEndingStream : Stream | |
| 304 | + { | |
| 305 | + public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) | |
| 306 | + { | |
| 307 | + await Task.Delay(Timeout.Infinite, cancellationToken); | |
| 308 | + return 0; | |
| 309 | + } | |
| 310 | + | |
| 311 | + public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => | |
| 312 | + ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); | |
| 313 | + | |
| 314 | + public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException(); | |
| 315 | + public override bool CanRead => true; | |
| 316 | + public override bool CanSeek => false; | |
| 317 | + public override bool CanWrite => false; | |
| 318 | + public override long Length => throw new NotSupportedException(); | |
| 319 | + public override long Position { get => 0; set => throw new NotSupportedException(); } | |
| 320 | + public override void Flush() { } | |
| 321 | + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); | |
| 322 | + public override void SetLength(long value) => throw new NotSupportedException(); | |
| 323 | + public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException(); | |
| 324 | + } | |
| 325 | +} |
added forge.Tests/InsightsTests.cs +87 −0View file
| @@ -0,0 +1,87 @@ | ||
| 1 | +using Forge.Features.Browse; | |
| 2 | +using Forge.Git; | |
| 3 | + | |
| 4 | +namespace Forge.Tests; | |
| 5 | + | |
| 6 | +public class InsightsTests | |
| 7 | +{ | |
| 8 | + [Fact] | |
| 9 | + public void Languages_are_shared_by_bytes_and_ignore_data_and_vendored_files() | |
| 10 | + { | |
| 11 | + var shares = RepoInsights.ComputeLanguages( | |
| 12 | + [ | |
| 13 | + new FileEntry("src/App.cs", 600), | |
| 14 | + new FileEntry("src/Deep/Other.cs", 150), | |
| 15 | + new FileEntry("web/site.js", 250), | |
| 16 | + new FileEntry("README.md", 10_000), | |
| 17 | + new FileEntry("package.json", 10_000), | |
| 18 | + new FileEntry("node_modules/left-pad/index.js", 50_000), | |
| 19 | + new FileEntry("web/wwwroot/lib/highlight/highlight.min.js", 50_000), | |
| 20 | + new FileEntry("web/jquery.min.js", 50_000), | |
| 21 | + new FileEntry("empty.py", 0), | |
| 22 | + ]); | |
| 23 | + | |
| 24 | + Assert.Equal(["csharp", "javascript"], shares.Select(s => s.Key)); | |
| 25 | + Assert.Equal("C#", shares[0].Name); | |
| 26 | + Assert.Equal(75.0, shares[0].Percent, 3); | |
| 27 | + Assert.Equal(25.0, shares[1].Percent, 3); | |
| 28 | + } | |
| 29 | + | |
| 30 | + [Fact] | |
| 31 | + public void Languages_beyond_the_first_six_are_grouped_as_other() | |
| 32 | + { | |
| 33 | + string[] extensions = [".cs", ".js", ".ts", ".py", ".go", ".rs", ".java", ".rb"]; | |
| 34 | + var files = extensions.Select((ext, i) => new FileEntry("file" + ext, 1000 - i * 100)).ToList(); | |
| 35 | + | |
| 36 | + var shares = RepoInsights.ComputeLanguages(files); | |
| 37 | + | |
| 38 | + Assert.Equal(7, shares.Count); | |
| 39 | + Assert.Equal("other", shares[^1].Key); | |
| 40 | + Assert.Null(shares[^1].Name); | |
| 41 | + Assert.Equal(100.0, shares.Sum(s => s.Percent), 3); | |
| 42 | + } | |
| 43 | + | |
| 44 | + [Fact] | |
| 45 | + public void A_repository_without_code_has_no_languages() | |
| 46 | + { | |
| 47 | + Assert.Empty(RepoInsights.ComputeLanguages([new FileEntry("README.md", 100), new FileEntry("data.json", 5)])); | |
| 48 | + } | |
| 49 | + | |
| 50 | + [Fact] | |
| 51 | + public void Activity_counts_people_by_email_and_commits_by_utc_day() | |
| 52 | + { | |
| 53 | + var day = new DateTimeOffset(2026, 3, 10, 23, 30, 0, TimeSpan.Zero); | |
| 54 | + var activity = RepoInsights.ComputeActivity( | |
| 55 | + [ | |
| 56 | + ("Jessie", "jessie@example.com", day.AddHours(1)), // Already the 11th in UTC. | |
| 57 | + ("jessie (laptop)", "Jessie@Example.com", day), | |
| 58 | + ("Sam", "sam@example.com", day.AddDays(-2)), | |
| 59 | + ("Jessie", "jessie@example.com", day.AddDays(-3)), | |
| 60 | + ], limit: 100); | |
| 61 | + | |
| 62 | + Assert.Equal(4, activity.Commits); | |
| 63 | + Assert.False(activity.Truncated); | |
| 64 | + Assert.Equal(["Jessie", "Sam"], activity.Contributors.Select(c => c.Name)); | |
| 65 | + Assert.Equal(3, activity.Contributors[0].Commits); | |
| 66 | + Assert.Equal(day.AddDays(-3), activity.Contributors[0].First); | |
| 67 | + Assert.Equal(day.AddHours(1), activity.Contributors[0].Last); | |
| 68 | + Assert.Equal(1, activity.CommitsByDay[new DateOnly(2026, 3, 11)]); | |
| 69 | + Assert.Equal(1, activity.CommitsByDay[new DateOnly(2026, 3, 10)]); | |
| 70 | + Assert.False(activity.CommitsByDay.ContainsKey(new DateOnly(2026, 3, 9))); | |
| 71 | + | |
| 72 | + Assert.True(RepoInsights.ComputeActivity([("A", "a@example.com", day)], limit: 1).Truncated); | |
| 73 | + } | |
| 74 | + | |
| 75 | + [Fact] | |
| 76 | + public void File_list_keeps_full_paths_and_skips_submodules() | |
| 77 | + { | |
| 78 | + var output = | |
| 79 | + "100644 blob 1111111111111111111111111111111111111111 12\tREADME.md\0" | |
| 80 | + + "160000 commit 2222222222222222222222222222222222222222 -\tvendor/sub\0" | |
| 81 | + + "100755 blob 3333333333333333333333333333333333333333 2048\tsrc/dir with space/run.sh\0"; | |
| 82 | + | |
| 83 | + var files = GitParsers.ParseFileList(output); | |
| 84 | + | |
| 85 | + Assert.Equal([new FileEntry("README.md", 12), new FileEntry("src/dir with space/run.sh", 2048)], files); | |
| 86 | + } | |
| 87 | +} |
added forge.Tests/LocalizationTests.cs +227 −0View file
| @@ -0,0 +1,227 @@ | ||
| 1 | +using System.Globalization; | |
| 2 | +using System.Net; | |
| 3 | +using System.Text.RegularExpressions; | |
| 4 | +using Forge.Localization; | |
| 5 | +using Forge.Tests.Support; | |
| 6 | + | |
| 7 | +namespace Forge.Tests; | |
| 8 | + | |
| 9 | +public partial class LocalizationTests(ForgeHost host) : IClassFixture<ForgeHost> | |
| 10 | +{ | |
| 11 | + private static readonly Translations Translations = new(); | |
| 12 | + private static readonly Localizer T = new(Translations); | |
| 13 | + | |
| 14 | + private static TResult In<TResult>(string culture, Func<TResult> action) | |
| 15 | + { | |
| 16 | + var (ui, format) = (CultureInfo.CurrentUICulture, CultureInfo.CurrentCulture); | |
| 17 | + try | |
| 18 | + { | |
| 19 | + CultureInfo.CurrentUICulture = CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo(culture); | |
| 20 | + return action(); | |
| 21 | + } | |
| 22 | + finally | |
| 23 | + { | |
| 24 | + (CultureInfo.CurrentUICulture, CultureInfo.CurrentCulture) = (ui, format); | |
| 25 | + } | |
| 26 | + } | |
| 27 | + | |
| 28 | + /// <summary>Every English text the code can display: T["…"], T.Html("…"), Localizer.Key("…") and T.Plural(n, "…", "…").</summary> | |
| 29 | + private static HashSet<string> KeysUsedInSource() | |
| 30 | + { | |
| 31 | + var keys = new HashSet<string>(StringComparer.Ordinal); | |
| 32 | + var files = Directory.EnumerateFiles(ForgeHost.WebProjectDirectory, "*.*", SearchOption.AllDirectories) | |
| 33 | + .Where(f => f.EndsWith(".razor", StringComparison.Ordinal) || f.EndsWith(".cs", StringComparison.Ordinal)) | |
| 34 | + .Where(f => !f.Contains(Path.DirectorySeparatorChar + "obj" + Path.DirectorySeparatorChar) | |
| 35 | + && !f.Contains(Path.DirectorySeparatorChar + "bin" + Path.DirectorySeparatorChar)); | |
| 36 | + foreach (var file in files) | |
| 37 | + { | |
| 38 | + var source = File.ReadAllText(file); | |
| 39 | + foreach (Match m in SingleKey().Matches(source)) | |
| 40 | + { | |
| 41 | + keys.Add(Regex.Unescape(m.Groups[1].Value)); | |
| 42 | + } | |
| 43 | + | |
| 44 | + foreach (Match m in PluralKey().Matches(source)) | |
| 45 | + { | |
| 46 | + keys.Add(m.Groups[1].Value + "|" + m.Groups[2].Value); | |
| 47 | + } | |
| 48 | + } | |
| 49 | + | |
| 50 | + return keys; | |
| 51 | + } | |
| 52 | + | |
| 53 | + [Fact] | |
| 54 | + public void English_is_first_and_slovak_is_available() | |
| 55 | + { | |
| 56 | + Assert.Equal("en", Translations.Languages[0]); | |
| 57 | + Assert.Contains("sk", Translations.Languages); | |
| 58 | + } | |
| 59 | + | |
| 60 | + [Fact] | |
| 61 | + public void Every_language_translates_every_text_and_nothing_else() | |
| 62 | + { | |
| 63 | + var used = KeysUsedInSource(); | |
| 64 | + Assert.True(used.Count > 150, $"Only {used.Count} keys found in the sources; the scan is probably broken."); | |
| 65 | + | |
| 66 | + foreach (var language in Translations.Languages.Skip(1)) | |
| 67 | + { | |
| 68 | + var translated = Translations.KeysOf(language).ToHashSet(StringComparer.Ordinal); | |
| 69 | + var missing = used.Except(translated).Order().ToList(); | |
| 70 | + var unused = translated.Except(used).Order().ToList(); | |
| 71 | + Assert.True(missing.Count == 0, $"{language}.json is missing:\n" + string.Join("\n", missing)); | |
| 72 | + Assert.True(unused.Count == 0, $"{language}.json has entries the code does not use:\n" + string.Join("\n", unused)); | |
| 73 | + } | |
| 74 | + } | |
| 75 | + | |
| 76 | + [Fact] | |
| 77 | + public void Translations_keep_the_placeholders_of_the_english_text() | |
| 78 | + { | |
| 79 | + static string[] Placeholders(string text) => | |
| 80 | + Placeholder().Matches(text).Select(m => m.Value).Distinct().Order().ToArray(); | |
| 81 | + | |
| 82 | + foreach (var language in Translations.Languages.Skip(1)) | |
| 83 | + { | |
| 84 | + foreach (var key in Translations.KeysOf(language)) | |
| 85 | + { | |
| 86 | + // A plural key is "one|other"; both halves carry the same placeholders. | |
| 87 | + var expected = Placeholders(key.Split('|')[^1]); | |
| 88 | + foreach (var form in Translations.Find(language, key)!) | |
| 89 | + { | |
| 90 | + Assert.True(expected.SequenceEqual(Placeholders(form)), $"{language}.json: \"{form}\" does not keep the placeholders of \"{key}\"."); | |
| 91 | + } | |
| 92 | + } | |
| 93 | + } | |
| 94 | + } | |
| 95 | + | |
| 96 | + [Fact] | |
| 97 | + public void Unknown_text_and_unknown_languages_fall_back_to_english() | |
| 98 | + { | |
| 99 | + Assert.Equal("Sign in", In("en", () => T["Sign in"])); | |
| 100 | + Assert.Equal("Prihlásiť sa", In("sk", () => T["Sign in"])); | |
| 101 | + Assert.Equal("Prihlásiť sa", In("sk-SK", () => T["Sign in"])); | |
| 102 | + Assert.Equal("Sign in", In("de-DE", () => T["Sign in"])); | |
| 103 | + Assert.Equal("Not a known text", In("sk", () => T["Not a known text"])); | |
| 104 | + Assert.Equal("sk", In("sk-SK", () => T.Language)); | |
| 105 | + Assert.Equal("en", In("de-DE", () => T.Language)); | |
| 106 | + Assert.Equal("Odhlásiť sa (jessie)", In("sk", () => T["Sign out ({0})", "jessie"])); | |
| 107 | + } | |
| 108 | + | |
| 109 | + [Theory] | |
| 110 | + [InlineData(1, "1 line", "1 riadok")] | |
| 111 | + [InlineData(2, "2 lines", "2 riadky")] | |
| 112 | + [InlineData(4, "4 lines", "4 riadky")] | |
| 113 | + [InlineData(5, "5 lines", "5 riadkov")] | |
| 114 | + [InlineData(0, "0 lines", "0 riadkov")] | |
| 115 | + [InlineData(22, "22 lines", "22 riadkov")] | |
| 116 | + public void Plurals_follow_the_rules_of_each_language(int count, string english, string slovak) | |
| 117 | + { | |
| 118 | + Assert.Equal(english, In("en", () => T.Plural(count, "{0} line", "{0} lines"))); | |
| 119 | + Assert.Equal(slovak, In("sk", () => T.Plural(count, "{0} line", "{0} lines"))); | |
| 120 | + } | |
| 121 | + | |
| 122 | + [Theory] | |
| 123 | + [InlineData(10, "just now", "práve teraz")] | |
| 124 | + [InlineData(60, "a minute ago", "pred minútou")] | |
| 125 | + [InlineData(60 * 5, "5 minutes ago", "pred 5 minútami")] | |
| 126 | + [InlineData(3600, "an hour ago", "pred hodinou")] | |
| 127 | + [InlineData(3600 * 3, "3 hours ago", "pred 3 hodinami")] | |
| 128 | + [InlineData(86400 + 3600, "yesterday", "včera")] | |
| 129 | + [InlineData(86400 * 3, "3 days ago", "pred 3 dňami")] | |
| 130 | + [InlineData(86400 * 45, "a month ago", "pred mesiacom")] | |
| 131 | + [InlineData(86400 * 100, "3 months ago", "pred 3 mesiacmi")] | |
| 132 | + [InlineData(86400 * 400, "a year ago", "pred rokom")] | |
| 133 | + [InlineData(86400 * 800, "2 years ago", "pred 2 rokmi")] | |
| 134 | + public void Relative_time_is_translated(int secondsAgo, string english, string slovak) | |
| 135 | + { | |
| 136 | + var now = new DateTimeOffset(2026, 1, 1, 12, 0, 0, TimeSpan.Zero); | |
| 137 | + Assert.Equal(english, In("en", () => T.RelativeTime(now.AddSeconds(-secondsAgo), now))); | |
| 138 | + Assert.Equal(slovak, In("sk", () => T.RelativeTime(now.AddSeconds(-secondsAgo), now))); | |
| 139 | + } | |
| 140 | + | |
| 141 | + [Fact] | |
| 142 | + public async Task Pages_are_english_by_default_and_follow_the_browser_language() | |
| 143 | + { | |
| 144 | + await host.CreateUserAsync(); | |
| 145 | + | |
| 146 | + using var plain = host.CreateClient(); | |
| 147 | + var english = await ForgeHost.TextAsync(await plain.GetAsync("/login")); | |
| 148 | + Assert.Contains("<html lang=\"en\">", english); | |
| 149 | + Assert.Contains("<h1>Sign in</h1>", english); | |
| 150 | + | |
| 151 | + using var slovakBrowser = host.CreateClient(); | |
| 152 | + slovakBrowser.DefaultRequestHeaders.AcceptLanguage.ParseAdd("sk-SK,sk;q=0.9,en;q=0.8"); | |
| 153 | + var slovak = await ForgeHost.TextAsync(await slovakBrowser.GetAsync("/login")); | |
| 154 | + Assert.Contains("<html lang=\"sk\">", slovak); | |
| 155 | + Assert.Contains("<h1>Prihlásiť sa</h1>", slovak); | |
| 156 | + | |
| 157 | + // A language Forge does not have falls back to English. | |
| 158 | + using var germanBrowser = host.CreateClient(); | |
| 159 | + germanBrowser.DefaultRequestHeaders.AcceptLanguage.ParseAdd("de-DE,de;q=0.9"); | |
| 160 | + Assert.Contains("<h1>Sign in</h1>", await ForgeHost.TextAsync(await germanBrowser.GetAsync("/login"))); | |
| 161 | + | |
| 162 | + // Messages produced by form handlers and by services are translated too. | |
| 163 | + var wrong = await ForgeHost.PostFormAsync(slovakBrowser, "/login", "login", new() { ["Username"] = "jessie", ["Password"] = "wrong password" }); | |
| 164 | + Assert.Contains("Nesprávne meno alebo heslo.", await ForgeHost.TextAsync(wrong)); | |
| 165 | + using var signedIn = await host.CreateSignedInClientAsync(); | |
| 166 | + signedIn.DefaultRequestHeaders.AcceptLanguage.ParseAdd("sk"); | |
| 167 | + var invalid = await ForgeHost.PostFormAsync(signedIn, "/new", "new-repo", new() { ["Name"] = "bad..name" }); | |
| 168 | + Assert.Contains("Názov nesmie obsahovať „..“.", await ForgeHost.TextAsync(invalid)); | |
| 169 | + | |
| 170 | + // Error pages as well. | |
| 171 | + var missing = await slovakBrowser.GetAsync("/nobody/nothing"); | |
| 172 | + Assert.Equal(HttpStatusCode.NotFound, missing.StatusCode); | |
| 173 | + Assert.Contains("Táto stránka neexistuje", await ForgeHost.TextAsync(missing)); | |
| 174 | + } | |
| 175 | + | |
| 176 | + [Fact] | |
| 177 | + public async Task Language_switcher_remembers_the_choice_over_the_browser_language() | |
| 178 | + { | |
| 179 | + await host.CreateUserAsync(); | |
| 180 | + using var client = host.CreateClient(); | |
| 181 | + client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-US,en;q=0.9"); | |
| 182 | + | |
| 183 | + var page = await client.GetStringAsync("/login?returnUrl=%2Fnew"); | |
| 184 | + Assert.Contains("name=\"lang\" value=\"sk\"", page); | |
| 185 | + Assert.Contains("slovenčina", WebUtility.HtmlDecode(page)); | |
| 186 | + var token = WebUtility.HtmlDecode(AntiforgeryToken().Match(page).Groups[1].Value); | |
| 187 | + | |
| 188 | + var switched = await client.PostAsync("/language", new FormUrlEncodedContent(new Dictionary<string, string> | |
| 189 | + { | |
| 190 | + ["__RequestVerificationToken"] = token, | |
| 191 | + ["lang"] = "sk", | |
| 192 | + ["returnUrl"] = "/login?returnUrl=%2Fnew", | |
| 193 | + })); | |
| 194 | + Assert.Equal(HttpStatusCode.Redirect, switched.StatusCode); | |
| 195 | + Assert.Equal("/login?returnUrl=%2Fnew", switched.Headers.Location?.OriginalString); | |
| 196 | + | |
| 197 | + // The cookie wins over Accept-Language from now on. | |
| 198 | + Assert.Contains("<h1>Prihlásiť sa</h1>", await ForgeHost.TextAsync(await client.GetAsync("/login"))); | |
| 199 | + | |
| 200 | + // An unsupported language is ignored, and the return address cannot leave the site. | |
| 201 | + var ignored = await client.PostAsync("/language", new FormUrlEncodedContent(new Dictionary<string, string> | |
| 202 | + { | |
| 203 | + ["__RequestVerificationToken"] = token, | |
| 204 | + ["lang"] = "xx", | |
| 205 | + ["returnUrl"] = "//evil.example", | |
| 206 | + })); | |
| 207 | + Assert.Equal("/", ignored.Headers.Location?.OriginalString); | |
| 208 | + Assert.Contains("<h1>Prihlásiť sa</h1>", await ForgeHost.TextAsync(await client.GetAsync("/login"))); | |
| 209 | + | |
| 210 | + // Without the antiforgery token the switch is refused. | |
| 211 | + var forged = await client.PostAsync("/language", new FormUrlEncodedContent(new Dictionary<string, string> { ["lang"] = "en" })); | |
| 212 | + Assert.Equal(HttpStatusCode.BadRequest, forged.StatusCode); | |
| 213 | + } | |
| 214 | + | |
| 215 | + // "this[" covers the Localizer's own lookups (relative time). | |
| 216 | + [GeneratedRegex("""(?:\bT\[|\bthis\[|\bT\.Html\(|Localizer\.Key\()\s*"((?:[^"\\]|\\.)*)"\s*[\],)]""")] | |
| 217 | + private static partial Regex SingleKey(); | |
| 218 | + | |
| 219 | + [GeneratedRegex("""\bT\.Plural\([^,]+,\s*"([^"]*)",\s*"([^"]*)"\)""")] | |
| 220 | + private static partial Regex PluralKey(); | |
| 221 | + | |
| 222 | + [GeneratedRegex(@"\{\d+\}")] | |
| 223 | + private static partial Regex Placeholder(); | |
| 224 | + | |
| 225 | + [GeneratedRegex("name=\"__RequestVerificationToken\" value=\"([^\"]+)\"")] | |
| 226 | + private static partial Regex AntiforgeryToken(); | |
| 227 | +} |
added forge.Tests/MergeTests.cs +326 −0View file
| @@ -0,0 +1,326 @@ | ||
| 1 | +using System.Net; | |
| 2 | +using Forge.Data; | |
| 3 | +using Forge.Features.History; | |
| 4 | +using Forge.Features.Repos; | |
| 5 | +using Forge.Tests.Support; | |
| 6 | +using Microsoft.EntityFrameworkCore; | |
| 7 | +using Microsoft.Extensions.DependencyInjection; | |
| 8 | + | |
| 9 | +namespace Forge.Tests; | |
| 10 | + | |
| 11 | +/// <summary>Compare, merge, and creating or deleting branches and tags from the web UI.</summary> | |
| 12 | +public class MergeTests(ForgeHost host) : IClassFixture<ForgeHost> | |
| 13 | +{ | |
| 14 | + private sealed record Scenario(Repository Repo, string Work, string Url, string MainSha, string FeatureSha); | |
| 15 | + | |
| 16 | + /// <summary> | |
| 17 | + /// A repository with main and a branch "feature/x" that adds b.txt and edits line two of a.txt. | |
| 18 | + /// With <paramref name="diverge"/>, main also gets a commit of its own: a different file, or the same line for a conflict. | |
| 19 | + /// </summary> | |
| 20 | + private async Task<Scenario> CreateAsync(string name, bool diverge = false, bool conflict = false, Visibility visibility = Visibility.Public) | |
| 21 | + { | |
| 22 | + var user = await host.CreateUserAsync(); | |
| 23 | + var repo = await host.CreateRepoAsync(user, name, visibility); | |
| 24 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 25 | + var url = host.GitUrl("jessie", name, token); | |
| 26 | + var work = host.NewDir("work"); | |
| 27 | + | |
| 28 | + await host.Git.CreateWorkRepoAsync(work, fileName: "a.txt", content: "one\ntwo\nthree\n"); | |
| 29 | + await host.Git.MustAsync(work, "checkout", "-b", "feature/x"); | |
| 30 | + await File.WriteAllTextAsync(Path.Combine(work, "a.txt"), "one\nTWO from feature\nthree\n"); | |
| 31 | + await File.WriteAllTextAsync(Path.Combine(work, "b.txt"), "new file\n"); | |
| 32 | + await host.Git.MustAsync(work, "add", "-A"); | |
| 33 | + await host.Git.MustAsync(work, "commit", "-m", "Feature work"); | |
| 34 | + await File.WriteAllTextAsync(Path.Combine(work, "b.txt"), "new file\nsecond line\n"); | |
| 35 | + await host.Git.MustAsync(work, "commit", "-am", "More feature work"); | |
| 36 | + var featureSha = await host.Git.MustAsync(work, "rev-parse", "HEAD"); | |
| 37 | + | |
| 38 | + await host.Git.MustAsync(work, "checkout", "main"); | |
| 39 | + if (diverge) | |
| 40 | + { | |
| 41 | + var (file, content) = conflict ? ("a.txt", "one\nTWO from main\nthree\n") : ("c.txt", "only on main\n"); | |
| 42 | + await File.WriteAllTextAsync(Path.Combine(work, file), content); | |
| 43 | + await host.Git.MustAsync(work, "add", "-A"); | |
| 44 | + await host.Git.MustAsync(work, "commit", "-m", "Main moves on"); | |
| 45 | + } | |
| 46 | + | |
| 47 | + var mainSha = await host.Git.MustAsync(work, "rev-parse", "HEAD"); | |
| 48 | + await host.Git.MustAsync(work, "push", url, "main", "feature/x"); | |
| 49 | + return new Scenario(repo, work, url, mainSha, featureSha); | |
| 50 | + } | |
| 51 | + | |
| 52 | + /// <summary>Fetches the server's state into the scenario's working repository and returns `git` output for it.</summary> | |
| 53 | + private async Task<string> ServerAsync(Scenario s, params string[] args) | |
| 54 | + { | |
| 55 | + await host.Git.MustAsync(s.Work, "fetch", "--prune", s.Url, "+refs/heads/*:refs/remotes/server/*"); | |
| 56 | + return await host.Git.MustAsync(s.Work, args); | |
| 57 | + } | |
| 58 | + | |
| 59 | + private Task<List<PushEvent>> EventsAsync(long repoId) => | |
| 60 | + host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().PushEvents | |
| 61 | + .Where(e => e.RepoId == repoId).OrderBy(e => e.Id).ToListAsync()); | |
| 62 | + | |
| 63 | + private Task<RefResult> MergeViaServiceAsync(Scenario s, MergeMethod method) => | |
| 64 | + host.WithScopeAsync(async sp => | |
| 65 | + { | |
| 66 | + var repo = await sp.GetRequiredService<RepoService>().FindAsync("jessie", s.Repo.Name); | |
| 67 | + var refs = sp.GetRequiredService<RefService>(); | |
| 68 | + return await refs.MergeAsync(repo!, new Git.GitIdentity("Jessie", "jessie@forge.test"), "main", "feature/x", method, null); | |
| 69 | + }); | |
| 70 | + | |
| 71 | + [Fact] | |
| 72 | + public async Task Compare_shows_commits_and_diff_and_offers_merge_only_to_the_owner() | |
| 73 | + { | |
| 74 | + var s = await CreateAsync("compare", diverge: true); | |
| 75 | + using var anonymous = host.CreateClient(); | |
| 76 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 77 | + | |
| 78 | + var page = await anonymous.GetStringAsync("/jessie/compare/compare/main...feature/x"); | |
| 79 | + Assert.Contains("Feature work", page); | |
| 80 | + Assert.Contains("More feature work", page); | |
| 81 | + Assert.DoesNotContain("Main moves on", page); | |
| 82 | + Assert.Contains("2 commits", page); | |
| 83 | + Assert.Contains("b.txt", page); | |
| 84 | + Assert.Contains("TWO from feature", page); | |
| 85 | + // The diff is taken from the point where the branches diverged, so main's own change is not in it. | |
| 86 | + Assert.DoesNotContain("only on main", page); | |
| 87 | + Assert.DoesNotContain("name=\"Method\"", page); | |
| 88 | + | |
| 89 | + var ownerPage = await owner.GetStringAsync("/jessie/compare/compare/main...feature/x"); | |
| 90 | + Assert.Contains("These branches can be merged automatically.", ownerPage); | |
| 91 | + Assert.Contains("name=\"Method\"", ownerPage); | |
| 92 | + // Diverged branches cannot fast-forward. | |
| 93 | + Assert.DoesNotContain("value=\"ff\"", ownerPage); | |
| 94 | + | |
| 95 | + // Two SHAs work too (webhook payloads link like this), and so does the picker's query form. | |
| 96 | + Assert.Equal(HttpStatusCode.OK, (await anonymous.GetAsync($"/jessie/compare/compare/{s.MainSha}...{s.FeatureSha}")).StatusCode); | |
| 97 | + var picked = await anonymous.GetAsync("/jessie/compare/compare?base=main&head=feature%2Fx"); | |
| 98 | + Assert.Equal("/jessie/compare/compare/main...feature/x", picked.Headers.Location?.PathAndQuery); | |
| 99 | + Assert.Equal(HttpStatusCode.OK, (await anonymous.GetAsync("/jessie/compare/compare")).StatusCode); | |
| 100 | + | |
| 101 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync("/jessie/compare/compare/main...nope")).StatusCode); | |
| 102 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync("/jessie/compare/compare/--all...main")).StatusCode); | |
| 103 | + | |
| 104 | + // The branches page links to the comparison. | |
| 105 | + Assert.Contains("href=\"/jessie/compare/compare/main...feature/x\"", await anonymous.GetStringAsync("/jessie/compare/branches")); | |
| 106 | + } | |
| 107 | + | |
| 108 | + [Fact] | |
| 109 | + public async Task Merge_commit_from_the_page_joins_both_histories_and_can_delete_the_branch() | |
| 110 | + { | |
| 111 | + var s = await CreateAsync("merge-commit", diverge: true); | |
| 112 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 113 | + | |
| 114 | + var merged = await ForgeHost.PostFormAsync(owner, "/jessie/merge-commit/compare/main...feature/x", "merge", new() | |
| 115 | + { | |
| 116 | + ["Method"] = "merge", | |
| 117 | + ["Message"] = "", | |
| 118 | + ["DeleteBranch"] = "true", | |
| 119 | + }); | |
| 120 | + Assert.Equal("/jessie/merge-commit/tree/main", merged.Headers.Location?.PathAndQuery); | |
| 121 | + | |
| 122 | + // The new commit has both tips as parents and carries both sides' changes. | |
| 123 | + var parents = (await ServerAsync(s, "log", "-1", "--format=%P", "server/main")).Split(' '); | |
| 124 | + Assert.Equal([s.MainSha, s.FeatureSha], parents); | |
| 125 | + Assert.Equal("Merge branch 'feature/x' into main", await host.Git.MustAsync(s.Work, "log", "-1", "--format=%s", "server/main")); | |
| 126 | + Assert.Equal("jessie <jessie@forge.test>", await host.Git.MustAsync(s.Work, "log", "-1", "--format=%an <%ae>", "server/main")); | |
| 127 | + var files = await host.Git.MustAsync(s.Work, "ls-tree", "--name-only", "server/main"); | |
| 128 | + Assert.Equal(["a.txt", "b.txt", "c.txt"], files.Split('\n')); | |
| 129 | + Assert.Contains("TWO from feature", await host.Git.MustAsync(s.Work, "show", "server/main:a.txt")); | |
| 130 | + | |
| 131 | + // The branch is gone, and both changes were recorded like pushes. | |
| 132 | + Assert.DoesNotContain("server/feature/x", await host.Git.MustAsync(s.Work, "branch", "-r")); | |
| 133 | + var events = (await EventsAsync(s.Repo.Id)).Skip(2).ToList(); | |
| 134 | + Assert.Collection( | |
| 135 | + events, | |
| 136 | + e => Assert.Equal(("refs/heads/main", s.MainSha), (e.RefName, e.OldSha)), | |
| 137 | + e => Assert.Equal(("refs/heads/feature/x", s.FeatureSha, Git.GitParsers.ZeroSha), (e.RefName, e.OldSha, e.NewSha))); | |
| 138 | + | |
| 139 | + // A normal git client accepts the result: pulling it is a fast-forward. | |
| 140 | + await host.Git.MustAsync(s.Work, "pull", "--ff-only", s.Url, "main"); | |
| 141 | + } | |
| 142 | + | |
| 143 | + [Fact] | |
| 144 | + public async Task Squash_creates_one_commit_with_a_single_parent() | |
| 145 | + { | |
| 146 | + var s = await CreateAsync("squash", diverge: true); | |
| 147 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 148 | + | |
| 149 | + await ForgeHost.PostFormAsync(owner, "/jessie/squash/compare/main...feature/x", "merge", new() | |
| 150 | + { | |
| 151 | + ["Method"] = "squash", | |
| 152 | + ["Message"] = "", | |
| 153 | + }); | |
| 154 | + | |
| 155 | + Assert.Equal(s.MainSha, await ServerAsync(s, "log", "-1", "--format=%P", "server/main")); | |
| 156 | + var message = await host.Git.MustAsync(s.Work, "log", "-1", "--format=%B", "server/main"); | |
| 157 | + Assert.StartsWith("Squash branch 'feature/x' into main", message); | |
| 158 | + Assert.Contains("* Feature work", message); | |
| 159 | + Assert.Contains("* More feature work", message); | |
| 160 | + Assert.Equal("new file\nsecond line", await host.Git.MustAsync(s.Work, "show", "server/main:b.txt")); | |
| 161 | + // Without the checkbox the branch stays. | |
| 162 | + Assert.Contains("server/feature/x", await host.Git.MustAsync(s.Work, "branch", "-r")); | |
| 163 | + } | |
| 164 | + | |
| 165 | + [Fact] | |
| 166 | + public async Task Fast_forward_moves_the_branch_without_a_new_commit() | |
| 167 | + { | |
| 168 | + var s = await CreateAsync("fast-forward"); | |
| 169 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 170 | + | |
| 171 | + var page = await owner.GetStringAsync("/jessie/fast-forward/compare/main...feature/x"); | |
| 172 | + Assert.Contains("value=\"ff\"", page); | |
| 173 | + | |
| 174 | + await ForgeHost.PostFormAsync(owner, "/jessie/fast-forward/compare/main...feature/x", "merge", new() | |
| 175 | + { | |
| 176 | + ["Method"] = "ff", | |
| 177 | + ["Message"] = "ignored", | |
| 178 | + }); | |
| 179 | + | |
| 180 | + Assert.Equal(s.FeatureSha, await ServerAsync(s, "rev-parse", "server/main")); | |
| 181 | + | |
| 182 | + // Now there is nothing left to merge, and the page says so instead of offering the form. | |
| 183 | + var after = await owner.GetStringAsync("/jessie/fast-forward/compare/main...feature/x"); | |
| 184 | + Assert.DoesNotContain("name=\"Method\"", after); | |
| 185 | + Assert.Equal("There is nothing to merge.", (await MergeViaServiceAsync(s, MergeMethod.MergeCommit)).Error); | |
| 186 | + } | |
| 187 | + | |
| 188 | + [Fact] | |
| 189 | + public async Task Custom_message_is_used_for_the_merge_commit() | |
| 190 | + { | |
| 191 | + var s = await CreateAsync("message", diverge: true); | |
| 192 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 193 | + | |
| 194 | + await ForgeHost.PostFormAsync(owner, "/jessie/message/compare/main...feature/x", "merge", new() | |
| 195 | + { | |
| 196 | + ["Method"] = "merge", | |
| 197 | + ["Message"] = "--amend is just text here", | |
| 198 | + }); | |
| 199 | + | |
| 200 | + Assert.Equal("--amend is just text here", await ServerAsync(s, "log", "-1", "--format=%s", "server/main")); | |
| 201 | + } | |
| 202 | + | |
| 203 | + [Fact] | |
| 204 | + public async Task Conflicting_branches_are_reported_and_left_alone() | |
| 205 | + { | |
| 206 | + var s = await CreateAsync("conflict", diverge: true, conflict: true); | |
| 207 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 208 | + | |
| 209 | + var page = await owner.GetStringAsync("/jessie/conflict/compare/main...feature/x"); | |
| 210 | + Assert.Contains("These branches have conflicts", page); | |
| 211 | + Assert.Contains("<code>a.txt</code>", page); | |
| 212 | + Assert.DoesNotContain("name=\"Method\"", page); | |
| 213 | + | |
| 214 | + foreach (var method in (MergeMethod[])[MergeMethod.MergeCommit, MergeMethod.Squash]) | |
| 215 | + { | |
| 216 | + var result = await MergeViaServiceAsync(s, method); | |
| 217 | + Assert.Equal("The branches have conflicts and cannot be merged automatically.", result.Error); | |
| 218 | + Assert.Equal(["a.txt"], result.Conflicts); | |
| 219 | + } | |
| 220 | + | |
| 221 | + Assert.Equal( | |
| 222 | + "Fast-forward is not possible because the branches have diverged.", | |
| 223 | + (await MergeViaServiceAsync(s, MergeMethod.FastForward)).Error); | |
| 224 | + | |
| 225 | + Assert.Equal(s.MainSha, await ServerAsync(s, "rev-parse", "server/main")); | |
| 226 | + Assert.Equal(2, (await EventsAsync(s.Repo.Id)).Count); | |
| 227 | + } | |
| 228 | + | |
| 229 | + [Fact] | |
| 230 | + public async Task Visitors_cannot_merge_or_change_refs() | |
| 231 | + { | |
| 232 | + var s = await CreateAsync("visitor", diverge: true); | |
| 233 | + using var anonymous = host.CreateClient(); | |
| 234 | + | |
| 235 | + // The compare page renders no merge form for a visitor, so the post has nothing to bind to. | |
| 236 | + var merge = await ForgeHost.PostFormAsync(anonymous, "/jessie/visitor/compare/main...feature/x", "merge", new() { ["Method"] = "merge" }); | |
| 237 | + Assert.Equal(HttpStatusCode.BadRequest, merge.StatusCode); | |
| 238 | + | |
| 239 | + // The delete form is on the page for everyone (its buttons are not); the handler must refuse on its own. | |
| 240 | + await ForgeHost.PostFormAsync(anonymous, "/jessie/visitor/branches", "delete-branch", new() { ["DeleteName"] = "feature/x" }); | |
| 241 | + await ForgeHost.PostFormAsync(anonymous, "/jessie/visitor/branches", "create-branch", new() { ["NewName"] = "sneaky", ["From"] = "main" }); | |
| 242 | + | |
| 243 | + var branches = await ServerAsync(s, "branch", "-r"); | |
| 244 | + Assert.Contains("server/feature/x", branches); | |
| 245 | + Assert.DoesNotContain("sneaky", branches); | |
| 246 | + Assert.Equal(s.MainSha, await host.Git.MustAsync(s.Work, "rev-parse", "server/main")); | |
| 247 | + | |
| 248 | + // Nothing in a private repository is reachable at all. | |
| 249 | + await CreateAsync("visitor-private", visibility: Visibility.Private); | |
| 250 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync("/jessie/visitor-private/compare/main...feature/x")).StatusCode); | |
| 251 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync("/jessie/visitor-private/compare")).StatusCode); | |
| 252 | + } | |
| 253 | + | |
| 254 | + [Fact] | |
| 255 | + public async Task Branches_are_created_and_deleted_from_the_page() | |
| 256 | + { | |
| 257 | + var s = await CreateAsync("branches"); | |
| 258 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 259 | + const string page = "/jessie/branches/branches"; | |
| 260 | + | |
| 261 | + var created = await ForgeHost.PostFormAsync(owner, page, "create-branch", new() { ["NewName"] = "release/1.0", ["From"] = "feature/x" }); | |
| 262 | + Assert.Contains("Branch release/1.0 was created.", await ForgeHost.TextAsync(created)); | |
| 263 | + Assert.Equal(s.FeatureSha, await ServerAsync(s, "rev-parse", "server/release/1.0")); | |
| 264 | + | |
| 265 | + // From a commit SHA. | |
| 266 | + await ForgeHost.PostFormAsync(owner, page, "create-branch", new() { ["NewName"] = "from-sha", ["From"] = s.MainSha }); | |
| 267 | + Assert.Equal(s.MainSha, await ServerAsync(s, "rev-parse", "server/from-sha")); | |
| 268 | + | |
| 269 | + var duplicate = await ForgeHost.PostFormAsync(owner, page, "create-branch", new() { ["NewName"] = "from-sha", ["From"] = "main" }); | |
| 270 | + Assert.Contains("A branch with this name already exists.", await ForgeHost.TextAsync(duplicate)); | |
| 271 | + | |
| 272 | + var missing = await ForgeHost.PostFormAsync(owner, page, "create-branch", new() { ["NewName"] = "ok-name", ["From"] = "nope" }); | |
| 273 | + Assert.Contains("The starting point does not exist.", await ForgeHost.TextAsync(missing)); | |
| 274 | + | |
| 275 | + foreach (var bad in (string[])["-x", "--force", "a..b", "has space", "ends.lock", "a~1", "HEAD", "x/", "a:b"]) | |
| 276 | + { | |
| 277 | + var refused = await ForgeHost.PostFormAsync(owner, page, "create-branch", new() { ["NewName"] = bad, ["From"] = "main" }); | |
| 278 | + Assert.True( | |
| 279 | + (await ForgeHost.TextAsync(refused)).Contains("This is not a valid branch name."), | |
| 280 | + $"Branch name '{bad}' was not refused."); | |
| 281 | + } | |
| 282 | + | |
| 283 | + var deleted = await ForgeHost.PostFormAsync(owner, page, "delete-branch", new() { ["DeleteName"] = "release/1.0" }); | |
| 284 | + Assert.Contains($"Branch release/1.0 was deleted (it pointed at {s.FeatureSha}).", await ForgeHost.TextAsync(deleted)); | |
| 285 | + | |
| 286 | + var protectedDefault = await ForgeHost.PostFormAsync(owner, page, "delete-branch", new() { ["DeleteName"] = "main" }); | |
| 287 | + Assert.Contains("The default branch cannot be deleted.", await ForgeHost.TextAsync(protectedDefault)); | |
| 288 | + | |
| 289 | + var branches = (await ServerAsync(s, "branch", "-r")).Split('\n').Select(b => b.Trim()).Order().ToList(); | |
| 290 | + Assert.Equal(["server/feature/x", "server/from-sha", "server/main"], branches); | |
| 291 | + | |
| 292 | + // Creations and the deletion were recorded as push events, after the two from the initial push. | |
| 293 | + var events = (await EventsAsync(s.Repo.Id)).Skip(2).Select(e => (e.RefName, Created: e.OldSha == Git.GitParsers.ZeroSha, Deleted: e.NewSha == Git.GitParsers.ZeroSha)).ToList(); | |
| 294 | + Assert.Equal( | |
| 295 | + [ | |
| 296 | + ("refs/heads/release/1.0", true, false), | |
| 297 | + ("refs/heads/from-sha", true, false), | |
| 298 | + ("refs/heads/release/1.0", false, true), | |
| 299 | + ], events); | |
| 300 | + } | |
| 301 | + | |
| 302 | + [Fact] | |
| 303 | + public async Task Tags_are_created_and_deleted_from_the_page() | |
| 304 | + { | |
| 305 | + var s = await CreateAsync("tags"); | |
| 306 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 307 | + const string page = "/jessie/tags/tags"; | |
| 308 | + | |
| 309 | + var created = await ForgeHost.PostFormAsync(owner, page, "create-tag", new() { ["NewName"] = "v1.0", ["From"] = "feature/x" }); | |
| 310 | + var html = await ForgeHost.TextAsync(created); | |
| 311 | + Assert.Contains("Tag v1.0 was created.", html); | |
| 312 | + Assert.Contains("href=\"/jessie/tags/tree/v1.0\"", html); | |
| 313 | + | |
| 314 | + await host.Git.MustAsync(s.Work, "fetch", "--tags", s.Url); | |
| 315 | + Assert.Equal(s.FeatureSha, await host.Git.MustAsync(s.Work, "rev-parse", "v1.0^{commit}")); | |
| 316 | + | |
| 317 | + var duplicate = await ForgeHost.PostFormAsync(owner, page, "create-tag", new() { ["NewName"] = "v1.0", ["From"] = "main" }); | |
| 318 | + Assert.Contains("A tag with this name already exists.", await ForgeHost.TextAsync(duplicate)); | |
| 319 | + var invalid = await ForgeHost.PostFormAsync(owner, page, "create-tag", new() { ["NewName"] = "-d", ["From"] = "main" }); | |
| 320 | + Assert.Contains("This is not a valid tag name.", await ForgeHost.TextAsync(invalid)); | |
| 321 | + | |
| 322 | + var deleted = await ForgeHost.PostFormAsync(owner, page, "delete-tag", new() { ["DeleteName"] = "v1.0" }); | |
| 323 | + Assert.Contains($"Tag v1.0 was deleted (it pointed at {s.FeatureSha}).", await ForgeHost.TextAsync(deleted)); | |
| 324 | + Assert.Equal("", await host.Git.MustAsync(s.Work, "ls-remote", "--tags", s.Url)); | |
| 325 | + } | |
| 326 | +} |
added forge.Tests/ParserTests.cs +340 −0View file
| @@ -0,0 +1,340 @@ | ||
| 1 | +using Forge.Features.Auth; | |
| 2 | +using Forge.Features.Browse; | |
| 3 | +using Forge.Features.Repos; | |
| 4 | +using Forge.Features.SmartHttp; | |
| 5 | +using Forge.Features.Webhooks; | |
| 6 | +using Forge.Git; | |
| 7 | + | |
| 8 | +namespace Forge.Tests; | |
| 9 | + | |
| 10 | +/// <summary>Pure logic that needs neither git nor the web app.</summary> | |
| 11 | +public class ParserTests | |
| 12 | +{ | |
| 13 | + [Fact] | |
| 14 | + public void ParseTree_reads_modes_sizes_and_names_with_spaces() | |
| 15 | + { | |
| 16 | + const string output = | |
| 17 | + "100644 blob 1111111111111111111111111111111111111111 12\tfile with space.txt\0" | |
| 18 | + + "040000 tree 2222222222222222222222222222222222222222 -\tsrc\0" | |
| 19 | + + "160000 commit 3333333333333333333333333333333333333333 -\tvendor/lib\0"; | |
| 20 | + | |
| 21 | + var entries = GitParsers.ParseTree(output); | |
| 22 | + | |
| 23 | + Assert.Equal(3, entries.Count); | |
| 24 | + Assert.Equal("file with space.txt", entries[0].Name); | |
| 25 | + Assert.Equal(12, entries[0].Size); | |
| 26 | + Assert.True(entries[0].IsBlob); | |
| 27 | + Assert.True(entries[1].IsTree); | |
| 28 | + Assert.Null(entries[1].Size); | |
| 29 | + Assert.Equal("lib", entries[2].Name); | |
| 30 | + Assert.True(entries[2].IsSubmodule); | |
| 31 | + } | |
| 32 | + | |
| 33 | + [Fact] | |
| 34 | + public void ParseLog_splits_records_and_keeps_multiline_bodies() | |
| 35 | + { | |
| 36 | + var a = new string('a', 40); | |
| 37 | + var b = new string('b', 40); | |
| 38 | + var output = | |
| 39 | + $"{a}\0{b}\0Ann\0ann@example.com\01700000000\0Bob\0bob@example.com\01700000100\0Subject one\0Body line 1\nBody line 2\n\0\n" | |
| 40 | + + $"{b}\0\0Ann\0ann@example.com\01600000000\0Ann\0ann@example.com\01600000000\0Root\0\0\n"; | |
| 41 | + | |
| 42 | + var commits = GitParsers.ParseLog(output); | |
| 43 | + | |
| 44 | + Assert.Equal(2, commits.Count); | |
| 45 | + Assert.Equal(a, commits[0].Sha); | |
| 46 | + Assert.Equal([b], commits[0].Parents); | |
| 47 | + Assert.Equal("Body line 1\nBody line 2", commits[0].Body); | |
| 48 | + Assert.Equal("Bob", commits[0].CommitterName); | |
| 49 | + Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1700000000), commits[0].AuthorDate); | |
| 50 | + Assert.Equal(b, commits[1].Sha); | |
| 51 | + Assert.Empty(commits[1].Parents); | |
| 52 | + Assert.Equal("", commits[1].Body); | |
| 53 | + } | |
| 54 | + | |
| 55 | + [Fact] | |
| 56 | + public void ParseNumstat_handles_renames_and_binary_files() | |
| 57 | + { | |
| 58 | + const string output = "3\t1\tsrc/a.cs\0-\t-\tlogo.png\00\t0\t\0old name.txt\0new name.txt\0"; | |
| 59 | + | |
| 60 | + var stats = GitParsers.ParseNumstat(output); | |
| 61 | + | |
| 62 | + Assert.Equal(3, stats.Count); | |
| 63 | + Assert.Equal(new FileStat("src/a.cs", null, 3, 1), stats[0]); | |
| 64 | + Assert.True(stats[1].IsBinary); | |
| 65 | + Assert.Equal("new name.txt", stats[2].Path); | |
| 66 | + Assert.Equal("old name.txt", stats[2].OldPath); | |
| 67 | + } | |
| 68 | + | |
| 69 | + [Fact] | |
| 70 | + public void ParseDiff_builds_hunks_with_line_numbers() | |
| 71 | + { | |
| 72 | + const string patch = """ | |
| 73 | + diff --git a/src/a.cs b/src/a.cs | |
| 74 | + index 1111111..2222222 100644 | |
| 75 | + --- a/src/a.cs | |
| 76 | + +++ b/src/a.cs | |
| 77 | + @@ -1,3 +1,4 @@ class A | |
| 78 | + line one | |
| 79 | + -line two | |
| 80 | + +line 2 | |
| 81 | + +line 2b | |
| 82 | + line three | |
| 83 | + \ No newline at end of file | |
| 84 | + diff --git a/logo.png b/logo.png | |
| 85 | + new file mode 100644 | |
| 86 | + index 0000000..3333333 | |
| 87 | + Binary files /dev/null and b/logo.png differ | |
| 88 | + diff --git a/old name.txt b/new name.txt | |
| 89 | + similarity index 100% | |
| 90 | + rename from old name.txt | |
| 91 | + rename to new name.txt | |
| 92 | + diff --git a/gone.txt b/gone.txt | |
| 93 | + deleted file mode 100644 | |
| 94 | + index 4444444..0000000 | |
| 95 | + --- a/gone.txt | |
| 96 | + +++ /dev/null | |
| 97 | + @@ -1 +0,0 @@ | |
| 98 | + -bye | |
| 99 | + | |
| 100 | + """; | |
| 101 | + | |
| 102 | + var diff = GitParsers.ParseDiff(patch.ReplaceLineEndings("\n")); | |
| 103 | + | |
| 104 | + Assert.False(diff.Truncated); | |
| 105 | + Assert.Equal(4, diff.Files.Count); | |
| 106 | + | |
| 107 | + var modified = diff.Files[0]; | |
| 108 | + Assert.Equal("src/a.cs", modified.NewPath); | |
| 109 | + Assert.Equal(FileChange.Modified, modified.Change); | |
| 110 | + Assert.Equal(2, modified.Added); | |
| 111 | + Assert.Equal(1, modified.Deleted); | |
| 112 | + var lines = Assert.Single(modified.Hunks).Lines; | |
| 113 | + Assert.Equal(new DiffLine(DiffLineKind.Context, 1, 1, "line one"), lines[0]); | |
| 114 | + Assert.Equal(new DiffLine(DiffLineKind.Deleted, 2, null, "line two"), lines[1]); | |
| 115 | + Assert.Equal(new DiffLine(DiffLineKind.Added, null, 2, "line 2"), lines[2]); | |
| 116 | + Assert.Equal(new DiffLine(DiffLineKind.Added, null, 3, "line 2b"), lines[3]); | |
| 117 | + Assert.Equal(new DiffLine(DiffLineKind.Context, 3, 4, "line three"), lines[4]); | |
| 118 | + Assert.Equal(DiffLineKind.NoNewline, lines[5].Kind); | |
| 119 | + | |
| 120 | + var binary = diff.Files[1]; | |
| 121 | + Assert.True(binary.IsBinary); | |
| 122 | + Assert.Equal(FileChange.Added, binary.Change); | |
| 123 | + Assert.Equal("logo.png", binary.NewPath); | |
| 124 | + | |
| 125 | + var renamed = diff.Files[2]; | |
| 126 | + Assert.Equal(FileChange.Renamed, renamed.Change); | |
| 127 | + Assert.Equal("old name.txt", renamed.OldPath); | |
| 128 | + Assert.Equal("new name.txt", renamed.NewPath); | |
| 129 | + | |
| 130 | + var deleted = diff.Files[3]; | |
| 131 | + Assert.Equal(FileChange.Deleted, deleted.Change); | |
| 132 | + Assert.Equal("gone.txt", deleted.DisplayPath); | |
| 133 | + } | |
| 134 | + | |
| 135 | + [Fact] | |
| 136 | + public void ParseDiff_applies_file_and_line_limits() | |
| 137 | + { | |
| 138 | + var big = "diff --git a/big.txt b/big.txt\n--- a/big.txt\n+++ b/big.txt\n@@ -0,0 +1,5 @@\n+1\n+2\n+3\n+4\n+5\n"; | |
| 139 | + var patch = big + "diff --git a/b.txt b/b.txt\n--- a/b.txt\n+++ b/b.txt\n@@ -1 +1 @@\n-x\n+y\n" | |
| 140 | + + "diff --git a/c.txt b/c.txt\n--- a/c.txt\n+++ b/c.txt\n@@ -1 +1 @@\n-x\n+y\n"; | |
| 141 | + | |
| 142 | + var diff = GitParsers.ParseDiff(patch, maxFiles: 2, maxLinesPerFile: 3); | |
| 143 | + | |
| 144 | + Assert.True(diff.Truncated); | |
| 145 | + Assert.Equal(2, diff.Files.Count); | |
| 146 | + Assert.True(diff.Files[0].TooLarge); | |
| 147 | + Assert.Empty(diff.Files[0].Hunks); | |
| 148 | + Assert.Equal(5, diff.Files[0].Added); | |
| 149 | + Assert.False(diff.Files[1].TooLarge); | |
| 150 | + } | |
| 151 | + | |
| 152 | + [Theory] | |
| 153 | + [InlineData("plain.txt", "plain.txt")] | |
| 154 | + [InlineData("\"tab\\there.txt\"", "tab\there.txt")] | |
| 155 | + [InlineData("\"quote\\\"d.txt\"", "quote\"d.txt")] | |
| 156 | + [InlineData("\"\\303\\251t\\303\\251.txt\"", "été.txt")] | |
| 157 | + public void Unquote_reverses_git_path_quoting(string quoted, string expected) => | |
| 158 | + Assert.Equal(expected, GitParsers.Unquote(quoted)); | |
| 159 | + | |
| 160 | + [Fact] | |
| 161 | + public void IsBinary_looks_for_nul_in_the_first_8000_bytes() | |
| 162 | + { | |
| 163 | + var late = new byte[9000]; | |
| 164 | + Array.Fill(late, (byte)'a'); | |
| 165 | + late[8500] = 0; | |
| 166 | + var early = (byte[])late.Clone(); | |
| 167 | + early[100] = 0; | |
| 168 | + | |
| 169 | + Assert.False(GitParsers.IsBinary(late)); | |
| 170 | + Assert.True(GitParsers.IsBinary(early)); | |
| 171 | + Assert.False(GitParsers.IsBinary("text"u8)); | |
| 172 | + } | |
| 173 | + | |
| 174 | + [Fact] | |
| 175 | + public void RefResolver_prefers_the_longest_matching_ref() | |
| 176 | + { | |
| 177 | + var sha1 = new string('1', 40); | |
| 178 | + var sha2 = new string('2', 40); | |
| 179 | + GitRef[] refs = | |
| 180 | + [ | |
| 181 | + new("refs/heads/feature", "feature", RefKind.Branch, sha1, "commit", null, null, ""), | |
| 182 | + new("refs/heads/feature/x", "feature/x", RefKind.Branch, sha2, "commit", null, null, ""), | |
| 183 | + new("refs/tags/v1.0", "v1.0", RefKind.Tag, sha1, "tag", sha2, null, ""), | |
| 184 | + ]; | |
| 185 | + | |
| 186 | + var deep = RefResolver.Match(refs, "feature/x/src/a.cs"); | |
| 187 | + Assert.Equal(new ResolvedRef("feature/x", ResolvedKind.Branch, sha2, "src/a.cs"), deep); | |
| 188 | + | |
| 189 | + var shallow = RefResolver.Match(refs, "feature/y/a.cs"); | |
| 190 | + Assert.Equal(new ResolvedRef("feature", ResolvedKind.Branch, sha1, "y/a.cs"), shallow); | |
| 191 | + | |
| 192 | + // An annotated tag resolves to the commit it points at. | |
| 193 | + Assert.Equal(new ResolvedRef("v1.0", ResolvedKind.Tag, sha2, ""), RefResolver.Match(refs, "v1.0")); | |
| 194 | + } | |
| 195 | + | |
| 196 | + [Theory] | |
| 197 | + [InlineData("--upload-pack=touch /tmp/x")] | |
| 198 | + [InlineData("-n")] | |
| 199 | + [InlineData("feature/../x")] | |
| 200 | + [InlineData("nope")] | |
| 201 | + [InlineData("")] | |
| 202 | + public void RefResolver_rejects_anything_that_is_not_an_existing_ref(string input) | |
| 203 | + { | |
| 204 | + GitRef[] refs = [new("refs/heads/feature", "feature", RefKind.Branch, new string('1', 40), "commit", null, null, "")]; | |
| 205 | + Assert.Null(RefResolver.Match(refs, input)); | |
| 206 | + } | |
| 207 | + | |
| 208 | + [Theory] | |
| 209 | + [InlineData("forge", true)] | |
| 210 | + [InlineData("my.repo_2-x", true)] | |
| 211 | + [InlineData("-leading-dash", true)] | |
| 212 | + [InlineData("", false)] | |
| 213 | + [InlineData(".", false)] | |
| 214 | + [InlineData("..", false)] | |
| 215 | + [InlineData("a..b", false)] | |
| 216 | + [InlineData("a/b", false)] | |
| 217 | + [InlineData("a\\b", false)] | |
| 218 | + [InlineData("repo.git", false)] | |
| 219 | + [InlineData("repo.GIT", false)] | |
| 220 | + [InlineData("has space", false)] | |
| 221 | + [InlineData("name\n", false)] | |
| 222 | + [InlineData("ž", false)] | |
| 223 | + public void Repository_names_are_validated(string name, bool valid) => | |
| 224 | + Assert.Equal(valid, RepoService.ValidateName(name) is null); | |
| 225 | + | |
| 226 | + [Fact] | |
| 227 | + public void Repository_name_length_is_limited_to_100() | |
| 228 | + { | |
| 229 | + Assert.Null(RepoService.ValidateName(new string('a', 100))); | |
| 230 | + Assert.NotNull(RepoService.ValidateName(new string('a', 101))); | |
| 231 | + } | |
| 232 | + | |
| 233 | + [Theory] | |
| 234 | + [InlineData("jessie", true)] | |
| 235 | + [InlineData("settings", false)] | |
| 236 | + [InlineData("Login", false)] | |
| 237 | + [InlineData("-x", false)] | |
| 238 | + [InlineData("a.b", false)] | |
| 239 | + public void Usernames_are_validated(string name, bool valid) => | |
| 240 | + Assert.Equal(valid, AccountRules.ValidateUsername(name) is null); | |
| 241 | + | |
| 242 | + [Fact] | |
| 243 | + public void PktLine_prefixes_the_total_length_in_hex() => | |
| 244 | + Assert.Equal("001e# service=git-upload-pack\n", System.Text.Encoding.ASCII.GetString(SmartHttpEndpoints.PktLine("# service=git-upload-pack\n"))); | |
| 245 | + | |
| 246 | + [Theory] | |
| 247 | + [InlineData("version=2", "version=2")] | |
| 248 | + [InlineData("version=2:object-format=sha1", "version=2:object-format=sha1")] | |
| 249 | + [InlineData("version=2; rm -rf /", null)] | |
| 250 | + [InlineData("a b", null)] | |
| 251 | + [InlineData("", null)] | |
| 252 | + public void Git_protocol_header_is_validated(string header, string? expected) => | |
| 253 | + Assert.Equal(expected, SmartHttpEndpoints.ValidateProtocolHeader(header)); | |
| 254 | + | |
| 255 | + [Fact] | |
| 256 | + public void Basic_auth_password_is_extracted() | |
| 257 | + { | |
| 258 | + var header = "Basic " + Convert.ToBase64String("git:forge_abc:def"u8); | |
| 259 | + Assert.Equal("forge_abc:def", SmartHttpEndpoints.ParseBasicPassword(header)); | |
| 260 | + Assert.Null(SmartHttpEndpoints.ParseBasicPassword(null)); | |
| 261 | + Assert.Null(SmartHttpEndpoints.ParseBasicPassword("Bearer x")); | |
| 262 | + Assert.Equal("", SmartHttpEndpoints.ParseBasicPassword("Basic !!!")); | |
| 263 | + } | |
| 264 | + | |
| 265 | + [Fact] | |
| 266 | + public void Push_diff_reports_created_updated_and_deleted_refs() | |
| 267 | + { | |
| 268 | + var a = new string('a', 40); | |
| 269 | + var b = new string('b', 40); | |
| 270 | + var before = new Dictionary<string, string> { ["refs/heads/main"] = a, ["refs/heads/old"] = a }; | |
| 271 | + var after = new Dictionary<string, string> { ["refs/heads/main"] = b, ["refs/tags/v1"] = b }; | |
| 272 | + | |
| 273 | + var changes = PushRecorder.Diff(before, after); | |
| 274 | + | |
| 275 | + Assert.Equal( | |
| 276 | + [ | |
| 277 | + new RefChange("refs/heads/main", a, b), | |
| 278 | + new RefChange("refs/heads/old", a, GitParsers.ZeroSha), | |
| 279 | + new RefChange("refs/tags/v1", GitParsers.ZeroSha, b), | |
| 280 | + ], changes); | |
| 281 | + } | |
| 282 | + | |
| 283 | + [Fact] | |
| 284 | + public void Tokens_are_hashed_with_sha256() | |
| 285 | + { | |
| 286 | + Assert.Equal( | |
| 287 | + "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", | |
| 288 | + TokenService.Hash("abc")); | |
| 289 | + } | |
| 290 | + | |
| 291 | + [Fact] | |
| 292 | + public void Webhook_signature_is_hmac_sha256_of_the_body() | |
| 293 | + { | |
| 294 | + // RFC 4231 test case 2. | |
| 295 | + Assert.Equal( | |
| 296 | + "sha256=5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843", | |
| 297 | + WebhookSender.Sign("Jefe", "what do ya want for nothing?"u8)); | |
| 298 | + } | |
| 299 | + | |
| 300 | + [Fact] | |
| 301 | + public void Markdown_is_sanitized_and_relative_links_point_into_the_repository() | |
| 302 | + { | |
| 303 | + var links = new LinkContext("/o/r/raw/main", "/o/r/blob/main", "docs"); | |
| 304 | + var html = new MarkdownRenderer().Render( | |
| 305 | + """ | |
| 306 | + # Title | |
| 307 | + | |
| 308 | +  [guide](../GUIDE.md) [root](/LICENSE) [ext](https://example.com/x) [anchor](#top) | |
| 309 | + | |
| 310 | + <script>alert(1)</script> | |
| 311 | + <img src="x.png" onerror="alert(1)"> | |
| 312 | + <a href="javascript:alert(1)">bad</a> | |
| 313 | + """, | |
| 314 | + links); | |
| 315 | + | |
| 316 | + Assert.Contains("src=\"/o/r/raw/main/docs/img/logo.png\"", html); | |
| 317 | + Assert.Contains("href=\"/o/r/blob/main/GUIDE.md\"", html); | |
| 318 | + Assert.Contains("href=\"/o/r/blob/main/LICENSE\"", html); | |
| 319 | + Assert.Contains("src=\"/o/r/raw/main/docs/x.png\"", html); | |
| 320 | + Assert.Contains("href=\"#top\"", html); | |
| 321 | + Assert.Matches("<a[^>]*href=\"https://example.com/x\"[^>]*rel=\"nofollow noopener\"", html); | |
| 322 | + Assert.DoesNotContain("<script", html); | |
| 323 | + Assert.DoesNotContain("onerror", html); | |
| 324 | + Assert.DoesNotContain("javascript:", html); | |
| 325 | + } | |
| 326 | + | |
| 327 | + [Fact] | |
| 328 | + public void Auth_failure_limiter_blocks_after_repeated_failures() | |
| 329 | + { | |
| 330 | + var limiter = new AuthFailureLimiter(TimeProvider.System); | |
| 331 | + for (var i = 0; i < AuthFailureLimiter.MaxFailures; i++) | |
| 332 | + { | |
| 333 | + Assert.False(limiter.IsBlocked("1.2.3.4")); | |
| 334 | + limiter.RecordFailure("1.2.3.4"); | |
| 335 | + } | |
| 336 | + | |
| 337 | + Assert.True(limiter.IsBlocked("1.2.3.4")); | |
| 338 | + Assert.False(limiter.IsBlocked("5.6.7.8")); | |
| 339 | + } | |
| 340 | +} |
added forge.Tests/SmartHttpTests.cs +218 −0View file
| @@ -0,0 +1,218 @@ | ||
| 1 | +using System.Net; | |
| 2 | +using System.Net.Http.Headers; | |
| 3 | +using System.Text; | |
| 4 | +using Forge.Data; | |
| 5 | +using Forge.Tests.Support; | |
| 6 | +using Microsoft.EntityFrameworkCore; | |
| 7 | +using Microsoft.Extensions.DependencyInjection; | |
| 8 | + | |
| 9 | +namespace Forge.Tests; | |
| 10 | + | |
| 11 | +/// <summary>Real `git clone` and `git push` against the running app.</summary> | |
| 12 | +public class SmartHttpTests(ForgeHost host) : IClassFixture<ForgeHost> | |
| 13 | +{ | |
| 14 | + [Theory] | |
| 15 | + [InlineData("0")] | |
| 16 | + [InlineData("2")] | |
| 17 | + public async Task Push_then_clone_round_trips(string protocolVersion) | |
| 18 | + { | |
| 19 | + var user = await host.CreateUserAsync(); | |
| 20 | + var name = "roundtrip-v" + protocolVersion; | |
| 21 | + var repo = await host.CreateRepoAsync(user, name, Visibility.Public); | |
| 22 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 23 | + var protocol = "protocol.version=" + protocolVersion; | |
| 24 | + | |
| 25 | + var work = host.NewDir("work"); | |
| 26 | + var sha = await host.Git.CreateWorkRepoAsync(work); | |
| 27 | + await host.Git.MustAsync(work, "-c", protocol, "push", host.GitUrl(user.Username, name, token), "main"); | |
| 28 | + | |
| 29 | + // Tags go up with --tags. | |
| 30 | + await host.Git.MustAsync(work, "tag", "-a", "v1", "-m", "one"); | |
| 31 | + await host.Git.MustAsync(work, "-c", protocol, "push", "--tags", host.GitUrl(user.Username, name, token)); | |
| 32 | + | |
| 33 | + // A public repository clones without credentials. | |
| 34 | + var clone = host.NewDir("clone"); | |
| 35 | + await host.Git.MustAsync(clone, "-c", protocol, "clone", host.GitUrl(user.Username, name), "."); | |
| 36 | + Assert.Equal(sha, await host.Git.MustAsync(clone, "rev-parse", "HEAD")); | |
| 37 | + Assert.Equal("# Demo\n", await File.ReadAllTextAsync(Path.Combine(clone, "README.md"))); | |
| 38 | + Assert.Equal("v1", await host.Git.MustAsync(clone, "tag", "--list")); | |
| 39 | + | |
| 40 | + // A second push is a fast-forward and is recorded as an update. | |
| 41 | + await File.WriteAllTextAsync(Path.Combine(work, "second.txt"), "more\n"); | |
| 42 | + await host.Git.MustAsync(work, "add", "-A"); | |
| 43 | + await host.Git.MustAsync(work, "commit", "-m", "Second"); | |
| 44 | + var secondSha = await host.Git.MustAsync(work, "rev-parse", "HEAD"); | |
| 45 | + await host.Git.MustAsync(work, "-c", protocol, "push", host.GitUrl(user.Username, name, token), "main"); | |
| 46 | + await host.Git.MustAsync(clone, "-c", protocol, "pull", "--ff-only"); | |
| 47 | + Assert.Equal(secondSha, await host.Git.MustAsync(clone, "rev-parse", "HEAD")); | |
| 48 | + | |
| 49 | + var events = await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().PushEvents | |
| 50 | + .Where(e => e.RepoId == repo.Id).OrderBy(e => e.Id).ToListAsync()); | |
| 51 | + Assert.Collection( | |
| 52 | + events, | |
| 53 | + e => Assert.Equal(("refs/heads/main", Git.GitParsers.ZeroSha, sha), (e.RefName, e.OldSha, e.NewSha)), | |
| 54 | + e => Assert.Equal(("refs/tags/v1", Git.GitParsers.ZeroSha), (e.RefName, e.OldSha)), | |
| 55 | + e => Assert.Equal(("refs/heads/main", sha, secondSha), (e.RefName, e.OldSha, e.NewSha))); | |
| 56 | + | |
| 57 | + var reloaded = await host.ReloadRepoAsync(repo.Id); | |
| 58 | + Assert.NotNull(reloaded.PushedAt); | |
| 59 | + Assert.Equal("main", reloaded.DefaultBranch); | |
| 60 | + } | |
| 61 | + | |
| 62 | + [Fact] | |
| 63 | + public async Task First_push_of_another_branch_becomes_the_default_branch() | |
| 64 | + { | |
| 65 | + var user = await host.CreateUserAsync(); | |
| 66 | + var repo = await host.CreateRepoAsync(user, "master-first", Visibility.Public); | |
| 67 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 68 | + | |
| 69 | + var work = host.NewDir("work"); | |
| 70 | + var sha = await host.Git.CreateWorkRepoAsync(work, branch: "master"); | |
| 71 | + await host.Git.MustAsync(work, "push", host.GitUrl(user.Username, repo.Name, token), "master"); | |
| 72 | + | |
| 73 | + Assert.Equal("master", (await host.ReloadRepoAsync(repo.Id)).DefaultBranch); | |
| 74 | + | |
| 75 | + // HEAD moved too, so a clone checks out the pushed branch. | |
| 76 | + var clone = host.NewDir("clone"); | |
| 77 | + await host.Git.MustAsync(clone, "clone", host.GitUrl(user.Username, repo.Name), "."); | |
| 78 | + Assert.Equal(sha, await host.Git.MustAsync(clone, "rev-parse", "HEAD")); | |
| 79 | + } | |
| 80 | + | |
| 81 | + [Fact] | |
| 82 | + public async Task Private_repository_needs_a_token_to_clone() | |
| 83 | + { | |
| 84 | + var user = await host.CreateUserAsync(); | |
| 85 | + var (repo, sha, _) = await host.CreatePushedRepoAsync(user, "private-clone", Visibility.Private); | |
| 86 | + var readToken = await host.CreateTokenAsync(user, canWrite: false); | |
| 87 | + | |
| 88 | + var anonymous = await host.Git.RunAsync(host.NewDir("anon"), "clone", host.GitUrl(user.Username, repo.Name), "."); | |
| 89 | + Assert.False(anonymous.Ok); | |
| 90 | + | |
| 91 | + var clone = host.NewDir("clone"); | |
| 92 | + await host.Git.MustAsync(clone, "clone", host.GitUrl(user.Username, repo.Name, readToken), "."); | |
| 93 | + Assert.Equal(sha, await host.Git.MustAsync(clone, "rev-parse", "HEAD")); | |
| 94 | + | |
| 95 | + var used = await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().AccessTokens | |
| 96 | + .Where(t => !t.CanWrite && t.UserId == user.Id).Select(t => t.LastUsedAt).ToListAsync()); | |
| 97 | + Assert.Contains(used, u => u is not null); | |
| 98 | + } | |
| 99 | + | |
| 100 | + [Fact] | |
| 101 | + public async Task Push_is_rejected_without_a_write_token() | |
| 102 | + { | |
| 103 | + var user = await host.CreateUserAsync(); | |
| 104 | + var (repo, sha, work) = await host.CreatePushedRepoAsync(user, "push-rights", Visibility.Public); | |
| 105 | + var readToken = await host.CreateTokenAsync(user, canWrite: false); | |
| 106 | + var expired = await host.CreateTokenAsync(user, canWrite: true, DateTime.UtcNow.AddMinutes(-1)); | |
| 107 | + | |
| 108 | + await File.WriteAllTextAsync(Path.Combine(work, "new.txt"), "x\n"); | |
| 109 | + await host.Git.MustAsync(work, "add", "-A"); | |
| 110 | + await host.Git.MustAsync(work, "commit", "-m", "Not allowed"); | |
| 111 | + | |
| 112 | + Assert.False((await host.Git.RunAsync(work, "push", host.GitUrl(user.Username, repo.Name), "main")).Ok); | |
| 113 | + Assert.False((await host.Git.RunAsync(work, "push", host.GitUrl(user.Username, repo.Name, readToken), "main")).Ok); | |
| 114 | + Assert.False((await host.Git.RunAsync(work, "push", host.GitUrl(user.Username, repo.Name, expired), "main")).Ok); | |
| 115 | + Assert.False((await host.Git.RunAsync(work, "push", host.GitUrl(user.Username, repo.Name, "forge_wrong"), "main")).Ok); | |
| 116 | + | |
| 117 | + // Nothing moved on the server. | |
| 118 | + var check = host.NewDir("check"); | |
| 119 | + await host.Git.MustAsync(check, "clone", host.GitUrl(user.Username, repo.Name), "."); | |
| 120 | + Assert.Equal(sha, await host.Git.MustAsync(check, "rev-parse", "HEAD")); | |
| 121 | + } | |
| 122 | + | |
| 123 | + [Fact] | |
| 124 | + public async Task Status_codes_do_not_reveal_private_repositories() | |
| 125 | + { | |
| 126 | + var user = await host.CreateUserAsync(); | |
| 127 | + var other = await host.CreateUserAsync("other"); | |
| 128 | + await host.CreatePushedRepoAsync(user, "hidden", Visibility.Private); | |
| 129 | + var readToken = await host.CreateTokenAsync(user, canWrite: false); | |
| 130 | + var otherToken = await host.CreateTokenAsync(other, canWrite: true); | |
| 131 | + var expired = await host.CreateTokenAsync(user, canWrite: true, DateTime.UtcNow.AddMinutes(-1)); | |
| 132 | + using var client = host.CreateClient(); | |
| 133 | + | |
| 134 | + const string upload = "/jessie/hidden.git/info/refs?service=git-upload-pack"; | |
| 135 | + const string receive = "/jessie/hidden.git/info/refs?service=git-receive-pack"; | |
| 136 | + const string missing = "/jessie/does-not-exist.git/info/refs?service=git-upload-pack"; | |
| 137 | + | |
| 138 | + // Anonymous: a private repository and a missing one answer identically, and git is asked for credentials. | |
| 139 | + var hidden = await client.GetAsync(upload); | |
| 140 | + var absent = await client.GetAsync(missing); | |
| 141 | + Assert.Equal(HttpStatusCode.Unauthorized, hidden.StatusCode); | |
| 142 | + Assert.Equal(HttpStatusCode.Unauthorized, absent.StatusCode); | |
| 143 | + Assert.StartsWith("Basic realm=\"forge\"", hidden.Headers.WwwAuthenticate.ToString()); | |
| 144 | + Assert.Equal(await hidden.Content.ReadAsStringAsync(), await absent.Content.ReadAsStringAsync()); | |
| 145 | + | |
| 146 | + // Another user's valid token: the repository does not exist for them. | |
| 147 | + Assert.Equal(HttpStatusCode.NotFound, (await GetAsync(client, upload, otherToken)).StatusCode); | |
| 148 | + Assert.Equal(HttpStatusCode.NotFound, (await GetAsync(client, receive, otherToken)).StatusCode); | |
| 149 | + | |
| 150 | + // The owner's read token reads but may not push; an expired token is no token. | |
| 151 | + Assert.Equal(HttpStatusCode.OK, (await GetAsync(client, upload, readToken)).StatusCode); | |
| 152 | + Assert.Equal(HttpStatusCode.Forbidden, (await GetAsync(client, receive, readToken)).StatusCode); | |
| 153 | + Assert.Equal(HttpStatusCode.Unauthorized, (await GetAsync(client, upload, expired)).StatusCode); | |
| 154 | + } | |
| 155 | + | |
| 156 | + [Fact] | |
| 157 | + public async Task Info_refs_validates_the_service_and_sets_headers() | |
| 158 | + { | |
| 159 | + var user = await host.CreateUserAsync(); | |
| 160 | + await host.CreatePushedRepoAsync(user, "headers", Visibility.Public); | |
| 161 | + using var client = host.CreateClient(); | |
| 162 | + | |
| 163 | + var bad = await client.GetAsync("/jessie/headers.git/info/refs?service=git-upload-archive"); | |
| 164 | + Assert.Equal(HttpStatusCode.BadRequest, bad.StatusCode); | |
| 165 | + Assert.Equal(HttpStatusCode.BadRequest, (await client.GetAsync("/jessie/headers.git/info/refs")).StatusCode); | |
| 166 | + | |
| 167 | + var v0 = await client.GetAsync("/jessie/headers.git/info/refs?service=git-upload-pack"); | |
| 168 | + Assert.Equal(HttpStatusCode.OK, v0.StatusCode); | |
| 169 | + Assert.Equal("application/x-git-upload-pack-advertisement", v0.Content.Headers.ContentType?.MediaType); | |
| 170 | + Assert.Equal("no-cache", v0.Headers.CacheControl?.ToString()); | |
| 171 | + Assert.StartsWith("001e# service=git-upload-pack\n0000", await v0.Content.ReadAsStringAsync()); | |
| 172 | + | |
| 173 | + // Protocol v2: the header reaches git as GIT_PROTOCOL and the answer is a v2 capability advertisement. | |
| 174 | + using var request = new HttpRequestMessage(HttpMethod.Get, "/jessie/headers.git/info/refs?service=git-upload-pack"); | |
| 175 | + request.Headers.Add("Git-Protocol", "version=2"); | |
| 176 | + var v2 = await (await client.SendAsync(request)).Content.ReadAsStringAsync(); | |
| 177 | + Assert.StartsWith("000eversion 2\n", v2); | |
| 178 | + } | |
| 179 | + | |
| 180 | + [Fact] | |
| 181 | + public async Task Oversized_push_is_rejected() | |
| 182 | + { | |
| 183 | + var small = new ForgeHost(); | |
| 184 | + small.ExtraArgs.Add("--Forge:MaxPushSizeMb=1"); | |
| 185 | + await small.InitializeAsync(); | |
| 186 | + try | |
| 187 | + { | |
| 188 | + var user = await small.CreateUserAsync(); | |
| 189 | + var repo = await small.CreateRepoAsync(user, "small", Visibility.Public); | |
| 190 | + var token = await small.CreateTokenAsync(user, canWrite: true); | |
| 191 | + | |
| 192 | + var work = small.NewDir("work"); | |
| 193 | + await small.Git.CreateWorkRepoAsync(work); | |
| 194 | + // Random bytes do not compress, so the pack is larger than the 1 MB limit. | |
| 195 | + await File.WriteAllBytesAsync(Path.Combine(work, "big.bin"), System.Security.Cryptography.RandomNumberGenerator.GetBytes(3 * 1024 * 1024)); | |
| 196 | + await small.Git.MustAsync(work, "add", "-A"); | |
| 197 | + await small.Git.MustAsync(work, "commit", "-m", "Too big"); | |
| 198 | + | |
| 199 | + var push = await small.Git.RunAsync(work, "push", small.GitUrl(user.Username, repo.Name, token), "main"); | |
| 200 | + Assert.False(push.Ok); | |
| 201 | + | |
| 202 | + var refs = await small.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().PushEvents.CountAsync()); | |
| 203 | + Assert.Equal(0, refs); | |
| 204 | + } | |
| 205 | + finally | |
| 206 | + { | |
| 207 | + await small.DisposeAsync(); | |
| 208 | + } | |
| 209 | + } | |
| 210 | + | |
| 211 | + private static Task<HttpResponseMessage> GetAsync(HttpClient client, string url, string token) | |
| 212 | + { | |
| 213 | + var request = new HttpRequestMessage(HttpMethod.Get, url); | |
| 214 | + request.Headers.Authorization = new AuthenticationHeaderValue( | |
| 215 | + "Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("git:" + token))); | |
| 216 | + return client.SendAsync(request); | |
| 217 | + } | |
| 218 | +} |
added forge.Tests/Support/BranchScenario.cs +59 −0View file
| @@ -0,0 +1,59 @@ | ||
| 1 | +using Forge.Data; | |
| 2 | + | |
| 3 | +namespace Forge.Tests.Support; | |
| 4 | + | |
| 5 | +/// <summary> | |
| 6 | +/// A pushed repository with main and a branch "feature/x". The feature branch has two commits: | |
| 7 | +/// it edits line two of a.txt and adds b.txt. Main can be made to diverge, with or without a conflict. | |
| 8 | +/// </summary> | |
| 9 | +public sealed record BranchScenario(ForgeHost Host, Repository Repo, string Work, string Url, string MainSha, string FeatureSha) | |
| 10 | +{ | |
| 11 | + public string Name => Repo.Name; | |
| 12 | + | |
| 13 | + public static async Task<BranchScenario> CreateAsync( | |
| 14 | + ForgeHost host, | |
| 15 | + string name, | |
| 16 | + bool diverge = false, | |
| 17 | + bool conflict = false, | |
| 18 | + Visibility visibility = Visibility.Public) | |
| 19 | + { | |
| 20 | + var user = await host.CreateUserAsync(); | |
| 21 | + var repo = await host.CreateRepoAsync(user, name, visibility); | |
| 22 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 23 | + var url = host.GitUrl("jessie", name, token); | |
| 24 | + var work = host.NewDir("work"); | |
| 25 | + var git = host.Git; | |
| 26 | + | |
| 27 | + await git.CreateWorkRepoAsync(work, fileName: "a.txt", content: "one\ntwo\nthree\n"); | |
| 28 | + await git.MustAsync(work, "checkout", "-b", "feature/x"); | |
| 29 | + await File.WriteAllTextAsync(Path.Combine(work, "a.txt"), "one\nTWO from feature\nthree\n"); | |
| 30 | + await File.WriteAllTextAsync(Path.Combine(work, "b.txt"), "new file\n"); | |
| 31 | + await git.MustAsync(work, "add", "-A"); | |
| 32 | + await git.MustAsync(work, "commit", "-m", "Feature work"); | |
| 33 | + await File.WriteAllTextAsync(Path.Combine(work, "b.txt"), "new file\nsecond line\n"); | |
| 34 | + await git.MustAsync(work, "commit", "-am", "More feature work"); | |
| 35 | + var featureSha = await git.MustAsync(work, "rev-parse", "HEAD"); | |
| 36 | + | |
| 37 | + await git.MustAsync(work, "checkout", "main"); | |
| 38 | + if (diverge) | |
| 39 | + { | |
| 40 | + var (file, content) = conflict ? ("a.txt", "one\nTWO from main\nthree\n") : ("c.txt", "only on main\n"); | |
| 41 | + await File.WriteAllTextAsync(Path.Combine(work, file), content); | |
| 42 | + await git.MustAsync(work, "add", "-A"); | |
| 43 | + await git.MustAsync(work, "commit", "-m", "Main moves on"); | |
| 44 | + } | |
| 45 | + | |
| 46 | + var mainSha = await git.MustAsync(work, "rev-parse", "HEAD"); | |
| 47 | + await git.MustAsync(work, "push", url, "main", "feature/x"); | |
| 48 | + return new BranchScenario(host, repo, work, url, mainSha, featureSha); | |
| 49 | + } | |
| 50 | + | |
| 51 | + /// <summary>Fetches the server's branches as server/* into the working repository, then runs git there.</summary> | |
| 52 | + public async Task<string> ServerAsync(params string[] args) | |
| 53 | + { | |
| 54 | + await Host.Git.MustAsync(Work, "fetch", "--prune", Url, "+refs/heads/*:refs/remotes/server/*"); | |
| 55 | + return await Host.Git.MustAsync(Work, args); | |
| 56 | + } | |
| 57 | + | |
| 58 | + public string Page(string relative) => $"/jessie/{Name}/{relative}"; | |
| 59 | +} |
added forge.Tests/Support/ForgeHost.cs +213 −0View file
| @@ -0,0 +1,213 @@ | ||
| 1 | +using System.Net; | |
| 2 | +using System.Text.RegularExpressions; | |
| 3 | +using Forge.Data; | |
| 4 | +using Forge.Features.Auth; | |
| 5 | +using Forge.Features.Repos; | |
| 6 | +using Forge.Git; | |
| 7 | +using Microsoft.AspNetCore.Identity; | |
| 8 | +using Microsoft.Data.Sqlite; | |
| 9 | +using Microsoft.Extensions.DependencyInjection; | |
| 10 | + | |
| 11 | +namespace Forge.Tests.Support; | |
| 12 | + | |
| 13 | +/// <summary> | |
| 14 | +/// The real app on a random local port with a temporary data directory and database. | |
| 15 | +/// Tests talk to it over HTTP, with HttpClient and with the real git client. | |
| 16 | +/// </summary> | |
| 17 | +public sealed partial class ForgeHost : IAsyncLifetime | |
| 18 | +{ | |
| 19 | + public const string Password = "correct horse battery"; | |
| 20 | + | |
| 21 | + private readonly TempDir _temp = new(); | |
| 22 | + private WebApplication _app = null!; | |
| 23 | + | |
| 24 | + public string BaseUrl { get; private set; } = ""; | |
| 25 | + public string DataPath => Path.Combine(_temp.Path, "data"); | |
| 26 | + public IServiceProvider Services => _app.Services; | |
| 27 | + public TestGit Git { get; private set; } = null!; | |
| 28 | + | |
| 29 | + /// <summary>Extra command-line configuration, set by a subclass-free test before InitializeAsync runs.</summary> | |
| 30 | + public List<string> ExtraArgs { get; } = []; | |
| 31 | + | |
| 32 | + /// <summary>The forge project folder, found by walking up to the solution file, wherever the build output lives.</summary> | |
| 33 | + public static string WebProjectDirectory | |
| 34 | + { | |
| 35 | + get | |
| 36 | + { | |
| 37 | + for (var dir = new DirectoryInfo(AppContext.BaseDirectory); dir is not null; dir = dir.Parent) | |
| 38 | + { | |
| 39 | + if (File.Exists(Path.Combine(dir.FullName, "forge.slnx"))) | |
| 40 | + { | |
| 41 | + return Path.Combine(dir.FullName, "forge"); | |
| 42 | + } | |
| 43 | + } | |
| 44 | + | |
| 45 | + throw new DirectoryNotFoundException("forge.slnx was not found above " + AppContext.BaseDirectory); | |
| 46 | + } | |
| 47 | + } | |
| 48 | + | |
| 49 | + public async Task InitializeAsync() | |
| 50 | + { | |
| 51 | + Git = new TestGit(_temp.Sub("client-home")); | |
| 52 | + string[] args = | |
| 53 | + [ | |
| 54 | + "--urls=http://127.0.0.1:0", | |
| 55 | + "--environment=Production", | |
| 56 | + "--Forge:DataPath=" + DataPath, | |
| 57 | + "--Forge:BaseUrl=http://forge.test", | |
| 58 | + "--Forge:GitPath=" + TestGit.Executable, | |
| 59 | + "--Logging:LogLevel:Default=Warning", | |
| 60 | + // The web project's directory, so wwwroot is served as it is in a real run. | |
| 61 | + "--contentRoot=" + WebProjectDirectory, | |
| 62 | + .. ExtraArgs, | |
| 63 | + ]; | |
| 64 | + _app = ForgeApp.Build(args); | |
| 65 | + await ForgeApp.InitializeAsync(_app); | |
| 66 | + await _app.StartAsync(); | |
| 67 | + BaseUrl = _app.Urls.First().TrimEnd('/'); | |
| 68 | + } | |
| 69 | + | |
| 70 | + public async Task DisposeAsync() | |
| 71 | + { | |
| 72 | + await _app.StopAsync(); | |
| 73 | + await _app.DisposeAsync(); | |
| 74 | + SqliteConnection.ClearAllPools(); | |
| 75 | + _temp.Dispose(); | |
| 76 | + } | |
| 77 | + | |
| 78 | + public string NewDir(string name) => _temp.Sub(name + "-" + Guid.NewGuid().ToString("N")[..8]); | |
| 79 | + | |
| 80 | + public string RepoDirectory(long repoId) => Path.Combine(DataPath, "repos", repoId + ".git"); | |
| 81 | + | |
| 82 | + /// <summary>Clone URL with the token embedded as the password, the way a user would paste it.</summary> | |
| 83 | + public string GitUrl(string owner, string repo, string? token = null) | |
| 84 | + { | |
| 85 | + var authority = BaseUrl["http://".Length..]; | |
| 86 | + return token is null | |
| 87 | + ? $"http://{authority}/{owner}/{repo}.git" | |
| 88 | + : $"http://git:{token}@{authority}/{owner}/{repo}.git"; | |
| 89 | + } | |
| 90 | + | |
| 91 | + public async Task<T> WithScopeAsync<T>(Func<IServiceProvider, Task<T>> action) | |
| 92 | + { | |
| 93 | + await using var scope = Services.CreateAsyncScope(); | |
| 94 | + return await action(scope.ServiceProvider); | |
| 95 | + } | |
| 96 | + | |
| 97 | + public Task<User> CreateUserAsync(string username = "jessie") => | |
| 98 | + WithScopeAsync(async sp => | |
| 99 | + { | |
| 100 | + var db = sp.GetRequiredService<ForgeDb>(); | |
| 101 | + // Tests in one class share the host, so the user may already be there. | |
| 102 | + if (db.Users.FirstOrDefault(u => u.Username == username) is { } existing) | |
| 103 | + { | |
| 104 | + return existing; | |
| 105 | + } | |
| 106 | + | |
| 107 | + var user = new User { Username = username, DisplayName = username, CreatedAt = DateTime.UtcNow }; | |
| 108 | + user.PasswordHash = sp.GetRequiredService<IPasswordHasher<User>>().HashPassword(user, Password); | |
| 109 | + db.Users.Add(user); | |
| 110 | + await db.SaveChangesAsync(); | |
| 111 | + return user; | |
| 112 | + }); | |
| 113 | + | |
| 114 | + public Task<Repository> CreateRepoAsync(User owner, string name, Visibility visibility) => | |
| 115 | + WithScopeAsync(async sp => | |
| 116 | + { | |
| 117 | + var (repo, error) = await sp.GetRequiredService<RepoService>().CreateAsync(owner.Id, name, "", visibility); | |
| 118 | + Assert.True(repo is not null, error); | |
| 119 | + return repo!; | |
| 120 | + }); | |
| 121 | + | |
| 122 | + public Task<string> CreateTokenAsync(User user, bool canWrite, DateTime? expiresAt = null) => | |
| 123 | + WithScopeAsync(async sp => | |
| 124 | + { | |
| 125 | + var (_, plaintext) = await sp.GetRequiredService<TokenService>() | |
| 126 | + .CreateAsync(user.Id, canWrite ? "write" : "read", canWrite, expiresAt); | |
| 127 | + return plaintext; | |
| 128 | + }); | |
| 129 | + | |
| 130 | + public Task<Repository> ReloadRepoAsync(long id) => | |
| 131 | + WithScopeAsync(async sp => (await sp.GetRequiredService<ForgeDb>().Repositories.FindAsync(id))!); | |
| 132 | + | |
| 133 | + /// <summary>A client that keeps cookies and does not follow redirects, so tests can assert on them.</summary> | |
| 134 | + public HttpClient CreateClient() => | |
| 135 | + new(new HttpClientHandler { AllowAutoRedirect = false, UseCookies = true, CookieContainer = new CookieContainer() }) | |
| 136 | + { | |
| 137 | + BaseAddress = new Uri(BaseUrl), | |
| 138 | + }; | |
| 139 | + | |
| 140 | + /// <summary>Submits a server-rendered form the way a browser would: load the page, then post with its antiforgery token.</summary> | |
| 141 | + public static async Task<HttpResponseMessage> PostFormAsync( | |
| 142 | + HttpClient client, | |
| 143 | + string pageUrl, | |
| 144 | + string formName, | |
| 145 | + Dictionary<string, string> fields) | |
| 146 | + { | |
| 147 | + var page = await client.GetAsync(pageUrl); | |
| 148 | + var html = await page.Content.ReadAsStringAsync(); | |
| 149 | + var match = AntiforgeryToken().Match(html); | |
| 150 | + Assert.True(match.Success, $"No antiforgery token on {pageUrl} (status {(int)page.StatusCode})."); | |
| 151 | + | |
| 152 | + var form = new Dictionary<string, string>(fields) | |
| 153 | + { | |
| 154 | + ["__RequestVerificationToken"] = WebUtility.HtmlDecode(match.Groups[1].Value), | |
| 155 | + ["_handler"] = formName, | |
| 156 | + }; | |
| 157 | + return await client.PostAsync(pageUrl, new FormUrlEncodedContent(form)); | |
| 158 | + } | |
| 159 | + | |
| 160 | + /// <summary>Page text with HTML entities decoded; the renderer writes non-ASCII letters as entities.</summary> | |
| 161 | + public static async Task<string> TextAsync(HttpResponseMessage response) => | |
| 162 | + WebUtility.HtmlDecode(await response.Content.ReadAsStringAsync()); | |
| 163 | + | |
| 164 | + private readonly Dictionary<string, CookieContainer> _sessions = []; | |
| 165 | + | |
| 166 | + /// <summary> | |
| 167 | + /// A client signed in as the user. The login happens once per host and its cookies are reused, | |
| 168 | + /// so a class with many tests does not run into the login rate limit. | |
| 169 | + /// </summary> | |
| 170 | + public async Task<HttpClient> CreateSignedInClientAsync(string username = "jessie") | |
| 171 | + { | |
| 172 | + if (_sessions.TryGetValue(username, out var cookies)) | |
| 173 | + { | |
| 174 | + return new HttpClient(new HttpClientHandler { AllowAutoRedirect = false, UseCookies = true, CookieContainer = cookies }) | |
| 175 | + { | |
| 176 | + BaseAddress = new Uri(BaseUrl), | |
| 177 | + }; | |
| 178 | + } | |
| 179 | + | |
| 180 | + cookies = new CookieContainer(); | |
| 181 | + _sessions[username] = cookies; | |
| 182 | + var client = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false, UseCookies = true, CookieContainer = cookies }) | |
| 183 | + { | |
| 184 | + BaseAddress = new Uri(BaseUrl), | |
| 185 | + }; | |
| 186 | + var response = await PostFormAsync(client, "/login", "login", new() | |
| 187 | + { | |
| 188 | + ["Username"] = username, | |
| 189 | + ["Password"] = Password, | |
| 190 | + }); | |
| 191 | + Assert.Equal(HttpStatusCode.Redirect, response.StatusCode); | |
| 192 | + return client; | |
| 193 | + } | |
| 194 | + | |
| 195 | + /// <summary>Creates a repository and pushes one commit to it. Returns the pushed commit SHA.</summary> | |
| 196 | + public async Task<(Repository Repo, string Sha, string WorkDir)> CreatePushedRepoAsync( | |
| 197 | + User owner, | |
| 198 | + string name, | |
| 199 | + Visibility visibility, | |
| 200 | + string fileName = "README.md", | |
| 201 | + string content = "# Demo\n") | |
| 202 | + { | |
| 203 | + var repo = await CreateRepoAsync(owner, name, visibility); | |
| 204 | + var token = await CreateTokenAsync(owner, canWrite: true); | |
| 205 | + var work = NewDir("work"); | |
| 206 | + var sha = await Git.CreateWorkRepoAsync(work, fileName: fileName, content: content); | |
| 207 | + await Git.MustAsync(work, "push", GitUrl(owner.Username, name, token), "main"); | |
| 208 | + return (repo, sha, work); | |
| 209 | + } | |
| 210 | + | |
| 211 | + [GeneratedRegex("name=\"__RequestVerificationToken\" value=\"([^\"]+)\"")] | |
| 212 | + private static partial Regex AntiforgeryToken(); | |
| 213 | +} |
added forge.Tests/Support/TestGit.cs +96 −0View file
| @@ -0,0 +1,96 @@ | ||
| 1 | +using System.Text; | |
| 2 | +using CliWrap; | |
| 3 | +using Forge.Git; | |
| 4 | + | |
| 5 | +namespace Forge.Tests.Support; | |
| 6 | + | |
| 7 | +public sealed record GitRun(int ExitCode, string StdOut, string StdErr) | |
| 8 | +{ | |
| 9 | + public bool Ok => ExitCode == 0; | |
| 10 | +} | |
| 11 | + | |
| 12 | +/// <summary> | |
| 13 | +/// The git client used by tests, as a user's machine would run it. Isolated from the real machine: | |
| 14 | +/// no system or user config, no credential helper, and no prompts, so a rejected push fails instead of hanging. | |
| 15 | +/// </summary> | |
| 16 | +public sealed class TestGit(string home) | |
| 17 | +{ | |
| 18 | + public static string Executable => Environment.GetEnvironmentVariable("FORGE_TEST_GIT") ?? "git"; | |
| 19 | + | |
| 20 | + public async Task<GitRun> RunAsync(string workDir, params string[] args) | |
| 21 | + { | |
| 22 | + var stdout = new StringBuilder(); | |
| 23 | + var stderr = new StringBuilder(); | |
| 24 | + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(2)); | |
| 25 | + | |
| 26 | + var result = await Cli.Wrap(Executable) | |
| 27 | + .WithArguments(args) | |
| 28 | + .WithWorkingDirectory(workDir) | |
| 29 | + .WithEnvironmentVariables(new Dictionary<string, string?> | |
| 30 | + { | |
| 31 | + ["GIT_CONFIG_NOSYSTEM"] = "1", | |
| 32 | + ["HOME"] = home, | |
| 33 | + ["XDG_CONFIG_HOME"] = Path.Combine(home, ".config"), | |
| 34 | + ["GIT_TERMINAL_PROMPT"] = "0", | |
| 35 | + ["GCM_INTERACTIVE"] = "never", | |
| 36 | + ["GIT_ASKPASS"] = null, | |
| 37 | + ["SSH_ASKPASS"] = null, | |
| 38 | + ["GIT_AUTHOR_NAME"] = "Test Author", | |
| 39 | + ["GIT_AUTHOR_EMAIL"] = "author@example.com", | |
| 40 | + ["GIT_COMMITTER_NAME"] = "Test Author", | |
| 41 | + ["GIT_COMMITTER_EMAIL"] = "author@example.com", | |
| 42 | + ["GIT_DIR"] = null, | |
| 43 | + ["GIT_WORK_TREE"] = null, | |
| 44 | + ["LC_ALL"] = "C", | |
| 45 | + }) | |
| 46 | + .WithStandardOutputPipe(PipeTarget.ToStringBuilder(stdout)) | |
| 47 | + .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stderr)) | |
| 48 | + .WithValidation(CommandResultValidation.None) | |
| 49 | + .ExecuteAsync(timeout.Token); | |
| 50 | + | |
| 51 | + return new GitRun(result.ExitCode, stdout.ToString(), stderr.ToString()); | |
| 52 | + } | |
| 53 | + | |
| 54 | + /// <summary>Runs git and fails the test with git's own output if it exits non-zero.</summary> | |
| 55 | + public async Task<string> MustAsync(string workDir, params string[] args) | |
| 56 | + { | |
| 57 | + var run = await RunAsync(workDir, args); | |
| 58 | + Assert.True(run.Ok, $"git {string.Join(' ', args)} failed ({run.ExitCode}):\n{run.StdOut}\n{run.StdErr}"); | |
| 59 | + return run.StdOut.Trim(); | |
| 60 | + } | |
| 61 | + | |
| 62 | + /// <summary>Creates a working repository on branch <paramref name="branch"/> with one commit.</summary> | |
| 63 | + public async Task<string> CreateWorkRepoAsync(string path, string branch = "main", string fileName = "README.md", string content = "# Demo\n") | |
| 64 | + { | |
| 65 | + Directory.CreateDirectory(path); | |
| 66 | + await MustAsync(path, "init", "--initial-branch=" + branch, "."); | |
| 67 | + await File.WriteAllTextAsync(Path.Combine(path, fileName), content); | |
| 68 | + await MustAsync(path, "add", "-A"); | |
| 69 | + await MustAsync(path, "commit", "-m", "First commit"); | |
| 70 | + return await MustAsync(path, "rev-parse", "HEAD"); | |
| 71 | + } | |
| 72 | +} | |
| 73 | + | |
| 74 | +public sealed class TempDir : IDisposable | |
| 75 | +{ | |
| 76 | + public string Path { get; } = Directory.CreateTempSubdirectory("forge-test-").FullName; | |
| 77 | + | |
| 78 | + public string Sub(string name) | |
| 79 | + { | |
| 80 | + var path = System.IO.Path.Combine(Path, name); | |
| 81 | + Directory.CreateDirectory(path); | |
| 82 | + return path; | |
| 83 | + } | |
| 84 | + | |
| 85 | + public void Dispose() | |
| 86 | + { | |
| 87 | + try | |
| 88 | + { | |
| 89 | + RepoPaths.DeleteDirectory(Path); | |
| 90 | + } | |
| 91 | + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) | |
| 92 | + { | |
| 93 | + // A leftover temp directory must not fail a test run. | |
| 94 | + } | |
| 95 | + } | |
| 96 | +} |
added forge.Tests/WebTests.cs +650 −0View file
| @@ -0,0 +1,650 @@ | ||
| 1 | +using System.Net; | |
| 2 | +using Forge.Data; | |
| 3 | +using Forge.Features.Repos; | |
| 4 | +using Forge.Tests.Support; | |
| 5 | +using Microsoft.EntityFrameworkCore; | |
| 6 | +using Microsoft.Extensions.DependencyInjection; | |
| 7 | + | |
| 8 | +namespace Forge.Tests; | |
| 9 | + | |
| 10 | +/// <summary>Pages, permissions and the raw endpoint, over HTTP against the running app.</summary> | |
| 11 | +public class WebTests(ForgeHost host) : IClassFixture<ForgeHost> | |
| 12 | +{ | |
| 13 | + private static string[] RepoPages(string repo, string sha) => | |
| 14 | + [ | |
| 15 | + $"/jessie/{repo}", | |
| 16 | + $"/jessie/{repo}/tree/main", | |
| 17 | + $"/jessie/{repo}/blob/main/README.md", | |
| 18 | + $"/jessie/{repo}/raw/main/README.md", | |
| 19 | + $"/jessie/{repo}/commits/main", | |
| 20 | + $"/jessie/{repo}/commits", | |
| 21 | + $"/jessie/{repo}/commit/{sha}", | |
| 22 | + $"/jessie/{repo}/branches", | |
| 23 | + $"/jessie/{repo}/tags", | |
| 24 | + $"/jessie/{repo}/atom", | |
| 25 | + $"/jessie/{repo}/search?q=Demo", | |
| 26 | + $"/jessie/{repo}/activity", | |
| 27 | + ]; | |
| 28 | + | |
| 29 | + private static string[] AdminPages(string repo) => | |
| 30 | + [ | |
| 31 | + $"/jessie/{repo}/settings", | |
| 32 | + $"/jessie/{repo}/settings/webhooks", | |
| 33 | + ]; | |
| 34 | + | |
| 35 | + [Fact] | |
| 36 | + public async Task Anonymous_visitor_gets_404_for_everything_in_a_private_repository() | |
| 37 | + { | |
| 38 | + var user = await host.CreateUserAsync(); | |
| 39 | + var (_, sha, _) = await host.CreatePushedRepoAsync(user, "secret", Visibility.Private); | |
| 40 | + using var anonymous = host.CreateClient(); | |
| 41 | + | |
| 42 | + foreach (var url in RepoPages("secret", sha).Concat(AdminPages("secret"))) | |
| 43 | + { | |
| 44 | + var response = await anonymous.GetAsync(url); | |
| 45 | + Assert.True(response.StatusCode == HttpStatusCode.NotFound, $"{url} answered {(int)response.StatusCode}, expected 404"); | |
| 46 | + } | |
| 47 | + | |
| 48 | + // The home page does not list it either. | |
| 49 | + Assert.DoesNotContain("secret", await anonymous.GetStringAsync("/")); | |
| 50 | + | |
| 51 | + // The owner sees all of it. | |
| 52 | + using var owner = await host.CreateSignedInClientAsync(); | |
| 53 | + foreach (var url in RepoPages("secret", sha).Concat(AdminPages("secret"))) | |
| 54 | + { | |
| 55 | + var response = await owner.GetAsync(url); | |
| 56 | + Assert.True(response.StatusCode == HttpStatusCode.OK, $"{url} answered {(int)response.StatusCode} for the owner, expected 200"); | |
| 57 | + } | |
| 58 | + | |
| 59 | + Assert.Contains("secret", await owner.GetStringAsync("/")); | |
| 60 | + } | |
| 61 | + | |
| 62 | + [Fact] | |
| 63 | + public async Task Public_repository_is_readable_but_its_settings_are_hidden() | |
| 64 | + { | |
| 65 | + var user = await host.CreateUserAsync(); | |
| 66 | + var (_, sha, _) = await host.CreatePushedRepoAsync(user, "open", Visibility.Public); | |
| 67 | + using var anonymous = host.CreateClient(); | |
| 68 | + | |
| 69 | + foreach (var url in RepoPages("open", sha)) | |
| 70 | + { | |
| 71 | + var response = await anonymous.GetAsync(url); | |
| 72 | + Assert.True(response.StatusCode == HttpStatusCode.OK, $"{url} answered {(int)response.StatusCode}, expected 200"); | |
| 73 | + } | |
| 74 | + | |
| 75 | + foreach (var url in AdminPages("open")) | |
| 76 | + { | |
| 77 | + Assert.Equal(HttpStatusCode.NotFound, (await anonymous.GetAsync(url)).StatusCode); | |
| 78 | + } | |
| 79 | + | |
| 80 | + Assert.Contains("open", await anonymous.GetStringAsync("/")); | |
| 81 | + } | |
| 82 | + | |
| 83 | + [Fact] | |
| 84 | + public async Task Home_page_searches_and_sorts_repositories() | |
| 85 | + { | |
| 86 | + var user = await host.CreateUserAsync(); | |
| 87 | + await host.WithScopeAsync(async sp => | |
| 88 | + { | |
| 89 | + var repos = sp.GetRequiredService<RepoService>(); | |
| 90 | + await repos.CreateAsync(user.Id, "zebra-tools", "Stripes for everyone", Visibility.Public); | |
| 91 | + await repos.CreateAsync(user.Id, "aardvark", "100% ants", Visibility.Public); | |
| 92 | + return 0; | |
| 93 | + }); | |
| 94 | + using var client = host.CreateClient(); | |
| 95 | + | |
| 96 | + var byName = await client.GetStringAsync("/?q=ZEBRA"); | |
| 97 | + Assert.Contains("zebra-tools", byName); | |
| 98 | + Assert.DoesNotContain("aardvark", byName); | |
| 99 | + | |
| 100 | + // The description is searched too, and LIKE wildcards in the text are literal. | |
| 101 | + var byDescription = await client.GetStringAsync("/?q=100%25"); | |
| 102 | + Assert.Contains("aardvark", byDescription); | |
| 103 | + Assert.DoesNotContain("zebra-tools", byDescription); | |
| 104 | + Assert.DoesNotContain("zebra-tools", await client.GetStringAsync("/?q=_ebra")); | |
| 105 | + | |
| 106 | + var nothing = await ForgeHost.TextAsync(await client.GetAsync("/?q=no-such-thing")); | |
| 107 | + Assert.Contains("No repository matches “no-such-thing”.", nothing); | |
| 108 | + | |
| 109 | + var sorted = await client.GetStringAsync("/jessie?sort=name"); | |
| 110 | + Assert.True(sorted.IndexOf("aardvark", StringComparison.Ordinal) < sorted.IndexOf("zebra-tools", StringComparison.Ordinal)); | |
| 111 | + } | |
| 112 | + | |
| 113 | + [Fact] | |
| 114 | + public async Task Pages_show_repository_content() | |
| 115 | + { | |
| 116 | + var user = await host.CreateUserAsync(); | |
| 117 | + var repo = await host.CreateRepoAsync(user, "content", Visibility.Public); | |
| 118 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 119 | + using var client = host.CreateClient(); | |
| 120 | + | |
| 121 | + // Before the first push the page explains how to push. | |
| 122 | + var empty = await client.GetStringAsync("/jessie/content"); | |
| 123 | + Assert.Contains("The repository is empty", empty); | |
| 124 | + Assert.Contains("git clone http://forge.test/jessie/content.git", empty); | |
| 125 | + | |
| 126 | + var work = host.NewDir("work"); | |
| 127 | + await host.Git.CreateWorkRepoAsync(work, content: "# Hello\n\nSee [the code](src/app.cs) and .\n"); | |
| 128 | + Directory.CreateDirectory(Path.Combine(work, "src")); | |
| 129 | + await File.WriteAllTextAsync(Path.Combine(work, "src", "app.cs"), "class App\n{\n}\n"); | |
| 130 | + await host.Git.MustAsync(work, "add", "-A"); | |
| 131 | + await host.Git.MustAsync(work, "commit", "-m", "Add the app"); | |
| 132 | + var sha = await host.Git.MustAsync(work, "rev-parse", "HEAD"); | |
| 133 | + await host.Git.MustAsync(work, "checkout", "-b", "feature/x"); | |
| 134 | + await host.Git.MustAsync(work, "tag", "v1"); | |
| 135 | + await host.Git.MustAsync(work, "push", host.GitUrl("jessie", "content", token), "main", "feature/x", "v1"); | |
| 136 | + | |
| 137 | + var home = await client.GetStringAsync("/jessie/content"); | |
| 138 | + Assert.Contains("README.md", home); | |
| 139 | + Assert.Contains(">src</a>", home); | |
| 140 | + Assert.Contains("<h1>Hello</h1>", home); | |
| 141 | + Assert.Contains("href=\"/jessie/content/blob/main/src/app.cs\"", home); | |
| 142 | + Assert.Contains("src=\"/jessie/content/raw/main/logo.png\"", home); | |
| 143 | + Assert.Contains("Add the app", home); | |
| 144 | + | |
| 145 | + // Every entry shows the commit that last changed it; the side panel summarises the repository. | |
| 146 | + Assert.Contains("First commit</a>", home); | |
| 147 | + Assert.Contains("2 commits", home); | |
| 148 | + Assert.Contains("2 branches", home); | |
| 149 | + Assert.Contains("1 tag<", home); | |
| 150 | + Assert.Contains("class=\"lang-csharp\"", home); | |
| 151 | + Assert.Contains("100.0 %", home); | |
| 152 | + | |
| 153 | + // A branch name with a slash resolves, and the rest of the URL is the path. | |
| 154 | + var tree = await client.GetStringAsync("/jessie/content/tree/feature/x/src"); | |
| 155 | + Assert.Contains("app.cs", tree); | |
| 156 | + | |
| 157 | + var blob = await client.GetStringAsync("/jessie/content/blob/main/src/app.cs"); | |
| 158 | + Assert.Contains("class App", blob); | |
| 159 | + Assert.Contains("id=\"L3\"", blob); | |
| 160 | + Assert.Contains("language-csharp", blob); | |
| 161 | + Assert.Contains("/lib/highlight/highlight.min.js", blob); | |
| 162 | + Assert.DoesNotContain("/lib/highlight/highlight.min.js", home); | |
| 163 | + | |
| 164 | + // A Markdown file is rendered; ?plain=1 shows its source with line numbers instead. | |
| 165 | + var preview = await client.GetStringAsync("/jessie/content/blob/main/README.md"); | |
| 166 | + Assert.Contains("<h1>Hello</h1>", preview); | |
| 167 | + Assert.DoesNotContain("id=\"L1\"", preview); | |
| 168 | + var source = await client.GetStringAsync("/jessie/content/blob/main/README.md?plain=1"); | |
| 169 | + Assert.Contains("# Hello", source); | |
| 170 | + Assert.Contains("id=\"L1\"", source); | |
| 171 | + | |
| 172 | + // The permalink names the commit, so it keeps pointing at this version. | |
| 173 | + Assert.Contains($"href=\"/jessie/content/blob/{sha}/src/app.cs\"", blob); | |
| 174 | + | |
| 175 | + var commits = await client.GetStringAsync("/jessie/content/commits/main/src/app.cs"); | |
| 176 | + Assert.Contains("Add the app", commits); | |
| 177 | + Assert.DoesNotContain("First commit", commits); | |
| 178 | + Assert.Contains("Commits on ", commits); | |
| 179 | + Assert.Contains($"data-copy=\"{sha}\"", commits); | |
| 180 | + | |
| 181 | + var commit = await client.GetStringAsync($"/jessie/content/commit/{sha}"); | |
| 182 | + Assert.Contains("src/app.cs", commit); | |
| 183 | + Assert.Contains("class App", commit); | |
| 184 | + | |
| 185 | + // Both commits were made just now, so they fall into the current week of the chart. | |
| 186 | + var activity = await client.GetStringAsync("/jessie/content/activity"); | |
| 187 | + Assert.Contains("Commits per week", activity); | |
| 188 | + Assert.Contains("The last 52 weeks, 2 commits in total", activity); | |
| 189 | + Assert.Single(System.Text.RegularExpressions.Regex.Matches(activity, "class=\"week-bar\"")); | |
| 190 | + Assert.Single(System.Text.RegularExpressions.Regex.Matches(activity, "class=\"contributor\"")); | |
| 191 | + | |
| 192 | + Assert.Contains("feature/x", await client.GetStringAsync("/jessie/content/branches")); | |
| 193 | + Assert.Contains("v1", await client.GetStringAsync("/jessie/content/tags")); | |
| 194 | + | |
| 195 | + var atom = await client.GetAsync("/jessie/content/atom"); | |
| 196 | + Assert.Equal("application/atom+xml", atom.Content.Headers.ContentType?.MediaType); | |
| 197 | + var feed = await atom.Content.ReadAsStringAsync(); | |
| 198 | + Assert.Contains("<title>Add the app</title>", feed); | |
| 199 | + Assert.Contains($"http://forge.test/jessie/content/commit/{sha}", feed); | |
| 200 | + | |
| 201 | + // Paths and refs that do not exist are plain 404s. | |
| 202 | + Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync("/jessie/content/tree/nope")).StatusCode); | |
| 203 | + Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync("/jessie/content/blob/main/nope.txt")).StatusCode); | |
| 204 | + Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync("/jessie/content/commit/" + new string('0', 40))).StatusCode); | |
| 205 | + Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync("/jessie/nope")).StatusCode); | |
| 206 | + | |
| 207 | + // A blob URL for a directory, and a tree URL for a file, redirect to the right view. | |
| 208 | + var redirect = await client.GetAsync("/jessie/content/blob/main/src"); | |
| 209 | + Assert.Equal("/jessie/content/tree/main/src", redirect.Headers.Location?.PathAndQuery); | |
| 210 | + } | |
| 211 | + | |
| 212 | + [Fact] | |
| 213 | + public async Task Search_finds_file_names_and_code_and_treats_the_text_literally() | |
| 214 | + { | |
| 215 | + var user = await host.CreateUserAsync(); | |
| 216 | + var repo = await host.CreateRepoAsync(user, "searchable", Visibility.Public); | |
| 217 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 218 | + var work = host.NewDir("work"); | |
| 219 | + await host.Git.CreateWorkRepoAsync(work, content: "# Notes\n\nThe Anvil is heavy.\n"); | |
| 220 | + Directory.CreateDirectory(Path.Combine(work, "src")); | |
| 221 | + await File.WriteAllTextAsync(Path.Combine(work, "src", "anvil.cs"), "class Hammer\n{\n // strikes <b>the</b> anvil.*\n}\n"); | |
| 222 | + await File.WriteAllBytesAsync(Path.Combine(work, "anvil.bin"), [1, 0, (byte)'a', (byte)'n', (byte)'v', (byte)'i', (byte)'l']); | |
| 223 | + await host.Git.MustAsync(work, "add", "-A"); | |
| 224 | + await host.Git.MustAsync(work, "commit", "-m", "Add files"); | |
| 225 | + await host.Git.MustAsync(work, "tag", "v1"); | |
| 226 | + await host.Git.MustAsync(work, "push", host.GitUrl("jessie", repo.Name, token), "main", "v1"); | |
| 227 | + using var client = host.CreateClient(); | |
| 228 | + var marker = Path.Combine(host.DataPath, "pwned-by-search"); | |
| 229 | + | |
| 230 | + // Case does not matter; both the file names and the lines are found, binary content is not. | |
| 231 | + var page = await client.GetStringAsync("/jessie/searchable/search?q=ANVIL"); | |
| 232 | + Assert.Contains("src/<mark>anvil</mark>.cs", page); | |
| 233 | + Assert.Contains("<mark>anvil</mark>.bin", page); | |
| 234 | + Assert.Contains("The <mark>Anvil</mark> is heavy.", page); | |
| 235 | + Assert.Contains("href=\"/jessie/searchable/blob/main/src/anvil.cs#L3\"", page); | |
| 236 | + // A match in a Markdown file links to its source view, where the line exists. | |
| 237 | + Assert.Contains("href=\"/jessie/searchable/blob/main/README.md?plain=1#L3\"", page); | |
| 238 | + | |
| 239 | + // The text is literal (no regular expression) and is encoded on the way out. | |
| 240 | + var literal = await client.GetStringAsync("/jessie/searchable/search?q=" + Uri.EscapeDataString("anvil.*")); | |
| 241 | + Assert.Contains("<mark>anvil.*</mark>", literal); | |
| 242 | + Assert.DoesNotContain("is heavy", literal); | |
| 243 | + var html = await client.GetStringAsync("/jessie/searchable/search?q=" + Uri.EscapeDataString("<b>the</b>")); | |
| 244 | + Assert.Contains("<mark><b>the</b></mark>", html); | |
| 245 | + Assert.DoesNotContain("<b>the</b>", html); | |
| 246 | + | |
| 247 | + // Text that looks like an option is still just text. | |
| 248 | + foreach (var hostile in (string[])["--output=" + marker, "-O" + marker, "--open-files-in-pager=touch " + marker]) | |
| 249 | + { | |
| 250 | + var response = await client.GetAsync("/jessie/searchable/search?q=" + Uri.EscapeDataString(hostile)); | |
| 251 | + Assert.Equal(HttpStatusCode.OK, response.StatusCode); | |
| 252 | + } | |
| 253 | + | |
| 254 | + Assert.False(File.Exists(marker)); | |
| 255 | + | |
| 256 | + // A tag can be searched; a ref that does not exist is a 404; nothing found says so. | |
| 257 | + Assert.Contains("class <mark>Hammer</mark>", await client.GetStringAsync("/jessie/searchable/search?q=hammer&ref=v1")); | |
| 258 | + Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync("/jessie/searchable/search?q=hammer&ref=--all")).StatusCode); | |
| 259 | + var nothing = await ForgeHost.TextAsync(await client.GetAsync("/jessie/searchable/search?q=zzzz")); | |
| 260 | + Assert.Contains("Nothing in main matches “zzzz”.", nothing); | |
| 261 | + | |
| 262 | + // One character is too short to search for. | |
| 263 | + Assert.Contains("Search this repository", await client.GetStringAsync("/jessie/searchable/search?q=a")); | |
| 264 | + } | |
| 265 | + | |
| 266 | + [Fact] | |
| 267 | + public async Task Option_like_refs_are_not_found() | |
| 268 | + { | |
| 269 | + var user = await host.CreateUserAsync(); | |
| 270 | + await host.CreatePushedRepoAsync(user, "hostile", Visibility.Public); | |
| 271 | + using var client = host.CreateClient(); | |
| 272 | + var marker = Path.Combine(host.DataPath, "pwned"); | |
| 273 | + | |
| 274 | + string[] refs = ["--upload-pack=touch " + marker, "--output=" + marker, "-n", "--all"]; | |
| 275 | + foreach (var hostile in refs) | |
| 276 | + { | |
| 277 | + var encoded = Uri.EscapeDataString(hostile); | |
| 278 | + foreach (var view in (string[])["tree", "blob", "raw", "commits"]) | |
| 279 | + { | |
| 280 | + var response = await client.GetAsync($"/jessie/hostile/{view}/{encoded}/README.md"); | |
| 281 | + Assert.True(response.StatusCode == HttpStatusCode.NotFound, $"{view}/{hostile} answered {(int)response.StatusCode}"); | |
| 282 | + } | |
| 283 | + | |
| 284 | + Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync($"/jessie/hostile/commit/{encoded}")).StatusCode); | |
| 285 | + } | |
| 286 | + | |
| 287 | + Assert.False(File.Exists(marker)); | |
| 288 | + } | |
| 289 | + | |
| 290 | + [Fact] | |
| 291 | + public async Task Raw_never_serves_html_and_only_inlines_safe_images() | |
| 292 | + { | |
| 293 | + var user = await host.CreateUserAsync(); | |
| 294 | + var repo = await host.CreateRepoAsync(user, "raw", Visibility.Public); | |
| 295 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 296 | + | |
| 297 | + var work = host.NewDir("work"); | |
| 298 | + await host.Git.CreateWorkRepoAsync(work, fileName: "index.html", content: "<script>alert(1)</script>\n"); | |
| 299 | + await File.WriteAllTextAsync(Path.Combine(work, "icon.svg"), "<svg xmlns=\"http://www.w3.org/2000/svg\"><script>alert(1)</script></svg>\n"); | |
| 300 | + await File.WriteAllBytesAsync(Path.Combine(work, "pixel.png"), [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0, 0, 0, 0]); | |
| 301 | + await File.WriteAllBytesAsync(Path.Combine(work, "data.bin"), [1, 0, 2, 0, 3]); | |
| 302 | + await File.WriteAllTextAsync(Path.Combine(work, "name with space.txt"), "spaced\n"); | |
| 303 | + await host.Git.MustAsync(work, "add", "-A"); | |
| 304 | + await host.Git.MustAsync(work, "commit", "-m", "Files"); | |
| 305 | + await host.Git.MustAsync(work, "push", host.GitUrl("jessie", repo.Name, token), "main"); | |
| 306 | + using var client = host.CreateClient(); | |
| 307 | + | |
| 308 | + var html = await client.GetAsync("/jessie/raw/raw/main/index.html"); | |
| 309 | + Assert.Equal(HttpStatusCode.OK, html.StatusCode); | |
| 310 | + Assert.Equal("text/plain; charset=utf-8", html.Content.Headers.ContentType?.ToString()); | |
| 311 | + Assert.Equal("nosniff", html.Headers.GetValues("X-Content-Type-Options").Single()); | |
| 312 | + Assert.Equal("<script>alert(1)</script>\n", await html.Content.ReadAsStringAsync()); | |
| 313 | + | |
| 314 | + var svg = await client.GetAsync("/jessie/raw/raw/main/icon.svg"); | |
| 315 | + Assert.Equal("application/octet-stream", svg.Content.Headers.ContentType?.MediaType); | |
| 316 | + Assert.Equal("attachment", svg.Content.Headers.ContentDisposition?.DispositionType); | |
| 317 | + | |
| 318 | + var png = await client.GetAsync("/jessie/raw/raw/main/pixel.png"); | |
| 319 | + Assert.Equal("image/png", png.Content.Headers.ContentType?.MediaType); | |
| 320 | + Assert.Null(png.Content.Headers.ContentDisposition); | |
| 321 | + Assert.Equal(12, (await png.Content.ReadAsByteArrayAsync()).Length); | |
| 322 | + | |
| 323 | + var bin = await client.GetAsync("/jessie/raw/raw/main/data.bin"); | |
| 324 | + Assert.Equal("application/octet-stream", bin.Content.Headers.ContentType?.MediaType); | |
| 325 | + Assert.Equal("attachment", bin.Content.Headers.ContentDisposition?.DispositionType); | |
| 326 | + Assert.Equal(new byte[] { 1, 0, 2, 0, 3 }, await bin.Content.ReadAsByteArrayAsync()); | |
| 327 | + | |
| 328 | + var spaced = await client.GetAsync("/jessie/raw/raw/main/name%20with%20space.txt"); | |
| 329 | + Assert.Equal("spaced\n", await spaced.Content.ReadAsStringAsync()); | |
| 330 | + | |
| 331 | + // ETag is the blob SHA; a matching If-None-Match gets 304 with no body. | |
| 332 | + var etag = html.Headers.ETag; | |
| 333 | + Assert.NotNull(etag); | |
| 334 | + using var conditional = new HttpRequestMessage(HttpMethod.Get, "/jessie/raw/raw/main/index.html"); | |
| 335 | + conditional.Headers.IfNoneMatch.Add(etag); | |
| 336 | + var notModified = await client.SendAsync(conditional); | |
| 337 | + Assert.Equal(HttpStatusCode.NotModified, notModified.StatusCode); | |
| 338 | + Assert.Empty(await notModified.Content.ReadAsByteArrayAsync()); | |
| 339 | + | |
| 340 | + // The blob page shows the HTML file as escaped source, never as markup. | |
| 341 | + var page = await client.GetStringAsync("/jessie/raw/blob/main/index.html"); | |
| 342 | + Assert.Contains("<script>alert(1)</script>", page); | |
| 343 | + Assert.DoesNotContain("<script>alert(1)</script>", page); | |
| 344 | + } | |
| 345 | + | |
| 346 | + [Fact] | |
| 347 | + public async Task Security_headers_are_on_every_page() | |
| 348 | + { | |
| 349 | + await host.CreateUserAsync(); | |
| 350 | + using var client = host.CreateClient(); | |
| 351 | + | |
| 352 | + var response = await client.GetAsync("/login"); | |
| 353 | + | |
| 354 | + Assert.Equal(HttpStatusCode.OK, response.StatusCode); | |
| 355 | + Assert.StartsWith("default-src 'self'", response.Headers.GetValues("Content-Security-Policy").Single()); | |
| 356 | + Assert.Equal("nosniff", response.Headers.GetValues("X-Content-Type-Options").Single()); | |
| 357 | + Assert.Equal("DENY", response.Headers.GetValues("X-Frame-Options").Single()); | |
| 358 | + // The CSP forbids inline script and style, so pages must not contain any. | |
| 359 | + var html = await response.Content.ReadAsStringAsync(); | |
| 360 | + Assert.DoesNotContain("style=\"", html); | |
| 361 | + Assert.DoesNotContain("<script>", html); | |
| 362 | + } | |
| 363 | + | |
| 364 | + [Theory] | |
| 365 | + [InlineData("/style.css", "text/css")] | |
| 366 | + [InlineData("/app.js", "text/javascript")] | |
| 367 | + [InlineData("/theme.js", "text/javascript")] | |
| 368 | + [InlineData("/favicon.png", "image/png")] | |
| 369 | + [InlineData("/lib/highlight/highlight.min.js", "text/javascript")] | |
| 370 | + [InlineData("/lib/highlight/github.min.css", "text/css")] | |
| 371 | + public async Task Static_assets_are_served_and_not_mistaken_for_pages(string url, string contentType) | |
| 372 | + { | |
| 373 | + await host.CreateUserAsync(); | |
| 374 | + using var client = host.CreateClient(); | |
| 375 | + | |
| 376 | + var response = await client.GetAsync(url); | |
| 377 | + | |
| 378 | + Assert.Equal(HttpStatusCode.OK, response.StatusCode); | |
| 379 | + Assert.Equal(contentType, response.Content.Headers.ContentType?.MediaType); | |
| 380 | + } | |
| 381 | + | |
| 382 | + [Fact] | |
| 383 | + public async Task Forms_require_an_antiforgery_token() | |
| 384 | + { | |
| 385 | + await host.CreateUserAsync(); | |
| 386 | + using var client = host.CreateClient(); | |
| 387 | + | |
| 388 | + var response = await client.PostAsync("/login", new FormUrlEncodedContent(new Dictionary<string, string> | |
| 389 | + { | |
| 390 | + ["_handler"] = "login", | |
| 391 | + ["Username"] = "jessie", | |
| 392 | + ["Password"] = ForgeHost.Password, | |
| 393 | + })); | |
| 394 | + | |
| 395 | + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); | |
| 396 | + } | |
| 397 | + | |
| 398 | + [Fact] | |
| 399 | + public async Task Signed_in_owner_manages_repository_through_forms() | |
| 400 | + { | |
| 401 | + var user = await host.CreateUserAsync(); | |
| 402 | + using var client = await host.CreateSignedInClientAsync(); | |
| 403 | + | |
| 404 | + // Pages that need a session send anonymous visitors to the login page. | |
| 405 | + using var anonymous = host.CreateClient(); | |
| 406 | + var bounced = await anonymous.GetAsync("/new"); | |
| 407 | + Assert.Equal(HttpStatusCode.Redirect, bounced.StatusCode); | |
| 408 | + Assert.StartsWith("/login", bounced.Headers.Location!.PathAndQuery); | |
| 409 | + | |
| 410 | + // Invalid names are refused with a message. | |
| 411 | + var invalid = await ForgeHost.PostFormAsync(client, "/new", "new-repo", new() { ["Name"] = "bad..name", ["Visibility"] = "private" }); | |
| 412 | + Assert.Equal(HttpStatusCode.OK, invalid.StatusCode); | |
| 413 | + Assert.Contains("alert error", await ForgeHost.TextAsync(invalid)); | |
| 414 | + | |
| 415 | + var created = await ForgeHost.PostFormAsync(client, "/new", "new-repo", new() | |
| 416 | + { | |
| 417 | + ["Name"] = "managed", | |
| 418 | + ["Description"] = "A managed repo", | |
| 419 | + ["Visibility"] = "private", | |
| 420 | + }); | |
| 421 | + Assert.Equal("/jessie/managed", created.Headers.Location?.PathAndQuery); | |
| 422 | + | |
| 423 | + var repo = await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().Repositories.SingleAsync(r => r.Name == "managed")); | |
| 424 | + var directory = host.RepoDirectory(repo.Id); | |
| 425 | + Assert.True(File.Exists(Path.Combine(directory, "HEAD"))); | |
| 426 | + Assert.Equal(Visibility.Private, repo.Visibility); | |
| 427 | + | |
| 428 | + // A duplicate name is refused. | |
| 429 | + var duplicate = await ForgeHost.PostFormAsync(client, "/new", "new-repo", new() { ["Name"] = "MANAGED", ["Visibility"] = "private" }); | |
| 430 | + Assert.Contains("already exists", await ForgeHost.TextAsync(duplicate)); | |
| 431 | + | |
| 432 | + // Description and visibility. | |
| 433 | + var saved = await ForgeHost.PostFormAsync(client, "/jessie/managed/settings", "general", new() | |
| 434 | + { | |
| 435 | + ["Description"] = "Now public", | |
| 436 | + ["Visibility"] = "public", | |
| 437 | + }); | |
| 438 | + Assert.Contains("Saved.", await ForgeHost.TextAsync(saved)); | |
| 439 | + Assert.Equal(Visibility.Public, (await host.ReloadRepoAsync(repo.Id)).Visibility); | |
| 440 | + | |
| 441 | + // Rename changes the row and the URL, never the directory. | |
| 442 | + var renamed = await ForgeHost.PostFormAsync(client, "/jessie/managed/settings", "rename", new() { ["NewName"] = "renamed" }); | |
| 443 | + Assert.Equal("/jessie/renamed/settings", renamed.Headers.Location?.PathAndQuery); | |
| 444 | + Assert.Equal("renamed", (await host.ReloadRepoAsync(repo.Id)).Name); | |
| 445 | + Assert.True(Directory.Exists(directory)); | |
| 446 | + Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync("/jessie/managed")).StatusCode); | |
| 447 | + Assert.Equal(HttpStatusCode.OK, (await client.GetAsync("/jessie/renamed")).StatusCode); | |
| 448 | + | |
| 449 | + // Default branch: push two branches, then switch. | |
| 450 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 451 | + var work = host.NewDir("work"); | |
| 452 | + await host.Git.CreateWorkRepoAsync(work); | |
| 453 | + await host.Git.MustAsync(work, "branch", "develop"); | |
| 454 | + await host.Git.MustAsync(work, "push", host.GitUrl("jessie", "renamed", token), "main", "develop"); | |
| 455 | + await ForgeHost.PostFormAsync(client, "/jessie/renamed/settings", "default-branch", new() { ["Branch"] = "develop" }); | |
| 456 | + Assert.Equal("develop", (await host.ReloadRepoAsync(repo.Id)).DefaultBranch); | |
| 457 | + var bogus = await ForgeHost.PostFormAsync(client, "/jessie/renamed/settings", "default-branch", new() { ["Branch"] = "--delete" }); | |
| 458 | + Assert.Contains("alert error", await ForgeHost.TextAsync(bogus)); | |
| 459 | + | |
| 460 | + // Delete needs the name typed back. | |
| 461 | + var refused = await ForgeHost.PostFormAsync(client, "/jessie/renamed/settings", "delete", new() { ["ConfirmName"] = "wrong" }); | |
| 462 | + Assert.Contains("does not match", await ForgeHost.TextAsync(refused)); | |
| 463 | + Assert.True(Directory.Exists(directory)); | |
| 464 | + | |
| 465 | + var deleted = await ForgeHost.PostFormAsync(client, "/jessie/renamed/settings", "delete", new() { ["ConfirmName"] = "renamed" }); | |
| 466 | + Assert.Equal("/", deleted.Headers.Location?.PathAndQuery); | |
| 467 | + Assert.False(Directory.Exists(directory)); | |
| 468 | + Assert.False(await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().Repositories.AnyAsync(r => r.Id == repo.Id))); | |
| 469 | + } | |
| 470 | + | |
| 471 | + [Fact] | |
| 472 | + public async Task Tokens_are_shown_once_and_stored_hashed() | |
| 473 | + { | |
| 474 | + var user = await host.CreateUserAsync(); | |
| 475 | + using var client = await host.CreateSignedInClientAsync(); | |
| 476 | + | |
| 477 | + var created = await ForgeHost.PostFormAsync(client, "/settings/tokens", "create-token", new() | |
| 478 | + { | |
| 479 | + ["Name"] = "laptop", | |
| 480 | + ["Scope"] = "write", | |
| 481 | + ["ExpiresInDays"] = "30", | |
| 482 | + }); | |
| 483 | + var html = await created.Content.ReadAsStringAsync(); | |
| 484 | + var plaintext = System.Text.RegularExpressions.Regex.Match(html, "forge_[0-9a-f]{64}").Value; | |
| 485 | + Assert.NotEmpty(plaintext); | |
| 486 | + | |
| 487 | + var row = await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().AccessTokens.SingleAsync(t => t.Name == "laptop")); | |
| 488 | + Assert.Equal(Features.Auth.TokenService.Hash(plaintext), row.TokenHash); | |
| 489 | + Assert.True(row.CanWrite); | |
| 490 | + Assert.InRange(row.ExpiresAt!.Value, DateTime.UtcNow.AddDays(29), DateTime.UtcNow.AddDays(31)); | |
| 491 | + | |
| 492 | + // Loading the page again does not show it, and the database never had it. | |
| 493 | + Assert.DoesNotContain(plaintext, await client.GetStringAsync("/settings/tokens")); | |
| 494 | + foreach (var file in Directory.GetFiles(host.DataPath, "forge.db*")) | |
| 495 | + { | |
| 496 | + // The app has the database open, so read it with sharing. The WAL file counts too. | |
| 497 | + await using var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete); | |
| 498 | + using var buffer = new MemoryStream(); | |
| 499 | + await stream.CopyToAsync(buffer); | |
| 500 | + Assert.DoesNotContain(plaintext, System.Text.Encoding.Latin1.GetString(buffer.ToArray())); | |
| 501 | + } | |
| 502 | + | |
| 503 | + // The token works for git, and stops working once revoked. | |
| 504 | + var repo = await host.CreateRepoAsync(user, "token-check", Visibility.Private); | |
| 505 | + var work = host.NewDir("work"); | |
| 506 | + await host.Git.CreateWorkRepoAsync(work); | |
| 507 | + await host.Git.MustAsync(work, "push", host.GitUrl("jessie", repo.Name, plaintext), "main"); | |
| 508 | + | |
| 509 | + await ForgeHost.PostFormAsync(client, "/settings/tokens", "revoke-token", new() { ["TokenId"] = row.Id.ToString() }); | |
| 510 | + Assert.False(await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().AccessTokens.AnyAsync(t => t.Id == row.Id))); | |
| 511 | + Assert.False((await host.Git.RunAsync(work, "push", host.GitUrl("jessie", repo.Name, plaintext), "main", "--force")).Ok); | |
| 512 | + } | |
| 513 | + | |
| 514 | + [Fact] | |
| 515 | + public async Task Rename_does_not_touch_the_directory() | |
| 516 | + { | |
| 517 | + var user = await host.CreateUserAsync(); | |
| 518 | + var repo = await host.CreateRepoAsync(user, "before-rename", Visibility.Private); | |
| 519 | + var directory = host.RepoDirectory(repo.Id); | |
| 520 | + var created = Directory.GetCreationTimeUtc(directory); | |
| 521 | + | |
| 522 | + var error = await host.WithScopeAsync(async sp => | |
| 523 | + { | |
| 524 | + var service = sp.GetRequiredService<RepoService>(); | |
| 525 | + var tracked = await service.FindAsync("jessie", "before-rename"); | |
| 526 | + return await service.RenameAsync(tracked!, "after-rename"); | |
| 527 | + }); | |
| 528 | + | |
| 529 | + Assert.Null(error); | |
| 530 | + Assert.True(Directory.Exists(directory)); | |
| 531 | + Assert.Equal(created, Directory.GetCreationTimeUtc(directory)); | |
| 532 | + Assert.Equal([directory], Directory.GetDirectories(Path.GetDirectoryName(directory)!, repo.Id + ".git")); | |
| 533 | + } | |
| 534 | +} | |
| 535 | + | |
| 536 | +/// <summary>First-run setup needs an empty database, so it gets a host of its own.</summary> | |
| 537 | +public class SetupTests(ForgeHost host) : IClassFixture<ForgeHost> | |
| 538 | +{ | |
| 539 | + [Fact] | |
| 540 | + public async Task Setup_creates_the_first_account_and_then_closes_for_good() | |
| 541 | + { | |
| 542 | + using var client = host.CreateClient(); | |
| 543 | + | |
| 544 | + // With no account, the home page leads to setup. | |
| 545 | + var home = await client.GetAsync("/"); | |
| 546 | + Assert.Equal("/setup", home.Headers.Location?.PathAndQuery); | |
| 547 | + Assert.True(File.Exists(Path.Combine(host.DataPath, "forge.db"))); | |
| 548 | + Assert.True(Directory.Exists(Path.Combine(host.DataPath, "repos"))); | |
| 549 | + | |
| 550 | + var mismatch = await ForgeHost.PostFormAsync(client, "/setup", "setup", new() | |
| 551 | + { | |
| 552 | + ["Username"] = "jessie", | |
| 553 | + ["Password"] = ForgeHost.Password, | |
| 554 | + ["PasswordRepeat"] = "something else", | |
| 555 | + }); | |
| 556 | + Assert.Contains("do not match", await ForgeHost.TextAsync(mismatch)); | |
| 557 | + | |
| 558 | + var reserved = await ForgeHost.PostFormAsync(client, "/setup", "setup", new() | |
| 559 | + { | |
| 560 | + ["Username"] = "settings", | |
| 561 | + ["Password"] = ForgeHost.Password, | |
| 562 | + ["PasswordRepeat"] = ForgeHost.Password, | |
| 563 | + }); | |
| 564 | + Assert.Contains("reserved", await ForgeHost.TextAsync(reserved)); | |
| 565 | + | |
| 566 | + var created = await ForgeHost.PostFormAsync(client, "/setup", "setup", new() | |
| 567 | + { | |
| 568 | + ["Username"] = "jessie", | |
| 569 | + ["DisplayName"] = "Jessie", | |
| 570 | + ["Password"] = ForgeHost.Password, | |
| 571 | + ["PasswordRepeat"] = ForgeHost.Password, | |
| 572 | + }); | |
| 573 | + Assert.Equal(HttpStatusCode.Redirect, created.StatusCode); | |
| 574 | + Assert.Equal("/", created.Headers.Location?.PathAndQuery); | |
| 575 | + | |
| 576 | + // Setup signed the new user in. | |
| 577 | + var signedIn = await client.GetStringAsync("/"); | |
| 578 | + Assert.Contains("Sign out (jessie)", signedIn); | |
| 579 | + | |
| 580 | + // The password is stored hashed. | |
| 581 | + var user = await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().Users.SingleAsync()); | |
| 582 | + Assert.DoesNotContain(ForgeHost.Password, user.PasswordHash); | |
| 583 | + | |
| 584 | + // Setup is gone, for the signed-in user and for strangers, on GET and on POST. | |
| 585 | + using var stranger = host.CreateClient(); | |
| 586 | + Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync("/setup")).StatusCode); | |
| 587 | + Assert.Equal(HttpStatusCode.NotFound, (await stranger.GetAsync("/setup")).StatusCode); | |
| 588 | + var loginPage = await stranger.GetAsync("/login"); | |
| 589 | + var token = System.Text.RegularExpressions.Regex.Match( | |
| 590 | + await loginPage.Content.ReadAsStringAsync(), "name=\"__RequestVerificationToken\" value=\"([^\"]+)\"").Groups[1].Value; | |
| 591 | + var second = await stranger.PostAsync("/setup", new FormUrlEncodedContent(new Dictionary<string, string> | |
| 592 | + { | |
| 593 | + ["__RequestVerificationToken"] = token, | |
| 594 | + ["_handler"] = "setup", | |
| 595 | + ["Username"] = "intruder", | |
| 596 | + ["Password"] = ForgeHost.Password, | |
| 597 | + ["PasswordRepeat"] = ForgeHost.Password, | |
| 598 | + })); | |
| 599 | + // The page no longer renders a form, so the framework refuses the post (400) before any handler runs. | |
| 600 | + Assert.True( | |
| 601 | + second.StatusCode is HttpStatusCode.NotFound or HttpStatusCode.BadRequest, | |
| 602 | + $"POST /setup answered {(int)second.StatusCode}"); | |
| 603 | + Assert.Equal(1, await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().Users.CountAsync())); | |
| 604 | + | |
| 605 | + // Logout ends the session; a wrong password does not start one; the right one does. | |
| 606 | + var page = await client.GetStringAsync("/"); | |
| 607 | + var logoutToken = System.Text.RegularExpressions.Regex.Match(page, "name=\"__RequestVerificationToken\" value=\"([^\"]+)\"").Groups[1].Value; | |
| 608 | + var loggedOut = await client.PostAsync("/logout", new FormUrlEncodedContent(new Dictionary<string, string> | |
| 609 | + { | |
| 610 | + ["__RequestVerificationToken"] = logoutToken, | |
| 611 | + })); | |
| 612 | + Assert.Equal(HttpStatusCode.Redirect, loggedOut.StatusCode); | |
| 613 | + Assert.Contains("Sign in", await client.GetStringAsync("/")); | |
| 614 | + | |
| 615 | + var wrong = await ForgeHost.PostFormAsync(client, "/login", "login", new() { ["Username"] = "jessie", ["Password"] = "wrong password" }); | |
| 616 | + Assert.Equal(HttpStatusCode.OK, wrong.StatusCode); | |
| 617 | + Assert.Contains("Wrong username or password", await ForgeHost.TextAsync(wrong)); | |
| 618 | + | |
| 619 | + var right = await ForgeHost.PostFormAsync(client, "/login?returnUrl=%2Fnew", "login", new() { ["Username"] = "JESSIE", ["Password"] = ForgeHost.Password }); | |
| 620 | + Assert.Equal("/new", right.Headers.Location?.PathAndQuery); | |
| 621 | + | |
| 622 | + // An off-site return URL is ignored. | |
| 623 | + using var other = host.CreateClient(); | |
| 624 | + var offsite = await ForgeHost.PostFormAsync(other, "/login?returnUrl=%2F%2Fevil.example", "login", new() { ["Username"] = "jessie", ["Password"] = ForgeHost.Password }); | |
| 625 | + Assert.Equal("/", offsite.Headers.Location?.PathAndQuery); | |
| 626 | + } | |
| 627 | +} | |
| 628 | + | |
| 629 | +/// <summary>The login limiter is per client address, so this needs a host nobody else is logging in to.</summary> | |
| 630 | +public class RateLimitTests(ForgeHost host) : IClassFixture<ForgeHost> | |
| 631 | +{ | |
| 632 | + [Fact] | |
| 633 | + public async Task Login_attempts_are_rate_limited() | |
| 634 | + { | |
| 635 | + await host.CreateUserAsync(); | |
| 636 | + using var client = host.CreateClient(); | |
| 637 | + | |
| 638 | + var statuses = new List<HttpStatusCode>(); | |
| 639 | + for (var i = 0; i < 12; i++) | |
| 640 | + { | |
| 641 | + var response = await ForgeHost.PostFormAsync(client, "/login", "login", new() { ["Username"] = "jessie", ["Password"] = "guess " + i }); | |
| 642 | + statuses.Add(response.StatusCode); | |
| 643 | + } | |
| 644 | + | |
| 645 | + Assert.All(statuses.Take(10), s => Assert.Equal(HttpStatusCode.OK, s)); | |
| 646 | + Assert.Contains(HttpStatusCode.TooManyRequests, statuses.Skip(10)); | |
| 647 | + // Reading the login page is still possible. | |
| 648 | + Assert.Equal(HttpStatusCode.OK, (await client.GetAsync("/login")).StatusCode); | |
| 649 | + } | |
| 650 | +} |
added forge.Tests/WebhookTests.cs +199 −0View file
| @@ -0,0 +1,199 @@ | ||
| 1 | +using System.Collections.Concurrent; | |
| 2 | +using System.Net; | |
| 3 | +using System.Text.Json; | |
| 4 | +using Forge.Data; | |
| 5 | +using Forge.Features.Webhooks; | |
| 6 | +using Forge.Tests.Support; | |
| 7 | +using Microsoft.EntityFrameworkCore; | |
| 8 | +using Microsoft.Extensions.DependencyInjection; | |
| 9 | + | |
| 10 | +namespace Forge.Tests; | |
| 11 | + | |
| 12 | +public class WebhookTests(ForgeHost host) : IClassFixture<ForgeHost> | |
| 13 | +{ | |
| 14 | + private sealed record Received(string Event, string Delivery, string Signature, byte[] Body); | |
| 15 | + | |
| 16 | + /// <summary>A local HTTP endpoint standing in for a CI server. Answers with whatever status the test queues.</summary> | |
| 17 | + private sealed class Receiver : IAsyncDisposable | |
| 18 | + { | |
| 19 | + private readonly WebApplication _app; | |
| 20 | + | |
| 21 | + public ConcurrentQueue<Received> Requests { get; } = new(); | |
| 22 | + public ConcurrentQueue<int> Statuses { get; } = new(); | |
| 23 | + public string Url { get; } | |
| 24 | + | |
| 25 | + private Receiver(WebApplication app) | |
| 26 | + { | |
| 27 | + _app = app; | |
| 28 | + Url = app.Urls.First().TrimEnd('/') + "/hook"; | |
| 29 | + } | |
| 30 | + | |
| 31 | + public static async Task<Receiver> StartAsync() | |
| 32 | + { | |
| 33 | + var builder = WebApplication.CreateBuilder(["--urls=http://127.0.0.1:0", "--Logging:LogLevel:Default=Warning"]); | |
| 34 | + var app = builder.Build(); | |
| 35 | + Receiver? self = null; | |
| 36 | + app.MapPost("/hook", async (HttpContext context) => | |
| 37 | + { | |
| 38 | + using var body = new MemoryStream(); | |
| 39 | + await context.Request.Body.CopyToAsync(body); | |
| 40 | + self!.Requests.Enqueue(new Received( | |
| 41 | + context.Request.Headers["X-Forge-Event"].ToString(), | |
| 42 | + context.Request.Headers["X-Forge-Delivery"].ToString(), | |
| 43 | + context.Request.Headers["X-Forge-Signature"].ToString(), | |
| 44 | + body.ToArray())); | |
| 45 | + return Results.StatusCode(self.Statuses.TryDequeue(out var status) ? status : 200); | |
| 46 | + }); | |
| 47 | + await app.StartAsync(); | |
| 48 | + self = new Receiver(app); | |
| 49 | + return self; | |
| 50 | + } | |
| 51 | + | |
| 52 | + public async Task<Received> NextAsync(int count = 1) | |
| 53 | + { | |
| 54 | + var deadline = DateTime.UtcNow.AddSeconds(30); | |
| 55 | + while (Requests.Count < count) | |
| 56 | + { | |
| 57 | + Assert.True(DateTime.UtcNow < deadline, $"Expected {count} webhook request(s), got {Requests.Count}."); | |
| 58 | + await Task.Delay(50); | |
| 59 | + } | |
| 60 | + | |
| 61 | + return Requests.ElementAt(count - 1); | |
| 62 | + } | |
| 63 | + | |
| 64 | + public async ValueTask DisposeAsync() | |
| 65 | + { | |
| 66 | + await _app.StopAsync(); | |
| 67 | + await _app.DisposeAsync(); | |
| 68 | + } | |
| 69 | + } | |
| 70 | + | |
| 71 | + private Task<List<WebhookDelivery>> DeliveriesAsync(long webhookId) => | |
| 72 | + host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().WebhookDeliveries | |
| 73 | + .Where(d => d.WebhookId == webhookId).OrderBy(d => d.Id).ToListAsync()); | |
| 74 | + | |
| 75 | + private async Task<List<WebhookDelivery>> WaitForDeliveriesAsync(long webhookId, Func<List<WebhookDelivery>, bool> done) | |
| 76 | + { | |
| 77 | + var deadline = DateTime.UtcNow.AddSeconds(30); | |
| 78 | + while (true) | |
| 79 | + { | |
| 80 | + var rows = await DeliveriesAsync(webhookId); | |
| 81 | + if (done(rows)) | |
| 82 | + { | |
| 83 | + return rows; | |
| 84 | + } | |
| 85 | + | |
| 86 | + Assert.True(DateTime.UtcNow < deadline, $"Deliveries did not reach the expected state; have {rows.Count}."); | |
| 87 | + await Task.Delay(50); | |
| 88 | + } | |
| 89 | + } | |
| 90 | + | |
| 91 | + [Fact] | |
| 92 | + public async Task Push_sends_a_signed_payload_and_failures_are_retried() | |
| 93 | + { | |
| 94 | + WebhookWorker.RetryDelays = [TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100)]; | |
| 95 | + await using var receiver = await Receiver.StartAsync(); | |
| 96 | + var user = await host.CreateUserAsync(); | |
| 97 | + var repo = await host.CreateRepoAsync(user, "hooked", Visibility.Public); | |
| 98 | + var token = await host.CreateTokenAsync(user, canWrite: true); | |
| 99 | + using var client = await host.CreateSignedInClientAsync(); | |
| 100 | + | |
| 101 | + // Add the webhook through the UI. | |
| 102 | + var added = await ForgeHost.PostFormAsync(client, "/jessie/hooked/settings/webhooks", "add-webhook", new() | |
| 103 | + { | |
| 104 | + ["Url"] = receiver.Url, | |
| 105 | + ["Secret"] = "s3cret", | |
| 106 | + }); | |
| 107 | + Assert.Equal(HttpStatusCode.Redirect, added.StatusCode); | |
| 108 | + var hook = await host.WithScopeAsync(sp => sp.GetRequiredService<ForgeDb>().Webhooks.SingleAsync(w => w.RepoId == repo.Id)); | |
| 109 | + var detailUrl = $"/jessie/hooked/settings/webhooks/{hook.Id}"; | |
| 110 | + | |
| 111 | + // Test ping. | |
| 112 | + var pinged = await ForgeHost.PostFormAsync(client, detailUrl, "hook-action", new() { ["Action"] = "ping" }); | |
| 113 | + Assert.Contains("The ping was delivered", await ForgeHost.TextAsync(pinged)); | |
| 114 | + var ping = await receiver.NextAsync(1); | |
| 115 | + Assert.Equal("ping", ping.Event); | |
| 116 | + Assert.Equal(WebhookSender.Sign("s3cret", ping.Body), ping.Signature); | |
| 117 | + | |
| 118 | + // A push: the first attempt fails with 500, the retry succeeds. | |
| 119 | + receiver.Statuses.Enqueue(500); | |
| 120 | + var work = host.NewDir("work"); | |
| 121 | + var sha = await host.Git.CreateWorkRepoAsync(work); | |
| 122 | + await host.Git.MustAsync(work, "push", host.GitUrl("jessie", "hooked", token), "main"); | |
| 123 | + | |
| 124 | + var retried = await receiver.NextAsync(3); | |
| 125 | + Assert.Equal("push", retried.Event); | |
| 126 | + Assert.Equal(WebhookSender.Sign("s3cret", retried.Body), retried.Signature); | |
| 127 | + Assert.StartsWith("sha256=", retried.Signature); | |
| 128 | + | |
| 129 | + using var payload = JsonDocument.Parse(retried.Body); | |
| 130 | + var root = payload.RootElement; | |
| 131 | + Assert.Equal("refs/heads/main", root.GetProperty("ref").GetString()); | |
| 132 | + Assert.Equal(Git.GitParsers.ZeroSha, root.GetProperty("before").GetString()); | |
| 133 | + Assert.Equal(sha, root.GetProperty("after").GetString()); | |
| 134 | + Assert.Equal("jessie/hooked", root.GetProperty("repository").GetProperty("full_name").GetString()); | |
| 135 | + Assert.Equal("http://forge.test/jessie/hooked.git", root.GetProperty("repository").GetProperty("clone_url").GetString()); | |
| 136 | + Assert.StartsWith("http://forge.test/jessie/hooked/", root.GetProperty("compare").GetString()); | |
| 137 | + var commit = Assert.Single(root.GetProperty("commits").EnumerateArray()); | |
| 138 | + Assert.Equal(sha, commit.GetProperty("id").GetString()); | |
| 139 | + Assert.Equal("First commit", commit.GetProperty("message").GetString()); | |
| 140 | + | |
| 141 | + // Every attempt is a row: ping, failed push, successful retry. | |
| 142 | + var rows = await WaitForDeliveriesAsync(hook.Id, r => r.Count(d => d.PushEventId != null && d.StatusCode != null) == 2); | |
| 143 | + var pushRows = rows.Where(d => d.PushEventId != null).ToList(); | |
| 144 | + Assert.Equal([(1, 500), (2, 200)], pushRows.Select(d => (d.Attempt, d.StatusCode!.Value))); | |
| 145 | + Assert.Equal(retried.Delivery, pushRows[1].Id.ToString()); | |
| 146 | + Assert.Null(rows[0].PushEventId); | |
| 147 | + Assert.Equal(200, rows[0].StatusCode); | |
| 148 | + | |
| 149 | + // The history page lists them, and Redeliver sends the event again. | |
| 150 | + var history = await client.GetStringAsync(detailUrl); | |
| 151 | + Assert.Contains("refs/heads/main", history); | |
| 152 | + var redelivered = await ForgeHost.PostFormAsync(client, detailUrl, "redeliver", new() { ["DeliveryId"] = pushRows[0].Id.ToString() }); | |
| 153 | + Assert.Contains("Delivered again", await ForgeHost.TextAsync(redelivered)); | |
| 154 | + var again = await receiver.NextAsync(4); | |
| 155 | + Assert.Equal(retried.Body, again.Body); | |
| 156 | + Assert.Equal(3, (await DeliveriesAsync(hook.Id)).Last().Attempt); | |
| 157 | + | |
| 158 | + // A disabled webhook receives nothing. | |
| 159 | + await ForgeHost.PostFormAsync(client, detailUrl, "hook-action", new() { ["Action"] = "toggle" }); | |
| 160 | + await File.WriteAllTextAsync(Path.Combine(work, "more.txt"), "more\n"); | |
| 161 | + await host.Git.MustAsync(work, "add", "-A"); | |
| 162 | + await host.Git.MustAsync(work, "commit", "-m", "More"); | |
| 163 | + await host.Git.MustAsync(work, "push", host.GitUrl("jessie", "hooked", token), "main"); | |
| 164 | + await Task.Delay(500); | |
| 165 | + Assert.Equal(4, receiver.Requests.Count); | |
| 166 | + | |
| 167 | + // Deleting the repository removes its webhooks and deliveries with it. | |
| 168 | + await host.WithScopeAsync(async sp => | |
| 169 | + { | |
| 170 | + var service = sp.GetRequiredService<Features.Repos.RepoService>(); | |
| 171 | + await service.DeleteAsync((await service.FindAsync("jessie", "hooked"))!); | |
| 172 | + return 0; | |
| 173 | + }); | |
| 174 | + Assert.Empty(await DeliveriesAsync(hook.Id)); | |
| 175 | + } | |
| 176 | + | |
| 177 | + [Fact] | |
| 178 | + public async Task Unreachable_receiver_is_recorded_as_a_failed_delivery() | |
| 179 | + { | |
| 180 | + var user = await host.CreateUserAsync(); | |
| 181 | + var repo = await host.CreateRepoAsync(user, "unreachable", Visibility.Public); | |
| 182 | + var hook = await host.WithScopeAsync(async sp => | |
| 183 | + { | |
| 184 | + var db = sp.GetRequiredService<ForgeDb>(); | |
| 185 | + // Port 9 (discard) on localhost: nothing listens there. | |
| 186 | + var row = new Webhook { RepoId = repo.Id, Url = "http://127.0.0.1:9/hook", Secret = "x", CreatedAt = DateTime.UtcNow }; | |
| 187 | + db.Webhooks.Add(row); | |
| 188 | + await db.SaveChangesAsync(); | |
| 189 | + return row; | |
| 190 | + }); | |
| 191 | + | |
| 192 | + var ok = await host.Services.GetRequiredService<WebhookSender>().DeliverAsync(hook.Id, null, 1); | |
| 193 | + | |
| 194 | + Assert.False(ok); | |
| 195 | + var delivery = Assert.Single(await DeliveriesAsync(hook.Id)); | |
| 196 | + Assert.Null(delivery.StatusCode); | |
| 197 | + Assert.False(string.IsNullOrEmpty(delivery.Error)); | |
| 198 | + } | |
| 199 | +} |
added forge.Tests/forge.Tests.csproj +29 −0View file
| @@ -0,0 +1,29 @@ | ||
| 1 | +<Project Sdk="Microsoft.NET.Sdk"> | |
| 2 | + | |
| 3 | + <PropertyGroup> | |
| 4 | + <TargetFramework>net11.0</TargetFramework> | |
| 5 | + <Nullable>enable</Nullable> | |
| 6 | + <ImplicitUsings>enable</ImplicitUsings> | |
| 7 | + <IsPackable>false</IsPackable> | |
| 8 | + <RootNamespace>Forge.Tests</RootNamespace> | |
| 9 | + </PropertyGroup> | |
| 10 | + | |
| 11 | + <ItemGroup> | |
| 12 | + <FrameworkReference Include="Microsoft.AspNetCore.App" /> | |
| 13 | + <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.12.0" /> | |
| 14 | + <PackageReference Include="xunit" Version="2.9.3" /> | |
| 15 | + <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5" /> | |
| 16 | + </ItemGroup> | |
| 17 | + | |
| 18 | + <ItemGroup> | |
| 19 | + <ProjectReference Include="..\forge\forge.csproj" /> | |
| 20 | + </ItemGroup> | |
| 21 | + | |
| 22 | + <ItemGroup> | |
| 23 | + <Using Include="Xunit" /> | |
| 24 | + <Using Include="Microsoft.AspNetCore.Builder" /> | |
| 25 | + <Using Include="Microsoft.AspNetCore.Http" /> | |
| 26 | + <Using Include="Microsoft.Extensions.Hosting" /> | |
| 27 | + </ItemGroup> | |
| 28 | + | |
| 29 | +</Project> |
added forge.slnx +4 −0View file
| @@ -0,0 +1,4 @@ | ||
| 1 | +<Solution> | |
| 2 | + <Project Path="forge/forge.csproj" /> | |
| 3 | + <Project Path="forge.Tests/forge.Tests.csproj" /> | |
| 4 | +</Solution> |
added forge/Components/App.razor +25 −0View file
| @@ -0,0 +1,25 @@ | ||
| 1 | +<!DOCTYPE html> | |
| 2 | +<html lang="@T.Language"> | |
| 3 | + | |
| 4 | +<head> | |
| 5 | + <meta charset="utf-8"/> | |
| 6 | + <meta name="viewport" content="width=device-width, initial-scale=1.0"/> | |
| 7 | + <meta name="color-scheme" content="light dark"/> | |
| 8 | + <script src="/theme.js?v=@AssetVersion"></script> | |
| 9 | + <link rel="stylesheet" href="/style.css?v=@AssetVersion"/> | |
| 10 | + <link rel="icon" type="image/png" href="/favicon.png"/> | |
| 11 | + <HeadOutlet/> | |
| 12 | +</head> | |
| 13 | + | |
| 14 | +<body> | |
| 15 | +<Routes/> | |
| 16 | +<script src="/app.js?v=@AssetVersion" defer></script> | |
| 17 | +</body> | |
| 18 | + | |
| 19 | +</html> | |
| 20 | + | |
| 21 | +@code { | |
| 22 | + /// <summary>Changes with every build, so browsers pick up new CSS and JS.</summary> | |
| 23 | + public static readonly string AssetVersion = | |
| 24 | + typeof(App).Assembly.ManifestModule.ModuleVersionId.ToString("N")[..8]; | |
| 25 | +} |
added forge/Components/Avatar.razor +32 −0View file
| @@ -0,0 +1,32 @@ | ||
| 1 | +@* A generated avatar: the first letter on one of eight colours, picked from the name so it never changes. *@ | |
| 2 | +<span class="avatar avatar-@Size avatar-c@(ColorIndex(Name))" aria-hidden="true">@Initial</span> | |
| 3 | + | |
| 4 | +@code { | |
| 5 | + [Parameter, EditorRequired] | |
| 6 | + public string Name { get; set; } = ""; | |
| 7 | + | |
| 8 | + /// <summary>sm (20px), md (28px) or lg (72px).</summary> | |
| 9 | + [Parameter] | |
| 10 | + public string Size { get; set; } = "sm"; | |
| 11 | + | |
| 12 | + private string Initial | |
| 13 | + { | |
| 14 | + get | |
| 15 | + { | |
| 16 | + var trimmed = Name.Trim(); | |
| 17 | + return trimmed.Length == 0 ? "?" : System.Globalization.StringInfo.GetNextTextElement(trimmed).ToUpperInvariant(); | |
| 18 | + } | |
| 19 | + } | |
| 20 | + | |
| 21 | + /// <summary>A stable hash (string.GetHashCode differs between runs).</summary> | |
| 22 | + public static int ColorIndex(string name) | |
| 23 | + { | |
| 24 | + var hash = 2166136261u; | |
| 25 | + foreach (var c in name.Trim().ToLowerInvariant()) | |
| 26 | + { | |
| 27 | + hash = (hash ^ c) * 16777619u; | |
| 28 | + } | |
| 29 | + | |
| 30 | + return (int)(hash % 8); | |
| 31 | + } | |
| 32 | +} |
added forge/Components/Breadcrumbs.razor +29 −0View file
| @@ -0,0 +1,29 @@ | ||
| 1 | +<nav class="breadcrumbs" aria-label="@T["Path"]"> | |
| 2 | + <a href="@Urls.Tree(Repository, RefName)">@Repository.Name</a> | |
| 3 | + @for (var i = 0; i < Segments.Length; i++) | |
| 4 | + { | |
| 5 | + var upTo = string.Join('/', Segments, 0, i + 1); | |
| 6 | + <span class="sep">/</span> | |
| 7 | + @if (i == Segments.Length - 1) | |
| 8 | + { | |
| 9 | + <strong>@Segments[i]</strong> | |
| 10 | + } | |
| 11 | + else | |
| 12 | + { | |
| 13 | + <a href="@Urls.Tree(Repository, RefName, upTo)">@Segments[i]</a> | |
| 14 | + } | |
| 15 | + } | |
| 16 | +</nav> | |
| 17 | + | |
| 18 | +@code { | |
| 19 | + [Parameter, EditorRequired] | |
| 20 | + public Repository Repository { get; set; } = null!; | |
| 21 | + | |
| 22 | + [Parameter, EditorRequired] | |
| 23 | + public string RefName { get; set; } = ""; | |
| 24 | + | |
| 25 | + [Parameter] | |
| 26 | + public string Path { get; set; } = ""; | |
| 27 | + | |
| 28 | + private string[] Segments => Path.Length == 0 ? [] : Path.Split('/'); | |
| 29 | +} |
added forge/Components/CloneBox.razor +22 −0View file
| @@ -0,0 +1,22 @@ | ||
| 1 | +@* The "Clone" dropdown. A <details> element, so it opens without script; only the copy button needs it. *@ | |
| 2 | +<details class="menu clone-menu"> | |
| 3 | + <summary class="button"> | |
| 4 | + <Icon Name="download"/> @T["Clone"] <Icon Name="chevron-down" Size="14"/> | |
| 5 | + </summary> | |
| 6 | + <div class="menu-panel menu-right clone-panel"> | |
| 7 | + <p class="clone-title"><Icon Name="link" Size="14"/> @T["Clone over HTTP"]</p> | |
| 8 | + <div class="clone-box"> | |
| 9 | + <input type="text" readonly value="@Url" aria-label="@T["Clone URL"]" class="clone-url"/> | |
| 10 | + <button type="button" class="button js-only" data-copy="@Url" data-copied-label="@T["Copied"]" | |
| 11 | + title="@T["Copy"]" aria-label="@T["Copy"]"> | |
| 12 | + <Icon Name="copy"/> | |
| 13 | + </button> | |
| 14 | + </div> | |
| 15 | + <p class="muted small clone-hint">@T["Use an access token as the password."]</p> | |
| 16 | + </div> | |
| 17 | +</details> | |
| 18 | + | |
| 19 | +@code { | |
| 20 | + [Parameter, EditorRequired] | |
| 21 | + public string Url { get; set; } = ""; | |
| 22 | +} |
added forge/Components/CommitList.razor +55 −0View file
| @@ -0,0 +1,55 @@ | ||
| 1 | +@foreach (var group in Groups) | |
| 2 | +{ | |
| 3 | + @if (GroupByDay) | |
| 4 | + { | |
| 5 | + <h3 class="commit-day"> | |
| 6 | + <Icon Name="commit"/> @T["Commits on {0}", group.Key.ToString("d MMMM yyyy", CultureInfo.CurrentCulture)] | |
| 7 | + </h3> | |
| 8 | + } | |
| 9 | + <ul class="commit-list"> | |
| 10 | + @foreach (var c in group) | |
| 11 | + { | |
| 12 | + <li class="commit-row"> | |
| 13 | + <div class="commit-main"> | |
| 14 | + <a class="commit-subject" href="@Urls.Commit(Repository, c.Sha)">@(c.Subject.Length == 0 ? T["(no message)"] : c.Subject)</a> | |
| 15 | + <div class="muted small commit-byline"> | |
| 16 | + <Avatar Name="@c.AuthorName"/> | |
| 17 | + <span>@c.AuthorName</span> | |
| 18 | + <span class="sep">·</span> | |
| 19 | + <TimeAgo Value="c.AuthorDate"/> | |
| 20 | + </div> | |
| 21 | + </div> | |
| 22 | + <div class="commit-actions"> | |
| 23 | + <span class="button-group"> | |
| 24 | + <a class="button small sha" href="@Urls.Commit(Repository, c.Sha)">@c.ShortSha</a> | |
| 25 | + <button type="button" class="button small js-only" data-copy="@c.Sha" | |
| 26 | + title="@T["Copy the full SHA"]" aria-label="@T["Copy the full SHA"]"> | |
| 27 | + <Icon Name="copy" Size="14"/> | |
| 28 | + </button> | |
| 29 | + </span> | |
| 30 | + <a class="button small" href="@Urls.Tree(Repository, c.Sha)" | |
| 31 | + title="@T["Browse files at this commit"]" aria-label="@T["Browse files at this commit"]"> | |
| 32 | + <Icon Name="code" Size="14"/> | |
| 33 | + </a> | |
| 34 | + </div> | |
| 35 | + </li> | |
| 36 | + } | |
| 37 | + </ul> | |
| 38 | +} | |
| 39 | + | |
| 40 | +@code { | |
| 41 | + [Parameter, EditorRequired] | |
| 42 | + public Repository Repository { get; set; } = null!; | |
| 43 | + | |
| 44 | + [Parameter, EditorRequired] | |
| 45 | + public IReadOnlyList<CommitInfo> Commits { get; set; } = []; | |
| 46 | + | |
| 47 | + /// <summary>Puts a date heading above the commits of each day (in the author's time zone).</summary> | |
| 48 | + [Parameter] | |
| 49 | + public bool GroupByDay { get; set; } | |
| 50 | + | |
| 51 | + private IEnumerable<IGrouping<DateTime, CommitInfo>> Groups => | |
| 52 | + GroupByDay | |
| 53 | + ? Commits.GroupBy(c => c.AuthorDate.Date) | |
| 54 | + : Commits.GroupBy(_ => DateTime.MinValue); | |
| 55 | +} |
added forge/Components/Counter.razor +10 −0View file
| @@ -0,0 +1,10 @@ | ||
| 1 | +@* A small count next to a tab label. Zero shows nothing. *@ | |
| 2 | +@if (Value > 0) | |
| 3 | +{ | |
| 4 | + <span class="counter">@Value.ToString("N0", CultureInfo.CurrentCulture)</span> | |
| 5 | +} | |
| 6 | + | |
| 7 | +@code { | |
| 8 | + [Parameter] | |
| 9 | + public int Value { get; set; } | |
| 10 | +} |
added forge/Components/Error.razor +5 −0View file
| @@ -0,0 +1,5 @@ | ||
| 1 | +@page "/error" | |
| 2 | + | |
| 3 | +<PageTitle>@T["Error"] · Forge</PageTitle> | |
| 4 | + | |
| 5 | +<StatusMessage Code="500"/> |
added forge/Components/HighlightAssets.razor +7 −0View file
| @@ -0,0 +1,7 @@ | ||
| 1 | +@* Loads highlight.js from this server. Use on pages that show code; a page can have only one HeadContent. | |
| 2 | + app.js switches the two stylesheets when the visitor picks a theme by hand (data-hl-theme). *@ | |
| 3 | +<HeadContent> | |
| 4 | + <link rel="stylesheet" href="/lib/highlight/github.min.css" media="(prefers-color-scheme: light)" data-hl-theme="light"/> | |
| 5 | + <link rel="stylesheet" href="/lib/highlight/github-dark.min.css" media="(prefers-color-scheme: dark)" data-hl-theme="dark"/> | |
| 6 | + <script src="/lib/highlight/highlight.min.js" defer></script> | |
| 7 | +</HeadContent> |
added forge/Components/Highlighted.razor +40 −0View file
| @@ -0,0 +1,40 @@ | ||
| 1 | +@* Text with every occurrence of a search term marked. Case-insensitive. | |
| 2 | + Built as one string so that no whitespace is added or lost inside preformatted code. *@ | |
| 3 | +@((MarkupString)Render(Text, Term)) | |
| 4 | + | |
| 5 | +@code { | |
| 6 | + [Parameter, EditorRequired] | |
| 7 | + public string Text { get; set; } = ""; | |
| 8 | + | |
| 9 | + [Parameter, EditorRequired] | |
| 10 | + public string Term { get; set; } = ""; | |
| 11 | + | |
| 12 | + /// <summary>HTML for <paramref name="text"/>: every part is encoded, matches are wrapped in <mark>.</summary> | |
| 13 | + public static string Render(string text, string term) | |
| 14 | + { | |
| 15 | + var encode = System.Text.Encodings.Web.HtmlEncoder.Default; | |
| 16 | + if (term.Length == 0) | |
| 17 | + { | |
| 18 | + return encode.Encode(text); | |
| 19 | + } | |
| 20 | + | |
| 21 | + var html = new System.Text.StringBuilder(text.Length + 32); | |
| 22 | + var position = 0; | |
| 23 | + while (position < text.Length) | |
| 24 | + { | |
| 25 | + var found = text.IndexOf(term, position, StringComparison.OrdinalIgnoreCase); | |
| 26 | + if (found < 0) | |
| 27 | + { | |
| 28 | + break; | |
| 29 | + } | |
| 30 | + | |
| 31 | + html.Append(encode.Encode(text[position..found])) | |
| 32 | + .Append("<mark>") | |
| 33 | + .Append(encode.Encode(text.Substring(found, term.Length))) | |
| 34 | + .Append("</mark>"); | |
| 35 | + position = found + term.Length; | |
| 36 | + } | |
| 37 | + | |
| 38 | + return html.Append(encode.Encode(text[position..])).ToString(); | |
| 39 | + } | |
| 40 | +} |
added forge/Components/Icon.razor +59 −0View file
| @@ -0,0 +1,59 @@ | ||
| 1 | +@* Inline SVG icons (24×24 grid, drawn with the text colour). Inline because the CSP allows no external sprite tricks and no inline style. *@ | |
| 2 | +<svg class="@CssClass" viewBox="0 0 24 24" width="@Size" height="@Size" aria-hidden="true" focusable="false">@((MarkupString)Shapes.GetValueOrDefault(Name, ""))</svg> | |
| 3 | + | |
| 4 | +@code { | |
| 5 | + [Parameter, EditorRequired] | |
| 6 | + public string Name { get; set; } = ""; | |
| 7 | + | |
| 8 | + [Parameter] | |
| 9 | + public int Size { get; set; } = 16; | |
| 10 | + | |
| 11 | + [Parameter] | |
| 12 | + public string? Class { get; set; } | |
| 13 | + | |
| 14 | + private string CssClass => Class is null ? "icon" : "icon " + Class; | |
| 15 | + | |
| 16 | + private static readonly Dictionary<string, string> Shapes = new(StringComparer.Ordinal) | |
| 17 | + { | |
| 18 | + // An anvil. Used filled (class "logo-mark"). | |
| 19 | + ["logo"] = "<path d=\"M2 6h13c2.6 0 4.6-1 6.5-3 0 5-3 8.5-7.5 8.5h-1V16h3.5v4h-12v-4H8v-4.5C5 11.5 2.6 9.3 2 6Z\"/>", | |
| 20 | + ["folder"] = "<path d=\"M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z\"/>", | |
| 21 | + ["file"] = "<path d=\"M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z\"/><path d=\"M14 2v6h6\"/>", | |
| 22 | + ["code"] = "<path d=\"m16 18 6-6-6-6\"/><path d=\"m8 6-6 6 6 6\"/>", | |
| 23 | + ["commit"] = "<circle cx=\"12\" cy=\"12\" r=\"3\"/><path d=\"M3 12h6\"/><path d=\"M15 12h6\"/>", | |
| 24 | + ["branch"] = "<path d=\"M6 3v12\"/><circle cx=\"18\" cy=\"6\" r=\"3\"/><circle cx=\"6\" cy=\"18\" r=\"3\"/><path d=\"M18 9a9 9 0 0 1-9 9\"/>", | |
| 25 | + ["tag"] = "<path d=\"M12 2H2v10l9.29 9.29c.94.94 2.48.94 3.42 0l6.58-6.58c.94-.94.94-2.48 0-3.42L12 2Z\"/><path d=\"M7 7h.01\"/>", | |
| 26 | + ["pull"] = "<circle cx=\"18\" cy=\"18\" r=\"3\"/><circle cx=\"6\" cy=\"6\" r=\"3\"/><path d=\"M13 6h3a2 2 0 0 1 2 2v7\"/><path d=\"M6 9v12\"/>", | |
| 27 | + ["merge"] = "<circle cx=\"18\" cy=\"18\" r=\"3\"/><circle cx=\"6\" cy=\"6\" r=\"3\"/><path d=\"M6 21V9a9 9 0 0 0 9 9\"/>", | |
| 28 | + ["settings"] = "<path d=\"M4 21v-7\"/><path d=\"M4 10V3\"/><path d=\"M12 21v-9\"/><path d=\"M12 8V3\"/><path d=\"M20 21v-5\"/><path d=\"M20 12V3\"/><path d=\"M1 14h6\"/><path d=\"M9 8h6\"/><path d=\"M17 16h6\"/>", | |
| 29 | + ["search"] = "<circle cx=\"11\" cy=\"11\" r=\"8\"/><path d=\"m21 21-4.3-4.3\"/>", | |
| 30 | + ["plus"] = "<path d=\"M5 12h14\"/><path d=\"M12 5v14\"/>", | |
| 31 | + ["lock"] = "<rect x=\"3\" y=\"11\" width=\"18\" height=\"11\" rx=\"2\"/><path d=\"M7 11V7a5 5 0 0 1 10 0v4\"/>", | |
| 32 | + ["globe"] = "<circle cx=\"12\" cy=\"12\" r=\"10\"/><path d=\"M2 12h20\"/><path d=\"M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z\"/>", | |
| 33 | + ["copy"] = "<rect x=\"9\" y=\"9\" width=\"13\" height=\"13\" rx=\"2\"/><path d=\"M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1\"/>", | |
| 34 | + ["check"] = "<path d=\"M20 6 9 17l-5-5\"/>", | |
| 35 | + ["sun"] = "<circle cx=\"12\" cy=\"12\" r=\"4\"/><path d=\"M12 1v2\"/><path d=\"M12 21v2\"/><path d=\"m4.22 4.22 1.42 1.42\"/><path d=\"m18.36 18.36 1.42 1.42\"/><path d=\"M1 12h2\"/><path d=\"M21 12h2\"/><path d=\"m4.22 19.78 1.42-1.42\"/><path d=\"m18.36 5.64 1.42-1.42\"/>", | |
| 36 | + ["moon"] = "<path d=\"M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z\"/>", | |
| 37 | + ["monitor"] = "<rect x=\"2\" y=\"3\" width=\"20\" height=\"14\" rx=\"2\"/><path d=\"M8 21h8\"/><path d=\"M12 17v4\"/>", | |
| 38 | + ["chevron-down"] = "<path d=\"m6 9 6 6 6-6\"/>", | |
| 39 | + ["history"] = "<circle cx=\"12\" cy=\"12\" r=\"10\"/><path d=\"M12 6v6l4 2\"/>", | |
| 40 | + ["key"] = "<circle cx=\"7.5\" cy=\"15.5\" r=\"5.5\"/><path d=\"m21 2-9.6 9.6\"/><path d=\"m15.5 7.5 3 3L22 7l-3-3\"/>", | |
| 41 | + ["sign-out"] = "<path d=\"M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4\"/><path d=\"m16 17 5-5-5-5\"/><path d=\"M21 12H9\"/>", | |
| 42 | + ["book"] = "<path d=\"M4 19.5A2.5 2.5 0 0 1 6.5 17H20\"/><path d=\"M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z\"/>", | |
| 43 | + ["package"] = "<path d=\"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z\"/><path d=\"M3.27 6.96 12 12.01l8.73-5.05\"/><path d=\"M12 22.08V12\"/>", | |
| 44 | + ["download"] = "<path d=\"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4\"/><path d=\"m7 10 5 5 5-5\"/><path d=\"M12 15V3\"/>", | |
| 45 | + ["rss"] = "<path d=\"M4 11a9 9 0 0 1 9 9\"/><path d=\"M4 4a16 16 0 0 1 16 16\"/><circle cx=\"5\" cy=\"19\" r=\"1\"/>", | |
| 46 | + ["zap"] = "<path d=\"M13 2 3 14h9l-1 8 10-12h-9l1-8z\"/>", | |
| 47 | + ["shield"] = "<path d=\"M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z\"/>", | |
| 48 | + ["user"] = "<path d=\"M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2\"/><circle cx=\"12\" cy=\"7\" r=\"4\"/>", | |
| 49 | + ["users"] = "<path d=\"M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2\"/><circle cx=\"9\" cy=\"7\" r=\"4\"/><path d=\"M23 21v-2a4 4 0 0 0-3-3.87\"/><path d=\"M16 3.13a4 4 0 0 1 0 7.75\"/>", | |
| 50 | + ["link"] = "<path d=\"M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71\"/><path d=\"M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71\"/>", | |
| 51 | + ["activity"] = "<path d=\"M22 12h-4l-3 9L9 3l-3 9H2\"/>", | |
| 52 | + ["x"] = "<path d=\"M18 6 6 18\"/><path d=\"m6 6 12 12\"/>", | |
| 53 | + ["arrow-left"] = "<path d=\"M19 12H5\"/><path d=\"m12 19-7-7 7-7\"/>", | |
| 54 | + ["arrow-right"] = "<path d=\"M5 12h14\"/><path d=\"m12 5 7 7-7 7\"/>", | |
| 55 | + ["comment"] = "<path d=\"M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z\"/>", | |
| 56 | + ["inbox"] = "<path d=\"M22 12h-6l-2 3h-4l-2-3H2\"/><path d=\"M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z\"/>", | |
| 57 | + ["eye"] = "<path d=\"M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z\"/><circle cx=\"12\" cy=\"12\" r=\"3\"/>", | |
| 58 | + }; | |
| 59 | +} |
added forge/Components/LanguageBar.razor +30 −0View file
| @@ -0,0 +1,30 @@ | ||
| 1 | +@* Language shares as one stacked bar with a legend. Widths are SVG attributes because the CSP forbids inline style. *@ | |
| 2 | +<svg class="lang-bar" viewBox="0 0 100 8" preserveAspectRatio="none" width="100%" height="8" role="img" aria-label="@T["Languages"]"> | |
| 3 | + @{ | |
| 4 | + var x = 0.0; | |
| 5 | + foreach (var share in Shares) | |
| 6 | + { | |
| 7 | + // A 0.4 gap between slices, so neighbouring colours do not run together. | |
| 8 | + var width = Math.Max(share.Percent - 0.4, 0.2); | |
| 9 | + <rect class="lang-@share.Key" x="@Number(x)" y="0" width="@Number(width)" height="8"/> | |
| 10 | + x += share.Percent; | |
| 11 | + } | |
| 12 | + } | |
| 13 | +</svg> | |
| 14 | +<ul class="lang-legend"> | |
| 15 | + @foreach (var share in Shares) | |
| 16 | + { | |
| 17 | + <li> | |
| 18 | + <span class="lang-dot lang-@share.Key"></span> | |
| 19 | + <span>@(share.Name ?? T["Other"])</span> | |
| 20 | + <span class="muted">@share.Percent.ToString("0.0", CultureInfo.CurrentCulture) %</span> | |
| 21 | + </li> | |
| 22 | + } | |
| 23 | +</ul> | |
| 24 | + | |
| 25 | +@code { | |
| 26 | + [Parameter, EditorRequired] | |
| 27 | + public IReadOnlyList<LanguageShare> Shares { get; set; } = []; | |
| 28 | + | |
| 29 | + private static string Number(double value) => value.ToString("0.##", CultureInfo.InvariantCulture); | |
| 30 | +} |
added forge/Components/MainLayout.razor +130 −0View file
| @@ -0,0 +1,130 @@ | ||
| 1 | +@inherits LayoutComponentBase | |
| 2 | +@using Microsoft.AspNetCore.Diagnostics | |
| 3 | +@inject CurrentUser Me | |
| 4 | +@inject IHttpContextAccessor Http | |
| 5 | + | |
| 6 | +<a class="skip-link" href="#main">@T["Skip to content"]</a> | |
| 7 | + | |
| 8 | +<header class="topbar"> | |
| 9 | + <div class="wrap topbar-inner"> | |
| 10 | + <a class="brand" href="/"> | |
| 11 | + <Icon Name="logo" Size="22" Class="logo-mark"/> | |
| 12 | + <span>Forge</span> | |
| 13 | + </a> | |
| 14 | + | |
| 15 | + <form class="search" method="get" action="/" role="search"> | |
| 16 | + <Icon Name="search" Size="15"/> | |
| 17 | + <input type="search" name="q" value="@Query" placeholder="@T["Search repositories"]" | |
| 18 | + aria-label="@T["Search repositories"]" autocomplete="off" data-hotkey="/"/> | |
| 19 | + <kbd class="js-only">/</kbd> | |
| 20 | + </form> | |
| 21 | + | |
| 22 | + <nav class="topnav"> | |
| 23 | + <button type="button" class="icon-button js-only" data-theme-toggle | |
| 24 | + title="@T["Switch theme"]" aria-label="@T["Switch theme"]"> | |
| 25 | + <Icon Name="monitor" Size="17" Class="theme-icon theme-icon-auto"/> | |
| 26 | + <Icon Name="sun" Size="17" Class="theme-icon theme-icon-light"/> | |
| 27 | + <Icon Name="moon" Size="17" Class="theme-icon theme-icon-dark"/> | |
| 28 | + </button> | |
| 29 | + @if (Me.IsAuthenticated) | |
| 30 | + { | |
| 31 | + <a class="icon-button" href="/new" title="@T["New repository"]" aria-label="@T["New repository"]"> | |
| 32 | + <Icon Name="plus" Size="18"/> | |
| 33 | + </a> | |
| 34 | + <details class="menu"> | |
| 35 | + <summary class="menu-button" aria-label="@T["Account menu"]"> | |
| 36 | + <Avatar Name="@(Me.Username ?? "")" Size="md"/> | |
| 37 | + <Icon Name="chevron-down" Size="14"/> | |
| 38 | + </summary> | |
| 39 | + <div class="menu-panel menu-right"> | |
| 40 | + <p class="menu-header">@T["Signed in as"] <strong>@Me.Username</strong></p> | |
| 41 | + <a class="menu-item" href="@Urls.User(Me.Username!)"><Icon Name="book"/> @T["Your repositories"]</a> | |
| 42 | + <a class="menu-item" href="/new"><Icon Name="plus"/> @T["New repository"]</a> | |
| 43 | + <a class="menu-item" href="/settings/tokens"><Icon Name="key"/> @T["Access tokens"]</a> | |
| 44 | + <form method="post" action="/logout" class="menu-form"> | |
| 45 | + <AntiforgeryToken/> | |
| 46 | + <button type="submit" class="menu-item"><Icon Name="sign-out"/> @T["Sign out ({0})", Me.Username]</button> | |
| 47 | + </form> | |
| 48 | + </div> | |
| 49 | + </details> | |
| 50 | + } | |
| 51 | + else | |
| 52 | + { | |
| 53 | + <a class="button small" href="/login">@T["Sign in"]</a> | |
| 54 | + } | |
| 55 | + </nav> | |
| 56 | + </div> | |
| 57 | +</header> | |
| 58 | + | |
| 59 | +<main class="wrap" id="main"> | |
| 60 | + @Body | |
| 61 | +</main> | |
| 62 | + | |
| 63 | +<footer class="footer"> | |
| 64 | + <div class="wrap footer-inner"> | |
| 65 | + <span class="footer-brand muted"> | |
| 66 | + <Icon Name="logo" Size="15" Class="logo-mark"/> | |
| 67 | + Forge · @T["self-hosted Git"] | |
| 68 | + <button type="button" class="link-button js-only footer-link" data-open-dialog="shortcuts">@T["Keyboard shortcuts"]</button> | |
| 69 | + </span> | |
| 70 | + <form method="post" action="/language" class="language-form"> | |
| 71 | + <AntiforgeryToken/> | |
| 72 | + <input type="hidden" name="returnUrl" value="@ReturnUrl"/> | |
| 73 | + <span class="muted language-label"><Icon Name="globe" Size="14"/> @T["Language"]:</span> | |
| 74 | + @foreach (var language in T.Languages) | |
| 75 | + { | |
| 76 | + var name = CultureInfo.GetCultureInfo(language).NativeName; | |
| 77 | + @if (string.Equals(language, T.Language, StringComparison.OrdinalIgnoreCase)) | |
| 78 | + { | |
| 79 | + <strong lang="@language">@name</strong> | |
| 80 | + } | |
| 81 | + else | |
| 82 | + { | |
| 83 | + <button type="submit" name="lang" value="@language" lang="@language" class="link-button">@name</button> | |
| 84 | + } | |
| 85 | + } | |
| 86 | + </form> | |
| 87 | + </div> | |
| 88 | +</footer> | |
| 89 | + | |
| 90 | +@* Opened by the "?" key or the footer link (app.js). *@ | |
| 91 | +<dialog class="dialog" id="shortcuts" aria-labelledby="shortcuts-title"> | |
| 92 | + <h2 id="shortcuts-title">@T["Keyboard shortcuts"]</h2> | |
| 93 | + <dl class="shortcut-list"> | |
| 94 | + <dt><kbd>/</kbd></dt> | |
| 95 | + <dd>@T["Search repositories"]</dd> | |
| 96 | + <dt><kbd>s</kbd></dt> | |
| 97 | + <dd>@T["Search file names and code"]</dd> | |
| 98 | + <dt><kbd>y</kbd></dt> | |
| 99 | + <dd>@T["Open the permalink of the file being viewed"]</dd> | |
| 100 | + <dt><kbd>?</kbd></dt> | |
| 101 | + <dd>@T["Show this help"]</dd> | |
| 102 | + </dl> | |
| 103 | + <form method="dialog"> | |
| 104 | + <button type="submit" class="button">@T["Close"]</button> | |
| 105 | + </form> | |
| 106 | +</dialog> | |
| 107 | + | |
| 108 | +@code { | |
| 109 | + /// <summary>The search box keeps what was searched for on the repository list.</summary> | |
| 110 | + private string? Query => | |
| 111 | + Http.HttpContext is { } context && context.Request.Path == "/" ? context.Request.Query["q"].ToString() : null; | |
| 112 | + | |
| 113 | + /// <summary>Where the language switcher returns to: the page the visitor asked for, even when an error page is shown instead.</summary> | |
| 114 | + private string ReturnUrl | |
| 115 | + { | |
| 116 | + get | |
| 117 | + { | |
| 118 | + var context = Http.HttpContext; | |
| 119 | + if (context is null) | |
| 120 | + { | |
| 121 | + return "/"; | |
| 122 | + } | |
| 123 | + | |
| 124 | + var original = context.Features.Get<IStatusCodeReExecuteFeature>(); | |
| 125 | + return original is not null | |
| 126 | + ? original.OriginalPathBase + original.OriginalPath + original.OriginalQueryString | |
| 127 | + : context.Request.PathBase + context.Request.Path + context.Request.QueryString; | |
| 128 | + } | |
| 129 | + } | |
| 130 | +} |
added forge/Components/NotFound.razor +5 −0View file
| @@ -0,0 +1,5 @@ | ||
| 1 | +@page "/not-found" | |
| 2 | + | |
| 3 | +<PageTitle>@T["Not found"] · Forge</PageTitle> | |
| 4 | + | |
| 5 | +<StatusMessage Code="404"/> |
added forge/Components/RefSwitcher.razor +53 −0View file
| @@ -0,0 +1,53 @@ | ||
| 1 | +@* Branch and tag picker. A <details> element, so it needs no script. *@ | |
| 2 | +<details class="ref-switcher"> | |
| 3 | + <summary class="button"> | |
| 4 | + <span class="muted">@KindLabel:</span> | |
| 5 | + <strong>@(CurrentKind == ResolvedKind.Commit && Current.Length > 8 ? Current[..8] : Current)</strong> | |
| 6 | + </summary> | |
| 7 | + <div class="ref-menu"> | |
| 8 | + @if (Branches.Any()) | |
| 9 | + { | |
| 10 | + <p class="ref-menu-title">@T["Branches"]</p> | |
| 11 | + @foreach (var r in Branches) | |
| 12 | + { | |
| 13 | + <a class="@ItemClass(r, ResolvedKind.Branch)" href="@UrlFor(r.Name)">@r.Name</a> | |
| 14 | + } | |
| 15 | + } | |
| 16 | + @if (Tags.Any()) | |
| 17 | + { | |
| 18 | + <p class="ref-menu-title">@T["Tags"]</p> | |
| 19 | + @foreach (var r in Tags) | |
| 20 | + { | |
| 21 | + <a class="@ItemClass(r, ResolvedKind.Tag)" href="@UrlFor(r.Name)">@r.Name</a> | |
| 22 | + } | |
| 23 | + } | |
| 24 | + </div> | |
| 25 | +</details> | |
| 26 | + | |
| 27 | +@code { | |
| 28 | + [Parameter, EditorRequired] | |
| 29 | + public IReadOnlyList<GitRef> Refs { get; set; } = []; | |
| 30 | + | |
| 31 | + [Parameter, EditorRequired] | |
| 32 | + public string Current { get; set; } = ""; | |
| 33 | + | |
| 34 | + [Parameter] | |
| 35 | + public ResolvedKind CurrentKind { get; set; } | |
| 36 | + | |
| 37 | + /// <summary>Builds the URL of the current view for another ref name.</summary> | |
| 38 | + [Parameter, EditorRequired] | |
| 39 | + public Func<string, string> UrlFor { get; set; } = null!; | |
| 40 | + | |
| 41 | + private IEnumerable<GitRef> Branches => Refs.Where(r => r.Kind == RefKind.Branch); | |
| 42 | + private IEnumerable<GitRef> Tags => Refs.Where(r => r.Kind == RefKind.Tag); | |
| 43 | + | |
| 44 | + private string KindLabel => CurrentKind switch | |
| 45 | + { | |
| 46 | + ResolvedKind.Tag => T["tag"], | |
| 47 | + ResolvedKind.Commit => T["commit"], | |
| 48 | + _ => T["branch"], | |
| 49 | + }; | |
| 50 | + | |
| 51 | + private string ItemClass(GitRef r, ResolvedKind kind) => | |
| 52 | + kind == CurrentKind && r.Name == Current ? "ref-item active" : "ref-item"; | |
| 53 | +} |
added forge/Components/RepoHeader.razor +72 −0View file
| @@ -0,0 +1,72 @@ | ||
| 1 | +@inject IOptions<ForgeOptions> Options | |
| 2 | +@inject GitRepo Git | |
| 3 | +@inject RepoPaths Paths | |
| 4 | +@inject IServiceScopeFactory Scopes | |
| 5 | + | |
| 6 | +<div class="repo-head"> | |
| 7 | + <h1 class="repo-title"> | |
| 8 | + <Icon Name="@(IsPrivate ? "lock" : "book")" Size="20"/> | |
| 9 | + <a href="@Urls.User(Repository.Owner.Username)">@Repository.Owner.Username</a> | |
| 10 | + <span class="sep">/</span> | |
| 11 | + <a class="repo-name" href="@Urls.Repo(Repository)">@Repository.Name</a> | |
| 12 | + <span class="badge">@(IsPrivate ? T["private"] : T["public"])</span> | |
| 13 | + </h1> | |
| 14 | + @if (Repository.Description.Length > 0) | |
| 15 | + { | |
| 16 | + <p class="muted repo-description">@Repository.Description</p> | |
| 17 | + } | |
| 18 | + <div class="repo-bar"> | |
| 19 | + <nav class="tabs"> | |
| 20 | + <a class="@TabClass("code")" href="@Urls.Repo(Repository)"><Icon Name="code"/> @T["Code"]</a> | |
| 21 | + <a class="@TabClass("commits")" href="@Urls.Repo(Repository)/commits"><Icon Name="commit"/> @T["Commits"]</a> | |
| 22 | + <a class="@TabClass("branches")" href="@Urls.Branches(Repository)"> | |
| 23 | + <Icon Name="branch"/> @T["Branches"] <Counter Value="_branches"/> | |
| 24 | + </a> | |
| 25 | + <a class="@TabClass("tags")" href="@Urls.Tags(Repository)"> | |
| 26 | + <Icon Name="tag"/> @T["Tags"] <Counter Value="_tags"/> | |
| 27 | + </a> | |
| 28 | + <a class="@TabClass("pulls")" href="@Urls.Pulls(Repository)"> | |
| 29 | + <Icon Name="pull"/> @T["Pull requests"] <Counter Value="_openPulls"/> | |
| 30 | + </a> | |
| 31 | + <a class="@TabClass("activity")" href="@Urls.Activity(Repository)"><Icon Name="activity"/> @T["Activity"]</a> | |
| 32 | + @if (IsOwner) | |
| 33 | + { | |
| 34 | + <a class="@TabClass("settings")" href="@Urls.Settings(Repository)"><Icon Name="settings"/> @T["Settings"]</a> | |
| 35 | + } | |
| 36 | + </nav> | |
| 37 | + <CloneBox Url="@Urls.Clone(Options.Value, Repository)"/> | |
| 38 | + </div> | |
| 39 | +</div> | |
| 40 | + | |
| 41 | +@code { | |
| 42 | + [Parameter, EditorRequired] | |
| 43 | + public Repository Repository { get; set; } = null!; | |
| 44 | + | |
| 45 | + /// <summary>code, commits, branches, tags, pulls or settings.</summary> | |
| 46 | + [Parameter] | |
| 47 | + public string Active { get; set; } = ""; | |
| 48 | + | |
| 49 | + [Parameter] | |
| 50 | + public bool IsOwner { get; set; } | |
| 51 | + | |
| 52 | + private int _branches; | |
| 53 | + private int _tags; | |
| 54 | + private int _openPulls; | |
| 55 | + | |
| 56 | + private bool IsPrivate => Repository.Visibility == Visibility.Private; | |
| 57 | + | |
| 58 | + private string TabClass(string tab) => tab == Active ? "tab active" : "tab"; | |
| 59 | + | |
| 60 | + protected override async Task OnInitializedAsync() | |
| 61 | + { | |
| 62 | + var refs = await Git.ListRefsAsync(Paths.For(Repository.Id)); | |
| 63 | + _branches = refs.Count(r => r.Kind == RefKind.Branch); | |
| 64 | + _tags = refs.Count(r => r.Kind == RefKind.Tag); | |
| 65 | + | |
| 66 | + // A scope of its own: the page around this header may be using the request's DbContext right now. | |
| 67 | + await using var scope = Scopes.CreateAsyncScope(); | |
| 68 | + var repoId = Repository.Id; | |
| 69 | + _openPulls = await scope.ServiceProvider.GetRequiredService<ForgeDb>().PullRequests | |
| 70 | + .CountAsync(p => p.RepoId == repoId && p.Status == PullRequestStatus.Open); | |
| 71 | + } | |
| 72 | +} |
added forge/Components/RepoPageBase.cs +75 −0View file
| @@ -0,0 +1,75 @@ | ||
| 1 | +using Forge.Data; | |
| 2 | +using Forge.Features.Auth; | |
| 3 | +using Forge.Features.Repos; | |
| 4 | +using Forge.Git; | |
| 5 | +using Microsoft.AspNetCore.Components; | |
| 6 | + | |
| 7 | +namespace Forge.Components; | |
| 8 | + | |
| 9 | +/// <summary> | |
| 10 | +/// Base for every page under /{owner}/{repo}. Loads the repository and applies access rules in one | |
| 11 | +/// place: a repository the visitor may not read answers exactly like one that does not exist. | |
| 12 | +/// </summary> | |
| 13 | +public abstract class RepoPageBase : ComponentBase | |
| 14 | +{ | |
| 15 | + [Parameter] | |
| 16 | + public string Owner { get; set; } = ""; | |
| 17 | + | |
| 18 | + [Parameter] | |
| 19 | + public string Repo { get; set; } = ""; | |
| 20 | + | |
| 21 | + [Inject] | |
| 22 | + protected RepoService Repos { get; set; } = null!; | |
| 23 | + | |
| 24 | + [Inject] | |
| 25 | + protected RepoPaths Paths { get; set; } = null!; | |
| 26 | + | |
| 27 | + [Inject] | |
| 28 | + protected GitRepo Git { get; set; } = null!; | |
| 29 | + | |
| 30 | + [Inject] | |
| 31 | + protected RefResolver Resolver { get; set; } = null!; | |
| 32 | + | |
| 33 | + [Inject] | |
| 34 | + protected CurrentUser Me { get; set; } = null!; | |
| 35 | + | |
| 36 | + [Inject] | |
| 37 | + protected NavigationManager Nav { get; set; } = null!; | |
| 38 | + | |
| 39 | + /// <summary>Null until loaded, and null again when the page answered 404 or redirected. Markup must check it.</summary> | |
| 40 | + protected Repository? Repository { get; private set; } | |
| 41 | + | |
| 42 | + protected string RepoPath { get; private set; } = ""; | |
| 43 | + | |
| 44 | + protected bool IsOwner { get; private set; } | |
| 45 | + | |
| 46 | + /// <summary>Returns false after answering 404; the caller must stop.</summary> | |
| 47 | + protected async Task<bool> LoadRepoAsync(bool requireAdmin = false) | |
| 48 | + { | |
| 49 | + var repo = await Repos.FindAsync(Owner, Repo); | |
| 50 | + if (repo is null | |
| 51 | + || !RepoAccess.CanRead(repo, Me.Actor) | |
| 52 | + || (requireAdmin && !RepoAccess.CanAdmin(repo, Me.Actor))) | |
| 53 | + { | |
| 54 | + NotFound(); | |
| 55 | + return false; | |
| 56 | + } | |
| 57 | + | |
| 58 | + Repository = repo; | |
| 59 | + RepoPath = Paths.For(repo.Id); | |
| 60 | + IsOwner = RepoAccess.CanAdmin(repo, Me.Actor); | |
| 61 | + return true; | |
| 62 | + } | |
| 63 | + | |
| 64 | + protected void NotFound() | |
| 65 | + { | |
| 66 | + Repository = null; | |
| 67 | + Nav.NotFound(); | |
| 68 | + } | |
| 69 | + | |
| 70 | + protected void Redirect(string url) | |
| 71 | + { | |
| 72 | + Repository = null; | |
| 73 | + Nav.NavigateTo(url); | |
| 74 | + } | |
| 75 | +} |
added forge/Components/Routes.razor +5 −0View file
| @@ -0,0 +1,5 @@ | ||
| 1 | +<Router AppAssembly="typeof(Program).Assembly" NotFoundPage="typeof(NotFound)"> | |
| 2 | + <Found Context="routeData"> | |
| 3 | + <RouteView RouteData="routeData" DefaultLayout="typeof(MainLayout)"/> | |
| 4 | + </Found> | |
| 5 | +</Router> |
added forge/Components/StatusMessage.razor +27 −0View file
| @@ -0,0 +1,27 @@ | ||
| 1 | +<section class="status-page"> | |
| 2 | + <p class="status-code">@Code</p> | |
| 3 | + <h1>@Title</h1> | |
| 4 | + <p class="muted">@Detail</p> | |
| 5 | + <p class="status-action"><a class="button" href="/"><Icon Name="arrow-left"/> @T["Back to the repository list"]</a></p> | |
| 6 | +</section> | |
| 7 | + | |
| 8 | +@code { | |
| 9 | + [Parameter] | |
| 10 | + public int Code { get; set; } | |
| 11 | + | |
| 12 | + private string Title => Code switch | |
| 13 | + { | |
| 14 | + 404 => T["This page does not exist"], | |
| 15 | + 400 => T["The request could not be processed"], | |
| 16 | + 429 => T["Too many attempts"], | |
| 17 | + _ => T["Something went wrong"], | |
| 18 | + }; | |
| 19 | + | |
| 20 | + private string Detail => Code switch | |
| 21 | + { | |
| 22 | + 404 => T["The address is wrong, or you do not have access to this content."], | |
| 23 | + 400 => T["The form may have expired. Reload the page and try again."], | |
| 24 | + 429 => T["Wait a minute and try again."], | |
| 25 | + _ => T["Try again in a moment."], | |
| 26 | + }; | |
| 27 | +} |
added forge/Components/StatusPage.razor +11 −0View file
| @@ -0,0 +1,11 @@ | ||
| 1 | +@page "/status/{Code:int}" | |
| 2 | + | |
| 3 | +<PageTitle>@Code · Forge</PageTitle> | |
| 4 | + | |
| 5 | +<StatusMessage Code="Code"/> | |
| 6 | + | |
| 7 | +@code { | |
| 8 | + /// <summary>Target of UseStatusCodePagesWithReExecute: renders a page for a bare 4xx/5xx response.</summary> | |
| 9 | + [Parameter] | |
| 10 | + public int Code { get; set; } | |
| 11 | +} |
added forge/Components/TimeAgo.razor +8 −0View file
| @@ -0,0 +1,8 @@ | ||
| 1 | +@inject TimeProvider Clock | |
| 2 | + | |
| 3 | +<time datetime="@Format.IsoTime(Value)" title="@Format.ExactTime(Value)">@T.RelativeTime(Value, Clock.GetUtcNow())</time> | |
| 4 | + | |
| 5 | +@code { | |
| 6 | + [Parameter, EditorRequired] | |
| 7 | + public DateTimeOffset Value { get; set; } | |
| 8 | +} |
added forge/Data/Entities.cs +154 −0View file
| @@ -0,0 +1,154 @@ | ||
| 1 | +namespace Forge.Data; | |
| 2 | + | |
| 3 | +public enum Visibility | |
| 4 | +{ | |
| 5 | + Private = 0, | |
| 6 | + Public = 1, | |
| 7 | +} | |
| 8 | + | |
| 9 | +public sealed class User | |
| 10 | +{ | |
| 11 | + public long Id { get; set; } | |
| 12 | + public required string Username { get; set; } | |
| 13 | + public required string DisplayName { get; set; } | |
| 14 | + public string PasswordHash { get; set; } = ""; | |
| 15 | + public DateTime CreatedAt { get; set; } | |
| 16 | +} | |
| 17 | + | |
| 18 | +public sealed class Repository | |
| 19 | +{ | |
| 20 | + public long Id { get; set; } | |
| 21 | + public long OwnerId { get; set; } | |
| 22 | + public User Owner { get; set; } = null!; | |
| 23 | + public required string Name { get; set; } | |
| 24 | + public string Description { get; set; } = ""; | |
| 25 | + public Visibility Visibility { get; set; } | |
| 26 | + public string DefaultBranch { get; set; } = "main"; | |
| 27 | + public DateTime CreatedAt { get; set; } | |
| 28 | + public DateTime? PushedAt { get; set; } | |
| 29 | +} | |
| 30 | + | |
| 31 | +public sealed class AccessToken | |
| 32 | +{ | |
| 33 | + public long Id { get; set; } | |
| 34 | + public long UserId { get; set; } | |
| 35 | + public User User { get; set; } = null!; | |
| 36 | + public required string Name { get; set; } | |
| 37 | + | |
| 38 | + /// <summary>Lower-case hex SHA-256 of the token. The token itself is never stored.</summary> | |
| 39 | + public required string TokenHash { get; set; } | |
| 40 | + | |
| 41 | + public bool CanWrite { get; set; } | |
| 42 | + public DateTime CreatedAt { get; set; } | |
| 43 | + public DateTime? LastUsedAt { get; set; } | |
| 44 | + public DateTime? ExpiresAt { get; set; } | |
| 45 | +} | |
| 46 | + | |
| 47 | +public sealed class PushEvent | |
| 48 | +{ | |
| 49 | + public long Id { get; set; } | |
| 50 | + public long RepoId { get; set; } | |
| 51 | + public Repository Repo { get; set; } = null!; | |
| 52 | + public required string RefName { get; set; } | |
| 53 | + public required string OldSha { get; set; } | |
| 54 | + public required string NewSha { get; set; } | |
| 55 | + public DateTime PushedAt { get; set; } | |
| 56 | +} | |
| 57 | + | |
| 58 | +public sealed class Webhook | |
| 59 | +{ | |
| 60 | + public long Id { get; set; } | |
| 61 | + public long RepoId { get; set; } | |
| 62 | + public Repository Repo { get; set; } = null!; | |
| 63 | + public required string Url { get; set; } | |
| 64 | + public required string Secret { get; set; } | |
| 65 | + public bool Active { get; set; } = true; | |
| 66 | + public DateTime CreatedAt { get; set; } | |
| 67 | +} | |
| 68 | + | |
| 69 | +public sealed class WebhookDelivery | |
| 70 | +{ | |
| 71 | + public long Id { get; set; } | |
| 72 | + public long WebhookId { get; set; } | |
| 73 | + public Webhook Webhook { get; set; } = null!; | |
| 74 | + | |
| 75 | + /// <summary>Null for test pings, which have no push behind them.</summary> | |
| 76 | + public long? PushEventId { get; set; } | |
| 77 | + | |
| 78 | + public PushEvent? PushEvent { get; set; } | |
| 79 | + public int? StatusCode { get; set; } | |
| 80 | + public int DurationMs { get; set; } | |
| 81 | + public string? Error { get; set; } | |
| 82 | + public int Attempt { get; set; } | |
| 83 | + public DateTime DeliveredAt { get; set; } | |
| 84 | + | |
| 85 | + public bool Succeeded => StatusCode is >= 200 and < 300; | |
| 86 | +} | |
| 87 | + | |
| 88 | +public enum PullRequestStatus | |
| 89 | +{ | |
| 90 | + Open = 0, | |
| 91 | + Merged = 1, | |
| 92 | + Closed = 2, | |
| 93 | +} | |
| 94 | + | |
| 95 | +/// <summary>A saved proposal to merge one branch of a repository into another.</summary> | |
| 96 | +public sealed class PullRequest | |
| 97 | +{ | |
| 98 | + public long Id { get; set; } | |
| 99 | + public long RepoId { get; set; } | |
| 100 | + public Repository Repo { get; set; } = null!; | |
| 101 | + | |
| 102 | + /// <summary>Counts from 1 within a repository; this is the number in the URL.</summary> | |
| 103 | + public int Number { get; set; } | |
| 104 | + | |
| 105 | + public required string Title { get; set; } | |
| 106 | + public string Description { get; set; } = ""; | |
| 107 | + public required string BaseBranch { get; set; } | |
| 108 | + public required string HeadBranch { get; set; } | |
| 109 | + public PullRequestStatus Status { get; set; } | |
| 110 | + public long AuthorId { get; set; } | |
| 111 | + public User Author { get; set; } = null!; | |
| 112 | + public DateTime CreatedAt { get; set; } | |
| 113 | + public DateTime UpdatedAt { get; set; } | |
| 114 | + public DateTime? ClosedAt { get; set; } | |
| 115 | + | |
| 116 | + /// <summary>The commit the base branch pointed at right after the merge.</summary> | |
| 117 | + public string? MergeCommitSha { get; set; } | |
| 118 | + | |
| 119 | + /// <summary> | |
| 120 | + /// Frozen when the pull request is merged or closed: where the branches diverged and the head's tip. | |
| 121 | + /// The page keeps showing the same commits and diff after the branches move on or are deleted. | |
| 122 | + /// </summary> | |
| 123 | + public string? BaseSha { get; set; } | |
| 124 | + | |
| 125 | + public string? HeadSha { get; set; } | |
| 126 | +} | |
| 127 | + | |
| 128 | +public sealed class PullRequestComment | |
| 129 | +{ | |
| 130 | + public long Id { get; set; } | |
| 131 | + public long PullRequestId { get; set; } | |
| 132 | + public PullRequest PullRequest { get; set; } = null!; | |
| 133 | + public long AuthorId { get; set; } | |
| 134 | + public User Author { get; set; } = null!; | |
| 135 | + public required string Body { get; set; } | |
| 136 | + public DateTime CreatedAt { get; set; } | |
| 137 | +} | |
| 138 | + | |
| 139 | +/// <summary> | |
| 140 | +/// Protects branches from force-pushes and deletion. <see cref="Pattern"/> is a branch name, | |
| 141 | +/// or a prefix ending in "/*" (release/*) covering every branch below it. | |
| 142 | +/// </summary> | |
| 143 | +public sealed class BranchProtection | |
| 144 | +{ | |
| 145 | + public long Id { get; set; } | |
| 146 | + public long RepoId { get; set; } | |
| 147 | + public Repository Repo { get; set; } = null!; | |
| 148 | + public required string Pattern { get; set; } | |
| 149 | + | |
| 150 | + /// <summary>Also refuse ordinary pushes: the branch then only changes through merges made in the web UI.</summary> | |
| 151 | + public bool BlockPush { get; set; } | |
| 152 | + | |
| 153 | + public DateTime CreatedAt { get; set; } | |
| 154 | +} |
added forge/Data/ForgeDb.cs +158 −0View file
| @@ -0,0 +1,158 @@ | ||
| 1 | +using System.Data.Common; | |
| 2 | +using System.Text.RegularExpressions; | |
| 3 | +using Microsoft.EntityFrameworkCore; | |
| 4 | +using Microsoft.EntityFrameworkCore.Design; | |
| 5 | +using Microsoft.EntityFrameworkCore.Diagnostics; | |
| 6 | +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; | |
| 7 | + | |
| 8 | +namespace Forge.Data; | |
| 9 | + | |
| 10 | +public sealed partial class ForgeDb(DbContextOptions<ForgeDb> options) : DbContext(options) | |
| 11 | +{ | |
| 12 | + public DbSet<User> Users => Set<User>(); | |
| 13 | + public DbSet<Repository> Repositories => Set<Repository>(); | |
| 14 | + public DbSet<AccessToken> AccessTokens => Set<AccessToken>(); | |
| 15 | + public DbSet<PushEvent> PushEvents => Set<PushEvent>(); | |
| 16 | + public DbSet<Webhook> Webhooks => Set<Webhook>(); | |
| 17 | + public DbSet<WebhookDelivery> WebhookDeliveries => Set<WebhookDelivery>(); | |
| 18 | + public DbSet<PullRequest> PullRequests => Set<PullRequest>(); | |
| 19 | + public DbSet<PullRequestComment> PullRequestComments => Set<PullRequestComment>(); | |
| 20 | + public DbSet<BranchProtection> BranchProtections => Set<BranchProtection>(); | |
| 21 | + | |
| 22 | + public static void Configure(DbContextOptionsBuilder builder, string databasePath) => | |
| 23 | + builder | |
| 24 | + .UseSqlite($"Data Source={databasePath}") | |
| 25 | + .AddInterceptors(SqlitePragmaInterceptor.Instance); | |
| 26 | + | |
| 27 | + protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder) | |
| 28 | + { | |
| 29 | + // SQLite has no date type: store UTC and hand UTC back. | |
| 30 | + configurationBuilder.Properties<DateTime>().HaveConversion<UtcDateTimeConverter>(); | |
| 31 | + } | |
| 32 | + | |
| 33 | + protected override void OnModelCreating(ModelBuilder b) | |
| 34 | + { | |
| 35 | + b.Entity<User>(e => | |
| 36 | + { | |
| 37 | + e.ToTable("users"); | |
| 38 | + e.Property(u => u.Username).UseCollation("NOCASE"); | |
| 39 | + e.HasIndex(u => u.Username).IsUnique(); | |
| 40 | + }); | |
| 41 | + | |
| 42 | + b.Entity<Repository>(e => | |
| 43 | + { | |
| 44 | + e.ToTable("repositories"); | |
| 45 | + e.Property(r => r.Name).UseCollation("NOCASE"); | |
| 46 | + e.Property(r => r.Visibility).HasConversion<string>(); | |
| 47 | + e.HasOne(r => r.Owner).WithMany().HasForeignKey(r => r.OwnerId).OnDelete(DeleteBehavior.Cascade); | |
| 48 | + e.HasIndex(r => new { r.OwnerId, r.Name }).IsUnique(); | |
| 49 | + }); | |
| 50 | + | |
| 51 | + b.Entity<AccessToken>(e => | |
| 52 | + { | |
| 53 | + e.ToTable("access_tokens"); | |
| 54 | + e.HasOne(t => t.User).WithMany().HasForeignKey(t => t.UserId).OnDelete(DeleteBehavior.Cascade); | |
| 55 | + e.HasIndex(t => t.TokenHash).IsUnique(); | |
| 56 | + }); | |
| 57 | + | |
| 58 | + b.Entity<PushEvent>(e => | |
| 59 | + { | |
| 60 | + e.ToTable("push_events"); | |
| 61 | + e.HasOne(p => p.Repo).WithMany().HasForeignKey(p => p.RepoId).OnDelete(DeleteBehavior.Cascade); | |
| 62 | + e.HasIndex(p => new { p.RepoId, p.PushedAt }); | |
| 63 | + }); | |
| 64 | + | |
| 65 | + b.Entity<Webhook>(e => | |
| 66 | + { | |
| 67 | + e.ToTable("webhooks"); | |
| 68 | + e.HasOne(w => w.Repo).WithMany().HasForeignKey(w => w.RepoId).OnDelete(DeleteBehavior.Cascade); | |
| 69 | + }); | |
| 70 | + | |
| 71 | + b.Entity<WebhookDelivery>(e => | |
| 72 | + { | |
| 73 | + e.ToTable("webhook_deliveries"); | |
| 74 | + e.Ignore(d => d.Succeeded); | |
| 75 | + e.HasOne(d => d.Webhook).WithMany().HasForeignKey(d => d.WebhookId).OnDelete(DeleteBehavior.Cascade); | |
| 76 | + e.HasOne(d => d.PushEvent).WithMany().HasForeignKey(d => d.PushEventId).OnDelete(DeleteBehavior.Cascade); | |
| 77 | + e.HasIndex(d => new { d.WebhookId, d.PushEventId }); | |
| 78 | + }); | |
| 79 | + | |
| 80 | + b.Entity<PullRequest>(e => | |
| 81 | + { | |
| 82 | + e.ToTable("pull_requests"); | |
| 83 | + e.Property(p => p.Status).HasConversion<string>(); | |
| 84 | + e.HasOne(p => p.Repo).WithMany().HasForeignKey(p => p.RepoId).OnDelete(DeleteBehavior.Cascade); | |
| 85 | + e.HasOne(p => p.Author).WithMany().HasForeignKey(p => p.AuthorId).OnDelete(DeleteBehavior.Cascade); | |
| 86 | + e.HasIndex(p => new { p.RepoId, p.Number }).IsUnique(); | |
| 87 | + }); | |
| 88 | + | |
| 89 | + b.Entity<PullRequestComment>(e => | |
| 90 | + { | |
| 91 | + e.ToTable("pull_request_comments"); | |
| 92 | + e.HasOne(c => c.PullRequest).WithMany().HasForeignKey(c => c.PullRequestId).OnDelete(DeleteBehavior.Cascade); | |
| 93 | + e.HasOne(c => c.Author).WithMany().HasForeignKey(c => c.AuthorId).OnDelete(DeleteBehavior.Cascade); | |
| 94 | + }); | |
| 95 | + | |
| 96 | + b.Entity<BranchProtection>(e => | |
| 97 | + { | |
| 98 | + e.ToTable("branch_protections"); | |
| 99 | + e.HasOne(p => p.Repo).WithMany().HasForeignKey(p => p.RepoId).OnDelete(DeleteBehavior.Cascade); | |
| 100 | + e.HasIndex(p => new { p.RepoId, p.Pattern }).IsUnique(); | |
| 101 | + }); | |
| 102 | + | |
| 103 | + foreach (var entity in b.Model.GetEntityTypes()) | |
| 104 | + { | |
| 105 | + foreach (var property in entity.GetProperties()) | |
| 106 | + { | |
| 107 | + property.SetColumnName(SnakeCase(property.Name)); | |
| 108 | + } | |
| 109 | + } | |
| 110 | + } | |
| 111 | + | |
| 112 | + internal static string SnakeCase(string name) => | |
| 113 | + UpperAfterLower().Replace(name, "_$1").ToLowerInvariant(); | |
| 114 | + | |
| 115 | + [GeneratedRegex("(?<=[a-z0-9])([A-Z])")] | |
| 116 | + private static partial Regex UpperAfterLower(); | |
| 117 | +} | |
| 118 | + | |
| 119 | +public sealed class UtcDateTimeConverter() : ValueConverter<DateTime, DateTime>( | |
| 120 | + v => v.Kind == DateTimeKind.Local ? v.ToUniversalTime() : v, | |
| 121 | + v => DateTime.SpecifyKind(v, DateTimeKind.Utc)); | |
| 122 | + | |
| 123 | +/// <summary>Applies the per-connection SQLite settings every time a connection is opened.</summary> | |
| 124 | +public sealed class SqlitePragmaInterceptor : DbConnectionInterceptor | |
| 125 | +{ | |
| 126 | + public static readonly SqlitePragmaInterceptor Instance = new(); | |
| 127 | + | |
| 128 | + private const string Pragmas = | |
| 129 | + "PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;"; | |
| 130 | + | |
| 131 | + public override void ConnectionOpened(DbConnection connection, ConnectionEndEventData eventData) | |
| 132 | + { | |
| 133 | + using var command = connection.CreateCommand(); | |
| 134 | + command.CommandText = Pragmas; | |
| 135 | + command.ExecuteNonQuery(); | |
| 136 | + } | |
| 137 | + | |
| 138 | + public override async Task ConnectionOpenedAsync( | |
| 139 | + DbConnection connection, | |
| 140 | + ConnectionEndEventData eventData, | |
| 141 | + CancellationToken cancellationToken = default) | |
| 142 | + { | |
| 143 | + await using var command = connection.CreateCommand(); | |
| 144 | + command.CommandText = Pragmas; | |
| 145 | + await command.ExecuteNonQueryAsync(cancellationToken); | |
| 146 | + } | |
| 147 | +} | |
| 148 | + | |
| 149 | +/// <summary>Lets `dotnet ef` build the context without starting the web app.</summary> | |
| 150 | +public sealed class ForgeDbDesignFactory : IDesignTimeDbContextFactory<ForgeDb> | |
| 151 | +{ | |
| 152 | + public ForgeDb CreateDbContext(string[] args) | |
| 153 | + { | |
| 154 | + var builder = new DbContextOptionsBuilder<ForgeDb>(); | |
| 155 | + ForgeDb.Configure(builder, "design-time.db"); | |
| 156 | + return new ForgeDb(builder.Options); | |
| 157 | + } | |
| 158 | +} |
added forge/Data/Migrations/20261115000224_Initial.Designer.cs +333 −0View file
| @@ -0,0 +1,333 @@ | ||
| 1 | +// <auto-generated /> | |
| 2 | +using System; | |
| 3 | +using Forge.Data; | |
| 4 | +using Microsoft.EntityFrameworkCore; | |
| 5 | +using Microsoft.EntityFrameworkCore.Infrastructure; | |
| 6 | +using Microsoft.EntityFrameworkCore.Migrations; | |
| 7 | +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; | |
| 8 | + | |
| 9 | +#nullable disable | |
| 10 | + | |
| 11 | +namespace Forge.Data.Migrations; | |
| 12 | + | |
| 13 | +[DbContext(typeof(ForgeDb))] | |
| 14 | +[Migration("20261115000224_Initial")] | |
| 15 | +partial class _20261115000224_Initial | |
| 16 | +{ | |
| 17 | + /// <inheritdoc /> | |
| 18 | + protected override void BuildTargetModel(ModelBuilder modelBuilder) | |
| 19 | + { | |
| 20 | +#pragma warning disable 612, 618 | |
| 21 | + modelBuilder.HasAnnotation("ProductVersion", "11.0.0"); | |
| 22 | + | |
| 23 | + modelBuilder.Entity("Forge.Data.AccessToken", b => | |
| 24 | + { | |
| 25 | + b.Property<long>("Id") | |
| 26 | + .ValueGeneratedOnAdd() | |
| 27 | + .HasColumnType("INTEGER") | |
| 28 | + .HasColumnName("id"); | |
| 29 | + | |
| 30 | + b.Property<bool>("CanWrite") | |
| 31 | + .HasColumnType("INTEGER") | |
| 32 | + .HasColumnName("can_write"); | |
| 33 | + | |
| 34 | + b.Property<DateTime>("CreatedAt") | |
| 35 | + .HasColumnType("TEXT") | |
| 36 | + .HasColumnName("created_at"); | |
| 37 | + | |
| 38 | + b.Property<DateTime?>("ExpiresAt") | |
| 39 | + .HasColumnType("TEXT") | |
| 40 | + .HasColumnName("expires_at"); | |
| 41 | + | |
| 42 | + b.Property<DateTime?>("LastUsedAt") | |
| 43 | + .HasColumnType("TEXT") | |
| 44 | + .HasColumnName("last_used_at"); | |
| 45 | + | |
| 46 | + b.Property<string>("Name") | |
| 47 | + .IsRequired() | |
| 48 | + .HasColumnType("TEXT") | |
| 49 | + .HasColumnName("name"); | |
| 50 | + | |
| 51 | + b.Property<string>("TokenHash") | |
| 52 | + .IsRequired() | |
| 53 | + .HasColumnType("TEXT") | |
| 54 | + .HasColumnName("token_hash"); | |
| 55 | + | |
| 56 | + b.Property<long>("UserId") | |
| 57 | + .HasColumnType("INTEGER") | |
| 58 | + .HasColumnName("user_id"); | |
| 59 | + | |
| 60 | + b.HasKey("Id"); | |
| 61 | + | |
| 62 | + b.HasIndex("TokenHash") | |
| 63 | + .IsUnique(); | |
| 64 | + | |
| 65 | + b.HasIndex("UserId"); | |
| 66 | + | |
| 67 | + b.ToTable("access_tokens"); | |
| 68 | + }); | |
| 69 | + | |
| 70 | + modelBuilder.Entity("Forge.Data.PushEvent", b => | |
| 71 | + { | |
| 72 | + b.Property<long>("Id") | |
| 73 | + .ValueGeneratedOnAdd() | |
| 74 | + .HasColumnType("INTEGER") | |
| 75 | + .HasColumnName("id"); | |
| 76 | + | |
| 77 | + b.Property<string>("NewSha") | |
| 78 | + .IsRequired() | |
| 79 | + .HasColumnType("TEXT") | |
| 80 | + .HasColumnName("new_sha"); | |
| 81 | + | |
| 82 | + b.Property<string>("OldSha") | |
| 83 | + .IsRequired() | |
| 84 | + .HasColumnType("TEXT") | |
| 85 | + .HasColumnName("old_sha"); | |
| 86 | + | |
| 87 | + b.Property<DateTime>("PushedAt") | |
| 88 | + .HasColumnType("TEXT") | |
| 89 | + .HasColumnName("pushed_at"); | |
| 90 | + | |
| 91 | + b.Property<string>("RefName") | |
| 92 | + .IsRequired() | |
| 93 | + .HasColumnType("TEXT") | |
| 94 | + .HasColumnName("ref_name"); | |
| 95 | + | |
| 96 | + b.Property<long>("RepoId") | |
| 97 | + .HasColumnType("INTEGER") | |
| 98 | + .HasColumnName("repo_id"); | |
| 99 | + | |
| 100 | + b.HasKey("Id"); | |
| 101 | + | |
| 102 | + b.HasIndex("RepoId", "PushedAt"); | |
| 103 | + | |
| 104 | + b.ToTable("push_events"); | |
| 105 | + }); | |
| 106 | + | |
| 107 | + modelBuilder.Entity("Forge.Data.Repository", b => | |
| 108 | + { | |
| 109 | + b.Property<long>("Id") | |
| 110 | + .ValueGeneratedOnAdd() | |
| 111 | + .HasColumnType("INTEGER") | |
| 112 | + .HasColumnName("id"); | |
| 113 | + | |
| 114 | + b.Property<DateTime>("CreatedAt") | |
| 115 | + .HasColumnType("TEXT") | |
| 116 | + .HasColumnName("created_at"); | |
| 117 | + | |
| 118 | + b.Property<string>("DefaultBranch") | |
| 119 | + .IsRequired() | |
| 120 | + .HasColumnType("TEXT") | |
| 121 | + .HasColumnName("default_branch"); | |
| 122 | + | |
| 123 | + b.Property<string>("Description") | |
| 124 | + .IsRequired() | |
| 125 | + .HasColumnType("TEXT") | |
| 126 | + .HasColumnName("description"); | |
| 127 | + | |
| 128 | + b.Property<string>("Name") | |
| 129 | + .IsRequired() | |
| 130 | + .HasColumnType("TEXT") | |
| 131 | + .HasColumnName("name") | |
| 132 | + .UseCollation("NOCASE"); | |
| 133 | + | |
| 134 | + b.Property<long>("OwnerId") | |
| 135 | + .HasColumnType("INTEGER") | |
| 136 | + .HasColumnName("owner_id"); | |
| 137 | + | |
| 138 | + b.Property<DateTime?>("PushedAt") | |
| 139 | + .HasColumnType("TEXT") | |
| 140 | + .HasColumnName("pushed_at"); | |
| 141 | + | |
| 142 | + b.Property<string>("Visibility") | |
| 143 | + .IsRequired() | |
| 144 | + .HasColumnType("TEXT") | |
| 145 | + .HasColumnName("visibility"); | |
| 146 | + | |
| 147 | + b.HasKey("Id"); | |
| 148 | + | |
| 149 | + b.HasIndex("OwnerId", "Name") | |
| 150 | + .IsUnique(); | |
| 151 | + | |
| 152 | + b.ToTable("repositories"); | |
| 153 | + }); | |
| 154 | + | |
| 155 | + modelBuilder.Entity("Forge.Data.User", b => | |
| 156 | + { | |
| 157 | + b.Property<long>("Id") | |
| 158 | + .ValueGeneratedOnAdd() | |
| 159 | + .HasColumnType("INTEGER") | |
| 160 | + .HasColumnName("id"); | |
| 161 | + | |
| 162 | + b.Property<DateTime>("CreatedAt") | |
| 163 | + .HasColumnType("TEXT") | |
| 164 | + .HasColumnName("created_at"); | |
| 165 | + | |
| 166 | + b.Property<string>("DisplayName") | |
| 167 | + .IsRequired() | |
| 168 | + .HasColumnType("TEXT") | |
| 169 | + .HasColumnName("display_name"); | |
| 170 | + | |
| 171 | + b.Property<string>("PasswordHash") | |
| 172 | + .IsRequired() | |
| 173 | + .HasColumnType("TEXT") | |
| 174 | + .HasColumnName("password_hash"); | |
| 175 | + | |
| 176 | + b.Property<string>("Username") | |
| 177 | + .IsRequired() | |
| 178 | + .HasColumnType("TEXT") | |
| 179 | + .HasColumnName("username") | |
| 180 | + .UseCollation("NOCASE"); | |
| 181 | + | |
| 182 | + b.HasKey("Id"); | |
| 183 | + | |
| 184 | + b.HasIndex("Username") | |
| 185 | + .IsUnique(); | |
| 186 | + | |
| 187 | + b.ToTable("users"); | |
| 188 | + }); | |
| 189 | + | |
| 190 | + modelBuilder.Entity("Forge.Data.Webhook", b => | |
| 191 | + { | |
| 192 | + b.Property<long>("Id") | |
| 193 | + .ValueGeneratedOnAdd() | |
| 194 | + .HasColumnType("INTEGER") | |
| 195 | + .HasColumnName("id"); | |
| 196 | + | |
| 197 | + b.Property<bool>("Active") | |
| 198 | + .HasColumnType("INTEGER") | |
| 199 | + .HasColumnName("active"); | |
| 200 | + | |
| 201 | + b.Property<DateTime>("CreatedAt") | |
| 202 | + .HasColumnType("TEXT") | |
| 203 | + .HasColumnName("created_at"); | |
| 204 | + | |
| 205 | + b.Property<long>("RepoId") | |
| 206 | + .HasColumnType("INTEGER") | |
| 207 | + .HasColumnName("repo_id"); | |
| 208 | + | |
| 209 | + b.Property<string>("Secret") | |
| 210 | + .IsRequired() | |
| 211 | + .HasColumnType("TEXT") | |
| 212 | + .HasColumnName("secret"); | |
| 213 | + | |
| 214 | + b.Property<string>("Url") | |
| 215 | + .IsRequired() | |
| 216 | + .HasColumnType("TEXT") | |
| 217 | + .HasColumnName("url"); | |
| 218 | + | |
| 219 | + b.HasKey("Id"); | |
| 220 | + | |
| 221 | + b.HasIndex("RepoId"); | |
| 222 | + | |
| 223 | + b.ToTable("webhooks"); | |
| 224 | + }); | |
| 225 | + | |
| 226 | + modelBuilder.Entity("Forge.Data.WebhookDelivery", b => | |
| 227 | + { | |
| 228 | + b.Property<long>("Id") | |
| 229 | + .ValueGeneratedOnAdd() | |
| 230 | + .HasColumnType("INTEGER") | |
| 231 | + .HasColumnName("id"); | |
| 232 | + | |
| 233 | + b.Property<int>("Attempt") | |
| 234 | + .HasColumnType("INTEGER") | |
| 235 | + .HasColumnName("attempt"); | |
| 236 | + | |
| 237 | + b.Property<DateTime>("DeliveredAt") | |
| 238 | + .HasColumnType("TEXT") | |
| 239 | + .HasColumnName("delivered_at"); | |
| 240 | + | |
| 241 | + b.Property<int>("DurationMs") | |
| 242 | + .HasColumnType("INTEGER") | |
| 243 | + .HasColumnName("duration_ms"); | |
| 244 | + | |
| 245 | + b.Property<string>("Error") | |
| 246 | + .HasColumnType("TEXT") | |
| 247 | + .HasColumnName("error"); | |
| 248 | + | |
| 249 | + b.Property<long?>("PushEventId") | |
| 250 | + .HasColumnType("INTEGER") | |
| 251 | + .HasColumnName("push_event_id"); | |
| 252 | + | |
| 253 | + b.Property<int?>("StatusCode") | |
| 254 | + .HasColumnType("INTEGER") | |
| 255 | + .HasColumnName("status_code"); | |
| 256 | + | |
| 257 | + b.Property<long>("WebhookId") | |
| 258 | + .HasColumnType("INTEGER") | |
| 259 | + .HasColumnName("webhook_id"); | |
| 260 | + | |
| 261 | + b.HasKey("Id"); | |
| 262 | + | |
| 263 | + b.HasIndex("PushEventId"); | |
| 264 | + | |
| 265 | + b.HasIndex("WebhookId", "PushEventId"); | |
| 266 | + | |
| 267 | + b.ToTable("webhook_deliveries"); | |
| 268 | + }); | |
| 269 | + | |
| 270 | + modelBuilder.Entity("Forge.Data.AccessToken", b => | |
| 271 | + { | |
| 272 | + b.HasOne("Forge.Data.User", "User") | |
| 273 | + .WithMany() | |
| 274 | + .HasForeignKey("UserId") | |
| 275 | + .OnDelete(DeleteBehavior.Cascade) | |
| 276 | + .IsRequired(); | |
| 277 | + | |
| 278 | + b.Navigation("User"); | |
| 279 | + }); | |
| 280 | + | |
| 281 | + modelBuilder.Entity("Forge.Data.PushEvent", b => | |
| 282 | + { | |
| 283 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 284 | + .WithMany() | |
| 285 | + .HasForeignKey("RepoId") | |
| 286 | + .OnDelete(DeleteBehavior.Cascade) | |
| 287 | + .IsRequired(); | |
| 288 | + | |
| 289 | + b.Navigation("Repo"); | |
| 290 | + }); | |
| 291 | + | |
| 292 | + modelBuilder.Entity("Forge.Data.Repository", b => | |
| 293 | + { | |
| 294 | + b.HasOne("Forge.Data.User", "Owner") | |
| 295 | + .WithMany() | |
| 296 | + .HasForeignKey("OwnerId") | |
| 297 | + .OnDelete(DeleteBehavior.Cascade) | |
| 298 | + .IsRequired(); | |
| 299 | + | |
| 300 | + b.Navigation("Owner"); | |
| 301 | + }); | |
| 302 | + | |
| 303 | + modelBuilder.Entity("Forge.Data.Webhook", b => | |
| 304 | + { | |
| 305 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 306 | + .WithMany() | |
| 307 | + .HasForeignKey("RepoId") | |
| 308 | + .OnDelete(DeleteBehavior.Cascade) | |
| 309 | + .IsRequired(); | |
| 310 | + | |
| 311 | + b.Navigation("Repo"); | |
| 312 | + }); | |
| 313 | + | |
| 314 | + modelBuilder.Entity("Forge.Data.WebhookDelivery", b => | |
| 315 | + { | |
| 316 | + b.HasOne("Forge.Data.PushEvent", "PushEvent") | |
| 317 | + .WithMany() | |
| 318 | + .HasForeignKey("PushEventId") | |
| 319 | + .OnDelete(DeleteBehavior.Cascade); | |
| 320 | + | |
| 321 | + b.HasOne("Forge.Data.Webhook", "Webhook") | |
| 322 | + .WithMany() | |
| 323 | + .HasForeignKey("WebhookId") | |
| 324 | + .OnDelete(DeleteBehavior.Cascade) | |
| 325 | + .IsRequired(); | |
| 326 | + | |
| 327 | + b.Navigation("PushEvent"); | |
| 328 | + | |
| 329 | + b.Navigation("Webhook"); | |
| 330 | + }); | |
| 331 | +#pragma warning restore 612, 618 | |
| 332 | + } | |
| 333 | +} |
added forge/Data/Migrations/20261115000224_Initial.cs +222 −0View file
| @@ -0,0 +1,222 @@ | ||
| 1 | +using System; | |
| 2 | +using Microsoft.EntityFrameworkCore.Migrations; | |
| 3 | + | |
| 4 | +#nullable disable | |
| 5 | + | |
| 6 | +namespace Forge.Data.Migrations; | |
| 7 | + | |
| 8 | +/// <inheritdoc /> | |
| 9 | +public partial class _20261115000224_Initial : Migration | |
| 10 | +{ | |
| 11 | + /// <inheritdoc /> | |
| 12 | + protected override void Up(MigrationBuilder migrationBuilder) | |
| 13 | + { | |
| 14 | + migrationBuilder.CreateTable( | |
| 15 | + name: "users", | |
| 16 | + columns: table => new | |
| 17 | + { | |
| 18 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 19 | + .Annotation("Sqlite:Autoincrement", true), | |
| 20 | + username = table.Column<string>(type: "TEXT", nullable: false, collation: "NOCASE"), | |
| 21 | + display_name = table.Column<string>(type: "TEXT", nullable: false), | |
| 22 | + password_hash = table.Column<string>(type: "TEXT", nullable: false), | |
| 23 | + created_at = table.Column<DateTime>(type: "TEXT", nullable: false) | |
| 24 | + }, | |
| 25 | + constraints: table => | |
| 26 | + { | |
| 27 | + table.PrimaryKey("PK_users", x => x.id); | |
| 28 | + }); | |
| 29 | + | |
| 30 | + migrationBuilder.CreateTable( | |
| 31 | + name: "access_tokens", | |
| 32 | + columns: table => new | |
| 33 | + { | |
| 34 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 35 | + .Annotation("Sqlite:Autoincrement", true), | |
| 36 | + user_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 37 | + name = table.Column<string>(type: "TEXT", nullable: false), | |
| 38 | + token_hash = table.Column<string>(type: "TEXT", nullable: false), | |
| 39 | + can_write = table.Column<bool>(type: "INTEGER", nullable: false), | |
| 40 | + created_at = table.Column<DateTime>(type: "TEXT", nullable: false), | |
| 41 | + last_used_at = table.Column<DateTime>(type: "TEXT", nullable: true), | |
| 42 | + expires_at = table.Column<DateTime>(type: "TEXT", nullable: true) | |
| 43 | + }, | |
| 44 | + constraints: table => | |
| 45 | + { | |
| 46 | + table.PrimaryKey("PK_access_tokens", x => x.id); | |
| 47 | + table.ForeignKey( | |
| 48 | + name: "FK_access_tokens_users_user_id", | |
| 49 | + column: x => x.user_id, | |
| 50 | + principalTable: "users", | |
| 51 | + principalColumn: "id", | |
| 52 | + onDelete: ReferentialAction.Cascade); | |
| 53 | + }); | |
| 54 | + | |
| 55 | + migrationBuilder.CreateTable( | |
| 56 | + name: "repositories", | |
| 57 | + columns: table => new | |
| 58 | + { | |
| 59 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 60 | + .Annotation("Sqlite:Autoincrement", true), | |
| 61 | + owner_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 62 | + name = table.Column<string>(type: "TEXT", nullable: false, collation: "NOCASE"), | |
| 63 | + description = table.Column<string>(type: "TEXT", nullable: false), | |
| 64 | + visibility = table.Column<string>(type: "TEXT", nullable: false), | |
| 65 | + default_branch = table.Column<string>(type: "TEXT", nullable: false), | |
| 66 | + created_at = table.Column<DateTime>(type: "TEXT", nullable: false), | |
| 67 | + pushed_at = table.Column<DateTime>(type: "TEXT", nullable: true) | |
| 68 | + }, | |
| 69 | + constraints: table => | |
| 70 | + { | |
| 71 | + table.PrimaryKey("PK_repositories", x => x.id); | |
| 72 | + table.ForeignKey( | |
| 73 | + name: "FK_repositories_users_owner_id", | |
| 74 | + column: x => x.owner_id, | |
| 75 | + principalTable: "users", | |
| 76 | + principalColumn: "id", | |
| 77 | + onDelete: ReferentialAction.Cascade); | |
| 78 | + }); | |
| 79 | + | |
| 80 | + migrationBuilder.CreateTable( | |
| 81 | + name: "push_events", | |
| 82 | + columns: table => new | |
| 83 | + { | |
| 84 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 85 | + .Annotation("Sqlite:Autoincrement", true), | |
| 86 | + repo_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 87 | + ref_name = table.Column<string>(type: "TEXT", nullable: false), | |
| 88 | + old_sha = table.Column<string>(type: "TEXT", nullable: false), | |
| 89 | + new_sha = table.Column<string>(type: "TEXT", nullable: false), | |
| 90 | + pushed_at = table.Column<DateTime>(type: "TEXT", nullable: false) | |
| 91 | + }, | |
| 92 | + constraints: table => | |
| 93 | + { | |
| 94 | + table.PrimaryKey("PK_push_events", x => x.id); | |
| 95 | + table.ForeignKey( | |
| 96 | + name: "FK_push_events_repositories_repo_id", | |
| 97 | + column: x => x.repo_id, | |
| 98 | + principalTable: "repositories", | |
| 99 | + principalColumn: "id", | |
| 100 | + onDelete: ReferentialAction.Cascade); | |
| 101 | + }); | |
| 102 | + | |
| 103 | + migrationBuilder.CreateTable( | |
| 104 | + name: "webhooks", | |
| 105 | + columns: table => new | |
| 106 | + { | |
| 107 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 108 | + .Annotation("Sqlite:Autoincrement", true), | |
| 109 | + repo_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 110 | + url = table.Column<string>(type: "TEXT", nullable: false), | |
| 111 | + secret = table.Column<string>(type: "TEXT", nullable: false), | |
| 112 | + active = table.Column<bool>(type: "INTEGER", nullable: false), | |
| 113 | + created_at = table.Column<DateTime>(type: "TEXT", nullable: false) | |
| 114 | + }, | |
| 115 | + constraints: table => | |
| 116 | + { | |
| 117 | + table.PrimaryKey("PK_webhooks", x => x.id); | |
| 118 | + table.ForeignKey( | |
| 119 | + name: "FK_webhooks_repositories_repo_id", | |
| 120 | + column: x => x.repo_id, | |
| 121 | + principalTable: "repositories", | |
| 122 | + principalColumn: "id", | |
| 123 | + onDelete: ReferentialAction.Cascade); | |
| 124 | + }); | |
| 125 | + | |
| 126 | + migrationBuilder.CreateTable( | |
| 127 | + name: "webhook_deliveries", | |
| 128 | + columns: table => new | |
| 129 | + { | |
| 130 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 131 | + .Annotation("Sqlite:Autoincrement", true), | |
| 132 | + webhook_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 133 | + push_event_id = table.Column<long>(type: "INTEGER", nullable: true), | |
| 134 | + status_code = table.Column<int>(type: "INTEGER", nullable: true), | |
| 135 | + duration_ms = table.Column<int>(type: "INTEGER", nullable: false), | |
| 136 | + error = table.Column<string>(type: "TEXT", nullable: true), | |
| 137 | + attempt = table.Column<int>(type: "INTEGER", nullable: false), | |
| 138 | + delivered_at = table.Column<DateTime>(type: "TEXT", nullable: false) | |
| 139 | + }, | |
| 140 | + constraints: table => | |
| 141 | + { | |
| 142 | + table.PrimaryKey("PK_webhook_deliveries", x => x.id); | |
| 143 | + table.ForeignKey( | |
| 144 | + name: "FK_webhook_deliveries_push_events_push_event_id", | |
| 145 | + column: x => x.push_event_id, | |
| 146 | + principalTable: "push_events", | |
| 147 | + principalColumn: "id", | |
| 148 | + onDelete: ReferentialAction.Cascade); | |
| 149 | + table.ForeignKey( | |
| 150 | + name: "FK_webhook_deliveries_webhooks_webhook_id", | |
| 151 | + column: x => x.webhook_id, | |
| 152 | + principalTable: "webhooks", | |
| 153 | + principalColumn: "id", | |
| 154 | + onDelete: ReferentialAction.Cascade); | |
| 155 | + }); | |
| 156 | + | |
| 157 | + migrationBuilder.CreateIndex( | |
| 158 | + name: "IX_access_tokens_token_hash", | |
| 159 | + table: "access_tokens", | |
| 160 | + column: "token_hash", | |
| 161 | + unique: true); | |
| 162 | + | |
| 163 | + migrationBuilder.CreateIndex( | |
| 164 | + name: "IX_access_tokens_user_id", | |
| 165 | + table: "access_tokens", | |
| 166 | + column: "user_id"); | |
| 167 | + | |
| 168 | + migrationBuilder.CreateIndex( | |
| 169 | + name: "IX_push_events_repo_id_pushed_at", | |
| 170 | + table: "push_events", | |
| 171 | + columns: new[] { "repo_id", "pushed_at" }); | |
| 172 | + | |
| 173 | + migrationBuilder.CreateIndex( | |
| 174 | + name: "IX_repositories_owner_id_name", | |
| 175 | + table: "repositories", | |
| 176 | + columns: new[] { "owner_id", "name" }, | |
| 177 | + unique: true); | |
| 178 | + | |
| 179 | + migrationBuilder.CreateIndex( | |
| 180 | + name: "IX_users_username", | |
| 181 | + table: "users", | |
| 182 | + column: "username", | |
| 183 | + unique: true); | |
| 184 | + | |
| 185 | + migrationBuilder.CreateIndex( | |
| 186 | + name: "IX_webhook_deliveries_push_event_id", | |
| 187 | + table: "webhook_deliveries", | |
| 188 | + column: "push_event_id"); | |
| 189 | + | |
| 190 | + migrationBuilder.CreateIndex( | |
| 191 | + name: "IX_webhook_deliveries_webhook_id_push_event_id", | |
| 192 | + table: "webhook_deliveries", | |
| 193 | + columns: new[] { "webhook_id", "push_event_id" }); | |
| 194 | + | |
| 195 | + migrationBuilder.CreateIndex( | |
| 196 | + name: "IX_webhooks_repo_id", | |
| 197 | + table: "webhooks", | |
| 198 | + column: "repo_id"); | |
| 199 | + } | |
| 200 | + | |
| 201 | + /// <inheritdoc /> | |
| 202 | + protected override void Down(MigrationBuilder migrationBuilder) | |
| 203 | + { | |
| 204 | + migrationBuilder.DropTable( | |
| 205 | + name: "access_tokens"); | |
| 206 | + | |
| 207 | + migrationBuilder.DropTable( | |
| 208 | + name: "webhook_deliveries"); | |
| 209 | + | |
| 210 | + migrationBuilder.DropTable( | |
| 211 | + name: "push_events"); | |
| 212 | + | |
| 213 | + migrationBuilder.DropTable( | |
| 214 | + name: "webhooks"); | |
| 215 | + | |
| 216 | + migrationBuilder.DropTable( | |
| 217 | + name: "repositories"); | |
| 218 | + | |
| 219 | + migrationBuilder.DropTable( | |
| 220 | + name: "users"); | |
| 221 | + } | |
| 222 | +} |
added forge/Data/Migrations/20261115121154_PullRequestsAndBranchProtection.Designer.cs +525 −0View file
| @@ -0,0 +1,525 @@ | ||
| 1 | +// <auto-generated /> | |
| 2 | +using System; | |
| 3 | +using Forge.Data; | |
| 4 | +using Microsoft.EntityFrameworkCore; | |
| 5 | +using Microsoft.EntityFrameworkCore.Infrastructure; | |
| 6 | +using Microsoft.EntityFrameworkCore.Migrations; | |
| 7 | +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; | |
| 8 | + | |
| 9 | +#nullable disable | |
| 10 | + | |
| 11 | +namespace Forge.Data.Migrations; | |
| 12 | + | |
| 13 | +[DbContext(typeof(ForgeDb))] | |
| 14 | +[Migration("20261115121154_PullRequestsAndBranchProtection")] | |
| 15 | +partial class _20261115121154_PullRequestsAndBranchProtection | |
| 16 | +{ | |
| 17 | + /// <inheritdoc /> | |
| 18 | + protected override void BuildTargetModel(ModelBuilder modelBuilder) | |
| 19 | + { | |
| 20 | +#pragma warning disable 612, 618 | |
| 21 | + modelBuilder.HasAnnotation("ProductVersion", "11.0.0"); | |
| 22 | + | |
| 23 | + modelBuilder.Entity("Forge.Data.AccessToken", b => | |
| 24 | + { | |
| 25 | + b.Property<long>("Id") | |
| 26 | + .ValueGeneratedOnAdd() | |
| 27 | + .HasColumnType("INTEGER") | |
| 28 | + .HasColumnName("id"); | |
| 29 | + | |
| 30 | + b.Property<bool>("CanWrite") | |
| 31 | + .HasColumnType("INTEGER") | |
| 32 | + .HasColumnName("can_write"); | |
| 33 | + | |
| 34 | + b.Property<DateTime>("CreatedAt") | |
| 35 | + .HasColumnType("TEXT") | |
| 36 | + .HasColumnName("created_at"); | |
| 37 | + | |
| 38 | + b.Property<DateTime?>("ExpiresAt") | |
| 39 | + .HasColumnType("TEXT") | |
| 40 | + .HasColumnName("expires_at"); | |
| 41 | + | |
| 42 | + b.Property<DateTime?>("LastUsedAt") | |
| 43 | + .HasColumnType("TEXT") | |
| 44 | + .HasColumnName("last_used_at"); | |
| 45 | + | |
| 46 | + b.Property<string>("Name") | |
| 47 | + .IsRequired() | |
| 48 | + .HasColumnType("TEXT") | |
| 49 | + .HasColumnName("name"); | |
| 50 | + | |
| 51 | + b.Property<string>("TokenHash") | |
| 52 | + .IsRequired() | |
| 53 | + .HasColumnType("TEXT") | |
| 54 | + .HasColumnName("token_hash"); | |
| 55 | + | |
| 56 | + b.Property<long>("UserId") | |
| 57 | + .HasColumnType("INTEGER") | |
| 58 | + .HasColumnName("user_id"); | |
| 59 | + | |
| 60 | + b.HasKey("Id"); | |
| 61 | + | |
| 62 | + b.HasIndex("TokenHash") | |
| 63 | + .IsUnique(); | |
| 64 | + | |
| 65 | + b.HasIndex("UserId"); | |
| 66 | + | |
| 67 | + b.ToTable("access_tokens"); | |
| 68 | + }); | |
| 69 | + | |
| 70 | + modelBuilder.Entity("Forge.Data.BranchProtection", b => | |
| 71 | + { | |
| 72 | + b.Property<long>("Id") | |
| 73 | + .ValueGeneratedOnAdd() | |
| 74 | + .HasColumnType("INTEGER") | |
| 75 | + .HasColumnName("id"); | |
| 76 | + | |
| 77 | + b.Property<bool>("BlockPush") | |
| 78 | + .HasColumnType("INTEGER") | |
| 79 | + .HasColumnName("block_push"); | |
| 80 | + | |
| 81 | + b.Property<DateTime>("CreatedAt") | |
| 82 | + .HasColumnType("TEXT") | |
| 83 | + .HasColumnName("created_at"); | |
| 84 | + | |
| 85 | + b.Property<string>("Pattern") | |
| 86 | + .IsRequired() | |
| 87 | + .HasColumnType("TEXT") | |
| 88 | + .HasColumnName("pattern"); | |
| 89 | + | |
| 90 | + b.Property<long>("RepoId") | |
| 91 | + .HasColumnType("INTEGER") | |
| 92 | + .HasColumnName("repo_id"); | |
| 93 | + | |
| 94 | + b.HasKey("Id"); | |
| 95 | + | |
| 96 | + b.HasIndex("RepoId", "Pattern") | |
| 97 | + .IsUnique(); | |
| 98 | + | |
| 99 | + b.ToTable("branch_protections"); | |
| 100 | + }); | |
| 101 | + | |
| 102 | + modelBuilder.Entity("Forge.Data.PullRequest", b => | |
| 103 | + { | |
| 104 | + b.Property<long>("Id") | |
| 105 | + .ValueGeneratedOnAdd() | |
| 106 | + .HasColumnType("INTEGER") | |
| 107 | + .HasColumnName("id"); | |
| 108 | + | |
| 109 | + b.Property<long>("AuthorId") | |
| 110 | + .HasColumnType("INTEGER") | |
| 111 | + .HasColumnName("author_id"); | |
| 112 | + | |
| 113 | + b.Property<string>("BaseBranch") | |
| 114 | + .IsRequired() | |
| 115 | + .HasColumnType("TEXT") | |
| 116 | + .HasColumnName("base_branch"); | |
| 117 | + | |
| 118 | + b.Property<string>("BaseSha") | |
| 119 | + .HasColumnType("TEXT") | |
| 120 | + .HasColumnName("base_sha"); | |
| 121 | + | |
| 122 | + b.Property<DateTime?>("ClosedAt") | |
| 123 | + .HasColumnType("TEXT") | |
| 124 | + .HasColumnName("closed_at"); | |
| 125 | + | |
| 126 | + b.Property<DateTime>("CreatedAt") | |
| 127 | + .HasColumnType("TEXT") | |
| 128 | + .HasColumnName("created_at"); | |
| 129 | + | |
| 130 | + b.Property<string>("Description") | |
| 131 | + .IsRequired() | |
| 132 | + .HasColumnType("TEXT") | |
| 133 | + .HasColumnName("description"); | |
| 134 | + | |
| 135 | + b.Property<string>("HeadBranch") | |
| 136 | + .IsRequired() | |
| 137 | + .HasColumnType("TEXT") | |
| 138 | + .HasColumnName("head_branch"); | |
| 139 | + | |
| 140 | + b.Property<string>("HeadSha") | |
| 141 | + .HasColumnType("TEXT") | |
| 142 | + .HasColumnName("head_sha"); | |
| 143 | + | |
| 144 | + b.Property<string>("MergeCommitSha") | |
| 145 | + .HasColumnType("TEXT") | |
| 146 | + .HasColumnName("merge_commit_sha"); | |
| 147 | + | |
| 148 | + b.Property<int>("Number") | |
| 149 | + .HasColumnType("INTEGER") | |
| 150 | + .HasColumnName("number"); | |
| 151 | + | |
| 152 | + b.Property<long>("RepoId") | |
| 153 | + .HasColumnType("INTEGER") | |
| 154 | + .HasColumnName("repo_id"); | |
| 155 | + | |
| 156 | + b.Property<string>("Status") | |
| 157 | + .IsRequired() | |
| 158 | + .HasColumnType("TEXT") | |
| 159 | + .HasColumnName("status"); | |
| 160 | + | |
| 161 | + b.Property<string>("Title") | |
| 162 | + .IsRequired() | |
| 163 | + .HasColumnType("TEXT") | |
| 164 | + .HasColumnName("title"); | |
| 165 | + | |
| 166 | + b.Property<DateTime>("UpdatedAt") | |
| 167 | + .HasColumnType("TEXT") | |
| 168 | + .HasColumnName("updated_at"); | |
| 169 | + | |
| 170 | + b.HasKey("Id"); | |
| 171 | + | |
| 172 | + b.HasIndex("AuthorId"); | |
| 173 | + | |
| 174 | + b.HasIndex("RepoId", "Number") | |
| 175 | + .IsUnique(); | |
| 176 | + | |
| 177 | + b.ToTable("pull_requests"); | |
| 178 | + }); | |
| 179 | + | |
| 180 | + modelBuilder.Entity("Forge.Data.PullRequestComment", b => | |
| 181 | + { | |
| 182 | + b.Property<long>("Id") | |
| 183 | + .ValueGeneratedOnAdd() | |
| 184 | + .HasColumnType("INTEGER") | |
| 185 | + .HasColumnName("id"); | |
| 186 | + | |
| 187 | + b.Property<long>("AuthorId") | |
| 188 | + .HasColumnType("INTEGER") | |
| 189 | + .HasColumnName("author_id"); | |
| 190 | + | |
| 191 | + b.Property<string>("Body") | |
| 192 | + .IsRequired() | |
| 193 | + .HasColumnType("TEXT") | |
| 194 | + .HasColumnName("body"); | |
| 195 | + | |
| 196 | + b.Property<DateTime>("CreatedAt") | |
| 197 | + .HasColumnType("TEXT") | |
| 198 | + .HasColumnName("created_at"); | |
| 199 | + | |
| 200 | + b.Property<long>("PullRequestId") | |
| 201 | + .HasColumnType("INTEGER") | |
| 202 | + .HasColumnName("pull_request_id"); | |
| 203 | + | |
| 204 | + b.HasKey("Id"); | |
| 205 | + | |
| 206 | + b.HasIndex("AuthorId"); | |
| 207 | + | |
| 208 | + b.HasIndex("PullRequestId"); | |
| 209 | + | |
| 210 | + b.ToTable("pull_request_comments"); | |
| 211 | + }); | |
| 212 | + | |
| 213 | + modelBuilder.Entity("Forge.Data.PushEvent", b => | |
| 214 | + { | |
| 215 | + b.Property<long>("Id") | |
| 216 | + .ValueGeneratedOnAdd() | |
| 217 | + .HasColumnType("INTEGER") | |
| 218 | + .HasColumnName("id"); | |
| 219 | + | |
| 220 | + b.Property<string>("NewSha") | |
| 221 | + .IsRequired() | |
| 222 | + .HasColumnType("TEXT") | |
| 223 | + .HasColumnName("new_sha"); | |
| 224 | + | |
| 225 | + b.Property<string>("OldSha") | |
| 226 | + .IsRequired() | |
| 227 | + .HasColumnType("TEXT") | |
| 228 | + .HasColumnName("old_sha"); | |
| 229 | + | |
| 230 | + b.Property<DateTime>("PushedAt") | |
| 231 | + .HasColumnType("TEXT") | |
| 232 | + .HasColumnName("pushed_at"); | |
| 233 | + | |
| 234 | + b.Property<string>("RefName") | |
| 235 | + .IsRequired() | |
| 236 | + .HasColumnType("TEXT") | |
| 237 | + .HasColumnName("ref_name"); | |
| 238 | + | |
| 239 | + b.Property<long>("RepoId") | |
| 240 | + .HasColumnType("INTEGER") | |
| 241 | + .HasColumnName("repo_id"); | |
| 242 | + | |
| 243 | + b.HasKey("Id"); | |
| 244 | + | |
| 245 | + b.HasIndex("RepoId", "PushedAt"); | |
| 246 | + | |
| 247 | + b.ToTable("push_events"); | |
| 248 | + }); | |
| 249 | + | |
| 250 | + modelBuilder.Entity("Forge.Data.Repository", b => | |
| 251 | + { | |
| 252 | + b.Property<long>("Id") | |
| 253 | + .ValueGeneratedOnAdd() | |
| 254 | + .HasColumnType("INTEGER") | |
| 255 | + .HasColumnName("id"); | |
| 256 | + | |
| 257 | + b.Property<DateTime>("CreatedAt") | |
| 258 | + .HasColumnType("TEXT") | |
| 259 | + .HasColumnName("created_at"); | |
| 260 | + | |
| 261 | + b.Property<string>("DefaultBranch") | |
| 262 | + .IsRequired() | |
| 263 | + .HasColumnType("TEXT") | |
| 264 | + .HasColumnName("default_branch"); | |
| 265 | + | |
| 266 | + b.Property<string>("Description") | |
| 267 | + .IsRequired() | |
| 268 | + .HasColumnType("TEXT") | |
| 269 | + .HasColumnName("description"); | |
| 270 | + | |
| 271 | + b.Property<string>("Name") | |
| 272 | + .IsRequired() | |
| 273 | + .HasColumnType("TEXT") | |
| 274 | + .HasColumnName("name") | |
| 275 | + .UseCollation("NOCASE"); | |
| 276 | + | |
| 277 | + b.Property<long>("OwnerId") | |
| 278 | + .HasColumnType("INTEGER") | |
| 279 | + .HasColumnName("owner_id"); | |
| 280 | + | |
| 281 | + b.Property<DateTime?>("PushedAt") | |
| 282 | + .HasColumnType("TEXT") | |
| 283 | + .HasColumnName("pushed_at"); | |
| 284 | + | |
| 285 | + b.Property<string>("Visibility") | |
| 286 | + .IsRequired() | |
| 287 | + .HasColumnType("TEXT") | |
| 288 | + .HasColumnName("visibility"); | |
| 289 | + | |
| 290 | + b.HasKey("Id"); | |
| 291 | + | |
| 292 | + b.HasIndex("OwnerId", "Name") | |
| 293 | + .IsUnique(); | |
| 294 | + | |
| 295 | + b.ToTable("repositories"); | |
| 296 | + }); | |
| 297 | + | |
| 298 | + modelBuilder.Entity("Forge.Data.User", b => | |
| 299 | + { | |
| 300 | + b.Property<long>("Id") | |
| 301 | + .ValueGeneratedOnAdd() | |
| 302 | + .HasColumnType("INTEGER") | |
| 303 | + .HasColumnName("id"); | |
| 304 | + | |
| 305 | + b.Property<DateTime>("CreatedAt") | |
| 306 | + .HasColumnType("TEXT") | |
| 307 | + .HasColumnName("created_at"); | |
| 308 | + | |
| 309 | + b.Property<string>("DisplayName") | |
| 310 | + .IsRequired() | |
| 311 | + .HasColumnType("TEXT") | |
| 312 | + .HasColumnName("display_name"); | |
| 313 | + | |
| 314 | + b.Property<string>("PasswordHash") | |
| 315 | + .IsRequired() | |
| 316 | + .HasColumnType("TEXT") | |
| 317 | + .HasColumnName("password_hash"); | |
| 318 | + | |
| 319 | + b.Property<string>("Username") | |
| 320 | + .IsRequired() | |
| 321 | + .HasColumnType("TEXT") | |
| 322 | + .HasColumnName("username") | |
| 323 | + .UseCollation("NOCASE"); | |
| 324 | + | |
| 325 | + b.HasKey("Id"); | |
| 326 | + | |
| 327 | + b.HasIndex("Username") | |
| 328 | + .IsUnique(); | |
| 329 | + | |
| 330 | + b.ToTable("users"); | |
| 331 | + }); | |
| 332 | + | |
| 333 | + modelBuilder.Entity("Forge.Data.Webhook", b => | |
| 334 | + { | |
| 335 | + b.Property<long>("Id") | |
| 336 | + .ValueGeneratedOnAdd() | |
| 337 | + .HasColumnType("INTEGER") | |
| 338 | + .HasColumnName("id"); | |
| 339 | + | |
| 340 | + b.Property<bool>("Active") | |
| 341 | + .HasColumnType("INTEGER") | |
| 342 | + .HasColumnName("active"); | |
| 343 | + | |
| 344 | + b.Property<DateTime>("CreatedAt") | |
| 345 | + .HasColumnType("TEXT") | |
| 346 | + .HasColumnName("created_at"); | |
| 347 | + | |
| 348 | + b.Property<long>("RepoId") | |
| 349 | + .HasColumnType("INTEGER") | |
| 350 | + .HasColumnName("repo_id"); | |
| 351 | + | |
| 352 | + b.Property<string>("Secret") | |
| 353 | + .IsRequired() | |
| 354 | + .HasColumnType("TEXT") | |
| 355 | + .HasColumnName("secret"); | |
| 356 | + | |
| 357 | + b.Property<string>("Url") | |
| 358 | + .IsRequired() | |
| 359 | + .HasColumnType("TEXT") | |
| 360 | + .HasColumnName("url"); | |
| 361 | + | |
| 362 | + b.HasKey("Id"); | |
| 363 | + | |
| 364 | + b.HasIndex("RepoId"); | |
| 365 | + | |
| 366 | + b.ToTable("webhooks"); | |
| 367 | + }); | |
| 368 | + | |
| 369 | + modelBuilder.Entity("Forge.Data.WebhookDelivery", b => | |
| 370 | + { | |
| 371 | + b.Property<long>("Id") | |
| 372 | + .ValueGeneratedOnAdd() | |
| 373 | + .HasColumnType("INTEGER") | |
| 374 | + .HasColumnName("id"); | |
| 375 | + | |
| 376 | + b.Property<int>("Attempt") | |
| 377 | + .HasColumnType("INTEGER") | |
| 378 | + .HasColumnName("attempt"); | |
| 379 | + | |
| 380 | + b.Property<DateTime>("DeliveredAt") | |
| 381 | + .HasColumnType("TEXT") | |
| 382 | + .HasColumnName("delivered_at"); | |
| 383 | + | |
| 384 | + b.Property<int>("DurationMs") | |
| 385 | + .HasColumnType("INTEGER") | |
| 386 | + .HasColumnName("duration_ms"); | |
| 387 | + | |
| 388 | + b.Property<string>("Error") | |
| 389 | + .HasColumnType("TEXT") | |
| 390 | + .HasColumnName("error"); | |
| 391 | + | |
| 392 | + b.Property<long?>("PushEventId") | |
| 393 | + .HasColumnType("INTEGER") | |
| 394 | + .HasColumnName("push_event_id"); | |
| 395 | + | |
| 396 | + b.Property<int?>("StatusCode") | |
| 397 | + .HasColumnType("INTEGER") | |
| 398 | + .HasColumnName("status_code"); | |
| 399 | + | |
| 400 | + b.Property<long>("WebhookId") | |
| 401 | + .HasColumnType("INTEGER") | |
| 402 | + .HasColumnName("webhook_id"); | |
| 403 | + | |
| 404 | + b.HasKey("Id"); | |
| 405 | + | |
| 406 | + b.HasIndex("PushEventId"); | |
| 407 | + | |
| 408 | + b.HasIndex("WebhookId", "PushEventId"); | |
| 409 | + | |
| 410 | + b.ToTable("webhook_deliveries"); | |
| 411 | + }); | |
| 412 | + | |
| 413 | + modelBuilder.Entity("Forge.Data.AccessToken", b => | |
| 414 | + { | |
| 415 | + b.HasOne("Forge.Data.User", "User") | |
| 416 | + .WithMany() | |
| 417 | + .HasForeignKey("UserId") | |
| 418 | + .OnDelete(DeleteBehavior.Cascade) | |
| 419 | + .IsRequired(); | |
| 420 | + | |
| 421 | + b.Navigation("User"); | |
| 422 | + }); | |
| 423 | + | |
| 424 | + modelBuilder.Entity("Forge.Data.BranchProtection", b => | |
| 425 | + { | |
| 426 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 427 | + .WithMany() | |
| 428 | + .HasForeignKey("RepoId") | |
| 429 | + .OnDelete(DeleteBehavior.Cascade) | |
| 430 | + .IsRequired(); | |
| 431 | + | |
| 432 | + b.Navigation("Repo"); | |
| 433 | + }); | |
| 434 | + | |
| 435 | + modelBuilder.Entity("Forge.Data.PullRequest", b => | |
| 436 | + { | |
| 437 | + b.HasOne("Forge.Data.User", "Author") | |
| 438 | + .WithMany() | |
| 439 | + .HasForeignKey("AuthorId") | |
| 440 | + .OnDelete(DeleteBehavior.Cascade) | |
| 441 | + .IsRequired(); | |
| 442 | + | |
| 443 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 444 | + .WithMany() | |
| 445 | + .HasForeignKey("RepoId") | |
| 446 | + .OnDelete(DeleteBehavior.Cascade) | |
| 447 | + .IsRequired(); | |
| 448 | + | |
| 449 | + b.Navigation("Author"); | |
| 450 | + | |
| 451 | + b.Navigation("Repo"); | |
| 452 | + }); | |
| 453 | + | |
| 454 | + modelBuilder.Entity("Forge.Data.PullRequestComment", b => | |
| 455 | + { | |
| 456 | + b.HasOne("Forge.Data.User", "Author") | |
| 457 | + .WithMany() | |
| 458 | + .HasForeignKey("AuthorId") | |
| 459 | + .OnDelete(DeleteBehavior.Cascade) | |
| 460 | + .IsRequired(); | |
| 461 | + | |
| 462 | + b.HasOne("Forge.Data.PullRequest", "PullRequest") | |
| 463 | + .WithMany() | |
| 464 | + .HasForeignKey("PullRequestId") | |
| 465 | + .OnDelete(DeleteBehavior.Cascade) | |
| 466 | + .IsRequired(); | |
| 467 | + | |
| 468 | + b.Navigation("Author"); | |
| 469 | + | |
| 470 | + b.Navigation("PullRequest"); | |
| 471 | + }); | |
| 472 | + | |
| 473 | + modelBuilder.Entity("Forge.Data.PushEvent", b => | |
| 474 | + { | |
| 475 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 476 | + .WithMany() | |
| 477 | + .HasForeignKey("RepoId") | |
| 478 | + .OnDelete(DeleteBehavior.Cascade) | |
| 479 | + .IsRequired(); | |
| 480 | + | |
| 481 | + b.Navigation("Repo"); | |
| 482 | + }); | |
| 483 | + | |
| 484 | + modelBuilder.Entity("Forge.Data.Repository", b => | |
| 485 | + { | |
| 486 | + b.HasOne("Forge.Data.User", "Owner") | |
| 487 | + .WithMany() | |
| 488 | + .HasForeignKey("OwnerId") | |
| 489 | + .OnDelete(DeleteBehavior.Cascade) | |
| 490 | + .IsRequired(); | |
| 491 | + | |
| 492 | + b.Navigation("Owner"); | |
| 493 | + }); | |
| 494 | + | |
| 495 | + modelBuilder.Entity("Forge.Data.Webhook", b => | |
| 496 | + { | |
| 497 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 498 | + .WithMany() | |
| 499 | + .HasForeignKey("RepoId") | |
| 500 | + .OnDelete(DeleteBehavior.Cascade) | |
| 501 | + .IsRequired(); | |
| 502 | + | |
| 503 | + b.Navigation("Repo"); | |
| 504 | + }); | |
| 505 | + | |
| 506 | + modelBuilder.Entity("Forge.Data.WebhookDelivery", b => | |
| 507 | + { | |
| 508 | + b.HasOne("Forge.Data.PushEvent", "PushEvent") | |
| 509 | + .WithMany() | |
| 510 | + .HasForeignKey("PushEventId") | |
| 511 | + .OnDelete(DeleteBehavior.Cascade); | |
| 512 | + | |
| 513 | + b.HasOne("Forge.Data.Webhook", "Webhook") | |
| 514 | + .WithMany() | |
| 515 | + .HasForeignKey("WebhookId") | |
| 516 | + .OnDelete(DeleteBehavior.Cascade) | |
| 517 | + .IsRequired(); | |
| 518 | + | |
| 519 | + b.Navigation("PushEvent"); | |
| 520 | + | |
| 521 | + b.Navigation("Webhook"); | |
| 522 | + }); | |
| 523 | +#pragma warning restore 612, 618 | |
| 524 | + } | |
| 525 | +} |
added forge/Data/Migrations/20261115121154_PullRequestsAndBranchProtection.cs +142 −0View file
| @@ -0,0 +1,142 @@ | ||
| 1 | +using System; | |
| 2 | +using Microsoft.EntityFrameworkCore.Migrations; | |
| 3 | + | |
| 4 | +#nullable disable | |
| 5 | + | |
| 6 | +namespace Forge.Data.Migrations; | |
| 7 | + | |
| 8 | +/// <inheritdoc /> | |
| 9 | +public partial class _20261115121154_PullRequestsAndBranchProtection : Migration | |
| 10 | +{ | |
| 11 | + /// <inheritdoc /> | |
| 12 | + protected override void Up(MigrationBuilder migrationBuilder) | |
| 13 | + { | |
| 14 | + migrationBuilder.CreateTable( | |
| 15 | + name: "branch_protections", | |
| 16 | + columns: table => new | |
| 17 | + { | |
| 18 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 19 | + .Annotation("Sqlite:Autoincrement", true), | |
| 20 | + repo_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 21 | + pattern = table.Column<string>(type: "TEXT", nullable: false), | |
| 22 | + block_push = table.Column<bool>(type: "INTEGER", nullable: false), | |
| 23 | + created_at = table.Column<DateTime>(type: "TEXT", nullable: false) | |
| 24 | + }, | |
| 25 | + constraints: table => | |
| 26 | + { | |
| 27 | + table.PrimaryKey("PK_branch_protections", x => x.id); | |
| 28 | + table.ForeignKey( | |
| 29 | + name: "FK_branch_protections_repositories_repo_id", | |
| 30 | + column: x => x.repo_id, | |
| 31 | + principalTable: "repositories", | |
| 32 | + principalColumn: "id", | |
| 33 | + onDelete: ReferentialAction.Cascade); | |
| 34 | + }); | |
| 35 | + | |
| 36 | + migrationBuilder.CreateTable( | |
| 37 | + name: "pull_requests", | |
| 38 | + columns: table => new | |
| 39 | + { | |
| 40 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 41 | + .Annotation("Sqlite:Autoincrement", true), | |
| 42 | + repo_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 43 | + number = table.Column<int>(type: "INTEGER", nullable: false), | |
| 44 | + title = table.Column<string>(type: "TEXT", nullable: false), | |
| 45 | + description = table.Column<string>(type: "TEXT", nullable: false), | |
| 46 | + base_branch = table.Column<string>(type: "TEXT", nullable: false), | |
| 47 | + head_branch = table.Column<string>(type: "TEXT", nullable: false), | |
| 48 | + status = table.Column<string>(type: "TEXT", nullable: false), | |
| 49 | + author_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 50 | + created_at = table.Column<DateTime>(type: "TEXT", nullable: false), | |
| 51 | + updated_at = table.Column<DateTime>(type: "TEXT", nullable: false), | |
| 52 | + closed_at = table.Column<DateTime>(type: "TEXT", nullable: true), | |
| 53 | + merge_commit_sha = table.Column<string>(type: "TEXT", nullable: true), | |
| 54 | + base_sha = table.Column<string>(type: "TEXT", nullable: true), | |
| 55 | + head_sha = table.Column<string>(type: "TEXT", nullable: true) | |
| 56 | + }, | |
| 57 | + constraints: table => | |
| 58 | + { | |
| 59 | + table.PrimaryKey("PK_pull_requests", x => x.id); | |
| 60 | + table.ForeignKey( | |
| 61 | + name: "FK_pull_requests_repositories_repo_id", | |
| 62 | + column: x => x.repo_id, | |
| 63 | + principalTable: "repositories", | |
| 64 | + principalColumn: "id", | |
| 65 | + onDelete: ReferentialAction.Cascade); | |
| 66 | + table.ForeignKey( | |
| 67 | + name: "FK_pull_requests_users_author_id", | |
| 68 | + column: x => x.author_id, | |
| 69 | + principalTable: "users", | |
| 70 | + principalColumn: "id", | |
| 71 | + onDelete: ReferentialAction.Cascade); | |
| 72 | + }); | |
| 73 | + | |
| 74 | + migrationBuilder.CreateTable( | |
| 75 | + name: "pull_request_comments", | |
| 76 | + columns: table => new | |
| 77 | + { | |
| 78 | + id = table.Column<long>(type: "INTEGER", nullable: false) | |
| 79 | + .Annotation("Sqlite:Autoincrement", true), | |
| 80 | + pull_request_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 81 | + author_id = table.Column<long>(type: "INTEGER", nullable: false), | |
| 82 | + body = table.Column<string>(type: "TEXT", nullable: false), | |
| 83 | + created_at = table.Column<DateTime>(type: "TEXT", nullable: false) | |
| 84 | + }, | |
| 85 | + constraints: table => | |
| 86 | + { | |
| 87 | + table.PrimaryKey("PK_pull_request_comments", x => x.id); | |
| 88 | + table.ForeignKey( | |
| 89 | + name: "FK_pull_request_comments_pull_requests_pull_request_id", | |
| 90 | + column: x => x.pull_request_id, | |
| 91 | + principalTable: "pull_requests", | |
| 92 | + principalColumn: "id", | |
| 93 | + onDelete: ReferentialAction.Cascade); | |
| 94 | + table.ForeignKey( | |
| 95 | + name: "FK_pull_request_comments_users_author_id", | |
| 96 | + column: x => x.author_id, | |
| 97 | + principalTable: "users", | |
| 98 | + principalColumn: "id", | |
| 99 | + onDelete: ReferentialAction.Cascade); | |
| 100 | + }); | |
| 101 | + | |
| 102 | + migrationBuilder.CreateIndex( | |
| 103 | + name: "IX_branch_protections_repo_id_pattern", | |
| 104 | + table: "branch_protections", | |
| 105 | + columns: new[] { "repo_id", "pattern" }, | |
| 106 | + unique: true); | |
| 107 | + | |
| 108 | + migrationBuilder.CreateIndex( | |
| 109 | + name: "IX_pull_request_comments_author_id", | |
| 110 | + table: "pull_request_comments", | |
| 111 | + column: "author_id"); | |
| 112 | + | |
| 113 | + migrationBuilder.CreateIndex( | |
| 114 | + name: "IX_pull_request_comments_pull_request_id", | |
| 115 | + table: "pull_request_comments", | |
| 116 | + column: "pull_request_id"); | |
| 117 | + | |
| 118 | + migrationBuilder.CreateIndex( | |
| 119 | + name: "IX_pull_requests_author_id", | |
| 120 | + table: "pull_requests", | |
| 121 | + column: "author_id"); | |
| 122 | + | |
| 123 | + migrationBuilder.CreateIndex( | |
| 124 | + name: "IX_pull_requests_repo_id_number", | |
| 125 | + table: "pull_requests", | |
| 126 | + columns: new[] { "repo_id", "number" }, | |
| 127 | + unique: true); | |
| 128 | + } | |
| 129 | + | |
| 130 | + /// <inheritdoc /> | |
| 131 | + protected override void Down(MigrationBuilder migrationBuilder) | |
| 132 | + { | |
| 133 | + migrationBuilder.DropTable( | |
| 134 | + name: "branch_protections"); | |
| 135 | + | |
| 136 | + migrationBuilder.DropTable( | |
| 137 | + name: "pull_request_comments"); | |
| 138 | + | |
| 139 | + migrationBuilder.DropTable( | |
| 140 | + name: "pull_requests"); | |
| 141 | + } | |
| 142 | +} |
added forge/Data/Migrations/ForgeDbModelSnapshot.cs +527 −0View file
| @@ -0,0 +1,527 @@ | ||
| 1 | +// <auto-generated /> | |
| 2 | +using System; | |
| 3 | +using Forge.Data; | |
| 4 | +using Microsoft.EntityFrameworkCore; | |
| 5 | +using Microsoft.EntityFrameworkCore.Infrastructure; | |
| 6 | +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; | |
| 7 | + | |
| 8 | +#nullable disable | |
| 9 | + | |
| 10 | +namespace Forge.Data.Migrations; | |
| 11 | + | |
| 12 | +[DbContext(typeof(ForgeDb))] | |
| 13 | +partial class ForgeDbModelSnapshot : ModelSnapshot | |
| 14 | +{ | |
| 15 | + // If you encounter a merge conflict in the line below, it means you need to | |
| 16 | + // discard one of the migration branches and recreate its migrations on top of | |
| 17 | + // the other branch. See https://aka.ms/efcore-docs-migrations-conflicts for more info. | |
| 18 | + public override string LastMigrationId => "20261115121154_PullRequestsAndBranchProtection"; | |
| 19 | + | |
| 20 | + protected override void BuildModel(ModelBuilder modelBuilder) | |
| 21 | + { | |
| 22 | +#pragma warning disable 612, 618 | |
| 23 | + modelBuilder.HasAnnotation("ProductVersion", "11.0.0"); | |
| 24 | + | |
| 25 | + modelBuilder.Entity("Forge.Data.AccessToken", b => | |
| 26 | + { | |
| 27 | + b.Property<long>("Id") | |
| 28 | + .ValueGeneratedOnAdd() | |
| 29 | + .HasColumnType("INTEGER") | |
| 30 | + .HasColumnName("id"); | |
| 31 | + | |
| 32 | + b.Property<bool>("CanWrite") | |
| 33 | + .HasColumnType("INTEGER") | |
| 34 | + .HasColumnName("can_write"); | |
| 35 | + | |
| 36 | + b.Property<DateTime>("CreatedAt") | |
| 37 | + .HasColumnType("TEXT") | |
| 38 | + .HasColumnName("created_at"); | |
| 39 | + | |
| 40 | + b.Property<DateTime?>("ExpiresAt") | |
| 41 | + .HasColumnType("TEXT") | |
| 42 | + .HasColumnName("expires_at"); | |
| 43 | + | |
| 44 | + b.Property<DateTime?>("LastUsedAt") | |
| 45 | + .HasColumnType("TEXT") | |
| 46 | + .HasColumnName("last_used_at"); | |
| 47 | + | |
| 48 | + b.Property<string>("Name") | |
| 49 | + .IsRequired() | |
| 50 | + .HasColumnType("TEXT") | |
| 51 | + .HasColumnName("name"); | |
| 52 | + | |
| 53 | + b.Property<string>("TokenHash") | |
| 54 | + .IsRequired() | |
| 55 | + .HasColumnType("TEXT") | |
| 56 | + .HasColumnName("token_hash"); | |
| 57 | + | |
| 58 | + b.Property<long>("UserId") | |
| 59 | + .HasColumnType("INTEGER") | |
| 60 | + .HasColumnName("user_id"); | |
| 61 | + | |
| 62 | + b.HasKey("Id"); | |
| 63 | + | |
| 64 | + b.HasIndex("TokenHash") | |
| 65 | + .IsUnique(); | |
| 66 | + | |
| 67 | + b.HasIndex("UserId"); | |
| 68 | + | |
| 69 | + b.ToTable("access_tokens"); | |
| 70 | + }); | |
| 71 | + | |
| 72 | + modelBuilder.Entity("Forge.Data.BranchProtection", b => | |
| 73 | + { | |
| 74 | + b.Property<long>("Id") | |
| 75 | + .ValueGeneratedOnAdd() | |
| 76 | + .HasColumnType("INTEGER") | |
| 77 | + .HasColumnName("id"); | |
| 78 | + | |
| 79 | + b.Property<bool>("BlockPush") | |
| 80 | + .HasColumnType("INTEGER") | |
| 81 | + .HasColumnName("block_push"); | |
| 82 | + | |
| 83 | + b.Property<DateTime>("CreatedAt") | |
| 84 | + .HasColumnType("TEXT") | |
| 85 | + .HasColumnName("created_at"); | |
| 86 | + | |
| 87 | + b.Property<string>("Pattern") | |
| 88 | + .IsRequired() | |
| 89 | + .HasColumnType("TEXT") | |
| 90 | + .HasColumnName("pattern"); | |
| 91 | + | |
| 92 | + b.Property<long>("RepoId") | |
| 93 | + .HasColumnType("INTEGER") | |
| 94 | + .HasColumnName("repo_id"); | |
| 95 | + | |
| 96 | + b.HasKey("Id"); | |
| 97 | + | |
| 98 | + b.HasIndex("RepoId", "Pattern") | |
| 99 | + .IsUnique(); | |
| 100 | + | |
| 101 | + b.ToTable("branch_protections"); | |
| 102 | + }); | |
| 103 | + | |
| 104 | + modelBuilder.Entity("Forge.Data.PullRequest", b => | |
| 105 | + { | |
| 106 | + b.Property<long>("Id") | |
| 107 | + .ValueGeneratedOnAdd() | |
| 108 | + .HasColumnType("INTEGER") | |
| 109 | + .HasColumnName("id"); | |
| 110 | + | |
| 111 | + b.Property<long>("AuthorId") | |
| 112 | + .HasColumnType("INTEGER") | |
| 113 | + .HasColumnName("author_id"); | |
| 114 | + | |
| 115 | + b.Property<string>("BaseBranch") | |
| 116 | + .IsRequired() | |
| 117 | + .HasColumnType("TEXT") | |
| 118 | + .HasColumnName("base_branch"); | |
| 119 | + | |
| 120 | + b.Property<string>("BaseSha") | |
| 121 | + .HasColumnType("TEXT") | |
| 122 | + .HasColumnName("base_sha"); | |
| 123 | + | |
| 124 | + b.Property<DateTime?>("ClosedAt") | |
| 125 | + .HasColumnType("TEXT") | |
| 126 | + .HasColumnName("closed_at"); | |
| 127 | + | |
| 128 | + b.Property<DateTime>("CreatedAt") | |
| 129 | + .HasColumnType("TEXT") | |
| 130 | + .HasColumnName("created_at"); | |
| 131 | + | |
| 132 | + b.Property<string>("Description") | |
| 133 | + .IsRequired() | |
| 134 | + .HasColumnType("TEXT") | |
| 135 | + .HasColumnName("description"); | |
| 136 | + | |
| 137 | + b.Property<string>("HeadBranch") | |
| 138 | + .IsRequired() | |
| 139 | + .HasColumnType("TEXT") | |
| 140 | + .HasColumnName("head_branch"); | |
| 141 | + | |
| 142 | + b.Property<string>("HeadSha") | |
| 143 | + .HasColumnType("TEXT") | |
| 144 | + .HasColumnName("head_sha"); | |
| 145 | + | |
| 146 | + b.Property<string>("MergeCommitSha") | |
| 147 | + .HasColumnType("TEXT") | |
| 148 | + .HasColumnName("merge_commit_sha"); | |
| 149 | + | |
| 150 | + b.Property<int>("Number") | |
| 151 | + .HasColumnType("INTEGER") | |
| 152 | + .HasColumnName("number"); | |
| 153 | + | |
| 154 | + b.Property<long>("RepoId") | |
| 155 | + .HasColumnType("INTEGER") | |
| 156 | + .HasColumnName("repo_id"); | |
| 157 | + | |
| 158 | + b.Property<string>("Status") | |
| 159 | + .IsRequired() | |
| 160 | + .HasColumnType("TEXT") | |
| 161 | + .HasColumnName("status"); | |
| 162 | + | |
| 163 | + b.Property<string>("Title") | |
| 164 | + .IsRequired() | |
| 165 | + .HasColumnType("TEXT") | |
| 166 | + .HasColumnName("title"); | |
| 167 | + | |
| 168 | + b.Property<DateTime>("UpdatedAt") | |
| 169 | + .HasColumnType("TEXT") | |
| 170 | + .HasColumnName("updated_at"); | |
| 171 | + | |
| 172 | + b.HasKey("Id"); | |
| 173 | + | |
| 174 | + b.HasIndex("AuthorId"); | |
| 175 | + | |
| 176 | + b.HasIndex("RepoId", "Number") | |
| 177 | + .IsUnique(); | |
| 178 | + | |
| 179 | + b.ToTable("pull_requests"); | |
| 180 | + }); | |
| 181 | + | |
| 182 | + modelBuilder.Entity("Forge.Data.PullRequestComment", b => | |
| 183 | + { | |
| 184 | + b.Property<long>("Id") | |
| 185 | + .ValueGeneratedOnAdd() | |
| 186 | + .HasColumnType("INTEGER") | |
| 187 | + .HasColumnName("id"); | |
| 188 | + | |
| 189 | + b.Property<long>("AuthorId") | |
| 190 | + .HasColumnType("INTEGER") | |
| 191 | + .HasColumnName("author_id"); | |
| 192 | + | |
| 193 | + b.Property<string>("Body") | |
| 194 | + .IsRequired() | |
| 195 | + .HasColumnType("TEXT") | |
| 196 | + .HasColumnName("body"); | |
| 197 | + | |
| 198 | + b.Property<DateTime>("CreatedAt") | |
| 199 | + .HasColumnType("TEXT") | |
| 200 | + .HasColumnName("created_at"); | |
| 201 | + | |
| 202 | + b.Property<long>("PullRequestId") | |
| 203 | + .HasColumnType("INTEGER") | |
| 204 | + .HasColumnName("pull_request_id"); | |
| 205 | + | |
| 206 | + b.HasKey("Id"); | |
| 207 | + | |
| 208 | + b.HasIndex("AuthorId"); | |
| 209 | + | |
| 210 | + b.HasIndex("PullRequestId"); | |
| 211 | + | |
| 212 | + b.ToTable("pull_request_comments"); | |
| 213 | + }); | |
| 214 | + | |
| 215 | + modelBuilder.Entity("Forge.Data.PushEvent", b => | |
| 216 | + { | |
| 217 | + b.Property<long>("Id") | |
| 218 | + .ValueGeneratedOnAdd() | |
| 219 | + .HasColumnType("INTEGER") | |
| 220 | + .HasColumnName("id"); | |
| 221 | + | |
| 222 | + b.Property<string>("NewSha") | |
| 223 | + .IsRequired() | |
| 224 | + .HasColumnType("TEXT") | |
| 225 | + .HasColumnName("new_sha"); | |
| 226 | + | |
| 227 | + b.Property<string>("OldSha") | |
| 228 | + .IsRequired() | |
| 229 | + .HasColumnType("TEXT") | |
| 230 | + .HasColumnName("old_sha"); | |
| 231 | + | |
| 232 | + b.Property<DateTime>("PushedAt") | |
| 233 | + .HasColumnType("TEXT") | |
| 234 | + .HasColumnName("pushed_at"); | |
| 235 | + | |
| 236 | + b.Property<string>("RefName") | |
| 237 | + .IsRequired() | |
| 238 | + .HasColumnType("TEXT") | |
| 239 | + .HasColumnName("ref_name"); | |
| 240 | + | |
| 241 | + b.Property<long>("RepoId") | |
| 242 | + .HasColumnType("INTEGER") | |
| 243 | + .HasColumnName("repo_id"); | |
| 244 | + | |
| 245 | + b.HasKey("Id"); | |
| 246 | + | |
| 247 | + b.HasIndex("RepoId", "PushedAt"); | |
| 248 | + | |
| 249 | + b.ToTable("push_events"); | |
| 250 | + }); | |
| 251 | + | |
| 252 | + modelBuilder.Entity("Forge.Data.Repository", b => | |
| 253 | + { | |
| 254 | + b.Property<long>("Id") | |
| 255 | + .ValueGeneratedOnAdd() | |
| 256 | + .HasColumnType("INTEGER") | |
| 257 | + .HasColumnName("id"); | |
| 258 | + | |
| 259 | + b.Property<DateTime>("CreatedAt") | |
| 260 | + .HasColumnType("TEXT") | |
| 261 | + .HasColumnName("created_at"); | |
| 262 | + | |
| 263 | + b.Property<string>("DefaultBranch") | |
| 264 | + .IsRequired() | |
| 265 | + .HasColumnType("TEXT") | |
| 266 | + .HasColumnName("default_branch"); | |
| 267 | + | |
| 268 | + b.Property<string>("Description") | |
| 269 | + .IsRequired() | |
| 270 | + .HasColumnType("TEXT") | |
| 271 | + .HasColumnName("description"); | |
| 272 | + | |
| 273 | + b.Property<string>("Name") | |
| 274 | + .IsRequired() | |
| 275 | + .HasColumnType("TEXT") | |
| 276 | + .HasColumnName("name") | |
| 277 | + .UseCollation("NOCASE"); | |
| 278 | + | |
| 279 | + b.Property<long>("OwnerId") | |
| 280 | + .HasColumnType("INTEGER") | |
| 281 | + .HasColumnName("owner_id"); | |
| 282 | + | |
| 283 | + b.Property<DateTime?>("PushedAt") | |
| 284 | + .HasColumnType("TEXT") | |
| 285 | + .HasColumnName("pushed_at"); | |
| 286 | + | |
| 287 | + b.Property<string>("Visibility") | |
| 288 | + .IsRequired() | |
| 289 | + .HasColumnType("TEXT") | |
| 290 | + .HasColumnName("visibility"); | |
| 291 | + | |
| 292 | + b.HasKey("Id"); | |
| 293 | + | |
| 294 | + b.HasIndex("OwnerId", "Name") | |
| 295 | + .IsUnique(); | |
| 296 | + | |
| 297 | + b.ToTable("repositories"); | |
| 298 | + }); | |
| 299 | + | |
| 300 | + modelBuilder.Entity("Forge.Data.User", b => | |
| 301 | + { | |
| 302 | + b.Property<long>("Id") | |
| 303 | + .ValueGeneratedOnAdd() | |
| 304 | + .HasColumnType("INTEGER") | |
| 305 | + .HasColumnName("id"); | |
| 306 | + | |
| 307 | + b.Property<DateTime>("CreatedAt") | |
| 308 | + .HasColumnType("TEXT") | |
| 309 | + .HasColumnName("created_at"); | |
| 310 | + | |
| 311 | + b.Property<string>("DisplayName") | |
| 312 | + .IsRequired() | |
| 313 | + .HasColumnType("TEXT") | |
| 314 | + .HasColumnName("display_name"); | |
| 315 | + | |
| 316 | + b.Property<string>("PasswordHash") | |
| 317 | + .IsRequired() | |
| 318 | + .HasColumnType("TEXT") | |
| 319 | + .HasColumnName("password_hash"); | |
| 320 | + | |
| 321 | + b.Property<string>("Username") | |
| 322 | + .IsRequired() | |
| 323 | + .HasColumnType("TEXT") | |
| 324 | + .HasColumnName("username") | |
| 325 | + .UseCollation("NOCASE"); | |
| 326 | + | |
| 327 | + b.HasKey("Id"); | |
| 328 | + | |
| 329 | + b.HasIndex("Username") | |
| 330 | + .IsUnique(); | |
| 331 | + | |
| 332 | + b.ToTable("users"); | |
| 333 | + }); | |
| 334 | + | |
| 335 | + modelBuilder.Entity("Forge.Data.Webhook", b => | |
| 336 | + { | |
| 337 | + b.Property<long>("Id") | |
| 338 | + .ValueGeneratedOnAdd() | |
| 339 | + .HasColumnType("INTEGER") | |
| 340 | + .HasColumnName("id"); | |
| 341 | + | |
| 342 | + b.Property<bool>("Active") | |
| 343 | + .HasColumnType("INTEGER") | |
| 344 | + .HasColumnName("active"); | |
| 345 | + | |
| 346 | + b.Property<DateTime>("CreatedAt") | |
| 347 | + .HasColumnType("TEXT") | |
| 348 | + .HasColumnName("created_at"); | |
| 349 | + | |
| 350 | + b.Property<long>("RepoId") | |
| 351 | + .HasColumnType("INTEGER") | |
| 352 | + .HasColumnName("repo_id"); | |
| 353 | + | |
| 354 | + b.Property<string>("Secret") | |
| 355 | + .IsRequired() | |
| 356 | + .HasColumnType("TEXT") | |
| 357 | + .HasColumnName("secret"); | |
| 358 | + | |
| 359 | + b.Property<string>("Url") | |
| 360 | + .IsRequired() | |
| 361 | + .HasColumnType("TEXT") | |
| 362 | + .HasColumnName("url"); | |
| 363 | + | |
| 364 | + b.HasKey("Id"); | |
| 365 | + | |
| 366 | + b.HasIndex("RepoId"); | |
| 367 | + | |
| 368 | + b.ToTable("webhooks"); | |
| 369 | + }); | |
| 370 | + | |
| 371 | + modelBuilder.Entity("Forge.Data.WebhookDelivery", b => | |
| 372 | + { | |
| 373 | + b.Property<long>("Id") | |
| 374 | + .ValueGeneratedOnAdd() | |
| 375 | + .HasColumnType("INTEGER") | |
| 376 | + .HasColumnName("id"); | |
| 377 | + | |
| 378 | + b.Property<int>("Attempt") | |
| 379 | + .HasColumnType("INTEGER") | |
| 380 | + .HasColumnName("attempt"); | |
| 381 | + | |
| 382 | + b.Property<DateTime>("DeliveredAt") | |
| 383 | + .HasColumnType("TEXT") | |
| 384 | + .HasColumnName("delivered_at"); | |
| 385 | + | |
| 386 | + b.Property<int>("DurationMs") | |
| 387 | + .HasColumnType("INTEGER") | |
| 388 | + .HasColumnName("duration_ms"); | |
| 389 | + | |
| 390 | + b.Property<string>("Error") | |
| 391 | + .HasColumnType("TEXT") | |
| 392 | + .HasColumnName("error"); | |
| 393 | + | |
| 394 | + b.Property<long?>("PushEventId") | |
| 395 | + .HasColumnType("INTEGER") | |
| 396 | + .HasColumnName("push_event_id"); | |
| 397 | + | |
| 398 | + b.Property<int?>("StatusCode") | |
| 399 | + .HasColumnType("INTEGER") | |
| 400 | + .HasColumnName("status_code"); | |
| 401 | + | |
| 402 | + b.Property<long>("WebhookId") | |
| 403 | + .HasColumnType("INTEGER") | |
| 404 | + .HasColumnName("webhook_id"); | |
| 405 | + | |
| 406 | + b.HasKey("Id"); | |
| 407 | + | |
| 408 | + b.HasIndex("PushEventId"); | |
| 409 | + | |
| 410 | + b.HasIndex("WebhookId", "PushEventId"); | |
| 411 | + | |
| 412 | + b.ToTable("webhook_deliveries"); | |
| 413 | + }); | |
| 414 | + | |
| 415 | + modelBuilder.Entity("Forge.Data.AccessToken", b => | |
| 416 | + { | |
| 417 | + b.HasOne("Forge.Data.User", "User") | |
| 418 | + .WithMany() | |
| 419 | + .HasForeignKey("UserId") | |
| 420 | + .OnDelete(DeleteBehavior.Cascade) | |
| 421 | + .IsRequired(); | |
| 422 | + | |
| 423 | + b.Navigation("User"); | |
| 424 | + }); | |
| 425 | + | |
| 426 | + modelBuilder.Entity("Forge.Data.BranchProtection", b => | |
| 427 | + { | |
| 428 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 429 | + .WithMany() | |
| 430 | + .HasForeignKey("RepoId") | |
| 431 | + .OnDelete(DeleteBehavior.Cascade) | |
| 432 | + .IsRequired(); | |
| 433 | + | |
| 434 | + b.Navigation("Repo"); | |
| 435 | + }); | |
| 436 | + | |
| 437 | + modelBuilder.Entity("Forge.Data.PullRequest", b => | |
| 438 | + { | |
| 439 | + b.HasOne("Forge.Data.User", "Author") | |
| 440 | + .WithMany() | |
| 441 | + .HasForeignKey("AuthorId") | |
| 442 | + .OnDelete(DeleteBehavior.Cascade) | |
| 443 | + .IsRequired(); | |
| 444 | + | |
| 445 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 446 | + .WithMany() | |
| 447 | + .HasForeignKey("RepoId") | |
| 448 | + .OnDelete(DeleteBehavior.Cascade) | |
| 449 | + .IsRequired(); | |
| 450 | + | |
| 451 | + b.Navigation("Author"); | |
| 452 | + | |
| 453 | + b.Navigation("Repo"); | |
| 454 | + }); | |
| 455 | + | |
| 456 | + modelBuilder.Entity("Forge.Data.PullRequestComment", b => | |
| 457 | + { | |
| 458 | + b.HasOne("Forge.Data.User", "Author") | |
| 459 | + .WithMany() | |
| 460 | + .HasForeignKey("AuthorId") | |
| 461 | + .OnDelete(DeleteBehavior.Cascade) | |
| 462 | + .IsRequired(); | |
| 463 | + | |
| 464 | + b.HasOne("Forge.Data.PullRequest", "PullRequest") | |
| 465 | + .WithMany() | |
| 466 | + .HasForeignKey("PullRequestId") | |
| 467 | + .OnDelete(DeleteBehavior.Cascade) | |
| 468 | + .IsRequired(); | |
| 469 | + | |
| 470 | + b.Navigation("Author"); | |
| 471 | + | |
| 472 | + b.Navigation("PullRequest"); | |
| 473 | + }); | |
| 474 | + | |
| 475 | + modelBuilder.Entity("Forge.Data.PushEvent", b => | |
| 476 | + { | |
| 477 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 478 | + .WithMany() | |
| 479 | + .HasForeignKey("RepoId") | |
| 480 | + .OnDelete(DeleteBehavior.Cascade) | |
| 481 | + .IsRequired(); | |
| 482 | + | |
| 483 | + b.Navigation("Repo"); | |
| 484 | + }); | |
| 485 | + | |
| 486 | + modelBuilder.Entity("Forge.Data.Repository", b => | |
| 487 | + { | |
| 488 | + b.HasOne("Forge.Data.User", "Owner") | |
| 489 | + .WithMany() | |
| 490 | + .HasForeignKey("OwnerId") | |
| 491 | + .OnDelete(DeleteBehavior.Cascade) | |
| 492 | + .IsRequired(); | |
| 493 | + | |
| 494 | + b.Navigation("Owner"); | |
| 495 | + }); | |
| 496 | + | |
| 497 | + modelBuilder.Entity("Forge.Data.Webhook", b => | |
| 498 | + { | |
| 499 | + b.HasOne("Forge.Data.Repository", "Repo") | |
| 500 | + .WithMany() | |
| 501 | + .HasForeignKey("RepoId") | |
| 502 | + .OnDelete(DeleteBehavior.Cascade) | |
| 503 | + .IsRequired(); | |
| 504 | + | |
| 505 | + b.Navigation("Repo"); | |
| 506 | + }); | |
| 507 | + | |
| 508 | + modelBuilder.Entity("Forge.Data.WebhookDelivery", b => | |
| 509 | + { | |
| 510 | + b.HasOne("Forge.Data.PushEvent", "PushEvent") | |
| 511 | + .WithMany() | |
| 512 | + .HasForeignKey("PushEventId") | |
| 513 | + .OnDelete(DeleteBehavior.Cascade); | |
| 514 | + | |
| 515 | + b.HasOne("Forge.Data.Webhook", "Webhook") | |
| 516 | + .WithMany() | |
| 517 | + .HasForeignKey("WebhookId") | |
| 518 | + .OnDelete(DeleteBehavior.Cascade) | |
| 519 | + .IsRequired(); | |
| 520 | + | |
| 521 | + b.Navigation("PushEvent"); | |
| 522 | + | |
| 523 | + b.Navigation("Webhook"); | |
| 524 | + }); | |
| 525 | +#pragma warning restore 612, 618 | |
| 526 | + } | |
| 527 | +} |
added forge/Features/Auth/AccountRules.cs +36 −0View file
| @@ -0,0 +1,36 @@ | ||
| 1 | +using System.Text.RegularExpressions; | |
| 2 | +using Forge.Localization; | |
| 3 | + | |
| 4 | +namespace Forge.Features.Auth; | |
| 5 | + | |
| 6 | +public static partial class AccountRules | |
| 7 | +{ | |
| 8 | + public const int MinPasswordLength = 8; | |
| 9 | + | |
| 10 | + /// <summary>Names that would collide with top-level routes.</summary> | |
| 11 | + private static readonly HashSet<string> Reserved = new(StringComparer.OrdinalIgnoreCase) | |
| 12 | + { | |
| 13 | + "login", "logout", "setup", "new", "settings", "status", "not-found", "error", "language", "lib", "api", | |
| 14 | + "admin", "assets", "static", "_framework", "_content", | |
| 15 | + }; | |
| 16 | + | |
| 17 | + /// <summary>Returns an English message (a translation key) for the user, or null when the username is acceptable.</summary> | |
| 18 | + public static string? ValidateUsername(string? username) | |
| 19 | + { | |
| 20 | + if (string.IsNullOrWhiteSpace(username) || !UsernamePattern().IsMatch(username)) | |
| 21 | + { | |
| 22 | + return Localizer.Key("A username may contain letters, digits, hyphens and underscores (1 to 39 characters) and must start with a letter or digit."); | |
| 23 | + } | |
| 24 | + | |
| 25 | + return Reserved.Contains(username) ? Localizer.Key("This username is reserved.") : null; | |
| 26 | + } | |
| 27 | + | |
| 28 | + /// <summary>Returns an English message template with {0} for <see cref="MinPasswordLength"/>, or null.</summary> | |
| 29 | + public static string? ValidatePassword(string? password) => | |
| 30 | + password is null || password.Length < MinPasswordLength | |
| 31 | + ? Localizer.Key("The password must be at least {0} characters long.") | |
| 32 | + : null; | |
| 33 | + | |
| 34 | + [GeneratedRegex(@"^[A-Za-z0-9][A-Za-z0-9_-]{0,38}\z")] | |
| 35 | + private static partial Regex UsernamePattern(); | |
| 36 | +} |
added forge/Features/Auth/CurrentUser.cs +64 −0View file
| @@ -0,0 +1,64 @@ | ||
| 1 | +using System.Globalization; | |
| 2 | +using System.Security.Claims; | |
| 3 | +using Forge.Data; | |
| 4 | +using Microsoft.AspNetCore.Authentication; | |
| 5 | +using Microsoft.AspNetCore.Authentication.Cookies; | |
| 6 | + | |
| 7 | +namespace Forge.Features.Auth; | |
| 8 | + | |
| 9 | +/// <summary>Who is asking: a user ID (null for anonymous) and whether the credential may write.</summary> | |
| 10 | +public readonly record struct Actor(long? UserId, bool MayWrite) | |
| 11 | +{ | |
| 12 | + public static Actor Anonymous => new(null, false); | |
| 13 | + public bool IsAnonymous => UserId is null; | |
| 14 | +} | |
| 15 | + | |
| 16 | +/// <summary>The signed-in user of the current web request, read from the auth cookie.</summary> | |
| 17 | +public sealed class CurrentUser(IHttpContextAccessor accessor) | |
| 18 | +{ | |
| 19 | + private ClaimsPrincipal? Principal => accessor.HttpContext?.User; | |
| 20 | + | |
| 21 | + public bool IsAuthenticated => UserId is not null; | |
| 22 | + | |
| 23 | + public long? UserId => | |
| 24 | + Principal?.Identity?.IsAuthenticated == true | |
| 25 | + && long.TryParse( | |
| 26 | + Principal.FindFirstValue(ClaimTypes.NameIdentifier), | |
| 27 | + NumberStyles.Integer, | |
| 28 | + CultureInfo.InvariantCulture, | |
| 29 | + out var id) | |
| 30 | + ? id | |
| 31 | + : null; | |
| 32 | + | |
| 33 | + public string? Username => IsAuthenticated ? Principal?.FindFirstValue(ClaimTypes.Name) : null; | |
| 34 | + | |
| 35 | + /// <summary>A browser session carries the user's full rights.</summary> | |
| 36 | + public Actor Actor => new(UserId, MayWrite: UserId is not null); | |
| 37 | + | |
| 38 | + public static ClaimsPrincipal CreatePrincipal(User user) | |
| 39 | + { | |
| 40 | + var identity = new ClaimsIdentity( | |
| 41 | + [ | |
| 42 | + new Claim(ClaimTypes.NameIdentifier, user.Id.ToString(CultureInfo.InvariantCulture)), | |
| 43 | + new Claim(ClaimTypes.Name, user.Username), | |
| 44 | + ], | |
| 45 | + CookieAuthenticationDefaults.AuthenticationScheme); | |
| 46 | + return new ClaimsPrincipal(identity); | |
| 47 | + } | |
| 48 | + | |
| 49 | + public static Task SignInAsync(HttpContext context, User user) => | |
| 50 | + context.SignInAsync( | |
| 51 | + CookieAuthenticationDefaults.AuthenticationScheme, | |
| 52 | + CreatePrincipal(user), | |
| 53 | + new AuthenticationProperties { IsPersistent = true }); | |
| 54 | + | |
| 55 | + /// <summary>Accepts only same-site relative paths, so a login link cannot bounce to another site.</summary> | |
| 56 | + public static string SafeReturnUrl(string? returnUrl) => | |
| 57 | + !string.IsNullOrEmpty(returnUrl) | |
| 58 | + && returnUrl[0] == '/' | |
| 59 | + && (returnUrl.Length == 1 || (returnUrl[1] != '/' && returnUrl[1] != '\\')) | |
| 60 | + && !returnUrl.Contains('\r') | |
| 61 | + && !returnUrl.Contains('\n') | |
| 62 | + ? returnUrl | |
| 63 | + : "/"; | |
| 64 | +} |
added forge/Features/Auth/Login.razor +82 −0View file
| @@ -0,0 +1,82 @@ | ||
| 1 | +@page "/login" | |
| 2 | +@attribute [EnableRateLimiting(ForgeApp.LoginRateLimit)] | |
| 3 | +@using Microsoft.AspNetCore.Identity | |
| 4 | +@inject ForgeDb Db | |
| 5 | +@inject IPasswordHasher<User> Hasher | |
| 6 | +@inject IHttpContextAccessor Http | |
| 7 | +@inject NavigationManager Nav | |
| 8 | + | |
| 9 | +<PageTitle>@T["Sign in"] · Forge</PageTitle> | |
| 10 | + | |
| 11 | +<section class="narrow"> | |
| 12 | + <div class="auth-logo"><Icon Name="logo" Size="36" Class="logo-mark"/></div> | |
| 13 | + <h1>@T["Sign in"]</h1> | |
| 14 | + | |
| 15 | + @if (_error is not null) | |
| 16 | + { | |
| 17 | + <p class="alert error">@_error</p> | |
| 18 | + } | |
| 19 | + | |
| 20 | + <form method="post" @formname="login" @onsubmit="SignInAsync" class="form"> | |
| 21 | + <AntiforgeryToken/> | |
| 22 | + <label> | |
| 23 | + @T["Username"] | |
| 24 | + <input name="Username" value="@Username" required autocomplete="username" autofocus/> | |
| 25 | + </label> | |
| 26 | + <label> | |
| 27 | + @T["Password"] | |
| 28 | + <input name="Password" type="password" required autocomplete="current-password"/> | |
| 29 | + </label> | |
| 30 | + <button type="submit" class="button primary">@T["Sign in"]</button> | |
| 31 | + </form> | |
| 32 | +</section> | |
| 33 | + | |
| 34 | +@code { | |
| 35 | + [SupplyParameterFromForm] | |
| 36 | + private string? Username { get; set; } | |
| 37 | + | |
| 38 | + [SupplyParameterFromForm] | |
| 39 | + private string? Password { get; set; } | |
| 40 | + | |
| 41 | + [SupplyParameterFromQuery(Name = "returnUrl")] | |
| 42 | + private string? ReturnUrl { get; set; } | |
| 43 | + | |
| 44 | + private string? _error; | |
| 45 | + | |
| 46 | + protected override async Task OnInitializedAsync() | |
| 47 | + { | |
| 48 | + if (!await Db.Users.AnyAsync()) | |
| 49 | + { | |
| 50 | + Nav.NavigateTo("/setup"); | |
| 51 | + } | |
| 52 | + } | |
| 53 | + | |
| 54 | + private async Task SignInAsync() | |
| 55 | + { | |
| 56 | + var username = Username?.Trim() ?? ""; | |
| 57 | + var user = await Db.Users.FirstOrDefaultAsync(u => u.Username == username); | |
| 58 | + | |
| 59 | + // Hash even when the user does not exist, so the response time does not reveal which names are real. | |
| 60 | + var probe = user ?? new User { Username = "", DisplayName = "" }; | |
| 61 | + var hash = user?.PasswordHash ?? DummyHash.Value; | |
| 62 | + var result = Hasher.VerifyHashedPassword(probe, hash, Password ?? ""); | |
| 63 | + | |
| 64 | + if (user is null || result == PasswordVerificationResult.Failed) | |
| 65 | + { | |
| 66 | + _error = T["Wrong username or password."]; | |
| 67 | + return; | |
| 68 | + } | |
| 69 | + | |
| 70 | + if (result == PasswordVerificationResult.SuccessRehashNeeded) | |
| 71 | + { | |
| 72 | + user.PasswordHash = Hasher.HashPassword(user, Password!); | |
| 73 | + await Db.SaveChangesAsync(); | |
| 74 | + } | |
| 75 | + | |
| 76 | + await CurrentUser.SignInAsync(Http.HttpContext!, user); | |
| 77 | + Nav.NavigateTo(CurrentUser.SafeReturnUrl(ReturnUrl)); | |
| 78 | + } | |
| 79 | + | |
| 80 | + private static readonly Lazy<string> DummyHash = new(() => | |
| 81 | + new PasswordHasher<User>().HashPassword(new User { Username = "", DisplayName = "" }, Guid.NewGuid().ToString())); | |
| 82 | +} |
added forge/Features/Auth/RepoAccess.cs +22 −0View file
| @@ -0,0 +1,22 @@ | ||
| 1 | +using Forge.Data; | |
| 2 | + | |
| 3 | +namespace Forge.Features.Auth; | |
| 4 | + | |
| 5 | +/// <summary> | |
| 6 | +/// The only place that decides who may do what with a repository. | |
| 7 | +/// Callers turn "cannot read" into 404 (never 403), so a private repo is indistinguishable from a missing one. | |
| 8 | +/// </summary> | |
| 9 | +public static class RepoAccess | |
| 10 | +{ | |
| 11 | + public static bool CanRead(Repository repo, Actor actor) => | |
| 12 | + repo.Visibility == Visibility.Public || IsOwner(repo, actor); | |
| 13 | + | |
| 14 | + public static bool CanWrite(Repository repo, Actor actor) => | |
| 15 | + IsOwner(repo, actor) && actor.MayWrite; | |
| 16 | + | |
| 17 | + /// <summary>Settings, webhooks and deletion. Same rule as writing today; kept separate so it can diverge.</summary> | |
| 18 | + public static bool CanAdmin(Repository repo, Actor actor) => CanWrite(repo, actor); | |
| 19 | + | |
| 20 | + private static bool IsOwner(Repository repo, Actor actor) => | |
| 21 | + actor.UserId is { } id && id == repo.OwnerId; | |
| 22 | +} |
added forge/Features/Auth/Setup.razor +119 −0View file
| @@ -0,0 +1,119 @@ | ||
| 1 | +@page "/setup" | |
| 2 | +@attribute [EnableRateLimiting(ForgeApp.LoginRateLimit)] | |
| 3 | +@using Microsoft.AspNetCore.Identity | |
| 4 | +@inject ForgeDb Db | |
| 5 | +@inject IPasswordHasher<User> Hasher | |
| 6 | +@inject IHttpContextAccessor Http | |
| 7 | +@inject NavigationManager Nav | |
| 8 | + | |
| 9 | +@if (_open) | |
| 10 | +{ | |
| 11 | + <PageTitle>@T["First run"] · Forge</PageTitle> | |
| 12 | + | |
| 13 | + <section class="narrow"> | |
| 14 | + <div class="auth-logo"><Icon Name="logo" Size="36" Class="logo-mark"/></div> | |
| 15 | + <h1>@T["Welcome to Forge"]</h1> | |
| 16 | + <p class="muted">@T["Create your account. This page then closes for good."]</p> | |
| 17 | + | |
| 18 | + @if (_error is not null) | |
| 19 | + { | |
| 20 | + <p class="alert error">@_error</p> | |
| 21 | + } | |
| 22 | + | |
| 23 | + <form method="post" @formname="setup" @onsubmit="CreateAsync" class="form"> | |
| 24 | + <AntiforgeryToken/> | |
| 25 | + <label> | |
| 26 | + @T["Username"] | |
| 27 | + <input name="Username" value="@Username" required maxlength="39" autocomplete="username" autofocus/> | |
| 28 | + <small class="muted">@T["It becomes part of your repository addresses."]</small> | |
| 29 | + </label> | |
| 30 | + <label> | |
| 31 | + @T["Display name"] | |
| 32 | + <input name="DisplayName" value="@DisplayName" maxlength="100" autocomplete="name"/> | |
| 33 | + </label> | |
| 34 | + <label> | |
| 35 | + @T["Password"] | |
| 36 | + <input name="Password" type="password" required minlength="@AccountRules.MinPasswordLength" autocomplete="new-password"/> | |
| 37 | + </label> | |
| 38 | + <label> | |
| 39 | + @T["Repeat password"] | |
| 40 | + <input name="PasswordRepeat" type="password" required autocomplete="new-password"/> | |
| 41 | + </label> | |
| 42 | + <button type="submit" class="button primary">@T["Create account"]</button> | |
| 43 | + </form> | |
| 44 | + </section> | |
| 45 | +} | |
| 46 | + | |
| 47 | +@code { | |
| 48 | + [SupplyParameterFromForm] | |
| 49 | + private string? Username { get; set; } | |
| 50 | + | |
| 51 | + [SupplyParameterFromForm] | |
| 52 | + private string? DisplayName { get; set; } | |
| 53 | + | |
| 54 | + [SupplyParameterFromForm] | |
| 55 | + private string? Password { get; set; } | |
| 56 | + | |
| 57 | + [SupplyParameterFromForm] | |
| 58 | + private string? PasswordRepeat { get; set; } | |
| 59 | + | |
| 60 | + private bool _open; | |
| 61 | + private string? _error; | |
| 62 | + | |
| 63 | + protected override async Task OnInitializedAsync() | |
| 64 | + { | |
| 65 | + // Setup exists only while there is no account at all. | |
| 66 | + if (await Db.Users.AnyAsync()) | |
| 67 | + { | |
| 68 | + Nav.NotFound(); | |
| 69 | + return; | |
| 70 | + } | |
| 71 | + | |
| 72 | + _open = true; | |
| 73 | + } | |
| 74 | + | |
| 75 | + private async Task CreateAsync() | |
| 76 | + { | |
| 77 | + if (!_open) | |
| 78 | + { | |
| 79 | + return; | |
| 80 | + } | |
| 81 | + | |
| 82 | + var username = Username?.Trim(); | |
| 83 | + var invalid = AccountRules.ValidateUsername(username) | |
| 84 | + ?? AccountRules.ValidatePassword(Password) | |
| 85 | + ?? (Password != PasswordRepeat ? Localizer.Key("The passwords do not match.") : null); | |
| 86 | + if (invalid is not null) | |
| 87 | + { | |
| 88 | + // The rules return English templates; {0}, where present, is the minimum password length. | |
| 89 | + _error = T[invalid, AccountRules.MinPasswordLength]; | |
| 90 | + return; | |
| 91 | + } | |
| 92 | + | |
| 93 | + var user = new User | |
| 94 | + { | |
| 95 | + Username = username!, | |
| 96 | + DisplayName = string.IsNullOrWhiteSpace(DisplayName) ? username! : DisplayName.Trim(), | |
| 97 | + CreatedAt = DateTime.UtcNow, | |
| 98 | + }; | |
| 99 | + user.PasswordHash = Hasher.HashPassword(user, Password!); | |
| 100 | + | |
| 101 | + // The check and the insert share one write transaction, so two simultaneous setups cannot both win. | |
| 102 | + await using (var transaction = await Db.Database.BeginTransactionAsync()) | |
| 103 | + { | |
| 104 | + if (await Db.Users.AnyAsync()) | |
| 105 | + { | |
| 106 | + _open = false; | |
| 107 | + Nav.NotFound(); | |
| 108 | + return; | |
| 109 | + } | |
| 110 | + | |
| 111 | + Db.Users.Add(user); | |
| 112 | + await Db.SaveChangesAsync(); | |
| 113 | + await transaction.CommitAsync(); | |
| 114 | + } | |
| 115 | + | |
| 116 | + await CurrentUser.SignInAsync(Http.HttpContext!, user); | |
| 117 | + Nav.NavigateTo("/"); | |
| 118 | + } | |
| 119 | +} |
added forge/Features/Auth/TokenService.cs +105 −0View file
| @@ -0,0 +1,105 @@ | ||
| 1 | +using System.Collections.Concurrent; | |
| 2 | +using System.Security.Cryptography; | |
| 3 | +using System.Text; | |
| 4 | +using Forge.Data; | |
| 5 | +using Microsoft.EntityFrameworkCore; | |
| 6 | + | |
| 7 | +namespace Forge.Features.Auth; | |
| 8 | + | |
| 9 | +public sealed class TokenService(ForgeDb db) | |
| 10 | +{ | |
| 11 | + public const string Prefix = "forge_"; | |
| 12 | + | |
| 13 | + /// <summary>Creates a token and returns its plaintext. This is the only moment the plaintext exists.</summary> | |
| 14 | + public async Task<(AccessToken Token, string Plaintext)> CreateAsync( | |
| 15 | + long userId, | |
| 16 | + string name, | |
| 17 | + bool canWrite, | |
| 18 | + DateTime? expiresAt, | |
| 19 | + CancellationToken ct = default) | |
| 20 | + { | |
| 21 | + var plaintext = Prefix + Convert.ToHexStringLower(RandomNumberGenerator.GetBytes(32)); | |
| 22 | + var token = new AccessToken | |
| 23 | + { | |
| 24 | + UserId = userId, | |
| 25 | + Name = name, | |
| 26 | + TokenHash = Hash(plaintext), | |
| 27 | + CanWrite = canWrite, | |
| 28 | + CreatedAt = DateTime.UtcNow, | |
| 29 | + ExpiresAt = expiresAt, | |
| 30 | + }; | |
| 31 | + db.AccessTokens.Add(token); | |
| 32 | + await db.SaveChangesAsync(ct); | |
| 33 | + return (token, plaintext); | |
| 34 | + } | |
| 35 | + | |
| 36 | + /// <summary>Returns the token row for a presented plaintext, or null when it is unknown or expired.</summary> | |
| 37 | + public async Task<AccessToken?> ValidateAsync(string? plaintext, CancellationToken ct = default) | |
| 38 | + { | |
| 39 | + if (string.IsNullOrEmpty(plaintext) || plaintext.Length > 200) | |
| 40 | + { | |
| 41 | + return null; | |
| 42 | + } | |
| 43 | + | |
| 44 | + var hash = Hash(plaintext); | |
| 45 | + var token = await db.AccessTokens.FirstOrDefaultAsync(t => t.TokenHash == hash, ct); | |
| 46 | + if (token is null || (token.ExpiresAt is { } expires && expires <= DateTime.UtcNow)) | |
| 47 | + { | |
| 48 | + return null; | |
| 49 | + } | |
| 50 | + | |
| 51 | + // One clone is several requests; a write per minute is plenty for "last used". | |
| 52 | + var now = DateTime.UtcNow; | |
| 53 | + if (token.LastUsedAt is null || now - token.LastUsedAt.Value > TimeSpan.FromMinutes(1)) | |
| 54 | + { | |
| 55 | + token.LastUsedAt = now; | |
| 56 | + await db.SaveChangesAsync(ct); | |
| 57 | + } | |
| 58 | + | |
| 59 | + return token; | |
| 60 | + } | |
| 61 | + | |
| 62 | + public static string Hash(string plaintext) => | |
| 63 | + Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(plaintext))); | |
| 64 | +} | |
| 65 | + | |
| 66 | +/// <summary> | |
| 67 | +/// Throttles Basic auth on the git endpoints by counting failed attempts per client address. | |
| 68 | +/// Counting failures (rather than all requests) leaves normal clones and pushes untouched. | |
| 69 | +/// </summary> | |
| 70 | +public sealed class AuthFailureLimiter(TimeProvider time) | |
| 71 | +{ | |
| 72 | + public const int MaxFailures = 10; | |
| 73 | + public static readonly TimeSpan Window = TimeSpan.FromMinutes(5); | |
| 74 | + | |
| 75 | + private readonly ConcurrentDictionary<string, Entry> _entries = new(); | |
| 76 | + | |
| 77 | + public bool IsBlocked(string client) => | |
| 78 | + _entries.TryGetValue(client, out var entry) | |
| 79 | + && entry.WindowStart + Window > time.GetUtcNow() | |
| 80 | + && entry.Failures >= MaxFailures; | |
| 81 | + | |
| 82 | + public void RecordFailure(string client) | |
| 83 | + { | |
| 84 | + var now = time.GetUtcNow(); | |
| 85 | + _entries.AddOrUpdate( | |
| 86 | + client, | |
| 87 | + _ => new Entry(now, 1), | |
| 88 | + (_, existing) => existing.WindowStart + Window > now | |
| 89 | + ? existing with { Failures = existing.Failures + 1 } | |
| 90 | + : new Entry(now, 1)); | |
| 91 | + | |
| 92 | + if (_entries.Count > 10_000) | |
| 93 | + { | |
| 94 | + foreach (var (key, entry) in _entries) | |
| 95 | + { | |
| 96 | + if (entry.WindowStart + Window <= now) | |
| 97 | + { | |
| 98 | + _entries.TryRemove(key, out _); | |
| 99 | + } | |
| 100 | + } | |
| 101 | + } | |
| 102 | + } | |
| 103 | + | |
| 104 | + private sealed record Entry(DateTimeOffset WindowStart, int Failures); | |
| 105 | +} |
added forge/Features/Auth/Tokens.razor +178 −0View file
| @@ -0,0 +1,178 @@ | ||
| 1 | +@page "/settings/tokens" | |
| 2 | +@attribute [Authorize] | |
| 3 | +@inject ForgeDb Db | |
| 4 | +@inject TokenService TokenService | |
| 5 | +@inject CurrentUser Me | |
| 6 | + | |
| 7 | +<PageTitle>@T["Access tokens"] · Forge</PageTitle> | |
| 8 | + | |
| 9 | +<h1>@T["Access tokens"]</h1> | |
| 10 | +<p class="muted">@T.Html("A token is the password for <code>git clone</code> and <code>git push</code> over HTTPS. Any username works.")</p> | |
| 11 | + | |
| 12 | +@if (_created is not null) | |
| 13 | +{ | |
| 14 | + <div class="alert success"> | |
| 15 | + <p><strong>@T["The token is created. Copy it now, it will not be shown again."]</strong></p> | |
| 16 | + <CloneBox Url="@_created"/> | |
| 17 | + </div> | |
| 18 | +} | |
| 19 | + | |
| 20 | +@if (_error is not null) | |
| 21 | +{ | |
| 22 | + <p class="alert error">@_error</p> | |
| 23 | +} | |
| 24 | + | |
| 25 | +<section class="card"> | |
| 26 | + <h2>@T["New token"]</h2> | |
| 27 | + <form method="post" @formname="create-token" @onsubmit="CreateAsync" class="form"> | |
| 28 | + <AntiforgeryToken/> | |
| 29 | + <label> | |
| 30 | + @T["Name"] | |
| 31 | + <input name="Name" value="@Name" required maxlength="100" placeholder="@T["e.g. laptop"]"/> | |
| 32 | + </label> | |
| 33 | + <label> | |
| 34 | + @T["Permission"] | |
| 35 | + <select name="Scope"> | |
| 36 | + <option value="read">@T["Read only (clone, fetch)"]</option> | |
| 37 | + <option value="write">@T["Read and write (push)"]</option> | |
| 38 | + </select> | |
| 39 | + </label> | |
| 40 | + <label> | |
| 41 | + @T["Expires"] | |
| 42 | + <select name="ExpiresInDays"> | |
| 43 | + <option value="30">@T["30 days"]</option> | |
| 44 | + <option value="90" selected>@T["90 days"]</option> | |
| 45 | + <option value="365">@T["1 year"]</option> | |
| 46 | + <option value="0">@T["No expiry"]</option> | |
| 47 | + </select> | |
| 48 | + </label> | |
| 49 | + <button type="submit" class="button primary">@T["Create token"]</button> | |
| 50 | + </form> | |
| 51 | +</section> | |
| 52 | + | |
| 53 | +<section> | |
| 54 | + <h2>@T["Existing tokens"]</h2> | |
| 55 | + @if (_tokens.Count == 0) | |
| 56 | + { | |
| 57 | + <p class="muted">@T["You have no tokens yet."]</p> | |
| 58 | + } | |
| 59 | + else | |
| 60 | + { | |
| 61 | + <form method="post" @formname="revoke-token" @onsubmit="RevokeAsync"> | |
| 62 | + <AntiforgeryToken/> | |
| 63 | + <table class="table"> | |
| 64 | + <thead> | |
| 65 | + <tr> | |
| 66 | + <th>@T["Name"]</th> | |
| 67 | + <th>@T["Permission"]</th> | |
| 68 | + <th>@T["Created"]</th> | |
| 69 | + <th>@T["Last used"]</th> | |
| 70 | + <th>@T["Valid until"]</th> | |
| 71 | + <th></th> | |
| 72 | + </tr> | |
| 73 | + </thead> | |
| 74 | + <tbody> | |
| 75 | + @foreach (var token in _tokens) | |
| 76 | + { | |
| 77 | + <tr> | |
| 78 | + <td>@token.Name</td> | |
| 79 | + <td>@(token.CanWrite ? T["read and write"] : T["read only"])</td> | |
| 80 | + <td><TimeAgo Value="Format.Utc(token.CreatedAt)"/></td> | |
| 81 | + <td> | |
| 82 | + @if (token.LastUsedAt is { } used) | |
| 83 | + { | |
| 84 | + <TimeAgo Value="Format.Utc(used)"/> | |
| 85 | + } | |
| 86 | + else | |
| 87 | + { | |
| 88 | + <span class="muted">@T["never"]</span> | |
| 89 | + } | |
| 90 | + </td> | |
| 91 | + <td> | |
| 92 | + @if (token.ExpiresAt is not { } expires) | |
| 93 | + { | |
| 94 | + <span class="muted">@T["no expiry"]</span> | |
| 95 | + } | |
| 96 | + else if (expires <= DateTime.UtcNow) | |
| 97 | + { | |
| 98 | + <span class="danger-text">@T["expired {0}", Format.ExactTime(Format.Utc(expires))]</span> | |
| 99 | + } | |
| 100 | + else | |
| 101 | + { | |
| 102 | + <span>@Format.ExactTime(Format.Utc(expires))</span> | |
| 103 | + } | |
| 104 | + </td> | |
| 105 | + <td class="right"> | |
| 106 | + <button type="submit" name="TokenId" value="@token.Id" class="button danger small">@T["Revoke"]</button> | |
| 107 | + </td> | |
| 108 | + </tr> | |
| 109 | + } | |
| 110 | + </tbody> | |
| 111 | + </table> | |
| 112 | + </form> | |
| 113 | + } | |
| 114 | +</section> | |
| 115 | + | |
| 116 | +@code { | |
| 117 | + [SupplyParameterFromForm(FormName = "create-token")] | |
| 118 | + private string? Name { get; set; } | |
| 119 | + | |
| 120 | + [SupplyParameterFromForm(FormName = "create-token")] | |
| 121 | + private string? Scope { get; set; } | |
| 122 | + | |
| 123 | + [SupplyParameterFromForm(FormName = "create-token")] | |
| 124 | + private int? ExpiresInDays { get; set; } | |
| 125 | + | |
| 126 | + [SupplyParameterFromForm(FormName = "revoke-token")] | |
| 127 | + private long? TokenId { get; set; } | |
| 128 | + | |
| 129 | + private List<AccessToken> _tokens = []; | |
| 130 | + private string? _created; | |
| 131 | + private string? _error; | |
| 132 | + | |
| 133 | + protected override Task OnInitializedAsync() => LoadAsync(); | |
| 134 | + | |
| 135 | + private async Task LoadAsync() | |
| 136 | + { | |
| 137 | + var userId = Me.UserId; | |
| 138 | + _tokens = await Db.AccessTokens | |
| 139 | + .Where(t => t.UserId == userId) | |
| 140 | + .OrderByDescending(t => t.CreatedAt) | |
| 141 | + .ToListAsync(); | |
| 142 | + } | |
| 143 | + | |
| 144 | + private async Task CreateAsync() | |
| 145 | + { | |
| 146 | + var name = Name?.Trim(); | |
| 147 | + if (string.IsNullOrEmpty(name) || name.Length > 100) | |
| 148 | + { | |
| 149 | + _error = T["Enter a token name (at most 100 characters)."]; | |
| 150 | + return; | |
| 151 | + } | |
| 152 | + | |
| 153 | + if (ExpiresInDays is not (0 or 30 or 90 or 365)) | |
| 154 | + { | |
| 155 | + _error = T["Choose an expiry from the list."]; | |
| 156 | + return; | |
| 157 | + } | |
| 158 | + | |
| 159 | + DateTime? expiresAt = ExpiresInDays == 0 ? null : DateTime.UtcNow.AddDays(ExpiresInDays.Value); | |
| 160 | + var (_, plaintext) = await TokenService.CreateAsync(Me.UserId!.Value, name, Scope == "write", expiresAt); | |
| 161 | + _created = plaintext; | |
| 162 | + Name = null; | |
| 163 | + await LoadAsync(); | |
| 164 | + } | |
| 165 | + | |
| 166 | + private async Task RevokeAsync() | |
| 167 | + { | |
| 168 | + var userId = Me.UserId; | |
| 169 | + var token = await Db.AccessTokens.FirstOrDefaultAsync(t => t.Id == TokenId && t.UserId == userId); | |
| 170 | + if (token is not null) | |
| 171 | + { | |
| 172 | + Db.AccessTokens.Remove(token); | |
| 173 | + await Db.SaveChangesAsync(); | |
| 174 | + } | |
| 175 | + | |
| 176 | + await LoadAsync(); | |
| 177 | + } | |
| 178 | +} |
added forge/Features/Browse/Activity.razor +168 −0View file
| @@ -0,0 +1,168 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/activity" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject RepoInsights Insights | |
| 4 | +@inject TimeProvider Clock | |
| 5 | + | |
| 6 | +@if (Repository is not null && _activity is not null) | |
| 7 | +{ | |
| 8 | + <PageTitle>@T["Activity"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 9 | + | |
| 10 | + <RepoHeader Repository="Repository" Active="activity" IsOwner="IsOwner"/> | |
| 11 | + | |
| 12 | + <p class="muted activity-scope"> | |
| 13 | + <Icon Name="branch" Size="14"/> @T["Activity on {0}", _branch] | |
| 14 | + @if (_activity.Truncated) | |
| 15 | + { | |
| 16 | + <span> · @T["Only the newest {0} commits are counted.", RepoInsights.MaxActivityCommits.ToString("N0", CultureInfo.CurrentCulture)]</span> | |
| 17 | + } | |
| 18 | + </p> | |
| 19 | + | |
| 20 | + <dl class="stat-tiles"> | |
| 21 | + <div class="stat-tile"> | |
| 22 | + <dt>@T["Commits"]</dt> | |
| 23 | + <dd>@Number(_activity.Commits)</dd> | |
| 24 | + </div> | |
| 25 | + <div class="stat-tile"> | |
| 26 | + <dt>@T["Contributors"]</dt> | |
| 27 | + <dd>@Number(_activity.Contributors.Count)</dd> | |
| 28 | + </div> | |
| 29 | + <div class="stat-tile"> | |
| 30 | + <dt>@T["Commits in the last 30 days"]</dt> | |
| 31 | + <dd>@Number(_recent)</dd> | |
| 32 | + </div> | |
| 33 | + <div class="stat-tile"> | |
| 34 | + <dt>@T["First commit"]</dt> | |
| 35 | + <dd class="stat-date">@_first.ToString("d MMM yyyy", CultureInfo.CurrentCulture)</dd> | |
| 36 | + </div> | |
| 37 | + </dl> | |
| 38 | + | |
| 39 | + <section class="card"> | |
| 40 | + <h2>@T["Commits per week"]</h2> | |
| 41 | + <p class="muted small chart-sub">@T["The last 52 weeks, {0} in total", T.Plural(_weeks.Sum(w => w.Count), "{0} commit", "{0} commits")]</p> | |
| 42 | + <div class="chart-scroll"> | |
| 43 | + @* One series, so no legend: the heading names it. Every week has a tooltip on a full-height hit area. *@ | |
| 44 | + <svg class="week-chart" viewBox="0 0 @ChartWidth @ChartHeight" role="img" aria-label="@T["Commits per week"]"> | |
| 45 | + <line class="chart-grid" x1="@Left" x2="@ChartWidth" y1="@Top" y2="@Top"/> | |
| 46 | + <line class="chart-grid" x1="@Left" x2="@ChartWidth" y1="@(Top + PlotHeight / 2)" y2="@(Top + PlotHeight / 2)"/> | |
| 47 | + <line class="chart-axis" x1="@Left" x2="@ChartWidth" y1="@Baseline" y2="@Baseline"/> | |
| 48 | + <text class="chart-label" x="@(Left - 6)" y="@(Top + 4)" text-anchor="end">@_scaleMax</text> | |
| 49 | + <text class="chart-label" x="@(Left - 6)" y="@(Top + PlotHeight / 2 + 4)" text-anchor="end">@(_scaleMax / 2)</text> | |
| 50 | + <text class="chart-label" x="@(Left - 6)" y="@(Baseline + 4)" text-anchor="end">0</text> | |
| 51 | + @for (var i = 0; i < _weeks.Count; i++) | |
| 52 | + { | |
| 53 | + var week = _weeks[i]; | |
| 54 | + var x = Left + i * Step + 2; | |
| 55 | + var height = week.Count == 0 ? 0 : Math.Max(2.0, (double)week.Count / _scaleMax * PlotHeight); | |
| 56 | + <g class="week"> | |
| 57 | + <title>@T["Week of {0}", week.Start.ToString("d MMM yyyy", CultureInfo.CurrentCulture)]: @T.Plural(week.Count, "{0} commit", "{0} commits")</title> | |
| 58 | + <rect class="week-hit" x="@(x - 2)" y="@Top" width="@Step" height="@PlotHeight"/> | |
| 59 | + @if (week.Count > 0) | |
| 60 | + { | |
| 61 | + <rect class="week-bar" x="@x" y="@Coordinate(Baseline - height)" width="@BarWidth" height="@Coordinate(height)" rx="2"/> | |
| 62 | + } | |
| 63 | + </g> | |
| 64 | + @if (i > 0 && week.Start.Month != _weeks[i - 1].Start.Month && i < _weeks.Count - 2) | |
| 65 | + { | |
| 66 | + @* Inside a <g>: directly in a code block Razor would take <text> for its own text tag. *@ | |
| 67 | + <g><text class="chart-label" x="@x" y="@(Baseline + 16)">@week.Start.ToString("MMM", CultureInfo.CurrentCulture)</text></g> | |
| 68 | + } | |
| 69 | + } | |
| 70 | + </svg> | |
| 71 | + </div> | |
| 72 | + </section> | |
| 73 | + | |
| 74 | + <h2 class="section-title">@T["Contributors"] <Counter Value="_activity.Contributors.Count"/></h2> | |
| 75 | + <ol class="contributor-list"> | |
| 76 | + @foreach (var person in _activity.Contributors.Take(MaxContributors)) | |
| 77 | + { | |
| 78 | + <li class="contributor"> | |
| 79 | + <Avatar Name="@person.Name" Size="md"/> | |
| 80 | + <div class="contributor-main"> | |
| 81 | + <strong>@person.Name</strong> | |
| 82 | + <div class="muted small">@T["Last commit"] <TimeAgo Value="person.Last"/></div> | |
| 83 | + </div> | |
| 84 | + <div class="contributor-share"> | |
| 85 | + <span class="small">@T.Plural(person.Commits, "{0} commit", "{0} commits")</span> | |
| 86 | + <svg class="share-bar" viewBox="0 0 100 6" preserveAspectRatio="none" width="100%" height="6" aria-hidden="true"> | |
| 87 | + <rect x="0" y="0" height="6" width="@Coordinate(100.0 * person.Commits / _activity.Commits)"/> | |
| 88 | + </svg> | |
| 89 | + </div> | |
| 90 | + </li> | |
| 91 | + } | |
| 92 | + </ol> | |
| 93 | + @if (_activity.Contributors.Count > MaxContributors) | |
| 94 | + { | |
| 95 | + <p class="muted small">@T["Only the first {0} contributors are shown.", MaxContributors]</p> | |
| 96 | + } | |
| 97 | +} | |
| 98 | + | |
| 99 | +@code { | |
| 100 | + private const int WeekCount = 52; | |
| 101 | + private const int MaxContributors = 100; | |
| 102 | + | |
| 103 | + // Chart geometry in SVG user units. | |
| 104 | + private const int Left = 34; | |
| 105 | + private const int Top = 8; | |
| 106 | + private const int PlotHeight = 120; | |
| 107 | + private const int Step = 14; | |
| 108 | + private const int BarWidth = 10; | |
| 109 | + private const int Baseline = Top + PlotHeight; | |
| 110 | + private const int ChartWidth = Left + WeekCount * Step; | |
| 111 | + private const int ChartHeight = Baseline + 24; | |
| 112 | + | |
| 113 | + private sealed record Week(DateOnly Start, int Count); | |
| 114 | + | |
| 115 | + private RepoActivity? _activity; | |
| 116 | + private string _branch = ""; | |
| 117 | + private List<Week> _weeks = []; | |
| 118 | + private int _scaleMax = 4; | |
| 119 | + private int _recent; | |
| 120 | + private DateTimeOffset _first; | |
| 121 | + | |
| 122 | + private static string Number(int value) => value.ToString("N0", CultureInfo.CurrentCulture); | |
| 123 | + | |
| 124 | + private static string Coordinate(double value) => value.ToString("0.##", CultureInfo.InvariantCulture); | |
| 125 | + | |
| 126 | + protected override async Task OnInitializedAsync() | |
| 127 | + { | |
| 128 | + if (!await LoadRepoAsync()) | |
| 129 | + { | |
| 130 | + return; | |
| 131 | + } | |
| 132 | + | |
| 133 | + var repo = Repository!; | |
| 134 | + var refs = await Git.ListRefsAsync(RepoPath); | |
| 135 | + var branch = refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == repo.DefaultBranch) | |
| 136 | + ?? refs.FirstOrDefault(r => r.Kind == RefKind.Branch); | |
| 137 | + if (branch is null) | |
| 138 | + { | |
| 139 | + Redirect(Urls.Repo(repo)); | |
| 140 | + return; | |
| 141 | + } | |
| 142 | + | |
| 143 | + _branch = branch.Name; | |
| 144 | + var activity = await Insights.GetActivityAsync(RepoPath, branch.TargetSha); | |
| 145 | + _first = activity.Contributors.Count == 0 ? default : activity.Contributors.Min(c => c.First); | |
| 146 | + | |
| 147 | + // Weeks run Monday to Sunday (UTC); the last one is the current week. | |
| 148 | + var today = DateOnly.FromDateTime(Clock.GetUtcNow().UtcDateTime); | |
| 149 | + var thisMonday = today.AddDays(-(((int)today.DayOfWeek + 6) % 7)); | |
| 150 | + for (var i = WeekCount - 1; i >= 0; i--) | |
| 151 | + { | |
| 152 | + var start = thisMonday.AddDays(-7 * i); | |
| 153 | + var count = 0; | |
| 154 | + for (var day = 0; day < 7; day++) | |
| 155 | + { | |
| 156 | + count += activity.CommitsByDay.GetValueOrDefault(start.AddDays(day)); | |
| 157 | + } | |
| 158 | + | |
| 159 | + _weeks.Add(new Week(start, count)); | |
| 160 | + } | |
| 161 | + | |
| 162 | + // An even maximum, so the half-way grid line has a whole-number label. | |
| 163 | + var max = Math.Max(4, _weeks.Max(w => w.Count)); | |
| 164 | + _scaleMax = max + max % 2; | |
| 165 | + _recent = activity.CommitsByDay.Where(p => p.Key > today.AddDays(-30)).Sum(p => p.Value); | |
| 166 | + _activity = activity; | |
| 167 | + } | |
| 168 | +} |
added forge/Features/Browse/Blob.razor +193 −0View file
| @@ -0,0 +1,193 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/blob/{*RefAndPath}" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject ContentCache Cache | |
| 4 | +@inject MarkdownRenderer Markdown | |
| 5 | + | |
| 6 | +@if (Repository is not null && _resolved is not null && _entry is not null) | |
| 7 | +{ | |
| 8 | + <PageTitle>@_resolved.Path · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 9 | + @if (_text is not null && _language is not null) | |
| 10 | + { | |
| 11 | + @* Syntax highlighting is loaded on file pages only, and only from this server. *@ | |
| 12 | + <HighlightAssets/> | |
| 13 | + } | |
| 14 | + | |
| 15 | + <RepoHeader Repository="Repository" Active="code" IsOwner="IsOwner"/> | |
| 16 | + | |
| 17 | + <div class="toolbar"> | |
| 18 | + <RefSwitcher Refs="_refs" Current="@_resolved.Name" CurrentKind="_resolved.Kind" | |
| 19 | + UrlFor="@(name => Urls.Blob(Repository, name, _resolved.Path))"/> | |
| 20 | + <Breadcrumbs Repository="Repository" RefName="@_resolved.Name" Path="@_resolved.Path"/> | |
| 21 | + </div> | |
| 22 | + | |
| 23 | + <div class="file-head"> | |
| 24 | + <span class="file-info"> | |
| 25 | + <Icon Name="file"/> | |
| 26 | + <strong class="file-name">@_entry.Name</strong> | |
| 27 | + <span class="muted small"> | |
| 28 | + @Format.Size(_size) | |
| 29 | + @if (_text is not null) | |
| 30 | + { | |
| 31 | + <span> · @T.Plural(_lineCount, "{0} line", "{0} lines")</span> | |
| 32 | + } | |
| 33 | + </span> | |
| 34 | + </span> | |
| 35 | + <span class="file-actions"> | |
| 36 | + @if (_canPreview) | |
| 37 | + { | |
| 38 | + <nav class="segmented"> | |
| 39 | + <a class="@(ShowPreview ? "active" : "")" href="@Urls.Blob(Repository, _resolved.Name, _resolved.Path)">@T["Preview"]</a> | |
| 40 | + <a class="@(ShowPreview ? "" : "active")" href="@Urls.Blob(Repository, _resolved.Name, _resolved.Path)?plain=1">@T["Code"]</a> | |
| 41 | + </nav> | |
| 42 | + } | |
| 43 | + @if (_text is { Length: > 0 } && !ShowPreview) | |
| 44 | + { | |
| 45 | + <button type="button" class="button small js-only" data-copy-from="blob-code" data-copied-label="@T["Copied"]"> | |
| 46 | + <Icon Name="copy" Size="14"/> <span class="copy-label">@T["Copy"]</span> | |
| 47 | + </button> | |
| 48 | + } | |
| 49 | + <a class="button small" href="@Urls.Raw(Repository, _resolved.Name, _resolved.Path)">@T["Raw"]</a> | |
| 50 | + @if (_resolved.Kind != ResolvedKind.Commit) | |
| 51 | + { | |
| 52 | + <a class="button small" href="@Urls.Blob(Repository, _resolved.CommitSha, _resolved.Path)" data-hotkey="y" | |
| 53 | + title="@T["A link to this exact version of the file"]">@T["Permalink"]</a> | |
| 54 | + } | |
| 55 | + <a class="button small" href="@Urls.Commits(Repository, _resolved.Name, _resolved.Path)">@T["History"]</a> | |
| 56 | + </span> | |
| 57 | + </div> | |
| 58 | + | |
| 59 | + @if (_tooLarge) | |
| 60 | + { | |
| 61 | + <div class="card empty"> | |
| 62 | + <p>@T["The file is {0} and too large to display.", Format.Size(_size)]</p> | |
| 63 | + <p><a href="@Urls.Raw(Repository, _resolved.Name, _resolved.Path)">@T["Open raw"]</a></p> | |
| 64 | + </div> | |
| 65 | + } | |
| 66 | + else if (_imageType is not null) | |
| 67 | + { | |
| 68 | + <div class="card image-view"> | |
| 69 | + <img src="@Urls.Raw(Repository, _resolved.Name, _resolved.Path)" alt="@_entry.Name"/> | |
| 70 | + </div> | |
| 71 | + } | |
| 72 | + else if (_text is null) | |
| 73 | + { | |
| 74 | + <div class="card empty"> | |
| 75 | + <p>@T["A binary file cannot be displayed."]</p> | |
| 76 | + <p><a href="@Urls.Raw(Repository, _resolved.Name, _resolved.Path)">@T["Download"]</a></p> | |
| 77 | + </div> | |
| 78 | + } | |
| 79 | + else if (_text.Length == 0) | |
| 80 | + { | |
| 81 | + <div class="card empty"><p>@T["The file is empty."]</p></div> | |
| 82 | + } | |
| 83 | + else if (ShowPreview) | |
| 84 | + { | |
| 85 | + <article class="card file-preview"> | |
| 86 | + <div class="markdown">@((MarkupString)_previewHtml!)</div> | |
| 87 | + </article> | |
| 88 | + } | |
| 89 | + else | |
| 90 | + { | |
| 91 | + <div class="code-view"> | |
| 92 | + <pre class="line-numbers" aria-hidden="true">@for (var n = 1; n <= _lineCount; n++) | |
| 93 | + {<a id="L@(n)" href="#L@(n)">@n</a>}</pre> | |
| 94 | + <pre class="code"><code id="blob-code" class="@(_language is null ? "nohighlight" : "language-" + _language)" data-highlight="@_language">@_text</code></pre> | |
| 95 | + </div> | |
| 96 | + } | |
| 97 | +} | |
| 98 | + | |
| 99 | +@code { | |
| 100 | + [Parameter] | |
| 101 | + public string? RefAndPath { get; set; } | |
| 102 | + | |
| 103 | + private IReadOnlyList<GitRef> _refs = []; | |
| 104 | + private ResolvedRef? _resolved; | |
| 105 | + private TreeEntry? _entry; | |
| 106 | + private long _size; | |
| 107 | + private bool _tooLarge; | |
| 108 | + private string? _imageType; | |
| 109 | + private string? _text; | |
| 110 | + private string? _language; | |
| 111 | + private int _lineCount; | |
| 112 | + private bool _canPreview; | |
| 113 | + private string? _previewHtml; | |
| 114 | + | |
| 115 | + /// <summary>?plain=1 shows the source of a Markdown file instead of rendering it.</summary> | |
| 116 | + [SupplyParameterFromQuery(Name = "plain")] | |
| 117 | + private string? Plain { get; set; } | |
| 118 | + | |
| 119 | + private bool ShowPreview => _previewHtml is not null && Plain != "1"; | |
| 120 | + | |
| 121 | + protected override async Task OnInitializedAsync() | |
| 122 | + { | |
| 123 | + if (!await LoadRepoAsync()) | |
| 124 | + { | |
| 125 | + return; | |
| 126 | + } | |
| 127 | + | |
| 128 | + var repo = Repository!; | |
| 129 | + _refs = await Git.ListRefsAsync(RepoPath); | |
| 130 | + _resolved = await Resolver.ResolveAsync(RepoPath, RefAndPath, _refs); | |
| 131 | + if (_resolved is null) | |
| 132 | + { | |
| 133 | + NotFound(); | |
| 134 | + return; | |
| 135 | + } | |
| 136 | + | |
| 137 | + if (_resolved.Path.Length == 0) | |
| 138 | + { | |
| 139 | + Redirect(Urls.Tree(repo, _resolved.Name)); | |
| 140 | + return; | |
| 141 | + } | |
| 142 | + | |
| 143 | + _entry = await Git.GetEntryAsync(RepoPath, _resolved.CommitSha, _resolved.Path); | |
| 144 | + if (_entry is { IsTree: true }) | |
| 145 | + { | |
| 146 | + Redirect(Urls.Tree(repo, _resolved.Name, _resolved.Path)); | |
| 147 | + return; | |
| 148 | + } | |
| 149 | + | |
| 150 | + if (_entry is not { IsBlob: true }) | |
| 151 | + { | |
| 152 | + NotFound(); | |
| 153 | + return; | |
| 154 | + } | |
| 155 | + | |
| 156 | + _size = _entry.Size ?? await Git.GetBlobSizeAsync(RepoPath, _entry.Sha); | |
| 157 | + if (_size > FileTypes.MaxRenderBytes) | |
| 158 | + { | |
| 159 | + _tooLarge = true; | |
| 160 | + return; | |
| 161 | + } | |
| 162 | + | |
| 163 | + var blob = await Git.ReadBlobAsync(RepoPath, _entry.Sha, FileTypes.MaxRenderBytes); | |
| 164 | + if (blob.IsBinary) | |
| 165 | + { | |
| 166 | + // Only the known-safe image types are embedded; the raw endpoint serves them with the right type. | |
| 167 | + _imageType = FileTypes.InlineImageType(_entry.Name); | |
| 168 | + return; | |
| 169 | + } | |
| 170 | + | |
| 171 | + _text = blob.Text.Replace("\r\n", "\n"); | |
| 172 | + _language = FileTypes.Language(_entry.Name); | |
| 173 | + _lineCount = _text.Length == 0 | |
| 174 | + ? 0 | |
| 175 | + : _text.AsSpan().Count('\n') + (_text.EndsWith('\n') ? 0 : 1); | |
| 176 | + | |
| 177 | + if (FileTypes.IsMarkdown(_entry.Name) && _text.Length > 0 && _size <= FileTypes.MaxReadmeBytes) | |
| 178 | + { | |
| 179 | + _canPreview = true; | |
| 180 | + var slash = _resolved.Path.LastIndexOf('/'); | |
| 181 | + var links = new LinkContext( | |
| 182 | + Urls.Raw(repo, _resolved.Name, ""), | |
| 183 | + Urls.Blob(repo, _resolved.Name, ""), | |
| 184 | + slash < 0 ? "" : _resolved.Path[..slash]); | |
| 185 | + var text = _text; | |
| 186 | + // The same key as the README on the tree page: the HTML depends on the blob and on where relative links point. | |
| 187 | + _previewHtml = await Cache.GetOrCreateAsync( | |
| 188 | + $"readme:{_entry.Sha}:True:{links.RawBase}:{links.Directory}", | |
| 189 | + () => Task.FromResult(Markdown.Render(text, links)), | |
| 190 | + html => html.Length * 2L); | |
| 191 | + } | |
| 192 | + } | |
| 193 | +} |
added forge/Features/Browse/ContentCache.cs +34 −0View file
| @@ -0,0 +1,34 @@ | ||
| 1 | +using Microsoft.Extensions.Caching.Memory; | |
| 2 | + | |
| 3 | +namespace Forge.Features.Browse; | |
| 4 | + | |
| 5 | +/// <summary> | |
| 6 | +/// Cache for things derived from git objects. Keys include the object's SHA, and content under | |
| 7 | +/// a SHA never changes, so entries never need invalidating; they only age out to bound memory. | |
| 8 | +/// It owns its <see cref="MemoryCache"/> so the size limit applies to these entries alone. | |
| 9 | +/// </summary> | |
| 10 | +public sealed class ContentCache : IDisposable | |
| 11 | +{ | |
| 12 | + private readonly MemoryCache _cache = new(new MemoryCacheOptions { SizeLimit = 64 * 1024 * 1024 }); | |
| 13 | + | |
| 14 | + public IMemoryCache Cache => _cache; | |
| 15 | + | |
| 16 | + public async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> create, Func<T, long> sizeOf) | |
| 17 | + where T : notnull | |
| 18 | + { | |
| 19 | + if (_cache.TryGetValue(key, out T? cached) && cached is not null) | |
| 20 | + { | |
| 21 | + return cached; | |
| 22 | + } | |
| 23 | + | |
| 24 | + var value = await create(); | |
| 25 | + _cache.Set(key, value, new MemoryCacheEntryOptions | |
| 26 | + { | |
| 27 | + Size = Math.Max(1, sizeOf(value)), | |
| 28 | + SlidingExpiration = TimeSpan.FromHours(6), | |
| 29 | + }); | |
| 30 | + return value; | |
| 31 | + } | |
| 32 | + | |
| 33 | + public void Dispose() => _cache.Dispose(); | |
| 34 | +} |
added forge/Features/Browse/FileTypes.cs +80 −0View file
| @@ -0,0 +1,80 @@ | ||
| 1 | +namespace Forge.Features.Browse; | |
| 2 | + | |
| 3 | +public static class FileTypes | |
| 4 | +{ | |
| 5 | + public const long MaxRenderBytes = 1024 * 1024; | |
| 6 | + public const long MaxReadmeBytes = 512 * 1024; | |
| 7 | + | |
| 8 | + /// <summary>Image types that are safe to show inline. SVG is deliberately absent: it can carry script.</summary> | |
| 9 | + private static readonly Dictionary<string, string> InlineImages = new(StringComparer.OrdinalIgnoreCase) | |
| 10 | + { | |
| 11 | + [".png"] = "image/png", | |
| 12 | + [".jpg"] = "image/jpeg", | |
| 13 | + [".jpeg"] = "image/jpeg", | |
| 14 | + [".gif"] = "image/gif", | |
| 15 | + [".webp"] = "image/webp", | |
| 16 | + }; | |
| 17 | + | |
| 18 | + /// <summary>File extension → highlight.js language name (languages in the "common" bundle).</summary> | |
| 19 | + private static readonly Dictionary<string, string> Languages = new(StringComparer.OrdinalIgnoreCase) | |
| 20 | + { | |
| 21 | + [".cs"] = "csharp", [".csx"] = "csharp", [".razor"] = "xml", [".cshtml"] = "xml", | |
| 22 | + [".csproj"] = "xml", [".props"] = "xml", [".targets"] = "xml", [".slnx"] = "xml", | |
| 23 | + [".xml"] = "xml", [".html"] = "xml", [".htm"] = "xml", [".svg"] = "xml", [".xaml"] = "xml", | |
| 24 | + [".js"] = "javascript", [".mjs"] = "javascript", [".cjs"] = "javascript", [".jsx"] = "javascript", | |
| 25 | + [".ts"] = "typescript", [".tsx"] = "typescript", | |
| 26 | + [".json"] = "json", [".yml"] = "yaml", [".yaml"] = "yaml", [".toml"] = "ini", [".ini"] = "ini", | |
| 27 | + [".css"] = "css", [".scss"] = "scss", [".less"] = "less", | |
| 28 | + [".md"] = "markdown", [".markdown"] = "markdown", | |
| 29 | + [".py"] = "python", [".rb"] = "ruby", [".go"] = "go", [".rs"] = "rust", | |
| 30 | + [".java"] = "java", [".kt"] = "kotlin", [".kts"] = "kotlin", [".swift"] = "swift", | |
| 31 | + [".c"] = "c", [".h"] = "c", [".cpp"] = "cpp", [".cc"] = "cpp", [".hpp"] = "cpp", | |
| 32 | + [".m"] = "objectivec", [".php"] = "php", [".pl"] = "perl", [".lua"] = "lua", [".r"] = "r", | |
| 33 | + [".sh"] = "bash", [".bash"] = "bash", [".zsh"] = "bash", [".ps1"] = "powershell", | |
| 34 | + [".sql"] = "sql", [".diff"] = "diff", [".patch"] = "diff", [".vb"] = "vbnet", | |
| 35 | + [".graphql"] = "graphql", [".wasm"] = "wasm", | |
| 36 | + }; | |
| 37 | + | |
| 38 | + private static readonly Dictionary<string, string> LanguagesByName = new(StringComparer.OrdinalIgnoreCase) | |
| 39 | + { | |
| 40 | + ["Makefile"] = "makefile", ["Dockerfile"] = "bash", [".gitignore"] = "plaintext", [".editorconfig"] = "ini", | |
| 41 | + }; | |
| 42 | + | |
| 43 | + public static string? InlineImageType(string fileName) => | |
| 44 | + InlineImages.GetValueOrDefault(Path.GetExtension(fileName)); | |
| 45 | + | |
| 46 | + /// <summary>The highlight.js language for a file, or null when it should stay unhighlighted.</summary> | |
| 47 | + public static string? Language(string fileName) => | |
| 48 | + LanguagesByName.GetValueOrDefault(fileName) ?? Languages.GetValueOrDefault(Path.GetExtension(fileName)); | |
| 49 | + | |
| 50 | + public static bool IsMarkdown(string fileName) => | |
| 51 | + Path.GetExtension(fileName) is var ext | |
| 52 | + && (ext.Equals(".md", StringComparison.OrdinalIgnoreCase) || ext.Equals(".markdown", StringComparison.OrdinalIgnoreCase)); | |
| 53 | + | |
| 54 | + /// <summary>Picks the README among directory entries: README.md first, then other README variants.</summary> | |
| 55 | + public static T? FindReadme<T>(IEnumerable<T> files, Func<T, string> nameOf) | |
| 56 | + where T : class | |
| 57 | + { | |
| 58 | + T? best = null; | |
| 59 | + var bestRank = int.MaxValue; | |
| 60 | + foreach (var file in files) | |
| 61 | + { | |
| 62 | + var name = nameOf(file); | |
| 63 | + var rank = name.ToLowerInvariant() switch | |
| 64 | + { | |
| 65 | + "readme.md" => 0, | |
| 66 | + "readme.markdown" => 1, | |
| 67 | + "readme" => 2, | |
| 68 | + "readme.txt" => 3, | |
| 69 | + _ => int.MaxValue, | |
| 70 | + }; | |
| 71 | + if (rank < bestRank) | |
| 72 | + { | |
| 73 | + best = file; | |
| 74 | + bestRank = rank; | |
| 75 | + } | |
| 76 | + } | |
| 77 | + | |
| 78 | + return best; | |
| 79 | + } | |
| 80 | +} |
added forge/Features/Browse/MarkdownRenderer.cs +115 −0View file
| @@ -0,0 +1,115 @@ | ||
| 1 | +using System.Text.RegularExpressions; | |
| 2 | +using AngleSharp.Dom; | |
| 3 | +using Ganss.Xss; | |
| 4 | +using Markdig; | |
| 5 | + | |
| 6 | +namespace Forge.Features.Browse; | |
| 7 | + | |
| 8 | +/// <summary>Where relative links in a rendered document should point.</summary> | |
| 9 | +/// <param name="RawBase">For example /owner/repo/raw/main (images and other embedded files).</param> | |
| 10 | +/// <param name="BlobBase">For example /owner/repo/blob/main (links to other files).</param> | |
| 11 | +/// <param name="Directory">Directory of the document inside the repository; empty for the root.</param> | |
| 12 | +public sealed record LinkContext(string RawBase, string BlobBase, string Directory); | |
| 13 | + | |
| 14 | +/// <summary>Markdown → sanitized HTML. Everything a repository author wrote is treated as hostile.</summary> | |
| 15 | +public sealed partial class MarkdownRenderer | |
| 16 | +{ | |
| 17 | + private static readonly MarkdownPipeline Pipeline = new MarkdownPipelineBuilder() | |
| 18 | + .UsePipeTables() | |
| 19 | + .UseAutoLinks() | |
| 20 | + .UseTaskLists() | |
| 21 | + .UseEmphasisExtras() | |
| 22 | + .UseFootnotes() | |
| 23 | + .Build(); | |
| 24 | + | |
| 25 | + public string Render(string markdown, LinkContext links) | |
| 26 | + { | |
| 27 | + var html = Markdown.ToHtml(markdown, Pipeline); | |
| 28 | + | |
| 29 | + // A sanitizer per call: its event handlers capture this document's link context. | |
| 30 | + var sanitizer = new HtmlSanitizer(); | |
| 31 | + sanitizer.AllowedSchemes.Add("mailto"); | |
| 32 | + // Inline styles are blocked by the CSP anyway, and forms have no place in a README. | |
| 33 | + sanitizer.AllowedAttributes.Remove("style"); | |
| 34 | + foreach (var tag in (string[])["form", "button", "select", "textarea", "option", "optgroup", "fieldset", "style"]) | |
| 35 | + { | |
| 36 | + sanitizer.AllowedTags.Remove(tag); | |
| 37 | + } | |
| 38 | + | |
| 39 | + sanitizer.FilterUrl += (_, e) => | |
| 40 | + { | |
| 41 | + if (e.SanitizedUrl is { } url && IsRelative(url)) | |
| 42 | + { | |
| 43 | + var embedded = e.Tag.LocalName is "img" or "source" or "video" or "audio"; | |
| 44 | + e.SanitizedUrl = Rewrite(url, links, embedded); | |
| 45 | + } | |
| 46 | + }; | |
| 47 | + | |
| 48 | + sanitizer.PostProcessNode += (_, e) => | |
| 49 | + { | |
| 50 | + if (e.Node is IElement { LocalName: "a" } anchor | |
| 51 | + && anchor.GetAttribute("href") is { } href | |
| 52 | + && IsExternal(href)) | |
| 53 | + { | |
| 54 | + anchor.SetAttribute("rel", "nofollow noopener"); | |
| 55 | + } | |
| 56 | + }; | |
| 57 | + | |
| 58 | + return sanitizer.Sanitize(html); | |
| 59 | + } | |
| 60 | + | |
| 61 | + internal static bool IsRelative(string url) => | |
| 62 | + url.Length > 0 | |
| 63 | + && url[0] != '#' | |
| 64 | + && !url.StartsWith("//", StringComparison.Ordinal) | |
| 65 | + && !SchemePattern().IsMatch(url); | |
| 66 | + | |
| 67 | + internal static bool IsExternal(string url) => | |
| 68 | + url.StartsWith("//", StringComparison.Ordinal) | |
| 69 | + || url.StartsWith("http:", StringComparison.OrdinalIgnoreCase) | |
| 70 | + || url.StartsWith("https:", StringComparison.OrdinalIgnoreCase); | |
| 71 | + | |
| 72 | + /// <summary>Resolves a relative URL against the document's directory and points it into the repository.</summary> | |
| 73 | + internal static string Rewrite(string url, LinkContext links, bool embedded) | |
| 74 | + { | |
| 75 | + var suffixStart = url.IndexOfAny(['?', '#']); | |
| 76 | + var path = suffixStart >= 0 ? url[..suffixStart] : url; | |
| 77 | + var suffix = suffixStart >= 0 ? url[suffixStart..] : ""; | |
| 78 | + | |
| 79 | + // A leading slash means "from the repository root", as on other forges. | |
| 80 | + var segments = new List<string>(); | |
| 81 | + if (!path.StartsWith('/') && links.Directory.Length > 0) | |
| 82 | + { | |
| 83 | + segments.AddRange(links.Directory.Split('/')); | |
| 84 | + } | |
| 85 | + | |
| 86 | + foreach (var segment in path.Split('/', StringSplitOptions.RemoveEmptyEntries)) | |
| 87 | + { | |
| 88 | + if (segment == ".") | |
| 89 | + { | |
| 90 | + continue; | |
| 91 | + } | |
| 92 | + | |
| 93 | + if (segment == "..") | |
| 94 | + { | |
| 95 | + if (segments.Count > 0) | |
| 96 | + { | |
| 97 | + segments.RemoveAt(segments.Count - 1); | |
| 98 | + } | |
| 99 | + | |
| 100 | + continue; | |
| 101 | + } | |
| 102 | + | |
| 103 | + // The URL is already percent-encoded where needed; decode so it is not encoded twice. | |
| 104 | + segments.Add(Uri.UnescapeDataString(segment)); | |
| 105 | + } | |
| 106 | + | |
| 107 | + var basePath = embedded ? links.RawBase : links.BlobBase; | |
| 108 | + return segments.Count == 0 | |
| 109 | + ? basePath + suffix | |
| 110 | + : basePath + "/" + Urls.EncodePath(string.Join('/', segments)) + suffix; | |
| 111 | + } | |
| 112 | + | |
| 113 | + [GeneratedRegex("^[A-Za-z][A-Za-z0-9+.-]*:")] | |
| 114 | + private static partial Regex SchemePattern(); | |
| 115 | +} |
added forge/Features/Browse/RawEndpoint.cs +127 −0View file
| @@ -0,0 +1,127 @@ | ||
| 1 | +using CliWrap; | |
| 2 | +using Forge.Features.Auth; | |
| 3 | +using Forge.Features.Repos; | |
| 4 | +using Forge.Git; | |
| 5 | +using Microsoft.Net.Http.Headers; | |
| 6 | + | |
| 7 | +namespace Forge.Features.Browse; | |
| 8 | + | |
| 9 | +/// <summary> | |
| 10 | +/// Serves file contents straight from the repository. Repository content is untrusted, so it is | |
| 11 | +/// never served as HTML: text goes out as text/plain, a short list of image types is shown inline, | |
| 12 | +/// and everything else (including SVG) is a download. | |
| 13 | +/// </summary> | |
| 14 | +public static class RawEndpoint | |
| 15 | +{ | |
| 16 | + public static void MapRaw(this IEndpointRouteBuilder app) => | |
| 17 | + app.MapGet("/{owner}/{repo}/raw/{**refAndPath}", HandleAsync); | |
| 18 | + | |
| 19 | + private static async Task<IResult> HandleAsync( | |
| 20 | + HttpContext context, | |
| 21 | + string owner, | |
| 22 | + string repo, | |
| 23 | + string? refAndPath, | |
| 24 | + RepoService repos, | |
| 25 | + CurrentUser me, | |
| 26 | + RepoPaths paths, | |
| 27 | + RefResolver resolver, | |
| 28 | + GitRepo gitRepo, | |
| 29 | + GitCli git) | |
| 30 | + { | |
| 31 | + var ct = context.RequestAborted; | |
| 32 | + var repository = await repos.FindAsync(owner, repo, ct); | |
| 33 | + if (repository is null || !RepoAccess.CanRead(repository, me.Actor)) | |
| 34 | + { | |
| 35 | + return Results.NotFound(); | |
| 36 | + } | |
| 37 | + | |
| 38 | + var repoPath = paths.For(repository.Id); | |
| 39 | + // Catch-all route values keep an encoded slash as %2F; nothing in a ref or path needs it. | |
| 40 | + var resolved = await resolver.ResolveAsync(repoPath, refAndPath, ct: ct); | |
| 41 | + if (resolved is null || resolved.Path.Length == 0) | |
| 42 | + { | |
| 43 | + return Results.NotFound(); | |
| 44 | + } | |
| 45 | + | |
| 46 | + var entry = await gitRepo.GetEntryAsync(repoPath, resolved.CommitSha, resolved.Path, ct); | |
| 47 | + if (entry is not { IsBlob: true }) | |
| 48 | + { | |
| 49 | + return Results.NotFound(); | |
| 50 | + } | |
| 51 | + | |
| 52 | + var response = context.Response; | |
| 53 | + var etag = new EntityTagHeaderValue($"\"{entry.Sha}\""); | |
| 54 | + response.Headers.ETag = etag.ToString(); | |
| 55 | + response.Headers.CacheControl = "no-cache"; | |
| 56 | + response.Headers.XContentTypeOptions = "nosniff"; | |
| 57 | + // Even if a browser were tricked into rendering this, nothing in it may run or load. | |
| 58 | + response.Headers.ContentSecurityPolicy = "default-src 'none'; sandbox"; | |
| 59 | + | |
| 60 | + if (context.Request.GetTypedHeaders().IfNoneMatch is { Count: > 0 } candidates | |
| 61 | + && candidates.Any(c => c.Equals(EntityTagHeaderValue.Any) || c.Compare(etag, useStrongComparison: false))) | |
| 62 | + { | |
| 63 | + return Results.StatusCode(StatusCodes.Status304NotModified); | |
| 64 | + } | |
| 65 | + | |
| 66 | + var fileName = entry.Name; | |
| 67 | + var imageType = FileTypes.InlineImageType(fileName); | |
| 68 | + var forceDownload = Path.GetExtension(fileName).Equals(".svg", StringComparison.OrdinalIgnoreCase); | |
| 69 | + if (entry.Size is { } size) | |
| 70 | + { | |
| 71 | + response.ContentLength = size; | |
| 72 | + } | |
| 73 | + | |
| 74 | + var target = PipeTarget.Create(async (stream, token) => | |
| 75 | + { | |
| 76 | + // The first 8000 bytes decide text or binary, the same way git decides. | |
| 77 | + var head = new byte[8000]; | |
| 78 | + var filled = 0; | |
| 79 | + while (filled < head.Length) | |
| 80 | + { | |
| 81 | + var n = await stream.ReadAsync(head.AsMemory(filled), token); | |
| 82 | + if (n == 0) | |
| 83 | + { | |
| 84 | + break; | |
| 85 | + } | |
| 86 | + | |
| 87 | + filled += n; | |
| 88 | + } | |
| 89 | + | |
| 90 | + if (imageType is not null) | |
| 91 | + { | |
| 92 | + response.ContentType = imageType; | |
| 93 | + } | |
| 94 | + else if (forceDownload || GitParsers.IsBinary(head.AsSpan(0, filled))) | |
| 95 | + { | |
| 96 | + response.ContentType = "application/octet-stream"; | |
| 97 | + var disposition = new ContentDispositionHeaderValue("attachment"); | |
| 98 | + disposition.SetHttpFileName(fileName); | |
| 99 | + response.Headers.ContentDisposition = disposition.ToString(); | |
| 100 | + } | |
| 101 | + else | |
| 102 | + { | |
| 103 | + response.ContentType = "text/plain; charset=utf-8"; | |
| 104 | + } | |
| 105 | + | |
| 106 | + await response.Body.WriteAsync(head.AsMemory(0, filled), token); | |
| 107 | + await stream.CopyToAsync(response.Body, token); | |
| 108 | + }); | |
| 109 | + | |
| 110 | + try | |
| 111 | + { | |
| 112 | + await git.StreamAsync( | |
| 113 | + repoPath, | |
| 114 | + ["cat-file", "blob", entry.Sha], | |
| 115 | + PipeSource.Null, | |
| 116 | + target, | |
| 117 | + timeout: TimeSpan.FromMinutes(10), | |
| 118 | + ct: ct); | |
| 119 | + } | |
| 120 | + catch (OperationCanceledException) when (ct.IsCancellationRequested) | |
| 121 | + { | |
| 122 | + // The client stopped the download. | |
| 123 | + } | |
| 124 | + | |
| 125 | + return Results.Empty; | |
| 126 | + } | |
| 127 | +} |
added forge/Features/Browse/RepoInsights.cs +179 −0View file
| @@ -0,0 +1,179 @@ | ||
| 1 | +using Forge.Git; | |
| 2 | + | |
| 3 | +namespace Forge.Features.Browse; | |
| 4 | + | |
| 5 | +/// <summary>One slice of the language bar.</summary> | |
| 6 | +/// <param name="Key">CSS suffix (lang-csharp) that carries the colour; "other" for the rest.</param> | |
| 7 | +/// <param name="Name">Display name; null for "other", which the page translates.</param> | |
| 8 | +public sealed record LanguageShare(string Key, string? Name, double Percent); | |
| 9 | + | |
| 10 | +public sealed record Contributor(string Name, int Commits, DateTimeOffset First, DateTimeOffset Last); | |
| 11 | + | |
| 12 | +/// <param name="CommitsByDay">Commit counts by UTC day; days without commits are absent.</param> | |
| 13 | +/// <param name="Truncated">The history is longer than what was counted.</param> | |
| 14 | +public sealed record RepoActivity( | |
| 15 | + IReadOnlyList<Contributor> Contributors, | |
| 16 | + IReadOnlyDictionary<DateOnly, int> CommitsByDay, | |
| 17 | + int Commits, | |
| 18 | + bool Truncated); | |
| 19 | + | |
| 20 | +/// <summary> | |
| 21 | +/// Facts about a commit that cost more than one cheap git call: language shares, commit count, | |
| 22 | +/// the file list, and the last commit that touched each entry of a directory. Everything is keyed | |
| 23 | +/// by commit SHA, so it is cached without invalidation (see <see cref="ContentCache"/>). | |
| 24 | +/// </summary> | |
| 25 | +public sealed class RepoInsights(GitRepo git, ContentCache cache) | |
| 26 | +{ | |
| 27 | + /// <summary>Directories with more entries than this do not get per-entry commits: one git process each is too slow.</summary> | |
| 28 | + public const int MaxEntriesWithCommits = 100; | |
| 29 | + | |
| 30 | + private const int MaxLanguages = 6; | |
| 31 | + | |
| 32 | + private static readonly Dictionary<string, (string Key, string Name)> Languages = new(StringComparer.OrdinalIgnoreCase) | |
| 33 | + { | |
| 34 | + [".cs"] = ("csharp", "C#"), [".csx"] = ("csharp", "C#"), | |
| 35 | + [".js"] = ("javascript", "JavaScript"), [".mjs"] = ("javascript", "JavaScript"), | |
| 36 | + [".cjs"] = ("javascript", "JavaScript"), [".jsx"] = ("javascript", "JavaScript"), | |
| 37 | + [".ts"] = ("typescript", "TypeScript"), [".tsx"] = ("typescript", "TypeScript"), | |
| 38 | + [".html"] = ("html", "HTML"), [".htm"] = ("html", "HTML"), | |
| 39 | + [".razor"] = ("html", "HTML"), [".cshtml"] = ("html", "HTML"), | |
| 40 | + [".css"] = ("css", "CSS"), [".scss"] = ("css", "CSS"), [".less"] = ("css", "CSS"), | |
| 41 | + [".py"] = ("python", "Python"), [".go"] = ("go", "Go"), [".rs"] = ("rust", "Rust"), | |
| 42 | + [".java"] = ("java", "Java"), [".kt"] = ("kotlin", "Kotlin"), [".kts"] = ("kotlin", "Kotlin"), | |
| 43 | + [".swift"] = ("swift", "Swift"), [".c"] = ("c", "C"), [".h"] = ("c", "C"), | |
| 44 | + [".cpp"] = ("cpp", "C++"), [".cc"] = ("cpp", "C++"), [".hpp"] = ("cpp", "C++"), | |
| 45 | + [".rb"] = ("ruby", "Ruby"), [".php"] = ("php", "PHP"), [".lua"] = ("lua", "Lua"), | |
| 46 | + [".sh"] = ("shell", "Shell"), [".bash"] = ("shell", "Shell"), [".zsh"] = ("shell", "Shell"), | |
| 47 | + [".ps1"] = ("powershell", "PowerShell"), [".sql"] = ("sql", "SQL"), [".vb"] = ("vb", "Visual Basic"), | |
| 48 | + }; | |
| 49 | + | |
| 50 | + /// <summary>Third-party code checked into a repository would drown out the project's own languages.</summary> | |
| 51 | + private static readonly string[] VendoredSegments = ["node_modules/", "vendor/", "wwwroot/lib/", "dist/", "third_party/"]; | |
| 52 | + | |
| 53 | + public Task<IReadOnlyList<FileEntry>> ListFilesAsync(string repoPath, string commitSha) => | |
| 54 | + cache.GetOrCreateAsync( | |
| 55 | + "files:" + commitSha, | |
| 56 | + async () => (await git.ListFilesAsync(repoPath, commitSha)).Files, | |
| 57 | + files => files.Sum(f => 60L + f.Path.Length * 2)); | |
| 58 | + | |
| 59 | + public Task<int> CountCommitsAsync(string repoPath, string commitSha) => | |
| 60 | + cache.GetOrCreateAsync("count:" + commitSha, () => git.CountCommitsAsync(repoPath, commitSha), _ => 32); | |
| 61 | + | |
| 62 | + /// <summary>Share of each programming language by bytes, largest first. Empty when no file is in a known language.</summary> | |
| 63 | + public Task<IReadOnlyList<LanguageShare>> GetLanguagesAsync(string repoPath, string commitSha) => | |
| 64 | + cache.GetOrCreateAsync( | |
| 65 | + "languages:" + commitSha, | |
| 66 | + async () => ComputeLanguages(await ListFilesAsync(repoPath, commitSha)), | |
| 67 | + shares => 200L * (shares.Count + 1)); | |
| 68 | + | |
| 69 | + public static IReadOnlyList<LanguageShare> ComputeLanguages(IEnumerable<FileEntry> files) | |
| 70 | + { | |
| 71 | + var bytes = new Dictionary<string, (string Name, long Bytes)>(StringComparer.Ordinal); | |
| 72 | + foreach (var file in files) | |
| 73 | + { | |
| 74 | + if (file.Size == 0 | |
| 75 | + || file.Path.Contains(".min.", StringComparison.OrdinalIgnoreCase) | |
| 76 | + || IsVendored(file.Path) | |
| 77 | + || !Languages.TryGetValue(Path.GetExtension(file.Path), out var language)) | |
| 78 | + { | |
| 79 | + continue; | |
| 80 | + } | |
| 81 | + | |
| 82 | + bytes[language.Key] = (language.Name, bytes.GetValueOrDefault(language.Key).Bytes + file.Size); | |
| 83 | + } | |
| 84 | + | |
| 85 | + var total = bytes.Values.Sum(v => v.Bytes); | |
| 86 | + if (total == 0) | |
| 87 | + { | |
| 88 | + return []; | |
| 89 | + } | |
| 90 | + | |
| 91 | + var ordered = bytes.OrderByDescending(p => p.Value.Bytes).ThenBy(p => p.Key, StringComparer.Ordinal).ToList(); | |
| 92 | + var shares = ordered | |
| 93 | + .Take(MaxLanguages) | |
| 94 | + .Select(p => new LanguageShare(p.Key, p.Value.Name, 100.0 * p.Value.Bytes / total)) | |
| 95 | + .ToList(); | |
| 96 | + var rest = ordered.Skip(MaxLanguages).Sum(p => p.Value.Bytes); | |
| 97 | + if (rest > 0) | |
| 98 | + { | |
| 99 | + shares.Add(new LanguageShare("other", null, 100.0 * rest / total)); | |
| 100 | + } | |
| 101 | + | |
| 102 | + return shares; | |
| 103 | + } | |
| 104 | + | |
| 105 | + /// <summary>Who committed, and when, over the newest <see cref="MaxActivityCommits"/> commits.</summary> | |
| 106 | + public Task<RepoActivity> GetActivityAsync(string repoPath, string commitSha) => | |
| 107 | + cache.GetOrCreateAsync( | |
| 108 | + "activity:" + commitSha, | |
| 109 | + async () => ComputeActivity(await git.ListAuthorshipAsync(repoPath, commitSha, MaxActivityCommits), MaxActivityCommits), | |
| 110 | + activity => 200L * activity.Contributors.Count + 40L * activity.CommitsByDay.Count + 200); | |
| 111 | + | |
| 112 | + public const int MaxActivityCommits = 20_000; | |
| 113 | + | |
| 114 | + public static RepoActivity ComputeActivity(IReadOnlyList<(string Name, string Email, DateTimeOffset When)> commits, int limit) | |
| 115 | + { | |
| 116 | + // One person is one e-mail address, whatever the capitalisation; the newest name wins. | |
| 117 | + var contributors = commits | |
| 118 | + .GroupBy(c => c.Email.Length > 0 ? c.Email.ToLowerInvariant() : c.Name, StringComparer.Ordinal) | |
| 119 | + .Select(g => new Contributor(g.First().Name, g.Count(), g.Min(c => c.When), g.Max(c => c.When))) | |
| 120 | + .OrderByDescending(c => c.Commits) | |
| 121 | + .ThenBy(c => c.Name, StringComparer.OrdinalIgnoreCase) | |
| 122 | + .ToList(); | |
| 123 | + var byDay = commits | |
| 124 | + .GroupBy(c => DateOnly.FromDateTime(c.When.UtcDateTime)) | |
| 125 | + .ToDictionary(g => g.Key, g => g.Count()); | |
| 126 | + return new RepoActivity(contributors, byDay, commits.Count, commits.Count >= limit); | |
| 127 | + } | |
| 128 | + | |
| 129 | + private static bool IsVendored(string path) | |
| 130 | + { | |
| 131 | + foreach (var segment in VendoredSegments) | |
| 132 | + { | |
| 133 | + if (path.StartsWith(segment, StringComparison.OrdinalIgnoreCase) | |
| 134 | + || path.Contains("/" + segment, StringComparison.OrdinalIgnoreCase)) | |
| 135 | + { | |
| 136 | + return true; | |
| 137 | + } | |
| 138 | + } | |
| 139 | + | |
| 140 | + return false; | |
| 141 | + } | |
| 142 | + | |
| 143 | + /// <summary> | |
| 144 | + /// The newest commit that changed each entry of a directory, by entry name. Returns an empty map | |
| 145 | + /// for a directory with more than <see cref="MaxEntriesWithCommits"/> entries. | |
| 146 | + /// </summary> | |
| 147 | + public Task<IReadOnlyDictionary<string, CommitInfo>> GetLastCommitsAsync( | |
| 148 | + string repoPath, | |
| 149 | + string commitSha, | |
| 150 | + string directory, | |
| 151 | + IReadOnlyList<string> names) | |
| 152 | + { | |
| 153 | + if (names.Count is 0 or > MaxEntriesWithCommits) | |
| 154 | + { | |
| 155 | + return Task.FromResult<IReadOnlyDictionary<string, CommitInfo>>(new Dictionary<string, CommitInfo>()); | |
| 156 | + } | |
| 157 | + | |
| 158 | + return cache.GetOrCreateAsync<IReadOnlyDictionary<string, CommitInfo>>( | |
| 159 | + $"last:{commitSha}:{directory}", | |
| 160 | + async () => | |
| 161 | + { | |
| 162 | + var found = new System.Collections.Concurrent.ConcurrentDictionary<string, CommitInfo>(StringComparer.Ordinal); | |
| 163 | + await Parallel.ForEachAsync( | |
| 164 | + names, | |
| 165 | + new ParallelOptions { MaxDegreeOfParallelism = 6 }, | |
| 166 | + async (name, ct) => | |
| 167 | + { | |
| 168 | + var path = directory.Length == 0 ? name : directory + "/" + name; | |
| 169 | + var log = await git.LogAsync(repoPath, commitSha, path, take: 1, ct: ct); | |
| 170 | + if (log.Count > 0) | |
| 171 | + { | |
| 172 | + found[name] = log[0]; | |
| 173 | + } | |
| 174 | + }); | |
| 175 | + return found; | |
| 176 | + }, | |
| 177 | + map => map.Count * 600L + 100); | |
| 178 | + } | |
| 179 | +} |
added forge/Features/Browse/Search.razor +178 −0View file
| @@ -0,0 +1,178 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/search" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject RepoInsights Insights | |
| 4 | + | |
| 5 | +@if (Repository is not null) | |
| 6 | +{ | |
| 7 | + <PageTitle>@T["Search"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 8 | + | |
| 9 | + <RepoHeader Repository="Repository" Active="code" IsOwner="IsOwner"/> | |
| 10 | + | |
| 11 | + <form class="toolbar" method="get" action="@Urls.Search(Repository)" role="search"> | |
| 12 | + <div class="search repo-search"> | |
| 13 | + <Icon Name="search" Size="15"/> | |
| 14 | + <input type="search" name="q" value="@Query" placeholder="@T["Search file names and code"]" | |
| 15 | + aria-label="@T["Search file names and code"]" autocomplete="off" autofocus maxlength="@MaxQueryLength"/> | |
| 16 | + </div> | |
| 17 | + @if (_resolved is not null) | |
| 18 | + { | |
| 19 | + <input type="hidden" name="ref" value="@_resolved.Name"/> | |
| 20 | + } | |
| 21 | + <button type="submit" class="button">@T["Search"]</button> | |
| 22 | + </form> | |
| 23 | + | |
| 24 | + @if (_resolved is null) | |
| 25 | + { | |
| 26 | + <div class="empty-state"> | |
| 27 | + <Icon Name="inbox" Size="32"/> | |
| 28 | + <h2>@T["The repository is empty"]</h2> | |
| 29 | + </div> | |
| 30 | + } | |
| 31 | + else if (_term is null) | |
| 32 | + { | |
| 33 | + <div class="empty-state"> | |
| 34 | + <Icon Name="search" Size="32"/> | |
| 35 | + <h2>@T["Search this repository"]</h2> | |
| 36 | + <p>@T["Type at least {0} characters. Upper and lower case do not matter.", MinQueryLength]</p> | |
| 37 | + </div> | |
| 38 | + } | |
| 39 | + else if (_files.Count == 0 && _groups.Count == 0) | |
| 40 | + { | |
| 41 | + <div class="empty-state"> | |
| 42 | + <Icon Name="search" Size="32"/> | |
| 43 | + <h2>@T["Nothing in {0} matches “{1}”.", RefLabel, _term]</h2> | |
| 44 | + </div> | |
| 45 | + } | |
| 46 | + else | |
| 47 | + { | |
| 48 | + <p class="muted"> | |
| 49 | + @T["Results for “{0}” in {1}", _term, RefLabel] | |
| 50 | + </p> | |
| 51 | + | |
| 52 | + @if (_files.Count > 0) | |
| 53 | + { | |
| 54 | + <h3 class="result-heading"><Icon Name="file"/> @T["File names"] <Counter Value="_files.Count"/></h3> | |
| 55 | + <ul class="result-files"> | |
| 56 | + @foreach (var file in _files) | |
| 57 | + { | |
| 58 | + <li> | |
| 59 | + <Icon Name="file" Size="14"/> | |
| 60 | + <a href="@Urls.Blob(Repository, _resolved.Name, file.Path)"><Highlighted Text="@file.Path" Term="@_term"/></a> | |
| 61 | + </li> | |
| 62 | + } | |
| 63 | + </ul> | |
| 64 | + @if (_moreFiles) | |
| 65 | + { | |
| 66 | + <p class="muted small">@T["Only the first {0} files are shown.", MaxFiles]</p> | |
| 67 | + } | |
| 68 | + } | |
| 69 | + | |
| 70 | + @if (_groups.Count > 0) | |
| 71 | + { | |
| 72 | + <h3 class="result-heading"><Icon Name="code"/> @T["Code"] <Counter Value="_matchCount"/></h3> | |
| 73 | + @foreach (var group in _groups) | |
| 74 | + { | |
| 75 | + <section class="result-file"> | |
| 76 | + <header class="result-file-head"> | |
| 77 | + <Icon Name="file" Size="14"/> | |
| 78 | + <a href="@Urls.Blob(Repository, _resolved.Name, group.Key)">@group.Key</a> | |
| 79 | + </header> | |
| 80 | + <table class="result-lines"> | |
| 81 | + <tbody> | |
| 82 | + @foreach (var match in group) | |
| 83 | + { | |
| 84 | + <tr> | |
| 85 | + <td class="ln"><a href="@LineUrl(match)">@match.Line</a></td> | |
| 86 | + <td class="result-code"><Highlighted Text="@match.Text" Term="@_term"/></td> | |
| 87 | + </tr> | |
| 88 | + } | |
| 89 | + </tbody> | |
| 90 | + </table> | |
| 91 | + </section> | |
| 92 | + } | |
| 93 | + @if (_truncated) | |
| 94 | + { | |
| 95 | + <p class="alert warning">@T["There are more matches than shown. Make the search more specific."]</p> | |
| 96 | + } | |
| 97 | + } | |
| 98 | + } | |
| 99 | +} | |
| 100 | + | |
| 101 | +@code { | |
| 102 | + public const int MinQueryLength = 2; | |
| 103 | + public const int MaxQueryLength = 200; | |
| 104 | + public const int MaxFiles = 30; | |
| 105 | + public const int MaxCodeFiles = 40; | |
| 106 | + | |
| 107 | + [SupplyParameterFromQuery(Name = "q")] | |
| 108 | + private string? Query { get; set; } | |
| 109 | + | |
| 110 | + /// <summary>A branch, tag or commit SHA; the default branch when absent.</summary> | |
| 111 | + [SupplyParameterFromQuery(Name = "ref")] | |
| 112 | + private string? RefName { get; set; } | |
| 113 | + | |
| 114 | + private ResolvedRef? _resolved; | |
| 115 | + private string? _term; | |
| 116 | + private List<FileEntry> _files = []; | |
| 117 | + private bool _moreFiles; | |
| 118 | + private List<IGrouping<string, GrepMatch>> _groups = []; | |
| 119 | + private int _matchCount; | |
| 120 | + private bool _truncated; | |
| 121 | + | |
| 122 | + private string RefLabel => _resolved!.Kind == ResolvedKind.Commit ? _resolved.Name[..8] : _resolved.Name; | |
| 123 | + | |
| 124 | + /// <summary>A Markdown file opens as a preview, which has no line numbers to jump to.</summary> | |
| 125 | + private string LineUrl(GrepMatch match) => | |
| 126 | + Urls.Blob(Repository!, _resolved!.Name, match.Path) | |
| 127 | + + (FileTypes.IsMarkdown(match.Path) ? "?plain=1" : "") | |
| 128 | + + "#L" + match.Line.ToString(CultureInfo.InvariantCulture); | |
| 129 | + | |
| 130 | + protected override async Task OnInitializedAsync() | |
| 131 | + { | |
| 132 | + if (!await LoadRepoAsync()) | |
| 133 | + { | |
| 134 | + return; | |
| 135 | + } | |
| 136 | + | |
| 137 | + var refs = await Git.ListRefsAsync(RepoPath); | |
| 138 | + if (string.IsNullOrEmpty(RefName)) | |
| 139 | + { | |
| 140 | + var branch = refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == Repository!.DefaultBranch) | |
| 141 | + ?? refs.FirstOrDefault(r => r.Kind == RefKind.Branch); | |
| 142 | + if (branch is null) | |
| 143 | + { | |
| 144 | + return; // Empty repository. | |
| 145 | + } | |
| 146 | + | |
| 147 | + _resolved = new ResolvedRef(branch.Name, ResolvedKind.Branch, branch.TargetSha, ""); | |
| 148 | + } | |
| 149 | + else | |
| 150 | + { | |
| 151 | + // Only names from the repository's own ref list, or a hex SHA, get through. | |
| 152 | + _resolved = await Resolver.ResolveExactAsync(RepoPath, RefName, refs); | |
| 153 | + if (_resolved is null) | |
| 154 | + { | |
| 155 | + NotFound(); | |
| 156 | + return; | |
| 157 | + } | |
| 158 | + } | |
| 159 | + | |
| 160 | + var term = Query?.Trim() ?? ""; | |
| 161 | + if (term.Length < MinQueryLength || term.Length > MaxQueryLength || term.Any(char.IsControl)) | |
| 162 | + { | |
| 163 | + return; | |
| 164 | + } | |
| 165 | + | |
| 166 | + _term = term; | |
| 167 | + var allFiles = await Insights.ListFilesAsync(RepoPath, _resolved.CommitSha); | |
| 168 | + var named = allFiles.Where(f => f.Path.Contains(term, StringComparison.OrdinalIgnoreCase)).Take(MaxFiles + 1).ToList(); | |
| 169 | + _moreFiles = named.Count > MaxFiles; | |
| 170 | + _files = named.Take(MaxFiles).ToList(); | |
| 171 | + | |
| 172 | + var (matches, truncated) = await Git.GrepAsync(RepoPath, _resolved.CommitSha, term); | |
| 173 | + var groups = matches.GroupBy(m => m.Path).ToList(); | |
| 174 | + _truncated = truncated || groups.Count > MaxCodeFiles; | |
| 175 | + _groups = groups.Take(MaxCodeFiles).ToList(); | |
| 176 | + _matchCount = _groups.Sum(g => g.Count()); | |
| 177 | + } | |
| 178 | +} |
added forge/Features/Browse/Tree.razor +328 −0View file
| @@ -0,0 +1,328 @@ | ||
| 1 | +@page "/{Owner}/{Repo}" | |
| 2 | +@page "/{Owner}/{Repo}/tree/{*RefAndPath}" | |
| 3 | +@inherits RepoPageBase | |
| 4 | +@inject ContentCache Cache | |
| 5 | +@inject RepoInsights Insights | |
| 6 | +@inject MarkdownRenderer Markdown | |
| 7 | +@inject IOptions<ForgeOptions> Options | |
| 8 | + | |
| 9 | +@if (Repository is not null) | |
| 10 | +{ | |
| 11 | + <PageTitle>@(_resolved is { Path.Length: > 0 } ? $"{_resolved.Path} · " : "")@Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 12 | + <HeadContent> | |
| 13 | + <link rel="alternate" type="application/atom+xml" title="@T["Commits"]" href="@Urls.Atom(Repository)"/> | |
| 14 | + </HeadContent> | |
| 15 | + | |
| 16 | + <RepoHeader Repository="Repository" Active="code" IsOwner="IsOwner"/> | |
| 17 | + | |
| 18 | + @if (_resolved is null) | |
| 19 | + { | |
| 20 | + var cloneUrl = Urls.Clone(Options.Value, Repository); | |
| 21 | + <section class="card"> | |
| 22 | + <h2>@T["The repository is empty"]</h2> | |
| 23 | + <p>@T["Clone it and push the first commit:"]</p> | |
| 24 | + <pre class="snippet">git clone @cloneUrl | |
| 25 | +cd @Repository.Name | |
| 26 | +echo "# @Repository.Name" > README.md | |
| 27 | +git add README.md | |
| 28 | +git commit -m "First commit" | |
| 29 | +git push -u origin main</pre> | |
| 30 | + <p>@T["Or push an existing repository:"]</p> | |
| 31 | + <pre class="snippet">git remote add origin @cloneUrl | |
| 32 | +git push -u origin main</pre> | |
| 33 | + <p class="muted"> | |
| 34 | + @T["Use an access token with write permission as the password."] | |
| 35 | + @if (IsOwner) | |
| 36 | + { | |
| 37 | + <a href="/settings/tokens">@T["Create a token"]</a> | |
| 38 | + } | |
| 39 | + </p> | |
| 40 | + </section> | |
| 41 | + } | |
| 42 | + else | |
| 43 | + { | |
| 44 | + var atRoot = _resolved.Path.Length == 0; | |
| 45 | + <div class="@(atRoot ? "repo-layout with-side" : "repo-layout")"> | |
| 46 | + <div class="repo-content"> | |
| 47 | + <div class="toolbar"> | |
| 48 | + <RefSwitcher Refs="_refs" Current="@_resolved.Name" CurrentKind="_resolved.Kind" | |
| 49 | + UrlFor="@(name => Urls.Tree(Repository, name, _resolved.Path))"/> | |
| 50 | + <Breadcrumbs Repository="Repository" RefName="@_resolved.Name" Path="@_resolved.Path"/> | |
| 51 | + <form class="search repo-search toolbar-end" method="get" action="@Urls.Search(Repository)" role="search"> | |
| 52 | + <Icon Name="search" Size="15"/> | |
| 53 | + <input type="search" name="q" placeholder="@T["Search file names and code"]" | |
| 54 | + aria-label="@T["Search file names and code"]" autocomplete="off" data-hotkey="s"/> | |
| 55 | + <input type="hidden" name="ref" value="@_resolved.Name"/> | |
| 56 | + <kbd class="js-only">s</kbd> | |
| 57 | + </form> | |
| 58 | + <a class="button" href="@Urls.Commits(Repository, _resolved.Name, _resolved.Path)"> | |
| 59 | + <Icon Name="history"/> @T["History"] | |
| 60 | + </a> | |
| 61 | + </div> | |
| 62 | + | |
| 63 | + <div class="file-box"> | |
| 64 | + @if (_latest is not null) | |
| 65 | + { | |
| 66 | + <div class="latest-commit"> | |
| 67 | + <span class="latest-subject"> | |
| 68 | + <Avatar Name="@_latest.AuthorName"/> | |
| 69 | + <strong>@_latest.AuthorName</strong> | |
| 70 | + <a class="latest-message" href="@Urls.Commit(Repository, _latest.Sha)">@(_latest.Subject.Length == 0 ? T["(no message)"] : _latest.Subject)</a> | |
| 71 | + </span> | |
| 72 | + <span class="muted small latest-meta"> | |
| 73 | + <a class="sha" href="@Urls.Commit(Repository, _latest.Sha)">@_latest.ShortSha</a> | |
| 74 | + <span class="sep">·</span> | |
| 75 | + <TimeAgo Value="_latest.AuthorDate"/> | |
| 76 | + </span> | |
| 77 | + </div> | |
| 78 | + } | |
| 79 | + | |
| 80 | + <table class="table tree"> | |
| 81 | + <tbody> | |
| 82 | + @if (!atRoot) | |
| 83 | + { | |
| 84 | + <tr> | |
| 85 | + <td class="icon"><Icon Name="folder" Class="icon-folder"/></td> | |
| 86 | + <td colspan="3"><a href="@Urls.Tree(Repository, _resolved.Name, ParentPath)" title="@T["Parent directory"]">..</a></td> | |
| 87 | + </tr> | |
| 88 | + } | |
| 89 | + @foreach (var entry in _entries) | |
| 90 | + { | |
| 91 | + var path = atRoot ? entry.Name : _resolved.Path + "/" + entry.Name; | |
| 92 | + var last = _lastCommits.GetValueOrDefault(entry.Name); | |
| 93 | + <tr> | |
| 94 | + <td class="icon"> | |
| 95 | + @if (entry.IsTree) | |
| 96 | + { | |
| 97 | + <Icon Name="folder" Class="icon-folder"/> | |
| 98 | + } | |
| 99 | + else | |
| 100 | + { | |
| 101 | + <Icon Name="@(entry.IsSubmodule ? "package" : "file")"/> | |
| 102 | + } | |
| 103 | + </td> | |
| 104 | + <td class="name"> | |
| 105 | + @if (entry.IsTree) | |
| 106 | + { | |
| 107 | + <a href="@Urls.Tree(Repository, _resolved.Name, path)">@entry.Name</a> | |
| 108 | + } | |
| 109 | + else if (entry.IsBlob) | |
| 110 | + { | |
| 111 | + <a href="@Urls.Blob(Repository, _resolved.Name, path)" title="@(entry.Size is { } size ? Format.Size(size) : null)">@entry.Name</a> | |
| 112 | + } | |
| 113 | + else | |
| 114 | + { | |
| 115 | + <span title="@T["Submodule {0}", entry.Sha]">@entry.Name</span> | |
| 116 | + } | |
| 117 | + </td> | |
| 118 | + <td class="tree-commit small"> | |
| 119 | + @if (last is not null) | |
| 120 | + { | |
| 121 | + <a class="muted" href="@Urls.Commit(Repository, last.Sha)">@(last.Subject.Length == 0 ? T["(no message)"] : last.Subject)</a> | |
| 122 | + } | |
| 123 | + </td> | |
| 124 | + <td class="tree-age muted small right"> | |
| 125 | + @if (last is not null) | |
| 126 | + { | |
| 127 | + <TimeAgo Value="last.AuthorDate"/> | |
| 128 | + } | |
| 129 | + else if (entry is { IsBlob: true, Size: { } bytes }) | |
| 130 | + { | |
| 131 | + @Format.Size(bytes) | |
| 132 | + } | |
| 133 | + </td> | |
| 134 | + </tr> | |
| 135 | + } | |
| 136 | + </tbody> | |
| 137 | + </table> | |
| 138 | + </div> | |
| 139 | + | |
| 140 | + @if (_readmeHtml is not null) | |
| 141 | + { | |
| 142 | + <article class="card readme"> | |
| 143 | + <p class="readme-name"><Icon Name="book"/> @_readmeName</p> | |
| 144 | + @if (_readmeIsMarkdown) | |
| 145 | + { | |
| 146 | + <div class="markdown">@((MarkupString)_readmeHtml)</div> | |
| 147 | + } | |
| 148 | + else | |
| 149 | + { | |
| 150 | + <pre class="plain">@_readmeHtml</pre> | |
| 151 | + } | |
| 152 | + </article> | |
| 153 | + } | |
| 154 | + </div> | |
| 155 | + | |
| 156 | + @if (atRoot) | |
| 157 | + { | |
| 158 | + <aside class="repo-side"> | |
| 159 | + <section class="side-section"> | |
| 160 | + <h2>@T["About"]</h2> | |
| 161 | + <p class="@(Repository.Description.Length > 0 ? "" : "muted")"> | |
| 162 | + @(Repository.Description.Length > 0 ? Repository.Description : T["No description."]) | |
| 163 | + </p> | |
| 164 | + <ul class="side-list"> | |
| 165 | + <li> | |
| 166 | + <Icon Name="commit"/> | |
| 167 | + <a href="@Urls.Commits(Repository, _resolved.Name)">@T.Plural(_commitCount, "{0} commit", "{0} commits")</a> | |
| 168 | + </li> | |
| 169 | + <li> | |
| 170 | + <Icon Name="branch"/> | |
| 171 | + <a href="@Urls.Branches(Repository)">@T.Plural(_refs.Count(r => r.Kind == RefKind.Branch), "{0} branch", "{0} branches")</a> | |
| 172 | + </li> | |
| 173 | + <li> | |
| 174 | + <Icon Name="tag"/> | |
| 175 | + <a href="@Urls.Tags(Repository)">@T.Plural(_refs.Count(r => r.Kind == RefKind.Tag), "{0} tag", "{0} tags")</a> | |
| 176 | + </li> | |
| 177 | + <li> | |
| 178 | + <Icon Name="rss"/> | |
| 179 | + <a href="@Urls.Atom(Repository)">@T["Commit feed (Atom)"]</a> | |
| 180 | + </li> | |
| 181 | + </ul> | |
| 182 | + </section> | |
| 183 | + | |
| 184 | + @if (_languages.Count > 0) | |
| 185 | + { | |
| 186 | + <section class="side-section"> | |
| 187 | + <h2>@T["Languages"]</h2> | |
| 188 | + <LanguageBar Shares="_languages"/> | |
| 189 | + </section> | |
| 190 | + } | |
| 191 | + </aside> | |
| 192 | + } | |
| 193 | + </div> | |
| 194 | + } | |
| 195 | +} | |
| 196 | + | |
| 197 | +@code { | |
| 198 | + [Parameter] | |
| 199 | + public string? RefAndPath { get; set; } | |
| 200 | + | |
| 201 | + private IReadOnlyList<GitRef> _refs = []; | |
| 202 | + private ResolvedRef? _resolved; | |
| 203 | + private IReadOnlyList<TreeEntry> _entries = []; | |
| 204 | + private CommitInfo? _latest; | |
| 205 | + private IReadOnlyDictionary<string, CommitInfo> _lastCommits = new Dictionary<string, CommitInfo>(); | |
| 206 | + private int _commitCount; | |
| 207 | + private IReadOnlyList<LanguageShare> _languages = []; | |
| 208 | + private string? _readmeHtml; | |
| 209 | + private string? _readmeName; | |
| 210 | + private bool _readmeIsMarkdown; | |
| 211 | + | |
| 212 | + private string ParentPath => | |
| 213 | + _resolved!.Path.LastIndexOf('/') is var slash and >= 0 ? _resolved.Path[..slash] : ""; | |
| 214 | + | |
| 215 | + protected override async Task OnInitializedAsync() | |
| 216 | + { | |
| 217 | + if (!await LoadRepoAsync()) | |
| 218 | + { | |
| 219 | + return; | |
| 220 | + } | |
| 221 | + | |
| 222 | + var repo = Repository!; | |
| 223 | + _refs = await Git.ListRefsAsync(RepoPath); | |
| 224 | + | |
| 225 | + if (string.IsNullOrEmpty(RefAndPath)) | |
| 226 | + { | |
| 227 | + // Repository home: the default branch, or any branch if the default one is gone. | |
| 228 | + var branch = _refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == repo.DefaultBranch) | |
| 229 | + ?? _refs.FirstOrDefault(r => r.Kind == RefKind.Branch); | |
| 230 | + if (branch is null) | |
| 231 | + { | |
| 232 | + return; // Empty repository: the markup shows clone instructions. | |
| 233 | + } | |
| 234 | + | |
| 235 | + _resolved = new ResolvedRef(branch.Name, ResolvedKind.Branch, branch.TargetSha, ""); | |
| 236 | + } | |
| 237 | + else | |
| 238 | + { | |
| 239 | + _resolved = await Resolver.ResolveAsync(RepoPath, RefAndPath, _refs); | |
| 240 | + if (_resolved is null) | |
| 241 | + { | |
| 242 | + NotFound(); | |
| 243 | + return; | |
| 244 | + } | |
| 245 | + } | |
| 246 | + | |
| 247 | + string? treeSha; | |
| 248 | + if (_resolved.Path.Length == 0) | |
| 249 | + { | |
| 250 | + treeSha = await Git.GetRootTreeShaAsync(RepoPath, _resolved.CommitSha); | |
| 251 | + } | |
| 252 | + else | |
| 253 | + { | |
| 254 | + var entry = await Git.GetEntryAsync(RepoPath, _resolved.CommitSha, _resolved.Path); | |
| 255 | + if (entry is { IsBlob: true }) | |
| 256 | + { | |
| 257 | + Redirect(Urls.Blob(repo, _resolved.Name, _resolved.Path)); | |
| 258 | + return; | |
| 259 | + } | |
| 260 | + | |
| 261 | + treeSha = entry is { IsTree: true } ? entry.Sha : null; | |
| 262 | + } | |
| 263 | + | |
| 264 | + if (treeSha is null) | |
| 265 | + { | |
| 266 | + NotFound(); | |
| 267 | + return; | |
| 268 | + } | |
| 269 | + | |
| 270 | + // A tree SHA names its content forever, so the listing can be cached without invalidation. | |
| 271 | + var listing = await Cache.GetOrCreateAsync( | |
| 272 | + "tree:" + treeSha, | |
| 273 | + () => Git.ListTreeAsync(RepoPath, treeSha), | |
| 274 | + entries => entries.Sum(e => 120L + e.Name.Length * 2)); | |
| 275 | + _entries = listing | |
| 276 | + .OrderByDescending(e => e.IsTree) | |
| 277 | + .ThenBy(e => e.Name, StringComparer.OrdinalIgnoreCase) | |
| 278 | + .ToList(); | |
| 279 | + | |
| 280 | + _latest = await Git.GetCommitAsync(RepoPath, _resolved.CommitSha); | |
| 281 | + _lastCommits = await Insights.GetLastCommitsAsync( | |
| 282 | + RepoPath, _resolved.CommitSha, _resolved.Path, _entries.Select(e => e.Name).ToList()); | |
| 283 | + if (_resolved.Path.Length == 0) | |
| 284 | + { | |
| 285 | + _commitCount = await Insights.CountCommitsAsync(RepoPath, _resolved.CommitSha); | |
| 286 | + _languages = await Insights.GetLanguagesAsync(RepoPath, _resolved.CommitSha); | |
| 287 | + } | |
| 288 | + | |
| 289 | + await LoadReadmeAsync(repo, _resolved); | |
| 290 | + } | |
| 291 | + | |
| 292 | + private async Task LoadReadmeAsync(Repository repo, ResolvedRef resolved) | |
| 293 | + { | |
| 294 | + var readme = FileTypes.FindReadme(_entries.Where(e => e.IsBlob && !e.IsSymlink), e => e.Name); | |
| 295 | + if (readme is null || readme.Size is null or > FileTypes.MaxReadmeBytes) | |
| 296 | + { | |
| 297 | + return; | |
| 298 | + } | |
| 299 | + | |
| 300 | + _readmeName = readme.Name; | |
| 301 | + _readmeIsMarkdown = FileTypes.IsMarkdown(readme.Name); | |
| 302 | + var links = new LinkContext( | |
| 303 | + Urls.Raw(repo, resolved.Name, ""), | |
| 304 | + Urls.Blob(repo, resolved.Name, ""), | |
| 305 | + resolved.Path); | |
| 306 | + | |
| 307 | + // Rendered HTML depends on the blob and on where its relative links point. | |
| 308 | + var key = $"readme:{readme.Sha}:{_readmeIsMarkdown}:{links.RawBase}:{links.Directory}"; | |
| 309 | + _readmeHtml = await Cache.GetOrCreateAsync( | |
| 310 | + key, | |
| 311 | + async () => | |
| 312 | + { | |
| 313 | + var blob = await Git.ReadBlobAsync(RepoPath, readme.Sha, FileTypes.MaxReadmeBytes); | |
| 314 | + if (blob.IsBinary) | |
| 315 | + { | |
| 316 | + return ""; | |
| 317 | + } | |
| 318 | + | |
| 319 | + return _readmeIsMarkdown ? Markdown.Render(blob.Text, links) : blob.Text; | |
| 320 | + }, | |
| 321 | + html => html.Length * 2L); | |
| 322 | + | |
| 323 | + if (_readmeHtml.Length == 0) | |
| 324 | + { | |
| 325 | + _readmeHtml = null; | |
| 326 | + } | |
| 327 | + } | |
| 328 | +} |
added forge/Features/History/AtomEndpoint.cs +101 −0View file
| @@ -0,0 +1,101 @@ | ||
| 1 | +using System.Text; | |
| 2 | +using System.Xml; | |
| 3 | +using System.Xml.Linq; | |
| 4 | +using Forge.Data; | |
| 5 | +using Forge.Features.Auth; | |
| 6 | +using Forge.Features.Repos; | |
| 7 | +using Forge.Git; | |
| 8 | +using Microsoft.Extensions.Options; | |
| 9 | + | |
| 10 | +namespace Forge.Features.History; | |
| 11 | + | |
| 12 | +/// <summary>Atom feed of the latest commits on the default branch.</summary> | |
| 13 | +public static class AtomEndpoint | |
| 14 | +{ | |
| 15 | + private static readonly XNamespace Atom = "http://www.w3.org/2005/Atom"; | |
| 16 | + | |
| 17 | + public static void MapAtom(this IEndpointRouteBuilder app) => | |
| 18 | + app.MapGet("/{owner}/{repo}/atom", HandleAsync); | |
| 19 | + | |
| 20 | + private static async Task<IResult> HandleAsync( | |
| 21 | + HttpContext context, | |
| 22 | + string owner, | |
| 23 | + string repo, | |
| 24 | + RepoService repos, | |
| 25 | + CurrentUser me, | |
| 26 | + RepoPaths paths, | |
| 27 | + GitRepo git, | |
| 28 | + IOptions<ForgeOptions> options) | |
| 29 | + { | |
| 30 | + var ct = context.RequestAborted; | |
| 31 | + var repository = await repos.FindAsync(owner, repo, ct); | |
| 32 | + if (repository is null || !RepoAccess.CanRead(repository, me.Actor)) | |
| 33 | + { | |
| 34 | + return Results.NotFound(); | |
| 35 | + } | |
| 36 | + | |
| 37 | + var repoPath = paths.For(repository.Id); | |
| 38 | + var refs = await git.ListRefsAsync(repoPath, ct); | |
| 39 | + var branch = refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == repository.DefaultBranch) | |
| 40 | + ?? refs.FirstOrDefault(r => r.Kind == RefKind.Branch); | |
| 41 | + IReadOnlyList<CommitInfo> commits = branch is null | |
| 42 | + ? [] | |
| 43 | + : await git.LogAsync(repoPath, branch.TargetSha, take: 30, ct: ct); | |
| 44 | + | |
| 45 | + var document = Build(options.Value, repository, commits); | |
| 46 | + var bytes = Encoding.UTF8.GetBytes(document); | |
| 47 | + return Results.Bytes(bytes, "application/atom+xml; charset=utf-8"); | |
| 48 | + } | |
| 49 | + | |
| 50 | + public static string Build(ForgeOptions options, Repository repository, IReadOnlyList<CommitInfo> commits) | |
| 51 | + { | |
| 52 | + var repoUrl = Urls.Absolute(options, Urls.Repo(repository)); | |
| 53 | + var feedUrl = Urls.Absolute(options, Urls.Atom(repository)); | |
| 54 | + var updated = commits.Count > 0 | |
| 55 | + ? commits[0].CommitDate | |
| 56 | + : Format.Utc(repository.PushedAt ?? repository.CreatedAt); | |
| 57 | + | |
| 58 | + var feed = new XElement(Atom + "feed", | |
| 59 | + new XElement(Atom + "id", feedUrl), | |
| 60 | + new XElement(Atom + "title", $"{repository.Owner.Username}/{repository.Name}: commits"), | |
| 61 | + new XElement(Atom + "updated", Format.IsoTime(updated)), | |
| 62 | + new XElement(Atom + "link", new XAttribute("rel", "self"), new XAttribute("href", feedUrl)), | |
| 63 | + new XElement(Atom + "link", new XAttribute("rel", "alternate"), new XAttribute("href", repoUrl)), | |
| 64 | + commits.Select(c => | |
| 65 | + { | |
| 66 | + var url = Urls.Absolute(options, Urls.Commit(repository, c.Sha)); | |
| 67 | + return new XElement(Atom + "entry", | |
| 68 | + new XElement(Atom + "id", url), | |
| 69 | + new XElement(Atom + "title", Clean(c.Subject)), | |
| 70 | + new XElement(Atom + "updated", Format.IsoTime(c.CommitDate)), | |
| 71 | + new XElement(Atom + "link", new XAttribute("rel", "alternate"), new XAttribute("href", url)), | |
| 72 | + new XElement(Atom + "author", new XElement(Atom + "name", Clean(c.AuthorName))), | |
| 73 | + new XElement(Atom + "content", new XAttribute("type", "text"), | |
| 74 | + Clean(c.Body.Length == 0 ? c.Subject : c.Subject + "\n\n" + c.Body))); | |
| 75 | + })); | |
| 76 | + | |
| 77 | + var settings = new XmlWriterSettings { Indent = true, Encoding = new UTF8Encoding(false) }; | |
| 78 | + using var buffer = new MemoryStream(); | |
| 79 | + using (var writer = XmlWriter.Create(buffer, settings)) | |
| 80 | + { | |
| 81 | + new XDocument(feed).Save(writer); | |
| 82 | + } | |
| 83 | + | |
| 84 | + return Encoding.UTF8.GetString(buffer.ToArray()); | |
| 85 | + } | |
| 86 | + | |
| 87 | + /// <summary>Drops characters XML 1.0 cannot represent; commit messages can contain any byte.</summary> | |
| 88 | + private static string Clean(string value) | |
| 89 | + { | |
| 90 | + var builder = new StringBuilder(value.Length); | |
| 91 | + foreach (var rune in value.EnumerateRunes()) | |
| 92 | + { | |
| 93 | + if (rune.Value is 0x9 or 0xA or 0xD or >= 0x20 and <= 0xD7FF or >= 0xE000 and <= 0xFFFD or >= 0x10000) | |
| 94 | + { | |
| 95 | + builder.Append(rune.ToString()); | |
| 96 | + } | |
| 97 | + } | |
| 98 | + | |
| 99 | + return builder.ToString(); | |
| 100 | + } | |
| 101 | +} |
added forge/Features/History/BranchRules.cs +27 −0View file
| @@ -0,0 +1,27 @@ | ||
| 1 | +using Forge.Data; | |
| 2 | + | |
| 3 | +namespace Forge.Features.History; | |
| 4 | + | |
| 5 | +/// <summary>Matching of branch names against protection rules.</summary> | |
| 6 | +public static class BranchRules | |
| 7 | +{ | |
| 8 | + /// <summary>A pattern is a branch name, or a prefix ending in "/*" that covers every branch below it.</summary> | |
| 9 | + public static bool Matches(string pattern, string branch) => | |
| 10 | + pattern.EndsWith("/*", StringComparison.Ordinal) | |
| 11 | + ? branch.StartsWith(pattern[..^1], StringComparison.Ordinal) | |
| 12 | + : string.Equals(pattern, branch, StringComparison.Ordinal); | |
| 13 | + | |
| 14 | + public static BranchProtection? Find(IEnumerable<BranchProtection> rules, string branch) => | |
| 15 | + rules.FirstOrDefault(r => Matches(r.Pattern, branch)); | |
| 16 | + | |
| 17 | + /// <summary> | |
| 18 | + /// The ref prefix git's receive.hideRefs needs to refuse pushes to the pattern: | |
| 19 | + /// "refs/heads/main" for a name, "refs/heads/release/" for "release/*". | |
| 20 | + /// </summary> | |
| 21 | + public static string RefPrefix(string pattern) => | |
| 22 | + "refs/heads/" + (pattern.EndsWith("/*", StringComparison.Ordinal) ? pattern[..^1] : pattern); | |
| 23 | + | |
| 24 | + /// <summary>The part of a pattern that must be a valid branch name.</summary> | |
| 25 | + public static string NamePart(string pattern) => | |
| 26 | + pattern.EndsWith("/*", StringComparison.Ordinal) ? pattern[..^2] : pattern; | |
| 27 | +} |
added forge/Features/History/Branches.razor +209 −0View file
| @@ -0,0 +1,209 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/branches" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject ContentCache Cache | |
| 4 | +@inject RefService Refs | |
| 5 | + | |
| 6 | +@if (Repository is not null) | |
| 7 | +{ | |
| 8 | + <PageTitle>@T["Branches"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 9 | + | |
| 10 | + <RepoHeader Repository="Repository" Active="branches" IsOwner="IsOwner"/> | |
| 11 | + | |
| 12 | + @if (_message is not null) | |
| 13 | + { | |
| 14 | + <p class="alert success">@_message</p> | |
| 15 | + } | |
| 16 | + @if (_error is not null) | |
| 17 | + { | |
| 18 | + <p class="alert error">@_error</p> | |
| 19 | + } | |
| 20 | + | |
| 21 | + @if (_rows.Count == 0) | |
| 22 | + { | |
| 23 | + <div class="empty-state"> | |
| 24 | + <Icon Name="branch" Size="32"/> | |
| 25 | + <h2>@T["This repository has no branches yet."]</h2> | |
| 26 | + </div> | |
| 27 | + } | |
| 28 | + else | |
| 29 | + { | |
| 30 | + <form method="post" @formname="delete-branch" @onsubmit="DeleteAsync"> | |
| 31 | + <AntiforgeryToken/> | |
| 32 | + <table class="table"> | |
| 33 | + <thead> | |
| 34 | + <tr> | |
| 35 | + <th>@T["Branch"]</th> | |
| 36 | + <th>@T["Last commit"]</th> | |
| 37 | + <th class="right" title="@T["Commits ahead of and behind the default branch"]">@T["Compared to {0}", _defaultName]</th> | |
| 38 | + <th></th> | |
| 39 | + </tr> | |
| 40 | + </thead> | |
| 41 | + <tbody> | |
| 42 | + @foreach (var row in _rows) | |
| 43 | + { | |
| 44 | + <tr> | |
| 45 | + <td> | |
| 46 | + <Icon Name="branch" Class="cell-icon"/> | |
| 47 | + <a href="@Urls.Tree(Repository, row.Ref.Name)"><strong>@row.Ref.Name</strong></a> | |
| 48 | + @if (row.IsDefault) | |
| 49 | + { | |
| 50 | + <span class="badge">@T["default"]</span> | |
| 51 | + } | |
| 52 | + </td> | |
| 53 | + <td> | |
| 54 | + <a href="@Urls.Commit(Repository, row.Ref.TargetSha)">@row.Ref.Subject</a> | |
| 55 | + @if (row.Ref.Date is { } date) | |
| 56 | + { | |
| 57 | + <span class="muted small"> · <TimeAgo Value="date"/></span> | |
| 58 | + } | |
| 59 | + </td> | |
| 60 | + <td class="right small"> | |
| 61 | + @if (row.IsDefault) | |
| 62 | + { | |
| 63 | + <span class="muted">—</span> | |
| 64 | + } | |
| 65 | + else if (row.AheadBehind is { } ab) | |
| 66 | + { | |
| 67 | + <span title="@T["{0} ahead, {1} behind", ab.Ahead, ab.Behind]">↑@ab.Ahead ↓@ab.Behind</span> | |
| 68 | + } | |
| 69 | + </td> | |
| 70 | + <td class="right actions"> | |
| 71 | + @if (!row.IsDefault) | |
| 72 | + { | |
| 73 | + <a class="button small" href="@Urls.Compare(Repository, _defaultName, row.Ref.Name)">@T["Compare"]</a> | |
| 74 | + @if (IsOwner) | |
| 75 | + { | |
| 76 | + <button type="submit" name="DeleteName" value="@row.Ref.Name" class="button danger small">@T["Delete"]</button> | |
| 77 | + } | |
| 78 | + } | |
| 79 | + </td> | |
| 80 | + </tr> | |
| 81 | + } | |
| 82 | + </tbody> | |
| 83 | + </table> | |
| 84 | + </form> | |
| 85 | + | |
| 86 | + @if (IsOwner) | |
| 87 | + { | |
| 88 | + <section class="card"> | |
| 89 | + <h2>@T["New branch"]</h2> | |
| 90 | + <form method="post" @formname="create-branch" @onsubmit="CreateAsync" class="form"> | |
| 91 | + <AntiforgeryToken/> | |
| 92 | + <label> | |
| 93 | + @T["Name"] | |
| 94 | + <input name="NewName" value="@NewName" required maxlength="200"/> | |
| 95 | + </label> | |
| 96 | + <label> | |
| 97 | + <span>@T["From"] <span class="muted">@T["(branch, tag or commit SHA)"]</span></span> | |
| 98 | + <input name="From" value="@(From ?? _defaultName)" required maxlength="250"/> | |
| 99 | + </label> | |
| 100 | + <button type="submit" class="button primary">@T["Create branch"]</button> | |
| 101 | + </form> | |
| 102 | + </section> | |
| 103 | + } | |
| 104 | + } | |
| 105 | +} | |
| 106 | + | |
| 107 | +@code { | |
| 108 | + /// <summary>Ahead/behind costs one git process per branch, so it is computed for the first branches only.</summary> | |
| 109 | + private const int MaxCompared = 50; | |
| 110 | + | |
| 111 | + private sealed record Row(GitRef Ref, bool IsDefault, (int Ahead, int Behind)? AheadBehind); | |
| 112 | + | |
| 113 | + [SupplyParameterFromForm(FormName = "delete-branch")] | |
| 114 | + private string? DeleteName { get; set; } | |
| 115 | + | |
| 116 | + [SupplyParameterFromForm(FormName = "create-branch")] | |
| 117 | + private string? NewName { get; set; } | |
| 118 | + | |
| 119 | + [SupplyParameterFromForm(FormName = "create-branch")] | |
| 120 | + private string? From { get; set; } | |
| 121 | + | |
| 122 | + private List<Row> _rows = []; | |
| 123 | + private string _defaultName = ""; | |
| 124 | + private string? _message; | |
| 125 | + private string? _error; | |
| 126 | + | |
| 127 | + protected override async Task OnInitializedAsync() | |
| 128 | + { | |
| 129 | + if (await LoadRepoAsync()) | |
| 130 | + { | |
| 131 | + await LoadAsync(); | |
| 132 | + } | |
| 133 | + } | |
| 134 | + | |
| 135 | + private async Task LoadAsync() | |
| 136 | + { | |
| 137 | + var repo = Repository!; | |
| 138 | + _rows = []; | |
| 139 | + var branches = (await Git.ListRefsAsync(RepoPath)).Where(r => r.Kind == RefKind.Branch).ToList(); | |
| 140 | + var defaultBranch = branches.FirstOrDefault(b => b.Name == repo.DefaultBranch) ?? branches.FirstOrDefault(); | |
| 141 | + if (defaultBranch is null) | |
| 142 | + { | |
| 143 | + return; | |
| 144 | + } | |
| 145 | + | |
| 146 | + _defaultName = defaultBranch.Name; | |
| 147 | + _rows.Add(new Row(defaultBranch, true, null)); | |
| 148 | + | |
| 149 | + var compared = 0; | |
| 150 | + foreach (var branch in branches.Where(b => b != defaultBranch).OrderByDescending(b => b.Date)) | |
| 151 | + { | |
| 152 | + (int Ahead, int Behind)? counts = null; | |
| 153 | + if (compared++ < MaxCompared) | |
| 154 | + { | |
| 155 | + // Both SHAs are in the key, so the cached answer stays valid until either branch moves. | |
| 156 | + counts = await Cache.GetOrCreateAsync( | |
| 157 | + $"ab:{defaultBranch.TargetSha}:{branch.TargetSha}", | |
| 158 | + () => Git.AheadBehindAsync(RepoPath, defaultBranch.TargetSha, branch.TargetSha), | |
| 159 | + _ => 64); | |
| 160 | + } | |
| 161 | + | |
| 162 | + _rows.Add(new Row(branch, false, counts)); | |
| 163 | + } | |
| 164 | + } | |
| 165 | + | |
| 166 | + private async Task CreateAsync() | |
| 167 | + { | |
| 168 | + if (Repository is null || !IsOwner) | |
| 169 | + { | |
| 170 | + return; | |
| 171 | + } | |
| 172 | + | |
| 173 | + var name = NewName?.Trim() ?? ""; | |
| 174 | + var result = await Refs.CreateBranchAsync(Repository, name, From); | |
| 175 | + if (result.Ok) | |
| 176 | + { | |
| 177 | + _message = T["Branch {0} was created.", name]; | |
| 178 | + NewName = null; | |
| 179 | + From = null; | |
| 180 | + } | |
| 181 | + else | |
| 182 | + { | |
| 183 | + _error = T[result.Error!]; | |
| 184 | + } | |
| 185 | + | |
| 186 | + await LoadAsync(); | |
| 187 | + } | |
| 188 | + | |
| 189 | + private async Task DeleteAsync() | |
| 190 | + { | |
| 191 | + if (Repository is null || !IsOwner) | |
| 192 | + { | |
| 193 | + return; | |
| 194 | + } | |
| 195 | + | |
| 196 | + var result = await Refs.DeleteBranchAsync(Repository, DeleteName); | |
| 197 | + if (result.Ok) | |
| 198 | + { | |
| 199 | + // The SHA is shown so that a branch deleted by mistake can be created again from it. | |
| 200 | + _message = T["Branch {0} was deleted (it pointed at {1}).", DeleteName, result.Sha]; | |
| 201 | + } | |
| 202 | + else | |
| 203 | + { | |
| 204 | + _error = T[result.Error!]; | |
| 205 | + } | |
| 206 | + | |
| 207 | + await LoadAsync(); | |
| 208 | + } | |
| 209 | +} |
added forge/Features/History/Commit.razor +171 −0View file
| @@ -0,0 +1,171 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/commit/{Sha}" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject RefService Refs | |
| 4 | +@inject ForgeDb Db | |
| 5 | + | |
| 6 | +@if (Repository is not null && _commit is not null && _diff is not null) | |
| 7 | +{ | |
| 8 | + <PageTitle>@_commit.Subject · @_commit.ShortSha</PageTitle> | |
| 9 | + <HighlightAssets/> | |
| 10 | + | |
| 11 | + <RepoHeader Repository="Repository" Active="commits" IsOwner="IsOwner"/> | |
| 12 | + | |
| 13 | + @if (_error is not null) | |
| 14 | + { | |
| 15 | + <div class="alert error"> | |
| 16 | + <p>@_error</p> | |
| 17 | + @if (_conflicts.Count > 0) | |
| 18 | + { | |
| 19 | + <ul> | |
| 20 | + @foreach (var file in _conflicts) | |
| 21 | + { | |
| 22 | + <li><code>@file</code></li> | |
| 23 | + } | |
| 24 | + </ul> | |
| 25 | + } | |
| 26 | + </div> | |
| 27 | + } | |
| 28 | + | |
| 29 | + <section class="card commit-detail"> | |
| 30 | + <h2 class="commit-title">@(_commit.Subject.Length == 0 ? T["(no message)"] : _commit.Subject)</h2> | |
| 31 | + @if (_commit.Body.Length > 0) | |
| 32 | + { | |
| 33 | + <pre class="commit-body">@_commit.Body</pre> | |
| 34 | + } | |
| 35 | + <dl class="meta"> | |
| 36 | + <dt>@T["Author"]</dt> | |
| 37 | + <dd><Avatar Name="@_commit.AuthorName"/> @_commit.AuthorName <@_commit.AuthorEmail> · <TimeAgo Value="_commit.AuthorDate"/></dd> | |
| 38 | + @if (_commit.CommitterName != _commit.AuthorName || _commit.CommitterEmail != _commit.AuthorEmail) | |
| 39 | + { | |
| 40 | + <dt>@T["Committer"]</dt> | |
| 41 | + <dd>@_commit.CommitterName <@_commit.CommitterEmail> · <TimeAgo Value="_commit.CommitDate"/></dd> | |
| 42 | + } | |
| 43 | + <dt>@T["Commit"]</dt> | |
| 44 | + <dd> | |
| 45 | + <code>@_commit.Sha</code> | |
| 46 | + <button type="button" class="icon-button inline js-only" data-copy="@_commit.Sha" | |
| 47 | + title="@T["Copy the full SHA"]" aria-label="@T["Copy the full SHA"]"> | |
| 48 | + <Icon Name="copy" Size="14"/> | |
| 49 | + </button> | |
| 50 | + </dd> | |
| 51 | + <dt>@(_commit.Parents.Count == 1 ? T["Parent"] : T["Parents"])</dt> | |
| 52 | + <dd> | |
| 53 | + @if (_commit.Parents.Count == 0) | |
| 54 | + { | |
| 55 | + <span class="muted">@T["none (first commit)"]</span> | |
| 56 | + } | |
| 57 | + @foreach (var parent in _commit.Parents) | |
| 58 | + { | |
| 59 | + <a class="sha" href="@Urls.Commit(Repository, parent)">@(parent[..8])</a> | |
| 60 | + } | |
| 61 | + </dd> | |
| 62 | + </dl> | |
| 63 | + <p><a class="button" href="@Urls.Tree(Repository, _commit.Sha)"><Icon Name="code"/> @T["Browse files at this commit"]</a></p> | |
| 64 | + | |
| 65 | + @* Reverting and cherry-picking need exactly one parent to know what "this commit's change" is. *@ | |
| 66 | + @if (IsOwner && _commit.Parents.Count == 1 && _branches.Count > 0) | |
| 67 | + { | |
| 68 | + <form method="post" @formname="apply-commit" @onsubmit="ApplyAsync" class="toolbar apply-form"> | |
| 69 | + <AntiforgeryToken/> | |
| 70 | + <label> | |
| 71 | + <span class="muted">@T["Apply to branch"]</span> | |
| 72 | + <select name="Branch"> | |
| 73 | + @foreach (var branch in _branches) | |
| 74 | + { | |
| 75 | + <option value="@branch" selected="@(branch == Repository.DefaultBranch)">@branch</option> | |
| 76 | + } | |
| 77 | + </select> | |
| 78 | + </label> | |
| 79 | + <button type="submit" name="Action" value="revert" class="button">@T["Revert"]</button> | |
| 80 | + <button type="submit" name="Action" value="pick" class="button">@T["Cherry-pick"]</button> | |
| 81 | + </form> | |
| 82 | + } | |
| 83 | + </section> | |
| 84 | + | |
| 85 | + <h3> | |
| 86 | + @T.Plural(_diff.Stats.Count, "{0} changed file", "{0} changed files"): | |
| 87 | + <span class="added">+@_diff.Stats.Sum(s => s.Added ?? 0)</span> | |
| 88 | + <span class="deleted">−@_diff.Stats.Sum(s => s.Deleted ?? 0)</span> | |
| 89 | + </h3> | |
| 90 | + @if (_commit.Parents.Count > 1) | |
| 91 | + { | |
| 92 | + <p class="muted">@T["Merge commit: changes are shown against the first parent."]</p> | |
| 93 | + } | |
| 94 | + | |
| 95 | + <DiffOptions Path="@Urls.Commit(Repository, _commit.Sha)" Split="Split" IgnoreWhitespace="IgnoreWhitespace"/> | |
| 96 | + <DiffView Diff="_diff.Patch" Split="Split" Repository="Repository" HeadSha="@_commit.Sha"/> | |
| 97 | +} | |
| 98 | + | |
| 99 | +@code { | |
| 100 | + [Parameter] | |
| 101 | + public string Sha { get; set; } = ""; | |
| 102 | + | |
| 103 | + [SupplyParameterFromQuery(Name = "view")] | |
| 104 | + private string? View { get; set; } | |
| 105 | + | |
| 106 | + [SupplyParameterFromQuery(Name = "w")] | |
| 107 | + private string? Whitespace { get; set; } | |
| 108 | + | |
| 109 | + [SupplyParameterFromForm(FormName = "apply-commit")] | |
| 110 | + private string? Branch { get; set; } | |
| 111 | + | |
| 112 | + [SupplyParameterFromForm(FormName = "apply-commit")] | |
| 113 | + private string? Action { get; set; } | |
| 114 | + | |
| 115 | + private CommitInfo? _commit; | |
| 116 | + private CommitDiff? _diff; | |
| 117 | + private List<string> _branches = []; | |
| 118 | + private string? _error; | |
| 119 | + private IReadOnlyList<string> _conflicts = []; | |
| 120 | + | |
| 121 | + private bool Split => View == "split"; | |
| 122 | + private bool IgnoreWhitespace => Whitespace == "1"; | |
| 123 | + | |
| 124 | + protected override async Task OnInitializedAsync() | |
| 125 | + { | |
| 126 | + if (!await LoadRepoAsync()) | |
| 127 | + { | |
| 128 | + return; | |
| 129 | + } | |
| 130 | + | |
| 131 | + // ResolveCommitAsync accepts hex only, so nothing else from the URL reaches git. | |
| 132 | + var sha = await Git.ResolveCommitAsync(RepoPath, Sha); | |
| 133 | + _commit = sha is null ? null : await Git.GetCommitAsync(RepoPath, sha); | |
| 134 | + if (_commit is null) | |
| 135 | + { | |
| 136 | + NotFound(); | |
| 137 | + return; | |
| 138 | + } | |
| 139 | + | |
| 140 | + _diff = await Git.GetDiffAsync(RepoPath, _commit.Sha, IgnoreWhitespace); | |
| 141 | + if (IsOwner) | |
| 142 | + { | |
| 143 | + _branches = (await Git.ListRefsAsync(RepoPath)).Where(r => r.Kind == RefKind.Branch).Select(r => r.Name).ToList(); | |
| 144 | + } | |
| 145 | + } | |
| 146 | + | |
| 147 | + private async Task ApplyAsync() | |
| 148 | + { | |
| 149 | + if (Repository is null || _commit is null || !IsOwner || Action is not ("revert" or "pick")) | |
| 150 | + { | |
| 151 | + return; | |
| 152 | + } | |
| 153 | + | |
| 154 | + var user = await Db.Users.FindAsync(Me.UserId); | |
| 155 | + if (user is null) | |
| 156 | + { | |
| 157 | + return; | |
| 158 | + } | |
| 159 | + | |
| 160 | + var revert = Action == "revert"; | |
| 161 | + var result = await Refs.ApplyCommitAsync(Repository, Refs.IdentityFor(user), Branch ?? "", _commit.Sha, revert); | |
| 162 | + if (!result.Ok) | |
| 163 | + { | |
| 164 | + _error = T[result.Error!]; | |
| 165 | + _conflicts = result.Conflicts ?? []; | |
| 166 | + return; | |
| 167 | + } | |
| 168 | + | |
| 169 | + Redirect(Urls.Commit(Repository, result.Sha!)); | |
| 170 | + } | |
| 171 | +} |
added forge/Features/History/Commits.razor +104 −0View file
| @@ -0,0 +1,104 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/commits/{*RefAndPath}" | |
| 2 | +@inherits RepoPageBase | |
| 3 | + | |
| 4 | +@if (Repository is not null && _resolved is not null) | |
| 5 | +{ | |
| 6 | + <PageTitle>@T["Commits"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 7 | + | |
| 8 | + <RepoHeader Repository="Repository" Active="commits" IsOwner="IsOwner"/> | |
| 9 | + | |
| 10 | + <div class="toolbar"> | |
| 11 | + <RefSwitcher Refs="_refs" Current="@_resolved.Name" CurrentKind="_resolved.Kind" | |
| 12 | + UrlFor="@(name => Urls.Commits(Repository, name, _resolved.Path))"/> | |
| 13 | + @if (_resolved.Path.Length > 0) | |
| 14 | + { | |
| 15 | + <span class="muted">@T["History of path"]</span> | |
| 16 | + <Breadcrumbs Repository="Repository" RefName="@_resolved.Name" Path="@_resolved.Path"/> | |
| 17 | + <a class="toolbar-end" href="@Urls.Commits(Repository, _resolved.Name)">@T["Full history"]</a> | |
| 18 | + } | |
| 19 | + </div> | |
| 20 | + | |
| 21 | + @if (_commits.Count == 0) | |
| 22 | + { | |
| 23 | + <div class="card empty"><p>@T["No more commits."]</p></div> | |
| 24 | + } | |
| 25 | + else | |
| 26 | + { | |
| 27 | + <CommitList Repository="Repository" Commits="_commits" GroupByDay="true"/> | |
| 28 | + } | |
| 29 | + | |
| 30 | + <nav class="pager"> | |
| 31 | + @if (CurrentPage > 1) | |
| 32 | + { | |
| 33 | + <a class="button" href="@PageUrl(CurrentPage - 1)" rel="prev">@T["← Newer"]</a> | |
| 34 | + } | |
| 35 | + @if (_hasMore) | |
| 36 | + { | |
| 37 | + <a class="button" href="@PageUrl(CurrentPage + 1)" rel="next">@T["Older →"]</a> | |
| 38 | + } | |
| 39 | + </nav> | |
| 40 | +} | |
| 41 | + | |
| 42 | +@code { | |
| 43 | + public const int PageSize = 30; | |
| 44 | + | |
| 45 | + [Parameter] | |
| 46 | + public string? RefAndPath { get; set; } | |
| 47 | + | |
| 48 | + [SupplyParameterFromQuery(Name = "page")] | |
| 49 | + private int? PageNumber { get; set; } | |
| 50 | + | |
| 51 | + private IReadOnlyList<GitRef> _refs = []; | |
| 52 | + private ResolvedRef? _resolved; | |
| 53 | + private IReadOnlyList<CommitInfo> _commits = []; | |
| 54 | + private bool _hasMore; | |
| 55 | + | |
| 56 | + private int CurrentPage => Math.Clamp(PageNumber ?? 1, 1, 100_000); | |
| 57 | + | |
| 58 | + private string PageUrl(int page) => | |
| 59 | + Urls.Commits(Repository!, _resolved!.Name, _resolved.Path) | |
| 60 | + + (page > 1 ? "?page=" + page.ToString(CultureInfo.InvariantCulture) : ""); | |
| 61 | + | |
| 62 | + protected override async Task OnInitializedAsync() | |
| 63 | + { | |
| 64 | + if (!await LoadRepoAsync()) | |
| 65 | + { | |
| 66 | + return; | |
| 67 | + } | |
| 68 | + | |
| 69 | + var repo = Repository!; | |
| 70 | + _refs = await Git.ListRefsAsync(RepoPath); | |
| 71 | + | |
| 72 | + if (string.IsNullOrEmpty(RefAndPath)) | |
| 73 | + { | |
| 74 | + var branch = _refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == repo.DefaultBranch) | |
| 75 | + ?? _refs.FirstOrDefault(r => r.Kind == RefKind.Branch); | |
| 76 | + if (branch is null) | |
| 77 | + { | |
| 78 | + Redirect(Urls.Repo(repo)); | |
| 79 | + return; | |
| 80 | + } | |
| 81 | + | |
| 82 | + _resolved = new ResolvedRef(branch.Name, ResolvedKind.Branch, branch.TargetSha, ""); | |
| 83 | + } | |
| 84 | + else | |
| 85 | + { | |
| 86 | + _resolved = await Resolver.ResolveAsync(RepoPath, RefAndPath, _refs); | |
| 87 | + if (_resolved is null) | |
| 88 | + { | |
| 89 | + NotFound(); | |
| 90 | + return; | |
| 91 | + } | |
| 92 | + } | |
| 93 | + | |
| 94 | + // One extra row tells whether there is a next page, without counting the whole history. | |
| 95 | + var rows = await Git.LogAsync( | |
| 96 | + RepoPath, | |
| 97 | + _resolved.CommitSha, | |
| 98 | + _resolved.Path.Length == 0 ? null : _resolved.Path, | |
| 99 | + skip: (CurrentPage - 1) * PageSize, | |
| 100 | + take: PageSize + 1); | |
| 101 | + _hasMore = rows.Count > PageSize; | |
| 102 | + _commits = _hasMore ? rows.Take(PageSize).ToList() : rows; | |
| 103 | + } | |
| 104 | +} |
added forge/Features/History/Compare.razor +326 −0View file
| @@ -0,0 +1,326 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/compare/{*Range}" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject RefService Refs | |
| 4 | +@inject PullRequestService Pulls | |
| 5 | +@inject ForgeDb Db | |
| 6 | + | |
| 7 | +@if (Repository is not null) | |
| 8 | +{ | |
| 9 | + <PageTitle>@T["Compare"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 10 | + <HighlightAssets/> | |
| 11 | + | |
| 12 | + <RepoHeader Repository="Repository" Active="branches" IsOwner="IsOwner"/> | |
| 13 | + | |
| 14 | + @* A plain GET form: the page turns ?base=&head= into the canonical /compare/base...head address. *@ | |
| 15 | + <form method="get" action="@Urls.Compare(Repository)" class="toolbar compare-form"> | |
| 16 | + <label> | |
| 17 | + <span class="muted">@T["Merge into"]</span> | |
| 18 | + <select name="base"> | |
| 19 | + @foreach (var name in _choices) | |
| 20 | + { | |
| 21 | + <option value="@name" selected="@(name == (_base?.Name ?? Repository.DefaultBranch))">@name</option> | |
| 22 | + } | |
| 23 | + </select> | |
| 24 | + </label> | |
| 25 | + <label> | |
| 26 | + <span class="muted">@T["from"]</span> | |
| 27 | + <select name="head"> | |
| 28 | + @foreach (var name in _choices) | |
| 29 | + { | |
| 30 | + <option value="@name" selected="@(name == _head?.Name)">@name</option> | |
| 31 | + } | |
| 32 | + </select> | |
| 33 | + </label> | |
| 34 | + <button type="submit" class="button">@T["Show comparison"]</button> | |
| 35 | + </form> | |
| 36 | + | |
| 37 | + @if (_error is not null) | |
| 38 | + { | |
| 39 | + <div class="alert error"> | |
| 40 | + <p>@_error</p> | |
| 41 | + @if (_errorConflicts.Count > 0) | |
| 42 | + { | |
| 43 | + <ul> | |
| 44 | + @foreach (var file in _errorConflicts) | |
| 45 | + { | |
| 46 | + <li><code>@file</code></li> | |
| 47 | + } | |
| 48 | + </ul> | |
| 49 | + } | |
| 50 | + </div> | |
| 51 | + } | |
| 52 | + | |
| 53 | + @if (_base is null || _head is null) | |
| 54 | + { | |
| 55 | + <div class="card empty"><p>@T["Choose two branches to compare."]</p></div> | |
| 56 | + } | |
| 57 | + else if (_base.CommitSha == _head.CommitSha) | |
| 58 | + { | |
| 59 | + <div class="card empty"><p>@T["These are the same commit. There is nothing to compare."]</p></div> | |
| 60 | + } | |
| 61 | + else | |
| 62 | + { | |
| 63 | + @if (_check is not null) | |
| 64 | + { | |
| 65 | + @if (_openPull is not null) | |
| 66 | + { | |
| 67 | + <p class="alert success"> | |
| 68 | + @T["There is an open pull request for these branches:"] | |
| 69 | + <a href="@Urls.Pull(Repository, _openPull.Number)">#@_openPull.Number @_openPull.Title</a> | |
| 70 | + </p> | |
| 71 | + } | |
| 72 | + else if (!_check.NothingToMerge && !_check.Unrelated) | |
| 73 | + { | |
| 74 | + <details class="card"> | |
| 75 | + <summary><strong>@T["Open a pull request"]</strong></summary> | |
| 76 | + <form method="post" @formname="open-pull" @onsubmit="OpenPullAsync" class="form"> | |
| 77 | + <AntiforgeryToken/> | |
| 78 | + <label> | |
| 79 | + @T["Title"] | |
| 80 | + <input name="Title" value="@(Title ?? _defaultTitle)" required maxlength="@PullRequestService.MaxTitleLength"/> | |
| 81 | + </label> | |
| 82 | + <label> | |
| 83 | + <span>@T["Description"] <span class="muted">@T["(optional, Markdown)"]</span></span> | |
| 84 | + <textarea name="Description" rows="5">@Description</textarea> | |
| 85 | + </label> | |
| 86 | + <button type="submit" class="button primary">@T["Open pull request"]</button> | |
| 87 | + </form> | |
| 88 | + </details> | |
| 89 | + } | |
| 90 | + | |
| 91 | + <section class="card"> | |
| 92 | + <h2>@T["Merge {0} into {1}", _head.Name, _base.Name]</h2> | |
| 93 | + @if (_check.NothingToMerge) | |
| 94 | + { | |
| 95 | + <p class="muted">@T["{0} is already part of {1}. There is nothing to merge.", _head.Name, _base.Name]</p> | |
| 96 | + } | |
| 97 | + else if (_check.Unrelated) | |
| 98 | + { | |
| 99 | + <p class="alert warning">@T["The branches have no common history and cannot be merged here."]</p> | |
| 100 | + } | |
| 101 | + else if (_check.Conflicts.Count > 0) | |
| 102 | + { | |
| 103 | + <p class="alert warning">@T["These branches have conflicts."]</p> | |
| 104 | + <p>@T["Conflicting files:"]</p> | |
| 105 | + <ul> | |
| 106 | + @foreach (var file in _check.Conflicts) | |
| 107 | + { | |
| 108 | + <li><code>@file</code></li> | |
| 109 | + } | |
| 110 | + </ul> | |
| 111 | + <a class="button primary" href="@Urls.Conflicts(Repository, _base.Name, _head.Name)">@T["Resolve conflicts"]</a> | |
| 112 | + } | |
| 113 | + else | |
| 114 | + { | |
| 115 | + <p class="alert success">@T["These branches can be merged automatically."]</p> | |
| 116 | + <form method="post" @formname="merge" @onsubmit="MergeAsync" class="form"> | |
| 117 | + <AntiforgeryToken/> | |
| 118 | + <MergeFields CanFastForward="_check.CanFastForward" AllowDelete="@(_head.Name != Repository.DefaultBranch)" | |
| 119 | + HeadName="@_head.Name" Message="@Message"/> | |
| 120 | + <button type="submit" class="button primary">@T["Merge"]</button> | |
| 121 | + </form> | |
| 122 | + } | |
| 123 | + </section> | |
| 124 | + } | |
| 125 | + | |
| 126 | + <h3>@T.Plural(_commits.Count, "{0} commit", "{0} commits")</h3> | |
| 127 | + @if (_commits.Count == 0) | |
| 128 | + { | |
| 129 | + <div class="card empty"><p>@T["There are no new commits between these two commits."]</p></div> | |
| 130 | + } | |
| 131 | + else | |
| 132 | + { | |
| 133 | + <CommitList Repository="Repository" Commits="_commits"/> | |
| 134 | + @if (_commits.Count == MaxCommits) | |
| 135 | + { | |
| 136 | + <p class="muted">@T["Showing the first {0} commits.", MaxCommits]</p> | |
| 137 | + } | |
| 138 | + } | |
| 139 | + | |
| 140 | + @if (_diff is not null) | |
| 141 | + { | |
| 142 | + <h3> | |
| 143 | + @T.Plural(_diff.Stats.Count, "{0} changed file", "{0} changed files"): | |
| 144 | + <span class="added">+@_diff.Stats.Sum(s => s.Added ?? 0)</span> | |
| 145 | + <span class="deleted">−@_diff.Stats.Sum(s => s.Deleted ?? 0)</span> | |
| 146 | + </h3> | |
| 147 | + <DiffOptions Path="@PageUrl(_direct)" Split="Split" IgnoreWhitespace="IgnoreWhitespace"> | |
| 148 | + @* "..." shows what the head added since the branches diverged; ".." is the plain difference between the two tips. *@ | |
| 149 | + <a href="@(PageUrl(!_direct) + DiffOptions.Query(Split, IgnoreWhitespace))"> | |
| 150 | + @(_direct ? T["Show changes since the branches diverged"] : T["Show the direct difference between both ends"]) | |
| 151 | + </a> | |
| 152 | + </DiffOptions> | |
| 153 | + <DiffView Diff="_diff.Patch" Split="Split" Repository="Repository" HeadSha="@_head.CommitSha"/> | |
| 154 | + } | |
| 155 | + } | |
| 156 | +} | |
| 157 | + | |
| 158 | +@code { | |
| 159 | + private const int MaxCommits = 250; | |
| 160 | + | |
| 161 | + /// <summary> | |
| 162 | + /// "<base>...<head>" or "<base>..<head>". Each side is a branch, a tag or a commit SHA. | |
| 163 | + /// Three dots diff from the point where the two diverged, two dots diff the two ends directly. | |
| 164 | + /// </summary> | |
| 165 | + [Parameter] | |
| 166 | + public string? Range { get; set; } | |
| 167 | + | |
| 168 | + [SupplyParameterFromQuery(Name = "base")] | |
| 169 | + private string? BaseQuery { get; set; } | |
| 170 | + | |
| 171 | + [SupplyParameterFromQuery(Name = "head")] | |
| 172 | + private string? HeadQuery { get; set; } | |
| 173 | + | |
| 174 | + [SupplyParameterFromQuery(Name = "view")] | |
| 175 | + private string? View { get; set; } | |
| 176 | + | |
| 177 | + [SupplyParameterFromQuery(Name = "w")] | |
| 178 | + private string? Whitespace { get; set; } | |
| 179 | + | |
| 180 | + [SupplyParameterFromForm(FormName = "merge")] | |
| 181 | + private string? Method { get; set; } | |
| 182 | + | |
| 183 | + [SupplyParameterFromForm(FormName = "merge")] | |
| 184 | + private string? Message { get; set; } | |
| 185 | + | |
| 186 | + [SupplyParameterFromForm(FormName = "merge")] | |
| 187 | + private bool DeleteBranch { get; set; } | |
| 188 | + | |
| 189 | + [SupplyParameterFromForm(FormName = "open-pull")] | |
| 190 | + private string? Title { get; set; } | |
| 191 | + | |
| 192 | + [SupplyParameterFromForm(FormName = "open-pull")] | |
| 193 | + private string? Description { get; set; } | |
| 194 | + | |
| 195 | + private List<string> _choices = []; | |
| 196 | + private ResolvedRef? _base; | |
| 197 | + private ResolvedRef? _head; | |
| 198 | + private bool _direct; | |
| 199 | + private string? _mergeBase; | |
| 200 | + private IReadOnlyList<CommitInfo> _commits = []; | |
| 201 | + private CommitDiff? _diff; | |
| 202 | + private MergeCheck? _check; | |
| 203 | + private PullRequest? _openPull; | |
| 204 | + private string _defaultTitle = ""; | |
| 205 | + private string? _error; | |
| 206 | + private IReadOnlyList<string> _errorConflicts = []; | |
| 207 | + | |
| 208 | + private bool Split => View == "split"; | |
| 209 | + private bool IgnoreWhitespace => Whitespace == "1"; | |
| 210 | + | |
| 211 | + private string PageUrl(bool direct) | |
| 212 | + { | |
| 213 | + var url = Urls.Compare(Repository!, _base!.Name, _head!.Name); | |
| 214 | + return direct ? url.Replace("...", "..", StringComparison.Ordinal) : url; | |
| 215 | + } | |
| 216 | + | |
| 217 | + protected override async Task OnInitializedAsync() | |
| 218 | + { | |
| 219 | + if (!await LoadRepoAsync()) | |
| 220 | + { | |
| 221 | + return; | |
| 222 | + } | |
| 223 | + | |
| 224 | + var repo = Repository!; | |
| 225 | + var refs = await Git.ListRefsAsync(RepoPath); | |
| 226 | + _choices = refs.Where(r => r.Kind == RefKind.Branch).Select(r => r.Name).ToList(); | |
| 227 | + | |
| 228 | + if (string.IsNullOrEmpty(Range)) | |
| 229 | + { | |
| 230 | + if (!string.IsNullOrEmpty(BaseQuery) && !string.IsNullOrEmpty(HeadQuery)) | |
| 231 | + { | |
| 232 | + Redirect(Urls.Compare(repo, BaseQuery, HeadQuery)); | |
| 233 | + } | |
| 234 | + | |
| 235 | + return; // Nothing chosen yet: the markup shows only the picker. | |
| 236 | + } | |
| 237 | + | |
| 238 | + // Ref names cannot contain "..", so the first occurrence is the separator. | |
| 239 | + var split = Range.IndexOf("..", StringComparison.Ordinal); | |
| 240 | + if (split > 0) | |
| 241 | + { | |
| 242 | + _direct = !Range.AsSpan(split).StartsWith("..."); | |
| 243 | + _base = await Resolver.ResolveExactAsync(RepoPath, Range[..split], refs); | |
| 244 | + _head = await Resolver.ResolveExactAsync(RepoPath, Range[(split + (_direct ? 2 : 3))..], refs); | |
| 245 | + } | |
| 246 | + | |
| 247 | + if (_base is null || _head is null) | |
| 248 | + { | |
| 249 | + NotFound(); | |
| 250 | + return; | |
| 251 | + } | |
| 252 | + | |
| 253 | + if (_base.CommitSha == _head.CommitSha) | |
| 254 | + { | |
| 255 | + return; | |
| 256 | + } | |
| 257 | + | |
| 258 | + _mergeBase = await Git.MergeBaseAsync(RepoPath, _base.CommitSha, _head.CommitSha); | |
| 259 | + _commits = await Git.LogRangeAsync(RepoPath, _base.CommitSha, _head.CommitSha, MaxCommits); | |
| 260 | + var from = _direct ? _base.CommitSha : _mergeBase ?? _base.CommitSha; | |
| 261 | + _diff = await Git.GetRangeDiffAsync(RepoPath, from, _head.CommitSha, IgnoreWhitespace); | |
| 262 | + | |
| 263 | + // Merging is offered to the owner, and only between two branches. | |
| 264 | + if (IsOwner && _base.Kind == ResolvedKind.Branch && _head.Kind == ResolvedKind.Branch) | |
| 265 | + { | |
| 266 | + _check = await Refs.CheckMergeAsync(RepoPath, _base.CommitSha, _head.CommitSha); | |
| 267 | + _openPull = await Db.PullRequests.FirstOrDefaultAsync(p => | |
| 268 | + p.RepoId == repo.Id | |
| 269 | + && p.Status == PullRequestStatus.Open | |
| 270 | + && p.BaseBranch == _base.Name | |
| 271 | + && p.HeadBranch == _head.Name); | |
| 272 | + _defaultTitle = _commits.Count == 1 ? _commits[0].Subject : _head.Name; | |
| 273 | + } | |
| 274 | + } | |
| 275 | + | |
| 276 | + private async Task OpenPullAsync() | |
| 277 | + { | |
| 278 | + // _check is only set for the owner and two branches, so this also guards the handler. | |
| 279 | + if (Repository is null || _base is null || _head is null || _check is null) | |
| 280 | + { | |
| 281 | + return; | |
| 282 | + } | |
| 283 | + | |
| 284 | + var (pull, error) = await Pulls.CreateAsync(Repository, Me.UserId!.Value, Title, Description, _base.Name, _head.Name); | |
| 285 | + if (pull is null) | |
| 286 | + { | |
| 287 | + _error = T[error!]; | |
| 288 | + return; | |
| 289 | + } | |
| 290 | + | |
| 291 | + Redirect(Urls.Pull(Repository, pull.Number)); | |
| 292 | + } | |
| 293 | + | |
| 294 | + private async Task MergeAsync() | |
| 295 | + { | |
| 296 | + if (Repository is null || _base is null || _head is null || _check is null) | |
| 297 | + { | |
| 298 | + return; | |
| 299 | + } | |
| 300 | + | |
| 301 | + var user = await Db.Users.FindAsync(Me.UserId); | |
| 302 | + if (user is null) | |
| 303 | + { | |
| 304 | + return; | |
| 305 | + } | |
| 306 | + | |
| 307 | + var result = await Refs.MergeAsync( | |
| 308 | + Repository, Refs.IdentityFor(user), _base.Name, _head.Name, MergeFields.Parse(Method), Message); | |
| 309 | + if (!result.Ok) | |
| 310 | + { | |
| 311 | + _error = T[result.Error!]; | |
| 312 | + _errorConflicts = result.Conflicts ?? []; | |
| 313 | + return; | |
| 314 | + } | |
| 315 | + | |
| 316 | + // A pull request for the same branches is done as well. | |
| 317 | + await Pulls.MarkMergedAsync(Repository, _base.Name, _head.Name, _mergeBase, _head.CommitSha, result.Sha); | |
| 318 | + if (DeleteBranch) | |
| 319 | + { | |
| 320 | + // Refused for the default or a protected branch; a failure here does not undo the merge. | |
| 321 | + await Refs.DeleteBranchAsync(Repository, _head.Name); | |
| 322 | + } | |
| 323 | + | |
| 324 | + Redirect(Urls.Tree(Repository, _base.Name)); | |
| 325 | + } | |
| 326 | +} |
added forge/Features/History/Conflicts.razor +175 −0View file
| @@ -0,0 +1,175 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/conflicts/{*Range}" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject RefService Refs | |
| 4 | +@inject PullRequestService Pulls | |
| 5 | +@inject ForgeDb Db | |
| 6 | +@inject IHttpContextAccessor Http | |
| 7 | + | |
| 8 | +@if (Repository is not null && _base is not null && _head is not null) | |
| 9 | +{ | |
| 10 | + <PageTitle>@T["Resolve conflicts"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 11 | + | |
| 12 | + <RepoHeader Repository="Repository" Active="branches" IsOwner="IsOwner"/> | |
| 13 | + | |
| 14 | + <h2>@T["Resolve conflicts: {0} into {1}", _head.Name, _base.Name]</h2> | |
| 15 | + | |
| 16 | + @if (_error is not null) | |
| 17 | + { | |
| 18 | + <p class="alert error">@_error</p> | |
| 19 | + } | |
| 20 | + | |
| 21 | + @if (_files.Count == 0) | |
| 22 | + { | |
| 23 | + <div class="card empty"> | |
| 24 | + <p>@T["These branches have no conflicts."]</p> | |
| 25 | + <p><a href="@Urls.Compare(Repository, _base.Name, _head.Name)">@T["Back to the comparison"]</a></p> | |
| 26 | + </div> | |
| 27 | + } | |
| 28 | + else | |
| 29 | + { | |
| 30 | + <p class="muted">@T["Choose a version for every file, or edit the text and remove the conflict markers. Saving creates the merge commit."]</p> | |
| 31 | + | |
| 32 | + <form method="post" @formname="resolve" @onsubmit="ResolveAsync" class="form"> | |
| 33 | + <AntiforgeryToken/> | |
| 34 | + @* The SHAs the choices were made against; if a branch moves in the meantime, nothing is merged. *@ | |
| 35 | + <input type="hidden" name="base_sha" value="@_base.CommitSha"/> | |
| 36 | + <input type="hidden" name="head_sha" value="@_head.CommitSha"/> | |
| 37 | + | |
| 38 | + @for (var i = 0; i < _files.Count; i++) | |
| 39 | + { | |
| 40 | + var file = _files[i]; | |
| 41 | + var editable = file.MarkerText is not null; | |
| 42 | + <fieldset class="conflict"> | |
| 43 | + <legend><code>@file.Path</code></legend> | |
| 44 | + <label class="choice"> | |
| 45 | + <input type="radio" name="@($"choice_{i}")" value="ours" required/> | |
| 46 | + @(file.OnBase ? T["Keep the version from {0}", _base.Name] : T["Delete the file (as on {0})", _base.Name]) | |
| 47 | + </label> | |
| 48 | + <label class="choice"> | |
| 49 | + <input type="radio" name="@($"choice_{i}")" value="theirs"/> | |
| 50 | + @(file.OnHead ? T["Take the version from {0}", _head.Name] : T["Delete the file (as on {0})", _head.Name]) | |
| 51 | + </label> | |
| 52 | + @if (editable) | |
| 53 | + { | |
| 54 | + <label class="choice"> | |
| 55 | + <input type="radio" name="@($"choice_{i}")" value="edit" checked/> | |
| 56 | + @T["Use the text below"] | |
| 57 | + </label> | |
| 58 | + <textarea name="@($"text_{i}")" rows="@Rows(file.MarkerText!)" class="code-input" spellcheck="false">@file.MarkerText</textarea> | |
| 59 | + } | |
| 60 | + else | |
| 61 | + { | |
| 62 | + <p class="muted small">@T["This file is binary or too large to edit here."]</p> | |
| 63 | + } | |
| 64 | + </fieldset> | |
| 65 | + } | |
| 66 | + | |
| 67 | + <label> | |
| 68 | + <span>@T["Commit message"] <span class="muted">@T["(optional, a default is used if empty)"]</span></span> | |
| 69 | + <input name="message" maxlength="2000"/> | |
| 70 | + </label> | |
| 71 | + <button type="submit" class="button primary">@T["Resolve and merge"]</button> | |
| 72 | + </form> | |
| 73 | + } | |
| 74 | +} | |
| 75 | + | |
| 76 | +@code { | |
| 77 | + /// <summary>"<base>...<head>", two branch names.</summary> | |
| 78 | + [Parameter] | |
| 79 | + public string? Range { get; set; } | |
| 80 | + | |
| 81 | + private ResolvedRef? _base; | |
| 82 | + private ResolvedRef? _head; | |
| 83 | + private IReadOnlyList<ConflictFile> _files = []; | |
| 84 | + private string? _error; | |
| 85 | + | |
| 86 | + private static int Rows(string text) => Math.Clamp(text.AsSpan().Count('\n') + 2, 6, 30); | |
| 87 | + | |
| 88 | + protected override async Task OnInitializedAsync() | |
| 89 | + { | |
| 90 | + // Resolving a conflict writes a commit, so the whole page is for the owner only. | |
| 91 | + if (!await LoadRepoAsync(requireAdmin: true)) | |
| 92 | + { | |
| 93 | + return; | |
| 94 | + } | |
| 95 | + | |
| 96 | + var refs = await Git.ListRefsAsync(RepoPath); | |
| 97 | + var split = Range?.IndexOf("...", StringComparison.Ordinal) ?? -1; | |
| 98 | + if (split > 0) | |
| 99 | + { | |
| 100 | + _base = await Resolver.ResolveExactAsync(RepoPath, Range![..split], refs); | |
| 101 | + _head = await Resolver.ResolveExactAsync(RepoPath, Range[(split + 3)..], refs); | |
| 102 | + } | |
| 103 | + | |
| 104 | + if (_base is not { Kind: ResolvedKind.Branch } || _head is not { Kind: ResolvedKind.Branch }) | |
| 105 | + { | |
| 106 | + _base = null; | |
| 107 | + NotFound(); | |
| 108 | + return; | |
| 109 | + } | |
| 110 | + | |
| 111 | + _files = await Refs.GetConflictsAsync(RepoPath, _base.CommitSha, _head.CommitSha); | |
| 112 | + } | |
| 113 | + | |
| 114 | + private async Task ResolveAsync() | |
| 115 | + { | |
| 116 | + var form = Http.HttpContext?.Request.Form; | |
| 117 | + if (Repository is null || _base is null || _head is null || form is null) | |
| 118 | + { | |
| 119 | + return; | |
| 120 | + } | |
| 121 | + | |
| 122 | + var user = await Db.Users.FindAsync(Me.UserId); | |
| 123 | + if (user is null) | |
| 124 | + { | |
| 125 | + return; | |
| 126 | + } | |
| 127 | + | |
| 128 | + // The form has one group of fields per file, numbered in the order the files are listed. | |
| 129 | + var resolutions = new Dictionary<string, Resolution>(StringComparer.Ordinal); | |
| 130 | + for (var i = 0; i < _files.Count; i++) | |
| 131 | + { | |
| 132 | + var file = _files[i]; | |
| 133 | + switch (form[$"choice_{i}"].ToString()) | |
| 134 | + { | |
| 135 | + case "ours": | |
| 136 | + resolutions[file.Path] = new Resolution(ResolutionKind.Ours); | |
| 137 | + break; | |
| 138 | + case "theirs": | |
| 139 | + resolutions[file.Path] = new Resolution(ResolutionKind.Theirs); | |
| 140 | + break; | |
| 141 | + case "edit" when file.MarkerText is not null: | |
| 142 | + // Browsers submit textarea line breaks as CRLF; keep the line endings the file had. | |
| 143 | + var text = form[$"text_{i}"].ToString().Replace("\r\n", "\n"); | |
| 144 | + if (file.MarkerText.Contains("\r\n", StringComparison.Ordinal)) | |
| 145 | + { | |
| 146 | + text = text.Replace("\n", "\r\n"); | |
| 147 | + } | |
| 148 | + | |
| 149 | + resolutions[file.Path] = new Resolution(ResolutionKind.Edited, text); | |
| 150 | + break; | |
| 151 | + } | |
| 152 | + } | |
| 153 | + | |
| 154 | + var mergeBase = await Git.MergeBaseAsync(RepoPath, _base.CommitSha, _head.CommitSha); | |
| 155 | + var result = await Refs.ResolveAndMergeAsync( | |
| 156 | + Repository, | |
| 157 | + Refs.IdentityFor(user), | |
| 158 | + _base.Name, | |
| 159 | + _head.Name, | |
| 160 | + form["base_sha"].ToString(), | |
| 161 | + form["head_sha"].ToString(), | |
| 162 | + resolutions, | |
| 163 | + form["message"].ToString()); | |
| 164 | + if (!result.Ok) | |
| 165 | + { | |
| 166 | + _error = result.Conflicts is { Count: > 0 } | |
| 167 | + ? $"{T[result.Error!]} ({string.Join(", ", result.Conflicts)})" | |
| 168 | + : T[result.Error!]; | |
| 169 | + return; | |
| 170 | + } | |
| 171 | + | |
| 172 | + await Pulls.MarkMergedAsync(Repository, _base.Name, _head.Name, mergeBase, _head.CommitSha, result.Sha); | |
| 173 | + Redirect(Urls.Commit(Repository, result.Sha!)); | |
| 174 | + } | |
| 175 | +} |
added forge/Features/History/DiffOptions.razor +34 −0View file
| @@ -0,0 +1,34 @@ | ||
| 1 | +@* Switches for a diff: unified or side by side, and whether whitespace-only changes count. Plain links, no script. *@ | |
| 2 | +<nav class="diff-options"> | |
| 3 | + <span class="segmented"> | |
| 4 | + <a class="@(Split ? "" : "active")" href="@(Path + Query(false, IgnoreWhitespace))">@T["Unified"]</a> | |
| 5 | + <a class="@(Split ? "active" : "")" href="@(Path + Query(true, IgnoreWhitespace))">@T["Side by side"]</a> | |
| 6 | + </span> | |
| 7 | + <a href="@(Path + Query(Split, !IgnoreWhitespace))">@(IgnoreWhitespace ? T["Show whitespace changes"] : T["Hide whitespace changes"])</a> | |
| 8 | + @ChildContent | |
| 9 | +</nav> | |
| 10 | + | |
| 11 | +@code { | |
| 12 | + /// <summary>Address of the page without its query string.</summary> | |
| 13 | + [Parameter, EditorRequired] | |
| 14 | + public string Path { get; set; } = ""; | |
| 15 | + | |
| 16 | + [Parameter] | |
| 17 | + public bool Split { get; set; } | |
| 18 | + | |
| 19 | + [Parameter] | |
| 20 | + public bool IgnoreWhitespace { get; set; } | |
| 21 | + | |
| 22 | + /// <summary>Extra links shown after the standard ones.</summary> | |
| 23 | + [Parameter] | |
| 24 | + public RenderFragment? ChildContent { get; set; } | |
| 25 | + | |
| 26 | + /// <summary>The query string that selects these options; empty for the defaults.</summary> | |
| 27 | + public static string Query(bool split, bool ignoreWhitespace) => (split, ignoreWhitespace) switch | |
| 28 | + { | |
| 29 | + (true, true) => "?view=split&w=1", | |
| 30 | + (true, false) => "?view=split", | |
| 31 | + (false, true) => "?w=1", | |
| 32 | + _ => "", | |
| 33 | + }; | |
| 34 | +} |
added forge/Features/History/DiffRows.cs +156 −0View file
| @@ -0,0 +1,156 @@ | ||
| 1 | +using Forge.Git; | |
| 2 | + | |
| 3 | +namespace Forge.Features.History; | |
| 4 | + | |
| 5 | +/// <summary>The part of a line that differs from its counterpart, as character offsets [Start, End).</summary> | |
| 6 | +public readonly record struct ChangeRange(int Start, int End); | |
| 7 | + | |
| 8 | +public sealed record DiffCell(DiffLine Line, ChangeRange? Change); | |
| 9 | + | |
| 10 | +/// <summary>One row of a side-by-side diff. A side is null where the other side has a line with no counterpart.</summary> | |
| 11 | +public sealed record DiffRow(DiffCell? Left, DiffCell? Right); | |
| 12 | + | |
| 13 | +/// <summary> | |
| 14 | +/// Pairs removed lines with the added lines that replaced them. The pairing gives the side-by-side | |
| 15 | +/// layout its rows, and gives both layouts the within-line highlight of what actually changed. | |
| 16 | +/// </summary> | |
| 17 | +public static class DiffRows | |
| 18 | +{ | |
| 19 | + /// <summary>Rows for the side-by-side layout.</summary> | |
| 20 | + public static List<DiffRow> Pair(DiffHunk hunk) | |
| 21 | + { | |
| 22 | + var rows = new List<DiffRow>(); | |
| 23 | + foreach (var (removed, added, context) in Blocks(hunk)) | |
| 24 | + { | |
| 25 | + if (context is not null) | |
| 26 | + { | |
| 27 | + var cell = new DiffCell(context, null); | |
| 28 | + rows.Add(new DiffRow(cell, cell)); | |
| 29 | + continue; | |
| 30 | + } | |
| 31 | + | |
| 32 | + for (var i = 0; i < Math.Max(removed.Count, added.Count); i++) | |
| 33 | + { | |
| 34 | + var left = i < removed.Count ? removed[i] : null; | |
| 35 | + var right = i < added.Count ? added[i] : null; | |
| 36 | + var (leftChange, rightChange) = left is not null && right is not null | |
| 37 | + ? Compare(left.Text, right.Text) | |
| 38 | + : (null, null); | |
| 39 | + rows.Add(new DiffRow( | |
| 40 | + left is null ? null : new DiffCell(left, leftChange), | |
| 41 | + right is null ? null : new DiffCell(right, rightChange))); | |
| 42 | + } | |
| 43 | + } | |
| 44 | + | |
| 45 | + return rows; | |
| 46 | + } | |
| 47 | + | |
| 48 | + /// <summary>Within-line changes for the unified layout, keyed by line.</summary> | |
| 49 | + public static Dictionary<DiffLine, ChangeRange?> Changes(DiffHunk hunk) | |
| 50 | + { | |
| 51 | + var changes = new Dictionary<DiffLine, ChangeRange?>(); | |
| 52 | + foreach (var (removed, added, _) in Blocks(hunk)) | |
| 53 | + { | |
| 54 | + for (var i = 0; i < Math.Min(removed.Count, added.Count); i++) | |
| 55 | + { | |
| 56 | + var (left, right) = Compare(removed[i].Text, added[i].Text); | |
| 57 | + changes[removed[i]] = left; | |
| 58 | + changes[added[i]] = right; | |
| 59 | + } | |
| 60 | + } | |
| 61 | + | |
| 62 | + return changes; | |
| 63 | + } | |
| 64 | + | |
| 65 | + /// <summary> | |
| 66 | + /// What differs between two versions of a line: everything between their common start and common end. | |
| 67 | + /// Returns nothing when the lines have no meaningful part in common, since then the whole line changed. | |
| 68 | + /// </summary> | |
| 69 | + public static (ChangeRange? Old, ChangeRange? New) Compare(string oldText, string newText) | |
| 70 | + { | |
| 71 | + if (oldText == newText) | |
| 72 | + { | |
| 73 | + return (null, null); | |
| 74 | + } | |
| 75 | + | |
| 76 | + var limit = Math.Min(oldText.Length, newText.Length); | |
| 77 | + var prefix = 0; | |
| 78 | + while (prefix < limit && oldText[prefix] == newText[prefix]) | |
| 79 | + { | |
| 80 | + prefix++; | |
| 81 | + } | |
| 82 | + | |
| 83 | + // Never cut a surrogate pair in half. | |
| 84 | + if (prefix > 0 && char.IsHighSurrogate(oldText[prefix - 1])) | |
| 85 | + { | |
| 86 | + prefix--; | |
| 87 | + } | |
| 88 | + | |
| 89 | + var suffix = 0; | |
| 90 | + while (suffix < limit - prefix && oldText[^(suffix + 1)] == newText[^(suffix + 1)]) | |
| 91 | + { | |
| 92 | + suffix++; | |
| 93 | + } | |
| 94 | + | |
| 95 | + if (suffix > 0 && char.IsLowSurrogate(oldText[^suffix])) | |
| 96 | + { | |
| 97 | + suffix--; | |
| 98 | + } | |
| 99 | + | |
| 100 | + // Shared indentation alone says nothing about what changed. | |
| 101 | + var shared = oldText.AsSpan(0, prefix).Trim().Length + oldText.AsSpan(oldText.Length - suffix).Trim().Length; | |
| 102 | + if (shared == 0) | |
| 103 | + { | |
| 104 | + return (null, null); | |
| 105 | + } | |
| 106 | + | |
| 107 | + return ( | |
| 108 | + new ChangeRange(prefix, oldText.Length - suffix), | |
| 109 | + new ChangeRange(prefix, newText.Length - suffix)); | |
| 110 | + } | |
| 111 | + | |
| 112 | + /// <summary>Splits a hunk into context lines and blocks of removed lines followed by added lines.</summary> | |
| 113 | + private static IEnumerable<(List<DiffLine> Removed, List<DiffLine> Added, DiffLine? Context)> Blocks(DiffHunk hunk) | |
| 114 | + { | |
| 115 | + var removed = new List<DiffLine>(); | |
| 116 | + var added = new List<DiffLine>(); | |
| 117 | + foreach (var line in hunk.Lines) | |
| 118 | + { | |
| 119 | + switch (line.Kind) | |
| 120 | + { | |
| 121 | + case DiffLineKind.Deleted: | |
| 122 | + if (added.Count > 0) | |
| 123 | + { | |
| 124 | + yield return (removed, added, null); | |
| 125 | + removed = []; | |
| 126 | + added = []; | |
| 127 | + } | |
| 128 | + | |
| 129 | + removed.Add(line); | |
| 130 | + break; | |
| 131 | + | |
| 132 | + case DiffLineKind.Added: | |
| 133 | + added.Add(line); | |
| 134 | + break; | |
| 135 | + | |
| 136 | + case DiffLineKind.Context: | |
| 137 | + if (removed.Count > 0 || added.Count > 0) | |
| 138 | + { | |
| 139 | + yield return (removed, added, null); | |
| 140 | + removed = []; | |
| 141 | + added = []; | |
| 142 | + } | |
| 143 | + | |
| 144 | + yield return ([], [], line); | |
| 145 | + break; | |
| 146 | + | |
| 147 | + // "\ No newline at end of file" belongs to the line before it and is not a row of its own. | |
| 148 | + } | |
| 149 | + } | |
| 150 | + | |
| 151 | + if (removed.Count > 0 || added.Count > 0) | |
| 152 | + { | |
| 153 | + yield return (removed, added, null); | |
| 154 | + } | |
| 155 | + } | |
| 156 | +} |
added forge/Features/History/DiffView.razor +208 −0View file
| @@ -0,0 +1,208 @@ | ||
| 1 | +@* Renders a parsed diff: a file list to jump from, then one collapsible table per file, unified or side by side. *@ | |
| 2 | +@if (Diff.Truncated) | |
| 3 | +{ | |
| 4 | + <p class="alert warning">@T["The diff is too large; only part of it is shown."]</p> | |
| 5 | +} | |
| 6 | + | |
| 7 | +@if (Diff.Files.Count > 1) | |
| 8 | +{ | |
| 9 | + <ul class="diff-index"> | |
| 10 | + @for (var i = 0; i < Diff.Files.Count; i++) | |
| 11 | + { | |
| 12 | + var file = Diff.Files[i]; | |
| 13 | + <li> | |
| 14 | + <span class="stat-counts"> | |
| 15 | + @if (file.IsBinary) | |
| 16 | + { | |
| 17 | + <span class="muted">@T["bin"]</span> | |
| 18 | + } | |
| 19 | + else | |
| 20 | + { | |
| 21 | + <span class="added">+@file.Added</span> | |
| 22 | + <span class="deleted">−@file.Deleted</span> | |
| 23 | + } | |
| 24 | + </span> | |
| 25 | + <a href="#diff-@i">@file.DisplayPath</a> | |
| 26 | + </li> | |
| 27 | + } | |
| 28 | + </ul> | |
| 29 | +} | |
| 30 | + | |
| 31 | +@for (var i = 0; i < Diff.Files.Count; i++) | |
| 32 | +{ | |
| 33 | + var file = Diff.Files[i]; | |
| 34 | + var language = FileTypes.Language(System.IO.Path.GetFileName(file.DisplayPath)); | |
| 35 | + <details class="diff-file" id="diff-@i" open> | |
| 36 | + <summary class="diff-file-head"> | |
| 37 | + <span class="badge @ChangeClass(file.Change)">@ChangeLabel(file.Change)</span> | |
| 38 | + <span class="diff-path"> | |
| 39 | + @if (file.Change is FileChange.Renamed or FileChange.Copied) | |
| 40 | + { | |
| 41 | + <span>@file.OldPath → </span> | |
| 42 | + } | |
| 43 | + @file.DisplayPath | |
| 44 | + </span> | |
| 45 | + <span class="diff-counts"> | |
| 46 | + <span class="added">+@file.Added</span> | |
| 47 | + <span class="deleted">−@file.Deleted</span> | |
| 48 | + </span> | |
| 49 | + @if (Repository is not null && HeadSha is not null && file.Change != FileChange.Deleted) | |
| 50 | + { | |
| 51 | + <a class="small" href="@Urls.Blob(Repository, HeadSha, file.NewPath)">@T["View file"]</a> | |
| 52 | + } | |
| 53 | + </summary> | |
| 54 | + | |
| 55 | + @if (file.IsBinary) | |
| 56 | + { | |
| 57 | + <p class="diff-note muted">@T["Binary file, diff not shown."]</p> | |
| 58 | + } | |
| 59 | + else if (file.TooLarge) | |
| 60 | + { | |
| 61 | + <p class="diff-note muted">@T["The diff is too large (more than {0} lines).", GitParsers.MaxDiffLinesPerFile]</p> | |
| 62 | + } | |
| 63 | + else if (file.Hunks.Count == 0) | |
| 64 | + { | |
| 65 | + <p class="diff-note muted">@(file.Change is FileChange.Renamed or FileChange.Copied ? T["No content changes."] : T["No content changes (empty file or mode change)."])</p> | |
| 66 | + } | |
| 67 | + else if (Split) | |
| 68 | + { | |
| 69 | + <table class="diff split"> | |
| 70 | + <tbody> | |
| 71 | + @foreach (var hunk in file.Hunks) | |
| 72 | + { | |
| 73 | + <tr class="hunk"> | |
| 74 | + <td class="ln"></td> | |
| 75 | + <td class="diff-code" colspan="3">@hunk.Header</td> | |
| 76 | + </tr> | |
| 77 | + @foreach (var row in DiffRows.Pair(hunk)) | |
| 78 | + { | |
| 79 | + <tr> | |
| 80 | + @if (row.Left is { } left) | |
| 81 | + { | |
| 82 | + <td class="ln @SideClass(left.Line.Kind)">@left.Line.OldNumber</td> | |
| 83 | + <td class="diff-code @SideClass(left.Line.Kind)">@Code(left, language)</td> | |
| 84 | + } | |
| 85 | + else | |
| 86 | + { | |
| 87 | + <td class="ln blank"></td> | |
| 88 | + <td class="diff-code blank"></td> | |
| 89 | + } | |
| 90 | + @if (row.Right is { } right) | |
| 91 | + { | |
| 92 | + <td class="ln @SideClass(right.Line.Kind)">@right.Line.NewNumber</td> | |
| 93 | + <td class="diff-code @SideClass(right.Line.Kind)">@Code(right, language)</td> | |
| 94 | + } | |
| 95 | + else | |
| 96 | + { | |
| 97 | + <td class="ln blank"></td> | |
| 98 | + <td class="diff-code blank"></td> | |
| 99 | + } | |
| 100 | + </tr> | |
| 101 | + } | |
| 102 | + } | |
| 103 | + </tbody> | |
| 104 | + </table> | |
| 105 | + } | |
| 106 | + else | |
| 107 | + { | |
| 108 | + <table class="diff"> | |
| 109 | + <tbody> | |
| 110 | + @foreach (var hunk in file.Hunks) | |
| 111 | + { | |
| 112 | + var changes = DiffRows.Changes(hunk); | |
| 113 | + <tr class="hunk"> | |
| 114 | + <td class="ln"></td> | |
| 115 | + <td class="ln"></td> | |
| 116 | + <td class="diff-code">@hunk.Header</td> | |
| 117 | + </tr> | |
| 118 | + @foreach (var line in hunk.Lines) | |
| 119 | + { | |
| 120 | + <tr class="@LineClass(line.Kind)"> | |
| 121 | + <td class="ln">@line.OldNumber</td> | |
| 122 | + <td class="ln">@line.NewNumber</td> | |
| 123 | + @* One line on purpose: the cell preserves whitespace, so any stray space would show. *@ | |
| 124 | + <td class="diff-code"><span class="marker">@Marker(line.Kind)</span>@(line.Kind == DiffLineKind.NoNewline ? Note(T["No newline at end of file"]) : Code(new DiffCell(line, changes.GetValueOrDefault(line)), language))</td> | |
| 125 | + </tr> | |
| 126 | + } | |
| 127 | + } | |
| 128 | + </tbody> | |
| 129 | + </table> | |
| 130 | + } | |
| 131 | + </details> | |
| 132 | +} | |
| 133 | + | |
| 134 | +@code { | |
| 135 | + [Parameter, EditorRequired] | |
| 136 | + public ParsedDiff Diff { get; set; } = null!; | |
| 137 | + | |
| 138 | + /// <summary>Two columns, old on the left and new on the right, instead of one interleaved column.</summary> | |
| 139 | + [Parameter] | |
| 140 | + public bool Split { get; set; } | |
| 141 | + | |
| 142 | + /// <summary>With <see cref="HeadSha"/>, each file gets a link to its full content at that commit.</summary> | |
| 143 | + [Parameter] | |
| 144 | + public Repository? Repository { get; set; } | |
| 145 | + | |
| 146 | + [Parameter] | |
| 147 | + public string? HeadSha { get; set; } | |
| 148 | + | |
| 149 | + /// <summary> | |
| 150 | + /// One line of code. The part that differs from its counterpart is wrapped in a span, and the same | |
| 151 | + /// range is repeated in data attributes: the script that adds syntax colours rebuilds the line and re-applies it. | |
| 152 | + /// </summary> | |
| 153 | + private static RenderFragment Code(DiffCell cell, string? language) => __builder => | |
| 154 | + { | |
| 155 | + var text = cell.Line.Text; | |
| 156 | + if (cell.Change is { } c) | |
| 157 | + { | |
| 158 | + <span class="line" data-lang="@language" data-cs="@c.Start" data-ce="@c.End">@(text[..c.Start])<span class="chg">@(text[c.Start..c.End])</span>@(text[c.End..])</span> | |
| 159 | + } | |
| 160 | + else | |
| 161 | + { | |
| 162 | + <span class="line" data-lang="@language">@text</span> | |
| 163 | + } | |
| 164 | + }; | |
| 165 | + | |
| 166 | + private static RenderFragment Note(string text) => __builder => | |
| 167 | + { | |
| 168 | + <span>@text</span> | |
| 169 | + }; | |
| 170 | + | |
| 171 | + private string ChangeLabel(FileChange change) => change switch | |
| 172 | + { | |
| 173 | + FileChange.Added => T["added"], | |
| 174 | + FileChange.Deleted => T["deleted"], | |
| 175 | + FileChange.Renamed => T["renamed"], | |
| 176 | + FileChange.Copied => T["copied"], | |
| 177 | + _ => T["modified"], | |
| 178 | + }; | |
| 179 | + | |
| 180 | + private static string ChangeClass(FileChange change) => change switch | |
| 181 | + { | |
| 182 | + FileChange.Added => "badge-added", | |
| 183 | + FileChange.Deleted => "badge-deleted", | |
| 184 | + _ => "", | |
| 185 | + }; | |
| 186 | + | |
| 187 | + private static string LineClass(DiffLineKind kind) => kind switch | |
| 188 | + { | |
| 189 | + DiffLineKind.Added => "add", | |
| 190 | + DiffLineKind.Deleted => "del", | |
| 191 | + DiffLineKind.NoNewline => "meta", | |
| 192 | + _ => "ctx", | |
| 193 | + }; | |
| 194 | + | |
| 195 | + private static string SideClass(DiffLineKind kind) => kind switch | |
| 196 | + { | |
| 197 | + DiffLineKind.Added => "add", | |
| 198 | + DiffLineKind.Deleted => "del", | |
| 199 | + _ => "", | |
| 200 | + }; | |
| 201 | + | |
| 202 | + private static string Marker(DiffLineKind kind) => kind switch | |
| 203 | + { | |
| 204 | + DiffLineKind.Added => "+", | |
| 205 | + DiffLineKind.Deleted => "-", | |
| 206 | + _ => " ", | |
| 207 | + }; | |
| 208 | +} |
added forge/Features/History/MergeFields.razor +47 −0View file
| @@ -0,0 +1,47 @@ | ||
| 1 | +@* The inputs of a merge form. The page supplies the <form> around them and the handler. *@ | |
| 2 | +<label> | |
| 3 | + @T["Method"] | |
| 4 | + <select name="Method"> | |
| 5 | + <option value="merge">@T["Merge commit"]</option> | |
| 6 | + <option value="squash">@T["Squash into one commit"]</option> | |
| 7 | + <option value="rebase">@T["Rebase onto the base branch"]</option> | |
| 8 | + @if (CanFastForward) | |
| 9 | + { | |
| 10 | + <option value="ff">@T["Fast-forward"]</option> | |
| 11 | + } | |
| 12 | + </select> | |
| 13 | +</label> | |
| 14 | +<label> | |
| 15 | + <span>@T["Commit message"] <span class="muted">@T["(optional, a default is used if empty)"]</span></span> | |
| 16 | + <input name="Message" value="@Message" maxlength="2000"/> | |
| 17 | +</label> | |
| 18 | +@if (AllowDelete) | |
| 19 | +{ | |
| 20 | + <label class="choice"> | |
| 21 | + <input type="checkbox" name="DeleteBranch" value="true"/> | |
| 22 | + @T["Delete branch {0} after merging", HeadName] | |
| 23 | + </label> | |
| 24 | +} | |
| 25 | + | |
| 26 | +@code { | |
| 27 | + [Parameter] | |
| 28 | + public bool CanFastForward { get; set; } | |
| 29 | + | |
| 30 | + [Parameter] | |
| 31 | + public bool AllowDelete { get; set; } | |
| 32 | + | |
| 33 | + [Parameter] | |
| 34 | + public string HeadName { get; set; } = ""; | |
| 35 | + | |
| 36 | + [Parameter] | |
| 37 | + public string? Message { get; set; } | |
| 38 | + | |
| 39 | + /// <summary>Reads the value of the method select.</summary> | |
| 40 | + public static MergeMethod Parse(string? value) => value switch | |
| 41 | + { | |
| 42 | + "squash" => MergeMethod.Squash, | |
| 43 | + "rebase" => MergeMethod.Rebase, | |
| 44 | + "ff" => MergeMethod.FastForward, | |
| 45 | + _ => MergeMethod.MergeCommit, | |
| 46 | + }; | |
| 47 | +} |
added forge/Features/History/RefService.cs +570 −0View file
| @@ -0,0 +1,570 @@ | ||
| 1 | +using System.Text; | |
| 2 | +using Forge.Data; | |
| 3 | +using Forge.Features.SmartHttp; | |
| 4 | +using Forge.Git; | |
| 5 | +using Forge.Localization; | |
| 6 | +using Microsoft.EntityFrameworkCore; | |
| 7 | +using Microsoft.Extensions.Options; | |
| 8 | + | |
| 9 | +namespace Forge.Features.History; | |
| 10 | + | |
| 11 | +public enum MergeMethod | |
| 12 | +{ | |
| 13 | + /// <summary>A commit with two parents.</summary> | |
| 14 | + MergeCommit, | |
| 15 | + | |
| 16 | + /// <summary>One new commit on the base branch carrying all changes; the other branch's history is not linked.</summary> | |
| 17 | + Squash, | |
| 18 | + | |
| 19 | + /// <summary>The head's commits are re-created one by one on top of the base branch, giving a linear history.</summary> | |
| 20 | + Rebase, | |
| 21 | + | |
| 22 | + /// <summary>No new commit: the base branch simply moves forward. Only possible when it has not diverged.</summary> | |
| 23 | + FastForward, | |
| 24 | +} | |
| 25 | + | |
| 26 | +/// <summary>What merging two commits would involve, computed without changing anything.</summary> | |
| 27 | +/// <param name="NothingToMerge">The head is already contained in the base.</param> | |
| 28 | +/// <param name="CanFastForward">The base has no commits the head lacks.</param> | |
| 29 | +/// <param name="Conflicts">Files that need a manual merge; empty when the merge is clean.</param> | |
| 30 | +/// <param name="Unrelated">The two histories share no commit.</param> | |
| 31 | +public sealed record MergeCheck(bool NothingToMerge, bool CanFastForward, IReadOnlyList<string> Conflicts, bool Unrelated) | |
| 32 | +{ | |
| 33 | + public bool CanMerge => !NothingToMerge && !Unrelated && Conflicts.Count == 0; | |
| 34 | +} | |
| 35 | + | |
| 36 | +/// <param name="Error">An English message (a translation key), or null on success.</param> | |
| 37 | +/// <param name="Sha">On success, the commit the ref points at now (or pointed at, for a deletion).</param> | |
| 38 | +/// <param name="Conflicts">For a refused merge, the conflicting files.</param> | |
| 39 | +public sealed record RefResult(string? Error, string? Sha = null, IReadOnlyList<string>? Conflicts = null) | |
| 40 | +{ | |
| 41 | + public bool Ok => Error is null; | |
| 42 | +} | |
| 43 | + | |
| 44 | +public enum ResolutionKind | |
| 45 | +{ | |
| 46 | + /// <summary>Take the file as it is on the base branch.</summary> | |
| 47 | + Ours, | |
| 48 | + | |
| 49 | + /// <summary>Take the file as it is on the head branch.</summary> | |
| 50 | + Theirs, | |
| 51 | + | |
| 52 | + /// <summary>Use text the user edited by hand.</summary> | |
| 53 | + Edited, | |
| 54 | +} | |
| 55 | + | |
| 56 | +public sealed record Resolution(ResolutionKind Kind, string? Text = null); | |
| 57 | + | |
| 58 | +/// <summary>One conflicted file, as offered for resolution.</summary> | |
| 59 | +/// <param name="MarkerText">The file with conflict markers, or null when it is binary or too large to edit.</param> | |
| 60 | +public sealed record ConflictFile(string Path, bool OnBase, bool OnHead, string? MarkerText); | |
| 61 | + | |
| 62 | +/// <summary> | |
| 63 | +/// Changes refs from the web UI: merging, replaying commits, and creating or deleting branches and tags. | |
| 64 | +/// Every change takes the repository's push lock and is recorded exactly like a push, | |
| 65 | +/// so webhooks fire and "pushed at" moves whether a change came from git or from the browser. | |
| 66 | +/// </summary> | |
| 67 | +public sealed class RefService( | |
| 68 | + ForgeDb db, | |
| 69 | + GitRepo git, | |
| 70 | + RefResolver resolver, | |
| 71 | + RepoPaths paths, | |
| 72 | + PushLocks locks, | |
| 73 | + PushRecorder recorder, | |
| 74 | + IOptions<ForgeOptions> options) | |
| 75 | +{ | |
| 76 | + public const int MaxReplayedCommits = 200; | |
| 77 | + public const int MaxEditableConflictBytes = 256 * 1024; | |
| 78 | + | |
| 79 | + private const string Heads = "refs/heads/"; | |
| 80 | + private const string TagsPrefix = "refs/tags/"; | |
| 81 | + | |
| 82 | + private static readonly string ConflictError = | |
| 83 | + Localizer.Key("The branches have conflicts and cannot be merged automatically."); | |
| 84 | + | |
| 85 | + private static readonly string MovedError = | |
| 86 | + Localizer.Key("The branch changed in the meantime. Reload the page and try again."); | |
| 87 | + | |
| 88 | + /// <summary>The author of commits Forge creates for a user. Accounts have no e-mail, so one is derived from the site's host.</summary> | |
| 89 | + public GitIdentity IdentityFor(User user) | |
| 90 | + { | |
| 91 | + var host = Uri.TryCreate(options.Value.BaseUrl, UriKind.Absolute, out var uri) ? uri.Host : "forge.invalid"; | |
| 92 | + return new GitIdentity(user.DisplayName, $"{user.Username}@{host}"); | |
| 93 | + } | |
| 94 | + | |
| 95 | + public async Task<MergeCheck> CheckMergeAsync(string repoPath, string baseSha, string headSha, CancellationToken ct = default) | |
| 96 | + { | |
| 97 | + var mergeBase = await git.MergeBaseAsync(repoPath, baseSha, headSha, ct); | |
| 98 | + if (mergeBase is null) | |
| 99 | + { | |
| 100 | + return new MergeCheck(false, false, [], Unrelated: true); | |
| 101 | + } | |
| 102 | + | |
| 103 | + if (mergeBase == headSha) | |
| 104 | + { | |
| 105 | + return new MergeCheck(NothingToMerge: true, false, [], false); | |
| 106 | + } | |
| 107 | + | |
| 108 | + if (mergeBase == baseSha) | |
| 109 | + { | |
| 110 | + return new MergeCheck(false, CanFastForward: true, [], false); | |
| 111 | + } | |
| 112 | + | |
| 113 | + var merged = await git.MergeTreeAsync(repoPath, baseSha, headSha, ct); | |
| 114 | + return new MergeCheck(false, false, merged.Conflicts, Unrelated: merged is { IsClean: false, Conflicts.Count: 0 }); | |
| 115 | + } | |
| 116 | + | |
| 117 | + /// <summary>Merges branch <paramref name="headBranch"/> into branch <paramref name="baseBranch"/>.</summary> | |
| 118 | + public Task<RefResult> MergeAsync( | |
| 119 | + Repository repo, | |
| 120 | + GitIdentity who, | |
| 121 | + string baseBranch, | |
| 122 | + string headBranch, | |
| 123 | + MergeMethod method, | |
| 124 | + string? message, | |
| 125 | + CancellationToken ct = default) => | |
| 126 | + MutateAsync(repo, async path => | |
| 127 | + { | |
| 128 | + var (target, source, error) = await FindBranchesAsync(path, baseBranch, headBranch, ct); | |
| 129 | + if (error is not null) | |
| 130 | + { | |
| 131 | + return new RefResult(error); | |
| 132 | + } | |
| 133 | + | |
| 134 | + var check = await CheckMergeAsync(path, target!.Sha, source!.Sha, ct); | |
| 135 | + if (check.NothingToMerge) | |
| 136 | + { | |
| 137 | + return new RefResult(Localizer.Key("There is nothing to merge.")); | |
| 138 | + } | |
| 139 | + | |
| 140 | + if (check.Unrelated) | |
| 141 | + { | |
| 142 | + return new RefResult(Localizer.Key("The branches have no common history and cannot be merged here.")); | |
| 143 | + } | |
| 144 | + | |
| 145 | + string newSha; | |
| 146 | + switch (method) | |
| 147 | + { | |
| 148 | + case MergeMethod.FastForward: | |
| 149 | + if (!check.CanFastForward) | |
| 150 | + { | |
| 151 | + return new RefResult(Localizer.Key("Fast-forward is not possible because the branches have diverged.")); | |
| 152 | + } | |
| 153 | + | |
| 154 | + newSha = source.Sha; | |
| 155 | + break; | |
| 156 | + | |
| 157 | + case MergeMethod.Rebase: | |
| 158 | + var rebased = await RebaseAsync(path, target, source, who, ct); | |
| 159 | + if (!rebased.Ok) | |
| 160 | + { | |
| 161 | + return rebased; | |
| 162 | + } | |
| 163 | + | |
| 164 | + newSha = rebased.Sha!; | |
| 165 | + break; | |
| 166 | + | |
| 167 | + default: | |
| 168 | + var merged = await git.MergeTreeAsync(path, target.Sha, source.Sha, ct); | |
| 169 | + if (!merged.IsClean) | |
| 170 | + { | |
| 171 | + return new RefResult(ConflictError, Conflicts: merged.Conflicts); | |
| 172 | + } | |
| 173 | + | |
| 174 | + var squash = method == MergeMethod.Squash; | |
| 175 | + var text = string.IsNullOrWhiteSpace(message) | |
| 176 | + ? await DefaultMessageAsync(path, target, source, squash, ct) | |
| 177 | + : message.Trim(); | |
| 178 | + string[] parents = squash ? [target.Sha] : [target.Sha, source.Sha]; | |
| 179 | + newSha = await git.CommitTreeAsync(path, merged.TreeSha!, parents, text, who, ct); | |
| 180 | + break; | |
| 181 | + } | |
| 182 | + | |
| 183 | + // Compare-and-swap: if someone pushed to the base branch since it was read, nothing is overwritten. | |
| 184 | + return await git.UpdateRefAsync(path, target.FullName, newSha, target.Sha, ct) | |
| 185 | + ? new RefResult(null, newSha) | |
| 186 | + : new RefResult(MovedError); | |
| 187 | + }); | |
| 188 | + | |
| 189 | + /// <summary>The conflicted files of a merge, with the content needed to resolve them in the browser.</summary> | |
| 190 | + public async Task<IReadOnlyList<ConflictFile>> GetConflictsAsync(string repoPath, string baseSha, string headSha, CancellationToken ct = default) | |
| 191 | + { | |
| 192 | + var merged = await git.MergeTreeAsync(repoPath, baseSha, headSha, ct); | |
| 193 | + if (merged.ConflictTreeSha is null) | |
| 194 | + { | |
| 195 | + return []; | |
| 196 | + } | |
| 197 | + | |
| 198 | + var files = new List<ConflictFile>(); | |
| 199 | + foreach (var path in merged.Conflicts) | |
| 200 | + { | |
| 201 | + var ours = await git.GetEntryAsync(repoPath, baseSha, path, ct); | |
| 202 | + var theirs = await git.GetEntryAsync(repoPath, headSha, path, ct); | |
| 203 | + var marked = await git.GetEntryAsync(repoPath, merged.ConflictTreeSha, path, ct); | |
| 204 | + | |
| 205 | + string? text = null; | |
| 206 | + if (marked is { IsBlob: true, Size: <= MaxEditableConflictBytes }) | |
| 207 | + { | |
| 208 | + var blob = await git.ReadBlobAsync(repoPath, marked.Sha, MaxEditableConflictBytes, ct); | |
| 209 | + text = blob.IsBinary ? null : blob.Text; | |
| 210 | + } | |
| 211 | + | |
| 212 | + files.Add(new ConflictFile(path, ours is { IsBlob: true }, theirs is { IsBlob: true }, text)); | |
| 213 | + } | |
| 214 | + | |
| 215 | + return files; | |
| 216 | + } | |
| 217 | + | |
| 218 | + /// <summary> | |
| 219 | + /// Merges two conflicting branches using the user's choice for every conflicted file. | |
| 220 | + /// The expected SHAs are the ones the user was looking at; if either branch moved, nothing happens. | |
| 221 | + /// </summary> | |
| 222 | + public Task<RefResult> ResolveAndMergeAsync( | |
| 223 | + Repository repo, | |
| 224 | + GitIdentity who, | |
| 225 | + string baseBranch, | |
| 226 | + string headBranch, | |
| 227 | + string expectedBaseSha, | |
| 228 | + string expectedHeadSha, | |
| 229 | + IReadOnlyDictionary<string, Resolution> resolutions, | |
| 230 | + string? message, | |
| 231 | + CancellationToken ct = default) => | |
| 232 | + MutateAsync(repo, async path => | |
| 233 | + { | |
| 234 | + var (target, source, error) = await FindBranchesAsync(path, baseBranch, headBranch, ct); | |
| 235 | + if (error is not null) | |
| 236 | + { | |
| 237 | + return new RefResult(error); | |
| 238 | + } | |
| 239 | + | |
| 240 | + if (target!.Sha != expectedBaseSha || source!.Sha != expectedHeadSha) | |
| 241 | + { | |
| 242 | + return new RefResult(MovedError); | |
| 243 | + } | |
| 244 | + | |
| 245 | + var merged = await git.MergeTreeAsync(path, target.Sha, source.Sha, ct); | |
| 246 | + var tree = merged.TreeSha; | |
| 247 | + if (tree is null) | |
| 248 | + { | |
| 249 | + if (merged.ConflictTreeSha is null) | |
| 250 | + { | |
| 251 | + return new RefResult(Localizer.Key("The branches have no common history and cannot be merged here.")); | |
| 252 | + } | |
| 253 | + | |
| 254 | + var changes = new Dictionary<string, (string Mode, string BlobSha)?>(StringComparer.Ordinal); | |
| 255 | + foreach (var file in merged.Conflicts) | |
| 256 | + { | |
| 257 | + if (!resolutions.TryGetValue(file, out var resolution)) | |
| 258 | + { | |
| 259 | + return new RefResult(Localizer.Key("Choose a resolution for every conflicting file."), Conflicts: merged.Conflicts); | |
| 260 | + } | |
| 261 | + | |
| 262 | + var ours = await git.GetEntryAsync(path, target.Sha, file, ct); | |
| 263 | + var theirs = await git.GetEntryAsync(path, source.Sha, file, ct); | |
| 264 | + switch (resolution.Kind) | |
| 265 | + { | |
| 266 | + // A side that does not have the file resolves to "the file is deleted". | |
| 267 | + case ResolutionKind.Ours: | |
| 268 | + changes[file] = ours is { IsBlob: true } ? (ours.Mode, ours.Sha) : null; | |
| 269 | + break; | |
| 270 | + case ResolutionKind.Theirs: | |
| 271 | + changes[file] = theirs is { IsBlob: true } ? (theirs.Mode, theirs.Sha) : null; | |
| 272 | + break; | |
| 273 | + default: | |
| 274 | + var text = resolution.Text ?? ""; | |
| 275 | + if (HasConflictMarkers(text)) | |
| 276 | + { | |
| 277 | + return new RefResult(Localizer.Key("The edited text still contains conflict markers."), Conflicts: [file]); | |
| 278 | + } | |
| 279 | + | |
| 280 | + var blob = await git.WriteBlobAsync(path, Encoding.UTF8.GetBytes(text), ct); | |
| 281 | + changes[file] = (ours?.Mode ?? theirs?.Mode ?? "100644", blob); | |
| 282 | + break; | |
| 283 | + } | |
| 284 | + } | |
| 285 | + | |
| 286 | + tree = await git.BuildTreeAsync(path, merged.ConflictTreeSha, changes, ct); | |
| 287 | + } | |
| 288 | + | |
| 289 | + var commitMessage = string.IsNullOrWhiteSpace(message) | |
| 290 | + ? await DefaultMessageAsync(path, target, source, squash: false, ct) | |
| 291 | + : message.Trim(); | |
| 292 | + var commit = await git.CommitTreeAsync(path, tree, [target.Sha, source.Sha], commitMessage, who, ct); | |
| 293 | + return await git.UpdateRefAsync(path, target.FullName, commit, target.Sha, ct) | |
| 294 | + ? new RefResult(null, commit) | |
| 295 | + : new RefResult(MovedError); | |
| 296 | + }); | |
| 297 | + | |
| 298 | + /// <summary>Applies one commit's change to a branch (cherry-pick), or its inverse (revert), as a new commit.</summary> | |
| 299 | + public Task<RefResult> ApplyCommitAsync( | |
| 300 | + Repository repo, | |
| 301 | + GitIdentity who, | |
| 302 | + string branchName, | |
| 303 | + string commitSha, | |
| 304 | + bool revert, | |
| 305 | + CancellationToken ct = default) => | |
| 306 | + MutateAsync(repo, async path => | |
| 307 | + { | |
| 308 | + var refs = await git.ListRefsAsync(path, ct); | |
| 309 | + var branch = refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == branchName); | |
| 310 | + if (branch is null) | |
| 311 | + { | |
| 312 | + return new RefResult(Localizer.Key("There is no such branch in the repository.")); | |
| 313 | + } | |
| 314 | + | |
| 315 | + var commit = await git.GetCommitAsync(path, commitSha, ct); | |
| 316 | + if (commit is not { Parents.Count: 1 }) | |
| 317 | + { | |
| 318 | + return new RefResult(Localizer.Key("Merge commits and the first commit cannot be reverted or cherry-picked here.")); | |
| 319 | + } | |
| 320 | + | |
| 321 | + // A three-way merge with a chosen ancestor: picking replays parent→commit, reverting replays commit→parent. | |
| 322 | + var parent = commit.Parents[0]; | |
| 323 | + var merged = revert | |
| 324 | + ? await git.MergeTreeAsync(path, branch.Sha, parent, ct, mergeBaseSha: commit.Sha) | |
| 325 | + : await git.MergeTreeAsync(path, branch.Sha, commit.Sha, ct, mergeBaseSha: parent); | |
| 326 | + if (!merged.IsClean) | |
| 327 | + { | |
| 328 | + return new RefResult( | |
| 329 | + Localizer.Key("The change conflicts with the branch and cannot be applied automatically."), | |
| 330 | + Conflicts: merged.Conflicts); | |
| 331 | + } | |
| 332 | + | |
| 333 | + if (merged.TreeSha == await git.GetRootTreeShaAsync(path, branch.Sha, ct)) | |
| 334 | + { | |
| 335 | + return new RefResult(Localizer.Key("The branch already contains this change. There is nothing to do.")); | |
| 336 | + } | |
| 337 | + | |
| 338 | + var original = FullMessage(commit); | |
| 339 | + var newSha = revert | |
| 340 | + ? await git.CommitTreeAsync( | |
| 341 | + path, merged.TreeSha!, [branch.Sha], | |
| 342 | + $"Revert \"{commit.Subject}\"\n\nThis reverts commit {commit.Sha}.", who, ct) | |
| 343 | + : await git.CommitTreeAsync( | |
| 344 | + path, merged.TreeSha!, [branch.Sha], | |
| 345 | + $"{original}\n\n(cherry picked from commit {commit.Sha})", who, ct, | |
| 346 | + new GitIdentity(commit.AuthorName, commit.AuthorEmail), commit.AuthorDateRaw); | |
| 347 | + | |
| 348 | + return await git.UpdateRefAsync(path, branch.FullName, newSha, branch.Sha, ct) | |
| 349 | + ? new RefResult(null, newSha) | |
| 350 | + : new RefResult(MovedError); | |
| 351 | + }); | |
| 352 | + | |
| 353 | + public Task<RefResult> CreateBranchAsync(Repository repo, string? name, string? from, CancellationToken ct = default) => | |
| 354 | + CreateAsync( | |
| 355 | + repo, Heads, RefKind.Branch, name, from, | |
| 356 | + Localizer.Key("This is not a valid branch name."), | |
| 357 | + Localizer.Key("A branch with this name already exists."), | |
| 358 | + ct); | |
| 359 | + | |
| 360 | + public Task<RefResult> CreateTagAsync(Repository repo, string? name, string? from, CancellationToken ct = default) => | |
| 361 | + CreateAsync( | |
| 362 | + repo, TagsPrefix, RefKind.Tag, name, from, | |
| 363 | + Localizer.Key("This is not a valid tag name."), | |
| 364 | + Localizer.Key("A tag with this name already exists."), | |
| 365 | + ct); | |
| 366 | + | |
| 367 | + public Task<RefResult> DeleteBranchAsync(Repository repo, string? name, CancellationToken ct = default) => | |
| 368 | + MutateAsync(repo, async path => | |
| 369 | + { | |
| 370 | + var refs = await git.ListRefsAsync(path, ct); | |
| 371 | + var branch = refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == name); | |
| 372 | + if (branch is null) | |
| 373 | + { | |
| 374 | + return new RefResult(Localizer.Key("There is no such branch in the repository.")); | |
| 375 | + } | |
| 376 | + | |
| 377 | + // HEAD must keep pointing at something, and clones check this branch out. | |
| 378 | + if (branch.Name == repo.DefaultBranch || branch.Name == await git.GetHeadBranchAsync(path, ct)) | |
| 379 | + { | |
| 380 | + return new RefResult(Localizer.Key("The default branch cannot be deleted. Choose another default branch first.")); | |
| 381 | + } | |
| 382 | + | |
| 383 | + var rules = await db.BranchProtections.Where(r => r.RepoId == repo.Id).ToListAsync(ct); | |
| 384 | + if (BranchRules.Find(rules, branch.Name) is not null) | |
| 385 | + { | |
| 386 | + return new RefResult(Localizer.Key("This branch is protected and cannot be deleted.")); | |
| 387 | + } | |
| 388 | + | |
| 389 | + return await git.UpdateRefAsync(path, branch.FullName, null, branch.Sha, ct) | |
| 390 | + ? new RefResult(null, branch.Sha) | |
| 391 | + : new RefResult(MovedError); | |
| 392 | + }); | |
| 393 | + | |
| 394 | + public Task<RefResult> DeleteTagAsync(Repository repo, string? name, CancellationToken ct = default) => | |
| 395 | + MutateAsync(repo, async path => | |
| 396 | + { | |
| 397 | + var refs = await git.ListRefsAsync(path, ct); | |
| 398 | + var tag = refs.FirstOrDefault(r => r.Kind == RefKind.Tag && r.Name == name); | |
| 399 | + if (tag is null) | |
| 400 | + { | |
| 401 | + return new RefResult(Localizer.Key("There is no such tag in the repository.")); | |
| 402 | + } | |
| 403 | + | |
| 404 | + return await git.UpdateRefAsync(path, tag.FullName, null, tag.Sha, ct) | |
| 405 | + ? new RefResult(null, tag.TargetSha) | |
| 406 | + : new RefResult(MovedError); | |
| 407 | + }); | |
| 408 | + | |
| 409 | + /// <summary>True when the name could be a branch: git's own rules, plus a few that keep it usable in URLs and commands.</summary> | |
| 410 | + public async Task<bool> IsValidBranchNameAsync(string name, CancellationToken ct = default) => | |
| 411 | + name.Length is > 0 and <= 200 | |
| 412 | + && !name.StartsWith('-') | |
| 413 | + && name is not "HEAD" | |
| 414 | + && await git.IsValidRefNameAsync(Heads + name, ct); | |
| 415 | + | |
| 416 | + private async Task<(GitRef? Target, GitRef? Source, string? Error)> FindBranchesAsync( | |
| 417 | + string path, | |
| 418 | + string baseBranch, | |
| 419 | + string headBranch, | |
| 420 | + CancellationToken ct) | |
| 421 | + { | |
| 422 | + // Both names are looked up in the repository's own ref list; only their SHAs go to git. | |
| 423 | + var refs = await git.ListRefsAsync(path, ct); | |
| 424 | + var target = refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == baseBranch); | |
| 425 | + var source = refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == headBranch); | |
| 426 | + if (target is null || source is null) | |
| 427 | + { | |
| 428 | + return (null, null, Localizer.Key("There is no such branch in the repository.")); | |
| 429 | + } | |
| 430 | + | |
| 431 | + return target.Name == source.Name | |
| 432 | + ? (null, null, Localizer.Key("Choose two different branches.")) | |
| 433 | + : (target, source, null); | |
| 434 | + } | |
| 435 | + | |
| 436 | + /// <summary>Re-creates the head's commits on top of the base, one three-way merge per commit.</summary> | |
| 437 | + private async Task<RefResult> RebaseAsync(string path, GitRef target, GitRef source, GitIdentity who, CancellationToken ct) | |
| 438 | + { | |
| 439 | + var commits = await git.LogRangeAsync(path, target.Sha, source.Sha, MaxReplayedCommits + 1, ct); | |
| 440 | + if (commits.Count > MaxReplayedCommits) | |
| 441 | + { | |
| 442 | + return new RefResult(Localizer.Key("The branch has too many commits to rebase here.")); | |
| 443 | + } | |
| 444 | + | |
| 445 | + if (commits.Any(c => c.Parents.Count != 1)) | |
| 446 | + { | |
| 447 | + return new RefResult(Localizer.Key("The branch contains merge commits and cannot be rebased here.")); | |
| 448 | + } | |
| 449 | + | |
| 450 | + var tip = target.Sha; | |
| 451 | + var tipTree = await git.GetRootTreeShaAsync(path, tip, ct); | |
| 452 | + foreach (var commit in commits.Reverse()) | |
| 453 | + { | |
| 454 | + var merged = await git.MergeTreeAsync(path, tip, commit.Sha, ct, mergeBaseSha: commit.Parents[0]); | |
| 455 | + if (!merged.IsClean) | |
| 456 | + { | |
| 457 | + return new RefResult(ConflictError, Conflicts: merged.Conflicts); | |
| 458 | + } | |
| 459 | + | |
| 460 | + // A commit whose change is already on the base would be empty; it is left out. | |
| 461 | + if (merged.TreeSha == tipTree) | |
| 462 | + { | |
| 463 | + continue; | |
| 464 | + } | |
| 465 | + | |
| 466 | + tip = await git.CommitTreeAsync( | |
| 467 | + path, merged.TreeSha!, [tip], FullMessage(commit), who, ct, | |
| 468 | + new GitIdentity(commit.AuthorName, commit.AuthorEmail), commit.AuthorDateRaw); | |
| 469 | + tipTree = merged.TreeSha; | |
| 470 | + } | |
| 471 | + | |
| 472 | + return tip == target.Sha | |
| 473 | + ? new RefResult(Localizer.Key("There is nothing to merge.")) | |
| 474 | + : new RefResult(null, tip); | |
| 475 | + } | |
| 476 | + | |
| 477 | + private Task<RefResult> CreateAsync( | |
| 478 | + Repository repo, | |
| 479 | + string prefix, | |
| 480 | + RefKind kind, | |
| 481 | + string? name, | |
| 482 | + string? from, | |
| 483 | + string invalidName, | |
| 484 | + string exists, | |
| 485 | + CancellationToken ct) => | |
| 486 | + MutateAsync(repo, async path => | |
| 487 | + { | |
| 488 | + name = name?.Trim() ?? ""; | |
| 489 | + // git's own rules decide what a valid name is; the extra checks keep names usable in URLs and commands. | |
| 490 | + if (name.Length is 0 or > 200 | |
| 491 | + || name.StartsWith('-') | |
| 492 | + || name is "HEAD" | |
| 493 | + || !await git.IsValidRefNameAsync(prefix + name, ct)) | |
| 494 | + { | |
| 495 | + return new RefResult(invalidName); | |
| 496 | + } | |
| 497 | + | |
| 498 | + var refs = await git.ListRefsAsync(path, ct); | |
| 499 | + if (refs.Any(r => r.Kind == kind && r.Name == name)) | |
| 500 | + { | |
| 501 | + return new RefResult(exists); | |
| 502 | + } | |
| 503 | + | |
| 504 | + var start = await resolver.ResolveExactAsync(path, from?.Trim(), refs, ct); | |
| 505 | + if (start is null) | |
| 506 | + { | |
| 507 | + return new RefResult(Localizer.Key("The starting point does not exist.")); | |
| 508 | + } | |
| 509 | + | |
| 510 | + // "Expected old value: none" makes a simultaneous creation fail instead of being overwritten. | |
| 511 | + return await git.UpdateRefAsync(path, prefix + name, start.CommitSha, GitParsers.ZeroSha, ct) | |
| 512 | + ? new RefResult(null, start.CommitSha) | |
| 513 | + : new RefResult(exists); | |
| 514 | + }); | |
| 515 | + | |
| 516 | + private async Task<string> DefaultMessageAsync(string path, GitRef target, GitRef source, bool squash, CancellationToken ct) | |
| 517 | + { | |
| 518 | + if (!squash) | |
| 519 | + { | |
| 520 | + return $"Merge branch '{source.Name}' into {target.Name}"; | |
| 521 | + } | |
| 522 | + | |
| 523 | + // A squash drops the individual commits, so their subjects are kept in the message. | |
| 524 | + var commits = await git.LogRangeAsync(path, target.Sha, source.Sha, 100, ct); | |
| 525 | + var text = new StringBuilder($"Squash branch '{source.Name}' into {target.Name}\n"); | |
| 526 | + foreach (var commit in commits.Reverse()) | |
| 527 | + { | |
| 528 | + text.Append("\n* ").Append(commit.Subject); | |
| 529 | + } | |
| 530 | + | |
| 531 | + return text.ToString(); | |
| 532 | + } | |
| 533 | + | |
| 534 | + private static string FullMessage(CommitInfo commit) => | |
| 535 | + commit.Body.Length == 0 ? commit.Subject : commit.Subject + "\n\n" + commit.Body; | |
| 536 | + | |
| 537 | + /// <summary> | |
| 538 | + /// The opening and closing lines git writes around a conflict. The "=======" separator is not | |
| 539 | + /// checked: on its own it is ordinary text (a Markdown heading underline, for one). | |
| 540 | + /// </summary> | |
| 541 | + private static bool HasConflictMarkers(string text) | |
| 542 | + { | |
| 543 | + foreach (var line in text.Split('\n')) | |
| 544 | + { | |
| 545 | + if (line.StartsWith("<<<<<<< ", StringComparison.Ordinal) | |
| 546 | + || line.StartsWith(">>>>>>> ", StringComparison.Ordinal)) | |
| 547 | + { | |
| 548 | + return true; | |
| 549 | + } | |
| 550 | + } | |
| 551 | + | |
| 552 | + return false; | |
| 553 | + } | |
| 554 | + | |
| 555 | + private async Task<RefResult> MutateAsync(Repository repo, Func<string, Task<RefResult>> change) | |
| 556 | + { | |
| 557 | + using var pushLock = await locks.AcquireAsync(repo.Id, CancellationToken.None); | |
| 558 | + var path = paths.For(repo.Id); | |
| 559 | + var before = await git.SnapshotRefsAsync(path); | |
| 560 | + try | |
| 561 | + { | |
| 562 | + return await change(path); | |
| 563 | + } | |
| 564 | + finally | |
| 565 | + { | |
| 566 | + var after = await git.SnapshotRefsAsync(path); | |
| 567 | + await recorder.RecordAsync(repo.Id, before, after); | |
| 568 | + } | |
| 569 | + } | |
| 570 | +} |
added forge/Features/History/Tags.razor +165 −0View file
| @@ -0,0 +1,165 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/tags" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject RefService Refs | |
| 4 | + | |
| 5 | +@if (Repository is not null) | |
| 6 | +{ | |
| 7 | + <PageTitle>@T["Tags"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 8 | + | |
| 9 | + <RepoHeader Repository="Repository" Active="tags" IsOwner="IsOwner"/> | |
| 10 | + | |
| 11 | + @if (_message is not null) | |
| 12 | + { | |
| 13 | + <p class="alert success">@_message</p> | |
| 14 | + } | |
| 15 | + @if (_error is not null) | |
| 16 | + { | |
| 17 | + <p class="alert error">@_error</p> | |
| 18 | + } | |
| 19 | + | |
| 20 | + @if (_tags.Count == 0) | |
| 21 | + { | |
| 22 | + <div class="empty-state"> | |
| 23 | + <Icon Name="tag" Size="32"/> | |
| 24 | + <h2>@T["This repository has no tags yet."]</h2> | |
| 25 | + </div> | |
| 26 | + } | |
| 27 | + else | |
| 28 | + { | |
| 29 | + <form method="post" @formname="delete-tag" @onsubmit="DeleteAsync"> | |
| 30 | + <AntiforgeryToken/> | |
| 31 | + <table class="table"> | |
| 32 | + <thead> | |
| 33 | + <tr> | |
| 34 | + <th>@T["Tag"]</th> | |
| 35 | + <th>@T["Message"]</th> | |
| 36 | + <th>@T["Commit"]</th> | |
| 37 | + <th class="right">@T["Created"]</th> | |
| 38 | + <th></th> | |
| 39 | + </tr> | |
| 40 | + </thead> | |
| 41 | + <tbody> | |
| 42 | + @foreach (var tag in _tags) | |
| 43 | + { | |
| 44 | + <tr> | |
| 45 | + <td> | |
| 46 | + <Icon Name="tag" Class="cell-icon"/> | |
| 47 | + <a href="@Urls.Tree(Repository, tag.Name)"><strong>@tag.Name</strong></a> | |
| 48 | + </td> | |
| 49 | + <td>@tag.Subject</td> | |
| 50 | + <td><a class="sha" href="@Urls.Commit(Repository, tag.TargetSha)">@tag.TargetSha[..8]</a></td> | |
| 51 | + <td class="right small"> | |
| 52 | + @if (tag.Date is { } date) | |
| 53 | + { | |
| 54 | + <TimeAgo Value="date"/> | |
| 55 | + } | |
| 56 | + </td> | |
| 57 | + <td class="right actions"> | |
| 58 | + @if (IsOwner) | |
| 59 | + { | |
| 60 | + <button type="submit" name="DeleteName" value="@tag.Name" class="button danger small">@T["Delete"]</button> | |
| 61 | + } | |
| 62 | + </td> | |
| 63 | + </tr> | |
| 64 | + } | |
| 65 | + </tbody> | |
| 66 | + </table> | |
| 67 | + </form> | |
| 68 | + } | |
| 69 | + | |
| 70 | + @if (IsOwner && _hasCommits) | |
| 71 | + { | |
| 72 | + <section class="card"> | |
| 73 | + <h2>@T["New tag"]</h2> | |
| 74 | + <form method="post" @formname="create-tag" @onsubmit="CreateAsync" class="form"> | |
| 75 | + <AntiforgeryToken/> | |
| 76 | + <label> | |
| 77 | + @T["Name"] | |
| 78 | + <input name="NewName" value="@NewName" required maxlength="200" placeholder="v1.0"/> | |
| 79 | + </label> | |
| 80 | + <label> | |
| 81 | + <span>@T["From"] <span class="muted">@T["(branch, tag or commit SHA)"]</span></span> | |
| 82 | + <input name="From" value="@(From ?? Repository.DefaultBranch)" required maxlength="250"/> | |
| 83 | + </label> | |
| 84 | + <button type="submit" class="button primary">@T["Create tag"]</button> | |
| 85 | + </form> | |
| 86 | + </section> | |
| 87 | + } | |
| 88 | +} | |
| 89 | + | |
| 90 | +@code { | |
| 91 | + [SupplyParameterFromForm(FormName = "delete-tag")] | |
| 92 | + private string? DeleteName { get; set; } | |
| 93 | + | |
| 94 | + [SupplyParameterFromForm(FormName = "create-tag")] | |
| 95 | + private string? NewName { get; set; } | |
| 96 | + | |
| 97 | + [SupplyParameterFromForm(FormName = "create-tag")] | |
| 98 | + private string? From { get; set; } | |
| 99 | + | |
| 100 | + private IReadOnlyList<GitRef> _tags = []; | |
| 101 | + private bool _hasCommits; | |
| 102 | + private string? _message; | |
| 103 | + private string? _error; | |
| 104 | + | |
| 105 | + protected override async Task OnInitializedAsync() | |
| 106 | + { | |
| 107 | + if (await LoadRepoAsync()) | |
| 108 | + { | |
| 109 | + await LoadAsync(); | |
| 110 | + } | |
| 111 | + } | |
| 112 | + | |
| 113 | + private async Task LoadAsync() | |
| 114 | + { | |
| 115 | + // Tags of commits only; a tag pointing at a blob or tree has nothing to browse. | |
| 116 | + _tags = (await Git.ListTagsByDateAsync(RepoPath)) | |
| 117 | + .Where(t => t.ObjectType == "commit" || t.PeeledSha is not null) | |
| 118 | + .ToList(); | |
| 119 | + _hasCommits = _tags.Count > 0 || (await Git.ListRefsAsync(RepoPath)).Any(r => r.Kind == RefKind.Branch); | |
| 120 | + } | |
| 121 | + | |
| 122 | + private async Task CreateAsync() | |
| 123 | + { | |
| 124 | + if (Repository is null || !IsOwner) | |
| 125 | + { | |
| 126 | + return; | |
| 127 | + } | |
| 128 | + | |
| 129 | + var name = NewName?.Trim() ?? ""; | |
| 130 | + var result = await Refs.CreateTagAsync(Repository, name, From); | |
| 131 | + if (result.Ok) | |
| 132 | + { | |
| 133 | + _message = T["Tag {0} was created.", name]; | |
| 134 | + NewName = null; | |
| 135 | + From = null; | |
| 136 | + } | |
| 137 | + else | |
| 138 | + { | |
| 139 | + _error = T[result.Error!]; | |
| 140 | + } | |
| 141 | + | |
| 142 | + await LoadAsync(); | |
| 143 | + } | |
| 144 | + | |
| 145 | + private async Task DeleteAsync() | |
| 146 | + { | |
| 147 | + if (Repository is null || !IsOwner) | |
| 148 | + { | |
| 149 | + return; | |
| 150 | + } | |
| 151 | + | |
| 152 | + var result = await Refs.DeleteTagAsync(Repository, DeleteName); | |
| 153 | + if (result.Ok) | |
| 154 | + { | |
| 155 | + // The SHA is shown so that a tag deleted by mistake can be created again from it. | |
| 156 | + _message = T["Tag {0} was deleted (it pointed at {1}).", DeleteName, result.Sha]; | |
| 157 | + } | |
| 158 | + else | |
| 159 | + { | |
| 160 | + _error = T[result.Error!]; | |
| 161 | + } | |
| 162 | + | |
| 163 | + await LoadAsync(); | |
| 164 | + } | |
| 165 | +} |
added forge/Features/Pulls/PullDetail.razor +353 −0View file
| @@ -0,0 +1,353 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/pull/{Number:int}" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject PullRequestService Pulls | |
| 4 | +@inject RefService Refs | |
| 5 | +@inject MarkdownRenderer Markdown | |
| 6 | +@inject ForgeDb Db | |
| 7 | + | |
| 8 | +@if (Repository is not null && _pull is not null && _state is not null) | |
| 9 | +{ | |
| 10 | + <PageTitle>@_pull.Title · #@_pull.Number</PageTitle> | |
| 11 | + <HighlightAssets/> | |
| 12 | + | |
| 13 | + <RepoHeader Repository="Repository" Active="pulls" IsOwner="IsOwner"/> | |
| 14 | + | |
| 15 | + <h2 class="commit-title pull-title">@_pull.Title <span class="muted">#@_pull.Number</span></h2> | |
| 16 | + <p class="pull-summary"> | |
| 17 | + <PullStatusBadge Status="_pull.Status"/> | |
| 18 | + <span class="muted commit-byline"> | |
| 19 | + <Avatar Name="@_pull.Author.Username"/> | |
| 20 | + <span>@_pull.Author.Username</span> | |
| 21 | + <span class="sep">·</span> | |
| 22 | + <span><code>@_pull.HeadBranch</code> → <code>@_pull.BaseBranch</code></span> | |
| 23 | + <span class="sep">·</span> | |
| 24 | + <TimeAgo Value="Format.Utc(_pull.CreatedAt)"/> | |
| 25 | + </span> | |
| 26 | + </p> | |
| 27 | + | |
| 28 | + @if (_error is not null) | |
| 29 | + { | |
| 30 | + <div class="alert error"> | |
| 31 | + <p>@_error</p> | |
| 32 | + @if (_errorConflicts.Count > 0) | |
| 33 | + { | |
| 34 | + <ul> | |
| 35 | + @foreach (var file in _errorConflicts) | |
| 36 | + { | |
| 37 | + <li><code>@file</code></li> | |
| 38 | + } | |
| 39 | + </ul> | |
| 40 | + } | |
| 41 | + </div> | |
| 42 | + } | |
| 43 | + | |
| 44 | + @if (_pull.Description.Length > 0) | |
| 45 | + { | |
| 46 | + <article class="card markdown">@((MarkupString)Render(_pull.Description))</article> | |
| 47 | + } | |
| 48 | + | |
| 49 | + @if (IsOwner) | |
| 50 | + { | |
| 51 | + <details class="card"> | |
| 52 | + <summary>@T["Edit title and description"]</summary> | |
| 53 | + <form method="post" @formname="edit-pull" @onsubmit="EditAsync" class="form"> | |
| 54 | + <AntiforgeryToken/> | |
| 55 | + <label> | |
| 56 | + @T["Title"] | |
| 57 | + <input name="Title" value="@(Title ?? _pull.Title)" required maxlength="@PullRequestService.MaxTitleLength"/> | |
| 58 | + </label> | |
| 59 | + <label> | |
| 60 | + <span>@T["Description"] <span class="muted">@T["(optional, Markdown)"]</span></span> | |
| 61 | + <textarea name="Description" rows="5">@(Description ?? _pull.Description)</textarea> | |
| 62 | + </label> | |
| 63 | + <button type="submit" class="button">@T["Save"]</button> | |
| 64 | + </form> | |
| 65 | + </details> | |
| 66 | + } | |
| 67 | + | |
| 68 | + @if (_pull.Status == PullRequestStatus.Merged && _pull.MergeCommitSha is not null) | |
| 69 | + { | |
| 70 | + <p class="alert success"> | |
| 71 | + @T["Merged into {0}.", _pull.BaseBranch] | |
| 72 | + <a class="sha" href="@Urls.Commit(Repository, _pull.MergeCommitSha)">@(_pull.MergeCommitSha[..8])</a> | |
| 73 | + </p> | |
| 74 | + } | |
| 75 | + | |
| 76 | + @if (_pull.Status == PullRequestStatus.Open) | |
| 77 | + { | |
| 78 | + <section class="card"> | |
| 79 | + @if (_state.Base is null || _state.Head is null) | |
| 80 | + { | |
| 81 | + <p class="alert warning">@T["A branch of this pull request no longer exists."]</p> | |
| 82 | + } | |
| 83 | + else if (_state.Check is { } check) | |
| 84 | + { | |
| 85 | + @if (check.Unrelated) | |
| 86 | + { | |
| 87 | + <p class="alert warning">@T["The branches have no common history and cannot be merged here."]</p> | |
| 88 | + } | |
| 89 | + else if (check.Conflicts.Count > 0) | |
| 90 | + { | |
| 91 | + <p class="alert warning">@T["These branches have conflicts."]</p> | |
| 92 | + <p>@T["Conflicting files:"]</p> | |
| 93 | + <ul> | |
| 94 | + @foreach (var file in check.Conflicts) | |
| 95 | + { | |
| 96 | + <li><code>@file</code></li> | |
| 97 | + } | |
| 98 | + </ul> | |
| 99 | + @if (IsOwner) | |
| 100 | + { | |
| 101 | + <a class="button primary" href="@Urls.Conflicts(Repository, _pull.BaseBranch, _pull.HeadBranch)">@T["Resolve conflicts"]</a> | |
| 102 | + } | |
| 103 | + } | |
| 104 | + else | |
| 105 | + { | |
| 106 | + <p class="alert success">@T["These branches can be merged automatically."]</p> | |
| 107 | + @if (IsOwner) | |
| 108 | + { | |
| 109 | + <form method="post" @formname="merge" @onsubmit="MergeAsync" class="form"> | |
| 110 | + <AntiforgeryToken/> | |
| 111 | + <MergeFields CanFastForward="check.CanFastForward" AllowDelete="@(_pull.HeadBranch != Repository.DefaultBranch)" | |
| 112 | + HeadName="@_pull.HeadBranch" Message="@Message"/> | |
| 113 | + <button type="submit" class="button primary">@T["Merge"]</button> | |
| 114 | + </form> | |
| 115 | + } | |
| 116 | + } | |
| 117 | + } | |
| 118 | + </section> | |
| 119 | + } | |
| 120 | + | |
| 121 | + @if (IsOwner && _pull.Status != PullRequestStatus.Merged) | |
| 122 | + { | |
| 123 | + <form method="post" @formname="pull-state" @onsubmit="ChangeStateAsync" class="button-row"> | |
| 124 | + <AntiforgeryToken/> | |
| 125 | + @if (_pull.Status == PullRequestStatus.Open) | |
| 126 | + { | |
| 127 | + <button type="submit" name="Action" value="close" class="button">@T["Close pull request"]</button> | |
| 128 | + } | |
| 129 | + else | |
| 130 | + { | |
| 131 | + <button type="submit" name="Action" value="reopen" class="button">@T["Reopen pull request"]</button> | |
| 132 | + } | |
| 133 | + </form> | |
| 134 | + } | |
| 135 | + | |
| 136 | + <h3>@T.Plural(_commits.Count, "{0} commit", "{0} commits")</h3> | |
| 137 | + @if (_commits.Count > 0) | |
| 138 | + { | |
| 139 | + <CommitList Repository="Repository" Commits="_commits"/> | |
| 140 | + } | |
| 141 | + | |
| 142 | + <h3>@T.Plural(_comments.Count, "{0} comment", "{0} comments")</h3> | |
| 143 | + @foreach (var comment in _comments) | |
| 144 | + { | |
| 145 | + <article class="card comment" id="comment-@comment.Id"> | |
| 146 | + <p class="muted small commit-byline comment-head"> | |
| 147 | + <Avatar Name="@comment.Author.Username"/> | |
| 148 | + <strong>@comment.Author.Username</strong> | |
| 149 | + <span class="sep">·</span> | |
| 150 | + <TimeAgo Value="Format.Utc(comment.CreatedAt)"/> | |
| 151 | + </p> | |
| 152 | + <div class="markdown">@((MarkupString)Render(comment.Body))</div> | |
| 153 | + </article> | |
| 154 | + } | |
| 155 | + @if (IsOwner) | |
| 156 | + { | |
| 157 | + <form method="post" @formname="comment" @onsubmit="CommentAsync" class="form"> | |
| 158 | + <AntiforgeryToken/> | |
| 159 | + <label> | |
| 160 | + <span>@T["Add a comment"] <span class="muted">@T["(Markdown)"]</span></span> | |
| 161 | + <textarea name="Body" rows="4" required>@Body</textarea> | |
| 162 | + </label> | |
| 163 | + <button type="submit" class="button">@T["Comment"]</button> | |
| 164 | + </form> | |
| 165 | + } | |
| 166 | + | |
| 167 | + @if (_diff is not null) | |
| 168 | + { | |
| 169 | + <h3> | |
| 170 | + @T.Plural(_diff.Stats.Count, "{0} changed file", "{0} changed files"): | |
| 171 | + <span class="added">+@_diff.Stats.Sum(s => s.Added ?? 0)</span> | |
| 172 | + <span class="deleted">−@_diff.Stats.Sum(s => s.Deleted ?? 0)</span> | |
| 173 | + </h3> | |
| 174 | + <DiffOptions Path="@Urls.Pull(Repository, _pull.Number)" Split="Split" IgnoreWhitespace="IgnoreWhitespace"/> | |
| 175 | + <DiffView Diff="_diff.Patch" Split="Split" Repository="Repository" HeadSha="@_state.ToSha"/> | |
| 176 | + } | |
| 177 | +} | |
| 178 | + | |
| 179 | +@code { | |
| 180 | + private const int MaxCommits = 250; | |
| 181 | + | |
| 182 | + [Parameter] | |
| 183 | + public int Number { get; set; } | |
| 184 | + | |
| 185 | + [SupplyParameterFromQuery(Name = "view")] | |
| 186 | + private string? View { get; set; } | |
| 187 | + | |
| 188 | + [SupplyParameterFromQuery(Name = "w")] | |
| 189 | + private string? Whitespace { get; set; } | |
| 190 | + | |
| 191 | + [SupplyParameterFromForm(FormName = "merge")] | |
| 192 | + private string? Method { get; set; } | |
| 193 | + | |
| 194 | + [SupplyParameterFromForm(FormName = "merge")] | |
| 195 | + private string? Message { get; set; } | |
| 196 | + | |
| 197 | + [SupplyParameterFromForm(FormName = "merge")] | |
| 198 | + private bool DeleteBranch { get; set; } | |
| 199 | + | |
| 200 | + [SupplyParameterFromForm(FormName = "pull-state")] | |
| 201 | + private string? Action { get; set; } | |
| 202 | + | |
| 203 | + [SupplyParameterFromForm(FormName = "comment")] | |
| 204 | + private string? Body { get; set; } | |
| 205 | + | |
| 206 | + [SupplyParameterFromForm(FormName = "edit-pull")] | |
| 207 | + private string? Title { get; set; } | |
| 208 | + | |
| 209 | + [SupplyParameterFromForm(FormName = "edit-pull")] | |
| 210 | + private string? Description { get; set; } | |
| 211 | + | |
| 212 | + private PullRequest? _pull; | |
| 213 | + private PullRequestState? _state; | |
| 214 | + private IReadOnlyList<CommitInfo> _commits = []; | |
| 215 | + private CommitDiff? _diff; | |
| 216 | + private List<PullRequestComment> _comments = []; | |
| 217 | + private string? _error; | |
| 218 | + private IReadOnlyList<string> _errorConflicts = []; | |
| 219 | + | |
| 220 | + private bool Split => View == "split"; | |
| 221 | + private bool IgnoreWhitespace => Whitespace == "1"; | |
| 222 | + | |
| 223 | + /// <summary>Descriptions and comments are Markdown, sanitized like a README; relative links point at the default branch.</summary> | |
| 224 | + private string Render(string markdown) => | |
| 225 | + Markdown.Render(markdown, new LinkContext( | |
| 226 | + Urls.Raw(Repository!, Repository!.DefaultBranch, ""), | |
| 227 | + Urls.Blob(Repository, Repository.DefaultBranch, ""), | |
| 228 | + "")); | |
| 229 | + | |
| 230 | + protected override async Task OnInitializedAsync() | |
| 231 | + { | |
| 232 | + if (!await LoadRepoAsync()) | |
| 233 | + { | |
| 234 | + return; | |
| 235 | + } | |
| 236 | + | |
| 237 | + _pull = await Pulls.FindAsync(Repository!.Id, Number); | |
| 238 | + if (_pull is null) | |
| 239 | + { | |
| 240 | + NotFound(); | |
| 241 | + return; | |
| 242 | + } | |
| 243 | + | |
| 244 | + await LoadAsync(); | |
| 245 | + } | |
| 246 | + | |
| 247 | + private async Task LoadAsync() | |
| 248 | + { | |
| 249 | + var repo = Repository!; | |
| 250 | + var pull = _pull!; | |
| 251 | + _state = await Pulls.LoadStateAsync(repo, pull); | |
| 252 | + | |
| 253 | + _commits = []; | |
| 254 | + _diff = null; | |
| 255 | + if (_state.ToSha is { } to) | |
| 256 | + { | |
| 257 | + if (_state.FromSha is { } from) | |
| 258 | + { | |
| 259 | + _commits = await Git.LogRangeAsync(RepoPath, from, to, MaxCommits); | |
| 260 | + _diff = await Git.GetRangeDiffAsync(RepoPath, from, to, IgnoreWhitespace); | |
| 261 | + } | |
| 262 | + } | |
| 263 | + | |
| 264 | + _comments = await Db.PullRequestComments | |
| 265 | + .AsNoTracking() | |
| 266 | + .Include(c => c.Author) | |
| 267 | + .Where(c => c.PullRequestId == pull.Id) | |
| 268 | + .OrderBy(c => c.Id) | |
| 269 | + .ToListAsync(); | |
| 270 | + } | |
| 271 | + | |
| 272 | + private async Task MergeAsync() | |
| 273 | + { | |
| 274 | + if (Repository is null || _pull is null || !IsOwner) | |
| 275 | + { | |
| 276 | + return; | |
| 277 | + } | |
| 278 | + | |
| 279 | + var user = await Db.Users.FindAsync(Me.UserId); | |
| 280 | + if (user is null) | |
| 281 | + { | |
| 282 | + return; | |
| 283 | + } | |
| 284 | + | |
| 285 | + var result = await Pulls.MergeAsync( | |
| 286 | + Repository, _pull, Refs.IdentityFor(user), MergeFields.Parse(Method), Message, DeleteBranch); | |
| 287 | + if (!result.Ok) | |
| 288 | + { | |
| 289 | + _error = T[result.Error!]; | |
| 290 | + _errorConflicts = result.Conflicts ?? []; | |
| 291 | + } | |
| 292 | + | |
| 293 | + await LoadAsync(); | |
| 294 | + } | |
| 295 | + | |
| 296 | + private async Task ChangeStateAsync() | |
| 297 | + { | |
| 298 | + if (Repository is null || _pull is null || !IsOwner) | |
| 299 | + { | |
| 300 | + return; | |
| 301 | + } | |
| 302 | + | |
| 303 | + if (Action == "close") | |
| 304 | + { | |
| 305 | + await Pulls.CloseAsync(Repository, _pull); | |
| 306 | + } | |
| 307 | + else if (Action == "reopen" && await Pulls.ReopenAsync(Repository, _pull) is { } error) | |
| 308 | + { | |
| 309 | + _error = T[error]; | |
| 310 | + } | |
| 311 | + | |
| 312 | + await LoadAsync(); | |
| 313 | + } | |
| 314 | + | |
| 315 | + private async Task EditAsync() | |
| 316 | + { | |
| 317 | + if (Repository is null || _pull is null || !IsOwner) | |
| 318 | + { | |
| 319 | + return; | |
| 320 | + } | |
| 321 | + | |
| 322 | + if (await Pulls.UpdateAsync(_pull, Title, Description) is { } error) | |
| 323 | + { | |
| 324 | + _error = T[error]; | |
| 325 | + } | |
| 326 | + else | |
| 327 | + { | |
| 328 | + Title = null; | |
| 329 | + Description = null; | |
| 330 | + } | |
| 331 | + | |
| 332 | + await LoadAsync(); | |
| 333 | + } | |
| 334 | + | |
| 335 | + private async Task CommentAsync() | |
| 336 | + { | |
| 337 | + if (Repository is null || _pull is null || !IsOwner) | |
| 338 | + { | |
| 339 | + return; | |
| 340 | + } | |
| 341 | + | |
| 342 | + if (await Pulls.AddCommentAsync(_pull, Me.UserId!.Value, Body) is { } error) | |
| 343 | + { | |
| 344 | + _error = T[error]; | |
| 345 | + } | |
| 346 | + else | |
| 347 | + { | |
| 348 | + Body = null; | |
| 349 | + } | |
| 350 | + | |
| 351 | + await LoadAsync(); | |
| 352 | + } | |
| 353 | +} |
added forge/Features/Pulls/PullList.razor +103 −0View file
| @@ -0,0 +1,103 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/pulls" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject ForgeDb Db | |
| 4 | + | |
| 5 | +@if (Repository is not null) | |
| 6 | +{ | |
| 7 | + <PageTitle>@T["Pull requests"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 8 | + | |
| 9 | + <RepoHeader Repository="Repository" Active="pulls" IsOwner="IsOwner"/> | |
| 10 | + | |
| 11 | + <div class="toolbar"> | |
| 12 | + <nav class="segmented"> | |
| 13 | + <a class="@(ShowClosed ? "" : "active")" href="@Urls.Pulls(Repository)">@T["Open ({0})", _openCount]</a> | |
| 14 | + <a class="@(ShowClosed ? "active" : "")" href="@Urls.Pulls(Repository)?state=closed">@T["Closed ({0})", _closedCount]</a> | |
| 15 | + </nav> | |
| 16 | + @if (IsOwner) | |
| 17 | + { | |
| 18 | + <a class="button primary toolbar-end" href="@Urls.Compare(Repository)"><Icon Name="plus"/> @T["New pull request"]</a> | |
| 19 | + } | |
| 20 | + </div> | |
| 21 | + | |
| 22 | + @if (_pulls.Count == 0) | |
| 23 | + { | |
| 24 | + <div class="empty-state"> | |
| 25 | + <Icon Name="pull" Size="32"/> | |
| 26 | + <h2>@(ShowClosed ? T["There are no closed pull requests."] : T["There are no open pull requests."])</h2> | |
| 27 | + </div> | |
| 28 | + } | |
| 29 | + else | |
| 30 | + { | |
| 31 | + <ul class="commit-list"> | |
| 32 | + @foreach (var pull in _pulls) | |
| 33 | + { | |
| 34 | + <li class="commit-row"> | |
| 35 | + <span class="pull-icon pull-@pull.Status.ToString().ToLowerInvariant()"> | |
| 36 | + <Icon Name="@(pull.Status == PullRequestStatus.Merged ? "merge" : "pull")" Size="18"/> | |
| 37 | + </span> | |
| 38 | + <div class="commit-main pull-main"> | |
| 39 | + <a class="commit-subject" href="@Urls.Pull(Repository, pull.Number)">@pull.Title</a> | |
| 40 | + <div class="muted small commit-byline"> | |
| 41 | + <span>#@pull.Number</span> | |
| 42 | + <span class="sep">·</span> | |
| 43 | + <Avatar Name="@pull.Author.Username"/> | |
| 44 | + <span>@pull.Author.Username</span> | |
| 45 | + <span class="sep">·</span> | |
| 46 | + <span><code>@pull.HeadBranch</code> → <code>@pull.BaseBranch</code></span> | |
| 47 | + <span class="sep">·</span> | |
| 48 | + <TimeAgo Value="Format.Utc(pull.UpdatedAt)"/> | |
| 49 | + </div> | |
| 50 | + </div> | |
| 51 | + @if (_commentCounts.GetValueOrDefault(pull.Id) is > 0 and var comments) | |
| 52 | + { | |
| 53 | + <a class="meta-item muted small" href="@Urls.Pull(Repository, pull.Number)" | |
| 54 | + title="@T.Plural(comments, "{0} comment", "{0} comments")"> | |
| 55 | + <Icon Name="comment" Size="14"/> @comments | |
| 56 | + </a> | |
| 57 | + } | |
| 58 | + <PullStatusBadge Status="pull.Status"/> | |
| 59 | + </li> | |
| 60 | + } | |
| 61 | + </ul> | |
| 62 | + } | |
| 63 | +} | |
| 64 | + | |
| 65 | +@code { | |
| 66 | + [SupplyParameterFromQuery(Name = "state")] | |
| 67 | + private string? State { get; set; } | |
| 68 | + | |
| 69 | + private List<PullRequest> _pulls = []; | |
| 70 | + private Dictionary<long, int> _commentCounts = []; | |
| 71 | + private int _openCount; | |
| 72 | + private int _closedCount; | |
| 73 | + | |
| 74 | + private bool ShowClosed => State == "closed"; | |
| 75 | + | |
| 76 | + protected override async Task OnInitializedAsync() | |
| 77 | + { | |
| 78 | + if (!await LoadRepoAsync()) | |
| 79 | + { | |
| 80 | + return; | |
| 81 | + } | |
| 82 | + | |
| 83 | + var repoId = Repository!.Id; | |
| 84 | + var all = Db.PullRequests.Where(p => p.RepoId == repoId); | |
| 85 | + _openCount = await all.CountAsync(p => p.Status == PullRequestStatus.Open); | |
| 86 | + _closedCount = await all.CountAsync(p => p.Status != PullRequestStatus.Open); | |
| 87 | + | |
| 88 | + var showClosed = ShowClosed; | |
| 89 | + _pulls = await all | |
| 90 | + .Include(p => p.Author) | |
| 91 | + .Where(p => (p.Status != PullRequestStatus.Open) == showClosed) | |
| 92 | + .OrderByDescending(p => p.Number) | |
| 93 | + .Take(200) | |
| 94 | + .ToListAsync(); | |
| 95 | + | |
| 96 | + var ids = _pulls.Select(p => p.Id).ToList(); | |
| 97 | + _commentCounts = await Db.PullRequestComments | |
| 98 | + .Where(c => ids.Contains(c.PullRequestId)) | |
| 99 | + .GroupBy(c => c.PullRequestId) | |
| 100 | + .Select(g => new { g.Key, Count = g.Count() }) | |
| 101 | + .ToDictionaryAsync(g => g.Key, g => g.Count); | |
| 102 | + } | |
| 103 | +} |
added forge/Features/Pulls/PullRequestService.cs +289 −0View file
| @@ -0,0 +1,289 @@ | ||
| 1 | +using Forge.Data; | |
| 2 | +using Forge.Features.History; | |
| 3 | +using Forge.Git; | |
| 4 | +using Forge.Localization; | |
| 5 | +using Microsoft.EntityFrameworkCore; | |
| 6 | + | |
| 7 | +namespace Forge.Features.Pulls; | |
| 8 | + | |
| 9 | +/// <summary>What a pull request looks like right now.</summary> | |
| 10 | +/// <param name="Base">The base branch, or null when it no longer exists (or the pull request is not open).</param> | |
| 11 | +/// <param name="Head">The head branch, likewise.</param> | |
| 12 | +/// <param name="FromSha">Start of the diff: where the branches diverged. Null when unknown.</param> | |
| 13 | +/// <param name="ToSha">End of the diff: the head's tip.</param> | |
| 14 | +/// <param name="Check">For an open pull request with both branches present, whether it can be merged.</param> | |
| 15 | +public sealed record PullRequestState(GitRef? Base, GitRef? Head, string? FromSha, string? ToSha, MergeCheck? Check); | |
| 16 | + | |
| 17 | +public sealed class PullRequestService(ForgeDb db, RefService refs, GitRepo git, RepoPaths paths) | |
| 18 | +{ | |
| 19 | + public const int MaxTitleLength = 200; | |
| 20 | + public const int MaxTextLength = 20_000; | |
| 21 | + | |
| 22 | + public Task<PullRequest?> FindAsync(long repoId, int number, CancellationToken ct = default) => | |
| 23 | + db.PullRequests.Include(p => p.Author).FirstOrDefaultAsync(p => p.RepoId == repoId && p.Number == number, ct); | |
| 24 | + | |
| 25 | + public async Task<(PullRequest? PullRequest, string? Error)> CreateAsync( | |
| 26 | + Repository repo, | |
| 27 | + long authorId, | |
| 28 | + string? title, | |
| 29 | + string? description, | |
| 30 | + string? baseBranch, | |
| 31 | + string? headBranch, | |
| 32 | + CancellationToken ct = default) | |
| 33 | + { | |
| 34 | + title = title?.Trim() ?? ""; | |
| 35 | + description = description?.Trim() ?? ""; | |
| 36 | + if (title.Length is 0 or > MaxTitleLength) | |
| 37 | + { | |
| 38 | + return (null, Localizer.Key("Enter a title (at most 200 characters).")); | |
| 39 | + } | |
| 40 | + | |
| 41 | + if (description.Length > MaxTextLength) | |
| 42 | + { | |
| 43 | + return (null, Localizer.Key("The text is too long.")); | |
| 44 | + } | |
| 45 | + | |
| 46 | + var path = paths.For(repo.Id); | |
| 47 | + var branches = (await git.ListRefsAsync(path, ct)).Where(r => r.Kind == RefKind.Branch).ToList(); | |
| 48 | + var target = branches.FirstOrDefault(b => b.Name == baseBranch); | |
| 49 | + var source = branches.FirstOrDefault(b => b.Name == headBranch); | |
| 50 | + if (target is null || source is null) | |
| 51 | + { | |
| 52 | + return (null, Localizer.Key("There is no such branch in the repository.")); | |
| 53 | + } | |
| 54 | + | |
| 55 | + if (target.Name == source.Name) | |
| 56 | + { | |
| 57 | + return (null, Localizer.Key("Choose two different branches.")); | |
| 58 | + } | |
| 59 | + | |
| 60 | + if (await git.MergeBaseAsync(path, target.Sha, source.Sha, ct) == source.Sha) | |
| 61 | + { | |
| 62 | + return (null, Localizer.Key("There is nothing to merge.")); | |
| 63 | + } | |
| 64 | + | |
| 65 | + if (await db.PullRequests.AnyAsync( | |
| 66 | + p => p.RepoId == repo.Id | |
| 67 | + && p.Status == PullRequestStatus.Open | |
| 68 | + && p.BaseBranch == target.Name | |
| 69 | + && p.HeadBranch == source.Name, | |
| 70 | + ct)) | |
| 71 | + { | |
| 72 | + return (null, Localizer.Key("An open pull request for these branches already exists.")); | |
| 73 | + } | |
| 74 | + | |
| 75 | + var now = DateTime.UtcNow; | |
| 76 | + var pull = new PullRequest | |
| 77 | + { | |
| 78 | + RepoId = repo.Id, | |
| 79 | + Number = (await db.PullRequests.Where(p => p.RepoId == repo.Id).MaxAsync(p => (int?)p.Number, ct) ?? 0) + 1, | |
| 80 | + Title = title, | |
| 81 | + Description = description, | |
| 82 | + BaseBranch = target.Name, | |
| 83 | + HeadBranch = source.Name, | |
| 84 | + Status = PullRequestStatus.Open, | |
| 85 | + AuthorId = authorId, | |
| 86 | + CreatedAt = now, | |
| 87 | + UpdatedAt = now, | |
| 88 | + }; | |
| 89 | + db.PullRequests.Add(pull); | |
| 90 | + await db.SaveChangesAsync(ct); | |
| 91 | + return (pull, null); | |
| 92 | + } | |
| 93 | + | |
| 94 | + /// <summary> | |
| 95 | + /// Works out what to show. As a side effect, an open pull request whose head has meanwhile been | |
| 96 | + /// merged some other way (a push, the compare page) is marked as merged. | |
| 97 | + /// </summary> | |
| 98 | + public async Task<PullRequestState> LoadStateAsync(Repository repo, PullRequest pull, CancellationToken ct = default) | |
| 99 | + { | |
| 100 | + if (pull.Status != PullRequestStatus.Open) | |
| 101 | + { | |
| 102 | + return new PullRequestState(null, null, pull.BaseSha, pull.HeadSha, null); | |
| 103 | + } | |
| 104 | + | |
| 105 | + var path = paths.For(repo.Id); | |
| 106 | + var branches = (await git.ListRefsAsync(path, ct)).Where(r => r.Kind == RefKind.Branch).ToList(); | |
| 107 | + var target = branches.FirstOrDefault(b => b.Name == pull.BaseBranch); | |
| 108 | + var source = branches.FirstOrDefault(b => b.Name == pull.HeadBranch); | |
| 109 | + if (target is null || source is null) | |
| 110 | + { | |
| 111 | + return new PullRequestState(target, source, null, null, null); | |
| 112 | + } | |
| 113 | + | |
| 114 | + var mergeBase = await git.MergeBaseAsync(path, target.Sha, source.Sha, ct); | |
| 115 | + if (mergeBase == source.Sha) | |
| 116 | + { | |
| 117 | + // Where the branches had diverged is no longer known, so only the head is recorded. | |
| 118 | + await MarkMergedAsync(pull, null, source.Sha, target.Sha, ct); | |
| 119 | + return new PullRequestState(null, null, null, source.Sha, null); | |
| 120 | + } | |
| 121 | + | |
| 122 | + var check = await refs.CheckMergeAsync(path, target.Sha, source.Sha, ct); | |
| 123 | + return new PullRequestState(target, source, mergeBase ?? target.Sha, source.Sha, check); | |
| 124 | + } | |
| 125 | + | |
| 126 | + public async Task<RefResult> MergeAsync( | |
| 127 | + Repository repo, | |
| 128 | + PullRequest pull, | |
| 129 | + GitIdentity who, | |
| 130 | + MergeMethod method, | |
| 131 | + string? message, | |
| 132 | + bool deleteBranch, | |
| 133 | + CancellationToken ct = default) | |
| 134 | + { | |
| 135 | + var state = await LoadStateAsync(repo, pull, ct); | |
| 136 | + if (pull.Status != PullRequestStatus.Open || state.Base is null || state.Head is null) | |
| 137 | + { | |
| 138 | + return new RefResult(Localizer.Key("This pull request can no longer be merged.")); | |
| 139 | + } | |
| 140 | + | |
| 141 | + var result = await refs.MergeAsync(repo, who, pull.BaseBranch, pull.HeadBranch, method, message, ct); | |
| 142 | + if (!result.Ok) | |
| 143 | + { | |
| 144 | + return result; | |
| 145 | + } | |
| 146 | + | |
| 147 | + await MarkMergedAsync(pull, state.FromSha, state.Head.Sha, result.Sha, ct); | |
| 148 | + if (deleteBranch) | |
| 149 | + { | |
| 150 | + // Refused for the default or a protected branch; that does not undo the merge. | |
| 151 | + await refs.DeleteBranchAsync(repo, pull.HeadBranch, ct); | |
| 152 | + } | |
| 153 | + | |
| 154 | + return result; | |
| 155 | + } | |
| 156 | + | |
| 157 | + public async Task MarkMergedAsync(PullRequest pull, string? fromSha, string headSha, string? mergeCommitSha, CancellationToken ct = default) | |
| 158 | + { | |
| 159 | + var now = DateTime.UtcNow; | |
| 160 | + pull.Status = PullRequestStatus.Merged; | |
| 161 | + pull.BaseSha = fromSha; | |
| 162 | + pull.HeadSha = headSha; | |
| 163 | + pull.MergeCommitSha = mergeCommitSha; | |
| 164 | + pull.ClosedAt = now; | |
| 165 | + pull.UpdatedAt = now; | |
| 166 | + await db.SaveChangesAsync(ct); | |
| 167 | + } | |
| 168 | + | |
| 169 | + /// <summary>Marks the open pull request for a pair of branches as merged, if there is one.</summary> | |
| 170 | + public async Task MarkMergedAsync( | |
| 171 | + Repository repo, | |
| 172 | + string baseBranch, | |
| 173 | + string headBranch, | |
| 174 | + string? fromSha, | |
| 175 | + string headSha, | |
| 176 | + string? mergeCommitSha, | |
| 177 | + CancellationToken ct = default) | |
| 178 | + { | |
| 179 | + var pull = await db.PullRequests.FirstOrDefaultAsync( | |
| 180 | + p => p.RepoId == repo.Id | |
| 181 | + && p.Status == PullRequestStatus.Open | |
| 182 | + && p.BaseBranch == baseBranch | |
| 183 | + && p.HeadBranch == headBranch, | |
| 184 | + ct); | |
| 185 | + if (pull is not null) | |
| 186 | + { | |
| 187 | + await MarkMergedAsync(pull, fromSha, headSha, mergeCommitSha, ct); | |
| 188 | + } | |
| 189 | + } | |
| 190 | + | |
| 191 | + public async Task CloseAsync(Repository repo, PullRequest pull, CancellationToken ct = default) | |
| 192 | + { | |
| 193 | + var state = await LoadStateAsync(repo, pull, ct); | |
| 194 | + if (pull.Status != PullRequestStatus.Open) | |
| 195 | + { | |
| 196 | + return; | |
| 197 | + } | |
| 198 | + | |
| 199 | + var now = DateTime.UtcNow; | |
| 200 | + pull.Status = PullRequestStatus.Closed; | |
| 201 | + pull.BaseSha = state.FromSha; | |
| 202 | + pull.HeadSha = state.ToSha; | |
| 203 | + pull.ClosedAt = now; | |
| 204 | + pull.UpdatedAt = now; | |
| 205 | + await db.SaveChangesAsync(ct); | |
| 206 | + } | |
| 207 | + | |
| 208 | + public async Task<string?> ReopenAsync(Repository repo, PullRequest pull, CancellationToken ct = default) | |
| 209 | + { | |
| 210 | + if (pull.Status != PullRequestStatus.Closed) | |
| 211 | + { | |
| 212 | + return null; | |
| 213 | + } | |
| 214 | + | |
| 215 | + var path = paths.For(repo.Id); | |
| 216 | + var branches = (await git.ListRefsAsync(path, ct)).Where(r => r.Kind == RefKind.Branch).Select(r => r.Name).ToList(); | |
| 217 | + if (!branches.Contains(pull.BaseBranch) || !branches.Contains(pull.HeadBranch)) | |
| 218 | + { | |
| 219 | + return Localizer.Key("A branch of this pull request no longer exists, so it cannot be reopened."); | |
| 220 | + } | |
| 221 | + | |
| 222 | + if (await db.PullRequests.AnyAsync( | |
| 223 | + p => p.RepoId == repo.Id | |
| 224 | + && p.Id != pull.Id | |
| 225 | + && p.Status == PullRequestStatus.Open | |
| 226 | + && p.BaseBranch == pull.BaseBranch | |
| 227 | + && p.HeadBranch == pull.HeadBranch, | |
| 228 | + ct)) | |
| 229 | + { | |
| 230 | + return Localizer.Key("An open pull request for these branches already exists."); | |
| 231 | + } | |
| 232 | + | |
| 233 | + pull.Status = PullRequestStatus.Open; | |
| 234 | + pull.BaseSha = null; | |
| 235 | + pull.HeadSha = null; | |
| 236 | + pull.ClosedAt = null; | |
| 237 | + pull.UpdatedAt = DateTime.UtcNow; | |
| 238 | + await db.SaveChangesAsync(ct); | |
| 239 | + return null; | |
| 240 | + } | |
| 241 | + | |
| 242 | + /// <summary>Changes the title and description. Allowed in every state: a merged pull request is still a record worth correcting.</summary> | |
| 243 | + public async Task<string?> UpdateAsync(PullRequest pull, string? title, string? description, CancellationToken ct = default) | |
| 244 | + { | |
| 245 | + title = title?.Trim() ?? ""; | |
| 246 | + description = description?.Trim() ?? ""; | |
| 247 | + if (title.Length is 0 or > MaxTitleLength) | |
| 248 | + { | |
| 249 | + return Localizer.Key("Enter a title (at most 200 characters)."); | |
| 250 | + } | |
| 251 | + | |
| 252 | + if (description.Length > MaxTextLength) | |
| 253 | + { | |
| 254 | + return Localizer.Key("The text is too long."); | |
| 255 | + } | |
| 256 | + | |
| 257 | + pull.Title = title; | |
| 258 | + pull.Description = description; | |
| 259 | + pull.UpdatedAt = DateTime.UtcNow; | |
| 260 | + await db.SaveChangesAsync(ct); | |
| 261 | + return null; | |
| 262 | + } | |
| 263 | + | |
| 264 | + public async Task<string?> AddCommentAsync(PullRequest pull, long authorId, string? body, CancellationToken ct = default) | |
| 265 | + { | |
| 266 | + body = body?.Trim() ?? ""; | |
| 267 | + if (body.Length == 0) | |
| 268 | + { | |
| 269 | + return Localizer.Key("Write a comment first."); | |
| 270 | + } | |
| 271 | + | |
| 272 | + if (body.Length > MaxTextLength) | |
| 273 | + { | |
| 274 | + return Localizer.Key("The text is too long."); | |
| 275 | + } | |
| 276 | + | |
| 277 | + var now = DateTime.UtcNow; | |
| 278 | + db.PullRequestComments.Add(new PullRequestComment | |
| 279 | + { | |
| 280 | + PullRequestId = pull.Id, | |
| 281 | + AuthorId = authorId, | |
| 282 | + Body = body, | |
| 283 | + CreatedAt = now, | |
| 284 | + }); | |
| 285 | + pull.UpdatedAt = now; | |
| 286 | + await db.SaveChangesAsync(ct); | |
| 287 | + return null; | |
| 288 | + } | |
| 289 | +} |
added forge/Features/Pulls/PullStatusBadge.razor +17 −0View file
| @@ -0,0 +1,17 @@ | ||
| 1 | +@switch (Status) | |
| 2 | +{ | |
| 3 | + case PullRequestStatus.Open: | |
| 4 | + <span class="badge badge-added"><Icon Name="pull" Size="12"/> @T["open"]</span> | |
| 5 | + break; | |
| 6 | + case PullRequestStatus.Merged: | |
| 7 | + <span class="badge badge-merged"><Icon Name="merge" Size="12"/> @T["merged"]</span> | |
| 8 | + break; | |
| 9 | + default: | |
| 10 | + <span class="badge badge-deleted"><Icon Name="x" Size="12"/> @T["closed"]</span> | |
| 11 | + break; | |
| 12 | +} | |
| 13 | + | |
| 14 | +@code { | |
| 15 | + [Parameter, EditorRequired] | |
| 16 | + public PullRequestStatus Status { get; set; } | |
| 17 | +} |
added forge/Features/Repos/BranchProtectionSettings.razor +151 −0View file
| @@ -0,0 +1,151 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/settings/branches" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject ForgeDb Db | |
| 4 | +@inject RefService Refs | |
| 5 | + | |
| 6 | +@if (Repository is not null) | |
| 7 | +{ | |
| 8 | + <PageTitle>@T["Protected branches"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 9 | + | |
| 10 | + <RepoHeader Repository="Repository" Active="settings" IsOwner="IsOwner"/> | |
| 11 | + | |
| 12 | + <nav class="subtabs"> | |
| 13 | + <a href="@Urls.Settings(Repository)">@T["General"]</a> | |
| 14 | + <a href="@Urls.Webhooks(Repository)">@T["Webhooks"]</a> | |
| 15 | + <a class="active" href="@Urls.Protection(Repository)">@T["Protected branches"]</a> | |
| 16 | + </nav> | |
| 17 | + | |
| 18 | + <p class="muted">@T["A protected branch cannot be force-pushed or deleted, from git or from the web. Merging into it still works."]</p> | |
| 19 | + | |
| 20 | + @if (_error is not null) | |
| 21 | + { | |
| 22 | + <p class="alert error">@_error</p> | |
| 23 | + } | |
| 24 | + | |
| 25 | + @if (_rules.Count == 0) | |
| 26 | + { | |
| 27 | + <div class="card empty"><p>@T["No branch is protected yet."]</p></div> | |
| 28 | + } | |
| 29 | + else | |
| 30 | + { | |
| 31 | + <form method="post" @formname="remove-rule" @onsubmit="RemoveAsync"> | |
| 32 | + <AntiforgeryToken/> | |
| 33 | + <table class="table"> | |
| 34 | + <thead> | |
| 35 | + <tr> | |
| 36 | + <th>@T["Branch"]</th> | |
| 37 | + <th>@T["Direct pushes"]</th> | |
| 38 | + <th></th> | |
| 39 | + </tr> | |
| 40 | + </thead> | |
| 41 | + <tbody> | |
| 42 | + @foreach (var rule in _rules) | |
| 43 | + { | |
| 44 | + <tr> | |
| 45 | + <td><code>@rule.Pattern</code></td> | |
| 46 | + <td>@(rule.BlockPush ? T["refused, changes only through merges on the web"] : T["allowed"])</td> | |
| 47 | + <td class="right"> | |
| 48 | + <button type="submit" name="RuleId" value="@rule.Id" class="button danger small">@T["Remove protection"]</button> | |
| 49 | + </td> | |
| 50 | + </tr> | |
| 51 | + } | |
| 52 | + </tbody> | |
| 53 | + </table> | |
| 54 | + </form> | |
| 55 | + } | |
| 56 | + | |
| 57 | + <section class="card"> | |
| 58 | + <h2>@T["Protect a branch"]</h2> | |
| 59 | + <form method="post" @formname="add-rule" @onsubmit="AddAsync" class="form"> | |
| 60 | + <AntiforgeryToken/> | |
| 61 | + <label> | |
| 62 | + @T["Branch"] | |
| 63 | + <input name="Pattern" value="@(Pattern ?? Repository.DefaultBranch)" required maxlength="200"/> | |
| 64 | + <small class="muted">@T.Html("A branch name, or a prefix ending in <code>/*</code> such as <code>release/*</code>.")</small> | |
| 65 | + </label> | |
| 66 | + <label class="choice"> | |
| 67 | + <input type="checkbox" name="BlockPush" value="true"/> | |
| 68 | + @T["Also refuse direct pushes (changes only through merges on the web)"] | |
| 69 | + </label> | |
| 70 | + <button type="submit" class="button primary">@T["Protect"]</button> | |
| 71 | + </form> | |
| 72 | + </section> | |
| 73 | +} | |
| 74 | + | |
| 75 | +@code { | |
| 76 | + [SupplyParameterFromForm(FormName = "add-rule")] | |
| 77 | + private string? Pattern { get; set; } | |
| 78 | + | |
| 79 | + [SupplyParameterFromForm(FormName = "add-rule")] | |
| 80 | + private bool BlockPush { get; set; } | |
| 81 | + | |
| 82 | + [SupplyParameterFromForm(FormName = "remove-rule")] | |
| 83 | + private long? RuleId { get; set; } | |
| 84 | + | |
| 85 | + private List<BranchProtection> _rules = []; | |
| 86 | + private string? _error; | |
| 87 | + | |
| 88 | + protected override async Task OnInitializedAsync() | |
| 89 | + { | |
| 90 | + if (await LoadRepoAsync(requireAdmin: true)) | |
| 91 | + { | |
| 92 | + await LoadAsync(); | |
| 93 | + } | |
| 94 | + } | |
| 95 | + | |
| 96 | + private async Task LoadAsync() | |
| 97 | + { | |
| 98 | + var repoId = Repository!.Id; | |
| 99 | + _rules = await Db.BranchProtections.Where(r => r.RepoId == repoId).OrderBy(r => r.Pattern).ToListAsync(); | |
| 100 | + } | |
| 101 | + | |
| 102 | + private async Task AddAsync() | |
| 103 | + { | |
| 104 | + if (Repository is null) | |
| 105 | + { | |
| 106 | + return; | |
| 107 | + } | |
| 108 | + | |
| 109 | + // The pattern later becomes part of a git option, so it must be a real branch name (plus an optional /*). | |
| 110 | + var pattern = Pattern?.Trim() ?? ""; | |
| 111 | + if (!await Refs.IsValidBranchNameAsync(BranchRules.NamePart(pattern))) | |
| 112 | + { | |
| 113 | + _error = T["This is not a valid branch name."]; | |
| 114 | + return; | |
| 115 | + } | |
| 116 | + | |
| 117 | + if (_rules.Any(r => r.Pattern == pattern)) | |
| 118 | + { | |
| 119 | + _error = T["This branch is already protected."]; | |
| 120 | + return; | |
| 121 | + } | |
| 122 | + | |
| 123 | + Db.BranchProtections.Add(new BranchProtection | |
| 124 | + { | |
| 125 | + RepoId = Repository.Id, | |
| 126 | + Pattern = pattern, | |
| 127 | + BlockPush = BlockPush, | |
| 128 | + CreatedAt = DateTime.UtcNow, | |
| 129 | + }); | |
| 130 | + await Db.SaveChangesAsync(); | |
| 131 | + Pattern = null; | |
| 132 | + await LoadAsync(); | |
| 133 | + } | |
| 134 | + | |
| 135 | + private async Task RemoveAsync() | |
| 136 | + { | |
| 137 | + if (Repository is null) | |
| 138 | + { | |
| 139 | + return; | |
| 140 | + } | |
| 141 | + | |
| 142 | + var rule = _rules.FirstOrDefault(r => r.Id == RuleId); | |
| 143 | + if (rule is not null) | |
| 144 | + { | |
| 145 | + Db.BranchProtections.Remove(rule); | |
| 146 | + await Db.SaveChangesAsync(); | |
| 147 | + } | |
| 148 | + | |
| 149 | + await LoadAsync(); | |
| 150 | + } | |
| 151 | +} |
added forge/Features/Repos/Home.razor +198 −0View file
| @@ -0,0 +1,198 @@ | ||
| 1 | +@page "/" | |
| 2 | +@page "/{Owner}" | |
| 3 | +@inject ForgeDb Db | |
| 4 | +@inject CurrentUser Me | |
| 5 | +@inject NavigationManager Nav | |
| 6 | + | |
| 7 | +@if (_loaded) | |
| 8 | +{ | |
| 9 | + <PageTitle>@(_owner is null ? "Forge" : _owner.Username + " · Forge")</PageTitle> | |
| 10 | + | |
| 11 | + @if (_owner is not null) | |
| 12 | + { | |
| 13 | + <section class="profile"> | |
| 14 | + <Avatar Name="@_owner.Username" Size="lg"/> | |
| 15 | + <div> | |
| 16 | + <h1>@_owner.DisplayName</h1> | |
| 17 | + <p class="muted"> | |
| 18 | + @@@_owner.Username | |
| 19 | + <span class="sep">·</span> | |
| 20 | + @T["Joined"] <TimeAgo Value="Format.Utc(_owner.CreatedAt)"/> | |
| 21 | + </p> | |
| 22 | + </div> | |
| 23 | + </section> | |
| 24 | + } | |
| 25 | + | |
| 26 | + <div class="page-head"> | |
| 27 | + <div> | |
| 28 | + @if (_owner is null) | |
| 29 | + { | |
| 30 | + <h1>@T["Repositories"]</h1> | |
| 31 | + } | |
| 32 | + else | |
| 33 | + { | |
| 34 | + <h2>@T["Repositories"]</h2> | |
| 35 | + } | |
| 36 | + <p class="muted small page-sub">@T.Plural(_repos.Count, "{0} repository", "{0} repositories")</p> | |
| 37 | + </div> | |
| 38 | + @if (Me.IsAuthenticated) | |
| 39 | + { | |
| 40 | + <a class="button primary" href="/new"><Icon Name="plus"/> @T["New repository"]</a> | |
| 41 | + } | |
| 42 | + </div> | |
| 43 | + | |
| 44 | + @if (_repos.Count > 0 || HasQuery) | |
| 45 | + { | |
| 46 | + <div class="filter-bar"> | |
| 47 | + <form class="search filter-search" method="get" action="@BasePath" role="search"> | |
| 48 | + <Icon Name="search" Size="15"/> | |
| 49 | + <input type="search" name="q" value="@Query" placeholder="@T["Find a repository"]" | |
| 50 | + aria-label="@T["Find a repository"]" autocomplete="off"/> | |
| 51 | + @if (SortByName) | |
| 52 | + { | |
| 53 | + <input type="hidden" name="sort" value="name"/> | |
| 54 | + } | |
| 55 | + </form> | |
| 56 | + <nav class="segmented" aria-label="@T["Sort"]"> | |
| 57 | + <a class="@(SortByName ? "" : "active")" href="@ListUrl(sortByName: false)">@T["Recently updated"]</a> | |
| 58 | + <a class="@(SortByName ? "active" : "")" href="@ListUrl(sortByName: true)">@T["Name"]</a> | |
| 59 | + </nav> | |
| 60 | + </div> | |
| 61 | + } | |
| 62 | + | |
| 63 | + @if (_repos.Count == 0 && HasQuery) | |
| 64 | + { | |
| 65 | + <div class="empty-state"> | |
| 66 | + <Icon Name="search" Size="32"/> | |
| 67 | + <h2>@T["No repository matches “{0}”.", Query!.Trim()]</h2> | |
| 68 | + <p><a href="@ListUrl(SortByName, keepQuery: false)">@T["Clear the search"]</a></p> | |
| 69 | + </div> | |
| 70 | + } | |
| 71 | + else if (_repos.Count == 0) | |
| 72 | + { | |
| 73 | + <div class="empty-state"> | |
| 74 | + <Icon Name="inbox" Size="32"/> | |
| 75 | + <h2>@T["There are no repositories here yet."]</h2> | |
| 76 | + @if (Me.IsAuthenticated) | |
| 77 | + { | |
| 78 | + <p class="muted"><a href="/new">@T["Create your first repository"]</a> @T["and push your code to it."]</p> | |
| 79 | + } | |
| 80 | + </div> | |
| 81 | + } | |
| 82 | + else | |
| 83 | + { | |
| 84 | + <ul class="repo-list"> | |
| 85 | + @foreach (var repo in _repos) | |
| 86 | + { | |
| 87 | + var isPrivate = repo.Visibility == Visibility.Private; | |
| 88 | + <li class="repo-row"> | |
| 89 | + <span class="repo-icon"><Icon Name="@(isPrivate ? "lock" : "book")" Size="18"/></span> | |
| 90 | + <div class="repo-main"> | |
| 91 | + <a class="repo-link" href="@Urls.Repo(repo)">@repo.Owner.Username/<strong>@repo.Name</strong></a> | |
| 92 | + @if (isPrivate) | |
| 93 | + { | |
| 94 | + <span class="badge">@T["private"]</span> | |
| 95 | + } | |
| 96 | + @if (repo.Description.Length > 0) | |
| 97 | + { | |
| 98 | + <p class="muted repo-row-description">@repo.Description</p> | |
| 99 | + } | |
| 100 | + </div> | |
| 101 | + <div class="repo-meta muted small"> | |
| 102 | + <span class="meta-item"><Icon Name="branch" Size="13"/> @repo.DefaultBranch</span> | |
| 103 | + @if (repo.PushedAt is { } pushed) | |
| 104 | + { | |
| 105 | + <span class="meta-item"><Icon Name="history" Size="13"/> @T["pushed"] <TimeAgo Value="Format.Utc(pushed)"/></span> | |
| 106 | + } | |
| 107 | + else | |
| 108 | + { | |
| 109 | + <span class="badge">@T["empty"]</span> | |
| 110 | + } | |
| 111 | + </div> | |
| 112 | + </li> | |
| 113 | + } | |
| 114 | + </ul> | |
| 115 | + } | |
| 116 | +} | |
| 117 | + | |
| 118 | +@code { | |
| 119 | + /// <summary>When set, lists only this user's repositories.</summary> | |
| 120 | + [Parameter] | |
| 121 | + public string? Owner { get; set; } | |
| 122 | + | |
| 123 | + [SupplyParameterFromQuery(Name = "q")] | |
| 124 | + private string? Query { get; set; } | |
| 125 | + | |
| 126 | + [SupplyParameterFromQuery(Name = "sort")] | |
| 127 | + private string? Sort { get; set; } | |
| 128 | + | |
| 129 | + private bool _loaded; | |
| 130 | + private User? _owner; | |
| 131 | + private List<Repository> _repos = []; | |
| 132 | + | |
| 133 | + private bool HasQuery => !string.IsNullOrWhiteSpace(Query); | |
| 134 | + private bool SortByName => Sort == "name"; | |
| 135 | + private string BasePath => _owner is null ? "/" : Urls.User(_owner.Username); | |
| 136 | + | |
| 137 | + private string ListUrl(bool sortByName, bool keepQuery = true) | |
| 138 | + { | |
| 139 | + var parts = new List<string>(); | |
| 140 | + if (keepQuery && HasQuery) | |
| 141 | + { | |
| 142 | + parts.Add("q=" + Uri.EscapeDataString(Query!.Trim())); | |
| 143 | + } | |
| 144 | + | |
| 145 | + if (sortByName) | |
| 146 | + { | |
| 147 | + parts.Add("sort=name"); | |
| 148 | + } | |
| 149 | + | |
| 150 | + return parts.Count == 0 ? BasePath : BasePath + "?" + string.Join('&', parts); | |
| 151 | + } | |
| 152 | + | |
| 153 | + protected override async Task OnInitializedAsync() | |
| 154 | + { | |
| 155 | + if (!await Db.Users.AnyAsync()) | |
| 156 | + { | |
| 157 | + Nav.NavigateTo("/setup"); | |
| 158 | + return; | |
| 159 | + } | |
| 160 | + | |
| 161 | + var query = Db.Repositories.Include(r => r.Owner).AsQueryable(); | |
| 162 | + if (Owner is not null) | |
| 163 | + { | |
| 164 | + _owner = await Db.Users.FirstOrDefaultAsync(u => u.Username == Owner); | |
| 165 | + if (_owner is null) | |
| 166 | + { | |
| 167 | + Nav.NotFound(); | |
| 168 | + return; | |
| 169 | + } | |
| 170 | + | |
| 171 | + var ownerId = _owner.Id; | |
| 172 | + query = query.Where(r => r.OwnerId == ownerId); | |
| 173 | + } | |
| 174 | + | |
| 175 | + // Anonymous visitors see public repositories only; the owner sees everything of theirs. | |
| 176 | + var me = Me.UserId; | |
| 177 | + query = query.Where(r => r.Visibility == Visibility.Public || r.OwnerId == me); | |
| 178 | + | |
| 179 | + if (HasQuery) | |
| 180 | + { | |
| 181 | + // LIKE with the wildcards of the search text escaped, so "%" finds a literal percent sign. | |
| 182 | + var text = Query!.Trim(); | |
| 183 | + text = text.Length > 100 ? text[..100] : text; | |
| 184 | + var pattern = "%" + text.Replace("\\", "\\\\").Replace("%", "\\%").Replace("_", "\\_") + "%"; | |
| 185 | + query = query.Where(r => | |
| 186 | + EF.Functions.Like(r.Name, pattern, "\\") | |
| 187 | + || EF.Functions.Like(r.Description, pattern, "\\") | |
| 188 | + || EF.Functions.Like(r.Owner.Username, pattern, "\\")); | |
| 189 | + } | |
| 190 | + | |
| 191 | + query = SortByName | |
| 192 | + ? query.OrderBy(r => r.Name) | |
| 193 | + : query.OrderByDescending(r => r.PushedAt ?? r.CreatedAt); | |
| 194 | + | |
| 195 | + _repos = await query.ToListAsync(); | |
| 196 | + _loaded = true; | |
| 197 | + } | |
| 198 | +} |
added forge/Features/Repos/NewRepo.razor +78 −0View file
| @@ -0,0 +1,78 @@ | ||
| 1 | +@page "/new" | |
| 2 | +@attribute [Authorize] | |
| 3 | +@inject RepoService Repos | |
| 4 | +@inject CurrentUser Me | |
| 5 | +@inject NavigationManager Nav | |
| 6 | + | |
| 7 | +<PageTitle>@T["New repository"] · Forge</PageTitle> | |
| 8 | + | |
| 9 | +<section class="narrow"> | |
| 10 | + <h1>@T["New repository"]</h1> | |
| 11 | + | |
| 12 | + @if (_error is not null) | |
| 13 | + { | |
| 14 | + <p class="alert error">@_error</p> | |
| 15 | + } | |
| 16 | + | |
| 17 | + <form method="post" @formname="new-repo" @onsubmit="CreateAsync" class="form"> | |
| 18 | + <AntiforgeryToken/> | |
| 19 | + <label> | |
| 20 | + @T["Name"] | |
| 21 | + <input name="Name" value="@Name" required maxlength="100" pattern="[A-Za-z0-9._\-]+" autofocus/> | |
| 22 | + <small class="muted">@T["Letters, digits, dots, hyphens and underscores."]</small> | |
| 23 | + </label> | |
| 24 | + <label> | |
| 25 | + <span>@T["Description"] <span class="muted">@T["(optional)"]</span></span> | |
| 26 | + <input name="Description" value="@Description" maxlength="300"/> | |
| 27 | + </label> | |
| 28 | + <fieldset> | |
| 29 | + <legend>@T["Visibility"]</legend> | |
| 30 | + <label class="choice"> | |
| 31 | + <input type="radio" name="Visibility" value="private" checked="@(Visibility != "public")"/> | |
| 32 | + @T["Private: only you can see it"] | |
| 33 | + </label> | |
| 34 | + <label class="choice"> | |
| 35 | + <input type="radio" name="Visibility" value="public" checked="@(Visibility == "public")"/> | |
| 36 | + @T["Public: anyone can read and clone it"] | |
| 37 | + </label> | |
| 38 | + </fieldset> | |
| 39 | + <button type="submit" class="button primary">@T["Create repository"]</button> | |
| 40 | + </form> | |
| 41 | +</section> | |
| 42 | + | |
| 43 | +@code { | |
| 44 | + [SupplyParameterFromForm] | |
| 45 | + private string? Name { get; set; } | |
| 46 | + | |
| 47 | + [SupplyParameterFromForm] | |
| 48 | + private string? Description { get; set; } | |
| 49 | + | |
| 50 | + [SupplyParameterFromForm] | |
| 51 | + private string? Visibility { get; set; } | |
| 52 | + | |
| 53 | + private string? _error; | |
| 54 | + | |
| 55 | + private async Task CreateAsync() | |
| 56 | + { | |
| 57 | + var description = Description?.Trim() ?? ""; | |
| 58 | + if (description.Length > 300) | |
| 59 | + { | |
| 60 | + _error = T["The description can be at most 300 characters."]; | |
| 61 | + return; | |
| 62 | + } | |
| 63 | + | |
| 64 | + var (repo, error) = await Repos.CreateAsync( | |
| 65 | + Me.UserId!.Value, | |
| 66 | + Name?.Trim(), | |
| 67 | + description, | |
| 68 | + Visibility == "public" ? Data.Visibility.Public : Data.Visibility.Private); | |
| 69 | + if (repo is null) | |
| 70 | + { | |
| 71 | + // The service answers with an English message; show it in the visitor's language. | |
| 72 | + _error = error is null ? null : T[error]; | |
| 73 | + return; | |
| 74 | + } | |
| 75 | + | |
| 76 | + Nav.NavigateTo(Urls.Repo(repo)); | |
| 77 | + } | |
| 78 | +} |
added forge/Features/Repos/RepoService.cs +158 −0View file
| @@ -0,0 +1,158 @@ | ||
| 1 | +using System.Text.RegularExpressions; | |
| 2 | +using Forge.Data; | |
| 3 | +using Forge.Git; | |
| 4 | +using Forge.Localization; | |
| 5 | +using Microsoft.EntityFrameworkCore; | |
| 6 | + | |
| 7 | +namespace Forge.Features.Repos; | |
| 8 | + | |
| 9 | +public sealed partial class RepoService(ForgeDb db, GitRepo git, RepoPaths paths, ILogger<RepoService> log) | |
| 10 | +{ | |
| 11 | + /// <summary>Returns an English message (a translation key) for the user, or null when the name is acceptable.</summary> | |
| 12 | + public static string? ValidateName(string? name) | |
| 13 | + { | |
| 14 | + if (string.IsNullOrEmpty(name) || !NamePattern().IsMatch(name)) | |
| 15 | + { | |
| 16 | + return Localizer.Key("A name may contain letters, digits, dots, hyphens and underscores (1 to 100 characters)."); | |
| 17 | + } | |
| 18 | + | |
| 19 | + if (name.Contains("..", StringComparison.Ordinal) || name is ".") | |
| 20 | + { | |
| 21 | + return Localizer.Key("A name must not contain '..'."); | |
| 22 | + } | |
| 23 | + | |
| 24 | + if (name.EndsWith(".git", StringComparison.OrdinalIgnoreCase)) | |
| 25 | + { | |
| 26 | + return Localizer.Key("A name must not end with '.git'."); | |
| 27 | + } | |
| 28 | + | |
| 29 | + return null; | |
| 30 | + } | |
| 31 | + | |
| 32 | + public Task<Repository?> FindAsync(string owner, string name, CancellationToken ct = default) | |
| 33 | + { | |
| 34 | + // Clone URLs end in .git; browsing one should still find the repository. | |
| 35 | + var bare = name.EndsWith(".git", StringComparison.OrdinalIgnoreCase) ? name[..^4] : name; | |
| 36 | + return db.Repositories | |
| 37 | + .Include(r => r.Owner) | |
| 38 | + .FirstOrDefaultAsync(r => r.Owner.Username == owner && r.Name == bare, ct); | |
| 39 | + } | |
| 40 | + | |
| 41 | + public async Task<(Repository? Repo, string? Error)> CreateAsync( | |
| 42 | + long ownerId, | |
| 43 | + string? name, | |
| 44 | + string? description, | |
| 45 | + Visibility visibility, | |
| 46 | + CancellationToken ct = default) | |
| 47 | + { | |
| 48 | + if (ValidateName(name) is { } invalid) | |
| 49 | + { | |
| 50 | + return (null, invalid); | |
| 51 | + } | |
| 52 | + | |
| 53 | + if (await db.Repositories.AnyAsync(r => r.OwnerId == ownerId && r.Name == name, ct)) | |
| 54 | + { | |
| 55 | + return (null, Localizer.Key("A repository with this name already exists.")); | |
| 56 | + } | |
| 57 | + | |
| 58 | + var repo = new Repository | |
| 59 | + { | |
| 60 | + OwnerId = ownerId, | |
| 61 | + Name = name!, | |
| 62 | + Description = (description ?? "").Trim(), | |
| 63 | + Visibility = visibility, | |
| 64 | + DefaultBranch = "main", | |
| 65 | + CreatedAt = DateTime.UtcNow, | |
| 66 | + }; | |
| 67 | + db.Repositories.Add(repo); | |
| 68 | + try | |
| 69 | + { | |
| 70 | + await db.SaveChangesAsync(ct); | |
| 71 | + } | |
| 72 | + catch (DbUpdateException) | |
| 73 | + { | |
| 74 | + db.Entry(repo).State = EntityState.Detached; | |
| 75 | + return (null, Localizer.Key("A repository with this name already exists.")); | |
| 76 | + } | |
| 77 | + | |
| 78 | + var path = paths.For(repo.Id); | |
| 79 | + try | |
| 80 | + { | |
| 81 | + await git.InitBareAsync(path, ct); | |
| 82 | + } | |
| 83 | + catch (Exception ex) | |
| 84 | + { | |
| 85 | + // No row without a repository on disk: undo both halves. | |
| 86 | + log.LogError(ex, "git init failed for repository {RepoId}; removing the row", repo.Id); | |
| 87 | + db.Repositories.Remove(repo); | |
| 88 | + await db.SaveChangesAsync(CancellationToken.None); | |
| 89 | + TryDeleteDirectory(path); | |
| 90 | + return (null, Localizer.Key("The repository could not be created on disk. See the server log for details.")); | |
| 91 | + } | |
| 92 | + | |
| 93 | + await db.Entry(repo).Reference(r => r.Owner).LoadAsync(ct); | |
| 94 | + return (repo, null); | |
| 95 | + } | |
| 96 | + | |
| 97 | + /// <summary>Persists edits made to a repository returned by <see cref="FindAsync"/>.</summary> | |
| 98 | + public Task SaveAsync(CancellationToken ct = default) => db.SaveChangesAsync(ct); | |
| 99 | + | |
| 100 | + /// <summary>Renames in the database only. The directory is named after the ID and does not move.</summary> | |
| 101 | + public async Task<string?> RenameAsync(Repository repo, string? newName, CancellationToken ct = default) | |
| 102 | + { | |
| 103 | + if (ValidateName(newName) is { } invalid) | |
| 104 | + { | |
| 105 | + return invalid; | |
| 106 | + } | |
| 107 | + | |
| 108 | + if (await db.Repositories.AnyAsync(r => r.OwnerId == repo.OwnerId && r.Name == newName && r.Id != repo.Id, ct)) | |
| 109 | + { | |
| 110 | + return Localizer.Key("A repository with this name already exists."); | |
| 111 | + } | |
| 112 | + | |
| 113 | + repo.Name = newName!; | |
| 114 | + await db.SaveChangesAsync(ct); | |
| 115 | + return null; | |
| 116 | + } | |
| 117 | + | |
| 118 | + public async Task<string?> SetDefaultBranchAsync(Repository repo, string? branch, CancellationToken ct = default) | |
| 119 | + { | |
| 120 | + var path = paths.For(repo.Id); | |
| 121 | + var refs = await git.ListRefsAsync(path, ct); | |
| 122 | + // Only a name that exists in the repository is ever handed to git. | |
| 123 | + var match = refs.FirstOrDefault(r => r.Kind == RefKind.Branch && r.Name == branch); | |
| 124 | + if (match is null) | |
| 125 | + { | |
| 126 | + return Localizer.Key("There is no such branch in the repository."); | |
| 127 | + } | |
| 128 | + | |
| 129 | + await git.SetHeadBranchAsync(path, match.Name, ct); | |
| 130 | + repo.DefaultBranch = match.Name; | |
| 131 | + await db.SaveChangesAsync(ct); | |
| 132 | + return null; | |
| 133 | + } | |
| 134 | + | |
| 135 | + public async Task DeleteAsync(Repository repo, CancellationToken ct = default) | |
| 136 | + { | |
| 137 | + var path = paths.For(repo.Id); | |
| 138 | + db.Repositories.Remove(repo); | |
| 139 | + await db.SaveChangesAsync(ct); | |
| 140 | + TryDeleteDirectory(path); | |
| 141 | + } | |
| 142 | + | |
| 143 | + private void TryDeleteDirectory(string path) | |
| 144 | + { | |
| 145 | + try | |
| 146 | + { | |
| 147 | + RepoPaths.DeleteDirectory(path); | |
| 148 | + } | |
| 149 | + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) | |
| 150 | + { | |
| 151 | + log.LogWarning(ex, "Could not delete repository directory {Path}", path); | |
| 152 | + } | |
| 153 | + } | |
| 154 | + | |
| 155 | + // \z rather than $: $ would also accept a trailing newline. | |
| 156 | + [GeneratedRegex(@"^[A-Za-z0-9._-]{1,100}\z")] | |
| 157 | + private static partial Regex NamePattern(); | |
| 158 | +} |
added forge/Features/Repos/RepoSettings.razor +196 −0View file
| @@ -0,0 +1,196 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/settings" | |
| 2 | +@inherits RepoPageBase | |
| 3 | + | |
| 4 | +@if (Repository is not null) | |
| 5 | +{ | |
| 6 | + <PageTitle>@T["Settings"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 7 | + | |
| 8 | + <RepoHeader Repository="Repository" Active="settings" IsOwner="IsOwner"/> | |
| 9 | + | |
| 10 | + <nav class="subtabs"> | |
| 11 | + <a class="active" href="@Urls.Settings(Repository)">@T["General"]</a> | |
| 12 | + <a href="@Urls.Webhooks(Repository)">@T["Webhooks"]</a> | |
| 13 | + <a href="@Urls.Protection(Repository)">@T["Protected branches"]</a> | |
| 14 | + </nav> | |
| 15 | + | |
| 16 | + @if (_message is not null) | |
| 17 | + { | |
| 18 | + <p class="alert success">@_message</p> | |
| 19 | + } | |
| 20 | + @if (_error is not null) | |
| 21 | + { | |
| 22 | + <p class="alert error">@_error</p> | |
| 23 | + } | |
| 24 | + | |
| 25 | + <section class="card"> | |
| 26 | + <h2>@T["Description and visibility"]</h2> | |
| 27 | + <form method="post" @formname="general" @onsubmit="SaveGeneralAsync" class="form"> | |
| 28 | + <AntiforgeryToken/> | |
| 29 | + <label> | |
| 30 | + @T["Description"] | |
| 31 | + <input name="Description" value="@Repository.Description" maxlength="300"/> | |
| 32 | + </label> | |
| 33 | + <fieldset> | |
| 34 | + <legend>@T["Visibility"]</legend> | |
| 35 | + <label class="choice"> | |
| 36 | + <input type="radio" name="Visibility" value="private" checked="@(Repository.Visibility == Data.Visibility.Private)"/> | |
| 37 | + @T["Private"] | |
| 38 | + </label> | |
| 39 | + <label class="choice"> | |
| 40 | + <input type="radio" name="Visibility" value="public" checked="@(Repository.Visibility == Data.Visibility.Public)"/> | |
| 41 | + @T["Public"] | |
| 42 | + </label> | |
| 43 | + </fieldset> | |
| 44 | + <button type="submit" class="button primary">@T["Save"]</button> | |
| 45 | + </form> | |
| 46 | + </section> | |
| 47 | + | |
| 48 | + <section class="card"> | |
| 49 | + <h2>@T["Default branch"]</h2> | |
| 50 | + @if (_branches.Count == 0) | |
| 51 | + { | |
| 52 | + <p class="muted">@T["This repository has no branches yet."]</p> | |
| 53 | + } | |
| 54 | + else | |
| 55 | + { | |
| 56 | + <form method="post" @formname="default-branch" @onsubmit="SaveDefaultBranchAsync" class="form"> | |
| 57 | + <AntiforgeryToken/> | |
| 58 | + <label> | |
| 59 | + @T.Html("The branch that is shown first and that <code>git clone</code> checks out") | |
| 60 | + <select name="Branch"> | |
| 61 | + @foreach (var branch in _branches) | |
| 62 | + { | |
| 63 | + <option value="@branch" selected="@(branch == Repository.DefaultBranch)">@branch</option> | |
| 64 | + } | |
| 65 | + </select> | |
| 66 | + </label> | |
| 67 | + <button type="submit" class="button">@T["Set"]</button> | |
| 68 | + </form> | |
| 69 | + } | |
| 70 | + </section> | |
| 71 | + | |
| 72 | + <section class="card"> | |
| 73 | + <h2>@T["Rename repository"]</h2> | |
| 74 | + <p class="muted">@T["The repository address changes. Old clone URLs stop working."]</p> | |
| 75 | + <form method="post" @formname="rename" @onsubmit="RenameAsync" class="form"> | |
| 76 | + <AntiforgeryToken/> | |
| 77 | + <label> | |
| 78 | + @T["New name"] | |
| 79 | + <input name="NewName" value="@(NewName ?? Repository.Name)" required maxlength="100"/> | |
| 80 | + </label> | |
| 81 | + <button type="submit" class="button">@T["Rename"]</button> | |
| 82 | + </form> | |
| 83 | + </section> | |
| 84 | + | |
| 85 | + <section class="card danger-zone"> | |
| 86 | + <h2>@T["Delete this repository"]</h2> | |
| 87 | + <p>@T["This deletes the code, the history and the webhooks. It cannot be undone."]</p> | |
| 88 | + <form method="post" @formname="delete" @onsubmit="DeleteAsync" class="form"> | |
| 89 | + <AntiforgeryToken/> | |
| 90 | + <label> | |
| 91 | + @T["To confirm, type the repository name:"] <strong>@Repository.Name</strong> | |
| 92 | + <input name="ConfirmName" required autocomplete="off"/> | |
| 93 | + </label> | |
| 94 | + <button type="submit" class="button danger">@T["Delete repository"]</button> | |
| 95 | + </form> | |
| 96 | + </section> | |
| 97 | +} | |
| 98 | + | |
| 99 | +@code { | |
| 100 | + [SupplyParameterFromForm(FormName = "general")] | |
| 101 | + private string? Description { get; set; } | |
| 102 | + | |
| 103 | + [SupplyParameterFromForm(FormName = "general")] | |
| 104 | + private string? Visibility { get; set; } | |
| 105 | + | |
| 106 | + [SupplyParameterFromForm(FormName = "default-branch")] | |
| 107 | + private string? Branch { get; set; } | |
| 108 | + | |
| 109 | + [SupplyParameterFromForm(FormName = "rename")] | |
| 110 | + private string? NewName { get; set; } | |
| 111 | + | |
| 112 | + [SupplyParameterFromForm(FormName = "delete")] | |
| 113 | + private string? ConfirmName { get; set; } | |
| 114 | + | |
| 115 | + private List<string> _branches = []; | |
| 116 | + private string? _message; | |
| 117 | + private string? _error; | |
| 118 | + | |
| 119 | + /// <summary>The service answers with an English message, or null for success; show it in the visitor's language.</summary> | |
| 120 | + private string? Translate(string? error) => error is null ? null : T[error]; | |
| 121 | + | |
| 122 | + protected override async Task OnInitializedAsync() | |
| 123 | + { | |
| 124 | + if (!await LoadRepoAsync(requireAdmin: true)) | |
| 125 | + { | |
| 126 | + return; | |
| 127 | + } | |
| 128 | + | |
| 129 | + _branches = (await Git.ListRefsAsync(RepoPath)) | |
| 130 | + .Where(r => r.Kind == RefKind.Branch) | |
| 131 | + .Select(r => r.Name) | |
| 132 | + .ToList(); | |
| 133 | + } | |
| 134 | + | |
| 135 | + private async Task SaveGeneralAsync() | |
| 136 | + { | |
| 137 | + if (Repository is null) | |
| 138 | + { | |
| 139 | + return; | |
| 140 | + } | |
| 141 | + | |
| 142 | + var description = Description?.Trim() ?? ""; | |
| 143 | + if (description.Length > 300) | |
| 144 | + { | |
| 145 | + _error = T["The description can be at most 300 characters."]; | |
| 146 | + return; | |
| 147 | + } | |
| 148 | + | |
| 149 | + Repository.Description = description; | |
| 150 | + Repository.Visibility = Visibility == "public" ? Data.Visibility.Public : Data.Visibility.Private; | |
| 151 | + await Repos.SaveAsync(); | |
| 152 | + _message = T["Saved."]; | |
| 153 | + } | |
| 154 | + | |
| 155 | + private async Task SaveDefaultBranchAsync() | |
| 156 | + { | |
| 157 | + if (Repository is null) | |
| 158 | + { | |
| 159 | + return; | |
| 160 | + } | |
| 161 | + | |
| 162 | + _error = Translate(await Repos.SetDefaultBranchAsync(Repository, Branch)); | |
| 163 | + _message = _error is null ? T["The default branch is set."] : null; | |
| 164 | + } | |
| 165 | + | |
| 166 | + private async Task RenameAsync() | |
| 167 | + { | |
| 168 | + if (Repository is null) | |
| 169 | + { | |
| 170 | + return; | |
| 171 | + } | |
| 172 | + | |
| 173 | + _error = Translate(await Repos.RenameAsync(Repository, NewName?.Trim())); | |
| 174 | + if (_error is null) | |
| 175 | + { | |
| 176 | + Redirect(Urls.Settings(Repository)); | |
| 177 | + } | |
| 178 | + } | |
| 179 | + | |
| 180 | + private async Task DeleteAsync() | |
| 181 | + { | |
| 182 | + if (Repository is null) | |
| 183 | + { | |
| 184 | + return; | |
| 185 | + } | |
| 186 | + | |
| 187 | + if (!string.Equals(ConfirmName?.Trim(), Repository.Name, StringComparison.Ordinal)) | |
| 188 | + { | |
| 189 | + _error = T["The name does not match. The repository was not deleted."]; | |
| 190 | + return; | |
| 191 | + } | |
| 192 | + | |
| 193 | + await Repos.DeleteAsync(Repository); | |
| 194 | + Redirect("/"); | |
| 195 | + } | |
| 196 | +} |
added forge/Features/SmartHttp/PushGuard.cs +164 −0View file
| @@ -0,0 +1,164 @@ | ||
| 1 | +using System.Globalization; | |
| 2 | +using System.Text; | |
| 3 | +using Forge.Data; | |
| 4 | +using Forge.Features.History; | |
| 5 | +using Forge.Git; | |
| 6 | + | |
| 7 | +namespace Forge.Features.SmartHttp; | |
| 8 | + | |
| 9 | +/// <summary> | |
| 10 | +/// Enforces branch protection on pushes without git hooks. A push request starts with the list of | |
| 11 | +/// refs it wants to change; that list is read first, and when it touches a protected branch | |
| 12 | +/// receive-pack is started with settings that make git itself refuse the dangerous updates. | |
| 13 | +/// Git then reports the refusal to the client in the normal way ("remote rejected"). | |
| 14 | +/// </summary> | |
| 15 | +public static class PushGuard | |
| 16 | +{ | |
| 17 | + private const int MaxCommandBytes = 4 * 1024 * 1024; | |
| 18 | + | |
| 19 | + /// <summary> | |
| 20 | + /// Returns the `-c` options for receive-pack and a stream that replays what was read. | |
| 21 | + /// </summary> | |
| 22 | + public static async Task<(Stream Input, List<string> GitOptions)> InspectAsync( | |
| 23 | + Stream input, | |
| 24 | + IReadOnlyList<BranchProtection> rules, | |
| 25 | + CancellationToken ct) | |
| 26 | + { | |
| 27 | + var options = new List<string>(); | |
| 28 | + | |
| 29 | + // Branches closed to pushes are hidden from receive-pack; git rejects any update of a hidden ref. | |
| 30 | + foreach (var rule in rules.Where(r => r.BlockPush)) | |
| 31 | + { | |
| 32 | + options.Add("-c"); | |
| 33 | + options.Add("receive.hideRefs=" + BranchRules.RefPrefix(rule.Pattern)); | |
| 34 | + } | |
| 35 | + | |
| 36 | + var (refs, consumed, understood) = await ReadCommandsAsync(input, ct); | |
| 37 | + | |
| 38 | + // Force-pushes and deletions can only be switched off for a whole push. If the command list | |
| 39 | + // could not be read, assume the worst rather than let a protected branch through. | |
| 40 | + var touchesProtected = !understood || refs.Any(r => | |
| 41 | + r.StartsWith("refs/heads/", StringComparison.Ordinal) | |
| 42 | + && BranchRules.Find(rules, r["refs/heads/".Length..]) is not null); | |
| 43 | + if (touchesProtected) | |
| 44 | + { | |
| 45 | + options.AddRange(["-c", "receive.denyNonFastForwards=true", "-c", "receive.denyDeletes=true"]); | |
| 46 | + } | |
| 47 | + | |
| 48 | + return (new ReplayStream(consumed, input), options); | |
| 49 | + } | |
| 50 | + | |
| 51 | + /// <summary> | |
| 52 | + /// Reads the pkt-lines up to the first flush packet: "old SP new SP ref [NUL capabilities] LF" each. | |
| 53 | + /// Returns the ref names, every byte consumed, and whether the section was well-formed. | |
| 54 | + /// </summary> | |
| 55 | + public static async Task<(List<string> Refs, byte[] Consumed, bool Understood)> ReadCommandsAsync(Stream input, CancellationToken ct) | |
| 56 | + { | |
| 57 | + var refs = new List<string>(); | |
| 58 | + using var consumed = new MemoryStream(); | |
| 59 | + var header = new byte[4]; | |
| 60 | + | |
| 61 | + while (true) | |
| 62 | + { | |
| 63 | + var read = await ReadFullyAsync(input, header, ct); | |
| 64 | + consumed.Write(header, 0, read); | |
| 65 | + if (read == 0 && consumed.Length == 0) | |
| 66 | + { | |
| 67 | + return (refs, [], true); // An empty body: nothing is being pushed. | |
| 68 | + } | |
| 69 | + | |
| 70 | + if (read < 4 | |
| 71 | + || !int.TryParse(Encoding.ASCII.GetString(header), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out var length)) | |
| 72 | + { | |
| 73 | + return (refs, consumed.ToArray(), false); | |
| 74 | + } | |
| 75 | + | |
| 76 | + if (length == 0) | |
| 77 | + { | |
| 78 | + return (refs, consumed.ToArray(), true); // Flush packet: end of the command list. | |
| 79 | + } | |
| 80 | + | |
| 81 | + if (length < 4 || length > 65520 || consumed.Length + length > MaxCommandBytes) | |
| 82 | + { | |
| 83 | + return (refs, consumed.ToArray(), false); | |
| 84 | + } | |
| 85 | + | |
| 86 | + var payload = new byte[length - 4]; | |
| 87 | + read = await ReadFullyAsync(input, payload, ct); | |
| 88 | + consumed.Write(payload, 0, read); | |
| 89 | + if (read < payload.Length) | |
| 90 | + { | |
| 91 | + return (refs, consumed.ToArray(), false); | |
| 92 | + } | |
| 93 | + | |
| 94 | + var line = Encoding.UTF8.GetString(payload); | |
| 95 | + var nul = line.IndexOf('\0'); | |
| 96 | + var parts = (nul >= 0 ? line[..nul] : line).TrimEnd('\n').Split(' '); | |
| 97 | + if (parts.Length == 3 && GitParsers.IsHex(parts[0]) && GitParsers.IsHex(parts[1])) | |
| 98 | + { | |
| 99 | + refs.Add(parts[2]); | |
| 100 | + } | |
| 101 | + } | |
| 102 | + } | |
| 103 | + | |
| 104 | + private static async Task<int> ReadFullyAsync(Stream stream, byte[] buffer, CancellationToken ct) | |
| 105 | + { | |
| 106 | + var total = 0; | |
| 107 | + while (total < buffer.Length) | |
| 108 | + { | |
| 109 | + var n = await stream.ReadAsync(buffer.AsMemory(total), ct); | |
| 110 | + if (n == 0) | |
| 111 | + { | |
| 112 | + break; | |
| 113 | + } | |
| 114 | + | |
| 115 | + total += n; | |
| 116 | + } | |
| 117 | + | |
| 118 | + return total; | |
| 119 | + } | |
| 120 | + | |
| 121 | + /// <summary>Serves bytes that were already read, then continues with the rest of the stream.</summary> | |
| 122 | + private sealed class ReplayStream(byte[] prefix, Stream rest) : Stream | |
| 123 | + { | |
| 124 | + private int _position; | |
| 125 | + | |
| 126 | + public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) | |
| 127 | + { | |
| 128 | + if (_position < prefix.Length) | |
| 129 | + { | |
| 130 | + var n = Math.Min(buffer.Length, prefix.Length - _position); | |
| 131 | + prefix.AsMemory(_position, n).CopyTo(buffer); | |
| 132 | + _position += n; | |
| 133 | + return n; | |
| 134 | + } | |
| 135 | + | |
| 136 | + return await rest.ReadAsync(buffer, cancellationToken); | |
| 137 | + } | |
| 138 | + | |
| 139 | + public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => | |
| 140 | + ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); | |
| 141 | + | |
| 142 | + public override int Read(byte[] buffer, int offset, int count) => | |
| 143 | + throw new NotSupportedException("Use ReadAsync."); | |
| 144 | + | |
| 145 | + public override bool CanRead => true; | |
| 146 | + public override bool CanSeek => false; | |
| 147 | + public override bool CanWrite => false; | |
| 148 | + public override long Length => throw new NotSupportedException(); | |
| 149 | + | |
| 150 | + public override long Position | |
| 151 | + { | |
| 152 | + get => throw new NotSupportedException(); | |
| 153 | + set => throw new NotSupportedException(); | |
| 154 | + } | |
| 155 | + | |
| 156 | + public override void Flush() | |
| 157 | + { | |
| 158 | + } | |
| 159 | + | |
| 160 | + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); | |
| 161 | + public override void SetLength(long value) => throw new NotSupportedException(); | |
| 162 | + public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException(); | |
| 163 | + } | |
| 164 | +} |
added forge/Features/SmartHttp/PushRecorder.cs +163 −0View file
| @@ -0,0 +1,163 @@ | ||
| 1 | +using System.Collections.Concurrent; | |
| 2 | +using Forge.Data; | |
| 3 | +using Forge.Features.Webhooks; | |
| 4 | +using Forge.Git; | |
| 5 | +using Microsoft.EntityFrameworkCore; | |
| 6 | + | |
| 7 | +namespace Forge.Features.SmartHttp; | |
| 8 | + | |
| 9 | +/// <summary>One lock per repository, so two pushes never interleave their before/after snapshots.</summary> | |
| 10 | +public sealed class PushLocks | |
| 11 | +{ | |
| 12 | + private readonly ConcurrentDictionary<long, SemaphoreSlim> _locks = new(); | |
| 13 | + | |
| 14 | + public async Task<IDisposable> AcquireAsync(long repoId, CancellationToken ct) | |
| 15 | + { | |
| 16 | + var semaphore = _locks.GetOrAdd(repoId, _ => new SemaphoreSlim(1, 1)); | |
| 17 | + await semaphore.WaitAsync(ct); | |
| 18 | + return new Releaser(semaphore); | |
| 19 | + } | |
| 20 | + | |
| 21 | + private sealed class Releaser(SemaphoreSlim semaphore) : IDisposable | |
| 22 | + { | |
| 23 | + private int _released; | |
| 24 | + | |
| 25 | + public void Dispose() | |
| 26 | + { | |
| 27 | + if (Interlocked.Exchange(ref _released, 1) == 0) | |
| 28 | + { | |
| 29 | + semaphore.Release(); | |
| 30 | + } | |
| 31 | + } | |
| 32 | + } | |
| 33 | +} | |
| 34 | + | |
| 35 | +public sealed record RefChange(string RefName, string OldSha, string NewSha); | |
| 36 | + | |
| 37 | +/// <summary> | |
| 38 | +/// Turns the difference between two ref snapshots into push events. There are no git hooks: | |
| 39 | +/// the server runs receive-pack itself, so it can simply look before and after. | |
| 40 | +/// </summary> | |
| 41 | +public sealed class PushRecorder( | |
| 42 | + ForgeDb db, | |
| 43 | + GitRepo git, | |
| 44 | + RepoPaths paths, | |
| 45 | + WebhookQueue queue, | |
| 46 | + ILogger<PushRecorder> log) | |
| 47 | +{ | |
| 48 | + public static List<RefChange> Diff( | |
| 49 | + IReadOnlyDictionary<string, string> before, | |
| 50 | + IReadOnlyDictionary<string, string> after) | |
| 51 | + { | |
| 52 | + var changes = new List<RefChange>(); | |
| 53 | + foreach (var (name, newSha) in after) | |
| 54 | + { | |
| 55 | + if (!before.TryGetValue(name, out var oldSha)) | |
| 56 | + { | |
| 57 | + changes.Add(new RefChange(name, GitParsers.ZeroSha, newSha)); | |
| 58 | + } | |
| 59 | + else if (oldSha != newSha) | |
| 60 | + { | |
| 61 | + changes.Add(new RefChange(name, oldSha, newSha)); | |
| 62 | + } | |
| 63 | + } | |
| 64 | + | |
| 65 | + foreach (var (name, oldSha) in before) | |
| 66 | + { | |
| 67 | + if (!after.ContainsKey(name)) | |
| 68 | + { | |
| 69 | + changes.Add(new RefChange(name, oldSha, GitParsers.ZeroSha)); | |
| 70 | + } | |
| 71 | + } | |
| 72 | + | |
| 73 | + changes.Sort((a, b) => string.CompareOrdinal(a.RefName, b.RefName)); | |
| 74 | + return changes; | |
| 75 | + } | |
| 76 | + | |
| 77 | + public async Task RecordAsync( | |
| 78 | + long repoId, | |
| 79 | + IReadOnlyDictionary<string, string> before, | |
| 80 | + IReadOnlyDictionary<string, string> after, | |
| 81 | + CancellationToken ct = default) | |
| 82 | + { | |
| 83 | + var changes = Diff(before, after); | |
| 84 | + if (changes.Count == 0) | |
| 85 | + { | |
| 86 | + return; | |
| 87 | + } | |
| 88 | + | |
| 89 | + var repo = await db.Repositories.FirstOrDefaultAsync(r => r.Id == repoId, ct); | |
| 90 | + if (repo is null) | |
| 91 | + { | |
| 92 | + return; | |
| 93 | + } | |
| 94 | + | |
| 95 | + var now = DateTime.UtcNow; | |
| 96 | + var events = changes | |
| 97 | + .Select(c => new PushEvent | |
| 98 | + { | |
| 99 | + RepoId = repoId, | |
| 100 | + RefName = c.RefName, | |
| 101 | + OldSha = c.OldSha, | |
| 102 | + NewSha = c.NewSha, | |
| 103 | + PushedAt = now, | |
| 104 | + }) | |
| 105 | + .ToList(); | |
| 106 | + db.PushEvents.AddRange(events); | |
| 107 | + repo.PushedAt = now; | |
| 108 | + | |
| 109 | + await FixDefaultBranchAsync(repo, before, after, ct); | |
| 110 | + await db.SaveChangesAsync(ct); | |
| 111 | + | |
| 112 | + foreach (var e in events) | |
| 113 | + { | |
| 114 | + queue.Enqueue(e.Id); | |
| 115 | + } | |
| 116 | + } | |
| 117 | + | |
| 118 | + /// <summary> | |
| 119 | + /// After the first push into an empty repository HEAD may still name a branch nobody pushed | |
| 120 | + /// (HEAD says main, the push brought master). Point HEAD and the row at a branch that exists. | |
| 121 | + /// </summary> | |
| 122 | + private async Task FixDefaultBranchAsync( | |
| 123 | + Repository repo, | |
| 124 | + IReadOnlyDictionary<string, string> before, | |
| 125 | + IReadOnlyDictionary<string, string> after, | |
| 126 | + CancellationToken ct) | |
| 127 | + { | |
| 128 | + const string heads = "refs/heads/"; | |
| 129 | + if (before.Keys.Any(k => k.StartsWith(heads, StringComparison.Ordinal))) | |
| 130 | + { | |
| 131 | + return; | |
| 132 | + } | |
| 133 | + | |
| 134 | + var pushed = after.Keys | |
| 135 | + .Where(k => k.StartsWith(heads, StringComparison.Ordinal)) | |
| 136 | + .Select(k => k[heads.Length..]) | |
| 137 | + .Order(StringComparer.Ordinal) | |
| 138 | + .ToList(); | |
| 139 | + if (pushed.Count == 0) | |
| 140 | + { | |
| 141 | + return; | |
| 142 | + } | |
| 143 | + | |
| 144 | + var path = paths.For(repo.Id); | |
| 145 | + try | |
| 146 | + { | |
| 147 | + var head = await git.GetHeadBranchAsync(path, ct); | |
| 148 | + if (head is not null && pushed.Contains(head)) | |
| 149 | + { | |
| 150 | + repo.DefaultBranch = head; | |
| 151 | + return; | |
| 152 | + } | |
| 153 | + | |
| 154 | + var chosen = pushed.FirstOrDefault(b => b is "main" or "master") ?? pushed[0]; | |
| 155 | + await git.SetHeadBranchAsync(path, chosen, ct); | |
| 156 | + repo.DefaultBranch = chosen; | |
| 157 | + } | |
| 158 | + catch (GitException ex) | |
| 159 | + { | |
| 160 | + log.LogWarning(ex, "Could not set the default branch of repository {RepoId}", repo.Id); | |
| 161 | + } | |
| 162 | + } | |
| 163 | +} |
added forge/Features/SmartHttp/SmartHttpEndpoints.cs +428 −0View file
| @@ -0,0 +1,428 @@ | ||
| 1 | +using System.IO.Compression; | |
| 2 | +using System.Text; | |
| 3 | +using System.Text.RegularExpressions; | |
| 4 | +using CliWrap; | |
| 5 | +using Forge.Data; | |
| 6 | +using Forge.Features.Auth; | |
| 7 | +using Forge.Features.Repos; | |
| 8 | +using Forge.Git; | |
| 9 | +using Microsoft.AspNetCore.Diagnostics; | |
| 10 | +using Microsoft.AspNetCore.Http.Features; | |
| 11 | +using Microsoft.EntityFrameworkCore; | |
| 12 | +using Microsoft.Extensions.Options; | |
| 13 | + | |
| 14 | +namespace Forge.Features.SmartHttp; | |
| 15 | + | |
| 16 | +/// <summary> | |
| 17 | +/// Git smart HTTP. The app does not implement the protocol: it authenticates the request, | |
| 18 | +/// starts `git upload-pack` or `git receive-pack`, and streams bytes in both directions. | |
| 19 | +/// </summary> | |
| 20 | +public static partial class SmartHttpEndpoints | |
| 21 | +{ | |
| 22 | + private const string UploadPack = "git-upload-pack"; | |
| 23 | + private const string ReceivePack = "git-receive-pack"; | |
| 24 | + | |
| 25 | + public static void MapSmartHttp(this IEndpointRouteBuilder app) | |
| 26 | + { | |
| 27 | + // {repo} is "name.git" in clone URLs; the suffix is stripped when the repository is looked up. | |
| 28 | + app.MapGet("/{owner}/{repo}/info/refs", InfoRefsAsync); | |
| 29 | + app.MapPost("/{owner}/{repo}/" + UploadPack, | |
| 30 | + (HttpContext context, string owner, string repo, SmartHttpHandler handler) => | |
| 31 | + handler.RpcAsync(context, owner, repo, UploadPack)); | |
| 32 | + app.MapPost("/{owner}/{repo}/" + ReceivePack, | |
| 33 | + (HttpContext context, string owner, string repo, SmartHttpHandler handler) => | |
| 34 | + handler.RpcAsync(context, owner, repo, ReceivePack)); | |
| 35 | + } | |
| 36 | + | |
| 37 | + private static Task InfoRefsAsync(HttpContext context, string owner, string repo, SmartHttpHandler handler) => | |
| 38 | + handler.InfoRefsAsync(context, owner, repo); | |
| 39 | + | |
| 40 | + /// <summary>Formats one pkt-line: four hex digits of total length, then the payload.</summary> | |
| 41 | + public static byte[] PktLine(string payload) | |
| 42 | + { | |
| 43 | + var body = Encoding.UTF8.GetBytes(payload); | |
| 44 | + var line = new byte[body.Length + 4]; | |
| 45 | + Encoding.ASCII.GetBytes((body.Length + 4).ToString("x4"), line); | |
| 46 | + body.CopyTo(line, 4); | |
| 47 | + return line; | |
| 48 | + } | |
| 49 | + | |
| 50 | + public static readonly byte[] FlushPkt = "0000"u8.ToArray(); | |
| 51 | + | |
| 52 | + /// <summary>The Git-Protocol header becomes GIT_PROTOCOL, but only if it looks like "version=2".</summary> | |
| 53 | + public static string? ValidateProtocolHeader(string? value) => | |
| 54 | + value is { Length: > 0 and <= 128 } && ProtocolPattern().IsMatch(value) ? value : null; | |
| 55 | + | |
| 56 | + public static bool RequestsProtocolV2(string? protocol) => | |
| 57 | + protocol is not null && protocol.Split(':').Contains("version=2"); | |
| 58 | + | |
| 59 | + /// <summary>Extracts the password of a Basic Authorization header. The username is ignored: the token is the credential.</summary> | |
| 60 | + public static string? ParseBasicPassword(string? header) | |
| 61 | + { | |
| 62 | + const string scheme = "Basic "; | |
| 63 | + if (header is null || !header.StartsWith(scheme, StringComparison.OrdinalIgnoreCase)) | |
| 64 | + { | |
| 65 | + return null; | |
| 66 | + } | |
| 67 | + | |
| 68 | + try | |
| 69 | + { | |
| 70 | + var decoded = Encoding.UTF8.GetString(Convert.FromBase64String(header[scheme.Length..].Trim())); | |
| 71 | + var colon = decoded.IndexOf(':'); | |
| 72 | + return colon < 0 ? "" : decoded[(colon + 1)..]; | |
| 73 | + } | |
| 74 | + catch (FormatException) | |
| 75 | + { | |
| 76 | + return ""; | |
| 77 | + } | |
| 78 | + } | |
| 79 | + | |
| 80 | + [GeneratedRegex(@"^[A-Za-z0-9=:._-]+\z")] | |
| 81 | + private static partial Regex ProtocolPattern(); | |
| 82 | +} | |
| 83 | + | |
| 84 | +public sealed class SmartHttpHandler( | |
| 85 | + ForgeDb db, | |
| 86 | + RepoService repos, | |
| 87 | + TokenService tokens, | |
| 88 | + AuthFailureLimiter limiter, | |
| 89 | + GitCli git, | |
| 90 | + GitRepo gitRepo, | |
| 91 | + RepoPaths paths, | |
| 92 | + PushLocks locks, | |
| 93 | + PushRecorder recorder, | |
| 94 | + IOptions<ForgeOptions> options, | |
| 95 | + ILogger<SmartHttpHandler> log) | |
| 96 | +{ | |
| 97 | + private const string UploadPack = "git-upload-pack"; | |
| 98 | + private const string ReceivePack = "git-receive-pack"; | |
| 99 | + | |
| 100 | + public async Task InfoRefsAsync(HttpContext context, string owner, string repoName) | |
| 101 | + { | |
| 102 | + DisableStatusPages(context); | |
| 103 | + | |
| 104 | + // Only these two values ever become part of a command line. | |
| 105 | + var service = context.Request.Query["service"].ToString(); | |
| 106 | + if (service is not (UploadPack or ReceivePack)) | |
| 107 | + { | |
| 108 | + await WriteTextAsync(context, StatusCodes.Status400BadRequest, "Unsupported service."); | |
| 109 | + return; | |
| 110 | + } | |
| 111 | + | |
| 112 | + var repo = await AuthorizeAsync(context, owner, repoName, write: service == ReceivePack); | |
| 113 | + if (repo is null) | |
| 114 | + { | |
| 115 | + return; | |
| 116 | + } | |
| 117 | + | |
| 118 | + var protocol = SmartHttpEndpoints.ValidateProtocolHeader(context.Request.Headers["Git-Protocol"]); | |
| 119 | + context.Response.ContentType = $"application/x-{service}-advertisement"; | |
| 120 | + context.Response.Headers.CacheControl = "no-cache"; | |
| 121 | + | |
| 122 | + var body = context.Response.Body; | |
| 123 | + // Protocol v2 advertisements carry no service announcement (same as git http-backend). | |
| 124 | + if (!(service == UploadPack && SmartHttpEndpoints.RequestsProtocolV2(protocol))) | |
| 125 | + { | |
| 126 | + await body.WriteAsync(SmartHttpEndpoints.PktLine($"# service={service}\n"), context.RequestAborted); | |
| 127 | + await body.WriteAsync(SmartHttpEndpoints.FlushPkt, context.RequestAborted); | |
| 128 | + } | |
| 129 | + | |
| 130 | + try | |
| 131 | + { | |
| 132 | + var (exitCode, stderr) = await git.StreamAsync( | |
| 133 | + null, | |
| 134 | + [service["git-".Length..], "--stateless-rpc", "--advertise-refs", paths.For(repo.Id)], | |
| 135 | + PipeSource.Null, | |
| 136 | + PipeTarget.ToStream(body), | |
| 137 | + ProtocolEnvironment(protocol), | |
| 138 | + TimeSpan.FromMinutes(2), | |
| 139 | + context.RequestAborted); | |
| 140 | + if (exitCode != 0) | |
| 141 | + { | |
| 142 | + log.LogWarning("git {Service} --advertise-refs exited with {ExitCode}: {StdErr}", service, exitCode, stderr.Trim()); | |
| 143 | + } | |
| 144 | + } | |
| 145 | + catch (OperationCanceledException) when (context.RequestAborted.IsCancellationRequested) | |
| 146 | + { | |
| 147 | + // The client went away; the process is already killed. | |
| 148 | + } | |
| 149 | + } | |
| 150 | + | |
| 151 | + public async Task RpcAsync(HttpContext context, string owner, string repoName, string service) | |
| 152 | + { | |
| 153 | + DisableStatusPages(context); | |
| 154 | + var write = service == ReceivePack; | |
| 155 | + | |
| 156 | + var repo = await AuthorizeAsync(context, owner, repoName, write); | |
| 157 | + if (repo is null) | |
| 158 | + { | |
| 159 | + return; | |
| 160 | + } | |
| 161 | + | |
| 162 | + // Pushes are capped; fetch requests are small negotiation messages and stay unlimited. | |
| 163 | + var sizeFeature = context.Features.Get<IHttpMaxRequestBodySizeFeature>(); | |
| 164 | + if (sizeFeature is { IsReadOnly: false }) | |
| 165 | + { | |
| 166 | + sizeFeature.MaxRequestBodySize = write ? options.Value.MaxPushBytes : null; | |
| 167 | + } | |
| 168 | + | |
| 169 | + var input = context.Request.Body; | |
| 170 | + if (string.Equals(context.Request.Headers.ContentEncoding, "gzip", StringComparison.OrdinalIgnoreCase)) | |
| 171 | + { | |
| 172 | + input = new GZipStream(input, CompressionMode.Decompress); | |
| 173 | + if (write) | |
| 174 | + { | |
| 175 | + // The body limit above counts compressed bytes; this one stops a gzip bomb. | |
| 176 | + input = new LimitedReadStream(input, options.Value.MaxPushBytes); | |
| 177 | + } | |
| 178 | + } | |
| 179 | + | |
| 180 | + var protocol = SmartHttpEndpoints.ValidateProtocolHeader(context.Request.Headers["Git-Protocol"]); | |
| 181 | + context.Response.ContentType = $"application/x-{service}-result"; | |
| 182 | + context.Response.Headers.CacheControl = "no-cache"; | |
| 183 | + context.Features.Get<IHttpResponseBodyFeature>()?.DisableBuffering(); | |
| 184 | + | |
| 185 | + var repoPath = paths.For(repo.Id); | |
| 186 | + if (!write) | |
| 187 | + { | |
| 188 | + await RunServiceAsync(context, service, repoPath, input, protocol); | |
| 189 | + return; | |
| 190 | + } | |
| 191 | + | |
| 192 | + IDisposable pushLock; | |
| 193 | + try | |
| 194 | + { | |
| 195 | + pushLock = await locks.AcquireAsync(repo.Id, context.RequestAborted); | |
| 196 | + } | |
| 197 | + catch (OperationCanceledException) | |
| 198 | + { | |
| 199 | + return; | |
| 200 | + } | |
| 201 | + | |
| 202 | + using var releaseLock = pushLock; | |
| 203 | + var rules = await db.BranchProtections.AsNoTracking().Where(r => r.RepoId == repo.Id).ToListAsync(CancellationToken.None); | |
| 204 | + var before = await gitRepo.SnapshotRefsAsync(repoPath, CancellationToken.None); | |
| 205 | + try | |
| 206 | + { | |
| 207 | + await RunServiceAsync(context, service, repoPath, input, protocol, rules); | |
| 208 | + } | |
| 209 | + finally | |
| 210 | + { | |
| 211 | + // Refs may have moved even if the client disconnected halfway, so this must not be cancellable. | |
| 212 | + try | |
| 213 | + { | |
| 214 | + var after = await gitRepo.SnapshotRefsAsync(repoPath, CancellationToken.None); | |
| 215 | + await recorder.RecordAsync(repo.Id, before, after, CancellationToken.None); | |
| 216 | + } | |
| 217 | + catch (Exception ex) | |
| 218 | + { | |
| 219 | + log.LogError(ex, "Could not record push events for repository {RepoId}", repo.Id); | |
| 220 | + } | |
| 221 | + } | |
| 222 | + } | |
| 223 | + | |
| 224 | + private async Task RunServiceAsync( | |
| 225 | + HttpContext context, | |
| 226 | + string service, | |
| 227 | + string repoPath, | |
| 228 | + Stream input, | |
| 229 | + string? protocol, | |
| 230 | + IReadOnlyList<BranchProtection>? rules = null) | |
| 231 | + { | |
| 232 | + try | |
| 233 | + { | |
| 234 | + // With protected branches, git is told what to refuse before it sees the push. | |
| 235 | + List<string> gitOptions = []; | |
| 236 | + if (rules is { Count: > 0 }) | |
| 237 | + { | |
| 238 | + (input, gitOptions) = await PushGuard.InspectAsync(input, rules, context.RequestAborted); | |
| 239 | + } | |
| 240 | + | |
| 241 | + var (exitCode, stderr) = await git.StreamAsync( | |
| 242 | + null, | |
| 243 | + [.. gitOptions, service["git-".Length..], "--stateless-rpc", repoPath], | |
| 244 | + PipeSource.FromStream(input), | |
| 245 | + PipeTarget.ToStream(context.Response.Body), | |
| 246 | + ProtocolEnvironment(protocol), | |
| 247 | + GitCli.TransportTimeout, | |
| 248 | + context.RequestAborted); | |
| 249 | + if (exitCode != 0) | |
| 250 | + { | |
| 251 | + log.LogWarning("git {Service} exited with {ExitCode}: {StdErr}", service, exitCode, stderr.Trim()); | |
| 252 | + } | |
| 253 | + } | |
| 254 | + catch (OperationCanceledException) when (context.RequestAborted.IsCancellationRequested) | |
| 255 | + { | |
| 256 | + // The client went away; the process is already killed. | |
| 257 | + } | |
| 258 | + catch (Exception ex) when (ex is IOException or InvalidDataException) | |
| 259 | + { | |
| 260 | + // Reading the request body failed: too large, cut off, or not valid gzip. | |
| 261 | + var status = ex switch | |
| 262 | + { | |
| 263 | + PushTooLargeException => StatusCodes.Status413PayloadTooLarge, | |
| 264 | + BadHttpRequestException bad => bad.StatusCode, | |
| 265 | + _ => StatusCodes.Status400BadRequest, | |
| 266 | + }; | |
| 267 | + log.LogWarning("git {Service} request failed with {Status}: {Message}", service, status, ex.Message); | |
| 268 | + if (!context.Response.HasStarted) | |
| 269 | + { | |
| 270 | + await WriteTextAsync( | |
| 271 | + context, | |
| 272 | + status, | |
| 273 | + status == StatusCodes.Status413PayloadTooLarge | |
| 274 | + ? "Push is larger than the server allows." | |
| 275 | + : "The request body could not be read."); | |
| 276 | + } | |
| 277 | + else | |
| 278 | + { | |
| 279 | + context.Abort(); | |
| 280 | + } | |
| 281 | + } | |
| 282 | + } | |
| 283 | + | |
| 284 | + /// <summary> | |
| 285 | + /// Returns the repository when the request may proceed; otherwise writes the response and returns null. | |
| 286 | + /// Anonymous requests that cannot proceed always get 401, whether or not the repository exists: | |
| 287 | + /// git only sends credentials after a 401, and the identical answer keeps private repositories hidden. | |
| 288 | + /// A valid token without access gets 404. | |
| 289 | + /// </summary> | |
| 290 | + private async Task<Repository?> AuthorizeAsync(HttpContext context, string owner, string repoName, bool write) | |
| 291 | + { | |
| 292 | + var ct = context.RequestAborted; | |
| 293 | + var client = context.Connection.RemoteIpAddress?.ToString() ?? "unknown"; | |
| 294 | + var actor = Actor.Anonymous; | |
| 295 | + | |
| 296 | + var password = SmartHttpEndpoints.ParseBasicPassword(context.Request.Headers.Authorization); | |
| 297 | + if (password is not null) | |
| 298 | + { | |
| 299 | + if (limiter.IsBlocked(client)) | |
| 300 | + { | |
| 301 | + context.Response.Headers.RetryAfter = ((int)AuthFailureLimiter.Window.TotalSeconds).ToString(); | |
| 302 | + await WriteTextAsync(context, StatusCodes.Status429TooManyRequests, "Too many failed sign-in attempts. Try again later."); | |
| 303 | + return null; | |
| 304 | + } | |
| 305 | + | |
| 306 | + var token = await tokens.ValidateAsync(password, ct); | |
| 307 | + if (token is null) | |
| 308 | + { | |
| 309 | + limiter.RecordFailure(client); | |
| 310 | + await ChallengeAsync(context); | |
| 311 | + return null; | |
| 312 | + } | |
| 313 | + | |
| 314 | + actor = new Actor(token.UserId, token.CanWrite); | |
| 315 | + } | |
| 316 | + | |
| 317 | + var repo = await repos.FindAsync(owner, repoName, ct); | |
| 318 | + var allowed = repo is not null | |
| 319 | + && (write ? RepoAccess.CanWrite(repo, actor) : RepoAccess.CanRead(repo, actor)); | |
| 320 | + if (allowed) | |
| 321 | + { | |
| 322 | + return repo; | |
| 323 | + } | |
| 324 | + | |
| 325 | + if (actor.IsAnonymous) | |
| 326 | + { | |
| 327 | + await ChallengeAsync(context); | |
| 328 | + } | |
| 329 | + else if (repo is not null && RepoAccess.CanRead(repo, actor)) | |
| 330 | + { | |
| 331 | + await WriteTextAsync(context, StatusCodes.Status403Forbidden, "This token is read-only."); | |
| 332 | + } | |
| 333 | + else | |
| 334 | + { | |
| 335 | + await WriteTextAsync(context, StatusCodes.Status404NotFound, "Repository not found."); | |
| 336 | + } | |
| 337 | + | |
| 338 | + return null; | |
| 339 | + } | |
| 340 | + | |
| 341 | + private static Task ChallengeAsync(HttpContext context) | |
| 342 | + { | |
| 343 | + context.Response.Headers.WWWAuthenticate = "Basic realm=\"forge\", charset=\"UTF-8\""; | |
| 344 | + return WriteTextAsync(context, StatusCodes.Status401Unauthorized, "Authentication required."); | |
| 345 | + } | |
| 346 | + | |
| 347 | + private static Dictionary<string, string?> ProtocolEnvironment(string? protocol) => | |
| 348 | + new(StringComparer.Ordinal) { ["GIT_PROTOCOL"] = protocol }; | |
| 349 | + | |
| 350 | + private static Task WriteTextAsync(HttpContext context, int status, string message) | |
| 351 | + { | |
| 352 | + context.Response.StatusCode = status; | |
| 353 | + context.Response.ContentType = "text/plain; charset=utf-8"; | |
| 354 | + return context.Response.WriteAsync(message + "\n"); | |
| 355 | + } | |
| 356 | + | |
| 357 | + /// <summary>Git clients need the bare status code, not the HTML error page.</summary> | |
| 358 | + private static void DisableStatusPages(HttpContext context) | |
| 359 | + { | |
| 360 | + if (context.Features.Get<IStatusCodePagesFeature>() is { } feature) | |
| 361 | + { | |
| 362 | + feature.Enabled = false; | |
| 363 | + } | |
| 364 | + } | |
| 365 | +} | |
| 366 | + | |
| 367 | +public sealed class PushTooLargeException() : IOException("The decompressed push is larger than the configured limit."); | |
| 368 | + | |
| 369 | +/// <summary>Read-only wrapper that fails once more than <paramref name="limit"/> bytes have been read.</summary> | |
| 370 | +public sealed class LimitedReadStream(Stream inner, long limit) : Stream | |
| 371 | +{ | |
| 372 | + private long _read; | |
| 373 | + | |
| 374 | + public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) | |
| 375 | + { | |
| 376 | + var n = await inner.ReadAsync(buffer, cancellationToken); | |
| 377 | + Count(n); | |
| 378 | + return n; | |
| 379 | + } | |
| 380 | + | |
| 381 | + public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => | |
| 382 | + ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); | |
| 383 | + | |
| 384 | + public override int Read(byte[] buffer, int offset, int count) | |
| 385 | + { | |
| 386 | + var n = inner.Read(buffer, offset, count); | |
| 387 | + Count(n); | |
| 388 | + return n; | |
| 389 | + } | |
| 390 | + | |
| 391 | + private void Count(int n) | |
| 392 | + { | |
| 393 | + _read += n; | |
| 394 | + if (_read > limit) | |
| 395 | + { | |
| 396 | + throw new PushTooLargeException(); | |
| 397 | + } | |
| 398 | + } | |
| 399 | + | |
| 400 | + public override bool CanRead => true; | |
| 401 | + public override bool CanSeek => false; | |
| 402 | + public override bool CanWrite => false; | |
| 403 | + public override long Length => throw new NotSupportedException(); | |
| 404 | + | |
| 405 | + public override long Position | |
| 406 | + { | |
| 407 | + get => _read; | |
| 408 | + set => throw new NotSupportedException(); | |
| 409 | + } | |
| 410 | + | |
| 411 | + public override void Flush() | |
| 412 | + { | |
| 413 | + } | |
| 414 | + | |
| 415 | + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); | |
| 416 | + public override void SetLength(long value) => throw new NotSupportedException(); | |
| 417 | + public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException(); | |
| 418 | + | |
| 419 | + protected override void Dispose(bool disposing) | |
| 420 | + { | |
| 421 | + if (disposing) | |
| 422 | + { | |
| 423 | + inner.Dispose(); | |
| 424 | + } | |
| 425 | + | |
| 426 | + base.Dispose(disposing); | |
| 427 | + } | |
| 428 | +} |
added forge/Features/Webhooks/DeliveryStatus.razor +21 −0View file
| @@ -0,0 +1,21 @@ | ||
| 1 | +@if (Delivery.Succeeded) | |
| 2 | +{ | |
| 3 | + <span class="badge badge-added">@Delivery.StatusCode</span> | |
| 4 | +} | |
| 5 | +else if (Delivery.StatusCode is not null) | |
| 6 | +{ | |
| 7 | + <span class="badge badge-deleted">@Delivery.StatusCode</span> | |
| 8 | +} | |
| 9 | +else if (Delivery.Error is null) | |
| 10 | +{ | |
| 11 | + <span class="badge">@T["in progress"]</span> | |
| 12 | +} | |
| 13 | +else | |
| 14 | +{ | |
| 15 | + <span class="badge badge-deleted">@T["failed"]</span> | |
| 16 | +} | |
| 17 | + | |
| 18 | +@code { | |
| 19 | + [Parameter, EditorRequired] | |
| 20 | + public WebhookDelivery Delivery { get; set; } = null!; | |
| 21 | +} |
added forge/Features/Webhooks/WebhookDetail.razor +227 −0View file
| @@ -0,0 +1,227 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/settings/webhooks/{Id:long}" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@inject ForgeDb Db | |
| 4 | +@inject WebhookSender Sender | |
| 5 | + | |
| 6 | +@if (Repository is not null && _hook is not null) | |
| 7 | +{ | |
| 8 | + <PageTitle>@T["Webhook"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 9 | + | |
| 10 | + <RepoHeader Repository="Repository" Active="settings" IsOwner="IsOwner"/> | |
| 11 | + | |
| 12 | + <nav class="subtabs"> | |
| 13 | + <a href="@Urls.Settings(Repository)">@T["General"]</a> | |
| 14 | + <a class="active" href="@Urls.Webhooks(Repository)">@T["Webhooks"]</a> | |
| 15 | + <a href="@Urls.Protection(Repository)">@T["Protected branches"]</a> | |
| 16 | + </nav> | |
| 17 | + | |
| 18 | + @if (_message is not null) | |
| 19 | + { | |
| 20 | + <p class="alert success">@_message</p> | |
| 21 | + } | |
| 22 | + @if (_error is not null) | |
| 23 | + { | |
| 24 | + <p class="alert error">@_error</p> | |
| 25 | + } | |
| 26 | + | |
| 27 | + <section class="card"> | |
| 28 | + <h2 class="break">@_hook.Url</h2> | |
| 29 | + <dl class="meta"> | |
| 30 | + <dt>@T["Status"]</dt> | |
| 31 | + <dd>@(_hook.Active ? T["active"] : T["disabled"])</dd> | |
| 32 | + <dt>@T["Event"]</dt> | |
| 33 | + <dd>push</dd> | |
| 34 | + <dt>@T["Secret"]</dt> | |
| 35 | + <dd><code class="break">@_hook.Secret</code></dd> | |
| 36 | + <dt>@T["Created"]</dt> | |
| 37 | + <dd><TimeAgo Value="Format.Utc(_hook.CreatedAt)"/></dd> | |
| 38 | + </dl> | |
| 39 | + <form method="post" @formname="hook-action" @onsubmit="ActAsync" class="button-row"> | |
| 40 | + <AntiforgeryToken/> | |
| 41 | + <button type="submit" name="Action" value="ping" class="button">@T["Send test ping"]</button> | |
| 42 | + <button type="submit" name="Action" value="toggle" class="button">@(_hook.Active ? T["Disable"] : T["Enable"])</button> | |
| 43 | + <button type="submit" name="Action" value="delete" class="button danger">@T["Delete webhook"]</button> | |
| 44 | + </form> | |
| 45 | + </section> | |
| 46 | + | |
| 47 | + <section> | |
| 48 | + <h2>@T["Delivery history"]</h2> | |
| 49 | + @if (_deliveries.Count == 0) | |
| 50 | + { | |
| 51 | + <p class="muted">@T["No deliveries yet. Push to the repository or send a test ping."]</p> | |
| 52 | + } | |
| 53 | + else | |
| 54 | + { | |
| 55 | + <form method="post" @formname="redeliver" @onsubmit="RedeliverAsync"> | |
| 56 | + <AntiforgeryToken/> | |
| 57 | + <table class="table"> | |
| 58 | + <thead> | |
| 59 | + <tr> | |
| 60 | + <th>#</th> | |
| 61 | + <th>@T["Event"]</th> | |
| 62 | + <th>@T["Result"]</th> | |
| 63 | + <th>@T["Attempt"]</th> | |
| 64 | + <th>@T["Duration"]</th> | |
| 65 | + <th>@T["When"]</th> | |
| 66 | + <th></th> | |
| 67 | + </tr> | |
| 68 | + </thead> | |
| 69 | + <tbody> | |
| 70 | + @foreach (var d in _deliveries) | |
| 71 | + { | |
| 72 | + <tr> | |
| 73 | + <td>@d.Id</td> | |
| 74 | + <td> | |
| 75 | + @if (d.PushEvent is { } push) | |
| 76 | + { | |
| 77 | + <span>push <code>@push.RefName</code></span> | |
| 78 | + } | |
| 79 | + else | |
| 80 | + { | |
| 81 | + <span>ping</span> | |
| 82 | + } | |
| 83 | + </td> | |
| 84 | + <td> | |
| 85 | + <DeliveryStatus Delivery="d"/> | |
| 86 | + @if (d.Error is not null) | |
| 87 | + { | |
| 88 | + <span class="muted small break"> @d.Error</span> | |
| 89 | + } | |
| 90 | + </td> | |
| 91 | + <td>@d.Attempt</td> | |
| 92 | + <td>@d.DurationMs ms</td> | |
| 93 | + <td class="small"><TimeAgo Value="Format.Utc(d.DeliveredAt)"/></td> | |
| 94 | + <td class="right"> | |
| 95 | + @if (d.PushEventId is not null) | |
| 96 | + { | |
| 97 | + <button type="submit" name="DeliveryId" value="@d.Id" class="button small">@T["Redeliver"]</button> | |
| 98 | + } | |
| 99 | + </td> | |
| 100 | + </tr> | |
| 101 | + } | |
| 102 | + </tbody> | |
| 103 | + </table> | |
| 104 | + </form> | |
| 105 | + } | |
| 106 | + </section> | |
| 107 | +} | |
| 108 | + | |
| 109 | +@code { | |
| 110 | + private const int MaxDeliveriesShown = 50; | |
| 111 | + | |
| 112 | + [Parameter] | |
| 113 | + public long Id { get; set; } | |
| 114 | + | |
| 115 | + [SupplyParameterFromForm(FormName = "hook-action")] | |
| 116 | + private string? Action { get; set; } | |
| 117 | + | |
| 118 | + [SupplyParameterFromForm(FormName = "redeliver")] | |
| 119 | + private long? DeliveryId { get; set; } | |
| 120 | + | |
| 121 | + private Webhook? _hook; | |
| 122 | + private List<WebhookDelivery> _deliveries = []; | |
| 123 | + private string? _message; | |
| 124 | + private string? _error; | |
| 125 | + | |
| 126 | + protected override async Task OnInitializedAsync() | |
| 127 | + { | |
| 128 | + if (!await LoadRepoAsync(requireAdmin: true)) | |
| 129 | + { | |
| 130 | + return; | |
| 131 | + } | |
| 132 | + | |
| 133 | + // The repository ID is part of the lookup, so a webhook of another repository is simply not found. | |
| 134 | + var repoId = Repository!.Id; | |
| 135 | + _hook = await Db.Webhooks.FirstOrDefaultAsync(w => w.Id == Id && w.RepoId == repoId); | |
| 136 | + if (_hook is null) | |
| 137 | + { | |
| 138 | + NotFound(); | |
| 139 | + return; | |
| 140 | + } | |
| 141 | + | |
| 142 | + await LoadDeliveriesAsync(); | |
| 143 | + } | |
| 144 | + | |
| 145 | + private async Task LoadDeliveriesAsync() | |
| 146 | + { | |
| 147 | + var hookId = _hook!.Id; | |
| 148 | + _deliveries = await Db.WebhookDeliveries | |
| 149 | + .AsNoTracking() | |
| 150 | + .Include(d => d.PushEvent) | |
| 151 | + .Where(d => d.WebhookId == hookId) | |
| 152 | + .OrderByDescending(d => d.Id) | |
| 153 | + .Take(MaxDeliveriesShown) | |
| 154 | + .ToListAsync(); | |
| 155 | + } | |
| 156 | + | |
| 157 | + private async Task ActAsync() | |
| 158 | + { | |
| 159 | + if (Repository is null || _hook is null) | |
| 160 | + { | |
| 161 | + return; | |
| 162 | + } | |
| 163 | + | |
| 164 | + switch (Action) | |
| 165 | + { | |
| 166 | + case "ping": | |
| 167 | + // Sent inline (at most the 10 s timeout) so the result is on the page right away. | |
| 168 | + var ok = await Sender.DeliverAsync(_hook.Id, null, 1); | |
| 169 | + if (ok) | |
| 170 | + { | |
| 171 | + _message = T["The ping was delivered."]; | |
| 172 | + } | |
| 173 | + else | |
| 174 | + { | |
| 175 | + _error = T["The ping could not be delivered. See the history below for details."]; | |
| 176 | + } | |
| 177 | + | |
| 178 | + await LoadDeliveriesAsync(); | |
| 179 | + break; | |
| 180 | + | |
| 181 | + case "toggle": | |
| 182 | + _hook.Active = !_hook.Active; | |
| 183 | + await Db.SaveChangesAsync(); | |
| 184 | + _message = _hook.Active ? T["The webhook is enabled."] : T["The webhook is disabled."]; | |
| 185 | + break; | |
| 186 | + | |
| 187 | + case "delete": | |
| 188 | + Db.Webhooks.Remove(_hook); | |
| 189 | + await Db.SaveChangesAsync(); | |
| 190 | + Redirect(Urls.Webhooks(Repository)); | |
| 191 | + break; | |
| 192 | + } | |
| 193 | + } | |
| 194 | + | |
| 195 | + private async Task RedeliverAsync() | |
| 196 | + { | |
| 197 | + if (Repository is null || _hook is null) | |
| 198 | + { | |
| 199 | + return; | |
| 200 | + } | |
| 201 | + | |
| 202 | + var hookId = _hook.Id; | |
| 203 | + var original = await Db.WebhookDeliveries | |
| 204 | + .AsNoTracking() | |
| 205 | + .FirstOrDefaultAsync(d => d.Id == DeliveryId && d.WebhookId == hookId); | |
| 206 | + if (original?.PushEventId is not { } pushEventId) | |
| 207 | + { | |
| 208 | + _error = T["This delivery cannot be repeated."]; | |
| 209 | + return; | |
| 210 | + } | |
| 211 | + | |
| 212 | + var attempt = await Db.WebhookDeliveries | |
| 213 | + .Where(d => d.WebhookId == hookId && d.PushEventId == pushEventId) | |
| 214 | + .MaxAsync(d => d.Attempt) + 1; | |
| 215 | + | |
| 216 | + if (await Sender.DeliverAsync(hookId, pushEventId, attempt)) | |
| 217 | + { | |
| 218 | + _message = T["Delivered again."]; | |
| 219 | + } | |
| 220 | + else | |
| 221 | + { | |
| 222 | + _error = T["Redelivery failed. See the history below for details."]; | |
| 223 | + } | |
| 224 | + | |
| 225 | + await LoadDeliveriesAsync(); | |
| 226 | + } | |
| 227 | +} |
added forge/Features/Webhooks/WebhookList.razor +150 −0View file
| @@ -0,0 +1,150 @@ | ||
| 1 | +@page "/{Owner}/{Repo}/settings/webhooks" | |
| 2 | +@inherits RepoPageBase | |
| 3 | +@using System.Security.Cryptography | |
| 4 | +@inject ForgeDb Db | |
| 5 | + | |
| 6 | +@if (Repository is not null) | |
| 7 | +{ | |
| 8 | + <PageTitle>@T["Webhooks"] · @Repository.Owner.Username/@Repository.Name</PageTitle> | |
| 9 | + | |
| 10 | + <RepoHeader Repository="Repository" Active="settings" IsOwner="IsOwner"/> | |
| 11 | + | |
| 12 | + <nav class="subtabs"> | |
| 13 | + <a href="@Urls.Settings(Repository)">@T["General"]</a> | |
| 14 | + <a class="active" href="@Urls.Webhooks(Repository)">@T["Webhooks"]</a> | |
| 15 | + <a href="@Urls.Protection(Repository)">@T["Protected branches"]</a> | |
| 16 | + </nav> | |
| 17 | + | |
| 18 | + <p class="muted">@T["After every push Forge sends signed JSON to the given address. Useful for triggering an external CI."]</p> | |
| 19 | + | |
| 20 | + @if (_error is not null) | |
| 21 | + { | |
| 22 | + <p class="alert error">@_error</p> | |
| 23 | + } | |
| 24 | + | |
| 25 | + @if (_hooks.Count == 0) | |
| 26 | + { | |
| 27 | + <div class="card empty"><p>@T["This repository has no webhooks yet."]</p></div> | |
| 28 | + } | |
| 29 | + else | |
| 30 | + { | |
| 31 | + <table class="table"> | |
| 32 | + <thead> | |
| 33 | + <tr> | |
| 34 | + <th>@T["URL"]</th> | |
| 35 | + <th>@T["Status"]</th> | |
| 36 | + <th>@T["Last delivery"]</th> | |
| 37 | + </tr> | |
| 38 | + </thead> | |
| 39 | + <tbody> | |
| 40 | + @foreach (var hook in _hooks) | |
| 41 | + { | |
| 42 | + <tr> | |
| 43 | + <td><a href="@Urls.Webhook(Repository, hook.Id)">@hook.Url</a></td> | |
| 44 | + <td>@(hook.Active ? T["active"] : T["disabled"])</td> | |
| 45 | + <td> | |
| 46 | + @if (_last.TryGetValue(hook.Id, out var last)) | |
| 47 | + { | |
| 48 | + <DeliveryStatus Delivery="last"/> | |
| 49 | + <span class="muted small"> · <TimeAgo Value="Format.Utc(last.DeliveredAt)"/></span> | |
| 50 | + } | |
| 51 | + else | |
| 52 | + { | |
| 53 | + <span class="muted">@T["none yet"]</span> | |
| 54 | + } | |
| 55 | + </td> | |
| 56 | + </tr> | |
| 57 | + } | |
| 58 | + </tbody> | |
| 59 | + </table> | |
| 60 | + } | |
| 61 | + | |
| 62 | + <section class="card"> | |
| 63 | + <h2>@T["Add webhook"]</h2> | |
| 64 | + <form method="post" @formname="add-webhook" @onsubmit="AddAsync" class="form"> | |
| 65 | + <AntiforgeryToken/> | |
| 66 | + <label> | |
| 67 | + @T["URL"] | |
| 68 | + <input name="Url" type="url" value="@Url" required maxlength="2000" placeholder="https://ci.example.com/hooks/forge"/> | |
| 69 | + </label> | |
| 70 | + <label> | |
| 71 | + <span>@T["Secret"] <span class="muted">@T["(optional, generated if empty)"]</span></span> | |
| 72 | + <input name="Secret" maxlength="200" autocomplete="off"/> | |
| 73 | + <small class="muted">@T.Html("Used to sign <code>X-Forge-Signature</code> (HMAC-SHA256 of the request body).")</small> | |
| 74 | + </label> | |
| 75 | + <button type="submit" class="button primary">@T["Add webhook"]</button> | |
| 76 | + </form> | |
| 77 | + </section> | |
| 78 | +} | |
| 79 | + | |
| 80 | +@code { | |
| 81 | + [SupplyParameterFromForm] | |
| 82 | + private string? Url { get; set; } | |
| 83 | + | |
| 84 | + [SupplyParameterFromForm] | |
| 85 | + private string? Secret { get; set; } | |
| 86 | + | |
| 87 | + private List<Webhook> _hooks = []; | |
| 88 | + private Dictionary<long, WebhookDelivery> _last = []; | |
| 89 | + private string? _error; | |
| 90 | + | |
| 91 | + protected override async Task OnInitializedAsync() | |
| 92 | + { | |
| 93 | + if (await LoadRepoAsync(requireAdmin: true)) | |
| 94 | + { | |
| 95 | + await LoadAsync(); | |
| 96 | + } | |
| 97 | + } | |
| 98 | + | |
| 99 | + private async Task LoadAsync() | |
| 100 | + { | |
| 101 | + var repoId = Repository!.Id; | |
| 102 | + _hooks = await Db.Webhooks.Where(w => w.RepoId == repoId).OrderBy(w => w.Id).ToListAsync(); | |
| 103 | + | |
| 104 | + _last = []; | |
| 105 | + foreach (var hook in _hooks) | |
| 106 | + { | |
| 107 | + var last = await Db.WebhookDeliveries | |
| 108 | + .Where(d => d.WebhookId == hook.Id) | |
| 109 | + .OrderByDescending(d => d.Id) | |
| 110 | + .FirstOrDefaultAsync(); | |
| 111 | + if (last is not null) | |
| 112 | + { | |
| 113 | + _last[hook.Id] = last; | |
| 114 | + } | |
| 115 | + } | |
| 116 | + } | |
| 117 | + | |
| 118 | + private async Task AddAsync() | |
| 119 | + { | |
| 120 | + if (Repository is null) | |
| 121 | + { | |
| 122 | + return; | |
| 123 | + } | |
| 124 | + | |
| 125 | + var url = Url?.Trim() ?? ""; | |
| 126 | + if (url.Length > 2000 | |
| 127 | + || !Uri.TryCreate(url, UriKind.Absolute, out var uri) | |
| 128 | + || (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)) | |
| 129 | + { | |
| 130 | + _error = T["Enter a full address starting with http:// or https://."]; | |
| 131 | + return; | |
| 132 | + } | |
| 133 | + | |
| 134 | + var secret = string.IsNullOrWhiteSpace(Secret) | |
| 135 | + ? Convert.ToHexStringLower(RandomNumberGenerator.GetBytes(24)) | |
| 136 | + : Secret.Trim(); | |
| 137 | + | |
| 138 | + var hook = new Webhook | |
| 139 | + { | |
| 140 | + RepoId = Repository.Id, | |
| 141 | + Url = url, | |
| 142 | + Secret = secret, | |
| 143 | + Active = true, | |
| 144 | + CreatedAt = DateTime.UtcNow, | |
| 145 | + }; | |
| 146 | + Db.Webhooks.Add(hook); | |
| 147 | + await Db.SaveChangesAsync(); | |
| 148 | + Redirect(Urls.Webhook(Repository, hook.Id)); | |
| 149 | + } | |
| 150 | +} |
added forge/Features/Webhooks/WebhookSender.cs +202 −0View file
| @@ -0,0 +1,202 @@ | ||
| 1 | +using System.Diagnostics; | |
| 2 | +using System.Globalization; | |
| 3 | +using System.Net.Http.Headers; | |
| 4 | +using System.Security.Cryptography; | |
| 5 | +using System.Text; | |
| 6 | +using System.Text.Json; | |
| 7 | +using System.Threading.Channels; | |
| 8 | +using Forge.Data; | |
| 9 | +using Forge.Git; | |
| 10 | +using Microsoft.EntityFrameworkCore; | |
| 11 | +using Microsoft.Extensions.Options; | |
| 12 | + | |
| 13 | +namespace Forge.Features.Webhooks; | |
| 14 | + | |
| 15 | +/// <summary>Hands push event IDs from the request that received the push to the background worker.</summary> | |
| 16 | +public sealed class WebhookQueue | |
| 17 | +{ | |
| 18 | + private readonly Channel<long> _channel = Channel.CreateUnbounded<long>( | |
| 19 | + new UnboundedChannelOptions { SingleReader = true }); | |
| 20 | + | |
| 21 | + public ChannelReader<long> Reader => _channel.Reader; | |
| 22 | + | |
| 23 | + public void Enqueue(long pushEventId) => _channel.Writer.TryWrite(pushEventId); | |
| 24 | +} | |
| 25 | + | |
| 26 | +/// <summary>Performs single delivery attempts. Every attempt becomes a row in webhook_deliveries.</summary> | |
| 27 | +public sealed class WebhookSender( | |
| 28 | + IServiceScopeFactory scopes, | |
| 29 | + IHttpClientFactory httpClients, | |
| 30 | + GitRepo git, | |
| 31 | + RepoPaths paths, | |
| 32 | + IOptions<ForgeOptions> options, | |
| 33 | + ILogger<WebhookSender> log) | |
| 34 | +{ | |
| 35 | + public const string HttpClientName = "webhooks"; | |
| 36 | + public const int MaxCommits = 20; | |
| 37 | + public static readonly TimeSpan Timeout = TimeSpan.FromSeconds(10); | |
| 38 | + | |
| 39 | + private static readonly JsonSerializerOptions Json = new() { WriteIndented = false }; | |
| 40 | + | |
| 41 | + /// <summary>"sha256=<hex>": HMAC-SHA256 of the exact request body, keyed with the webhook secret.</summary> | |
| 42 | + public static string Sign(string secret, ReadOnlySpan<byte> body) => | |
| 43 | + "sha256=" + Convert.ToHexStringLower(HMACSHA256.HashData(Encoding.UTF8.GetBytes(secret), body)); | |
| 44 | + | |
| 45 | + /// <summary> | |
| 46 | + /// Sends one attempt and records it. A null <paramref name="pushEventId"/> sends a ping. | |
| 47 | + /// Returns true when the receiver answered with a 2xx status. | |
| 48 | + /// </summary> | |
| 49 | + public async Task<bool> DeliverAsync(long webhookId, long? pushEventId, int attempt, CancellationToken ct = default) | |
| 50 | + { | |
| 51 | + await using var scope = scopes.CreateAsyncScope(); | |
| 52 | + var db = scope.ServiceProvider.GetRequiredService<ForgeDb>(); | |
| 53 | + | |
| 54 | + var hook = await db.Webhooks | |
| 55 | + .Include(w => w.Repo).ThenInclude(r => r.Owner) | |
| 56 | + .FirstOrDefaultAsync(w => w.Id == webhookId, ct); | |
| 57 | + if (hook is null) | |
| 58 | + { | |
| 59 | + return true; // Deleted meanwhile: nothing left to retry. | |
| 60 | + } | |
| 61 | + | |
| 62 | + PushEvent? push = null; | |
| 63 | + if (pushEventId is not null) | |
| 64 | + { | |
| 65 | + push = await db.PushEvents.FirstOrDefaultAsync(e => e.Id == pushEventId, ct); | |
| 66 | + if (push is null) | |
| 67 | + { | |
| 68 | + return true; | |
| 69 | + } | |
| 70 | + } | |
| 71 | + | |
| 72 | + var delivery = new WebhookDelivery | |
| 73 | + { | |
| 74 | + WebhookId = hook.Id, | |
| 75 | + PushEventId = push?.Id, | |
| 76 | + Attempt = attempt, | |
| 77 | + DeliveredAt = DateTime.UtcNow, | |
| 78 | + }; | |
| 79 | + db.WebhookDeliveries.Add(delivery); | |
| 80 | + await db.SaveChangesAsync(ct); | |
| 81 | + | |
| 82 | + var stopwatch = Stopwatch.StartNew(); | |
| 83 | + try | |
| 84 | + { | |
| 85 | + var body = push is null | |
| 86 | + ? BuildPingPayload(hook) | |
| 87 | + : await BuildPushPayloadAsync(hook.Repo, push, ct); | |
| 88 | + | |
| 89 | + using var request = new HttpRequestMessage(HttpMethod.Post, hook.Url); | |
| 90 | + request.Content = new ByteArrayContent(body); | |
| 91 | + request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json") { CharSet = "utf-8" }; | |
| 92 | + request.Headers.TryAddWithoutValidation("User-Agent", "Forge-Webhook"); | |
| 93 | + request.Headers.TryAddWithoutValidation("X-Forge-Event", push is null ? "ping" : "push"); | |
| 94 | + request.Headers.TryAddWithoutValidation("X-Forge-Delivery", delivery.Id.ToString(CultureInfo.InvariantCulture)); | |
| 95 | + request.Headers.TryAddWithoutValidation("X-Forge-Signature", Sign(hook.Secret, body)); | |
| 96 | + | |
| 97 | + using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct); | |
| 98 | + timeout.CancelAfter(Timeout); | |
| 99 | + using var response = await httpClients.CreateClient(HttpClientName) | |
| 100 | + .SendAsync(request, HttpCompletionOption.ResponseHeadersRead, timeout.Token); | |
| 101 | + | |
| 102 | + delivery.StatusCode = (int)response.StatusCode; | |
| 103 | + if (!response.IsSuccessStatusCode) | |
| 104 | + { | |
| 105 | + delivery.Error = $"HTTP {(int)response.StatusCode} {response.ReasonPhrase}".Trim(); | |
| 106 | + } | |
| 107 | + } | |
| 108 | + catch (OperationCanceledException) when (ct.IsCancellationRequested) | |
| 109 | + { | |
| 110 | + delivery.Error = "Cancelled because the server was shutting down."; | |
| 111 | + } | |
| 112 | + catch (OperationCanceledException) | |
| 113 | + { | |
| 114 | + delivery.Error = $"Timed out after {Timeout.TotalSeconds:0} s."; | |
| 115 | + } | |
| 116 | + catch (Exception ex) when (ex is HttpRequestException or InvalidOperationException or UriFormatException or GitException or GitTimeoutException) | |
| 117 | + { | |
| 118 | + delivery.Error = Truncate(ex.InnerException?.Message ?? ex.Message, 500); | |
| 119 | + } | |
| 120 | + | |
| 121 | + delivery.DurationMs = (int)Math.Min(int.MaxValue, stopwatch.ElapsedMilliseconds); | |
| 122 | + await db.SaveChangesAsync(CancellationToken.None); | |
| 123 | + | |
| 124 | + if (!delivery.Succeeded) | |
| 125 | + { | |
| 126 | + log.LogInformation( | |
| 127 | + "Webhook {WebhookId} delivery {DeliveryId} failed (attempt {Attempt}): {Error}", | |
| 128 | + hook.Id, delivery.Id, attempt, delivery.Error); | |
| 129 | + } | |
| 130 | + | |
| 131 | + return delivery.Succeeded; | |
| 132 | + } | |
| 133 | + | |
| 134 | + private byte[] BuildPingPayload(Webhook hook) => | |
| 135 | + JsonSerializer.SerializeToUtf8Bytes( | |
| 136 | + new | |
| 137 | + { | |
| 138 | + zen = "Small commits, clear messages.", | |
| 139 | + hook_id = hook.Id, | |
| 140 | + repository = DescribeRepository(hook.Repo), | |
| 141 | + }, | |
| 142 | + Json); | |
| 143 | + | |
| 144 | + private async Task<byte[]> BuildPushPayloadAsync(Repository repo, PushEvent push, CancellationToken ct) | |
| 145 | + { | |
| 146 | + var o = options.Value; | |
| 147 | + var created = push.OldSha == GitParsers.ZeroSha; | |
| 148 | + var deleted = push.NewSha == GitParsers.ZeroSha; | |
| 149 | + | |
| 150 | + IReadOnlyList<CommitInfo> commits = []; | |
| 151 | + if (!deleted && GitParsers.IsFullSha(push.NewSha) && GitParsers.IsFullSha(push.OldSha)) | |
| 152 | + { | |
| 153 | + commits = await git.LogRangeAsync(paths.For(repo.Id), push.OldSha, push.NewSha, MaxCommits, ct); | |
| 154 | + } | |
| 155 | + | |
| 156 | + var compare = created || deleted | |
| 157 | + ? Urls.Absolute(o, Urls.Commit(repo, deleted ? push.OldSha : push.NewSha)) | |
| 158 | + : Urls.Absolute(o, Urls.Compare(repo, push.OldSha, push.NewSha)); | |
| 159 | + | |
| 160 | + return JsonSerializer.SerializeToUtf8Bytes( | |
| 161 | + new | |
| 162 | + { | |
| 163 | + @ref = push.RefName, | |
| 164 | + before = push.OldSha, | |
| 165 | + after = push.NewSha, | |
| 166 | + created, | |
| 167 | + deleted, | |
| 168 | + compare, | |
| 169 | + pushed_at = Format.IsoTime(Format.Utc(push.PushedAt)), | |
| 170 | + repository = DescribeRepository(repo), | |
| 171 | + // Oldest first, the order in which they were written. | |
| 172 | + commits = commits.Reverse().Select(c => new | |
| 173 | + { | |
| 174 | + id = c.Sha, | |
| 175 | + message = c.Body.Length == 0 ? c.Subject : c.Subject + "\n\n" + c.Body, | |
| 176 | + timestamp = Format.IsoTime(c.AuthorDate), | |
| 177 | + url = Urls.Absolute(o, Urls.Commit(repo, c.Sha)), | |
| 178 | + author = new { name = c.AuthorName, email = c.AuthorEmail }, | |
| 179 | + committer = new { name = c.CommitterName, email = c.CommitterEmail }, | |
| 180 | + }), | |
| 181 | + }, | |
| 182 | + Json); | |
| 183 | + } | |
| 184 | + | |
| 185 | + private object DescribeRepository(Repository repo) | |
| 186 | + { | |
| 187 | + var o = options.Value; | |
| 188 | + return new | |
| 189 | + { | |
| 190 | + id = repo.Id, | |
| 191 | + name = repo.Name, | |
| 192 | + full_name = $"{repo.Owner.Username}/{repo.Name}", | |
| 193 | + @private = repo.Visibility == Visibility.Private, | |
| 194 | + description = repo.Description, | |
| 195 | + default_branch = repo.DefaultBranch, | |
| 196 | + html_url = Urls.Absolute(o, Urls.Repo(repo)), | |
| 197 | + clone_url = Urls.Clone(o, repo), | |
| 198 | + }; | |
| 199 | + } | |
| 200 | + | |
| 201 | + private static string Truncate(string value, int max) => value.Length <= max ? value : value[..max]; | |
| 202 | +} |
added forge/Features/Webhooks/WebhookWorker.cs +155 −0View file
| @@ -0,0 +1,155 @@ | ||
| 1 | +using Forge.Data; | |
| 2 | +using Microsoft.EntityFrameworkCore; | |
| 3 | + | |
| 4 | +namespace Forge.Features.Webhooks; | |
| 5 | + | |
| 6 | +/// <summary> | |
| 7 | +/// Delivers push events to webhooks in the background, so a push never waits for a receiver. | |
| 8 | +/// A failed delivery is retried with a growing delay; each (webhook, event) pair retries on its own. | |
| 9 | +/// </summary> | |
| 10 | +public sealed class WebhookWorker( | |
| 11 | + WebhookQueue queue, | |
| 12 | + WebhookSender sender, | |
| 13 | + IServiceScopeFactory scopes, | |
| 14 | + ILogger<WebhookWorker> log) : BackgroundService | |
| 15 | +{ | |
| 16 | + public const int MaxAttempts = 3; | |
| 17 | + | |
| 18 | + /// <summary>Wait before attempt 2 and before attempt 3. Settable so tests do not wait a minute.</summary> | |
| 19 | + public static TimeSpan[] RetryDelays { get; set; } = [TimeSpan.FromSeconds(10), TimeSpan.FromMinutes(1)]; | |
| 20 | + | |
| 21 | + /// <summary>Events older than this are not picked up again after a restart.</summary> | |
| 22 | + private static readonly TimeSpan RequeueWindow = TimeSpan.FromDays(3); | |
| 23 | + | |
| 24 | + protected override async Task ExecuteAsync(CancellationToken stoppingToken) | |
| 25 | + { | |
| 26 | + try | |
| 27 | + { | |
| 28 | + await RequeueUndeliveredAsync(stoppingToken); | |
| 29 | + } | |
| 30 | + catch (Exception ex) when (ex is not OperationCanceledException) | |
| 31 | + { | |
| 32 | + log.LogError(ex, "Could not requeue undelivered webhook events"); | |
| 33 | + } | |
| 34 | + | |
| 35 | + try | |
| 36 | + { | |
| 37 | + await foreach (var pushEventId in queue.Reader.ReadAllAsync(stoppingToken)) | |
| 38 | + { | |
| 39 | + try | |
| 40 | + { | |
| 41 | + foreach (var webhookId in await ActiveWebhooksForAsync(pushEventId, stoppingToken)) | |
| 42 | + { | |
| 43 | + _ = DeliverWithRetriesAsync(webhookId, pushEventId, 1, stoppingToken); | |
| 44 | + } | |
| 45 | + } | |
| 46 | + catch (Exception ex) when (ex is not OperationCanceledException) | |
| 47 | + { | |
| 48 | + log.LogError(ex, "Could not dispatch webhooks for push event {PushEventId}", pushEventId); | |
| 49 | + } | |
| 50 | + } | |
| 51 | + } | |
| 52 | + catch (OperationCanceledException) | |
| 53 | + { | |
| 54 | + // Shutting down. | |
| 55 | + } | |
| 56 | + } | |
| 57 | + | |
| 58 | + private async Task<List<long>> ActiveWebhooksForAsync(long pushEventId, CancellationToken ct) | |
| 59 | + { | |
| 60 | + await using var scope = scopes.CreateAsyncScope(); | |
| 61 | + var db = scope.ServiceProvider.GetRequiredService<ForgeDb>(); | |
| 62 | + var push = await db.PushEvents.AsNoTracking().FirstOrDefaultAsync(e => e.Id == pushEventId, ct); | |
| 63 | + if (push is null) | |
| 64 | + { | |
| 65 | + return []; | |
| 66 | + } | |
| 67 | + | |
| 68 | + return await db.Webhooks | |
| 69 | + .Where(w => w.RepoId == push.RepoId && w.Active) | |
| 70 | + .Select(w => w.Id) | |
| 71 | + .ToListAsync(ct); | |
| 72 | + } | |
| 73 | + | |
| 74 | + private async Task DeliverWithRetriesAsync(long webhookId, long pushEventId, int firstAttempt, CancellationToken ct) | |
| 75 | + { | |
| 76 | + try | |
| 77 | + { | |
| 78 | + for (var attempt = firstAttempt; attempt <= MaxAttempts; attempt++) | |
| 79 | + { | |
| 80 | + if (attempt > firstAttempt) | |
| 81 | + { | |
| 82 | + var delays = RetryDelays; | |
| 83 | + await Task.Delay(delays[Math.Min(attempt - 2, delays.Length - 1)], ct); | |
| 84 | + } | |
| 85 | + | |
| 86 | + if (await sender.DeliverAsync(webhookId, pushEventId, attempt, ct)) | |
| 87 | + { | |
| 88 | + return; | |
| 89 | + } | |
| 90 | + } | |
| 91 | + } | |
| 92 | + catch (OperationCanceledException) | |
| 93 | + { | |
| 94 | + // Shutting down; the event is picked up again on the next start. | |
| 95 | + } | |
| 96 | + catch (Exception ex) | |
| 97 | + { | |
| 98 | + log.LogError(ex, "Webhook {WebhookId} delivery for push event {PushEventId} crashed", webhookId, pushEventId); | |
| 99 | + } | |
| 100 | + } | |
| 101 | + | |
| 102 | + /// <summary>On startup, continues deliveries that never succeeded and still have attempts left.</summary> | |
| 103 | + private async Task RequeueUndeliveredAsync(CancellationToken ct) | |
| 104 | + { | |
| 105 | + List<(long WebhookId, long PushEventId, int Attempts)> pending; | |
| 106 | + await using (var scope = scopes.CreateAsyncScope()) | |
| 107 | + { | |
| 108 | + var db = scope.ServiceProvider.GetRequiredService<ForgeDb>(); | |
| 109 | + var since = DateTime.UtcNow - RequeueWindow; | |
| 110 | + | |
| 111 | + var candidates = await ( | |
| 112 | + from e in db.PushEvents | |
| 113 | + join w in db.Webhooks on e.RepoId equals w.RepoId | |
| 114 | + where w.Active && e.PushedAt >= since && e.PushedAt >= w.CreatedAt | |
| 115 | + select new { WebhookId = w.Id, PushEventId = e.Id }) | |
| 116 | + .ToListAsync(ct); | |
| 117 | + if (candidates.Count == 0) | |
| 118 | + { | |
| 119 | + return; | |
| 120 | + } | |
| 121 | + | |
| 122 | + var eventIds = candidates.Select(c => c.PushEventId).Distinct().ToList(); | |
| 123 | + var attempts = await db.WebhookDeliveries | |
| 124 | + .Where(d => d.PushEventId != null && eventIds.Contains(d.PushEventId.Value)) | |
| 125 | + .Select(d => new { d.WebhookId, d.PushEventId, d.Attempt, d.StatusCode }) | |
| 126 | + .ToListAsync(ct); | |
| 127 | + | |
| 128 | + var summary = attempts | |
| 129 | + .GroupBy(d => (d.WebhookId, PushEventId: d.PushEventId!.Value)) | |
| 130 | + .ToDictionary( | |
| 131 | + g => g.Key, | |
| 132 | + g => (Max: g.Max(d => d.Attempt), Succeeded: g.Any(d => d.StatusCode is >= 200 and < 300))); | |
| 133 | + | |
| 134 | + pending = []; | |
| 135 | + foreach (var c in candidates) | |
| 136 | + { | |
| 137 | + var (max, succeeded) = summary.GetValueOrDefault((c.WebhookId, c.PushEventId)); | |
| 138 | + if (!succeeded && max < MaxAttempts) | |
| 139 | + { | |
| 140 | + pending.Add((c.WebhookId, c.PushEventId, max)); | |
| 141 | + } | |
| 142 | + } | |
| 143 | + } | |
| 144 | + | |
| 145 | + if (pending.Count > 0) | |
| 146 | + { | |
| 147 | + log.LogInformation("Resuming {Count} undelivered webhook deliveries", pending.Count); | |
| 148 | + } | |
| 149 | + | |
| 150 | + foreach (var (webhookId, pushEventId, attempts) in pending) | |
| 151 | + { | |
| 152 | + _ = DeliverWithRetriesAsync(webhookId, pushEventId, attempts + 1, ct); | |
| 153 | + } | |
| 154 | + } | |
| 155 | +} |
added forge/ForgeApp.cs +291 −0View file
| @@ -0,0 +1,291 @@ | ||
| 1 | +using System.Threading.RateLimiting; | |
| 2 | +using Forge.Components; | |
| 3 | +using Forge.Data; | |
| 4 | +using Forge.Features.Auth; | |
| 5 | +using Forge.Features.Browse; | |
| 6 | +using Forge.Features.History; | |
| 7 | +using Forge.Features.Pulls; | |
| 8 | +using Forge.Features.Repos; | |
| 9 | +using Forge.Features.SmartHttp; | |
| 10 | +using Forge.Features.Webhooks; | |
| 11 | +using Forge.Git; | |
| 12 | +using Forge.Localization; | |
| 13 | +using Microsoft.AspNetCore.Authentication; | |
| 14 | +using Microsoft.AspNetCore.Authentication.Cookies; | |
| 15 | +using Microsoft.AspNetCore.DataProtection; | |
| 16 | +using Microsoft.AspNetCore.Identity; | |
| 17 | +using Microsoft.AspNetCore.Localization; | |
| 18 | +using Microsoft.AspNetCore.Mvc; | |
| 19 | +using Microsoft.AspNetCore.RateLimiting; | |
| 20 | +using Microsoft.EntityFrameworkCore; | |
| 21 | +using Microsoft.Extensions.Options; | |
| 22 | + | |
| 23 | +namespace Forge; | |
| 24 | + | |
| 25 | +public sealed class ForgeStartupException(string message) : Exception(message); | |
| 26 | + | |
| 27 | +public static class ForgeApp | |
| 28 | +{ | |
| 29 | + public const string LoginRateLimit = "login"; | |
| 30 | + public const string LanguageCookie = "forge_lang"; | |
| 31 | + | |
| 32 | + /// <summary>Oldest git the app works with (`merge-tree --merge-base` needs 2.40).</summary> | |
| 33 | + public static readonly Version MinimumGitVersion = new(2, 40); | |
| 34 | + | |
| 35 | + public const string ContentSecurityPolicy = | |
| 36 | + "default-src 'self'; img-src 'self' data:; object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'"; | |
| 37 | + | |
| 38 | + public static WebApplication Build(string[] args) | |
| 39 | + { | |
| 40 | + var builder = WebApplication.CreateBuilder(new WebApplicationOptions | |
| 41 | + { | |
| 42 | + Args = args, | |
| 43 | + // Stays correct when the app is hosted from another process, such as the test runner. | |
| 44 | + ApplicationName = typeof(ForgeApp).Assembly.GetName().Name, | |
| 45 | + }); | |
| 46 | + | |
| 47 | + ConfigureServices(builder); | |
| 48 | + var app = builder.Build(); | |
| 49 | + ConfigurePipeline(app); | |
| 50 | + return app; | |
| 51 | + } | |
| 52 | + | |
| 53 | + /// <summary> | |
| 54 | + /// Prepares everything the app needs before it accepts requests: data directories, a working git, | |
| 55 | + /// and an up-to-date database. Throws <see cref="ForgeStartupException"/> with a message for the operator. | |
| 56 | + /// </summary> | |
| 57 | + public static async Task InitializeAsync(WebApplication app, CancellationToken ct = default) | |
| 58 | + { | |
| 59 | + ForgeOptions options; | |
| 60 | + try | |
| 61 | + { | |
| 62 | + options = app.Services.GetRequiredService<IOptions<ForgeOptions>>().Value; | |
| 63 | + } | |
| 64 | + catch (OptionsValidationException ex) | |
| 65 | + { | |
| 66 | + throw new ForgeStartupException("Invalid configuration: " + string.Join(" ", ex.Failures)); | |
| 67 | + } | |
| 68 | + | |
| 69 | + Directory.CreateDirectory(options.DataRoot); | |
| 70 | + Directory.CreateDirectory(options.ReposRoot); | |
| 71 | + | |
| 72 | + Version version; | |
| 73 | + try | |
| 74 | + { | |
| 75 | + version = await app.Services.GetRequiredService<GitCli>().GetVersionAsync(ct); | |
| 76 | + } | |
| 77 | + catch (GitException ex) | |
| 78 | + { | |
| 79 | + throw new ForgeStartupException( | |
| 80 | + $"Git is required but could not be run. {ex.Message} " | |
| 81 | + + "Install git or set Forge:GitPath to the git executable."); | |
| 82 | + } | |
| 83 | + | |
| 84 | + if (version < MinimumGitVersion) | |
| 85 | + { | |
| 86 | + throw new ForgeStartupException( | |
| 87 | + $"Git {version} is too old; Forge needs git {MinimumGitVersion} or newer."); | |
| 88 | + } | |
| 89 | + | |
| 90 | + await using var scope = app.Services.CreateAsyncScope(); | |
| 91 | + await scope.ServiceProvider.GetRequiredService<ForgeDb>().Database.MigrateAsync(ct); | |
| 92 | + | |
| 93 | + app.Logger.LogInformation("Forge data in {DataRoot}, git {GitVersion}", options.DataRoot, version); | |
| 94 | + } | |
| 95 | + | |
| 96 | + private static void ConfigureServices(WebApplicationBuilder builder) | |
| 97 | + { | |
| 98 | + var services = builder.Services; | |
| 99 | + | |
| 100 | + services.AddOptions<ForgeOptions>() | |
| 101 | + .Bind(builder.Configuration.GetSection(ForgeOptions.SectionName)) | |
| 102 | + .ValidateDataAnnotations() | |
| 103 | + .ValidateOnStart(); | |
| 104 | + services.AddSingleton<IValidateOptions<ForgeOptions>, ForgeOptionsValidator>(); | |
| 105 | + | |
| 106 | + services.AddDbContext<ForgeDb>((provider, options) => | |
| 107 | + ForgeDb.Configure(options, provider.GetRequiredService<IOptions<ForgeOptions>>().Value.DatabasePath)); | |
| 108 | + | |
| 109 | + // Language of a request: the visitor's saved choice, else the browser's Accept-Language, else English. | |
| 110 | + var translations = new Translations(); | |
| 111 | + services.AddSingleton(translations); | |
| 112 | + services.AddSingleton<Localizer>(); | |
| 113 | + services.Configure<RequestLocalizationOptions>(options => | |
| 114 | + { | |
| 115 | + var languages = translations.Languages.ToArray(); | |
| 116 | + options.SetDefaultCulture(Translations.DefaultLanguage); | |
| 117 | + options.AddSupportedCultures(languages); | |
| 118 | + options.AddSupportedUICultures(languages); | |
| 119 | + options.RequestCultureProviders = | |
| 120 | + [ | |
| 121 | + new CookieRequestCultureProvider { CookieName = LanguageCookie }, | |
| 122 | + new AcceptLanguageHeaderRequestCultureProvider(), | |
| 123 | + ]; | |
| 124 | + }); | |
| 125 | + | |
| 126 | + services.AddSingleton(TimeProvider.System); | |
| 127 | + services.AddSingleton<GitCli>(); | |
| 128 | + services.AddSingleton<GitRepo>(); | |
| 129 | + services.AddSingleton<RefResolver>(); | |
| 130 | + services.AddSingleton<RepoPaths>(); | |
| 131 | + services.AddSingleton<ContentCache>(); | |
| 132 | + services.AddSingleton<RepoInsights>(); | |
| 133 | + services.AddSingleton<MarkdownRenderer>(); | |
| 134 | + services.AddSingleton<PushLocks>(); | |
| 135 | + services.AddSingleton<AuthFailureLimiter>(); | |
| 136 | + services.AddSingleton<IPasswordHasher<User>, PasswordHasher<User>>(); | |
| 137 | + | |
| 138 | + services.AddHttpContextAccessor(); | |
| 139 | + services.AddScoped<CurrentUser>(); | |
| 140 | + services.AddScoped<TokenService>(); | |
| 141 | + services.AddScoped<RepoService>(); | |
| 142 | + services.AddScoped<PushRecorder>(); | |
| 143 | + services.AddScoped<RefService>(); | |
| 144 | + services.AddScoped<PullRequestService>(); | |
| 145 | + services.AddScoped<SmartHttpHandler>(); | |
| 146 | + | |
| 147 | + services.AddSingleton<WebhookQueue>(); | |
| 148 | + services.AddSingleton<WebhookSender>(); | |
| 149 | + services.AddHostedService<WebhookWorker>(); | |
| 150 | + services.AddHttpClient(WebhookSender.HttpClientName) | |
| 151 | + .ConfigurePrimaryHttpMessageHandler(() => new SocketsHttpHandler | |
| 152 | + { | |
| 153 | + // A receiver must answer itself; following redirects would re-send the signed body elsewhere. | |
| 154 | + AllowAutoRedirect = false, | |
| 155 | + ConnectTimeout = WebhookSender.Timeout, | |
| 156 | + }); | |
| 157 | + | |
| 158 | + var configured = builder.Configuration.GetSection(ForgeOptions.SectionName).Get<ForgeOptions>() ?? new ForgeOptions(); | |
| 159 | + var https = configured.IsHttps; | |
| 160 | + | |
| 161 | + // Keys that protect the session and CSRF cookies live with the rest of the data, so sessions | |
| 162 | + // survive restarts and container rebuilds, and backing up DataPath covers them too. | |
| 163 | + services.AddDataProtection() | |
| 164 | + .SetApplicationName("forge") | |
| 165 | + .PersistKeysToFileSystem(new DirectoryInfo(Path.Combine(configured.DataRoot, "keys"))); | |
| 166 | + | |
| 167 | + services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme) | |
| 168 | + .AddCookie(options => | |
| 169 | + { | |
| 170 | + options.Cookie.Name = "forge_session"; | |
| 171 | + options.Cookie.HttpOnly = true; | |
| 172 | + options.Cookie.SameSite = SameSiteMode.Lax; | |
| 173 | + // Secure whenever the site is served over HTTPS. Plain-HTTP development still works. | |
| 174 | + options.Cookie.SecurePolicy = https ? CookieSecurePolicy.Always : CookieSecurePolicy.SameAsRequest; | |
| 175 | + options.LoginPath = "/login"; | |
| 176 | + options.AccessDeniedPath = "/login"; | |
| 177 | + options.ReturnUrlParameter = "returnUrl"; | |
| 178 | + options.ExpireTimeSpan = TimeSpan.FromDays(30); | |
| 179 | + options.SlidingExpiration = true; | |
| 180 | + options.Events.OnValidatePrincipal = RejectUnknownUserAsync; | |
| 181 | + }); | |
| 182 | + services.AddAuthorization(); | |
| 183 | + services.AddAntiforgery(options => | |
| 184 | + { | |
| 185 | + options.Cookie.Name = "forge_csrf"; | |
| 186 | + options.Cookie.SecurePolicy = https ? CookieSecurePolicy.Always : CookieSecurePolicy.SameAsRequest; | |
| 187 | + }); | |
| 188 | + | |
| 189 | + services.AddRateLimiter(options => | |
| 190 | + { | |
| 191 | + options.RejectionStatusCode = StatusCodes.Status429TooManyRequests; | |
| 192 | + // Fixed window per client address. Only form posts count, so reading the page is never limited. | |
| 193 | + options.AddPolicy(LoginRateLimit, context => | |
| 194 | + HttpMethods.IsPost(context.Request.Method) | |
| 195 | + ? RateLimitPartition.GetFixedWindowLimiter( | |
| 196 | + context.Connection.RemoteIpAddress?.ToString() ?? "unknown", | |
| 197 | + _ => new FixedWindowRateLimiterOptions | |
| 198 | + { | |
| 199 | + PermitLimit = 10, | |
| 200 | + Window = TimeSpan.FromMinutes(1), | |
| 201 | + QueueLimit = 0, | |
| 202 | + }) | |
| 203 | + : RateLimitPartition.GetNoLimiter("read")); | |
| 204 | + }); | |
| 205 | + | |
| 206 | + services.AddRazorComponents(); | |
| 207 | + } | |
| 208 | + | |
| 209 | + private static void ConfigurePipeline(WebApplication app) | |
| 210 | + { | |
| 211 | + if (!app.Environment.IsDevelopment()) | |
| 212 | + { | |
| 213 | + app.UseExceptionHandler("/error", createScopeForErrors: true); | |
| 214 | + } | |
| 215 | + | |
| 216 | + app.Use(async (context, next) => | |
| 217 | + { | |
| 218 | + var headers = context.Response.Headers; | |
| 219 | + headers.XContentTypeOptions = "nosniff"; | |
| 220 | + headers.XFrameOptions = "DENY"; | |
| 221 | + headers["Referrer-Policy"] = "same-origin"; | |
| 222 | + headers.ContentSecurityPolicy = ContentSecurityPolicy; | |
| 223 | + await next(); | |
| 224 | + }); | |
| 225 | + | |
| 226 | + app.UseStatusCodePagesWithReExecute("/status/{0}", createScopeForStatusCodePages: true); | |
| 227 | + // Static files go before routing. Otherwise /style.css matches the /{owner} page route, | |
| 228 | + // and the static file middleware steps aside for a request that already has an endpoint. | |
| 229 | + app.UseStaticFiles(); | |
| 230 | + app.UseRequestLocalization(); | |
| 231 | + app.UseRouting(); | |
| 232 | + | |
| 233 | + app.UseAuthentication(); | |
| 234 | + app.UseAuthorization(); | |
| 235 | + app.UseRateLimiter(); | |
| 236 | + app.UseAntiforgery(); | |
| 237 | + | |
| 238 | + app.MapSmartHttp(); | |
| 239 | + app.MapRaw(); | |
| 240 | + app.MapAtom(); | |
| 241 | + | |
| 242 | + // [FromForm] makes the antiforgery middleware validate the token posted by the layout's form. | |
| 243 | + app.MapPost("/logout", async (HttpContext context, [FromForm] string? returnUrl) => | |
| 244 | + { | |
| 245 | + await context.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme); | |
| 246 | + return Results.LocalRedirect(CurrentUser.SafeReturnUrl(returnUrl)); | |
| 247 | + }); | |
| 248 | + | |
| 249 | + // The language switcher in the page footer. Remembers the choice for a year. | |
| 250 | + app.MapPost("/language", ( | |
| 251 | + HttpContext context, | |
| 252 | + [FromForm] string? lang, | |
| 253 | + [FromForm] string? returnUrl, | |
| 254 | + Translations translations, | |
| 255 | + IOptions<ForgeOptions> options) => | |
| 256 | + { | |
| 257 | + var language = translations.Languages.FirstOrDefault(l => string.Equals(l, lang, StringComparison.OrdinalIgnoreCase)); | |
| 258 | + if (language is not null) | |
| 259 | + { | |
| 260 | + context.Response.Cookies.Append( | |
| 261 | + LanguageCookie, | |
| 262 | + CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(language)), | |
| 263 | + new CookieOptions | |
| 264 | + { | |
| 265 | + MaxAge = TimeSpan.FromDays(365), | |
| 266 | + HttpOnly = true, | |
| 267 | + IsEssential = true, | |
| 268 | + SameSite = SameSiteMode.Lax, | |
| 269 | + Secure = options.Value.IsHttps, | |
| 270 | + Path = "/", | |
| 271 | + }); | |
| 272 | + } | |
| 273 | + | |
| 274 | + return Results.LocalRedirect(CurrentUser.SafeReturnUrl(returnUrl)); | |
| 275 | + }); | |
| 276 | + | |
| 277 | + app.MapRazorComponents<App>(); | |
| 278 | + } | |
| 279 | + | |
| 280 | + /// <summary>A cookie for a user that no longer exists (fresh database, deleted account) is not a session.</summary> | |
| 281 | + private static async Task RejectUnknownUserAsync(CookieValidatePrincipalContext context) | |
| 282 | + { | |
| 283 | + var db = context.HttpContext.RequestServices.GetRequiredService<ForgeDb>(); | |
| 284 | + var idText = context.Principal?.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value; | |
| 285 | + if (!long.TryParse(idText, out var id) || !await db.Users.AnyAsync(u => u.Id == id)) | |
| 286 | + { | |
| 287 | + context.RejectPrincipal(); | |
| 288 | + await context.HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme); | |
| 289 | + } | |
| 290 | + } | |
| 291 | +} |
added forge/ForgeOptions.cs +46 −0View file
| @@ -0,0 +1,46 @@ | ||
| 1 | +using System.ComponentModel.DataAnnotations; | |
| 2 | +using Microsoft.Extensions.Options; | |
| 3 | + | |
| 4 | +namespace Forge; | |
| 5 | + | |
| 6 | +public sealed class ForgeOptions | |
| 7 | +{ | |
| 8 | + public const string SectionName = "Forge"; | |
| 9 | + | |
| 10 | + /// <summary>Directory holding forge.db and repos/. Relative paths resolve against the working directory.</summary> | |
| 11 | + [Required] | |
| 12 | + public string DataPath { get; set; } = "data"; | |
| 13 | + | |
| 14 | + /// <summary>Public URL of the app, used for clone URLs, feeds and webhook payloads.</summary> | |
| 15 | + [Required] | |
| 16 | + public string BaseUrl { get; set; } = "http://localhost:5207"; | |
| 17 | + | |
| 18 | + [Range(1, 102_400)] | |
| 19 | + public int MaxPushSizeMb { get; set; } = 500; | |
| 20 | + | |
| 21 | + /// <summary>Git executable: a name resolved through PATH or an absolute path.</summary> | |
| 22 | + [Required] | |
| 23 | + public string GitPath { get; set; } = "git"; | |
| 24 | + | |
| 25 | + public string DataRoot => Path.GetFullPath(DataPath); | |
| 26 | + public string ReposRoot => Path.Combine(DataRoot, "repos"); | |
| 27 | + public string DatabasePath => Path.Combine(DataRoot, "forge.db"); | |
| 28 | + public string BaseUrlTrimmed => BaseUrl.TrimEnd('/'); | |
| 29 | + public bool IsHttps => BaseUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase); | |
| 30 | + public long MaxPushBytes => MaxPushSizeMb * 1024L * 1024L; | |
| 31 | +} | |
| 32 | + | |
| 33 | +public sealed class ForgeOptionsValidator : IValidateOptions<ForgeOptions> | |
| 34 | +{ | |
| 35 | + public ValidateOptionsResult Validate(string? name, ForgeOptions options) | |
| 36 | + { | |
| 37 | + if (!Uri.TryCreate(options.BaseUrl, UriKind.Absolute, out var uri) | |
| 38 | + || (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)) | |
| 39 | + { | |
| 40 | + return ValidateOptionsResult.Fail( | |
| 41 | + $"Forge:BaseUrl must be an absolute http(s) URL, got '{options.BaseUrl}'."); | |
| 42 | + } | |
| 43 | + | |
| 44 | + return ValidateOptionsResult.Success; | |
| 45 | + } | |
| 46 | +} |
added forge/Format.cs +23 −0View file
| @@ -0,0 +1,23 @@ | ||
| 1 | +using System.Globalization; | |
| 2 | + | |
| 3 | +namespace Forge; | |
| 4 | + | |
| 5 | +/// <summary>Formatting that follows the language of the current request (<see cref="CultureInfo.CurrentCulture"/>).</summary> | |
| 6 | +public static class Format | |
| 7 | +{ | |
| 8 | + public static string ExactTime(DateTimeOffset value) => | |
| 9 | + value.ToUniversalTime().ToString("d MMM yyyy HH:mm", CultureInfo.CurrentCulture) + " UTC"; | |
| 10 | + | |
| 11 | + public static string IsoTime(DateTimeOffset value) => | |
| 12 | + value.ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture); | |
| 13 | + | |
| 14 | + public static DateTimeOffset Utc(DateTime value) => | |
| 15 | + new(DateTime.SpecifyKind(value, DateTimeKind.Utc)); | |
| 16 | + | |
| 17 | + public static string Size(long bytes) => bytes switch | |
| 18 | + { | |
| 19 | + < 1024 => $"{bytes} B", | |
| 20 | + < 1024 * 1024 => string.Create(CultureInfo.CurrentCulture, $"{bytes / 1024.0:0.#} kB"), | |
| 21 | + _ => string.Create(CultureInfo.CurrentCulture, $"{bytes / (1024.0 * 1024.0):0.#} MB"), | |
| 22 | + }; | |
| 23 | +} |
added forge/Git/GitCli.cs +288 −0View file
| @@ -0,0 +1,288 @@ | ||
| 1 | +using System.ComponentModel; | |
| 2 | +using System.Text; | |
| 3 | +using CliWrap; | |
| 4 | +using Microsoft.Extensions.Options; | |
| 5 | + | |
| 6 | +namespace Forge.Git; | |
| 7 | + | |
| 8 | +public sealed record GitResult(int ExitCode, byte[] StdOut, string StdErr, bool Truncated) | |
| 9 | +{ | |
| 10 | + public bool Ok => ExitCode == 0 && !Truncated; | |
| 11 | + public string Text => Encoding.UTF8.GetString(StdOut); | |
| 12 | +} | |
| 13 | + | |
| 14 | +/// <summary> | |
| 15 | +/// The only place that starts git processes. Every process gets an isolated environment, | |
| 16 | +/// a timeout, and is killed when the caller cancels. | |
| 17 | +/// </summary> | |
| 18 | +public sealed class GitCli | |
| 19 | +{ | |
| 20 | + public static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(30); | |
| 21 | + | |
| 22 | + /// <summary>Clone and push can legitimately run long; they still must not run forever.</summary> | |
| 23 | + public static readonly TimeSpan TransportTimeout = TimeSpan.FromHours(2); | |
| 24 | + | |
| 25 | + public const long DefaultMaxOutputBytes = 32 * 1024 * 1024; | |
| 26 | + | |
| 27 | + private readonly string _gitPath; | |
| 28 | + private readonly string _workDir; | |
| 29 | + | |
| 30 | + /// <summary>The data directory; git processes run here and scratch files go below it.</summary> | |
| 31 | + public string WorkDirectory => _workDir; | |
| 32 | + private readonly Dictionary<string, string?> _environment; | |
| 33 | + | |
| 34 | + public GitCli(IOptions<ForgeOptions> options) | |
| 35 | + { | |
| 36 | + var o = options.Value; | |
| 37 | + _gitPath = o.GitPath; | |
| 38 | + _workDir = o.DataRoot; | |
| 39 | + _environment = new Dictionary<string, string?>(StringComparer.Ordinal) | |
| 40 | + { | |
| 41 | + // Isolation: no system config, no config from the real home directory, never prompt. | |
| 42 | + ["GIT_CONFIG_NOSYSTEM"] = "1", | |
| 43 | + ["HOME"] = o.DataRoot, | |
| 44 | + ["XDG_CONFIG_HOME"] = Path.Combine(o.DataRoot, ".config"), | |
| 45 | + ["GIT_TERMINAL_PROMPT"] = "0", | |
| 46 | + // Paths from URLs are plain paths, never pathspec magic such as ":(glob)". | |
| 47 | + ["GIT_LITERAL_PATHSPECS"] = "1", | |
| 48 | + ["GIT_OPTIONAL_LOCKS"] = "0", | |
| 49 | + ["LC_ALL"] = "C", | |
| 50 | + // Nothing inherited from the server's own environment may redirect git elsewhere. | |
| 51 | + ["GIT_DIR"] = null, | |
| 52 | + ["GIT_WORK_TREE"] = null, | |
| 53 | + ["GIT_INDEX_FILE"] = null, | |
| 54 | + ["GIT_OBJECT_DIRECTORY"] = null, | |
| 55 | + ["GIT_ALTERNATE_OBJECT_DIRECTORIES"] = null, | |
| 56 | + ["GIT_NAMESPACE"] = null, | |
| 57 | + ["GIT_CONFIG_GLOBAL"] = null, | |
| 58 | + ["GIT_CONFIG_PARAMETERS"] = null, | |
| 59 | + ["GIT_CONFIG_COUNT"] = null, | |
| 60 | + ["GIT_PROTOCOL"] = null, | |
| 61 | + }; | |
| 62 | + } | |
| 63 | + | |
| 64 | + /// <summary>Runs git and buffers stdout. Pass <paramref name="repoPath"/> as null for commands outside a repo.</summary> | |
| 65 | + public async Task<GitResult> RunAsync( | |
| 66 | + string? repoPath, | |
| 67 | + IEnumerable<string> args, | |
| 68 | + Stream? stdin = null, | |
| 69 | + CancellationToken ct = default, | |
| 70 | + TimeSpan? timeout = null, | |
| 71 | + long maxOutputBytes = DefaultMaxOutputBytes, | |
| 72 | + bool throwOnError = true, | |
| 73 | + IReadOnlyDictionary<string, string?>? extraEnvironment = null) | |
| 74 | + { | |
| 75 | + var fullArgs = BuildArgs(repoPath, args); | |
| 76 | + var limit = timeout ?? DefaultTimeout; | |
| 77 | + var environment = MergeEnvironment(extraEnvironment); | |
| 78 | + | |
| 79 | + using var timeoutCts = new CancellationTokenSource(limit); | |
| 80 | + using var capCts = new CancellationTokenSource(); | |
| 81 | + using var linked = CancellationTokenSource.CreateLinkedTokenSource(ct, timeoutCts.Token, capCts.Token); | |
| 82 | + | |
| 83 | + await using var stdout = new CappedBuffer(maxOutputBytes, capCts); | |
| 84 | + var stderr = new StringBuilder(); | |
| 85 | + | |
| 86 | + var command = Cli.Wrap(_gitPath) | |
| 87 | + .WithArguments(fullArgs) | |
| 88 | + .WithWorkingDirectory(_workDir) | |
| 89 | + .WithEnvironmentVariables(environment) | |
| 90 | + .WithStandardInputPipe(stdin is null ? PipeSource.Null : PipeSource.FromStream(stdin)) | |
| 91 | + .WithStandardOutputPipe(PipeTarget.ToStream(stdout)) | |
| 92 | + .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stderr)) | |
| 93 | + .WithValidation(CommandResultValidation.None); | |
| 94 | + | |
| 95 | + try | |
| 96 | + { | |
| 97 | + var result = await command.ExecuteAsync(linked.Token); | |
| 98 | + if (result.ExitCode != 0 && throwOnError && !stdout.Truncated) | |
| 99 | + { | |
| 100 | + throw new GitException( | |
| 101 | + $"git {Describe(fullArgs)} exited with code {result.ExitCode}: {stderr.ToString().Trim()}", | |
| 102 | + result.ExitCode, | |
| 103 | + stderr.ToString()); | |
| 104 | + } | |
| 105 | + | |
| 106 | + return new GitResult(result.ExitCode, stdout.ToArray(), stderr.ToString(), stdout.Truncated); | |
| 107 | + } | |
| 108 | + catch (OperationCanceledException) when (!ct.IsCancellationRequested && stdout.Truncated) | |
| 109 | + { | |
| 110 | + // Output went over the cap, so the process was killed on purpose. | |
| 111 | + return new GitResult(-1, stdout.ToArray(), stderr.ToString(), Truncated: true); | |
| 112 | + } | |
| 113 | + catch (OperationCanceledException) when (!ct.IsCancellationRequested && timeoutCts.IsCancellationRequested) | |
| 114 | + { | |
| 115 | + throw new GitTimeoutException($"git {Describe(fullArgs)} did not finish within {limit.TotalSeconds:0} s and was killed."); | |
| 116 | + } | |
| 117 | + } | |
| 118 | + | |
| 119 | + /// <summary>Runs git with caller-supplied pipes, for output that must not be buffered.</summary> | |
| 120 | + public async Task<(int ExitCode, string StdErr)> StreamAsync( | |
| 121 | + string? repoPath, | |
| 122 | + IEnumerable<string> args, | |
| 123 | + PipeSource stdin, | |
| 124 | + PipeTarget stdout, | |
| 125 | + IReadOnlyDictionary<string, string?>? extraEnvironment = null, | |
| 126 | + TimeSpan? timeout = null, | |
| 127 | + CancellationToken ct = default) | |
| 128 | + { | |
| 129 | + var fullArgs = BuildArgs(repoPath, args); | |
| 130 | + var limit = timeout ?? DefaultTimeout; | |
| 131 | + | |
| 132 | + var environment = MergeEnvironment(extraEnvironment); | |
| 133 | + | |
| 134 | + using var timeoutCts = new CancellationTokenSource(limit); | |
| 135 | + using var linked = CancellationTokenSource.CreateLinkedTokenSource(ct, timeoutCts.Token); | |
| 136 | + var stderr = new StringBuilder(); | |
| 137 | + | |
| 138 | + var command = Cli.Wrap(_gitPath) | |
| 139 | + .WithArguments(fullArgs) | |
| 140 | + .WithWorkingDirectory(_workDir) | |
| 141 | + .WithEnvironmentVariables(environment) | |
| 142 | + .WithStandardInputPipe(stdin) | |
| 143 | + .WithStandardOutputPipe(stdout) | |
| 144 | + .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stderr)) | |
| 145 | + .WithValidation(CommandResultValidation.None); | |
| 146 | + | |
| 147 | + try | |
| 148 | + { | |
| 149 | + var result = await command.ExecuteAsync(linked.Token); | |
| 150 | + return (result.ExitCode, stderr.ToString()); | |
| 151 | + } | |
| 152 | + catch (OperationCanceledException) when (!ct.IsCancellationRequested && timeoutCts.IsCancellationRequested) | |
| 153 | + { | |
| 154 | + throw new GitTimeoutException($"git {Describe(fullArgs)} did not finish within {limit.TotalMinutes:0} min and was killed."); | |
| 155 | + } | |
| 156 | + } | |
| 157 | + | |
| 158 | + /// <summary>Returns the installed git version, or throws with a message suitable for the startup log.</summary> | |
| 159 | + public async Task<Version> GetVersionAsync(CancellationToken ct = default) | |
| 160 | + { | |
| 161 | + GitResult result; | |
| 162 | + try | |
| 163 | + { | |
| 164 | + result = await RunAsync(null, ["--version"], ct: ct, throwOnError: false); | |
| 165 | + } | |
| 166 | + catch (Exception ex) when (ex is Win32Exception or FileNotFoundException or InvalidOperationException) | |
| 167 | + { | |
| 168 | + throw new GitException($"Could not start git ('{_gitPath}'): {ex.Message}", -1, ""); | |
| 169 | + } | |
| 170 | + | |
| 171 | + var version = result.ExitCode == 0 ? GitParsers.ParseVersion(result.Text) : null; | |
| 172 | + return version ?? throw new GitException( | |
| 173 | + $"'{_gitPath} --version' did not report a git version (exit code {result.ExitCode}): {result.Text.Trim()} {result.StdErr.Trim()}", | |
| 174 | + result.ExitCode, | |
| 175 | + result.StdErr); | |
| 176 | + } | |
| 177 | + | |
| 178 | + private Dictionary<string, string?> MergeEnvironment(IReadOnlyDictionary<string, string?>? extra) | |
| 179 | + { | |
| 180 | + if (extra is not { Count: > 0 }) | |
| 181 | + { | |
| 182 | + return _environment; | |
| 183 | + } | |
| 184 | + | |
| 185 | + var merged = new Dictionary<string, string?>(_environment, StringComparer.Ordinal); | |
| 186 | + foreach (var (key, value) in extra) | |
| 187 | + { | |
| 188 | + merged[key] = value; | |
| 189 | + } | |
| 190 | + | |
| 191 | + return merged; | |
| 192 | + } | |
| 193 | + | |
| 194 | + private static List<string> BuildArgs(string? repoPath, IEnumerable<string> args) | |
| 195 | + { | |
| 196 | + var list = new List<string>(); | |
| 197 | + if (repoPath is not null) | |
| 198 | + { | |
| 199 | + list.Add("--git-dir=" + repoPath); | |
| 200 | + } | |
| 201 | + | |
| 202 | + // Print non-ASCII paths as UTF-8 instead of octal escapes. | |
| 203 | + list.Add("-c"); | |
| 204 | + list.Add("core.quotePath=false"); | |
| 205 | + list.AddRange(args); | |
| 206 | + return list; | |
| 207 | + } | |
| 208 | + | |
| 209 | + private static string Describe(List<string> args) | |
| 210 | + { | |
| 211 | + var text = string.Join(' ', args.Where(a => !a.StartsWith("--git-dir=", StringComparison.Ordinal))); | |
| 212 | + return text.Length > 200 ? text[..200] + "…" : text; | |
| 213 | + } | |
| 214 | + | |
| 215 | + /// <summary>Collects process output up to a cap, then cancels the run instead of growing without bound.</summary> | |
| 216 | + private sealed class CappedBuffer(long cap, CancellationTokenSource onOverflow) : Stream | |
| 217 | + { | |
| 218 | + private readonly MemoryStream _buffer = new(); | |
| 219 | + | |
| 220 | + public bool Truncated { get; private set; } | |
| 221 | + | |
| 222 | + public byte[] ToArray() => _buffer.ToArray(); | |
| 223 | + | |
| 224 | + public override void Write(byte[] buffer, int offset, int count) => Write(buffer.AsSpan(offset, count)); | |
| 225 | + | |
| 226 | + public override void Write(ReadOnlySpan<byte> buffer) | |
| 227 | + { | |
| 228 | + var room = cap - _buffer.Length; | |
| 229 | + if (room >= buffer.Length) | |
| 230 | + { | |
| 231 | + _buffer.Write(buffer); | |
| 232 | + return; | |
| 233 | + } | |
| 234 | + | |
| 235 | + if (room > 0) | |
| 236 | + { | |
| 237 | + _buffer.Write(buffer[..(int)room]); | |
| 238 | + } | |
| 239 | + | |
| 240 | + if (!Truncated) | |
| 241 | + { | |
| 242 | + Truncated = true; | |
| 243 | + onOverflow.Cancel(); | |
| 244 | + } | |
| 245 | + } | |
| 246 | + | |
| 247 | + public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) | |
| 248 | + { | |
| 249 | + Write(buffer.AsSpan(offset, count)); | |
| 250 | + return Task.CompletedTask; | |
| 251 | + } | |
| 252 | + | |
| 253 | + public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) | |
| 254 | + { | |
| 255 | + Write(buffer.Span); | |
| 256 | + return ValueTask.CompletedTask; | |
| 257 | + } | |
| 258 | + | |
| 259 | + public override void Flush() | |
| 260 | + { | |
| 261 | + } | |
| 262 | + | |
| 263 | + public override bool CanRead => false; | |
| 264 | + public override bool CanSeek => false; | |
| 265 | + public override bool CanWrite => true; | |
| 266 | + public override long Length => _buffer.Length; | |
| 267 | + | |
| 268 | + public override long Position | |
| 269 | + { | |
| 270 | + get => _buffer.Length; | |
| 271 | + set => throw new NotSupportedException(); | |
| 272 | + } | |
| 273 | + | |
| 274 | + public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException(); | |
| 275 | + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); | |
| 276 | + public override void SetLength(long value) => throw new NotSupportedException(); | |
| 277 | + | |
| 278 | + protected override void Dispose(bool disposing) | |
| 279 | + { | |
| 280 | + if (disposing) | |
| 281 | + { | |
| 282 | + _buffer.Dispose(); | |
| 283 | + } | |
| 284 | + | |
| 285 | + base.Dispose(disposing); | |
| 286 | + } | |
| 287 | + } | |
| 288 | +} |
added forge/Git/GitModels.cs +137 −0View file
| @@ -0,0 +1,137 @@ | ||
| 1 | +using System.Text; | |
| 2 | + | |
| 3 | +namespace Forge.Git; | |
| 4 | + | |
| 5 | +public enum RefKind | |
| 6 | +{ | |
| 7 | + Branch, | |
| 8 | + Tag, | |
| 9 | + Other, | |
| 10 | +} | |
| 11 | + | |
| 12 | +/// <param name="FullName">For example refs/heads/feature/x.</param> | |
| 13 | +/// <param name="Name">Short name, for example feature/x.</param> | |
| 14 | +/// <param name="Sha">Object the ref points at (a tag object for annotated tags).</param> | |
| 15 | +/// <param name="ObjectType">commit, tag, tree or blob.</param> | |
| 16 | +/// <param name="PeeledSha">For annotated tags, the object the tag points at.</param> | |
| 17 | +public sealed record GitRef( | |
| 18 | + string FullName, | |
| 19 | + string Name, | |
| 20 | + RefKind Kind, | |
| 21 | + string Sha, | |
| 22 | + string ObjectType, | |
| 23 | + string? PeeledSha, | |
| 24 | + DateTimeOffset? Date, | |
| 25 | + string Subject) | |
| 26 | +{ | |
| 27 | + public string TargetSha => PeeledSha ?? Sha; | |
| 28 | +} | |
| 29 | + | |
| 30 | +public sealed record TreeEntry(string Name, string Mode, string Type, string Sha, long? Size) | |
| 31 | +{ | |
| 32 | + public bool IsTree => Type == "tree"; | |
| 33 | + public bool IsBlob => Type == "blob"; | |
| 34 | + public bool IsSubmodule => Type == "commit"; | |
| 35 | + public bool IsSymlink => Mode == "120000"; | |
| 36 | +} | |
| 37 | + | |
| 38 | +/// <summary>A file anywhere in a commit's tree, with its path from the repository root.</summary> | |
| 39 | +public sealed record FileEntry(string Path, long Size); | |
| 40 | + | |
| 41 | +/// <summary>One line found by a content search.</summary> | |
| 42 | +public sealed record GrepMatch(string Path, int Line, string Text); | |
| 43 | + | |
| 44 | +public sealed record CommitInfo( | |
| 45 | + string Sha, | |
| 46 | + IReadOnlyList<string> Parents, | |
| 47 | + string AuthorName, | |
| 48 | + string AuthorEmail, | |
| 49 | + DateTimeOffset AuthorDate, | |
| 50 | + string CommitterName, | |
| 51 | + string CommitterEmail, | |
| 52 | + DateTimeOffset CommitDate, | |
| 53 | + string Subject, | |
| 54 | + string Body, | |
| 55 | + string AuthorDateRaw = "") | |
| 56 | +{ | |
| 57 | + public string ShortSha => Sha.Length > 8 ? Sha[..8] : Sha; | |
| 58 | +} | |
| 59 | + | |
| 60 | +public sealed record BlobContent(byte[] Bytes, bool Truncated) | |
| 61 | +{ | |
| 62 | + public bool IsBinary => GitParsers.IsBinary(Bytes); | |
| 63 | + public string Text => Encoding.UTF8.GetString(Bytes); | |
| 64 | +} | |
| 65 | + | |
| 66 | +public enum FileChange | |
| 67 | +{ | |
| 68 | + Modified, | |
| 69 | + Added, | |
| 70 | + Deleted, | |
| 71 | + Renamed, | |
| 72 | + Copied, | |
| 73 | +} | |
| 74 | + | |
| 75 | +/// <summary>One row of `--numstat`. Counts are null for binary files.</summary> | |
| 76 | +public sealed record FileStat(string Path, string? OldPath, int? Added, int? Deleted) | |
| 77 | +{ | |
| 78 | + public bool IsBinary => Added is null; | |
| 79 | +} | |
| 80 | + | |
| 81 | +public enum DiffLineKind | |
| 82 | +{ | |
| 83 | + Context, | |
| 84 | + Added, | |
| 85 | + Deleted, | |
| 86 | + NoNewline, | |
| 87 | +} | |
| 88 | + | |
| 89 | +public sealed record DiffLine(DiffLineKind Kind, int? OldNumber, int? NewNumber, string Text); | |
| 90 | + | |
| 91 | +public sealed class DiffHunk | |
| 92 | +{ | |
| 93 | + public required string Header { get; init; } | |
| 94 | + public List<DiffLine> Lines { get; } = []; | |
| 95 | +} | |
| 96 | + | |
| 97 | +public sealed class FileDiff | |
| 98 | +{ | |
| 99 | + public string OldPath { get; set; } = ""; | |
| 100 | + public string NewPath { get; set; } = ""; | |
| 101 | + public FileChange Change { get; set; } = FileChange.Modified; | |
| 102 | + public bool IsBinary { get; set; } | |
| 103 | + | |
| 104 | + /// <summary>The file went over the per-file line limit; its hunks were dropped.</summary> | |
| 105 | + public bool TooLarge { get; set; } | |
| 106 | + | |
| 107 | + public int Added { get; set; } | |
| 108 | + public int Deleted { get; set; } | |
| 109 | + public List<DiffHunk> Hunks { get; } = []; | |
| 110 | + | |
| 111 | + public string DisplayPath => Change == FileChange.Deleted ? OldPath : NewPath; | |
| 112 | +} | |
| 113 | + | |
| 114 | +/// <param name="Truncated">The diff went over a limit (files, or bytes read from git) and is incomplete.</param> | |
| 115 | +public sealed record ParsedDiff(IReadOnlyList<FileDiff> Files, bool Truncated); | |
| 116 | + | |
| 117 | +public sealed record CommitDiff(IReadOnlyList<FileStat> Stats, ParsedDiff Patch); | |
| 118 | + | |
| 119 | +public sealed record GitIdentity(string Name, string Email); | |
| 120 | + | |
| 121 | +/// <summary>Outcome of a tree-level merge.</summary> | |
| 122 | +/// <param name="TreeSha">The merged tree when the merge was clean; otherwise null.</param> | |
| 123 | +/// <param name="ConflictTreeSha">On conflict, a tree in which the conflicted files carry conflict markers.</param> | |
| 124 | +/// <param name="Conflicts">Paths that could not be merged automatically.</param> | |
| 125 | +/// <param name="Error">Set when git could not attempt the merge at all (for example unrelated histories).</param> | |
| 126 | +public sealed record MergeTreeResult(string? TreeSha, IReadOnlyList<string> Conflicts, string? Error, string? ConflictTreeSha = null) | |
| 127 | +{ | |
| 128 | + public bool IsClean => TreeSha is not null; | |
| 129 | +} | |
| 130 | + | |
| 131 | +public class GitException(string message, int exitCode, string stdErr) : Exception(message) | |
| 132 | +{ | |
| 133 | + public int ExitCode { get; } = exitCode; | |
| 134 | + public string StdErr { get; } = stdErr; | |
| 135 | +} | |
| 136 | + | |
| 137 | +public sealed class GitTimeoutException(string message) : Exception(message); |
added forge/Git/GitParsers.cs +609 −0View file
| @@ -0,0 +1,609 @@ | ||
| 1 | +using System.Globalization; | |
| 2 | +using System.Text; | |
| 3 | +using System.Text.RegularExpressions; | |
| 4 | + | |
| 5 | +namespace Forge.Git; | |
| 6 | + | |
| 7 | +/// <summary>Pure parsers for git plumbing output. No process access, so they are testable with canned input.</summary> | |
| 8 | +public static partial class GitParsers | |
| 9 | +{ | |
| 10 | + public const string ZeroSha = "0000000000000000000000000000000000000000"; | |
| 11 | + | |
| 12 | + /// <summary>for-each-ref format matching <see cref="ParseRefs"/>. %00 is a NUL in for-each-ref formats.</summary> | |
| 13 | + public const string RefFormat = | |
| 14 | + "%(refname)%00%(objectname)%00%(objecttype)%00%(*objectname)%00%(creatordate:unix)%00%(contents:subject)"; | |
| 15 | + | |
| 16 | + /// <summary>log/show format matching <see cref="ParseLog"/>: ten fields, each terminated by NUL.</summary> | |
| 17 | + public const string LogFormat = | |
| 18 | + "%H%x00%P%x00%an%x00%ae%x00%ad%x00%cn%x00%ce%x00%ct%x00%s%x00%b%x00"; | |
| 19 | + | |
| 20 | + private const int LogFieldCount = 10; | |
| 21 | + | |
| 22 | + public const int MaxDiffFiles = 300; | |
| 23 | + public const int MaxDiffLinesPerFile = 1000; | |
| 24 | + | |
| 25 | + public static bool IsFullSha(string? value) => value is { Length: 40 } && IsHex(value); | |
| 26 | + | |
| 27 | + public static bool IsHex(string value) | |
| 28 | + { | |
| 29 | + foreach (var c in value) | |
| 30 | + { | |
| 31 | + if (!char.IsAsciiHexDigit(c)) | |
| 32 | + { | |
| 33 | + return false; | |
| 34 | + } | |
| 35 | + } | |
| 36 | + | |
| 37 | + return value.Length > 0; | |
| 38 | + } | |
| 39 | + | |
| 40 | + /// <summary>Same heuristic as git: a NUL byte in the first 8000 bytes means binary.</summary> | |
| 41 | + public static bool IsBinary(ReadOnlySpan<byte> content) | |
| 42 | + { | |
| 43 | + var head = content.Length > 8000 ? content[..8000] : content; | |
| 44 | + return head.Contains((byte)0); | |
| 45 | + } | |
| 46 | + | |
| 47 | + public static Version? ParseVersion(string output) | |
| 48 | + { | |
| 49 | + var match = VersionPattern().Match(output); | |
| 50 | + return match.Success | |
| 51 | + ? new Version(int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture), | |
| 52 | + int.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture)) | |
| 53 | + : null; | |
| 54 | + } | |
| 55 | + | |
| 56 | + public static IReadOnlyList<GitRef> ParseRefs(string output) | |
| 57 | + { | |
| 58 | + var refs = new List<GitRef>(); | |
| 59 | + foreach (var line in output.Split('\n', StringSplitOptions.RemoveEmptyEntries)) | |
| 60 | + { | |
| 61 | + var f = line.Split('\0'); | |
| 62 | + if (f.Length < 6) | |
| 63 | + { | |
| 64 | + continue; | |
| 65 | + } | |
| 66 | + | |
| 67 | + var fullName = f[0]; | |
| 68 | + var (kind, name) = fullName switch | |
| 69 | + { | |
| 70 | + _ when fullName.StartsWith("refs/heads/", StringComparison.Ordinal) => | |
| 71 | + (RefKind.Branch, fullName["refs/heads/".Length..]), | |
| 72 | + _ when fullName.StartsWith("refs/tags/", StringComparison.Ordinal) => | |
| 73 | + (RefKind.Tag, fullName["refs/tags/".Length..]), | |
| 74 | + _ => (RefKind.Other, fullName), | |
| 75 | + }; | |
| 76 | + | |
| 77 | + DateTimeOffset? date = long.TryParse(f[4], NumberStyles.Integer, CultureInfo.InvariantCulture, out var unix) | |
| 78 | + ? DateTimeOffset.FromUnixTimeSeconds(unix) | |
| 79 | + : null; | |
| 80 | + | |
| 81 | + refs.Add(new GitRef(fullName, name, kind, f[1], f[2], f[3].Length == 0 ? null : f[3], date, f[5])); | |
| 82 | + } | |
| 83 | + | |
| 84 | + return refs; | |
| 85 | + } | |
| 86 | + | |
| 87 | + /// <summary>Parses `for-each-ref --format=%(refname)%00%(objectname)` into name → sha.</summary> | |
| 88 | + public static Dictionary<string, string> ParseRefSnapshot(string output) | |
| 89 | + { | |
| 90 | + var map = new Dictionary<string, string>(StringComparer.Ordinal); | |
| 91 | + foreach (var line in output.Split('\n', StringSplitOptions.RemoveEmptyEntries)) | |
| 92 | + { | |
| 93 | + var sep = line.IndexOf('\0'); | |
| 94 | + if (sep > 0) | |
| 95 | + { | |
| 96 | + map[line[..sep]] = line[(sep + 1)..]; | |
| 97 | + } | |
| 98 | + } | |
| 99 | + | |
| 100 | + return map; | |
| 101 | + } | |
| 102 | + | |
| 103 | + /// <summary>Parses `ls-tree -z --long`: "mode SP type SP sha SP+ size TAB path NUL".</summary> | |
| 104 | + public static IReadOnlyList<TreeEntry> ParseTree(string output) | |
| 105 | + { | |
| 106 | + var entries = new List<TreeEntry>(); | |
| 107 | + foreach (var record in output.Split('\0', StringSplitOptions.RemoveEmptyEntries)) | |
| 108 | + { | |
| 109 | + var tab = record.IndexOf('\t'); | |
| 110 | + if (tab < 0) | |
| 111 | + { | |
| 112 | + continue; | |
| 113 | + } | |
| 114 | + | |
| 115 | + var meta = record[..tab].Split(' ', StringSplitOptions.RemoveEmptyEntries); | |
| 116 | + if (meta.Length < 4) | |
| 117 | + { | |
| 118 | + continue; | |
| 119 | + } | |
| 120 | + | |
| 121 | + var path = record[(tab + 1)..]; | |
| 122 | + var slash = path.LastIndexOf('/'); | |
| 123 | + var name = slash >= 0 ? path[(slash + 1)..] : path; | |
| 124 | + long? size = long.TryParse(meta[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var s) ? s : null; | |
| 125 | + entries.Add(new TreeEntry(name, meta[0], meta[1], meta[2], size)); | |
| 126 | + } | |
| 127 | + | |
| 128 | + return entries; | |
| 129 | + } | |
| 130 | + | |
| 131 | + /// <summary>Parses `ls-tree -r -z --long` into the blobs of a whole tree, keeping full paths.</summary> | |
| 132 | + public static IReadOnlyList<FileEntry> ParseFileList(string output) | |
| 133 | + { | |
| 134 | + var files = new List<FileEntry>(); | |
| 135 | + foreach (var record in output.Split('\0', StringSplitOptions.RemoveEmptyEntries)) | |
| 136 | + { | |
| 137 | + var tab = record.IndexOf('\t'); | |
| 138 | + if (tab < 0) | |
| 139 | + { | |
| 140 | + continue; | |
| 141 | + } | |
| 142 | + | |
| 143 | + var meta = record[..tab].Split(' ', StringSplitOptions.RemoveEmptyEntries); | |
| 144 | + if (meta.Length < 4 || meta[1] != "blob") | |
| 145 | + { | |
| 146 | + continue; | |
| 147 | + } | |
| 148 | + | |
| 149 | + files.Add(new FileEntry( | |
| 150 | + record[(tab + 1)..], | |
| 151 | + long.TryParse(meta[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var size) ? size : 0)); | |
| 152 | + } | |
| 153 | + | |
| 154 | + return files; | |
| 155 | + } | |
| 156 | + | |
| 157 | + public const int MaxGrepLineLength = 300; | |
| 158 | + | |
| 159 | + /// <summary> | |
| 160 | + /// Parses `grep -n -z <commit>`: each line is "commit:path NUL line-number NUL text". | |
| 161 | + /// Long lines (minified files) are cut to <see cref="MaxGrepLineLength"/> characters. | |
| 162 | + /// </summary> | |
| 163 | + public static IReadOnlyList<GrepMatch> ParseGrep(string output) | |
| 164 | + { | |
| 165 | + var matches = new List<GrepMatch>(); | |
| 166 | + foreach (var record in output.Split('\n', StringSplitOptions.RemoveEmptyEntries)) | |
| 167 | + { | |
| 168 | + var parts = record.Split('\0', 3); | |
| 169 | + var colon = parts[0].IndexOf(':'); | |
| 170 | + if (parts.Length < 3 | |
| 171 | + || colon < 0 | |
| 172 | + || !int.TryParse(parts[1], NumberStyles.None, CultureInfo.InvariantCulture, out var line)) | |
| 173 | + { | |
| 174 | + continue; | |
| 175 | + } | |
| 176 | + | |
| 177 | + var text = parts[2].TrimEnd('\r'); | |
| 178 | + matches.Add(new GrepMatch( | |
| 179 | + parts[0][(colon + 1)..], | |
| 180 | + line, | |
| 181 | + text.Length > MaxGrepLineLength ? text[..MaxGrepLineLength] : text)); | |
| 182 | + } | |
| 183 | + | |
| 184 | + return matches; | |
| 185 | + } | |
| 186 | + | |
| 187 | + public static IReadOnlyList<CommitInfo> ParseLog(string output) | |
| 188 | + { | |
| 189 | + var commits = new List<CommitInfo>(); | |
| 190 | + var f = output.Split('\0'); | |
| 191 | + for (var i = 0; i + LogFieldCount <= f.Length; i += LogFieldCount) | |
| 192 | + { | |
| 193 | + var sha = f[i].TrimStart('\n'); | |
| 194 | + if (sha.Length == 0) | |
| 195 | + { | |
| 196 | + break; | |
| 197 | + } | |
| 198 | + | |
| 199 | + commits.Add(new CommitInfo( | |
| 200 | + sha, | |
| 201 | + f[i + 1].Split(' ', StringSplitOptions.RemoveEmptyEntries), | |
| 202 | + f[i + 2], | |
| 203 | + f[i + 3], | |
| 204 | + RawDate(f[i + 4]), | |
| 205 | + f[i + 5], | |
| 206 | + f[i + 6], | |
| 207 | + UnixTime(f[i + 7]), | |
| 208 | + f[i + 8], | |
| 209 | + f[i + 9].TrimEnd('\n'), | |
| 210 | + f[i + 4].Trim())); | |
| 211 | + } | |
| 212 | + | |
| 213 | + return commits; | |
| 214 | + } | |
| 215 | + | |
| 216 | + /// <summary>Parses git's raw date format, "1700000000 +0100", keeping the author's time zone.</summary> | |
| 217 | + private static DateTimeOffset RawDate(string value) | |
| 218 | + { | |
| 219 | + var parts = value.Trim().Split(' '); | |
| 220 | + var time = UnixTime(parts[0]); | |
| 221 | + if (parts.Length == 2 | |
| 222 | + && parts[1].Length == 5 | |
| 223 | + && int.TryParse(parts[1].AsSpan(1, 2), NumberStyles.None, CultureInfo.InvariantCulture, out var hours) | |
| 224 | + && int.TryParse(parts[1].AsSpan(3, 2), NumberStyles.None, CultureInfo.InvariantCulture, out var minutes) | |
| 225 | + && hours <= 14 | |
| 226 | + && minutes < 60) | |
| 227 | + { | |
| 228 | + var offset = new TimeSpan(hours, minutes, 0); | |
| 229 | + return time.ToOffset(parts[1][0] == '-' ? -offset : offset); | |
| 230 | + } | |
| 231 | + | |
| 232 | + return time; | |
| 233 | + } | |
| 234 | + | |
| 235 | + private static DateTimeOffset UnixTime(string value) => | |
| 236 | + long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var unix) | |
| 237 | + ? DateTimeOffset.FromUnixTimeSeconds(unix) | |
| 238 | + : DateTimeOffset.UnixEpoch; | |
| 239 | + | |
| 240 | + /// <summary> | |
| 241 | + /// Parses `--numstat -z`. Normal rows are "added TAB deleted TAB path NUL"; renames are | |
| 242 | + /// "added TAB deleted TAB NUL old NUL new NUL". Binary files report "-" for both counts. | |
| 243 | + /// </summary> | |
| 244 | + public static IReadOnlyList<FileStat> ParseNumstat(string output) | |
| 245 | + { | |
| 246 | + var stats = new List<FileStat>(); | |
| 247 | + var tokens = output.Split('\0'); | |
| 248 | + for (var i = 0; i < tokens.Length; i++) | |
| 249 | + { | |
| 250 | + var token = tokens[i].TrimStart('\n'); | |
| 251 | + if (token.Length == 0) | |
| 252 | + { | |
| 253 | + continue; | |
| 254 | + } | |
| 255 | + | |
| 256 | + var parts = token.Split('\t', 3); | |
| 257 | + if (parts.Length < 3) | |
| 258 | + { | |
| 259 | + continue; | |
| 260 | + } | |
| 261 | + | |
| 262 | + int? added = int.TryParse(parts[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var a) ? a : null; | |
| 263 | + int? deleted = int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var d) ? d : null; | |
| 264 | + | |
| 265 | + if (parts[2].Length > 0) | |
| 266 | + { | |
| 267 | + stats.Add(new FileStat(parts[2], null, added, deleted)); | |
| 268 | + } | |
| 269 | + else if (i + 2 < tokens.Length) | |
| 270 | + { | |
| 271 | + stats.Add(new FileStat(tokens[i + 2], tokens[i + 1], added, deleted)); | |
| 272 | + i += 2; | |
| 273 | + } | |
| 274 | + } | |
| 275 | + | |
| 276 | + return stats; | |
| 277 | + } | |
| 278 | + | |
| 279 | + /// <summary>`rev-list --left-right --count base...tip` prints "behind TAB ahead".</summary> | |
| 280 | + public static (int Ahead, int Behind) ParseAheadBehind(string output) | |
| 281 | + { | |
| 282 | + var parts = output.Trim().Split('\t', ' '); | |
| 283 | + return parts.Length == 2 | |
| 284 | + && int.TryParse(parts[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var behind) | |
| 285 | + && int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var ahead) | |
| 286 | + ? (ahead, behind) | |
| 287 | + : (0, 0); | |
| 288 | + } | |
| 289 | + | |
| 290 | + /// <summary> | |
| 291 | + /// Parses `merge-tree --write-tree --name-only -z`: "tree NUL", then on conflict (exit code 1) | |
| 292 | + /// "path NUL" per conflicted file, an empty field, and messages. Any other exit code is a failure. | |
| 293 | + /// </summary> | |
| 294 | + public static MergeTreeResult ParseMergeTree(int exitCode, string output, string stdErr) | |
| 295 | + { | |
| 296 | + var fields = output.Split('\0'); | |
| 297 | + var tree = fields[0].Trim(); | |
| 298 | + if (exitCode == 0 && IsFullSha(tree)) | |
| 299 | + { | |
| 300 | + return new MergeTreeResult(tree, [], null); | |
| 301 | + } | |
| 302 | + | |
| 303 | + if (exitCode == 1 && IsFullSha(tree)) | |
| 304 | + { | |
| 305 | + var conflicts = fields.Skip(1).TakeWhile(f => f.Length > 0).Distinct().ToList(); | |
| 306 | + return new MergeTreeResult(null, conflicts, null, tree); | |
| 307 | + } | |
| 308 | + | |
| 309 | + var error = stdErr.Trim(); | |
| 310 | + return new MergeTreeResult(null, [], error.Length > 0 ? error : $"git merge-tree exited with code {exitCode}."); | |
| 311 | + } | |
| 312 | + | |
| 313 | + /// <summary>Parses a unified diff as printed by `git show --patch` into files and hunks.</summary> | |
| 314 | + public static ParsedDiff ParseDiff( | |
| 315 | + string patch, | |
| 316 | + bool inputTruncated = false, | |
| 317 | + int maxFiles = MaxDiffFiles, | |
| 318 | + int maxLinesPerFile = MaxDiffLinesPerFile) | |
| 319 | + { | |
| 320 | + var files = new List<FileDiff>(); | |
| 321 | + var truncated = inputTruncated; | |
| 322 | + FileDiff? file = null; | |
| 323 | + DiffHunk? hunk = null; | |
| 324 | + var oldNo = 0; | |
| 325 | + var newNo = 0; | |
| 326 | + var lineCount = 0; | |
| 327 | + | |
| 328 | + var lines = patch.Split('\n'); | |
| 329 | + var last = lines.Length - 1; | |
| 330 | + for (var i = 0; i < lines.Length; i++) | |
| 331 | + { | |
| 332 | + var line = lines[i]; | |
| 333 | + if (line.EndsWith('\r')) | |
| 334 | + { | |
| 335 | + line = line[..^1]; | |
| 336 | + } | |
| 337 | + | |
| 338 | + if (line.StartsWith("diff --git ", StringComparison.Ordinal)) | |
| 339 | + { | |
| 340 | + if (files.Count >= maxFiles) | |
| 341 | + { | |
| 342 | + truncated = true; | |
| 343 | + break; | |
| 344 | + } | |
| 345 | + | |
| 346 | + file = new FileDiff(); | |
| 347 | + hunk = null; | |
| 348 | + lineCount = 0; | |
| 349 | + ParseDiffHeaderPaths(line["diff --git ".Length..], file); | |
| 350 | + files.Add(file); | |
| 351 | + continue; | |
| 352 | + } | |
| 353 | + | |
| 354 | + if (file is null) | |
| 355 | + { | |
| 356 | + continue; | |
| 357 | + } | |
| 358 | + | |
| 359 | + if (line.StartsWith("@@ ", StringComparison.Ordinal)) | |
| 360 | + { | |
| 361 | + var match = HunkHeader().Match(line); | |
| 362 | + if (match.Success) | |
| 363 | + { | |
| 364 | + oldNo = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture); | |
| 365 | + newNo = int.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture); | |
| 366 | + hunk = new DiffHunk { Header = line }; | |
| 367 | + if (!file.TooLarge) | |
| 368 | + { | |
| 369 | + file.Hunks.Add(hunk); | |
| 370 | + } | |
| 371 | + | |
| 372 | + continue; | |
| 373 | + } | |
| 374 | + } | |
| 375 | + | |
| 376 | + if (hunk is null) | |
| 377 | + { | |
| 378 | + ParseDiffHeaderLine(line, file); | |
| 379 | + continue; | |
| 380 | + } | |
| 381 | + | |
| 382 | + // The trailing empty string after the final newline is not a diff line. | |
| 383 | + if (i == last && line.Length == 0) | |
| 384 | + { | |
| 385 | + break; | |
| 386 | + } | |
| 387 | + | |
| 388 | + DiffLine parsed; | |
| 389 | + switch (line.Length == 0 ? ' ' : line[0]) | |
| 390 | + { | |
| 391 | + case '+': | |
| 392 | + parsed = new DiffLine(DiffLineKind.Added, null, newNo++, line[1..]); | |
| 393 | + file.Added++; | |
| 394 | + break; | |
| 395 | + case '-': | |
| 396 | + parsed = new DiffLine(DiffLineKind.Deleted, oldNo++, null, line[1..]); | |
| 397 | + file.Deleted++; | |
| 398 | + break; | |
| 399 | + case '\\': | |
| 400 | + parsed = new DiffLine(DiffLineKind.NoNewline, null, null, line[1..].Trim()); | |
| 401 | + break; | |
| 402 | + default: | |
| 403 | + parsed = new DiffLine(DiffLineKind.Context, oldNo++, newNo++, line.Length == 0 ? "" : line[1..]); | |
| 404 | + break; | |
| 405 | + } | |
| 406 | + | |
| 407 | + if (file.TooLarge) | |
| 408 | + { | |
| 409 | + continue; | |
| 410 | + } | |
| 411 | + | |
| 412 | + if (++lineCount > maxLinesPerFile) | |
| 413 | + { | |
| 414 | + file.TooLarge = true; | |
| 415 | + file.Hunks.Clear(); | |
| 416 | + continue; | |
| 417 | + } | |
| 418 | + | |
| 419 | + hunk.Lines.Add(parsed); | |
| 420 | + } | |
| 421 | + | |
| 422 | + return new ParsedDiff(files, truncated); | |
| 423 | + } | |
| 424 | + | |
| 425 | + private static void ParseDiffHeaderLine(string line, FileDiff file) | |
| 426 | + { | |
| 427 | + if (line.StartsWith("new file mode", StringComparison.Ordinal)) | |
| 428 | + { | |
| 429 | + file.Change = FileChange.Added; | |
| 430 | + } | |
| 431 | + else if (line.StartsWith("deleted file mode", StringComparison.Ordinal)) | |
| 432 | + { | |
| 433 | + file.Change = FileChange.Deleted; | |
| 434 | + } | |
| 435 | + else if (line.StartsWith("rename from ", StringComparison.Ordinal)) | |
| 436 | + { | |
| 437 | + file.Change = FileChange.Renamed; | |
| 438 | + file.OldPath = Unquote(line["rename from ".Length..]); | |
| 439 | + } | |
| 440 | + else if (line.StartsWith("rename to ", StringComparison.Ordinal)) | |
| 441 | + { | |
| 442 | + file.Change = FileChange.Renamed; | |
| 443 | + file.NewPath = Unquote(line["rename to ".Length..]); | |
| 444 | + } | |
| 445 | + else if (line.StartsWith("copy from ", StringComparison.Ordinal)) | |
| 446 | + { | |
| 447 | + file.Change = FileChange.Copied; | |
| 448 | + file.OldPath = Unquote(line["copy from ".Length..]); | |
| 449 | + } | |
| 450 | + else if (line.StartsWith("copy to ", StringComparison.Ordinal)) | |
| 451 | + { | |
| 452 | + file.Change = FileChange.Copied; | |
| 453 | + file.NewPath = Unquote(line["copy to ".Length..]); | |
| 454 | + } | |
| 455 | + else if (line.StartsWith("Binary files ", StringComparison.Ordinal) | |
| 456 | + || line.StartsWith("GIT binary patch", StringComparison.Ordinal)) | |
| 457 | + { | |
| 458 | + file.IsBinary = true; | |
| 459 | + } | |
| 460 | + else if (line.StartsWith("--- ", StringComparison.Ordinal)) | |
| 461 | + { | |
| 462 | + var path = StripDiffPrefix(line[4..]); | |
| 463 | + if (path is not null) | |
| 464 | + { | |
| 465 | + file.OldPath = path; | |
| 466 | + } | |
| 467 | + } | |
| 468 | + else if (line.StartsWith("+++ ", StringComparison.Ordinal)) | |
| 469 | + { | |
| 470 | + var path = StripDiffPrefix(line[4..]); | |
| 471 | + if (path is not null) | |
| 472 | + { | |
| 473 | + file.NewPath = path; | |
| 474 | + } | |
| 475 | + } | |
| 476 | + } | |
| 477 | + | |
| 478 | + /// <summary>Turns "a/src/x.cs" from a ---/+++ line into "src/x.cs"; null for /dev/null.</summary> | |
| 479 | + private static string? StripDiffPrefix(string raw) | |
| 480 | + { | |
| 481 | + // Git appends a tab after names containing whitespace, for GNU patch. | |
| 482 | + var path = Unquote(raw.TrimEnd('\t')); | |
| 483 | + if (path == "/dev/null") | |
| 484 | + { | |
| 485 | + return null; | |
| 486 | + } | |
| 487 | + | |
| 488 | + return path.Length > 2 && path[1] == '/' ? path[2..] : path; | |
| 489 | + } | |
| 490 | + | |
| 491 | + /// <summary> | |
| 492 | + /// Best-effort path extraction from "a/old b/new". Used for files with no ---/+++ lines | |
| 493 | + /// (binary, mode-only, empty); rename headers override it afterwards. | |
| 494 | + /// </summary> | |
| 495 | + private static void ParseDiffHeaderPaths(string rest, FileDiff file) | |
| 496 | + { | |
| 497 | + string a, b; | |
| 498 | + if (rest.StartsWith('"')) | |
| 499 | + { | |
| 500 | + var end = FindClosingQuote(rest, 0); | |
| 501 | + a = Unquote(rest[..(end + 1)]); | |
| 502 | + b = Unquote(rest[(end + 1)..].TrimStart()); | |
| 503 | + } | |
| 504 | + else if (rest.Length >= 5 | |
| 505 | + && rest.Length % 2 == 1 | |
| 506 | + && rest[rest.Length / 2] == ' ' | |
| 507 | + && rest.AsSpan(2, rest.Length / 2 - 2).SequenceEqual(rest.AsSpan(rest.Length / 2 + 3))) | |
| 508 | + { | |
| 509 | + // Same path on both sides: "a/P b/P" splits exactly in the middle. | |
| 510 | + a = rest[..(rest.Length / 2)]; | |
| 511 | + b = rest[(rest.Length / 2 + 1)..]; | |
| 512 | + } | |
| 513 | + else | |
| 514 | + { | |
| 515 | + var split = rest.IndexOf(" b/", StringComparison.Ordinal); | |
| 516 | + if (split < 0) | |
| 517 | + { | |
| 518 | + split = rest.IndexOf(" \"b/", StringComparison.Ordinal); | |
| 519 | + } | |
| 520 | + | |
| 521 | + if (split < 0) | |
| 522 | + { | |
| 523 | + return; | |
| 524 | + } | |
| 525 | + | |
| 526 | + a = rest[..split]; | |
| 527 | + b = Unquote(rest[(split + 1)..]); | |
| 528 | + } | |
| 529 | + | |
| 530 | + file.OldPath = a.Length > 2 ? a[2..] : a; | |
| 531 | + file.NewPath = b.Length > 2 ? b[2..] : b; | |
| 532 | + } | |
| 533 | + | |
| 534 | + private static int FindClosingQuote(string value, int open) | |
| 535 | + { | |
| 536 | + for (var i = open + 1; i < value.Length; i++) | |
| 537 | + { | |
| 538 | + if (value[i] == '\\') | |
| 539 | + { | |
| 540 | + i++; | |
| 541 | + } | |
| 542 | + else if (value[i] == '"') | |
| 543 | + { | |
| 544 | + return i; | |
| 545 | + } | |
| 546 | + } | |
| 547 | + | |
| 548 | + return value.Length - 1; | |
| 549 | + } | |
| 550 | + | |
| 551 | + /// <summary>Reverses git's C-style path quoting ("a\tb\303\251"). Unquoted input is returned as is.</summary> | |
| 552 | + public static string Unquote(string value) | |
| 553 | + { | |
| 554 | + if (value.Length < 2 || value[0] != '"' || value[^1] != '"') | |
| 555 | + { | |
| 556 | + return value; | |
| 557 | + } | |
| 558 | + | |
| 559 | + var bytes = new List<byte>(value.Length); | |
| 560 | + for (var i = 1; i < value.Length - 1; i++) | |
| 561 | + { | |
| 562 | + var c = value[i]; | |
| 563 | + if (c != '\\' || i + 1 >= value.Length - 1) | |
| 564 | + { | |
| 565 | + var pair = char.IsHighSurrogate(c) && i + 1 < value.Length - 1 && char.IsLowSurrogate(value[i + 1]); | |
| 566 | + bytes.AddRange(Encoding.UTF8.GetBytes(value.Substring(i, pair ? 2 : 1))); | |
| 567 | + if (pair) | |
| 568 | + { | |
| 569 | + i++; | |
| 570 | + } | |
| 571 | + | |
| 572 | + continue; | |
| 573 | + } | |
| 574 | + | |
| 575 | + var next = value[++i]; | |
| 576 | + if (next is >= '0' and <= '7') | |
| 577 | + { | |
| 578 | + var octal = next - '0'; | |
| 579 | + for (var n = 0; n < 2 && i + 1 < value.Length - 1 && value[i + 1] is >= '0' and <= '7'; n++) | |
| 580 | + { | |
| 581 | + octal = octal * 8 + (value[++i] - '0'); | |
| 582 | + } | |
| 583 | + | |
| 584 | + bytes.Add((byte)octal); | |
| 585 | + continue; | |
| 586 | + } | |
| 587 | + | |
| 588 | + bytes.Add(next switch | |
| 589 | + { | |
| 590 | + 'n' => (byte)'\n', | |
| 591 | + 't' => (byte)'\t', | |
| 592 | + 'r' => (byte)'\r', | |
| 593 | + 'a' => 7, | |
| 594 | + 'b' => 8, | |
| 595 | + 'f' => 12, | |
| 596 | + 'v' => 11, | |
| 597 | + _ => (byte)next, | |
| 598 | + }); | |
| 599 | + } | |
| 600 | + | |
| 601 | + return Encoding.UTF8.GetString(bytes.ToArray()); | |
| 602 | + } | |
| 603 | + | |
| 604 | + [GeneratedRegex(@"^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@")] | |
| 605 | + private static partial Regex HunkHeader(); | |
| 606 | + | |
| 607 | + [GeneratedRegex(@"(\d+)\.(\d+)")] | |
| 608 | + private static partial Regex VersionPattern(); | |
| 609 | +} |
added forge/Git/GitRepo.cs +558 −0View file
| @@ -0,0 +1,558 @@ | ||
| 1 | +using System.Globalization; | |
| 2 | + | |
| 3 | +namespace Forge.Git; | |
| 4 | + | |
| 5 | +/// <summary> | |
| 6 | +/// Read and write operations on one bare repository, built on <see cref="GitCli"/>. | |
| 7 | +/// Every revision argument here is expected to be a full SHA that came out of | |
| 8 | +/// <see cref="RefResolver"/> or out of git itself; user-typed names never reach git. | |
| 9 | +/// </summary> | |
| 10 | +public sealed class GitRepo(GitCli git) | |
| 11 | +{ | |
| 12 | + public const int MaxDiffBytes = 4 * 1024 * 1024; | |
| 13 | + | |
| 14 | + public async Task InitBareAsync(string repoPath, CancellationToken ct = default) | |
| 15 | + { | |
| 16 | + await git.RunAsync(null, ["init", "--bare", "--initial-branch=main", repoPath], ct: ct); | |
| 17 | + await git.RunAsync(repoPath, ["config", "receive.fsckObjects", "true"], ct: ct); | |
| 18 | + // Lets clients use partial clone (--filter=blob:none). | |
| 19 | + await git.RunAsync(repoPath, ["config", "uploadpack.allowFilter", "true"], ct: ct); | |
| 20 | + } | |
| 21 | + | |
| 22 | + /// <summary>Branches and tags, branches first, each group sorted by name.</summary> | |
| 23 | + public async Task<IReadOnlyList<GitRef>> ListRefsAsync(string repoPath, CancellationToken ct = default) | |
| 24 | + { | |
| 25 | + var result = await git.RunAsync( | |
| 26 | + repoPath, | |
| 27 | + ["for-each-ref", "--format=" + GitParsers.RefFormat, "refs/heads", "refs/tags"], | |
| 28 | + ct: ct); | |
| 29 | + return GitParsers.ParseRefs(result.Text); | |
| 30 | + } | |
| 31 | + | |
| 32 | + /// <summary>Tags, newest first.</summary> | |
| 33 | + public async Task<IReadOnlyList<GitRef>> ListTagsByDateAsync(string repoPath, CancellationToken ct = default) | |
| 34 | + { | |
| 35 | + var result = await git.RunAsync( | |
| 36 | + repoPath, | |
| 37 | + ["for-each-ref", "--sort=-creatordate", "--format=" + GitParsers.RefFormat, "refs/tags"], | |
| 38 | + ct: ct); | |
| 39 | + return GitParsers.ParseRefs(result.Text); | |
| 40 | + } | |
| 41 | + | |
| 42 | + /// <summary>Every ref with its SHA. Two snapshots around a push give the list of changed refs.</summary> | |
| 43 | + public async Task<Dictionary<string, string>> SnapshotRefsAsync(string repoPath, CancellationToken ct = default) | |
| 44 | + { | |
| 45 | + var result = await git.RunAsync( | |
| 46 | + repoPath, | |
| 47 | + ["for-each-ref", "--format=%(refname)%00%(objectname)"], | |
| 48 | + ct: ct); | |
| 49 | + return GitParsers.ParseRefSnapshot(result.Text); | |
| 50 | + } | |
| 51 | + | |
| 52 | + /// <summary>Resolves a full or abbreviated hex SHA to a commit SHA. Anything that is not hex is rejected before git runs.</summary> | |
| 53 | + public async Task<string?> ResolveCommitAsync(string repoPath, string hex, CancellationToken ct = default) | |
| 54 | + { | |
| 55 | + if (hex.Length is < 4 or > 40 || !GitParsers.IsHex(hex)) | |
| 56 | + { | |
| 57 | + return null; | |
| 58 | + } | |
| 59 | + | |
| 60 | + var result = await git.RunAsync( | |
| 61 | + repoPath, | |
| 62 | + ["rev-parse", "--verify", "--quiet", "--end-of-options", hex + "^{commit}"], | |
| 63 | + ct: ct, | |
| 64 | + throwOnError: false); | |
| 65 | + var sha = result.Text.Trim(); | |
| 66 | + return result.ExitCode == 0 && GitParsers.IsFullSha(sha) ? sha : null; | |
| 67 | + } | |
| 68 | + | |
| 69 | + public async Task<string?> GetRootTreeShaAsync(string repoPath, string commitSha, CancellationToken ct = default) | |
| 70 | + { | |
| 71 | + RequireSha(commitSha); | |
| 72 | + var result = await git.RunAsync( | |
| 73 | + repoPath, | |
| 74 | + ["rev-parse", "--verify", "--quiet", "--end-of-options", commitSha + "^{tree}"], | |
| 75 | + ct: ct, | |
| 76 | + throwOnError: false); | |
| 77 | + var sha = result.Text.Trim(); | |
| 78 | + return result.ExitCode == 0 && GitParsers.IsFullSha(sha) ? sha : null; | |
| 79 | + } | |
| 80 | + | |
| 81 | + /// <summary>Looks up one path inside a commit. Returns null when the path does not exist.</summary> | |
| 82 | + public async Task<TreeEntry?> GetEntryAsync(string repoPath, string commitSha, string path, CancellationToken ct = default) | |
| 83 | + { | |
| 84 | + RequireSha(commitSha); | |
| 85 | + var result = await git.RunAsync( | |
| 86 | + repoPath, | |
| 87 | + ["ls-tree", "-z", "--long", commitSha, "--", path.TrimEnd('/')], | |
| 88 | + ct: ct, | |
| 89 | + throwOnError: false); | |
| 90 | + return result.ExitCode == 0 ? GitParsers.ParseTree(result.Text).FirstOrDefault() : null; | |
| 91 | + } | |
| 92 | + | |
| 93 | + /// <summary>Lists the direct children of a tree object.</summary> | |
| 94 | + public async Task<IReadOnlyList<TreeEntry>> ListTreeAsync(string repoPath, string treeSha, CancellationToken ct = default) | |
| 95 | + { | |
| 96 | + RequireSha(treeSha); | |
| 97 | + var result = await git.RunAsync(repoPath, ["ls-tree", "-z", "--long", treeSha], ct: ct); | |
| 98 | + return GitParsers.ParseTree(result.Text); | |
| 99 | + } | |
| 100 | + | |
| 101 | + /// <summary> | |
| 102 | + /// Every file of a commit, in git's path order. Stops at <paramref name="maxOutputBytes"/> of listing, | |
| 103 | + /// so for a huge repository the result is a prefix; <c>Truncated</c> says so. | |
| 104 | + /// </summary> | |
| 105 | + public async Task<(IReadOnlyList<FileEntry> Files, bool Truncated)> ListFilesAsync( | |
| 106 | + string repoPath, | |
| 107 | + string commitSha, | |
| 108 | + long maxOutputBytes = 8 * 1024 * 1024, | |
| 109 | + CancellationToken ct = default) | |
| 110 | + { | |
| 111 | + RequireSha(commitSha); | |
| 112 | + var result = await git.RunAsync( | |
| 113 | + repoPath, | |
| 114 | + ["ls-tree", "-r", "-z", "--long", commitSha], | |
| 115 | + ct: ct, | |
| 116 | + maxOutputBytes: maxOutputBytes); | |
| 117 | + var text = result.Text; | |
| 118 | + if (result.Truncated) | |
| 119 | + { | |
| 120 | + // The last record is probably cut in half. | |
| 121 | + var end = text.LastIndexOf('\0'); | |
| 122 | + text = end < 0 ? "" : text[..end]; | |
| 123 | + } | |
| 124 | + | |
| 125 | + return (GitParsers.ParseFileList(text), result.Truncated); | |
| 126 | + } | |
| 127 | + | |
| 128 | + /// <summary> | |
| 129 | + /// Finds lines containing <paramref name="text"/> (literal, case-insensitive) in the text files of a commit. | |
| 130 | + /// At most <paramref name="maxPerFile"/> lines per file; <c>Truncated</c> when the output limit cut the search short. | |
| 131 | + /// </summary> | |
| 132 | + public async Task<(IReadOnlyList<GrepMatch> Matches, bool Truncated)> GrepAsync( | |
| 133 | + string repoPath, | |
| 134 | + string commitSha, | |
| 135 | + string text, | |
| 136 | + int maxPerFile = 10, | |
| 137 | + long maxOutputBytes = 256 * 1024, | |
| 138 | + CancellationToken ct = default) | |
| 139 | + { | |
| 140 | + RequireSha(commitSha); | |
| 141 | + // A newline would split the text into several patterns. | |
| 142 | + if (text.Length == 0 || text.Contains('\n') || text.Contains('\r') || text.Contains('\0')) | |
| 143 | + { | |
| 144 | + return ([], false); | |
| 145 | + } | |
| 146 | + | |
| 147 | + var result = await git.RunAsync( | |
| 148 | + repoPath, | |
| 149 | + [ | |
| 150 | + "grep", "-n", "-z", "-I", "-i", "-F", "--no-color", | |
| 151 | + "--max-count=" + maxPerFile.ToString(CultureInfo.InvariantCulture), | |
| 152 | + // The text follows -e, so it is never read as an option, whatever it starts with. | |
| 153 | + "-e", text, | |
| 154 | + commitSha, "--", | |
| 155 | + ], | |
| 156 | + ct: ct, | |
| 157 | + maxOutputBytes: maxOutputBytes, | |
| 158 | + throwOnError: false); | |
| 159 | + | |
| 160 | + // Exit code 1 means "no match"; anything above is a real error. | |
| 161 | + if (!result.Truncated && result.ExitCode > 1) | |
| 162 | + { | |
| 163 | + throw new GitException($"git grep exited with code {result.ExitCode}: {result.StdErr.Trim()}", result.ExitCode, result.StdErr); | |
| 164 | + } | |
| 165 | + | |
| 166 | + var output = result.Text; | |
| 167 | + if (result.Truncated) | |
| 168 | + { | |
| 169 | + var end = output.LastIndexOf('\n'); | |
| 170 | + output = end < 0 ? "" : output[..end]; | |
| 171 | + } | |
| 172 | + | |
| 173 | + return (GitParsers.ParseGrep(output), result.Truncated); | |
| 174 | + } | |
| 175 | + | |
| 176 | + /// <summary>Author name, e-mail and time of the newest <paramref name="max"/> commits (mailmap applied), newest first.</summary> | |
| 177 | + public async Task<IReadOnlyList<(string Name, string Email, DateTimeOffset When)>> ListAuthorshipAsync( | |
| 178 | + string repoPath, | |
| 179 | + string commitSha, | |
| 180 | + int max, | |
| 181 | + CancellationToken ct = default) | |
| 182 | + { | |
| 183 | + RequireSha(commitSha); | |
| 184 | + var result = await git.RunAsync( | |
| 185 | + repoPath, | |
| 186 | + [ | |
| 187 | + "log", "--format=%aN%x00%aE%x00%at%x00", | |
| 188 | + "-n", max.ToString(CultureInfo.InvariantCulture), | |
| 189 | + "--end-of-options", commitSha, "--", | |
| 190 | + ], | |
| 191 | + ct: ct); | |
| 192 | + | |
| 193 | + var fields = result.Text.Split('\0'); | |
| 194 | + var rows = new List<(string, string, DateTimeOffset)>(fields.Length / 3); | |
| 195 | + for (var i = 0; i + 3 <= fields.Length; i += 3) | |
| 196 | + { | |
| 197 | + if (long.TryParse(fields[i + 2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var unix)) | |
| 198 | + { | |
| 199 | + rows.Add((fields[i].TrimStart('\n'), fields[i + 1], DateTimeOffset.FromUnixTimeSeconds(unix))); | |
| 200 | + } | |
| 201 | + } | |
| 202 | + | |
| 203 | + return rows; | |
| 204 | + } | |
| 205 | + | |
| 206 | + /// <summary>How many commits are reachable from a commit.</summary> | |
| 207 | + public async Task<int> CountCommitsAsync(string repoPath, string commitSha, CancellationToken ct = default) | |
| 208 | + { | |
| 209 | + RequireSha(commitSha); | |
| 210 | + var result = await git.RunAsync(repoPath, ["rev-list", "--count", commitSha, "--"], ct: ct, throwOnError: false); | |
| 211 | + return result.ExitCode == 0 && int.TryParse(result.Text.Trim(), NumberStyles.None, CultureInfo.InvariantCulture, out var count) | |
| 212 | + ? count | |
| 213 | + : 0; | |
| 214 | + } | |
| 215 | + | |
| 216 | + public async Task<long> GetBlobSizeAsync(string repoPath, string blobSha, CancellationToken ct = default) | |
| 217 | + { | |
| 218 | + RequireSha(blobSha); | |
| 219 | + var result = await git.RunAsync(repoPath, ["cat-file", "-s", blobSha], ct: ct); | |
| 220 | + return long.Parse(result.Text.Trim(), CultureInfo.InvariantCulture); | |
| 221 | + } | |
| 222 | + | |
| 223 | + /// <summary>Reads a blob, stopping at <paramref name="maxBytes"/>.</summary> | |
| 224 | + public async Task<BlobContent> ReadBlobAsync(string repoPath, string blobSha, long maxBytes, CancellationToken ct = default) | |
| 225 | + { | |
| 226 | + RequireSha(blobSha); | |
| 227 | + var result = await git.RunAsync( | |
| 228 | + repoPath, | |
| 229 | + ["cat-file", "blob", blobSha], | |
| 230 | + ct: ct, | |
| 231 | + maxOutputBytes: maxBytes); | |
| 232 | + return new BlobContent(result.StdOut, result.Truncated); | |
| 233 | + } | |
| 234 | + | |
| 235 | + public async Task<IReadOnlyList<CommitInfo>> LogAsync( | |
| 236 | + string repoPath, | |
| 237 | + string commitSha, | |
| 238 | + string? path = null, | |
| 239 | + int skip = 0, | |
| 240 | + int take = 30, | |
| 241 | + CancellationToken ct = default) | |
| 242 | + { | |
| 243 | + RequireSha(commitSha); | |
| 244 | + List<string> args = | |
| 245 | + [ | |
| 246 | + "log", | |
| 247 | + "--format=" + GitParsers.LogFormat, "--date=raw", | |
| 248 | + "-n", take.ToString(CultureInfo.InvariantCulture), | |
| 249 | + "--skip=" + skip.ToString(CultureInfo.InvariantCulture), | |
| 250 | + "--end-of-options", | |
| 251 | + commitSha, | |
| 252 | + "--", | |
| 253 | + ]; | |
| 254 | + if (!string.IsNullOrEmpty(path)) | |
| 255 | + { | |
| 256 | + args.Add(path); | |
| 257 | + } | |
| 258 | + | |
| 259 | + var result = await git.RunAsync(repoPath, args, ct: ct); | |
| 260 | + return GitParsers.ParseLog(result.Text); | |
| 261 | + } | |
| 262 | + | |
| 263 | + /// <summary>Commits reachable from <paramref name="newSha"/> but not from <paramref name="oldSha"/>, newest first.</summary> | |
| 264 | + public async Task<IReadOnlyList<CommitInfo>> LogRangeAsync( | |
| 265 | + string repoPath, | |
| 266 | + string? oldSha, | |
| 267 | + string newSha, | |
| 268 | + int take, | |
| 269 | + CancellationToken ct = default) | |
| 270 | + { | |
| 271 | + RequireSha(newSha); | |
| 272 | + var range = oldSha is null || oldSha == GitParsers.ZeroSha ? newSha : $"{RequireSha(oldSha)}..{newSha}"; | |
| 273 | + var result = await git.RunAsync( | |
| 274 | + repoPath, | |
| 275 | + [ | |
| 276 | + "log", | |
| 277 | + "--format=" + GitParsers.LogFormat, "--date=raw", | |
| 278 | + "-n", take.ToString(CultureInfo.InvariantCulture), | |
| 279 | + "--end-of-options", | |
| 280 | + range, | |
| 281 | + "--", | |
| 282 | + ], | |
| 283 | + ct: ct, | |
| 284 | + throwOnError: false); | |
| 285 | + return result.ExitCode == 0 ? GitParsers.ParseLog(result.Text) : []; | |
| 286 | + } | |
| 287 | + | |
| 288 | + public async Task<CommitInfo?> GetCommitAsync(string repoPath, string commitSha, CancellationToken ct = default) | |
| 289 | + { | |
| 290 | + RequireSha(commitSha); | |
| 291 | + var result = await git.RunAsync( | |
| 292 | + repoPath, | |
| 293 | + ["show", "--no-patch", "--format=" + GitParsers.LogFormat, "--date=raw", "--end-of-options", commitSha, "--"], | |
| 294 | + ct: ct, | |
| 295 | + throwOnError: false); | |
| 296 | + return result.ExitCode == 0 ? GitParsers.ParseLog(result.Text).FirstOrDefault() : null; | |
| 297 | + } | |
| 298 | + | |
| 299 | + /// <summary>Change summary and patch for one commit. Merges are shown against their first parent.</summary> | |
| 300 | + public async Task<CommitDiff> GetDiffAsync( | |
| 301 | + string repoPath, | |
| 302 | + string commitSha, | |
| 303 | + bool ignoreWhitespace = false, | |
| 304 | + CancellationToken ct = default) | |
| 305 | + { | |
| 306 | + RequireSha(commitSha); | |
| 307 | + string[] whitespace = ignoreWhitespace ? ["-w"] : []; | |
| 308 | + | |
| 309 | + var numstat = await git.RunAsync( | |
| 310 | + repoPath, | |
| 311 | + [ | |
| 312 | + "show", "--format=", "--numstat", "-z", "-M", "--diff-merges=first-parent", .. whitespace, | |
| 313 | + "--end-of-options", commitSha, "--", | |
| 314 | + ], | |
| 315 | + ct: ct); | |
| 316 | + | |
| 317 | + var patch = await git.RunAsync( | |
| 318 | + repoPath, | |
| 319 | + [ | |
| 320 | + "show", "--format=", "--patch", "-M", "--diff-merges=first-parent", | |
| 321 | + "--no-color", "--no-ext-diff", "--no-textconv", .. whitespace, | |
| 322 | + "--end-of-options", commitSha, "--", | |
| 323 | + ], | |
| 324 | + ct: ct, | |
| 325 | + maxOutputBytes: MaxDiffBytes); | |
| 326 | + | |
| 327 | + return new CommitDiff( | |
| 328 | + GitParsers.ParseNumstat(numstat.Text), | |
| 329 | + GitParsers.ParseDiff(patch.Text, inputTruncated: patch.Truncated)); | |
| 330 | + } | |
| 331 | + | |
| 332 | + public async Task<(int Ahead, int Behind)> AheadBehindAsync( | |
| 333 | + string repoPath, | |
| 334 | + string baseSha, | |
| 335 | + string tipSha, | |
| 336 | + CancellationToken ct = default) | |
| 337 | + { | |
| 338 | + RequireSha(baseSha); | |
| 339 | + RequireSha(tipSha); | |
| 340 | + var result = await git.RunAsync( | |
| 341 | + repoPath, | |
| 342 | + ["rev-list", "--left-right", "--count", "--end-of-options", $"{baseSha}...{tipSha}", "--"], | |
| 343 | + ct: ct, | |
| 344 | + throwOnError: false); | |
| 345 | + return result.ExitCode == 0 ? GitParsers.ParseAheadBehind(result.Text) : (0, 0); | |
| 346 | + } | |
| 347 | + | |
| 348 | + /// <summary>The best common ancestor of two commits, or null when their histories are unrelated.</summary> | |
| 349 | + public async Task<string?> MergeBaseAsync(string repoPath, string a, string b, CancellationToken ct = default) | |
| 350 | + { | |
| 351 | + RequireSha(a); | |
| 352 | + RequireSha(b); | |
| 353 | + var result = await git.RunAsync(repoPath, ["merge-base", a, b], ct: ct, throwOnError: false); | |
| 354 | + var sha = result.Text.Trim(); | |
| 355 | + return result.ExitCode == 0 && GitParsers.IsFullSha(sha) ? sha : null; | |
| 356 | + } | |
| 357 | + | |
| 358 | + /// <summary>Change summary and patch between two commits.</summary> | |
| 359 | + public async Task<CommitDiff> GetRangeDiffAsync( | |
| 360 | + string repoPath, | |
| 361 | + string fromSha, | |
| 362 | + string toSha, | |
| 363 | + bool ignoreWhitespace = false, | |
| 364 | + CancellationToken ct = default) | |
| 365 | + { | |
| 366 | + RequireSha(fromSha); | |
| 367 | + RequireSha(toSha); | |
| 368 | + string[] whitespace = ignoreWhitespace ? ["-w"] : []; | |
| 369 | + | |
| 370 | + var numstat = await git.RunAsync( | |
| 371 | + repoPath, | |
| 372 | + ["diff", "--numstat", "-z", "-M", .. whitespace, "--end-of-options", fromSha, toSha, "--"], | |
| 373 | + ct: ct); | |
| 374 | + | |
| 375 | + var patch = await git.RunAsync( | |
| 376 | + repoPath, | |
| 377 | + [ | |
| 378 | + "diff", "--patch", "-M", "--no-color", "--no-ext-diff", "--no-textconv", .. whitespace, | |
| 379 | + "--end-of-options", fromSha, toSha, "--", | |
| 380 | + ], | |
| 381 | + ct: ct, | |
| 382 | + maxOutputBytes: MaxDiffBytes); | |
| 383 | + | |
| 384 | + return new CommitDiff( | |
| 385 | + GitParsers.ParseNumstat(numstat.Text), | |
| 386 | + GitParsers.ParseDiff(patch.Text, inputTruncated: patch.Truncated)); | |
| 387 | + } | |
| 388 | + | |
| 389 | + /// <summary> | |
| 390 | + /// Merges two commits without a working tree (`git merge-tree --write-tree`). Nothing but loose | |
| 391 | + /// objects is written: on success the caller gets a tree to commit, on conflict the list of files. | |
| 392 | + /// </summary> | |
| 393 | + /// <param name="mergeBaseSha"> | |
| 394 | + /// Overrides the common ancestor. This is what turns a merge into a cherry-pick (base = the commit's | |
| 395 | + /// parent), a revert (base = the commit, theirs = its parent) or one step of a rebase. | |
| 396 | + /// </param> | |
| 397 | + public async Task<MergeTreeResult> MergeTreeAsync( | |
| 398 | + string repoPath, | |
| 399 | + string oursSha, | |
| 400 | + string theirsSha, | |
| 401 | + CancellationToken ct = default, | |
| 402 | + string? mergeBaseSha = null) | |
| 403 | + { | |
| 404 | + RequireSha(oursSha); | |
| 405 | + RequireSha(theirsSha); | |
| 406 | + string[] mergeBase = mergeBaseSha is null ? [] : ["--merge-base=" + RequireSha(mergeBaseSha)]; | |
| 407 | + var result = await git.RunAsync( | |
| 408 | + repoPath, | |
| 409 | + ["merge-tree", "--write-tree", "--name-only", "-z", .. mergeBase, oursSha, theirsSha], | |
| 410 | + ct: ct, | |
| 411 | + timeout: TimeSpan.FromMinutes(2), | |
| 412 | + throwOnError: false); | |
| 413 | + return GitParsers.ParseMergeTree(result.ExitCode, result.Text, result.StdErr); | |
| 414 | + } | |
| 415 | + | |
| 416 | + /// <summary>Creates a commit object for a tree and returns its SHA. No ref is moved.</summary> | |
| 417 | + public async Task<string> CommitTreeAsync( | |
| 418 | + string repoPath, | |
| 419 | + string treeSha, | |
| 420 | + IReadOnlyList<string> parents, | |
| 421 | + string message, | |
| 422 | + GitIdentity who, | |
| 423 | + CancellationToken ct = default, | |
| 424 | + GitIdentity? author = null, | |
| 425 | + string? authorDateRaw = null) | |
| 426 | + { | |
| 427 | + RequireSha(treeSha); | |
| 428 | + List<string> args = ["commit-tree", treeSha]; | |
| 429 | + foreach (var parent in parents) | |
| 430 | + { | |
| 431 | + args.Add("-p"); | |
| 432 | + args.Add(RequireSha(parent)); | |
| 433 | + } | |
| 434 | + | |
| 435 | + // The message goes in on stdin, so nothing in it can be read as an option. | |
| 436 | + args.Add("-F"); | |
| 437 | + args.Add("-"); | |
| 438 | + | |
| 439 | + using var stdin = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(message.TrimEnd() + "\n")); | |
| 440 | + var result = await git.RunAsync( | |
| 441 | + repoPath, | |
| 442 | + args, | |
| 443 | + stdin, | |
| 444 | + ct, | |
| 445 | + extraEnvironment: new Dictionary<string, string?> | |
| 446 | + { | |
| 447 | + // A replayed commit keeps its original author and date; the committer is whoever replays it. | |
| 448 | + ["GIT_AUTHOR_NAME"] = (author ?? who).Name, | |
| 449 | + ["GIT_AUTHOR_EMAIL"] = (author ?? who).Email, | |
| 450 | + ["GIT_AUTHOR_DATE"] = string.IsNullOrEmpty(authorDateRaw) ? null : authorDateRaw, | |
| 451 | + ["GIT_COMMITTER_NAME"] = who.Name, | |
| 452 | + ["GIT_COMMITTER_EMAIL"] = who.Email, | |
| 453 | + }); | |
| 454 | + return RequireSha(result.Text.Trim()); | |
| 455 | + } | |
| 456 | + | |
| 457 | + /// <summary>Stores content as a blob and returns its SHA.</summary> | |
| 458 | + public async Task<string> WriteBlobAsync(string repoPath, byte[] content, CancellationToken ct = default) | |
| 459 | + { | |
| 460 | + using var stdin = new MemoryStream(content); | |
| 461 | + var result = await git.RunAsync(repoPath, ["hash-object", "-w", "--stdin"], stdin, ct); | |
| 462 | + return RequireSha(result.Text.Trim()); | |
| 463 | + } | |
| 464 | + | |
| 465 | + /// <summary> | |
| 466 | + /// Returns a new tree: <paramref name="treeSha"/> with some paths replaced or removed. | |
| 467 | + /// A bare repository has no index, so a throwaway one is used and deleted afterwards. | |
| 468 | + /// </summary> | |
| 469 | + /// <param name="changes">Path → (mode, blob SHA), or null to remove the path.</param> | |
| 470 | + public async Task<string> BuildTreeAsync( | |
| 471 | + string repoPath, | |
| 472 | + string treeSha, | |
| 473 | + IReadOnlyDictionary<string, (string Mode, string BlobSha)?> changes, | |
| 474 | + CancellationToken ct = default) | |
| 475 | + { | |
| 476 | + RequireSha(treeSha); | |
| 477 | + var scratch = Path.Combine(git.WorkDirectory, "tmp"); | |
| 478 | + Directory.CreateDirectory(scratch); | |
| 479 | + var index = Path.Combine(scratch, "index-" + Guid.NewGuid().ToString("N")); | |
| 480 | + var environment = new Dictionary<string, string?> { ["GIT_INDEX_FILE"] = index }; | |
| 481 | + try | |
| 482 | + { | |
| 483 | + await git.RunAsync(repoPath, ["read-tree", treeSha], ct: ct, extraEnvironment: environment); | |
| 484 | + foreach (var (path, entry) in changes) | |
| 485 | + { | |
| 486 | + // The path is the tail of a single argument (or follows "--"), so it cannot be read as an option. | |
| 487 | + string[] args = entry is { } e | |
| 488 | + ? ["update-index", "--add", "--cacheinfo", $"{e.Mode},{RequireSha(e.BlobSha)},{path}"] | |
| 489 | + : ["update-index", "--force-remove", "--", path]; | |
| 490 | + await git.RunAsync(repoPath, args, ct: ct, extraEnvironment: environment); | |
| 491 | + } | |
| 492 | + | |
| 493 | + var result = await git.RunAsync(repoPath, ["write-tree"], ct: ct, extraEnvironment: environment); | |
| 494 | + return RequireSha(result.Text.Trim()); | |
| 495 | + } | |
| 496 | + finally | |
| 497 | + { | |
| 498 | + File.Delete(index); | |
| 499 | + File.Delete(index + ".lock"); | |
| 500 | + } | |
| 501 | + } | |
| 502 | + | |
| 503 | + /// <summary>True when "refs/heads/x" or "refs/tags/x" is a name git accepts.</summary> | |
| 504 | + public async Task<bool> IsValidRefNameAsync(string fullRefName, CancellationToken ct = default) | |
| 505 | + { | |
| 506 | + // The refs/ prefix guarantees the argument cannot be taken for an option. | |
| 507 | + if (!fullRefName.StartsWith("refs/", StringComparison.Ordinal) || fullRefName.Length > 250) | |
| 508 | + { | |
| 509 | + return false; | |
| 510 | + } | |
| 511 | + | |
| 512 | + var result = await git.RunAsync(null, ["check-ref-format", fullRefName], ct: ct, throwOnError: false); | |
| 513 | + return result.ExitCode == 0; | |
| 514 | + } | |
| 515 | + | |
| 516 | + /// <summary> | |
| 517 | + /// Moves, creates or deletes a ref, but only if it still has the expected value | |
| 518 | + /// (<see cref="GitParsers.ZeroSha"/> for "must not exist"). Returns false when it changed meanwhile. | |
| 519 | + /// </summary> | |
| 520 | + public async Task<bool> UpdateRefAsync( | |
| 521 | + string repoPath, | |
| 522 | + string fullRefName, | |
| 523 | + string? newSha, | |
| 524 | + string expectedOldSha, | |
| 525 | + CancellationToken ct = default) | |
| 526 | + { | |
| 527 | + if (!fullRefName.StartsWith("refs/", StringComparison.Ordinal)) | |
| 528 | + { | |
| 529 | + throw new ArgumentException("Expected a full ref name.", nameof(fullRefName)); | |
| 530 | + } | |
| 531 | + | |
| 532 | + RequireSha(expectedOldSha); | |
| 533 | + string[] args = newSha is null | |
| 534 | + ? ["update-ref", "-d", fullRefName, expectedOldSha] | |
| 535 | + : ["update-ref", fullRefName, RequireSha(newSha), expectedOldSha]; | |
| 536 | + var result = await git.RunAsync(repoPath, args, ct: ct, throwOnError: false); | |
| 537 | + return result.ExitCode == 0; | |
| 538 | + } | |
| 539 | + | |
| 540 | + /// <summary>The branch HEAD points at, or null when HEAD is detached.</summary> | |
| 541 | + public async Task<string?> GetHeadBranchAsync(string repoPath, CancellationToken ct = default) | |
| 542 | + { | |
| 543 | + var result = await git.RunAsync(repoPath, ["symbolic-ref", "--quiet", "HEAD"], ct: ct, throwOnError: false); | |
| 544 | + var target = result.Text.Trim(); | |
| 545 | + return result.ExitCode == 0 && target.StartsWith("refs/heads/", StringComparison.Ordinal) | |
| 546 | + ? target["refs/heads/".Length..] | |
| 547 | + : null; | |
| 548 | + } | |
| 549 | + | |
| 550 | + /// <summary>Points HEAD at a branch. The caller must have checked that the branch exists.</summary> | |
| 551 | + public Task SetHeadBranchAsync(string repoPath, string branch, CancellationToken ct = default) => | |
| 552 | + git.RunAsync(repoPath, ["symbolic-ref", "HEAD", "refs/heads/" + branch], ct: ct); | |
| 553 | + | |
| 554 | + private static string RequireSha(string value) => | |
| 555 | + GitParsers.IsFullSha(value) | |
| 556 | + ? value | |
| 557 | + : throw new ArgumentException("Expected a full 40-character SHA.", nameof(value)); | |
| 558 | +} |
added forge/Git/RefResolver.cs +149 −0View file
| @@ -0,0 +1,149 @@ | ||
| 1 | +namespace Forge.Git; | |
| 2 | + | |
| 3 | +public enum ResolvedKind | |
| 4 | +{ | |
| 5 | + Branch, | |
| 6 | + Tag, | |
| 7 | + Commit, | |
| 8 | +} | |
| 9 | + | |
| 10 | +/// <param name="Name">Branch or tag name, or the full SHA when the URL named a commit.</param> | |
| 11 | +/// <param name="Path">Path inside the tree, without leading or trailing slashes; empty for the root.</param> | |
| 12 | +public sealed record ResolvedRef(string Name, ResolvedKind Kind, string CommitSha, string Path); | |
| 13 | + | |
| 14 | +/// <summary> | |
| 15 | +/// Splits "feature/x/src/a.cs" into a ref and a path. The split is ambiguous, so the longest | |
| 16 | +/// prefix that names an existing branch or tag wins; a full SHA is accepted as a fallback. | |
| 17 | +/// Input is only ever compared against the repository's own ref list, so a hostile "ref" | |
| 18 | +/// such as "--upload-pack=..." resolves to nothing and never reaches a git command line. | |
| 19 | +/// </summary> | |
| 20 | +public sealed class RefResolver(GitRepo git) | |
| 21 | +{ | |
| 22 | + public async Task<ResolvedRef?> ResolveAsync( | |
| 23 | + string repoPath, | |
| 24 | + string? refAndPath, | |
| 25 | + IReadOnlyList<GitRef>? refs = null, | |
| 26 | + CancellationToken ct = default) | |
| 27 | + { | |
| 28 | + var segments = SplitSegments(refAndPath); | |
| 29 | + if (segments is null) | |
| 30 | + { | |
| 31 | + return null; | |
| 32 | + } | |
| 33 | + | |
| 34 | + refs ??= await git.ListRefsAsync(repoPath, ct); | |
| 35 | + var match = Match(refs, segments); | |
| 36 | + if (match is not null) | |
| 37 | + { | |
| 38 | + return match; | |
| 39 | + } | |
| 40 | + | |
| 41 | + if (GitParsers.IsFullSha(segments[0])) | |
| 42 | + { | |
| 43 | + var sha = await git.ResolveCommitAsync(repoPath, segments[0], ct); | |
| 44 | + if (sha is not null) | |
| 45 | + { | |
| 46 | + return new ResolvedRef(sha, ResolvedKind.Commit, sha, string.Join('/', segments.Skip(1))); | |
| 47 | + } | |
| 48 | + } | |
| 49 | + | |
| 50 | + return null; | |
| 51 | + } | |
| 52 | + | |
| 53 | + /// <summary> | |
| 54 | + /// Resolves text that must name one whole ref or commit, with no path after it: | |
| 55 | + /// an existing branch, an existing tag, or a hex SHA. Used by compare and by "create from". | |
| 56 | + /// </summary> | |
| 57 | + public async Task<ResolvedRef?> ResolveExactAsync( | |
| 58 | + string repoPath, | |
| 59 | + string? spec, | |
| 60 | + IReadOnlyList<GitRef> refs, | |
| 61 | + CancellationToken ct = default) | |
| 62 | + { | |
| 63 | + if (string.IsNullOrEmpty(spec)) | |
| 64 | + { | |
| 65 | + return null; | |
| 66 | + } | |
| 67 | + | |
| 68 | + var found = Find(refs, spec, RefKind.Branch) ?? Find(refs, spec, RefKind.Tag); | |
| 69 | + if (found is not null && (found.ObjectType == "commit" || found.PeeledSha is not null)) | |
| 70 | + { | |
| 71 | + return new ResolvedRef( | |
| 72 | + found.Name, | |
| 73 | + found.Kind == RefKind.Branch ? ResolvedKind.Branch : ResolvedKind.Tag, | |
| 74 | + found.TargetSha, | |
| 75 | + ""); | |
| 76 | + } | |
| 77 | + | |
| 78 | + var sha = await git.ResolveCommitAsync(repoPath, spec, ct); | |
| 79 | + return sha is null ? null : new ResolvedRef(sha, ResolvedKind.Commit, sha, ""); | |
| 80 | + } | |
| 81 | + | |
| 82 | + /// <summary>Longest-prefix match against existing refs. Branches win over tags of the same name.</summary> | |
| 83 | + public static ResolvedRef? Match(IReadOnlyList<GitRef> refs, string? refAndPath) | |
| 84 | + { | |
| 85 | + var segments = SplitSegments(refAndPath); | |
| 86 | + return segments is null ? null : Match(refs, segments); | |
| 87 | + } | |
| 88 | + | |
| 89 | + private static ResolvedRef? Match(IReadOnlyList<GitRef> refs, string[] segments) | |
| 90 | + { | |
| 91 | + for (var take = segments.Length; take >= 1; take--) | |
| 92 | + { | |
| 93 | + var candidate = string.Join('/', segments, 0, take); | |
| 94 | + var found = Find(refs, candidate, RefKind.Branch) ?? Find(refs, candidate, RefKind.Tag); | |
| 95 | + if (found is null) | |
| 96 | + { | |
| 97 | + continue; | |
| 98 | + } | |
| 99 | + | |
| 100 | + // Only refs that end at a commit are browsable; a tag of a blob or tree is not. | |
| 101 | + if (found.ObjectType != "commit" && found.PeeledSha is null) | |
| 102 | + { | |
| 103 | + continue; | |
| 104 | + } | |
| 105 | + | |
| 106 | + return new ResolvedRef( | |
| 107 | + found.Name, | |
| 108 | + found.Kind == RefKind.Branch ? ResolvedKind.Branch : ResolvedKind.Tag, | |
| 109 | + found.TargetSha, | |
| 110 | + string.Join('/', segments, take, segments.Length - take)); | |
| 111 | + } | |
| 112 | + | |
| 113 | + return null; | |
| 114 | + } | |
| 115 | + | |
| 116 | + private static GitRef? Find(IReadOnlyList<GitRef> refs, string name, RefKind kind) | |
| 117 | + { | |
| 118 | + foreach (var r in refs) | |
| 119 | + { | |
| 120 | + if (r.Kind == kind && string.Equals(r.Name, name, StringComparison.Ordinal)) | |
| 121 | + { | |
| 122 | + return r; | |
| 123 | + } | |
| 124 | + } | |
| 125 | + | |
| 126 | + return null; | |
| 127 | + } | |
| 128 | + | |
| 129 | + /// <summary>Null when the input is empty or contains segments no tree path can have.</summary> | |
| 130 | + private static string[]? SplitSegments(string? refAndPath) | |
| 131 | + { | |
| 132 | + var trimmed = refAndPath?.Trim('/'); | |
| 133 | + if (string.IsNullOrEmpty(trimmed)) | |
| 134 | + { | |
| 135 | + return null; | |
| 136 | + } | |
| 137 | + | |
| 138 | + var segments = trimmed.Split('/'); | |
| 139 | + foreach (var segment in segments) | |
| 140 | + { | |
| 141 | + if (segment.Length == 0 || segment == "." || segment == ".." || segment.Contains('\0')) | |
| 142 | + { | |
| 143 | + return null; | |
| 144 | + } | |
| 145 | + } | |
| 146 | + | |
| 147 | + return segments; | |
| 148 | + } | |
| 149 | +} |
added forge/Git/RepoPaths.cs +41 −0View file
| @@ -0,0 +1,41 @@ | ||
| 1 | +using System.Globalization; | |
| 2 | +using Microsoft.Extensions.Options; | |
| 3 | + | |
| 4 | +namespace Forge.Git; | |
| 5 | + | |
| 6 | +/// <summary> | |
| 7 | +/// The only place that builds a repository path. Paths are derived from the numeric ID, | |
| 8 | +/// so nothing a user typed ever ends up in a file system path. | |
| 9 | +/// </summary> | |
| 10 | +public sealed class RepoPaths(IOptions<ForgeOptions> options) | |
| 11 | +{ | |
| 12 | + private readonly string _root = options.Value.ReposRoot; | |
| 13 | + | |
| 14 | + public string Root => _root; | |
| 15 | + | |
| 16 | + public string For(long repoId) | |
| 17 | + { | |
| 18 | + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(repoId); | |
| 19 | + return Path.Combine(_root, repoId.ToString(CultureInfo.InvariantCulture) + ".git"); | |
| 20 | + } | |
| 21 | + | |
| 22 | + /// <summary>Deletes a repository directory. Git marks pack files read-only, which blocks deletion on Windows.</summary> | |
| 23 | + public static void DeleteDirectory(string path) | |
| 24 | + { | |
| 25 | + if (!Directory.Exists(path)) | |
| 26 | + { | |
| 27 | + return; | |
| 28 | + } | |
| 29 | + | |
| 30 | + foreach (var file in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)) | |
| 31 | + { | |
| 32 | + var attributes = File.GetAttributes(file); | |
| 33 | + if ((attributes & FileAttributes.ReadOnly) != 0) | |
| 34 | + { | |
| 35 | + File.SetAttributes(file, attributes & ~FileAttributes.ReadOnly); | |
| 36 | + } | |
| 37 | + } | |
| 38 | + | |
| 39 | + Directory.Delete(path, recursive: true); | |
| 40 | + } | |
| 41 | +} |
added forge/Localization/Localizer.cs +153 −0View file
| @@ -0,0 +1,153 @@ | ||
| 1 | +using System.Globalization; | |
| 2 | +using System.Reflection; | |
| 3 | +using System.Text.Json; | |
| 4 | +using Microsoft.AspNetCore.Components; | |
| 5 | + | |
| 6 | +namespace Forge.Localization; | |
| 7 | + | |
| 8 | +/// <summary> | |
| 9 | +/// All translations, loaded once from the JSON files embedded from the Localization folder. | |
| 10 | +/// English is the source language: its text is written in the code and doubles as the lookup key, | |
| 11 | +/// so there is no en.json. Adding a language means adding one file named after its code (de.json). | |
| 12 | +/// </summary> | |
| 13 | +public sealed class Translations | |
| 14 | +{ | |
| 15 | + public const string DefaultLanguage = "en"; | |
| 16 | + | |
| 17 | + private const string ResourcePrefix = "Forge.Localization."; | |
| 18 | + private const string ResourceSuffix = ".json"; | |
| 19 | + | |
| 20 | + private readonly Dictionary<string, Dictionary<string, string[]>> _byLanguage = new(StringComparer.OrdinalIgnoreCase); | |
| 21 | + | |
| 22 | + public Translations() | |
| 23 | + { | |
| 24 | + var assembly = typeof(Translations).Assembly; | |
| 25 | + foreach (var resource in assembly.GetManifestResourceNames()) | |
| 26 | + { | |
| 27 | + if (!resource.StartsWith(ResourcePrefix, StringComparison.Ordinal) | |
| 28 | + || !resource.EndsWith(ResourceSuffix, StringComparison.Ordinal)) | |
| 29 | + { | |
| 30 | + continue; | |
| 31 | + } | |
| 32 | + | |
| 33 | + var language = resource[ResourcePrefix.Length..^ResourceSuffix.Length]; | |
| 34 | + using var stream = assembly.GetManifestResourceStream(resource)!; | |
| 35 | + _byLanguage[language] = Load(stream, resource); | |
| 36 | + } | |
| 37 | + | |
| 38 | + Languages = [DefaultLanguage, .. _byLanguage.Keys.Order(StringComparer.Ordinal)]; | |
| 39 | + } | |
| 40 | + | |
| 41 | + /// <summary>Language codes, English first.</summary> | |
| 42 | + public IReadOnlyList<string> Languages { get; } | |
| 43 | + | |
| 44 | + /// <summary>The translated forms for a key, or null when the language has none (callers fall back to English).</summary> | |
| 45 | + public string[]? Find(string language, string key) => | |
| 46 | + _byLanguage.TryGetValue(language, out var entries) && entries.TryGetValue(key, out var forms) ? forms : null; | |
| 47 | + | |
| 48 | + public IReadOnlyCollection<string> KeysOf(string language) => | |
| 49 | + _byLanguage.TryGetValue(language, out var entries) ? entries.Keys : []; | |
| 50 | + | |
| 51 | + /// <summary>A value is either one string, or an array of plural forms.</summary> | |
| 52 | + private static Dictionary<string, string[]> Load(Stream stream, string resource) | |
| 53 | + { | |
| 54 | + using var document = JsonDocument.Parse(stream, new JsonDocumentOptions { CommentHandling = JsonCommentHandling.Skip }); | |
| 55 | + var entries = new Dictionary<string, string[]>(StringComparer.Ordinal); | |
| 56 | + foreach (var property in document.RootElement.EnumerateObject()) | |
| 57 | + { | |
| 58 | + entries[property.Name] = property.Value.ValueKind switch | |
| 59 | + { | |
| 60 | + JsonValueKind.String => [property.Value.GetString()!], | |
| 61 | + JsonValueKind.Array => property.Value.EnumerateArray().Select(v => v.GetString()!).ToArray(), | |
| 62 | + _ => throw new InvalidDataException($"{resource}: the value of \"{property.Name}\" must be a string or an array of strings."), | |
| 63 | + }; | |
| 64 | + } | |
| 65 | + | |
| 66 | + return entries; | |
| 67 | + } | |
| 68 | +} | |
| 69 | + | |
| 70 | +/// <summary> | |
| 71 | +/// Translates UI text into the language of the current request, which the request localization | |
| 72 | +/// middleware has stored in <see cref="CultureInfo.CurrentUICulture"/>. Injected into every component as T. | |
| 73 | +/// </summary> | |
| 74 | +public sealed class Localizer(Translations translations) | |
| 75 | +{ | |
| 76 | + /// <summary>The supported language of the current request: "en", "sk", …</summary> | |
| 77 | + public string Language | |
| 78 | + { | |
| 79 | + get | |
| 80 | + { | |
| 81 | + for (var culture = CultureInfo.CurrentUICulture; culture.Name.Length > 0; culture = culture.Parent) | |
| 82 | + { | |
| 83 | + if (translations.Languages.Contains(culture.Name, StringComparer.OrdinalIgnoreCase)) | |
| 84 | + { | |
| 85 | + return culture.Name; | |
| 86 | + } | |
| 87 | + } | |
| 88 | + | |
| 89 | + return Translations.DefaultLanguage; | |
| 90 | + } | |
| 91 | + } | |
| 92 | + | |
| 93 | + public IReadOnlyList<string> Languages => translations.Languages; | |
| 94 | + | |
| 95 | + /// <summary>Translates English text. Untranslated text comes back unchanged.</summary> | |
| 96 | + public string this[string english] => translations.Find(Language, english)?[0] ?? english; | |
| 97 | + | |
| 98 | + /// <summary>Translates an English template and fills its {0}, {1}… placeholders.</summary> | |
| 99 | + public string this[string english, params object?[] args] => | |
| 100 | + string.Format(CultureInfo.CurrentCulture, this[english], args); | |
| 101 | + | |
| 102 | + /// <summary> | |
| 103 | + /// Translates text that contains markup, such as <code>. Only for constant text: | |
| 104 | + /// nothing is encoded, so user data must never be put into it. | |
| 105 | + /// </summary> | |
| 106 | + public MarkupString Html(string english) => new(this[english]); | |
| 107 | + | |
| 108 | + /// <summary> | |
| 109 | + /// Picks the plural form for <paramref name="count"/> and fills {0} with it. English has two forms; | |
| 110 | + /// a translation supplies as many as its language needs, as an array under the key "one|other". | |
| 111 | + /// </summary> | |
| 112 | + public string Plural(long count, string one, string other) | |
| 113 | + { | |
| 114 | + var language = Language; | |
| 115 | + var forms = translations.Find(language, one + "|" + other) ?? [one, other]; | |
| 116 | + var index = Math.Min(PluralIndex(language, count), forms.Length - 1); | |
| 117 | + return string.Format(CultureInfo.CurrentCulture, forms[index], count); | |
| 118 | + } | |
| 119 | + | |
| 120 | + /// <summary>"3 hours ago". The exact time belongs in a title attribute next to it.</summary> | |
| 121 | + public string RelativeTime(DateTimeOffset value, DateTimeOffset now) | |
| 122 | + { | |
| 123 | + var delta = now - value; | |
| 124 | + return delta switch | |
| 125 | + { | |
| 126 | + _ when delta.TotalSeconds < 45 => this["just now"], | |
| 127 | + _ when delta.TotalMinutes < 1.5 => this["a minute ago"], | |
| 128 | + _ when delta.TotalMinutes < 60 => this["{0} minutes ago", (int)Math.Round(delta.TotalMinutes)], | |
| 129 | + _ when delta.TotalHours < 1.5 => this["an hour ago"], | |
| 130 | + _ when delta.TotalHours < 24 => this["{0} hours ago", (int)Math.Round(delta.TotalHours)], | |
| 131 | + _ when delta.TotalDays < 2 => this["yesterday"], | |
| 132 | + _ when delta.TotalDays < 30 => this["{0} days ago", (int)Math.Floor(delta.TotalDays)], | |
| 133 | + _ when delta.TotalDays < 60 => this["a month ago"], | |
| 134 | + _ when delta.TotalDays < 365 => this["{0} months ago", (int)Math.Floor(delta.TotalDays / 30)], | |
| 135 | + _ when delta.TotalDays < 730 => this["a year ago"], | |
| 136 | + _ => this["{0} years ago", (int)Math.Floor(delta.TotalDays / 365)], | |
| 137 | + }; | |
| 138 | + } | |
| 139 | + | |
| 140 | + /// <summary> | |
| 141 | + /// Marks English text in code that is translated later, where it is displayed (validation messages | |
| 142 | + /// returned by services). It returns its argument; the marker lets the tests find every key. | |
| 143 | + /// </summary> | |
| 144 | + public static string Key(string english) => english; | |
| 145 | + | |
| 146 | + /// <summary>Which plural form a count takes. Languages not listed use the English rule.</summary> | |
| 147 | + private static int PluralIndex(string language, long count) => language.ToLowerInvariant() switch | |
| 148 | + { | |
| 149 | + // One, few (2 to 4), many. | |
| 150 | + "sk" or "cs" => count == 1 ? 0 : count is >= 2 and <= 4 ? 1 : 2, | |
| 151 | + _ => count == 1 ? 0 : 1, | |
| 152 | + }; | |
| 153 | +} |
added forge/Localization/sk.json +407 −0View file
| @@ -0,0 +1,407 @@ | ||
| 1 | +{ | |
| 2 | + // Slovak. Keys are the English text exactly as written in the code. | |
| 3 | + // A value is a string, or for plurals an array: [one, few (2 to 4), many]. | |
| 4 | + | |
| 5 | + "New repository": "Nový repozitár", | |
| 6 | + "Sign out ({0})": "Odhlásiť sa ({0})", | |
| 7 | + "Sign in": "Prihlásiť sa", | |
| 8 | + "Language": "Jazyk", | |
| 9 | + "Skip to content": "Preskočiť na obsah", | |
| 10 | + "Search repositories": "Hľadať repozitáre", | |
| 11 | + "Switch theme": "Prepnúť tému", | |
| 12 | + "Account menu": "Menu účtu", | |
| 13 | + "Signed in as": "Prihlásený ako", | |
| 14 | + "Your repositories": "Tvoje repozitáre", | |
| 15 | + "self-hosted Git": "vlastný Git server", | |
| 16 | + "Keyboard shortcuts": "Klávesové skratky", | |
| 17 | + "Open the permalink of the file being viewed": "Otvoriť permalink zobrazeného súboru", | |
| 18 | + "Show this help": "Zobraziť túto nápovedu", | |
| 19 | + "Close": "Zavrieť", | |
| 20 | + | |
| 21 | + "Not found": "Nenájdené", | |
| 22 | + "Error": "Chyba", | |
| 23 | + "This page does not exist": "Táto stránka neexistuje", | |
| 24 | + "The request could not be processed": "Požiadavku sa nepodarilo spracovať", | |
| 25 | + "Too many attempts": "Priveľa pokusov", | |
| 26 | + "Something went wrong": "Niečo sa pokazilo", | |
| 27 | + "The address is wrong, or you do not have access to this content.": "Adresa je nesprávna, alebo na obsah nemáš prístup.", | |
| 28 | + "The form may have expired. Reload the page and try again.": "Formulár mohol vypršať. Načítaj stránku znova a skús to ešte raz.", | |
| 29 | + "Wait a minute and try again.": "Počkaj minútu a skús to znova.", | |
| 30 | + "Try again in a moment.": "Skús to znova o chvíľu.", | |
| 31 | + "Back to the repository list": "Späť na zoznam repozitárov", | |
| 32 | + | |
| 33 | + "just now": "práve teraz", | |
| 34 | + "a minute ago": "pred minútou", | |
| 35 | + "{0} minutes ago": "pred {0} minútami", | |
| 36 | + "an hour ago": "pred hodinou", | |
| 37 | + "{0} hours ago": "pred {0} hodinami", | |
| 38 | + "yesterday": "včera", | |
| 39 | + "{0} days ago": "pred {0} dňami", | |
| 40 | + "a month ago": "pred mesiacom", | |
| 41 | + "{0} months ago": "pred {0} mesiacmi", | |
| 42 | + "a year ago": "pred rokom", | |
| 43 | + "{0} years ago": "pred {0} rokmi", | |
| 44 | + | |
| 45 | + "public": "verejný", | |
| 46 | + "private": "súkromný", | |
| 47 | + "Code": "Kód", | |
| 48 | + "Commits": "Commity", | |
| 49 | + "Branches": "Branche", | |
| 50 | + "Tags": "Tagy", | |
| 51 | + "Settings": "Nastavenia", | |
| 52 | + "Copy": "Kopírovať", | |
| 53 | + "Copied": "Skopírované", | |
| 54 | + "Clone URL": "Clone URL", | |
| 55 | + "branch": "branch", | |
| 56 | + "tag": "tag", | |
| 57 | + "commit": "commit", | |
| 58 | + "Path": "Cesta", | |
| 59 | + "(no message)": "(bez správy)", | |
| 60 | + | |
| 61 | + "Repositories": "Repozitáre", | |
| 62 | + "There are no repositories here yet.": "Zatiaľ tu nie sú žiadne repozitáre.", | |
| 63 | + "Create your first repository": "Vytvor prvý repozitár", | |
| 64 | + "and push your code to it.": "a pushni doň svoj kód.", | |
| 65 | + "pushed": "push", | |
| 66 | + "empty": "prázdny", | |
| 67 | + "Joined": "Účet vytvorený", | |
| 68 | + "{0} repository|{0} repositories": ["{0} repozitár", "{0} repozitáre", "{0} repozitárov"], | |
| 69 | + "Find a repository": "Nájsť repozitár", | |
| 70 | + "Sort": "Zoradenie", | |
| 71 | + "Recently updated": "Naposledy zmenené", | |
| 72 | + "No repository matches “{0}”.": "Hľadaniu „{0}“ nezodpovedá žiadny repozitár.", | |
| 73 | + "Clear the search": "Zrušiť hľadanie", | |
| 74 | + | |
| 75 | + "First run": "Prvé spustenie", | |
| 76 | + "Welcome to Forge": "Vitaj vo Forge", | |
| 77 | + "Create your account. This page then closes for good.": "Vytvor si účet. Táto stránka sa potom natrvalo zatvorí.", | |
| 78 | + "Username": "Používateľské meno", | |
| 79 | + "It becomes part of your repository addresses.": "Bude súčasťou adries tvojich repozitárov.", | |
| 80 | + "Display name": "Zobrazované meno", | |
| 81 | + "Password": "Heslo", | |
| 82 | + "Repeat password": "Heslo znova", | |
| 83 | + "Create account": "Vytvoriť účet", | |
| 84 | + "The passwords do not match.": "Heslá sa nezhodujú.", | |
| 85 | + "A username may contain letters, digits, hyphens and underscores (1 to 39 characters) and must start with a letter or digit.": "Meno môže obsahovať písmená, číslice, pomlčku a podčiarkovník (1 až 39 znakov) a musí začínať písmenom alebo číslicou.", | |
| 86 | + "This username is reserved.": "Toto meno je vyhradené.", | |
| 87 | + "The password must be at least {0} characters long.": "Heslo musí mať aspoň {0} znakov.", | |
| 88 | + "Wrong username or password.": "Nesprávne meno alebo heslo.", | |
| 89 | + | |
| 90 | + "Access tokens": "Access tokeny", | |
| 91 | + "A token is the password for <code>git clone</code> and <code>git push</code> over HTTPS. Any username works.": "Token je heslo pre <code>git clone</code> a <code>git push</code> cez HTTPS. Ako meno môžeš zadať čokoľvek.", | |
| 92 | + "The token is created. Copy it now, it will not be shown again.": "Token je vytvorený. Skopíruj si ho teraz, znova sa už nezobrazí.", | |
| 93 | + "New token": "Nový token", | |
| 94 | + "Name": "Názov", | |
| 95 | + "e.g. laptop": "napr. notebook", | |
| 96 | + "Permission": "Oprávnenie", | |
| 97 | + "Read only (clone, fetch)": "Len čítanie (clone, fetch)", | |
| 98 | + "Read and write (push)": "Čítanie aj zápis (push)", | |
| 99 | + "Expires": "Platnosť", | |
| 100 | + "30 days": "30 dní", | |
| 101 | + "90 days": "90 dní", | |
| 102 | + "1 year": "1 rok", | |
| 103 | + "No expiry": "Bez expirácie", | |
| 104 | + "Create token": "Vytvoriť token", | |
| 105 | + "Existing tokens": "Existujúce tokeny", | |
| 106 | + "You have no tokens yet.": "Zatiaľ nemáš žiadny token.", | |
| 107 | + "Created": "Vytvorený", | |
| 108 | + "Last used": "Naposledy použitý", | |
| 109 | + "Valid until": "Platí do", | |
| 110 | + "read and write": "čítanie a zápis", | |
| 111 | + "read only": "len čítanie", | |
| 112 | + "never": "nikdy", | |
| 113 | + "expired {0}": "vypršal {0}", | |
| 114 | + "no expiry": "bez expirácie", | |
| 115 | + "Revoke": "Zrušiť", | |
| 116 | + "Enter a token name (at most 100 characters).": "Zadaj názov tokenu (najviac 100 znakov).", | |
| 117 | + "Choose an expiry from the list.": "Vyber platnosť zo zoznamu.", | |
| 118 | + | |
| 119 | + "Letters, digits, dots, hyphens and underscores.": "Písmená, číslice, bodka, pomlčka a podčiarkovník.", | |
| 120 | + "Description": "Popis", | |
| 121 | + "(optional)": "(nepovinný)", | |
| 122 | + "Visibility": "Viditeľnosť", | |
| 123 | + "Private: only you can see it": "Súkromný: vidíš ho len ty", | |
| 124 | + "Public: anyone can read and clone it": "Verejný: ktokoľvek ho môže čítať a klonovať", | |
| 125 | + "Create repository": "Vytvoriť repozitár", | |
| 126 | + "The description can be at most 300 characters.": "Popis môže mať najviac 300 znakov.", | |
| 127 | + "A name may contain letters, digits, dots, hyphens and underscores (1 to 100 characters).": "Názov môže obsahovať písmená, číslice, bodku, pomlčku a podčiarkovník (1 až 100 znakov).", | |
| 128 | + "A name must not contain '..'.": "Názov nesmie obsahovať „..“.", | |
| 129 | + "A name must not end with '.git'.": "Názov nesmie končiť na „.git“.", | |
| 130 | + "A repository with this name already exists.": "Repozitár s týmto názvom už existuje.", | |
| 131 | + "The repository could not be created on disk. See the server log for details.": "Repozitár sa nepodarilo vytvoriť na disku. Podrobnosti sú v logu servera.", | |
| 132 | + "There is no such branch in the repository.": "Taký branch v repozitári nie je.", | |
| 133 | + | |
| 134 | + "The repository is empty": "Repozitár je prázdny", | |
| 135 | + "Clone it and push the first commit:": "Naklonuj ho a pushni prvý commit:", | |
| 136 | + "Or push an existing repository:": "Alebo pushni existujúci repozitár:", | |
| 137 | + "Use an access token with write permission as the password.": "Ako heslo použi access token s právom zápisu.", | |
| 138 | + "Create a token": "Vytvoriť token", | |
| 139 | + "History": "História", | |
| 140 | + "Activity": "Aktivita", | |
| 141 | + "Activity on {0}": "Aktivita na {0}", | |
| 142 | + "Only the newest {0} commits are counted.": "Počíta sa len {0} najnovších commitov.", | |
| 143 | + "Contributors": "Prispievatelia", | |
| 144 | + "Commits in the last 30 days": "Commity za posledných 30 dní", | |
| 145 | + "First commit": "Prvý commit", | |
| 146 | + "Commits per week": "Commity za týždeň", | |
| 147 | + "The last 52 weeks, {0} in total": "Posledných 52 týždňov, spolu {0}", | |
| 148 | + "Week of {0}": "Týždeň od {0}", | |
| 149 | + "Only the first {0} contributors are shown.": "Zobrazuje sa len prvých {0} prispievateľov.", | |
| 150 | + "Search": "Hľadať", | |
| 151 | + "Search file names and code": "Hľadať v názvoch súborov a v kóde", | |
| 152 | + "Search this repository": "Hľadanie v repozitári", | |
| 153 | + "Type at least {0} characters. Upper and lower case do not matter.": "Napíš aspoň {0} znaky. Na veľkosti písmen nezáleží.", | |
| 154 | + "Nothing in {0} matches “{1}”.": "V {0} sa nenašlo nič pre „{1}“.", | |
| 155 | + "Results for “{0}” in {1}": "Výsledky pre „{0}“ v {1}", | |
| 156 | + "File names": "Názvy súborov", | |
| 157 | + "Only the first {0} files are shown.": "Zobrazuje sa len prvých {0} súborov.", | |
| 158 | + "There are more matches than shown. Make the search more specific.": "Zhôd je viac, než sa zobrazuje. Spresni hľadanie.", | |
| 159 | + "Clone": "Klonovať", | |
| 160 | + "Clone over HTTP": "Klonovanie cez HTTP", | |
| 161 | + "Use an access token as the password.": "Ako heslo použi access token.", | |
| 162 | + "Parent directory": "Nadradený priečinok", | |
| 163 | + "About": "O repozitári", | |
| 164 | + "No description.": "Bez popisu.", | |
| 165 | + "{0} branch|{0} branches": ["{0} branch", "{0} branche", "{0} branchov"], | |
| 166 | + "{0} tag|{0} tags": ["{0} tag", "{0} tagy", "{0} tagov"], | |
| 167 | + "Commit feed (Atom)": "Feed commitov (Atom)", | |
| 168 | + "Languages": "Jazyky", | |
| 169 | + "Other": "Ostatné", | |
| 170 | + "Submodule {0}": "Submodul {0}", | |
| 171 | + | |
| 172 | + "{0} line|{0} lines": ["{0} riadok", "{0} riadky", "{0} riadkov"], | |
| 173 | + "Raw": "Raw", | |
| 174 | + "Preview": "Náhľad", | |
| 175 | + "Permalink": "Permalink", | |
| 176 | + "A link to this exact version of the file": "Odkaz na presne túto verziu súboru", | |
| 177 | + "Commits on {0}": "Commity zo dňa {0}", | |
| 178 | + "Copy the full SHA": "Kopírovať celé SHA", | |
| 179 | + "The file is {0} and too large to display.": "Súbor má {0} a je príliš veľký na zobrazenie.", | |
| 180 | + "Open raw": "Otvoriť raw", | |
| 181 | + "A binary file cannot be displayed.": "Binárny súbor sa nedá zobraziť.", | |
| 182 | + "Download": "Stiahnuť", | |
| 183 | + "The file is empty.": "Súbor je prázdny.", | |
| 184 | + | |
| 185 | + "History of path": "História cesty", | |
| 186 | + "Full history": "Celá história", | |
| 187 | + "No more commits.": "Žiadne ďalšie commity.", | |
| 188 | + "← Newer": "← Novšie", | |
| 189 | + "Older →": "Staršie →", | |
| 190 | + | |
| 191 | + "The diff is too large; only part of it is shown.": "Diff je príliš veľký, zobrazuje sa len jeho časť.", | |
| 192 | + "added": "pridaný", | |
| 193 | + "deleted": "zmazaný", | |
| 194 | + "renamed": "premenovaný", | |
| 195 | + "copied": "skopírovaný", | |
| 196 | + "modified": "zmenený", | |
| 197 | + "Binary file, diff not shown.": "Binárny súbor, diff sa nezobrazuje.", | |
| 198 | + "The diff is too large (more than {0} lines).": "Diff je príliš veľký (viac ako {0} riadkov).", | |
| 199 | + "No content changes.": "Bez zmien v obsahu.", | |
| 200 | + "No content changes (empty file or mode change).": "Žiadne zmeny v obsahu (prázdny súbor alebo zmena práv).", | |
| 201 | + "No newline at end of file": "Bez znaku nového riadka na konci súboru", | |
| 202 | + | |
| 203 | + "Author": "Autor", | |
| 204 | + "Committer": "Commiter", | |
| 205 | + "Commit": "Commit", | |
| 206 | + "Parent": "Rodič", | |
| 207 | + "Parents": "Rodičia", | |
| 208 | + "none (first commit)": "žiadny (prvý commit)", | |
| 209 | + "Browse files at this commit": "Prehliadať súbory v tomto commite", | |
| 210 | + "{0} changed file|{0} changed files": ["{0} zmenený súbor", "{0} zmenené súbory", "{0} zmenených súborov"], | |
| 211 | + "Merge commit: changes are shown against the first parent.": "Merge commit: zmeny sú oproti prvému rodičovi.", | |
| 212 | + "bin": "bin", | |
| 213 | + | |
| 214 | + "This repository has no branches yet.": "Repozitár zatiaľ nemá žiadny branch.", | |
| 215 | + "Branch": "Branch", | |
| 216 | + "Last commit": "Posledný commit", | |
| 217 | + "Compared to {0}": "Oproti {0}", | |
| 218 | + "Commits ahead of and behind the default branch": "Commity navyše a chýbajúce oproti default branchu", | |
| 219 | + "default": "default", | |
| 220 | + "{0} ahead, {1} behind": "{0} commitov navyše, {1} chýba", | |
| 221 | + | |
| 222 | + "This repository has no tags yet.": "Repozitár zatiaľ nemá žiadny tag.", | |
| 223 | + "Tag": "Tag", | |
| 224 | + "Message": "Správa", | |
| 225 | + | |
| 226 | + "Compare": "Porovnanie", | |
| 227 | + "Merge into": "Zlúčiť do", | |
| 228 | + "from": "z", | |
| 229 | + "Show comparison": "Porovnať", | |
| 230 | + "Choose two branches to compare.": "Vyber dva branche na porovnanie.", | |
| 231 | + "These are the same commit. There is nothing to compare.": "Je to ten istý commit. Nie je čo porovnávať.", | |
| 232 | + "{0} commit|{0} commits": ["{0} commit", "{0} commity", "{0} commitov"], | |
| 233 | + "Merge {0} into {1}": "Zlúčiť {0} do {1}", | |
| 234 | + "{0} is already part of {1}. There is nothing to merge.": "{0} je už súčasťou {1}. Nie je čo zlučovať.", | |
| 235 | + "These branches can be merged automatically.": "Tieto branche sa dajú zlúčiť automaticky.", | |
| 236 | + "These branches have conflicts.": "Tieto branche majú konflikty.", | |
| 237 | + "Resolve conflicts": "Vyriešiť konflikty", | |
| 238 | + "Rebase onto the base branch": "Rebase na základný branch", | |
| 239 | + "The branch has too many commits to rebase here.": "Branch má priveľa commitov na rebase tu.", | |
| 240 | + "The branch contains merge commits and cannot be rebased here.": "Branch obsahuje merge commity a tu sa rebasovať nedá.", | |
| 241 | + "Show changes since the branches diverged": "Zobraziť zmeny od rozídenia branchov", | |
| 242 | + "Show the direct difference between both ends": "Zobraziť priamy rozdiel medzi oboma koncami", | |
| 243 | + | |
| 244 | + "Unified": "Zjednotený", | |
| 245 | + "Side by side": "Vedľa seba", | |
| 246 | + "Show whitespace changes": "Zobraziť zmeny bielych znakov", | |
| 247 | + "Hide whitespace changes": "Skryť zmeny bielych znakov", | |
| 248 | + "View file": "Zobraziť súbor", | |
| 249 | + | |
| 250 | + "Apply to branch": "Aplikovať na branch", | |
| 251 | + "Revert": "Revert", | |
| 252 | + "Cherry-pick": "Cherry-pick", | |
| 253 | + "Merge commits and the first commit cannot be reverted or cherry-picked here.": "Merge commity a prvý commit sa tu nedajú revertnúť ani cherry-picknúť.", | |
| 254 | + "The change conflicts with the branch and cannot be applied automatically.": "Zmena je v konflikte s branchom a nedá sa aplikovať automaticky.", | |
| 255 | + "The branch already contains this change. There is nothing to do.": "Branch túto zmenu už obsahuje. Nie je čo robiť.", | |
| 256 | + | |
| 257 | + "Resolve conflicts: {0} into {1}": "Riešenie konfliktov: {0} do {1}", | |
| 258 | + "These branches have no conflicts.": "Tieto branche nemajú konflikty.", | |
| 259 | + "Back to the comparison": "Späť na porovnanie", | |
| 260 | + "Choose a version for every file, or edit the text and remove the conflict markers. Saving creates the merge commit.": "Pre každý súbor vyber verziu, alebo uprav text a odstráň značky konfliktu. Uložením vznikne merge commit.", | |
| 261 | + "Keep the version from {0}": "Ponechať verziu z {0}", | |
| 262 | + "Take the version from {0}": "Prevziať verziu z {0}", | |
| 263 | + "Delete the file (as on {0})": "Zmazať súbor (ako na {0})", | |
| 264 | + "Use the text below": "Použiť text nižšie", | |
| 265 | + "This file is binary or too large to edit here.": "Súbor je binárny alebo príliš veľký na úpravu tu.", | |
| 266 | + "Resolve and merge": "Vyriešiť a zlúčiť", | |
| 267 | + "Choose a resolution for every conflicting file.": "Vyber riešenie pre každý súbor s konfliktom.", | |
| 268 | + "The edited text still contains conflict markers.": "Upravený text stále obsahuje značky konfliktu.", | |
| 269 | + | |
| 270 | + "Pull requests": "Pull requesty", | |
| 271 | + "Open ({0})": "Otvorené ({0})", | |
| 272 | + "Closed ({0})": "Zatvorené ({0})", | |
| 273 | + "New pull request": "Nový pull request", | |
| 274 | + "There are no open pull requests.": "Nie sú žiadne otvorené pull requesty.", | |
| 275 | + "There are no closed pull requests.": "Nie sú žiadne zatvorené pull requesty.", | |
| 276 | + "open": "otvorený", | |
| 277 | + "merged": "zlúčený", | |
| 278 | + "closed": "zatvorený", | |
| 279 | + "There is an open pull request for these branches:": "Pre tieto branche je otvorený pull request:", | |
| 280 | + "Open a pull request": "Otvoriť pull request", | |
| 281 | + "Open pull request": "Otvoriť pull request", | |
| 282 | + "Title": "Názov", | |
| 283 | + "(optional, Markdown)": "(nepovinný, Markdown)", | |
| 284 | + "Enter a title (at most 200 characters).": "Zadaj názov (najviac 200 znakov).", | |
| 285 | + "The text is too long.": "Text je príliš dlhý.", | |
| 286 | + "An open pull request for these branches already exists.": "Pre tieto branche už existuje otvorený pull request.", | |
| 287 | + "This pull request can no longer be merged.": "Tento pull request sa už nedá zlúčiť.", | |
| 288 | + "A branch of this pull request no longer exists, so it cannot be reopened.": "Branch tohto pull requestu už neexistuje, preto sa nedá znova otvoriť.", | |
| 289 | + "A branch of this pull request no longer exists.": "Branch tohto pull requestu už neexistuje.", | |
| 290 | + "Merged into {0}.": "Zlúčené do {0}.", | |
| 291 | + "Edit title and description": "Upraviť názov a popis", | |
| 292 | + "Close pull request": "Zatvoriť pull request", | |
| 293 | + "Reopen pull request": "Znova otvoriť pull request", | |
| 294 | + "{0} comment|{0} comments": ["{0} komentár", "{0} komentáre", "{0} komentárov"], | |
| 295 | + "Add a comment": "Pridať komentár", | |
| 296 | + "(Markdown)": "(Markdown)", | |
| 297 | + "Comment": "Komentovať", | |
| 298 | + "Write a comment first.": "Najprv napíš komentár.", | |
| 299 | + | |
| 300 | + "Protected branches": "Chránené branche", | |
| 301 | + "A protected branch cannot be force-pushed or deleted, from git or from the web. Merging into it still works.": "Chránený branch sa nedá force-pushnúť ani zmazať, z gitu ani z webu. Merge doň funguje ďalej.", | |
| 302 | + "No branch is protected yet.": "Zatiaľ nie je chránený žiadny branch.", | |
| 303 | + "Direct pushes": "Priame pushe", | |
| 304 | + "refused, changes only through merges on the web": "odmietnuté, zmeny len cez merge na webe", | |
| 305 | + "allowed": "povolené", | |
| 306 | + "Remove protection": "Zrušiť ochranu", | |
| 307 | + "Protect a branch": "Chrániť branch", | |
| 308 | + "A branch name, or a prefix ending in <code>/*</code> such as <code>release/*</code>.": "Názov branchu, alebo prefix končiaci na <code>/*</code>, napríklad <code>release/*</code>.", | |
| 309 | + "Also refuse direct pushes (changes only through merges on the web)": "Odmietať aj priame pushe (zmeny len cez merge na webe)", | |
| 310 | + "Protect": "Chrániť", | |
| 311 | + "This branch is already protected.": "Tento branch je už chránený.", | |
| 312 | + "This branch is protected and cannot be deleted.": "Tento branch je chránený a nedá sa zmazať.", | |
| 313 | + "Conflicting files:": "Súbory s konfliktom:", | |
| 314 | + "Method": "Spôsob", | |
| 315 | + "Merge commit": "Merge commit", | |
| 316 | + "Squash into one commit": "Squash do jedného commitu", | |
| 317 | + "Fast-forward": "Fast-forward", | |
| 318 | + "Commit message": "Správa commitu", | |
| 319 | + "(optional, a default is used if empty)": "(nepovinná, inak sa použije predvolená)", | |
| 320 | + "Delete branch {0} after merging": "Po zlúčení zmazať branch {0}", | |
| 321 | + "Merge": "Zlúčiť", | |
| 322 | + "Choose two different branches.": "Vyber dva rôzne branche.", | |
| 323 | + "There is nothing to merge.": "Nie je čo zlučovať.", | |
| 324 | + "The branches have no common history and cannot be merged here.": "Branche nemajú spoločnú históriu a tu sa zlúčiť nedajú.", | |
| 325 | + "Fast-forward is not possible because the branches have diverged.": "Fast-forward nie je možný, lebo branche sa rozišli.", | |
| 326 | + "The branches have conflicts and cannot be merged automatically.": "Branche majú konflikty a nedajú sa zlúčiť automaticky.", | |
| 327 | + "The branch changed in the meantime. Reload the page and try again.": "Branch sa medzitým zmenil. Načítaj stránku znova a skús to ešte raz.", | |
| 328 | + | |
| 329 | + "Delete": "Zmazať", | |
| 330 | + "New branch": "Nový branch", | |
| 331 | + "From": "Z", | |
| 332 | + "(branch, tag or commit SHA)": "(branch, tag alebo SHA commitu)", | |
| 333 | + "Create branch": "Vytvoriť branch", | |
| 334 | + "Branch {0} was created.": "Branch {0} bol vytvorený.", | |
| 335 | + "Branch {0} was deleted (it pointed at {1}).": "Branch {0} bol zmazaný (ukazoval na {1}).", | |
| 336 | + "This is not a valid branch name.": "Toto nie je platný názov branchu.", | |
| 337 | + "A branch with this name already exists.": "Branch s týmto názvom už existuje.", | |
| 338 | + "The default branch cannot be deleted. Choose another default branch first.": "Default branch sa nedá zmazať. Najprv nastav iný default branch.", | |
| 339 | + "The starting point does not exist.": "Východiskový bod neexistuje.", | |
| 340 | + "New tag": "Nový tag", | |
| 341 | + "Create tag": "Vytvoriť tag", | |
| 342 | + "Tag {0} was created.": "Tag {0} bol vytvorený.", | |
| 343 | + "Tag {0} was deleted (it pointed at {1}).": "Tag {0} bol zmazaný (ukazoval na {1}).", | |
| 344 | + "This is not a valid tag name.": "Toto nie je platný názov tagu.", | |
| 345 | + "A tag with this name already exists.": "Tag s týmto názvom už existuje.", | |
| 346 | + "There is no such tag in the repository.": "Taký tag v repozitári nie je.", | |
| 347 | + "There are no new commits between these two commits.": "Medzi týmito commitmi nie sú žiadne nové commity.", | |
| 348 | + "Showing the first {0} commits.": "Zobrazuje sa prvých {0} commitov.", | |
| 349 | + | |
| 350 | + "General": "Všeobecné", | |
| 351 | + "Webhooks": "Webhooky", | |
| 352 | + "Description and visibility": "Popis a viditeľnosť", | |
| 353 | + "Private": "Súkromný", | |
| 354 | + "Public": "Verejný", | |
| 355 | + "Save": "Uložiť", | |
| 356 | + "Default branch": "Default branch", | |
| 357 | + "The branch that is shown first and that <code>git clone</code> checks out": "Branch, ktorý sa zobrazí ako prvý a ktorý dostane <code>git clone</code>", | |
| 358 | + "Set": "Nastaviť", | |
| 359 | + "Rename repository": "Premenovanie", | |
| 360 | + "Rename": "Premenovať", | |
| 361 | + "The repository address changes. Old clone URLs stop working.": "Zmení sa adresa repozitára. Staré clone URL prestanú fungovať.", | |
| 362 | + "New name": "Nový názov", | |
| 363 | + "Delete this repository": "Zmazanie repozitára", | |
| 364 | + "Delete repository": "Zmazať repozitár", | |
| 365 | + "This deletes the code, the history and the webhooks. It cannot be undone.": "Zmaže sa kód, história aj webhooky. Nedá sa to vrátiť.", | |
| 366 | + "To confirm, type the repository name:": "Na potvrdenie napíš názov repozitára:", | |
| 367 | + "Saved.": "Uložené.", | |
| 368 | + "The default branch is set.": "Default branch je nastavený.", | |
| 369 | + "The name does not match. The repository was not deleted.": "Názov sa nezhoduje. Repozitár ostal nezmazaný.", | |
| 370 | + | |
| 371 | + "After every push Forge sends signed JSON to the given address. Useful for triggering an external CI.": "Po každom pushi pošle Forge na zadanú adresu podpísaný JSON. Hodí sa na spustenie externého CI.", | |
| 372 | + "This repository has no webhooks yet.": "Tento repozitár zatiaľ nemá žiadny webhook.", | |
| 373 | + "URL": "URL", | |
| 374 | + "Status": "Stav", | |
| 375 | + "Last delivery": "Posledné doručenie", | |
| 376 | + "active": "aktívny", | |
| 377 | + "disabled": "vypnutý", | |
| 378 | + "none yet": "zatiaľ žiadne", | |
| 379 | + "Add webhook": "Pridať webhook", | |
| 380 | + "Secret": "Tajomstvo", | |
| 381 | + "(optional, generated if empty)": "(nepovinné, inak sa vygeneruje)", | |
| 382 | + "Used to sign <code>X-Forge-Signature</code> (HMAC-SHA256 of the request body).": "Slúži na podpis <code>X-Forge-Signature</code> (HMAC-SHA256 tela požiadavky).", | |
| 383 | + "Enter a full address starting with http:// or https://.": "Zadaj celú adresu začínajúcu na http:// alebo https://.", | |
| 384 | + "in progress": "prebieha", | |
| 385 | + "failed": "zlyhalo", | |
| 386 | + | |
| 387 | + "Webhook": "Webhook", | |
| 388 | + "Event": "Udalosť", | |
| 389 | + "Send test ping": "Poslať testovací ping", | |
| 390 | + "Disable": "Vypnúť", | |
| 391 | + "Enable": "Zapnúť", | |
| 392 | + "Delete webhook": "Zmazať webhook", | |
| 393 | + "Delivery history": "História doručení", | |
| 394 | + "No deliveries yet. Push to the repository or send a test ping.": "Zatiaľ žiadne doručenie. Pushni do repozitára alebo pošli testovací ping.", | |
| 395 | + "Result": "Výsledok", | |
| 396 | + "Attempt": "Pokus", | |
| 397 | + "Duration": "Trvanie", | |
| 398 | + "When": "Kedy", | |
| 399 | + "Redeliver": "Redeliver", | |
| 400 | + "The ping was delivered.": "Ping bol doručený.", | |
| 401 | + "The ping could not be delivered. See the history below for details.": "Ping sa nepodarilo doručiť. Podrobnosti sú v histórii nižšie.", | |
| 402 | + "The webhook is enabled.": "Webhook je zapnutý.", | |
| 403 | + "The webhook is disabled.": "Webhook je vypnutý.", | |
| 404 | + "This delivery cannot be repeated.": "Toto doručenie sa nedá zopakovať.", | |
| 405 | + "Delivered again.": "Doručené znova.", | |
| 406 | + "Redelivery failed. See the history below for details.": "Opakované doručenie zlyhalo. Podrobnosti sú v histórii nižšie." | |
| 407 | +} |
added forge/Program.cs +17 −0View file
| @@ -0,0 +1,17 @@ | ||
| 1 | +using Forge; | |
| 2 | + | |
| 3 | +var app = ForgeApp.Build(args); | |
| 4 | + | |
| 5 | +try | |
| 6 | +{ | |
| 7 | + await ForgeApp.InitializeAsync(app); | |
| 8 | +} | |
| 9 | +catch (ForgeStartupException ex) | |
| 10 | +{ | |
| 11 | + // No stack trace: this is a message for whoever is starting the app. | |
| 12 | + Console.Error.WriteLine("Forge cannot start: " + ex.Message); | |
| 13 | + return 1; | |
| 14 | +} | |
| 15 | + | |
| 16 | +await app.RunAsync(); | |
| 17 | +return 0; |
added forge/Properties/launchSettings.json +23 −0View file
| @@ -0,0 +1,23 @@ | ||
| 1 | +{ | |
| 2 | + "$schema": "https://json.schemastore.org/launchsettings.json", | |
| 3 | + "profiles": { | |
| 4 | + "http": { | |
| 5 | + "commandName": "Project", | |
| 6 | + "dotnetRunMessages": true, | |
| 7 | + "launchBrowser": true, | |
| 8 | + "applicationUrl": "http://localhost:5207", | |
| 9 | + "environmentVariables": { | |
| 10 | + "ASPNETCORE_ENVIRONMENT": "Development" | |
| 11 | + } | |
| 12 | + }, | |
| 13 | + "https": { | |
| 14 | + "commandName": "Project", | |
| 15 | + "dotnetRunMessages": true, | |
| 16 | + "launchBrowser": true, | |
| 17 | + "applicationUrl": "https://localhost:7273;http://localhost:5207", | |
| 18 | + "environmentVariables": { | |
| 19 | + "ASPNETCORE_ENVIRONMENT": "Development" | |
| 20 | + } | |
| 21 | + } | |
| 22 | + } | |
| 23 | + } |
added forge/Urls.cs +51 −0View file
| @@ -0,0 +1,51 @@ | ||
| 1 | +using Forge.Data; | |
| 2 | + | |
| 3 | +namespace Forge; | |
| 4 | + | |
| 5 | +/// <summary>Builds site-relative URLs. Every dynamic part is escaped segment by segment.</summary> | |
| 6 | +public static class Urls | |
| 7 | +{ | |
| 8 | + public static string EncodePath(string path) => | |
| 9 | + string.Join('/', path.Split('/').Select(Uri.EscapeDataString)); | |
| 10 | + | |
| 11 | + public static string User(string username) => "/" + Uri.EscapeDataString(username); | |
| 12 | + | |
| 13 | + public static string Repo(string owner, string name) => | |
| 14 | + $"/{Uri.EscapeDataString(owner)}/{Uri.EscapeDataString(name)}"; | |
| 15 | + | |
| 16 | + public static string Repo(Repository repo) => Repo(repo.Owner.Username, repo.Name); | |
| 17 | + | |
| 18 | + public static string Tree(Repository repo, string refName, string path = "") => WithRef(repo, "tree", refName, path); | |
| 19 | + public static string Blob(Repository repo, string refName, string path) => WithRef(repo, "blob", refName, path); | |
| 20 | + public static string Raw(Repository repo, string refName, string path) => WithRef(repo, "raw", refName, path); | |
| 21 | + public static string Commits(Repository repo, string refName, string path = "") => WithRef(repo, "commits", refName, path); | |
| 22 | + | |
| 23 | + public static string Commit(Repository repo, string sha) => $"{Repo(repo)}/commit/{sha}"; | |
| 24 | + public static string Compare(Repository repo) => Repo(repo) + "/compare"; | |
| 25 | + | |
| 26 | + /// <summary>Each side is a branch, a tag or a commit SHA. Ref names cannot contain "..", so "..." splits them unambiguously.</summary> | |
| 27 | + public static string Compare(Repository repo, string before, string after) => | |
| 28 | + $"{Repo(repo)}/compare/{EncodePath(before)}...{EncodePath(after)}"; | |
| 29 | + public static string Conflicts(Repository repo, string baseBranch, string headBranch) => | |
| 30 | + $"{Repo(repo)}/conflicts/{EncodePath(baseBranch)}...{EncodePath(headBranch)}"; | |
| 31 | + | |
| 32 | + public static string Search(Repository repo) => Repo(repo) + "/search"; | |
| 33 | + public static string Activity(Repository repo) => Repo(repo) + "/activity"; | |
| 34 | + public static string Pulls(Repository repo) => Repo(repo) + "/pulls"; | |
| 35 | + public static string Pull(Repository repo, int number) => $"{Repo(repo)}/pull/{number}"; | |
| 36 | + public static string Branches(Repository repo) => Repo(repo) + "/branches"; | |
| 37 | + public static string Tags(Repository repo) => Repo(repo) + "/tags"; | |
| 38 | + public static string Atom(Repository repo) => Repo(repo) + "/atom"; | |
| 39 | + public static string Settings(Repository repo) => Repo(repo) + "/settings"; | |
| 40 | + public static string Webhooks(Repository repo) => Repo(repo) + "/settings/webhooks"; | |
| 41 | + public static string Protection(Repository repo) => Repo(repo) + "/settings/branches"; | |
| 42 | + public static string Webhook(Repository repo, long id) => $"{Repo(repo)}/settings/webhooks/{id}"; | |
| 43 | + | |
| 44 | + public static string Clone(ForgeOptions options, Repository repo) => | |
| 45 | + $"{options.BaseUrlTrimmed}{Repo(repo)}.git"; | |
| 46 | + | |
| 47 | + public static string Absolute(ForgeOptions options, string relative) => options.BaseUrlTrimmed + relative; | |
| 48 | + | |
| 49 | + private static string WithRef(Repository repo, string kind, string refName, string path) => | |
| 50 | + $"{Repo(repo)}/{kind}/{EncodePath(refName)}" + (path.Length == 0 ? "" : "/" + EncodePath(path)); | |
| 51 | +} |
added forge/_Imports.razor +21 −0View file
| @@ -0,0 +1,21 @@ | ||
| 1 | +@using System.Globalization | |
| 2 | +@using Microsoft.AspNetCore.Authorization | |
| 3 | +@using Microsoft.AspNetCore.Components.Forms | |
| 4 | +@using Microsoft.AspNetCore.Components.Routing | |
| 5 | +@using Microsoft.AspNetCore.Components.Web | |
| 6 | +@using Microsoft.AspNetCore.RateLimiting | |
| 7 | +@using Microsoft.EntityFrameworkCore | |
| 8 | +@using Microsoft.Extensions.Options | |
| 9 | +@using Forge | |
| 10 | +@using Forge.Components | |
| 11 | +@using Forge.Data | |
| 12 | +@using Forge.Features.Auth | |
| 13 | +@using Forge.Features.Browse | |
| 14 | +@using Forge.Features.History | |
| 15 | +@using Forge.Features.Pulls | |
| 16 | +@using Forge.Features.Repos | |
| 17 | +@using Forge.Features.Webhooks | |
| 18 | +@using Forge.Git | |
| 19 | +@using Forge.Localization | |
| 20 | +@* Every component gets the translator T; see Localization/Localizer.cs. *@ | |
| 21 | +@inject Localizer T |
added forge/appsettings.Development.json +8 −0View file
| @@ -0,0 +1,8 @@ | ||
| 1 | +{ | |
| 2 | + "Logging": { | |
| 3 | + "LogLevel": { | |
| 4 | + "Default": "Information", | |
| 5 | + "Microsoft.AspNetCore": "Warning" | |
| 6 | + } | |
| 7 | + } | |
| 8 | +} |
added forge/appsettings.json +16 −0View file
| @@ -0,0 +1,16 @@ | ||
| 1 | +{ | |
| 2 | + "Logging": { | |
| 3 | + "LogLevel": { | |
| 4 | + "Default": "Information", | |
| 5 | + "Microsoft.AspNetCore": "Warning", | |
| 6 | + "Microsoft.EntityFrameworkCore": "Warning" | |
| 7 | + } | |
| 8 | + }, | |
| 9 | + "AllowedHosts": "*", | |
| 10 | + "Forge": { | |
| 11 | + "DataPath": "data", | |
| 12 | + "BaseUrl": "http://localhost:5207", | |
| 13 | + "MaxPushSizeMb": 500, | |
| 14 | + "GitPath": "git" | |
| 15 | + } | |
| 16 | +} |
added forge/forge.csproj +33 −0View file
| @@ -0,0 +1,33 @@ | ||
| 1 | +<Project Sdk="Microsoft.NET.Sdk.Web"> | |
| 2 | + | |
| 3 | + <PropertyGroup> | |
| 4 | + <TargetFramework>net11.0</TargetFramework> | |
| 5 | + <Nullable>enable</Nullable> | |
| 6 | + <ImplicitUsings>enable</ImplicitUsings> | |
| 7 | + <TreatWarningsAsErrors>true</TreatWarningsAsErrors> | |
| 8 | + <!-- NuGet audit advisories should not break the build. --> | |
| 9 | + <WarningsNotAsErrors>NU1901;NU1902;NU1903;NU1904</WarningsNotAsErrors> | |
| 10 | + <RootNamespace>Forge</RootNamespace> | |
| 11 | + <AssemblyName>forge</AssemblyName> | |
| 12 | + <BlazorDisableThrowNavigationException>true</BlazorDisableThrowNavigationException> | |
| 13 | + </PropertyGroup> | |
| 14 | + | |
| 15 | + <ItemGroup> | |
| 16 | + <!-- One translation file per language. WithCulture=false keeps them in the main assembly | |
| 17 | + instead of being split off into satellite assemblies because of their culture-like names. --> | |
| 18 | + <Content Remove="Localization\*.json" /> | |
| 19 | + <EmbeddedResource Include="Localization\*.json" WithCulture="false" LogicalName="Forge.Localization.%(Filename)%(Extension)" /> | |
| 20 | + </ItemGroup> | |
| 21 | + | |
| 22 | + <ItemGroup> | |
| 23 | + <PackageReference Include="CliWrap" Version="3.10.5" /> | |
| 24 | + <PackageReference Include="HtmlSanitizer" Version="11.0.26" /> | |
| 25 | + <PackageReference Include="Markdig" Version="1.6.0" /> | |
| 26 | + <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="11.0.0" /> | |
| 27 | + <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="11.0.0"> | |
| 28 | + <PrivateAssets>all</PrivateAssets> | |
| 29 | + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> | |
| 30 | + </PackageReference> | |
| 31 | + </ItemGroup> | |
| 32 | + | |
| 33 | +</Project> |
added forge/wwwroot/app.js +278 −0View file
| @@ -0,0 +1,278 @@ | ||
| 1 | +// Forge has no client-side framework. Pages work without this file; it adds what plain HTML cannot do. | |
| 2 | + | |
| 3 | +// 1. Copy buttons: <button data-copy="text to copy" data-copied-label="Copied">. | |
| 4 | +// A button with a <span class="copy-label"> keeps its icon and changes only the label. | |
| 5 | +// data-copy-from="element-id" copies that element's text instead (a whole file). | |
| 6 | +document.addEventListener('click', (event) => { | |
| 7 | + const button = event.target.closest('[data-copy], [data-copy-from]'); | |
| 8 | + if (!button || !navigator.clipboard) { | |
| 9 | + return; | |
| 10 | + } | |
| 11 | + | |
| 12 | + const source = button.dataset.copyFrom ? document.getElementById(button.dataset.copyFrom) : null; | |
| 13 | + const text = source ? source.textContent : button.dataset.copy; | |
| 14 | + if (text === undefined) { | |
| 15 | + return; | |
| 16 | + } | |
| 17 | + | |
| 18 | + navigator.clipboard.writeText(text).then(() => { | |
| 19 | + // An icon-only button has no text to change; the "copied" class alone gives the feedback. | |
| 20 | + const label = button.querySelector('.copy-label') || (button.children.length === 0 ? button : null); | |
| 21 | + const original = label ? label.textContent : null; | |
| 22 | + if (label && button.dataset.copiedLabel) { | |
| 23 | + label.textContent = button.dataset.copiedLabel; | |
| 24 | + } | |
| 25 | + | |
| 26 | + button.classList.add('copied'); | |
| 27 | + setTimeout(() => { | |
| 28 | + button.classList.remove('copied'); | |
| 29 | + if (label && original !== null) { | |
| 30 | + label.textContent = original; | |
| 31 | + } | |
| 32 | + }, 1500); | |
| 33 | + }); | |
| 34 | +}); | |
| 35 | + | |
| 36 | +// 2. Theme switch: system → light → dark → system. theme.js applies the saved choice before paint. | |
| 37 | +function applyHighlightTheme() { | |
| 38 | + // highlight.js ships one stylesheet per theme, chosen by a media query. A manual choice overrides it. | |
| 39 | + const theme = document.documentElement.dataset.theme; | |
| 40 | + document.querySelectorAll('link[data-hl-theme]').forEach((link) => { | |
| 41 | + link.media = theme ? (link.dataset.hlTheme === theme ? 'all' : 'not all') : `(prefers-color-scheme: ${link.dataset.hlTheme})`; | |
| 42 | + }); | |
| 43 | +} | |
| 44 | + | |
| 45 | +document.addEventListener('click', (event) => { | |
| 46 | + if (!event.target.closest('[data-theme-toggle]')) { | |
| 47 | + return; | |
| 48 | + } | |
| 49 | + | |
| 50 | + const root = document.documentElement; | |
| 51 | + const next = { undefined: 'light', light: 'dark', dark: undefined }[root.dataset.theme]; | |
| 52 | + if (next) { | |
| 53 | + root.dataset.theme = next; | |
| 54 | + } else { | |
| 55 | + delete root.dataset.theme; | |
| 56 | + } | |
| 57 | + | |
| 58 | + try { | |
| 59 | + if (next) { | |
| 60 | + localStorage.setItem('forge-theme', next); | |
| 61 | + } else { | |
| 62 | + localStorage.removeItem('forge-theme'); | |
| 63 | + } | |
| 64 | + } catch (e) { | |
| 65 | + // Storage can be blocked; the choice then lasts for this page only. | |
| 66 | + } | |
| 67 | + | |
| 68 | + applyHighlightTheme(); | |
| 69 | +}); | |
| 70 | +applyHighlightTheme(); | |
| 71 | + | |
| 72 | +// 3. Dropdowns are <details>. Close them on a click elsewhere and on Escape. | |
| 73 | +const dropdowns = 'details.menu[open], details.ref-switcher[open]'; | |
| 74 | +document.addEventListener('click', (event) => { | |
| 75 | + document.querySelectorAll(dropdowns).forEach((menu) => { | |
| 76 | + if (!menu.contains(event.target)) { | |
| 77 | + menu.open = false; | |
| 78 | + } | |
| 79 | + }); | |
| 80 | +}); | |
| 81 | +document.addEventListener('keydown', (event) => { | |
| 82 | + if (event.key !== 'Escape') { | |
| 83 | + return; | |
| 84 | + } | |
| 85 | + | |
| 86 | + document.querySelectorAll(dropdowns).forEach((menu) => { | |
| 87 | + menu.open = false; | |
| 88 | + menu.querySelector('summary').focus(); | |
| 89 | + }); | |
| 90 | +}); | |
| 91 | + | |
| 92 | +// 4. Keyboard shortcuts: an element with data-hotkey="/" is focused (fields) or followed (links) | |
| 93 | +// when that key is pressed outside a text field. | |
| 94 | +document.addEventListener('keydown', (event) => { | |
| 95 | + if (event.ctrlKey || event.metaKey || event.altKey || event.defaultPrevented) { | |
| 96 | + return; | |
| 97 | + } | |
| 98 | + | |
| 99 | + const typing = event.target.closest('input, textarea, select, [contenteditable]'); | |
| 100 | + if (typing) { | |
| 101 | + return; | |
| 102 | + } | |
| 103 | + | |
| 104 | + if (event.key === '?') { | |
| 105 | + const help = document.getElementById('shortcuts'); | |
| 106 | + if (help && !help.open) { | |
| 107 | + event.preventDefault(); | |
| 108 | + help.showModal(); | |
| 109 | + } | |
| 110 | + | |
| 111 | + return; | |
| 112 | + } | |
| 113 | + | |
| 114 | + const target = Array.from(document.querySelectorAll('[data-hotkey]')).find((el) => el.dataset.hotkey === event.key); | |
| 115 | + if (!target) { | |
| 116 | + return; | |
| 117 | + } | |
| 118 | + | |
| 119 | + event.preventDefault(); | |
| 120 | + if (target.matches('input, textarea')) { | |
| 121 | + target.focus(); | |
| 122 | + target.select(); | |
| 123 | + } else { | |
| 124 | + target.click(); | |
| 125 | + } | |
| 126 | +}); | |
| 127 | + | |
| 128 | +// <button data-open-dialog="id"> opens a <dialog>; a click on its backdrop closes it. | |
| 129 | +document.addEventListener('click', (event) => { | |
| 130 | + const opener = event.target.closest('[data-open-dialog]'); | |
| 131 | + if (opener) { | |
| 132 | + const dialog = document.getElementById(opener.dataset.openDialog); | |
| 133 | + if (dialog && !dialog.open) { | |
| 134 | + dialog.showModal(); | |
| 135 | + } | |
| 136 | + } else if (event.target instanceof HTMLDialogElement) { | |
| 137 | + event.target.close(); | |
| 138 | + } | |
| 139 | +}); | |
| 140 | + | |
| 141 | +// 5. Syntax highlighting. highlight.js is only present on pages that show code. | |
| 142 | +if (window.hljs) { | |
| 143 | + document.querySelectorAll('code[data-highlight]').forEach((block) => { | |
| 144 | + if (window.hljs.getLanguage(block.dataset.highlight)) { | |
| 145 | + window.hljs.highlightElement(block); | |
| 146 | + } | |
| 147 | + }); | |
| 148 | +} | |
| 149 | + | |
| 150 | +// 6. Line selection in the file view. The address ends in #L12 or #L12-L20; click a line number to | |
| 151 | +// select it, shift-click another to select the range between them. | |
| 152 | +const codeView = document.querySelector('.code-view'); | |
| 153 | +if (codeView) { | |
| 154 | + const bar = document.createElement('div'); | |
| 155 | + bar.className = 'line-highlight'; | |
| 156 | + bar.hidden = true; | |
| 157 | + codeView.prepend(bar); | |
| 158 | + let anchorLine = null; | |
| 159 | + | |
| 160 | + const selectedRange = () => { | |
| 161 | + const match = /^#L(\d+)(?:-L?(\d+))?$/.exec(location.hash); | |
| 162 | + if (!match) { | |
| 163 | + return null; | |
| 164 | + } | |
| 165 | + | |
| 166 | + const a = Number(match[1]); | |
| 167 | + const b = match[2] ? Number(match[2]) : a; | |
| 168 | + return { from: Math.min(a, b), to: Math.max(a, b) }; | |
| 169 | + }; | |
| 170 | + | |
| 171 | + const showSelection = (scroll) => { | |
| 172 | + codeView.querySelectorAll('.line-numbers a.selected').forEach((a) => a.classList.remove('selected')); | |
| 173 | + const range = selectedRange(); | |
| 174 | + const first = range && document.getElementById('L' + range.from); | |
| 175 | + const last = range && document.getElementById('L' + range.to); | |
| 176 | + if (!first || !last) { | |
| 177 | + bar.hidden = true; | |
| 178 | + return; | |
| 179 | + } | |
| 180 | + | |
| 181 | + for (let n = range.from; n <= range.to; n++) { | |
| 182 | + document.getElementById('L' + n).classList.add('selected'); | |
| 183 | + } | |
| 184 | + | |
| 185 | + // Positions set through the CSSOM are allowed by the CSP; only style attributes in markup are not. | |
| 186 | + bar.style.top = first.offsetTop + 'px'; | |
| 187 | + bar.style.height = (last.offsetTop + last.offsetHeight - first.offsetTop) + 'px'; | |
| 188 | + bar.style.width = codeView.scrollWidth + 'px'; | |
| 189 | + bar.hidden = false; | |
| 190 | + if (scroll) { | |
| 191 | + first.scrollIntoView({ block: 'center' }); | |
| 192 | + } | |
| 193 | + }; | |
| 194 | + | |
| 195 | + codeView.addEventListener('click', (event) => { | |
| 196 | + const link = event.target.closest('.line-numbers a'); | |
| 197 | + if (!link) { | |
| 198 | + return; | |
| 199 | + } | |
| 200 | + | |
| 201 | + event.preventDefault(); | |
| 202 | + const line = Number(link.id.slice(1)); | |
| 203 | + let hash = '#L' + line; | |
| 204 | + if (event.shiftKey && anchorLine !== null && anchorLine !== line) { | |
| 205 | + hash = '#L' + Math.min(anchorLine, line) + '-L' + Math.max(anchorLine, line); | |
| 206 | + } else { | |
| 207 | + anchorLine = line; | |
| 208 | + } | |
| 209 | + | |
| 210 | + history.replaceState(null, '', hash); | |
| 211 | + showSelection(false); | |
| 212 | + }); | |
| 213 | + | |
| 214 | + window.addEventListener('hashchange', () => showSelection(true)); | |
| 215 | + const initial = selectedRange(); | |
| 216 | + if (initial) { | |
| 217 | + anchorLine = initial.from; | |
| 218 | + showSelection(true); | |
| 219 | + } | |
| 220 | +} | |
| 221 | + | |
| 222 | +// 7. Syntax colours in diffs. Each line is highlighted on its own, one file at a time as it | |
| 223 | +// scrolls into view, so a large diff does not freeze the page. | |
| 224 | +function markRange(root, start, end) { | |
| 225 | + // Re-applies the "this part of the line changed" span after highlighting rebuilt the line. | |
| 226 | + const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT); | |
| 227 | + const nodes = []; | |
| 228 | + while (walker.nextNode()) { | |
| 229 | + nodes.push(walker.currentNode); | |
| 230 | + } | |
| 231 | + | |
| 232 | + let offset = 0; | |
| 233 | + for (const node of nodes) { | |
| 234 | + const length = node.data.length; | |
| 235 | + const from = Math.max(start, offset) - offset; | |
| 236 | + const to = Math.min(end, offset + length) - offset; | |
| 237 | + offset += length; | |
| 238 | + if (from >= to) { | |
| 239 | + continue; | |
| 240 | + } | |
| 241 | + | |
| 242 | + const middle = from > 0 ? node.splitText(from) : node; | |
| 243 | + if (to - from < middle.data.length) { | |
| 244 | + middle.splitText(to - from); | |
| 245 | + } | |
| 246 | + | |
| 247 | + const mark = document.createElement('span'); | |
| 248 | + mark.className = 'chg'; | |
| 249 | + middle.replaceWith(mark); | |
| 250 | + mark.appendChild(middle); | |
| 251 | + } | |
| 252 | +} | |
| 253 | + | |
| 254 | +function highlightDiffFile(file) { | |
| 255 | + file.querySelectorAll('.line[data-lang]').forEach((line) => { | |
| 256 | + const language = line.dataset.lang; | |
| 257 | + if (!window.hljs.getLanguage(language)) { | |
| 258 | + return; | |
| 259 | + } | |
| 260 | + | |
| 261 | + line.innerHTML = window.hljs.highlight(line.textContent, { language, ignoreIllegals: true }).value; | |
| 262 | + if (line.dataset.cs !== undefined) { | |
| 263 | + markRange(line, Number(line.dataset.cs), Number(line.dataset.ce)); | |
| 264 | + } | |
| 265 | + }); | |
| 266 | +} | |
| 267 | + | |
| 268 | +if (window.hljs && 'IntersectionObserver' in window) { | |
| 269 | + const observer = new IntersectionObserver((entries) => { | |
| 270 | + for (const entry of entries) { | |
| 271 | + if (entry.isIntersecting) { | |
| 272 | + observer.unobserve(entry.target); | |
| 273 | + highlightDiffFile(entry.target); | |
| 274 | + } | |
| 275 | + } | |
| 276 | + }, { rootMargin: '400px' }); | |
| 277 | + document.querySelectorAll('.diff-file').forEach((file) => observer.observe(file)); | |
| 278 | +} |
added forge/wwwroot/favicon.png +0 −0View file
Binary file, diff not shown.
added forge/wwwroot/lib/highlight/github-dark.min.css +10 −0View file
| @@ -0,0 +1,10 @@ | ||
| 1 | +pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}/*! | |
| 2 | + Theme: GitHub Dark | |
| 3 | + Description: Dark theme as seen on github.com | |
| 4 | + Author: github.com | |
| 5 | + Maintainer: @Hirse | |
| 6 | + Updated: 2021-05-15 | |
| 7 | + | |
| 8 | + Outdated base version: https://github.com/primer/github-syntax-dark | |
| 9 | + Current colors taken from GitHub's CSS | |
| 10 | +*/.hljs{color:#c9d1d9;background:#0d1117}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#ff7b72}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#d2a8ff}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-variable{color:#79c0ff}.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#a5d6ff}.hljs-built_in,.hljs-symbol{color:#ffa657}.hljs-code,.hljs-comment,.hljs-formula{color:#8b949e}.hljs-name,.hljs-quote,.hljs-selector-pseudo,.hljs-selector-tag{color:#7ee787}.hljs-subst{color:#c9d1d9}.hljs-section{color:#1f6feb;font-weight:700}.hljs-bullet{color:#f2cc60}.hljs-emphasis{color:#c9d1d9;font-style:italic}.hljs-strong{color:#c9d1d9;font-weight:700}.hljs-addition{color:#aff5b4;background-color:#033a16}.hljs-deletion{color:#ffdcd7;background-color:#67060c} | |
| No newline at end of file |
added forge/wwwroot/lib/highlight/github.min.css +10 −0View file
| @@ -0,0 +1,10 @@ | ||
| 1 | +pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}/*! | |
| 2 | + Theme: GitHub | |
| 3 | + Description: Light theme as seen on github.com | |
| 4 | + Author: github.com | |
| 5 | + Maintainer: @Hirse | |
| 6 | + Updated: 2021-05-15 | |
| 7 | + | |
| 8 | + Outdated base version: https://github.com/primer/github-syntax-light | |
| 9 | + Current colors taken from GitHub's CSS | |
| 10 | +*/.hljs{color:#24292e;background:#fff}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#d73a49}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#6f42c1}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-variable{color:#005cc5}.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#032f62}.hljs-built_in,.hljs-symbol{color:#e36209}.hljs-code,.hljs-comment,.hljs-formula{color:#6a737d}.hljs-name,.hljs-quote,.hljs-selector-pseudo,.hljs-selector-tag{color:#22863a}.hljs-subst{color:#24292e}.hljs-section{color:#005cc5;font-weight:700}.hljs-bullet{color:#735c0f}.hljs-emphasis{color:#24292e;font-style:italic}.hljs-strong{color:#24292e;font-weight:700}.hljs-addition{color:#22863a;background-color:#f0fff4}.hljs-deletion{color:#b31d28;background-color:#ffeef0} | |
| No newline at end of file |
added forge/wwwroot/lib/highlight/highlight.min.js +1244 −0View file
The diff is too large (more than 1000 lines).
added forge/wwwroot/style.css +706 −0View file
| @@ -0,0 +1,706 @@ | ||
| 1 | +/* Forge. One stylesheet, no framework. | |
| 2 | + Colours are tokens written as light-dark(light, dark). The page follows the system setting | |
| 3 | + unless the visitor picked a theme, which theme.js stores as <html data-theme="light|dark">. */ | |
| 4 | + | |
| 5 | +:root { | |
| 6 | + color-scheme: light dark; | |
| 7 | + | |
| 8 | + --bg: light-dark(#ffffff, #0f1318); | |
| 9 | + --surface: light-dark(#f6f7f9, #161b22); | |
| 10 | + --surface-2: light-dark(#eceff3, #1f2630); | |
| 11 | + --border: light-dark(#d8dce3, #2b3440); | |
| 12 | + --border-strong: light-dark(#b4bcc8, #445061); | |
| 13 | + --text: light-dark(#171b22, #e3e8ee); | |
| 14 | + --muted: light-dark(#5b6472, #95a1b0); | |
| 15 | + --link: light-dark(#0b5fca, #74b0ff); | |
| 16 | + --accent: light-dark(#c2410c, #fb923c); | |
| 17 | + --accent-soft: light-dark(#fff1e8, #2e1d10); | |
| 18 | + --primary: light-dark(#c2410c, #c9480f); | |
| 19 | + --primary-hover: light-dark(#a3360a, #dd5514); | |
| 20 | + --primary-text: #ffffff; | |
| 21 | + --danger: light-dark(#b3261e, #ff7b72); | |
| 22 | + --add-bg: light-dark(#e3f6e8, #14321f); | |
| 23 | + --add-text: light-dark(#136c32, #7ee2a0); | |
| 24 | + --add-strong: light-dark(#abe7b9, #1f6b3a); | |
| 25 | + --del-bg: light-dark(#fde8e6, #3d1a1a); | |
| 26 | + --del-text: light-dark(#a4231c, #ffa198); | |
| 27 | + --del-strong: light-dark(#f8b8b3, #7d2a2a); | |
| 28 | + --hunk-bg: light-dark(#eaf1fb, #1b2a40); | |
| 29 | + --warn-bg: light-dark(#fff4d6, #3a3012); | |
| 30 | + --warn-text: light-dark(#6b4e00, #f2d27a); | |
| 31 | + --target-bg: light-dark(#fff3bf, #4a3f10); | |
| 32 | + --merged-bg: light-dark(#ebe2fb, #2e2350); | |
| 33 | + --merged-text: light-dark(#5b2fa6, #c9b2ff); | |
| 34 | + --shadow: 0 8px 28px light-dark(rgba(23, 27, 34, 0.14), rgba(0, 0, 0, 0.5)); | |
| 35 | + --shadow-small: 0 1px 2px light-dark(rgba(23, 27, 34, 0.06), rgba(0, 0, 0, 0.3)); | |
| 36 | + --focus: light-dark(#0b5fca, #74b0ff); | |
| 37 | + | |
| 38 | + --radius: 8px; | |
| 39 | + --radius-small: 6px; | |
| 40 | + --mono: ui-monospace, "Cascadia Code", "SF Mono", Consolas, "Liberation Mono", monospace; | |
| 41 | + --sans: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; | |
| 42 | +} | |
| 43 | + | |
| 44 | +:root[data-theme="light"] { color-scheme: light; } | |
| 45 | +:root[data-theme="dark"] { color-scheme: dark; } | |
| 46 | + | |
| 47 | +*, *::before, *::after { box-sizing: border-box; } | |
| 48 | + | |
| 49 | +html { -webkit-text-size-adjust: 100%; } | |
| 50 | + | |
| 51 | +body { | |
| 52 | + margin: 0; | |
| 53 | + min-height: 100vh; | |
| 54 | + display: flex; | |
| 55 | + flex-direction: column; | |
| 56 | + background: var(--bg); | |
| 57 | + color: var(--text); | |
| 58 | + font-family: var(--sans); | |
| 59 | + font-size: 15px; | |
| 60 | + line-height: 1.5; | |
| 61 | +} | |
| 62 | + | |
| 63 | +a { color: var(--link); text-decoration: none; } | |
| 64 | +a:hover { text-decoration: underline; } | |
| 65 | + | |
| 66 | +:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; border-radius: 4px; } | |
| 67 | + | |
| 68 | +h1 { font-size: 1.5rem; line-height: 1.25; margin: 0 0 0.5rem; letter-spacing: -0.01em; text-wrap: balance; } | |
| 69 | +h2 { font-size: 1.15rem; line-height: 1.3; margin: 0 0 0.75rem; } | |
| 70 | +h3 { font-size: 1rem; margin: 1.5rem 0 0.5rem; } | |
| 71 | + | |
| 72 | +code, pre, kbd { font-family: var(--mono); font-size: 0.87rem; } | |
| 73 | +code { background: var(--surface-2); padding: 0.1em 0.35em; border-radius: 4px; } | |
| 74 | +pre code { background: none; padding: 0; } | |
| 75 | +kbd { | |
| 76 | + display: inline-block; | |
| 77 | + min-width: 1.5em; | |
| 78 | + padding: 0 5px; | |
| 79 | + border: 1px solid var(--border); | |
| 80 | + border-bottom-width: 2px; | |
| 81 | + border-radius: 4px; | |
| 82 | + background: var(--bg); | |
| 83 | + color: var(--muted); | |
| 84 | + font-size: 0.75rem; | |
| 85 | + line-height: 1.5; | |
| 86 | + text-align: center; | |
| 87 | +} | |
| 88 | + | |
| 89 | +svg.icon { | |
| 90 | + flex: none; | |
| 91 | + fill: none; | |
| 92 | + stroke: currentColor; | |
| 93 | + stroke-width: 2; | |
| 94 | + stroke-linecap: round; | |
| 95 | + stroke-linejoin: round; | |
| 96 | + vertical-align: -0.15em; | |
| 97 | +} | |
| 98 | +svg.icon.logo-mark { fill: var(--accent); stroke: none; } | |
| 99 | + | |
| 100 | +html:not(.js) .js-only { display: none !important; } | |
| 101 | + | |
| 102 | +.wrap { width: 100%; max-width: 1180px; margin: 0 auto; padding: 0 20px; } | |
| 103 | +main.wrap { flex: 1; padding-top: 24px; padding-bottom: 56px; } | |
| 104 | +.narrow { | |
| 105 | + max-width: 440px; | |
| 106 | + margin: 40px auto; | |
| 107 | + padding: 28px; | |
| 108 | + border: 1px solid var(--border); | |
| 109 | + border-radius: 12px; | |
| 110 | + box-shadow: var(--shadow-small); | |
| 111 | +} | |
| 112 | +.auth-logo { margin-bottom: 12px; } | |
| 113 | + | |
| 114 | +.skip-link { position: absolute; left: -999px; top: 8px; z-index: 100; padding: 6px 12px; background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius-small); } | |
| 115 | +.skip-link:focus { left: 8px; } | |
| 116 | + | |
| 117 | +.muted { color: var(--muted); } | |
| 118 | +.small { font-size: 0.85rem; } | |
| 119 | +.right { text-align: right; } | |
| 120 | +.break { overflow-wrap: anywhere; } | |
| 121 | +.danger-text { color: var(--danger); } | |
| 122 | +.added { color: var(--add-text); } | |
| 123 | +.deleted { color: var(--del-text); } | |
| 124 | +.sep { color: var(--muted); margin: 0 0.25rem; } | |
| 125 | + | |
| 126 | +/* Top bar */ | |
| 127 | +.topbar { border-bottom: 1px solid var(--border); background: var(--surface); } | |
| 128 | +.topbar-inner { display: flex; align-items: center; gap: 16px; min-height: 56px; } | |
| 129 | +.brand { display: inline-flex; align-items: center; gap: 8px; font-weight: 700; font-size: 1.1rem; letter-spacing: -0.01em; color: var(--text); } | |
| 130 | +.brand:hover { text-decoration: none; } | |
| 131 | +.topnav { display: flex; align-items: center; gap: 6px; margin-left: auto; } | |
| 132 | +.inline-form { display: inline; margin: 0; } | |
| 133 | +.link-button { background: none; border: 0; padding: 0; color: var(--link); font: inherit; cursor: pointer; } | |
| 134 | +.link-button:hover { text-decoration: underline; } | |
| 135 | + | |
| 136 | +.icon-button { | |
| 137 | + display: inline-flex; | |
| 138 | + align-items: center; | |
| 139 | + justify-content: center; | |
| 140 | + width: 34px; | |
| 141 | + height: 34px; | |
| 142 | + border: 1px solid transparent; | |
| 143 | + border-radius: var(--radius-small); | |
| 144 | + background: none; | |
| 145 | + color: var(--muted); | |
| 146 | + cursor: pointer; | |
| 147 | +} | |
| 148 | +.icon-button:hover { background: var(--surface-2); color: var(--text); text-decoration: none; } | |
| 149 | +.theme-icon { display: none; } | |
| 150 | +:root:not([data-theme]) .theme-icon-auto, | |
| 151 | +:root[data-theme="light"] .theme-icon-light, | |
| 152 | +:root[data-theme="dark"] .theme-icon-dark { display: inline; } | |
| 153 | + | |
| 154 | +/* Search box: an icon, the field, and an optional key hint, drawn as one control. */ | |
| 155 | +.search { | |
| 156 | + display: flex; | |
| 157 | + align-items: center; | |
| 158 | + gap: 8px; | |
| 159 | + flex: 1; | |
| 160 | + max-width: 380px; | |
| 161 | + margin: 0; | |
| 162 | + padding: 0 10px; | |
| 163 | + border: 1px solid var(--border); | |
| 164 | + border-radius: var(--radius-small); | |
| 165 | + background: var(--bg); | |
| 166 | + color: var(--muted); | |
| 167 | +} | |
| 168 | +.search:focus-within { border-color: var(--focus); box-shadow: 0 0 0 3px color-mix(in srgb, var(--focus) 22%, transparent); } | |
| 169 | +.search input[type="search"] { | |
| 170 | + flex: 1; | |
| 171 | + min-width: 0; | |
| 172 | + padding: 6px 0; | |
| 173 | + border: 0; | |
| 174 | + outline: 0; | |
| 175 | + background: none; | |
| 176 | + color: var(--text); | |
| 177 | + font: inherit; | |
| 178 | +} | |
| 179 | + | |
| 180 | +/* Dropdown menus are <details>; app.js closes them on outside click and Escape. */ | |
| 181 | +.menu { position: relative; } | |
| 182 | +.menu > summary { list-style: none; cursor: pointer; } | |
| 183 | +.menu > summary::-webkit-details-marker { display: none; } | |
| 184 | +.menu-button { display: inline-flex; align-items: center; gap: 4px; padding: 3px 6px 3px 3px; border-radius: 999px; color: var(--muted); } | |
| 185 | +.menu-button:hover { background: var(--surface-2); } | |
| 186 | +.menu-panel { | |
| 187 | + position: absolute; | |
| 188 | + z-index: 30; | |
| 189 | + top: calc(100% + 6px); | |
| 190 | + left: 0; | |
| 191 | + min-width: 220px; | |
| 192 | + padding: 6px; | |
| 193 | + background: var(--bg); | |
| 194 | + border: 1px solid var(--border); | |
| 195 | + border-radius: var(--radius); | |
| 196 | + box-shadow: var(--shadow); | |
| 197 | +} | |
| 198 | +.menu-panel.menu-right { left: auto; right: 0; } | |
| 199 | +.menu-header { margin: 0 0 6px; padding: 6px 10px 8px; border-bottom: 1px solid var(--border); color: var(--muted); font-size: 0.85rem; } | |
| 200 | +.menu-header strong { color: var(--text); } | |
| 201 | +.menu-form { margin: 6px 0 0; padding-top: 6px; border-top: 1px solid var(--border); } | |
| 202 | +.menu-item { | |
| 203 | + display: flex; | |
| 204 | + align-items: center; | |
| 205 | + gap: 10px; | |
| 206 | + width: 100%; | |
| 207 | + padding: 6px 10px; | |
| 208 | + border: 0; | |
| 209 | + border-radius: var(--radius-small); | |
| 210 | + background: none; | |
| 211 | + color: var(--text); | |
| 212 | + font: inherit; | |
| 213 | + text-align: left; | |
| 214 | + cursor: pointer; | |
| 215 | +} | |
| 216 | +.menu-item:hover { background: var(--surface-2); text-decoration: none; } | |
| 217 | +.menu-item svg.icon { color: var(--muted); } | |
| 218 | + | |
| 219 | +/* Avatars */ | |
| 220 | +.avatar { | |
| 221 | + display: inline-flex; | |
| 222 | + align-items: center; | |
| 223 | + justify-content: center; | |
| 224 | + flex: none; | |
| 225 | + border-radius: 50%; | |
| 226 | + color: #ffffff; | |
| 227 | + font-weight: 700; | |
| 228 | + line-height: 1; | |
| 229 | + user-select: none; | |
| 230 | +} | |
| 231 | +.avatar-sm { width: 20px; height: 20px; font-size: 0.7rem; } | |
| 232 | +.avatar-md { width: 28px; height: 28px; font-size: 0.85rem; } | |
| 233 | +.avatar-lg { width: 72px; height: 72px; font-size: 2rem; } | |
| 234 | +.avatar-c0 { background: #c2410c; } | |
| 235 | +.avatar-c1 { background: #0f766e; } | |
| 236 | +.avatar-c2 { background: #1d4ed8; } | |
| 237 | +.avatar-c3 { background: #7c3aed; } | |
| 238 | +.avatar-c4 { background: #be185d; } | |
| 239 | +.avatar-c5 { background: #4d7c0f; } | |
| 240 | +.avatar-c6 { background: #a16207; } | |
| 241 | +.avatar-c7 { background: #475569; } | |
| 242 | + | |
| 243 | +/* Footer */ | |
| 244 | +.footer { border-top: 1px solid var(--border); font-size: 0.85rem; } | |
| 245 | +.footer-inner { display: flex; justify-content: space-between; align-items: center; gap: 12px 24px; flex-wrap: wrap; padding-top: 16px; padding-bottom: 20px; } | |
| 246 | +.footer-brand { display: inline-flex; align-items: center; gap: 6px; } | |
| 247 | +.language-form { display: flex; gap: 12px; align-items: center; flex-wrap: wrap; margin: 0; } | |
| 248 | +.language-label { display: inline-flex; align-items: center; gap: 5px; } | |
| 249 | + | |
| 250 | +/* Buttons and forms */ | |
| 251 | +.button { | |
| 252 | + display: inline-flex; | |
| 253 | + align-items: center; | |
| 254 | + justify-content: center; | |
| 255 | + gap: 6px; | |
| 256 | + padding: 6px 12px; | |
| 257 | + border: 1px solid var(--border); | |
| 258 | + border-radius: var(--radius-small); | |
| 259 | + background: var(--surface); | |
| 260 | + color: var(--text); | |
| 261 | + font: inherit; | |
| 262 | + font-weight: 500; | |
| 263 | + line-height: 1.4; | |
| 264 | + cursor: pointer; | |
| 265 | + white-space: nowrap; | |
| 266 | + box-shadow: var(--shadow-small); | |
| 267 | +} | |
| 268 | +.button:hover { text-decoration: none; border-color: var(--border-strong); background: var(--surface-2); } | |
| 269 | +.button.primary { background: var(--primary); border-color: var(--primary); color: var(--primary-text); } | |
| 270 | +.button.primary:hover { background: var(--primary-hover); border-color: var(--primary-hover); } | |
| 271 | +.button.danger { color: var(--danger); border-color: color-mix(in srgb, var(--danger) 55%, var(--border)); background: transparent; } | |
| 272 | +.button.danger:hover { background: var(--del-bg); border-color: var(--danger); } | |
| 273 | +.button.small { padding: 2px 8px; font-size: 0.85rem; } | |
| 274 | +.button-row { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 12px; } | |
| 275 | + | |
| 276 | +.form { display: grid; gap: 14px; } | |
| 277 | +.form label { display: grid; gap: 4px; font-weight: 600; } | |
| 278 | +.form label.choice { display: flex; gap: 8px; align-items: center; font-weight: 400; } | |
| 279 | +.form small { font-weight: 400; } | |
| 280 | +.form button { justify-self: start; } | |
| 281 | +input[type="text"], input[type="password"], input[type="url"], input:not([type]), select, textarea { | |
| 282 | + width: 100%; | |
| 283 | + padding: 7px 10px; | |
| 284 | + border: 1px solid var(--border); | |
| 285 | + border-radius: var(--radius-small); | |
| 286 | + background: var(--bg); | |
| 287 | + color: var(--text); | |
| 288 | + font: inherit; | |
| 289 | +} | |
| 290 | +input[type="text"]:focus, input[type="password"]:focus, input[type="url"]:focus, input:not([type]):focus, select:focus, textarea:focus { | |
| 291 | + outline: 0; | |
| 292 | + border-color: var(--focus); | |
| 293 | + box-shadow: 0 0 0 3px color-mix(in srgb, var(--focus) 22%, transparent); | |
| 294 | +} | |
| 295 | +input[type="checkbox"], input[type="radio"] { width: auto; accent-color: var(--accent); } | |
| 296 | +textarea { resize: vertical; } | |
| 297 | +textarea.code-input { font-family: var(--mono); font-size: 0.85rem; white-space: pre; overflow-x: auto; tab-size: 4; } | |
| 298 | +fieldset { border: 1px solid var(--border); border-radius: var(--radius-small); padding: 8px 12px; margin: 0; display: grid; gap: 6px; } | |
| 299 | +legend { font-weight: 600; padding: 0 4px; } | |
| 300 | + | |
| 301 | +.card { border: 1px solid var(--border); border-radius: var(--radius); padding: 16px; margin: 16px 0; } | |
| 302 | +.card.empty, .empty { text-align: center; color: var(--muted); padding: 32px 16px; } | |
| 303 | +.danger-zone { border-color: color-mix(in srgb, var(--danger) 60%, var(--border)); } | |
| 304 | +details.card > summary { cursor: pointer; } | |
| 305 | +details.card[open] > summary { margin-bottom: 12px; } | |
| 306 | + | |
| 307 | +.empty-state { padding: 56px 16px; border: 1px dashed var(--border-strong); border-radius: var(--radius); text-align: center; color: var(--muted); } | |
| 308 | +.empty-state h2 { margin: 12px 0 4px; color: var(--text); font-size: 1.05rem; } | |
| 309 | +.empty-state p { margin: 4px 0 0; } | |
| 310 | + | |
| 311 | +.alert { padding: 10px 14px; border-radius: var(--radius-small); margin: 12px 0; border: 1px solid var(--border); } | |
| 312 | +.alert.error { background: var(--del-bg); color: var(--del-text); border-color: transparent; } | |
| 313 | +.alert.success { background: var(--add-bg); color: var(--add-text); border-color: transparent; } | |
| 314 | +.alert.warning { background: var(--warn-bg); color: var(--warn-text); border-color: transparent; } | |
| 315 | +.alert p { margin: 0 0 8px; } | |
| 316 | +.alert p:last-child { margin-bottom: 0; } | |
| 317 | +.alert ul { margin: 4px 0 0; padding-left: 20px; } | |
| 318 | + | |
| 319 | +.badge { | |
| 320 | + display: inline-flex; | |
| 321 | + align-items: center; | |
| 322 | + gap: 4px; | |
| 323 | + padding: 0 8px; | |
| 324 | + border: 1px solid var(--border); | |
| 325 | + border-radius: 999px; | |
| 326 | + font-size: 0.75rem; | |
| 327 | + font-weight: 500; | |
| 328 | + line-height: 1.6; | |
| 329 | + color: var(--muted); | |
| 330 | + vertical-align: middle; | |
| 331 | + white-space: nowrap; | |
| 332 | +} | |
| 333 | +.badge-added { background: var(--add-bg); color: var(--add-text); border-color: transparent; } | |
| 334 | +.badge-deleted { background: var(--del-bg); color: var(--del-text); border-color: transparent; } | |
| 335 | +.badge-merged { background: var(--merged-bg); color: var(--merged-text); border-color: transparent; } | |
| 336 | +.counter { min-width: 20px; padding: 0 6px; border-radius: 999px; background: var(--surface-2); color: var(--muted); font-size: 0.75rem; font-weight: 600; line-height: 1.6; text-align: center; } | |
| 337 | + | |
| 338 | +/* Tables */ | |
| 339 | +.table { width: 100%; border-collapse: collapse; margin: 12px 0; } | |
| 340 | +.table th, .table td { padding: 8px 10px; border-bottom: 1px solid var(--border); text-align: left; vertical-align: top; } | |
| 341 | +.table th { font-size: 0.8rem; color: var(--muted); font-weight: 600; } | |
| 342 | +.table th.right, .table td.right { text-align: right; } | |
| 343 | +.table tbody tr:hover { background: var(--surface); } | |
| 344 | +.table td.actions { white-space: nowrap; } | |
| 345 | +.table td.actions .button { margin-left: 4px; } | |
| 346 | +.table.tree { border: 1px solid var(--border); border-radius: var(--radius); border-collapse: separate; border-spacing: 0; } | |
| 347 | +.table.tree tr:last-child td { border-bottom: 0; } | |
| 348 | +.table.tree td { vertical-align: middle; } | |
| 349 | +.table.tree td.icon { width: 28px; padding-right: 0; color: var(--muted); } | |
| 350 | +.table.tree .name { overflow-wrap: anywhere; } | |
| 351 | + | |
| 352 | +/* Home and profile */ | |
| 353 | +.page-head { display: flex; justify-content: space-between; align-items: center; gap: 12px; margin-bottom: 16px; } | |
| 354 | +.page-head h1, .page-head h2 { margin-bottom: 0; } | |
| 355 | +.page-sub { margin: 2px 0 0; } | |
| 356 | +.profile { display: flex; align-items: center; gap: 20px; margin-bottom: 28px; padding-bottom: 24px; border-bottom: 1px solid var(--border); } | |
| 357 | +.profile h1 { margin-bottom: 2px; } | |
| 358 | +.profile p { margin: 0; } | |
| 359 | +.filter-bar { display: flex; align-items: center; justify-content: space-between; gap: 12px; flex-wrap: wrap; margin-bottom: 12px; } | |
| 360 | +.filter-search { max-width: 420px; min-width: 200px; } | |
| 361 | +.repo-list { list-style: none; margin: 0; padding: 0; border: 1px solid var(--border); border-radius: var(--radius); } | |
| 362 | +.repo-row { display: flex; align-items: flex-start; gap: 12px; padding: 14px 16px; border-bottom: 1px solid var(--border); } | |
| 363 | +.repo-row:last-child { border-bottom: 0; } | |
| 364 | +.repo-row:hover { background: var(--surface); } | |
| 365 | +.repo-row:first-child { border-radius: var(--radius) var(--radius) 0 0; } | |
| 366 | +.repo-row:last-child { border-radius: 0 0 var(--radius) var(--radius); } | |
| 367 | +.repo-icon { display: inline-flex; padding-top: 3px; color: var(--muted); } | |
| 368 | +.repo-main { flex: 1; min-width: 0; } | |
| 369 | +.repo-link { font-size: 1.05rem; overflow-wrap: anywhere; } | |
| 370 | +.repo-row-description { margin: 2px 0 0; } | |
| 371 | +.repo-meta { display: flex; align-items: center; gap: 14px; flex-wrap: wrap; padding-top: 3px; white-space: nowrap; } | |
| 372 | +.meta-item { display: inline-flex; align-items: center; gap: 5px; } | |
| 373 | + | |
| 374 | +/* Repository header */ | |
| 375 | +.repo-head { margin-bottom: 16px; } | |
| 376 | +.repo-title { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; font-size: 1.3rem; font-weight: 400; } | |
| 377 | +.repo-title > svg.icon { color: var(--muted); } | |
| 378 | +.repo-title .sep { margin: 0; } | |
| 379 | +.repo-name { font-weight: 700; } | |
| 380 | +.repo-description { margin: 0 0 8px; } | |
| 381 | +.repo-bar { display: flex; justify-content: space-between; align-items: flex-end; gap: 16px; flex-wrap: wrap; border-bottom: 1px solid var(--border); } | |
| 382 | +.tabs { display: flex; gap: 2px; flex-wrap: wrap; } | |
| 383 | +.tab { display: inline-flex; align-items: center; gap: 7px; padding: 8px 12px; color: var(--text); border-bottom: 2px solid transparent; margin-bottom: -1px; } | |
| 384 | +.tab svg.icon { color: var(--muted); } | |
| 385 | +.tab:hover { text-decoration: none; border-bottom-color: var(--border-strong); } | |
| 386 | +.tab.active { border-bottom-color: var(--accent); font-weight: 600; } | |
| 387 | +.tab.active svg.icon { color: var(--text); } | |
| 388 | +.subtabs { display: flex; gap: 4px; margin: 12px 0; } | |
| 389 | +.subtabs a { padding: 4px 12px; border-radius: 999px; color: var(--muted); } | |
| 390 | +.subtabs a:hover { background: var(--surface); text-decoration: none; color: var(--text); } | |
| 391 | +.subtabs .active { background: var(--surface-2); font-weight: 600; color: var(--text); } | |
| 392 | + | |
| 393 | +.clone-menu { margin-bottom: 6px; } | |
| 394 | +.clone-panel { width: min(380px, calc(100vw - 28px)); padding: 12px; } | |
| 395 | +.clone-title { display: flex; align-items: center; gap: 6px; margin: 0 0 8px; font-weight: 600; } | |
| 396 | +.clone-hint { margin: 8px 0 0; } | |
| 397 | +.clone-box { display: flex; gap: 6px; min-width: 0; } | |
| 398 | +.clone-url { flex: 1; min-width: 0; font-family: var(--mono); font-size: 0.82rem; } | |
| 399 | +.copied, .copied svg.icon { color: var(--add-text); } | |
| 400 | + | |
| 401 | +/* Repository home: files on the left, facts about the repository on the right. */ | |
| 402 | +.repo-layout.with-side { display: grid; grid-template-columns: minmax(0, 1fr) 280px; gap: 32px; align-items: start; } | |
| 403 | +.repo-content { min-width: 0; } | |
| 404 | +.repo-side { margin-top: 12px; } | |
| 405 | +.side-section { padding-bottom: 16px; margin-bottom: 16px; border-bottom: 1px solid var(--border); } | |
| 406 | +.side-section:last-child { border-bottom: 0; } | |
| 407 | +.side-section h2 { font-size: 1rem; } | |
| 408 | +.side-section p { margin: 0 0 12px; overflow-wrap: anywhere; } | |
| 409 | +.side-list { list-style: none; margin: 0; padding: 0; display: grid; gap: 6px; } | |
| 410 | +.side-list li { display: flex; align-items: center; gap: 8px; } | |
| 411 | +.side-list svg.icon { color: var(--muted); } | |
| 412 | +.side-list a { color: var(--text); } | |
| 413 | +.side-list a:hover { color: var(--link); } | |
| 414 | + | |
| 415 | +.lang-bar { display: block; border-radius: 999px; overflow: hidden; background: var(--surface-2); } | |
| 416 | +.lang-bar rect { fill: var(--lang); } | |
| 417 | +.lang-legend { list-style: none; margin: 10px 0 0; padding: 0; display: flex; flex-wrap: wrap; gap: 4px 14px; font-size: 0.85rem; } | |
| 418 | +.lang-legend li { display: inline-flex; align-items: center; gap: 6px; } | |
| 419 | +.lang-dot { width: 9px; height: 9px; border-radius: 50%; background: var(--lang); } | |
| 420 | +.lang-csharp { --lang: #178600; } | |
| 421 | +.lang-javascript { --lang: #d4b830; } | |
| 422 | +.lang-typescript { --lang: #3178c6; } | |
| 423 | +.lang-html { --lang: #e34c26; } | |
| 424 | +.lang-css { --lang: #7e57c2; } | |
| 425 | +.lang-python { --lang: #3572a5; } | |
| 426 | +.lang-go { --lang: #00add8; } | |
| 427 | +.lang-rust { --lang: #dea584; } | |
| 428 | +.lang-java { --lang: #b07219; } | |
| 429 | +.lang-kotlin { --lang: #a97bff; } | |
| 430 | +.lang-swift { --lang: #f05138; } | |
| 431 | +.lang-c { --lang: #6e7681; } | |
| 432 | +.lang-cpp { --lang: #f34b7d; } | |
| 433 | +.lang-ruby { --lang: #a51d2d; } | |
| 434 | +.lang-php { --lang: #6e7bb8; } | |
| 435 | +.lang-lua { --lang: #3b4fc4; } | |
| 436 | +.lang-shell { --lang: #5fb233; } | |
| 437 | +.lang-powershell { --lang: #2b5797; } | |
| 438 | +.lang-sql { --lang: #e38c00; } | |
| 439 | +.lang-vb { --lang: #945db7; } | |
| 440 | +.lang-other { --lang: #8b949e; } | |
| 441 | + | |
| 442 | +/* Toolbar: ref switcher, breadcrumbs */ | |
| 443 | +.toolbar { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; margin: 12px 0; } | |
| 444 | +.toolbar-end { margin-left: auto; } | |
| 445 | +.breadcrumbs { overflow-wrap: anywhere; } | |
| 446 | + | |
| 447 | +.ref-switcher { position: relative; } | |
| 448 | +.ref-switcher summary { list-style: none; } | |
| 449 | +.ref-switcher summary::-webkit-details-marker { display: none; } | |
| 450 | +.ref-menu { | |
| 451 | + position: absolute; | |
| 452 | + z-index: 10; | |
| 453 | + top: calc(100% + 4px); | |
| 454 | + left: 0; | |
| 455 | + min-width: 240px; | |
| 456 | + max-height: 360px; | |
| 457 | + overflow-y: auto; | |
| 458 | + background: var(--bg); | |
| 459 | + border: 1px solid var(--border); | |
| 460 | + border-radius: var(--radius); | |
| 461 | + padding: 6px; | |
| 462 | + box-shadow: var(--shadow); | |
| 463 | +} | |
| 464 | +.ref-menu-title { margin: 6px 8px 2px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.04em; } | |
| 465 | +.ref-item { display: block; padding: 4px 8px; border-radius: 4px; color: var(--text); overflow-wrap: anywhere; } | |
| 466 | +.ref-item:hover { background: var(--surface-2); text-decoration: none; } | |
| 467 | +.ref-item.active { font-weight: 700; } | |
| 468 | + | |
| 469 | +/* The file list: the newest commit as its header, then one row per entry. */ | |
| 470 | +.file-box { border: 1px solid var(--border); border-radius: var(--radius); overflow: hidden; } | |
| 471 | +.file-box .table.tree { margin: 0; border: 0; border-radius: 0; } | |
| 472 | +.latest-commit { | |
| 473 | + display: flex; | |
| 474 | + justify-content: space-between; | |
| 475 | + align-items: center; | |
| 476 | + gap: 12px; | |
| 477 | + padding: 10px 12px; | |
| 478 | + border-bottom: 1px solid var(--border); | |
| 479 | + background: var(--surface); | |
| 480 | +} | |
| 481 | +.latest-subject { display: flex; align-items: center; gap: 8px; min-width: 0; } | |
| 482 | +.latest-subject strong { white-space: nowrap; } | |
| 483 | +.latest-message { color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } | |
| 484 | +.latest-meta { white-space: nowrap; } | |
| 485 | +.icon-folder { color: var(--link); fill: color-mix(in srgb, var(--link) 22%, transparent); } | |
| 486 | +.table.tree .tree-commit { width: 45%; max-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } | |
| 487 | +.table.tree .tree-age { white-space: nowrap; } | |
| 488 | +.readme-name { display: flex; align-items: center; gap: 8px; margin: -16px -16px 16px; padding: 10px 16px; border-bottom: 1px solid var(--border); background: var(--surface); border-radius: var(--radius) var(--radius) 0 0; font-weight: 600; } | |
| 489 | +.sha { font-family: var(--mono); font-size: 0.85rem; } | |
| 490 | + | |
| 491 | +/* Search inside a repository */ | |
| 492 | +.repo-search { flex: 0 1 300px; min-width: 180px; } | |
| 493 | +form.toolbar .repo-search { flex: 1 1 300px; max-width: 520px; } | |
| 494 | +.result-heading { display: flex; align-items: center; gap: 8px; margin-top: 24px; } | |
| 495 | +.result-heading svg.icon { color: var(--muted); } | |
| 496 | +.result-files { list-style: none; margin: 8px 0; padding: 4px 0; border: 1px solid var(--border); border-radius: var(--radius); } | |
| 497 | +.result-files li { display: flex; align-items: center; gap: 8px; padding: 4px 12px; overflow-wrap: anywhere; } | |
| 498 | +.result-files svg.icon { color: var(--muted); } | |
| 499 | +.result-file { margin: 12px 0; border: 1px solid var(--border); border-radius: var(--radius); overflow: hidden; } | |
| 500 | +.result-file-head { display: flex; align-items: center; gap: 8px; padding: 8px 12px; background: var(--surface); border-bottom: 1px solid var(--border); font-family: var(--mono); font-size: 0.87rem; overflow-wrap: anywhere; } | |
| 501 | +.result-file-head svg.icon { color: var(--muted); } | |
| 502 | +.result-lines { display: block; overflow-x: auto; border-collapse: collapse; font-family: var(--mono); font-size: 0.85rem; padding: 4px 0; } | |
| 503 | +.result-lines td { padding: 1px 10px; vertical-align: top; } | |
| 504 | +.result-lines .ln { min-width: 52px; text-align: right; user-select: none; white-space: nowrap; } | |
| 505 | +.result-lines .ln a { color: var(--muted); } | |
| 506 | +.result-code { white-space: pre; tab-size: 4; } | |
| 507 | +mark { background: var(--target-bg); color: inherit; border-radius: 2px; } | |
| 508 | + | |
| 509 | +/* README and markdown */ | |
| 510 | +.markdown { overflow-wrap: anywhere; } | |
| 511 | +.markdown > :first-child { margin-top: 0; } | |
| 512 | +.markdown > :last-child { margin-bottom: 0; } | |
| 513 | +.markdown img { max-width: 100%; } | |
| 514 | +.markdown pre, .snippet, .plain, .commit-body { | |
| 515 | + background: var(--surface); | |
| 516 | + border-radius: var(--radius-small); | |
| 517 | + padding: 12px; | |
| 518 | + overflow-x: auto; | |
| 519 | +} | |
| 520 | +.plain, .commit-body { white-space: pre-wrap; overflow-wrap: anywhere; } | |
| 521 | +.markdown table { border-collapse: collapse; } | |
| 522 | +.markdown th, .markdown td { border: 1px solid var(--border); padding: 4px 10px; } | |
| 523 | +.markdown blockquote { margin: 0; padding-left: 12px; border-left: 3px solid var(--border); color: var(--muted); } | |
| 524 | +.markdown h1, .markdown h2 { border-bottom: 1px solid var(--border); padding-bottom: 4px; margin-top: 1.2em; } | |
| 525 | + | |
| 526 | +/* File view */ | |
| 527 | +.file-head { | |
| 528 | + display: flex; | |
| 529 | + justify-content: space-between; | |
| 530 | + align-items: center; | |
| 531 | + gap: 12px; | |
| 532 | + padding: 8px 12px; | |
| 533 | + border: 1px solid var(--border); | |
| 534 | + border-bottom: 0; | |
| 535 | + border-radius: var(--radius) var(--radius) 0 0; | |
| 536 | + background: var(--surface); | |
| 537 | +} | |
| 538 | +.file-info { display: flex; align-items: center; gap: 8px; min-width: 0; } | |
| 539 | +.file-info svg.icon { color: var(--muted); } | |
| 540 | +.file-name { overflow-wrap: anywhere; } | |
| 541 | +.file-actions { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; justify-content: flex-end; } | |
| 542 | +.file-actions .segmented { font-size: 0.85rem; margin-right: 6px; } | |
| 543 | +.file-actions .segmented a { padding: 2px 10px; } | |
| 544 | +.file-head + .card, .file-head + .code-view { margin-top: 0; border-radius: 0 0 var(--radius) var(--radius); } | |
| 545 | +.file-preview { padding: 24px 32px; } | |
| 546 | +.code-view { position: relative; display: flex; border: 1px solid var(--border); overflow-x: auto; } | |
| 547 | +.code-view pre { position: relative; margin: 0; padding: 10px 0; line-height: 1.45; } | |
| 548 | +.line-numbers { text-align: right; user-select: none; border-right: 1px solid var(--border); flex: none; } | |
| 549 | +.line-numbers a { display: block; padding: 0 10px; color: var(--muted); } | |
| 550 | +.line-numbers a:hover { color: var(--text); text-decoration: none; } | |
| 551 | +html:not(.js) .line-numbers a:target, .line-numbers a.selected { background: var(--target-bg); color: var(--text); font-weight: 700; } | |
| 552 | +.line-highlight { position: absolute; left: 0; background: var(--target-bg); pointer-events: none; } | |
| 553 | +.button-group { display: inline-flex; } | |
| 554 | +.button-group .button { border-radius: 0; } | |
| 555 | +.button-group .button + .button { margin-left: -1px; } | |
| 556 | +.button-group .button:first-child { border-radius: var(--radius-small) 0 0 var(--radius-small); } | |
| 557 | +.button-group .button:last-child { border-radius: 0 var(--radius-small) var(--radius-small) 0; } | |
| 558 | +.icon-button.inline { width: 24px; height: 24px; vertical-align: middle; } | |
| 559 | +.code-view .code { padding-left: 12px; padding-right: 12px; flex: 1; tab-size: 4; } | |
| 560 | +.code-view .code code.hljs { padding: 0; background: none; overflow: visible; } | |
| 561 | +.image-view { text-align: center; } | |
| 562 | +.image-view img { max-width: 100%; } | |
| 563 | + | |
| 564 | +/* Commits */ | |
| 565 | +.commit-list { list-style: none; margin: 12px 0; padding: 0; border: 1px solid var(--border); border-radius: var(--radius); } | |
| 566 | +.commit-row { display: flex; justify-content: space-between; align-items: center; gap: 16px; padding: 10px 14px; border-bottom: 1px solid var(--border); } | |
| 567 | +.commit-row:last-child { border-bottom: 0; } | |
| 568 | +.commit-row:hover { background: var(--surface); } | |
| 569 | +.commit-main { min-width: 0; } | |
| 570 | +.commit-day { display: flex; align-items: center; gap: 8px; margin: 20px 0 0; color: var(--muted); font-size: 0.9rem; font-weight: 600; } | |
| 571 | +.commit-day + .commit-list { margin-top: 8px; } | |
| 572 | +.commit-byline { display: flex; align-items: center; gap: 6px; margin-top: 3px; } | |
| 573 | +.commit-byline .sep { margin: 0; } | |
| 574 | +.commit-actions { display: flex; align-items: center; gap: 6px; flex: none; } | |
| 575 | +.meta dd .avatar { vertical-align: -4px; } | |
| 576 | +.commit-subject { font-weight: 600; color: var(--text); overflow-wrap: anywhere; } | |
| 577 | +.pager { display: flex; gap: 8px; justify-content: center; margin: 16px 0; } | |
| 578 | +.commit-title { overflow-wrap: anywhere; } | |
| 579 | +.meta { display: grid; grid-template-columns: max-content 1fr; gap: 4px 16px; margin: 12px 0; } | |
| 580 | +.meta dt { color: var(--muted); } | |
| 581 | +.meta dd { margin: 0; overflow-wrap: anywhere; } | |
| 582 | +.meta .sha { margin-right: 8px; } | |
| 583 | +.stat-list { list-style: none; margin: 8px 0 16px; padding: 0; } | |
| 584 | +.stat-list li { display: flex; gap: 12px; padding: 2px 0; overflow-wrap: anywhere; } | |
| 585 | +.stat-counts { flex: none; min-width: 90px; font-family: var(--mono); font-size: 0.85rem; } | |
| 586 | +.comment { margin: 8px 0; } | |
| 587 | +.comment p:first-child { margin-top: 0; } | |
| 588 | + | |
| 589 | +/* Diff */ | |
| 590 | +.diff-file { border: 1px solid var(--border); border-radius: var(--radius); margin: 16px 0; overflow: hidden; } | |
| 591 | +.diff-file-head { display: flex; gap: 10px; align-items: center; padding: 8px 12px; background: var(--surface); border-bottom: 1px solid var(--border); } | |
| 592 | +.diff-path { font-family: var(--mono); font-size: 0.87rem; overflow-wrap: anywhere; flex: 1; } | |
| 593 | +.diff-counts { font-family: var(--mono); font-size: 0.85rem; white-space: nowrap; } | |
| 594 | +.diff-note { margin: 0; padding: 12px; } | |
| 595 | +.diff { width: 100%; border-collapse: collapse; font-family: var(--mono); font-size: 0.85rem; display: block; overflow-x: auto; } | |
| 596 | +.diff td { padding: 0 8px; vertical-align: top; } | |
| 597 | +.diff .ln { width: 1%; min-width: 44px; text-align: right; color: var(--muted); user-select: none; white-space: nowrap; } | |
| 598 | +.diff .diff-code { white-space: pre; width: 100%; } | |
| 599 | +.diff .marker { display: inline-block; width: 1.2em; user-select: none; } | |
| 600 | +.diff tr.add { background: var(--add-bg); } | |
| 601 | +.diff tr.del { background: var(--del-bg); } | |
| 602 | +.diff tr.hunk { background: var(--hunk-bg); color: var(--muted); } | |
| 603 | +.diff tr.meta { color: var(--muted); font-style: italic; } | |
| 604 | + | |
| 605 | +/* Diff: options, file index, collapsible files, side-by-side layout, within-line changes */ | |
| 606 | +.diff-options { display: flex; gap: 16px; align-items: center; flex-wrap: wrap; margin: 8px 0 12px; font-size: 0.9rem; } | |
| 607 | +.segmented { display: inline-flex; border: 1px solid var(--border); border-radius: var(--radius-small); overflow: hidden; } | |
| 608 | +.segmented a { padding: 4px 12px; color: var(--text); } | |
| 609 | +.segmented a + a { border-left: 1px solid var(--border); } | |
| 610 | +.segmented a.active { background: var(--surface-2); font-weight: 600; } | |
| 611 | +.segmented a:hover { text-decoration: none; background: var(--surface); } | |
| 612 | +.diff-index { list-style: none; margin: 8px 0 16px; padding: 0; } | |
| 613 | +.diff-index li { display: flex; gap: 12px; padding: 2px 0; overflow-wrap: anywhere; } | |
| 614 | +details.diff-file > summary { cursor: pointer; list-style-position: inside; } | |
| 615 | +details.diff-file:not([open]) > summary { border-bottom: 0; } | |
| 616 | +.diff.split .diff-code { width: 50%; } | |
| 617 | +.diff.split td.add { background: var(--add-bg); } | |
| 618 | +.diff.split td.del { background: var(--del-bg); } | |
| 619 | +.diff.split td.blank { background: var(--surface); } | |
| 620 | +.diff.split td.ln + td.diff-code { border-right: 1px solid var(--border); } | |
| 621 | +.diff .chg { border-radius: 2px; } | |
| 622 | +.diff tr.add .chg, .diff td.add .chg { background: var(--add-strong); } | |
| 623 | +.diff tr.del .chg, .diff td.del .chg { background: var(--del-strong); } | |
| 624 | +.diff .line .hljs, .diff .line { background: none; } | |
| 625 | + | |
| 626 | +/* Compare, conflicts and ref management */ | |
| 627 | +.compare-form label { display: flex; align-items: center; gap: 6px; } | |
| 628 | +.compare-form select { width: auto; max-width: 260px; } | |
| 629 | +fieldset.conflict { margin-bottom: 12px; } | |
| 630 | +.apply-form { margin: 12px 0 0; } | |
| 631 | +.apply-form label { display: flex; align-items: center; gap: 6px; } | |
| 632 | +.apply-form select { width: auto; max-width: 260px; } | |
| 633 | + | |
| 634 | +/* Pull requests */ | |
| 635 | +.pull-icon { display: inline-flex; flex: none; } | |
| 636 | +.pull-open { color: var(--add-text); } | |
| 637 | +.pull-merged { color: var(--merged-text); } | |
| 638 | +.pull-closed { color: var(--del-text); } | |
| 639 | +.pull-main { flex: 1; } | |
| 640 | +.pull-title { font-size: 1.4rem; margin-bottom: 8px; } | |
| 641 | +.pull-summary { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; margin: 0 0 16px; } | |
| 642 | +.commit-byline { flex-wrap: wrap; } | |
| 643 | +.comment-head { margin: 0 0 8px; } | |
| 644 | +.cell-icon { color: var(--muted); margin-right: 4px; } | |
| 645 | + | |
| 646 | +/* Activity: stat tiles, the weekly chart, contributors */ | |
| 647 | +.activity-scope { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; margin: 12px 0; } | |
| 648 | +.stat-tiles { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 12px; margin: 0 0 16px; } | |
| 649 | +.stat-tile { padding: 14px 16px; border: 1px solid var(--border); border-radius: var(--radius); } | |
| 650 | +.stat-tile dt { color: var(--muted); font-size: 0.85rem; } | |
| 651 | +.stat-tile dd { margin: 4px 0 0; font-size: 1.7rem; font-weight: 700; line-height: 1.2; letter-spacing: -0.01em; font-variant-numeric: tabular-nums; } | |
| 652 | +.stat-tile dd.stat-date { font-size: 1.25rem; line-height: 1.65; } | |
| 653 | +.chart-sub { margin: -8px 0 12px; } | |
| 654 | +.chart-scroll { overflow-x: auto; } | |
| 655 | +.week-chart { display: block; width: 100%; min-width: 620px; height: auto; } | |
| 656 | +.chart-grid { stroke: var(--border); stroke-width: 1; stroke-dasharray: 2 3; } | |
| 657 | +.chart-axis { stroke: var(--border-strong); stroke-width: 1; } | |
| 658 | +.chart-label { fill: var(--muted); font-size: 10px; font-family: var(--sans); } | |
| 659 | +.week-hit { fill: transparent; } | |
| 660 | +.week-bar { fill: var(--accent); } | |
| 661 | +.week:hover .week-hit { fill: var(--surface-2); } | |
| 662 | +.section-title { display: flex; align-items: center; gap: 8px; margin-top: 28px; } | |
| 663 | +.contributor-list { list-style: none; margin: 0; padding: 0; border: 1px solid var(--border); border-radius: var(--radius); } | |
| 664 | +.contributor { display: flex; align-items: center; gap: 12px; padding: 10px 14px; border-bottom: 1px solid var(--border); } | |
| 665 | +.contributor:last-child { border-bottom: 0; } | |
| 666 | +.contributor-main { flex: 1; min-width: 0; overflow-wrap: anywhere; } | |
| 667 | +.contributor-share { width: 180px; flex: none; text-align: right; } | |
| 668 | +.share-bar { display: block; margin-top: 4px; border-radius: 999px; background: var(--surface-2); } | |
| 669 | +.share-bar rect { fill: var(--accent); } | |
| 670 | + | |
| 671 | +/* Dialogs */ | |
| 672 | +.dialog { width: min(420px, calc(100vw - 32px)); padding: 20px; border: 1px solid var(--border); border-radius: 12px; background: var(--bg); color: var(--text); box-shadow: var(--shadow); } | |
| 673 | +.dialog::backdrop { background: rgba(0, 0, 0, 0.45); } | |
| 674 | +.shortcut-list { display: grid; grid-template-columns: max-content 1fr; gap: 10px 16px; margin: 0 0 20px; align-items: center; } | |
| 675 | +.shortcut-list dd { margin: 0; } | |
| 676 | +.footer-link { margin-left: 12px; } | |
| 677 | + | |
| 678 | +/* Status pages */ | |
| 679 | +.status-action { margin-top: 24px; } | |
| 680 | +.status-page { text-align: center; padding: 72px 0; } | |
| 681 | +.status-code { font-size: 4rem; font-weight: 800; line-height: 1; letter-spacing: -0.03em; margin: 0 0 12px; color: var(--accent); } | |
| 682 | + | |
| 683 | +@media (max-width: 900px) { | |
| 684 | + .repo-layout.with-side { grid-template-columns: minmax(0, 1fr); gap: 8px; } | |
| 685 | +} | |
| 686 | + | |
| 687 | +@media (max-width: 720px) { | |
| 688 | + .wrap { padding: 0 14px; } | |
| 689 | + .table.tree .tree-commit, .latest-message { display: none; } | |
| 690 | + .file-head { flex-wrap: wrap; } | |
| 691 | + .file-preview { padding: 16px; } | |
| 692 | + .file-box .table.tree { display: table; } | |
| 693 | + .repo-row { flex-wrap: wrap; } | |
| 694 | + .repo-meta { width: 100%; padding-left: 30px; } | |
| 695 | + .commit-row { flex-direction: column; align-items: flex-start; gap: 4px; } | |
| 696 | + .clone-url { width: 100%; } | |
| 697 | + .clone-box { width: 100%; } | |
| 698 | + .table { display: block; overflow-x: auto; } | |
| 699 | + .search kbd { display: none; } | |
| 700 | + .narrow { margin: 16px auto; padding: 20px; } | |
| 701 | + .profile { gap: 14px; } | |
| 702 | +} | |
| 703 | + | |
| 704 | +@media (prefers-reduced-motion: no-preference) { | |
| 705 | + .button, .icon-button, .menu-item, .tab { transition: background-color 0.12s, border-color 0.12s, color 0.12s; } | |
| 706 | +} |
added forge/wwwroot/theme.js +15 −0View file
| @@ -0,0 +1,15 @@ | ||
| 1 | +// Runs before the page paints, so a saved light/dark choice never flashes the other theme. | |
| 2 | +// Without a saved choice the page follows the system setting (see the media query in style.css). | |
| 3 | +(function () { | |
| 4 | + var root = document.documentElement; | |
| 5 | + // Controls that only work with script (theme switch, copy buttons) are hidden until this is set. | |
| 6 | + root.classList.add('js'); | |
| 7 | + try { | |
| 8 | + var theme = localStorage.getItem('forge-theme'); | |
| 9 | + if (theme === 'light' || theme === 'dark') { | |
| 10 | + root.dataset.theme = theme; | |
| 11 | + } | |
| 12 | + } catch (e) { | |
| 13 | + // Storage can be blocked; the system setting still applies. | |
| 14 | + } | |
| 15 | +})(); |