replace log.Fatal/os.Exit with error returns (#941)

* Use stdlib encoders
* Reduce some duplication
* Remove global pagination state
* Dedupe JSON detail types
* Bump golangci-lint

Reviewed-on: https://gitea.com/gitea/tea/pulls/941
Co-authored-by: techknowlogick <techknowlogick@gitea.com>
Co-committed-by: techknowlogick <techknowlogick@gitea.com>

modules/context/context.go

@@ -6,9 +6,8 @@ package context
 import (
 	"errors"
 	"fmt"
-	"log"
 	"os"
-	"path"
+	"strings"
 
 	"code.gitea.io/tea/modules/config"
 	"code.gitea.io/tea/modules/git"
@@ -23,6 +22,9 @@ import (
 
 var errNotAGiteaRepo = errors.New("No Gitea login found. You might want to specify --repo (and --login) to work outside of a repository")
 
+// ErrCommandCanceled is returned when the user explicitly cancels an interactive prompt.
+var ErrCommandCanceled = errors.New("command canceled")
+
 // TeaContext contains all context derived during command initialization and wraps cli.Context
 type TeaContext struct {
 	*cli.Command
@@ -38,9 +40,11 @@ type TeaContext struct {
 
 // GetRemoteRepoHTMLURL returns the web-ui url of the remote repo,
 // after ensuring a remote repo is present in the context.
-func (ctx *TeaContext) GetRemoteRepoHTMLURL() string {
-	ctx.Ensure(CtxRequirement{RemoteRepo: true})
-	return path.Join(ctx.Login.URL, ctx.Owner, ctx.Repo)
+func (ctx *TeaContext) GetRemoteRepoHTMLURL() (string, error) {
+	if err := ctx.Ensure(CtxRequirement{RemoteRepo: true}); err != nil {
+		return "", err
+	}
+	return strings.TrimRight(ctx.Login.URL, "/") + "/" + ctx.Owner + "/" + ctx.Repo, nil
 }
 
 // IsInteractiveMode returns true if the command is running in interactive mode
@@ -57,7 +61,7 @@ func shouldPromptFallbackLogin(login *config.Login, canPrompt bool) bool {
 // available the repo slug. It does this by reading the config file for logins, parsing
 // the remotes of the .git repo specified in repoFlag or $PWD, and using overrides from
 // command flags. If a local git repo can't be found, repo slug values are unset.
-func InitCommand(cmd *cli.Command) *TeaContext {
+func InitCommand(cmd *cli.Command) (*TeaContext, error) {
 	// these flags are used as overrides to the context detection via local git repo
 	repoFlag := cmd.String("repo")
 	loginFlag := cmd.String("login")
@@ -75,7 +79,7 @@ func InitCommand(cmd *cli.Command) *TeaContext {
 	// check if repoFlag can be interpreted as path to local repo.
 	if len(repoFlag) != 0 {
 		if repoFlagPathExists, err = utils.DirExists(repoFlag); err != nil {
-			log.Fatal(err.Error())
+			return nil, err
 		}
 		if repoFlagPathExists {
 			repoPath = repoFlag
@@ -88,7 +92,7 @@ func InitCommand(cmd *cli.Command) *TeaContext {
 
 	if repoPath == "" {
 		if repoPath, err = os.Getwd(); err != nil {
-			log.Fatal(err.Error())
+			return nil, err
 		}
 	}
 
@@ -97,7 +101,7 @@ func InitCommand(cmd *cli.Command) *TeaContext {
 	envLogin := GetLoginByEnvVar()
 	if envLogin != nil {
 		if _, err := utils.ValidateAuthenticationMethod(envLogin.URL, envLogin.Token, "", "", false, "", ""); err != nil {
-			log.Fatal(err.Error())
+			return nil, err
 		}
 		extraLogins = append(extraLogins, *envLogin)
 	}
@@ -108,7 +112,7 @@ func InitCommand(cmd *cli.Command) *TeaContext {
 		if err == errNotAGiteaRepo || err == gogit.ErrRepositoryNotExists {
 			// we can deal with that, commands needing the optional values use ctx.Ensure()
 		} else {
-			log.Fatal(err.Error())
+			return nil, err
 		}
 	}
 
@@ -125,20 +129,20 @@ func InitCommand(cmd *cli.Command) *TeaContext {
 
 	// override login from flag, or use default login if repo based detection failed
 	if len(loginFlag) != 0 {
-		c.Login = config.GetLoginByName(loginFlag)
+		if c.Login, err = config.GetLoginByName(loginFlag); err != nil {
+			return nil, err
+		}
 		if c.Login == nil {
-			log.Fatalf("Login name '%s' does not exist", loginFlag)
+			return nil, fmt.Errorf("login name '%s' does not exist", loginFlag)
 		}
 	} else if c.Login == nil {
 		if c.Login, err = config.GetDefaultLogin(); err != nil {
 			if err.Error() == "No available login" {
-				// TODO: maybe we can directly start interact.CreateLogin() (only if
-				// we're sure we can interactively!), as gh cli does.
-				fmt.Println(`No gitea login configured. To start using tea, first run
+				return nil, fmt.Errorf(`no gitea login configured. To start using tea, first run
   tea login add
-and then run your command again.`)
+and then run your command again`)
 			}
-			os.Exit(1)
+			return nil, err
 		}
 
 		// Only prompt for confirmation if the fallback login is not explicitly set as default
@@ -150,10 +154,10 @@ and then run your command again.`)
 				Value(&fallback).
 				WithTheme(theme.GetTheme()).
 				Run(); err != nil {
-				log.Fatalf("Get confirm failed: %v", err)
+				return nil, fmt.Errorf("get confirm failed: %w", err)
 			}
 			if !fallback {
-				os.Exit(1)
+				return nil, ErrCommandCanceled
 			}
 		} else if !c.Login.Default {
 			fmt.Fprintf(os.Stderr, "NOTE: no gitea login detected, falling back to login '%s' in non-interactive mode.\n", c.Login.Name)
@@ -166,5 +170,5 @@ and then run your command again.`)
 	c.IsGlobal = globalFlag
 	c.Command = cmd
 	c.Output = cmd.String("output")
-	return &c
+	return &c, nil
 }

modules/context/context_require.go

@@ -4,31 +4,28 @@
 package context
 
 import (
-	"fmt"
-	"os"
+	"errors"
 )
 
-// Ensure checks if requirements on the context are set, and terminates otherwise.
-func (ctx *TeaContext) Ensure(req CtxRequirement) {
+// Ensure checks if requirements on the context are set.
+func (ctx *TeaContext) Ensure(req CtxRequirement) error {
 	if req.LocalRepo && ctx.LocalRepo == nil {
-		fmt.Println("Local repository required: Execute from a repo dir, or specify a path with --repo.")
-		os.Exit(1)
+		return errors.New("local repository required: execute from a repo dir, or specify a path with --repo")
 	}
 
 	if req.RemoteRepo && len(ctx.RepoSlug) == 0 {
-		fmt.Println("Remote repository required: Specify ID via --repo or execute from a local git repo.")
-		os.Exit(1)
+		return errors.New("remote repository required: specify id via --repo or execute from a local git repo")
 	}
 
 	if req.Org && len(ctx.Org) == 0 {
-		fmt.Println("Organization required: Specify organization via --org.")
-		os.Exit(1)
+		return errors.New("organization required: specify organization via --org")
 	}
 
 	if req.Global && !ctx.IsGlobal {
-		fmt.Println("Global scope required: Specify --global.")
-		os.Exit(1)
+		return errors.New("global scope required: specify --global")
 	}
+
+	return nil
 }
 
 // CtxRequirement specifies context needed for operation

modules/context/context_require_test.go

@@ -0,0 +1,113 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package context
+
+import (
+	"testing"
+
+	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/git"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEnsureReturnsRequirementErrors(t *testing.T) {
+	tests := []struct {
+		name    string
+		ctx     TeaContext
+		req     CtxRequirement
+		wantErr string
+	}{
+		{
+			name:    "missing local repo",
+			ctx:     TeaContext{},
+			req:     CtxRequirement{LocalRepo: true},
+			wantErr: "local repository required",
+		},
+		{
+			name:    "missing remote repo",
+			ctx:     TeaContext{},
+			req:     CtxRequirement{RemoteRepo: true},
+			wantErr: "remote repository required",
+		},
+		{
+			name:    "missing org",
+			ctx:     TeaContext{},
+			req:     CtxRequirement{Org: true},
+			wantErr: "organization required",
+		},
+		{
+			name:    "missing global scope",
+			ctx:     TeaContext{},
+			req:     CtxRequirement{Global: true},
+			wantErr: "global scope required",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.ctx.Ensure(tt.req)
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), tt.wantErr)
+		})
+	}
+}
+
+func TestEnsureSucceedsWhenRequirementsMet(t *testing.T) {
+	ctx := TeaContext{
+		LocalRepo: &git.TeaRepo{},
+		RepoSlug:  "owner/repo",
+		Owner:     "owner",
+		Repo:      "repo",
+		Org:       "myorg",
+		IsGlobal:  true,
+	}
+	err := ctx.Ensure(CtxRequirement{
+		LocalRepo:  true,
+		RemoteRepo: true,
+		Org:        true,
+		Global:     true,
+	})
+	require.NoError(t, err)
+}
+
+func TestEnsureSucceedsWithNoRequirements(t *testing.T) {
+	ctx := TeaContext{}
+	err := ctx.Ensure(CtxRequirement{})
+	require.NoError(t, err)
+}
+
+func TestGetRemoteRepoHTMLURL(t *testing.T) {
+	t.Run("requires remote repo", func(t *testing.T) {
+		ctx := &TeaContext{}
+		_, err := ctx.GetRemoteRepoHTMLURL()
+		require.ErrorContains(t, err, "remote repository required")
+	})
+
+	t.Run("returns repo url when context is complete", func(t *testing.T) {
+		ctx := &TeaContext{
+			Login:    &config.Login{URL: "https://gitea.example.com"},
+			RepoSlug: "owner/repo",
+			Owner:    "owner",
+			Repo:     "repo",
+		}
+
+		url, err := ctx.GetRemoteRepoHTMLURL()
+		require.NoError(t, err)
+		assert.Equal(t, "https://gitea.example.com/owner/repo", url)
+	})
+
+	t.Run("trims trailing slash from login URL", func(t *testing.T) {
+		ctx := &TeaContext{
+			Login:    &config.Login{URL: "https://gitea.example.com/"},
+			RepoSlug: "owner/repo",
+			Owner:    "owner",
+			Repo:     "repo",
+		}
+
+		url, err := ctx.GetRemoteRepoHTMLURL()
+		require.NoError(t, err)
+		assert.Equal(t, "https://gitea.example.com/owner/repo", url)
+	})
+}