tenseleyflow/shithub / fa6f995

 	pool   *pgxpool.Pool

 	logger *slog.Logger

 }

 func loadHookCtx(ctx context.Context) (*hookCtx, error) {

 	}

 	for _, r := range refs {

 		event, err := wq.InsertPushEvent(ctx, tx, workerdb.InsertPushEventParams{

 		})

 		if err != nil {

 			return fmt.Errorf("insert push_event: %w", err)

 	rootCmd.AddCommand(hookCmd)

 	rootCmd.AddCommand(hooksParentCmd)

 }

 		if dispatchErr != nil {

 			pool.Close()

 			_, _ = fmt.Fprintln(cmd.ErrOrStderr(), protocol.FriendlyMessageFor(dispatchErr, ""))

 				"user_id", userID,

 				"original", original,

 				"remote_ip", remoteIP,

 			)

 			return dispatchErr

 		}

 			"user_id", userID,

 			"op", string(parsed.Service),

 			"owner", parsed.Owner,

 type Action string

 const (

 )

 // Target is a typed target-type constant.

 	}

 	return ref

 }

 }

 const (

 )

 func makeActor(k actorKind) policy.Actor {

 	}

 }

 // TestPermissionsDoc_CoversEveryAction guards against drift between

 // the policy package and docs/internal/permissions.md. The doc's

 // "Action → minimum role" table must mention every Action constant

 	"shithubd":      {},

 	"shithubbot":    {},

 	// S29 — notification subscribe/unsubscribe per thread.

 	// S30 — invitation accept/decline.

 }

 // IsReserved reports whether name is on the reserved list. The check is

 // Errors surfaced to API + handlers.

 var (

 	ErrCompletedNeedsConclusion = errors.New("checks: completed status requires conclusion")

 )

 // validStatus / validConclusion mirror the Postgres enums.

 		RepoID: f.repoID, HeadSHA: strings.Repeat("a", 40), Name: "lint",

 	})

 	if _, err := checks.Update(ctx, f.deps, checks.UpdateParams{

 		HasCompletedAt: true, CompletedAt: when.Add(30 * time.Second),

 	}); err != nil {

 		t.Fatalf("Update: %v", err)

 	}()

 	suite, err := q.GetOrCreateCheckSuite(ctx, tx, checksdb.GetOrCreateCheckSuiteParams{

 	})

 	if err != nil {

 		return checksdb.CheckRun{}, fmt.Errorf("suite: %w", err)

 // GateInputs is the small struct the merge gate cares about.

 type GateInputs struct {

 }

 // GateResult mirrors the spec's blocked-with-reason vocabulary.

 type GateResult struct {

 	Satisfied bool

 	// Missing is the subset of RequiredNames that haven't yet succeeded

 	// or returned neutral on HeadSHA. Populated for UI tooltips.

 	Missing []string

 func TestDeriveSuiteRollup(t *testing.T) {

 	t.Parallel()

 	cases := []struct {

 	}{

 		{

 			"empty → queued",

 func TestDispatch_SuspendedUserSuspended(t *testing.T) {

 	t.Parallel()

 	env := setupDispatch(t)

 		"UPDATE users SET suspended_at = now(), suspended_reason = 'test' WHERE id = $1",

 		env.alice,

 	); err != nil {

 // which is the safe default for the public-feed flag on the event row.

 func repoVisibilityPublic(ctx context.Context, db pgxRow, repoID int64) (bool, error) {

 	var vis string

 		`SELECT visibility::text FROM repos WHERE id = $1`,

 		repoID,

 	).Scan(&vis)

 // Two patterns:

 //

 //

 // Word-boundary on the leading side so we don't grab "abc#1". The N is

 // limited to 1–9 leading digit + arbitrary digits, capped at 9 total to

 			pKind string

 			pID   int64

 		)

 			`SELECT kind::text, id FROM principals WHERE slug = $1`,

 			strings.ToLower(owner),

 		).Scan(&pKind, &pID)

 	return nil

 }

 		t.Errorf("got %v, want %v", got, want)

 	}

 }

 // the rendered output.

 var emojiMap = map[string]string{

 	// Common reactions

 	"heavy_multiplication_x": "✖️",

 	"heavy_plus_sign":        "➕",

 	"heavy_minus_sign":       "➖",

 	"gem":                    "💎",

 	"art":                    "🎨",

 	"musical_note":           "🎵",

 	"sound":                  "🔊",

 	"mute":                   "🔇",

 	"video_camera":           "📹",

 //	#14               user mention: username

 //	#16               commit prefix

 //	#18               emoji name

 )

 // Extension is a goldmark.Extender that registers the AST transformer.

 		// content starts (excluding the regex-consumed boundary

 		// char, if any).

 		var (

 		)

 		var contentStart int

 		switch {

 	}

 	return true

 }

 func TestRender_AllowsSafeHTML(t *testing.T) {

 	t.Parallel()

 	cases := []struct {

 		mustContain []string

 	}{

 		{

 // participating threads master toggle, default on").

 func emailPrefOn(ctx context.Context, pool *pgxpool.Pool, userID int64, key string) (bool, error) {

 	var raw json.RawMessage

 		`SELECT value FROM user_notification_prefs WHERE user_id = $1 AND key = $2`,

 		userID, key,

 	).Scan(&raw)

 	RepoID      int64  // 0 → user-scoped event (NULL).

 	SourceKind  string // "issue", "pull", "repo", "user", …

 	SourceID    int64

 	Extra       map[string]any

 }

 	c.messages = append(c.messages, m)

 	return nil

 }

 func (c *captureSender) count() int {

 	c.mu.Lock()

 	defer c.mu.Unlock()

 func TestUnsubscribe_HMACRoundtrip(t *testing.T) {

 	key := []byte("test-key-32-bytes-aaaaaaaaaaaaaa")

 	const (

 		other = int64(46)

 	)

 	// Build by parsing the URL the same path the email-side uses.

 // Errors surfaced by the orchestrator.

 var (

 )

 // FanoutBatch is the per-tick cap on how many domain_events the

 // 10 minutes (the spec's day-1 lean). Per-recipient absolute cap

 // is 100 emails per hour.

 const (

 )

 	ReasonMention         Reason = "mention"

 	ReasonAssignment      Reason = "assignment"

 	ReasonReviewRequested Reason = "review_requested"

 	ReasonRepoAdminAction Reason = "repo_admin_action"

 )

 // CreateParams describes a create-org request.

 type CreateParams struct {

 }

 // slugRE mirrors the username pattern (lowercase letters, digits,

 	}

 	if err := q.AddOrgMember(ctx, tx, orgsdb.AddOrgMemberParams{

 	}); err != nil {

 		return orgsdb.Org{}, fmt.Errorf("seed owner: %w", err)

 	}

 	// soft-delete). Refuse to restore if so — the operator can rename

 	// the conflicting principal and retry.

 	var taken bool

 		`SELECT EXISTS(SELECT 1 FROM principals WHERE slug = $1)`,

 		row.Slug,

 	).Scan(&taken); err != nil {

 		return InviteResult{}, fmt.Errorf("invite token: %w", err)

 	}

 	row, err := q.CreateOrgInvitation(ctx, deps.Pool, orgsdb.CreateOrgInvitationParams{

 	})

 	if err != nil {

 		return InviteResult{}, fmt.Errorf("create invitation: %w", err)

 	}

 	return out

 }

 	}

 	prRow, err := pullsdb.New().CreatePullRequest(ctx, deps.Pool, pullsdb.CreatePullRequestParams{

 	})

 	if err != nil {

 		return CreateResult{}, fmt.Errorf("create pull_request: %w", err)

 	issue, ierr := issuesdb.New().GetIssueByID(ctx, deps.Pool, p.PRIssueID)

 	if ierr == nil {

 		var public bool

 			`SELECT visibility = 'public' FROM repos WHERE id = $1`,

 			issue.RepoID,

 		).Scan(&public)

 }

 type fx struct {

 }

 func setup(t *testing.T) fx {

 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))

 	return fx{

 		pullsDeps:  pulls.Deps{Pool: pool, Logger: logger},

 		reviewDeps: review.Deps{Pool: pool, Logger: logger},

 		authorID:   author.ID,

 		return err

 	}

 	return q.DismissPRReview(ctx, deps.Pool, pullsdb.DismissPRReviewParams{

 	})

 }

 // Line is one rendered row in a hunk.

 type Line struct {

 }

 // Parse consumes a unified diff stream into the typed shape. The

 		for _, l := range h.Lines {

 			old, neu := lineNoCells(l)

 			content := highlightOrEscape(f.NewPath, l.Content, opts)

 				`<tr class="%s"><td class="shithub-diff-lineno">%s</td><td class="shithub-diff-lineno">%s</td><td class="shithub-diff-content"><pre>%s%s</pre></td></tr>`,

 				lineClass(l.Kind), old, neu, lineMarker(l.Kind), content,

 			)

 				rightNo = numStr(p.right.NewLineNo)

 				rightContent = lineMarker(p.right.Kind) + highlightOrEscape(f.NewPath, p.right.Content, opts)

 			}

 				`<tr><td class="shithub-diff-lineno %s">%s</td><td class="shithub-diff-content %s"><pre>%s</pre></td><td class="shithub-diff-lineno %s">%s</td><td class="shithub-diff-content %s"><pre>%s</pre></td></tr>`,

 				leftClass, leftNo, leftClass, leftContent,

 				rightClass, rightNo, rightClass, rightContent,

 // root commit (no parent) we diff against the empty tree by using

 // `git diff-tree -p -r --root`.

 func FromCommit(ctx context.Context, gitDir, sha string, opts Options) ([]byte, error) {

 		"diff-tree", "-p", "-r", "--root",

 		"--no-color", "--no-ext-diff",

 		"--full-index",

 // FromRange returns the two-dot diff base..head. Use for "show me

 // every change between these two refs", regardless of merge graph.

 func FromRange(ctx context.Context, gitDir, base, head string, opts Options) ([]byte, error) {

 		"diff", "--patch",

 		"--no-color", "--no-ext-diff",

 		"--full-index",

 // `git diff $(git merge-base base head)..head`. Used by PR / compare

 // pages — shows only what `head` adds over the common ancestor.

 func FromMergeBase(ctx context.Context, gitDir, base, head string, opts Options) ([]byte, error) {

 		"diff", "--patch",

 		"--no-color", "--no-ext-diff",

 		"--full-index",

 // Errors surfaced to handlers.

 var (

 )

 	const sep = "\x1f"

 	const recordEnd = "\x1e"

 	format := strings.Join([]string{"%H", "%h", "%an", "%ae", "%at", "%s"}, sep) + sep + "%b" + recordEnd

 		"log",

 		"--max-count="+strconv.Itoa(max),

 		"--format="+format,

 // arrive via `git log --format=...`; the per-file stats live on

 // CommitDetail.

 type Commit struct {

 	AuthorName  string

 	AuthorEmail string

 	AuthorWhen  time.Time

 	// don't confuse SplitN.

 	format := strings.Join([]string{"%H", "%h", "%an", "%ae", "%at", "%s"}, sep) + sep + "%b" + recordEnd

 		"--max-count=" + strconv.Itoa(o.MaxCount),

 		"--skip=" + strconv.Itoa(o.Skip),

 		"--format=" + format,

 // Status is git's letter code: A added, M modified, D deleted, R renamed,

 // C copied, T type-changed.

 type FileChange struct {

 }

 // GetCommit returns the full detail for one SHA. Two commands: one for

 		"%cn", "%ce", "%ct",

 		"%s",

 	}, sep) + sep + "%b" + recordEnd

 		"log", "--reverse",

 		"--max-count="+strconv.Itoa(max),

 		"--format="+format,

 // changes from merge-base to head). Status is git's letter code,

 // renames carry the old path as the second column.

 func FilesChangedBetween(ctx context.Context, gitDir, baseOID, headOID string) ([]PRFileChange, error) {

 		"diff", "--name-status", "-M", "-C",

 		baseOID+"..."+headOID,

 	)

 		}

 		return nil, wrapExecErr(err)

 	}

 		"diff", "--numstat", "-M", "-C",

 		baseOID+"..."+headOID,

 	)

 	// Identity for the merge commit. `--no-edit` + a baked subject

 	// keeps the merge non-interactive.

 		"GIT_AUTHOR_NAME="+opts.AuthorName,

 		"GIT_AUTHOR_EMAIL="+opts.AuthorEmail,

 		"GIT_COMMITTER_NAME="+opts.CommitterName,

 		"GIT_COMMITTER_EMAIL="+opts.CommitterEmail,

 	)

 	if !opts.When.IsZero() {

 			"GIT_AUTHOR_DATE="+opts.When.Format(time.RFC3339),

 			"GIT_COMMITTER_DATE="+opts.When.Format(time.RFC3339),

 		)

 	//nolint:gosec // G204: tree is git's stdout (40-char OID); gitDir validated.

 	cmd := exec.CommandContext(ctx, "git", "-C", ic.GitDir, "commit-tree", tree, "-m", ic.Message)

 	stamp := ic.When.Format(time.RFC3339)

 		"GIT_AUTHOR_NAME="+ic.AuthorName,

 		"GIT_AUTHOR_EMAIL="+ic.AuthorEmail,

 		"GIT_AUTHOR_DATE="+stamp,

 	}

 	return nil

 }

 // TransferRequestParams describes a new transfer offer.

 type TransferRequestParams struct {

 	ToPrincipalKind string // "user" — "org" arrives in S31

 }

 // RequestTransfer creates a pending transfer with a 7-day TTL. Returns

 	rq := reposdb.New()

 	row, err := rq.InsertTransferRequest(ctx, deps.Pool, reposdb.InsertTransferRequestParams{

 	})

 	if err != nil {

 		return 0, fmt.Errorf("insert transfer: %w", err)

 	// Update owner. We keep the same name; if it collides on the

 	// recipient, the unique index trips and the tx rolls back.

 	if err := rq.TransferRepoOwner(ctx, tx, reposdb.TransferRepoOwnerParams{

 	}); err != nil {

 		var pgErr *pgconn.PgError

 		if errAs(err, &pgErr) && pgErr.Code == "23505" {

 // the rule set. Allow=true means the push proceeds; Allow=false

 // surfaces the reason+rule pattern back to the user via stderr.

 type Decision struct {

 }

 // Update is one ref update from the pre-receive hook's stdin.

 	}

 	return fmt.Sprintf("shithub: %s (rule pattern %q).", d.Reason, d.Pattern)

 }

 // to take effect (a bare `repo:foo` without slash is treated as

 // free text).

 type ParsedQuery struct {

 	RepoFilter   *RepoFilter

 	StateFilter  string // "open" | "closed" | ""

 	AuthorFilter string // username or empty

 		{"", search.ParsedQuery{}},

 		{"hello world", search.ParsedQuery{Text: "hello world"}},

 		{`"quoted phrase"`, search.ParsedQuery{Phrase: "quoted phrase"}},

 		{"repo:noslash bug", search.ParsedQuery{Text: "repo:noslash bug"}},

 		{"is:open broken", search.ParsedQuery{Text: "broken", StateFilter: "open"}},

 		{"state:closed bug", search.ParsedQuery{Text: "bug", StateFilter: "closed"}},

 // Errors surfaced to handlers.

 var (

 	ErrInvalidWatchLevel = errors.New("social: watch level must be all, participating, or ignore")

 )

 func presentSuite(s checksdb.CheckSuite) map[string]any {

 	out := map[string]any{

 	}

 	if s.Conclusion.Valid {

 		out["conclusion"] = string(s.Conclusion.CheckConclusion)

 	}

 	return t.String

 }

 			epoch       int32

 			suspendedAt sql.NullTime

 		)

 			"SELECT username, session_epoch, suspended_at FROM users WHERE id = $1", id,

 		).Scan(&name, &epoch, &suspendedAt)

 		return middleware.UserLookupResult{

 		if v.Size == variants[0].Size {

 			key = largestKey

 		}

 			bytes.NewReader(v.Data),

 			storage.PutOpts{ContentType: "image/png", ContentLength: int64(len(v.Data))},

 		); err != nil {

 	// be treated as nonexistent. Uses the SAME pool the test server is

 	// reading from — a fresh dbtest.NewTestDB call would clone a brand

 	// new database.

 		"UPDATE users SET deleted_at = $1 WHERE username = 'dangb'",

 		time.Now().Add(-30*24*time.Hour),

 	); err != nil {

 			epoch       int32

 			suspendedAt sql.NullTime

 		)

 			"SELECT username, session_epoch, suspended_at FROM users WHERE id = $1", id,

 		).Scan(&name, &epoch, &suspendedAt)

 		return middleware.UserLookupResult{

 // Package orgs wires the S30 organization web surface:

 //

 //

 // Profile rendering for /{org} is dispatched from the existing

 // /{username} catch-all in internal/web/handlers/profile via the

 func (h *Handlers) userIDByUsername(r *http.Request, username string) (int64, bool) {

 	var id int64

 		`SELECT id FROM users WHERE username = $1 AND deleted_at IS NULL`,

 		username,

 	).Scan(&id)

 		return false

 	}

 	var member bool

 		`SELECT EXISTS(SELECT 1 FROM team_members WHERE team_id = $1 AND user_id = $2)`,

 		team.ID, viewer.ID,

 	).Scan(&member)

 			continue

 		}

 		var member bool

 			`SELECT EXISTS(SELECT 1 FROM team_members WHERE team_id = $1 AND user_id = $2)`,

 			t.ID, viewer.ID,

 		).Scan(&member)

 // errTeamNotFound is reserved for the future; surfaced via

 // orgs.ErrTeamNotFound when needed.

 	refs, _ := repogit.ListRefs(r.Context(), gitDir)

 	type tagRow struct {

 	}

 	rows := make([]tagRow, 0, len(refs.Tags))

 	for _, t := range refs.Tags {

 	refs, _ := repogit.ListRefs(r.Context(), gitDir)

 	h.d.Render.RenderPage(w, r, "repo/compare", map[string]any{

 		"CommitsErr": cerr != nil,

 	})

 }

 	"github.com/jackc/pgx/v5/pgtype"

 	"github.com/tenseleyFlow/shithub/internal/auth/policy"

 	"github.com/tenseleyFlow/shithub/internal/repos/finder"

 	repogit "github.com/tenseleyFlow/shithub/internal/repos/git"

 	"github.com/tenseleyFlow/shithub/internal/repos/highlight"

 	reposdb "github.com/tenseleyFlow/shithub/internal/repos/sqlc"

 	"github.com/tenseleyFlow/shithub/internal/web/middleware"

 )

 // derive once at the top. Owner+repo come from chi; ref+path come from

 // the wildcard, resolved against the repo's ref list.

 type codeContext struct {

 }

 // loadCodeContext does the resolve dance for tree/blob/raw/find. On

 	}

 	// Enqueue the on-disk clone. The fork row exists with

 	// init_status='init_pending' so the URL resolves immediately.

 		map[string]any{"source_repo_id": res.Source.ID, "fork_repo_id": res.Fork.ID},

 		worker.EnqueueOptions{},

 	); err != nil {

 		h.d.Render.HTTPError(w, r, http.StatusInternalServerError, "")

 	}

 }

 	// thread events to them. Non-destructive — no-op if the user

 	// already has an explicit preference.

 	_ = social.AutoWatchOnInvolvement(r.Context(), h.socialDeps(), viewer.ID, row.ID)

 		"/"+owner.Username+"/"+row.Name+"/issues/"+strconv.FormatInt(created.Number, 10),

 		http.StatusSeeOther,

 	)

 	"github.com/tenseleyFlow/shithub/internal/orgs"

 	"github.com/tenseleyFlow/shithub/internal/repos/lifecycle"

 	reposdb "github.com/tenseleyFlow/shithub/internal/repos/sqlc"

 	usersdb "github.com/tenseleyFlow/shithub/internal/users/sqlc"

 )

 // MountLifecycle registers the repo settings danger-zone routes plus

 		return reposdb.Repo{}, usersdb.User{}, false

 	}

 	var (

 	)

 	switch principal.Kind {

 	case orgs.PrincipalUser:

 	checksdb "github.com/tenseleyFlow/shithub/internal/checks/sqlc"

 	"github.com/tenseleyFlow/shithub/internal/issues"

 	issuesdb "github.com/tenseleyFlow/shithub/internal/issues/sqlc"

 	"github.com/tenseleyFlow/shithub/internal/pulls"

 	pullsdb "github.com/tenseleyFlow/shithub/internal/pulls/sqlc"

 	repogit "github.com/tenseleyFlow/shithub/internal/repos/git"

 	reposdb "github.com/tenseleyFlow/shithub/internal/repos/sqlc"

 	"github.com/tenseleyFlow/shithub/internal/social"

 	"github.com/tenseleyFlow/shithub/internal/web/middleware"

 		h.d.Logger.WarnContext(r.Context(), "pulls: enqueue mergeability", "error", err)

 	}

 	_ = worker.Notify(r.Context(), h.d.Pool)

 		"/"+owner.Username+"/"+row.Name+"/pulls/"+strconv.FormatInt(res.Issue.Number, 10),

 		http.StatusSeeOther,

 	)

 		threadsByFile[f.Path] = out

 	}

 	h.renderPullPage(w, r, "files", map[string]any{