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 | } | ||
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} | ||
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} | ||
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 | })(); | ||