Commit `ddab521653`

ddab52165310177c117b89a07d5b155e56fb56dc

parent: 0a4bb99d63

Verified · cmc ci/build: success ci/test: success ci/vuln: success

cmc <hello@cleberg.net> · 2026-09-04 01:39 UTC

web: a diff cut at 4 MiB says so, and the commit list says how many it hides

Diff and ShowPatch cut the patch at the byte limit mid-line and
reported nothing, so the last hunk rendered wrong and the diffstat
under-reported. Both now cut on a line boundary and return whether
they did; the commit and merge request pages show a notice and the
diffstat says its counts are partial; mr diff and repo commit say so
on stderr. The merge request's commit list is capped at 100 and now
says "first 100 of N".

Closes #117

Layout: unified · split

internal/control/mr.go +4 −1

 		}
 		base = b
 	}
-	patch, err := gitutil.Diff(dir, base, head, 4<<20)
+	patch, truncated, err := gitutil.Diff(dir, base, head, 4<<20)
 	if err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 	fmt.Fprint(c.Stdout, patch)
+	if truncated {
+		fmt.Fprintln(c.Stderr, "diff truncated at 4 MiB; fetch the branch for the rest")
+	}
 	return protocol.ExitOK
 }

internal/control/sig.go +4 −1

 	if err != nil {
 		return c.fail(protocol.ExitFailure, "verifying %s: %v", full, err)
 	}
-	patch, err := gitutil.ShowPatch(dir, full, 4<<20)
+	patch, truncated, err := gitutil.ShowPatch(dir, full, 4<<20)
 	if err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
+	if truncated {
+		fmt.Fprintln(c.Stderr, "patch truncated at 4 MiB; clone the repository for the rest")
+	}
 	statuses, err := c.Store.ListCommitStatuses(repo.ID, full)
 	if err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)

internal/gitutil/endofoptions_test.go +1 −1

	@@ -35,7 +35,7 @@ func TestRefsAreNotOptions(t *testing.T) {
35	"Archive": func() error { return Archive(dir, ref, "x", &sink) },	35	"Archive": func() error { return Archive(dir, ref, "x", &sink) },
36	"Grep": func() error { _, err := Grep(dir, ref, "hi", 10); return err },	36	"Grep": func() error { _, err := Grep(dir, ref, "hi", 10); return err },
37	"MergeBase": func() error { _, err := MergeBase(dir, ref, "main"); return err },	37	"MergeBase": func() error { _, err := MergeBase(dir, ref, "main"); return err },
38	"Diff": func() error { _, err := Diff(dir, ref, "main", 1<<20); return err },	38	"Diff": func() error { _, _, err := Diff(dir, ref, "main", 1<<20); return err },
39	"DiffFiles": func() error { _, err := DiffFiles(dir, ref, "main"); return err },	39	"DiffFiles": func() error { _, err := DiffFiles(dir, ref, "main"); return err },
40	"RevListRange": func() error { _, err := RevListRange(dir, "main", ref); return err },	40	"RevListRange": func() error { _, err := RevListRange(dir, "main", ref); return err },
41	"Blame": func() error { _, err := Blame(dir, ref, "f.txt", 1, 1); return err },	41	"Blame": func() error { _, err := Blame(dir, ref, "f.txt", 1, 1); return err },

internal/gitutil/merge.go +20 −6

 package gitutil
 import (
+	"bytes"
 	"fmt"
 	"os"
 	"os/exec"
 }
 // Diff returns the patch for old..new (three-dot semantics are the caller's
-// job: pass the merge base as old).
+// job: pass the merge base as old), cut at limit bytes on a line boundary;
-func Diff(dir, old, new string, limit int64) (string, error) {
+// truncated says whether it was cut, so the caller can say so instead of
+// rendering a hunk that ends mid-line (#117).
+func Diff(dir, old, new string, limit int64) (patch string, truncated bool, err error) {
 	cmd := exec.Command("git", "-C", dir, "diff", "--stat", "--patch", "--end-of-options", old, new)
 	out, err := cmd.Output()
 	if err != nil {
-		return "", fmt.Errorf("diff: %w", err)
+		return "", false, fmt.Errorf("diff: %w", err)
 	}
-	if int64(len(out)) > limit {
+	out, truncated = cutAtLine(out, limit)
-		out = out[:limit]
+	return string(out), truncated, nil
+}
+// cutAtLine keeps at most limit bytes, ending on the last newline before
+// the limit.
+func cutAtLine(out []byte, limit int64) ([]byte, bool) {
+	if int64(len(out)) <= limit {
+		return out, false
+	}
+	cut := out[:limit]
+	if i := bytes.LastIndexByte(cut, '\n'); i >= 0 {
+		cut = cut[:i+1]
 	}
-	return string(out), nil
+	return cut, true
 }
 // MergeBase returns the best common ancestor, or an error if none exists.

internal/gitutil/read.go +9 −7

 }
 // ShowPatch returns the stat+patch text for one commit.
-func ShowPatch(dir, sha string, limit int64) (string, error) {
+func ShowPatch(dir, sha string, limit int64) (patch string, truncated bool, err error) {
-	cmd := exec.Command("git", "-C", dir, "show", "--stat", "--patch", "--format=", sha)
+	cmd := exec.Command("git", "-C", dir, "show", "--stat", "--patch", "--format=", "--end-of-options", sha)
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-		return "", err
+		return "", false, err
 	}
 	if err := cmd.Start(); err != nil {
-		return "", err
+		return "", false, err
 	}
-	data, _ := io.ReadAll(io.LimitReader(stdout, limit))
+	// One byte past the limit says whether there was more.
+	data, _ := io.ReadAll(io.LimitReader(stdout, limit+1))
 	io.Copy(io.Discard, stdout)
 	if err := cmd.Wait(); err != nil {
-		return "", fmt.Errorf("show %s: %w", sha, err)
+		return "", false, fmt.Errorf("show %s: %w", sha, err)
 	}
-	return string(data), nil
+	data, truncated = cutAtLine(data, limit)
+	return string(data), truncated, nil
 }
 // IsBinary reports whether data looks like binary content.

internal/httpd/web.go +11 −5

 		s.notFound(w, r)
 		return
 	}
-	patch, _ := gitutil.ShowPatch(p.Dir, full, 4<<20)
+	patch, truncated, _ := gitutil.ShowPatch(p.Dir, full, 4<<20)
 	files := parseDiff(patch)
 	committerEmail := ""
 	if parsed.CommitterEmail != parsed.AuthorEmail {
 		Sig                                                                               sigView
 		Checks                                                                            []store.CommitStatus
 		DiffFiles                                                                         []diffFile
+		DiffTruncated                                                                     bool
 	}{p, full, full[:10], commitNames.name(parsed.AuthorEmail, parsed.AuthorName), parsed.AuthorEmail, commitUser, committerEmail,
 		time.Unix(parsed.AuthorUnix, 0).UTC().Format(time.RFC3339), msg,
-		gitutil.Parents(p.Dir, full), v, checks, files})
+		gitutil.Parents(p.Dir, full), v, checks, files, truncated})
 }
 // labelPalette provides default label chip colors: mid-tone hues that stay
 			base = b
 		}
 	}
+	var diffTruncated bool
 	if base != "" {
-		if patch, err := gitutil.Diff(p.Dir, base, headRef, 4<<20); err == nil {
+		if patch, truncated, err := gitutil.Diff(p.Dir, base, headRef, 4<<20); err == nil {
-			files = parseDiff(patch)
+			files, diffTruncated = parseDiff(patch), truncated
 		}
 	}
 	md := s.ugcFor(r, p.Repo)
 	}
 	mrNames := s.authorNames()
 	var commits []commitRow
+	commitsTotal := 0
 	if base != "" {
 		const maxMRCommits = 100
 		shas, _ := gitutil.RevListRange(p.Dir, base, headRef)
+		commitsTotal = len(shas)
 		if len(shas) > maxMRCommits {
 			shas = shas[:maxMRCommits]
 		}
 		Comments        []renderedComment
 		Reviews         []store.MRReview
 		DiffFiles       []diffFile
+		DiffTruncated   bool
 		Stat            diffStat
 		Commits         []commitRow
+		CommitsTotal    int
 		Branches        []gitutil.Ref
 		CanEdit         bool
 		CanWrite        bool
 		StackedOn       *store.MR
 		Stacked         []store.MR
 	}{p, m, view, md(m.Body, m.BodyFormat), checks, combined, renderComments(comments, md),
-		reviews, files, stat, commits, branches, s.canEditItem(r, p.Repo, m.Author),
+		reviews, files, diffTruncated, stat, commits, commitsTotal, branches, s.canEditItem(r, p.Repo, m.Author),
 		canWrite, unresolved, r.URL.Query().Get("e"), detachedThreads, stackedOn, stacked})
 }

internal/web/templates/commit.html +1

	@@ -9,5 +9,6 @@
9	{{if .CommitterEmail}}<br>committer: <{{.CommitterEmail}}>{{end}}</p>	9	{{if .CommitterEmail}}<br>committer: <{{.CommitterEmail}}>{{end}}</p>
10	</div>	10	</div>
11	<pre class="message">{{.Message}}</pre>	11	<pre class="message">{{.Message}}</pre>
		12	{{if .DiffTruncated}}<p class="error" role="alert">This patch is larger than 4 MiB and is cut off below. Clone the repository to see all of it.</p>{{end}}
12	{{template "difffiles" dict "Files" .DiffFiles "Base" "" "Viewer" ""}}	13	{{template "difffiles" dict "Files" .DiffFiles "Base" "" "Viewer" ""}}
13	{{end}}	14	{{end}}

internal/web/templates/mr.html +3 −1

 {{end}}
 {{else if eq .View "commits"}}
+{{if gt .CommitsTotal (len .Commits)}}<p class="meta">first {{len .Commits}} of {{.CommitsTotal}} commits; the rest are in the branch</p>{{end}}
 <ul class="loglist">
 {{range .Commits}}<li>
   <div class="commitmain">
 </ul>
 {{else}}
-<p class="diffstat">{{.Stat.Files}} file{{if ne .Stat.Files 1}}s{{end}} changed, <span class="add">+{{.Stat.Adds}}</span> <span class="del">−{{.Stat.Dels}}</span></p>
+<p class="diffstat">{{.Stat.Files}} file{{if ne .Stat.Files 1}}s{{end}} changed, <span class="add">+{{.Stat.Adds}}</span> <span class="del">−{{.Stat.Dels}}</span>{{if .DiffTruncated}} · shown up to 4 MiB; the counts and the last file are partial{{end}}</p>
+{{if .DiffTruncated}}<p class="error" role="alert">This diff is larger than 4 MiB and is cut off below. Fetch the branch to see all of it.</p>{{end}}
 {{template "difffiles" dict "Files" .DiffFiles "Base" $base "Viewer" .Viewer}}
 {{end}}

Commit ddab521653

Commit `ddab521653`