*: Replacing more := with var

10 files changed, 75 insertions, 70 deletions

diff --git a/http_render_readme.go b/http_render_readme.go
index 0cd80fa..a4cef0d 100644
--- a/http_render_readme.go
+++ b/http_render_readme.go
@@ -20,39 +20,40 @@ var markdown_converter = goldmark.New(goldmark.WithExtensions(extension.GFM))
 
 func render_readme_at_tree(tree *object.Tree) (readme_filename string, readme_content template.HTML) {
 	var readme_rendered_unsafe bytes.Buffer
+	var readme_file *object.File
+	var readme_file_contents string
+	var err error
 
-	readme_file, err := tree.File("README")
-	if err == nil {
-		readme_file_contents, err := readme_file.Contents()
-		if err != nil {
+	if readme_file, err = tree.File("README"); err != nil {
+		if readme_file_contents, err = readme_file.Contents(); err != nil {
 			return "Error fetching README", string_escape_html("Unable to fetch contents of README: " + err.Error())
 		}
+
 		return "README", template.HTML("<pre>" + html.EscapeString(readme_file_contents) + "</pre>")
 	}
 
-	readme_file, err = tree.File("README.md")
-	if err == nil {
-		readme_file_contents, err := readme_file.Contents()
-		if err != nil {
+	if readme_file, err = tree.File("README.md"); err != nil {
+		if readme_file_contents, err = readme_file.Contents(); err != nil {
 			return "Error fetching README", string_escape_html("Unable to fetch contents of README: " + err.Error())
 		}
-		err = markdown_converter.Convert([]byte(readme_file_contents), &readme_rendered_unsafe)
-		if err != nil {
+
+		if err = markdown_converter.Convert([]byte(readme_file_contents), &readme_rendered_unsafe); err != nil {
 			return "Error fetching README", string_escape_html("Unable to render README: " + err.Error())
 		}
+
 		return "README.md", template.HTML(bluemonday.UGCPolicy().SanitizeBytes(readme_rendered_unsafe.Bytes()))
 	}
 
-	readme_file, err = tree.File("README.org")
-	if err == nil {
-		readme_file_contents, err := readme_file.Contents()
-		if err != nil {
+	if readme_file, err = tree.File("README.org"); err != nil {
+		if readme_file_contents, err = readme_file.Contents(); err != nil {
 			return "Error fetching README", string_escape_html("Unable to fetch contents of README: " + err.Error())
 		}
+
 		org_html, err := org.New().Parse(strings.NewReader(readme_file_contents), readme_filename).Write(org.NewHTMLWriter())
 		if err != nil {
 			return "Error fetching README", string_escape_html("Unable to render README: " + err.Error())
 		}
+
 		return "README.org", template.HTML(bluemonday.UGCPolicy().Sanitize(org_html))
 	}
 
diff --git a/http_server.go b/http_server.go
index 1d91874..849afd9 100644
--- a/http_server.go
+++ b/http_server.go
@@ -19,12 +19,17 @@ type http_router_t struct{}
 func (router *http_router_t) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	clog.Info("Incoming HTTP: " + r.RemoteAddr + " " + r.Method + " " + r.RequestURI)
 
-	segments, _, err := parse_request_uri(r.RequestURI)
-	if err != nil {
+	var segments []string
+	var err error
+	var non_empty_last_segments_len int
+	var params map[string]any
+	var separator_index int
+
+	if segments, _, err = parse_request_uri(r.RequestURI); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	non_empty_last_segments_len := len(segments)
+	non_empty_last_segments_len = len(segments)
 	if segments[len(segments)-1] == "" {
 		non_empty_last_segments_len--
 	}
@@ -47,7 +52,6 @@ func (router *http_router_t) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	params := make(map[string]any)
 	params["url_segments"] = segments
 	params["global"] = global_data
 	var _user_id int // 0 for none
@@ -79,7 +83,7 @@ func (router *http_router_t) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	separator_index := -1
+	separator_index = -1
 	for i, part := range segments {
 		if part == ":" {
 			separator_index = i
@@ -95,6 +99,10 @@ func (router *http_router_t) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	var module_type string
+	var module_name string
+	var group_name string
+
 	switch {
 	case non_empty_last_segments_len == 0:
 		handle_index(w, r, params)
@@ -106,7 +114,7 @@ func (router *http_router_t) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		if redirect_with_slash(w, r) {
 			return
 		}
-		module_type := segments[separator_index+1]
+		module_type = segments[separator_index+1]
 		params["group_name"] = segments[0]
 		switch module_type {
 		case "repos":
@@ -115,9 +123,9 @@ func (router *http_router_t) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, fmt.Sprintf("Unknown module type: %s", module_type), http.StatusNotFound)
 		}
 	default:
-		module_type := segments[separator_index+1]
-		module_name := segments[separator_index+2]
-		group_name := segments[0]
+		module_type = segments[separator_index+1]
+		module_name = segments[separator_index+2]
+		group_name = segments[0]
 		params["group_name"] = group_name
 		switch module_type {
 		case "repos":
@@ -126,22 +134,19 @@ func (router *http_router_t) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			if non_empty_last_segments_len > separator_index+3 {
 				switch segments[separator_index+3] {
 				case "info":
-					err = handle_repo_info(w, r, params)
-					if err != nil {
+					if err = handle_repo_info(w, r, params); err != nil {
 						http.Error(w, err.Error(), http.StatusInternalServerError)
 					}
 					return
 				case "git-upload-pack":
-					err = handle_upload_pack(w, r, params)
-					if err != nil {
+					if err = handle_upload_pack(w, r, params); err != nil {
 						http.Error(w, err.Error(), http.StatusInternalServerError)
 					}
 					return
 				}
 			}
 
-			params["ref_type"], params["ref_name"], err = get_param_ref_and_type(r)
-			if err != nil {
+			if params["ref_type"], params["ref_name"], err = get_param_ref_and_type(r); err != nil {
 				if errors.Is(err, err_no_ref_spec) {
 					params["ref_type"] = ""
 				} else {
@@ -152,8 +157,7 @@ func (router *http_router_t) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 			// TODO: subgroups
 
-			params["repo"], params["repo_description"], params["repo_id"], err = open_git_repo(r.Context(), group_name, module_name)
-			if err != nil {
+			if params["repo"], params["repo_description"], params["repo_id"], err = open_git_repo(r.Context(), group_name, module_name); err != nil {
 				http.Error(w, "Error opening repo: "+err.Error(), http.StatusInternalServerError)
 				return
 			}
diff --git a/http_template.go b/http_template.go
index be175f1..377ad4c 100644
--- a/http_template.go
+++ b/http_template.go
@@ -8,8 +8,7 @@ import "net/http"
 // render_template abstracts out the annoyances of reporting template rendering
 // errors.
 func render_template(w http.ResponseWriter, template_name string, params map[string]any) {
-	err := templates.ExecuteTemplate(w, template_name, params)
-	if err != nil {
+	if err := templates.ExecuteTemplate(w, template_name, params); err != nil {
 		http.Error(w, "Error rendering template: "+err.Error(), http.StatusInternalServerError)
 	}
 }
diff --git a/main.go b/main.go
index 0750303..cba6e1b 100644
--- a/main.go
+++ b/main.go
@@ -37,11 +37,10 @@ func main() {
 	hooks_listener, err = net.Listen("unix", config.Hooks.Socket)
 	if errors.Is(err, syscall.EADDRINUSE) {
 		clog.Warn("Removing stale socket " + config.Hooks.Socket)
-		if err := syscall.Unlink(config.Hooks.Socket); err != nil {
+		if err = syscall.Unlink(config.Hooks.Socket); err != nil {
 			clog.Fatal(1, "Removing stale socket: "+err.Error())
 		}
-		hooks_listener, err = net.Listen("unix", config.Hooks.Socket)
-		if err != nil {
+		if hooks_listener, err = net.Listen("unix", config.Hooks.Socket); err != nil {
 			clog.Fatal(1, "Listening hooks: "+err.Error())
 		}
 	} else if err != nil {
@@ -49,7 +48,7 @@ func main() {
 	}
 	clog.Info("Listening hooks on unix " + config.Hooks.Socket)
 	go func() {
-		if err := serve_git_hooks(hooks_listener); err != nil {
+		if err = serve_git_hooks(hooks_listener); err != nil {
 			clog.Fatal(1, "Serving hooks: "+err.Error())
 		}
 	}()
@@ -58,11 +57,10 @@ func main() {
 	ssh_listener, err := net.Listen(config.SSH.Net, config.SSH.Addr)
 	if errors.Is(err, syscall.EADDRINUSE) && config.SSH.Net == "unix" {
 		clog.Warn("Removing stale socket " + config.SSH.Addr)
-		if err := syscall.Unlink(config.SSH.Addr); err != nil {
+		if err = syscall.Unlink(config.SSH.Addr); err != nil {
 			clog.Fatal(1, "Removing stale socket: "+err.Error())
 		}
-		ssh_listener, err = net.Listen(config.SSH.Net, config.SSH.Addr)
-		if err != nil {
+		if ssh_listener, err = net.Listen(config.SSH.Net, config.SSH.Addr); err != nil {
 			clog.Fatal(1, "Listening SSH: "+err.Error())
 		}
 	} else if err != nil {
@@ -70,7 +68,7 @@ func main() {
 	}
 	clog.Info("Listening SSH on " + config.SSH.Net + " " + config.SSH.Addr)
 	go func() {
-		if err := serve_ssh(ssh_listener); err != nil {
+		if err = serve_ssh(ssh_listener); err != nil {
 			clog.Fatal(1, "Serving SSH: "+err.Error())
 		}
 	}()
@@ -79,11 +77,10 @@ func main() {
 	http_listener, err := net.Listen(config.HTTP.Net, config.HTTP.Addr)
 	if errors.Is(err, syscall.EADDRINUSE) && config.HTTP.Net == "unix" {
 		clog.Warn("Removing stale socket " + config.HTTP.Addr)
-		if err := syscall.Unlink(config.HTTP.Addr); err != nil {
+		if err = syscall.Unlink(config.HTTP.Addr); err != nil {
 			clog.Fatal(1, "Removing stale socket: "+err.Error())
 		}
-		http_listener, err = net.Listen(config.HTTP.Net, config.HTTP.Addr)
-		if err != nil {
+		if http_listener, err = net.Listen(config.HTTP.Net, config.HTTP.Addr); err != nil {
 			clog.Fatal(1, "Listening HTTP: "+err.Error())
 		}
 	} else if err != nil {
@@ -91,7 +88,7 @@ func main() {
 	}
 	clog.Info("Listening HTTP on " + config.HTTP.Net + " " + config.HTTP.Addr)
 	go func() {
-		if err := http.Serve(http_listener, &http_router_t{}); err != nil {
+		if err = http.Serve(http_listener, &http_router_t{}); err != nil {
 			clog.Fatal(1, "Serving HTTP: "+err.Error())
 		}
 	}()
diff --git a/resources.go b/resources.go
index 6c3cece..a65e8b7 100644
--- a/resources.go
+++ b/resources.go
@@ -44,8 +44,7 @@ func load_templates() (err error) {
 var static_handler http.Handler
 
 func init() {
-	static_fs, err := fs.Sub(resources_fs, "static")
-	if err != nil {
+	if static_fs, err := fs.Sub(resources_fs, "static"); err != nil {
 		panic(err)
 	}
 	static_handler = http.StripPrefix("/:/static/", http.FileServer(http.FS(static_fs)))
diff --git a/ssh_handle_receive_pack.go b/ssh_handle_receive_pack.go
index 27a60f7..4816c61 100644
--- a/ssh_handle_receive_pack.go
+++ b/ssh_handle_receive_pack.go
@@ -112,8 +112,7 @@ func ssh_handle_receive_pack(session glider_ssh.Session, pubkey string, repo_ide
 	proc.Stdout = session
 	proc.Stderr = session.Stderr()
 
-	err = proc.Start()
-	if err != nil {
+	if err = proc.Start(); err != nil {
 		fmt.Fprintln(session.Stderr(), "Error while starting process:", err)
 		return err
 	}
diff --git a/ssh_handle_upload_pack.go b/ssh_handle_upload_pack.go
index 3332631..fbbdfda 100644
--- a/ssh_handle_upload_pack.go
+++ b/ssh_handle_upload_pack.go
@@ -14,8 +14,8 @@ import (
 // ssh_handle_upload_pack handles clones/fetches. It just uses git-upload-pack
 // and has no ACL checks.
 func ssh_handle_upload_pack(session glider_ssh.Session, pubkey string, repo_identifier string) (err error) {
-	_, _, _, repo_path, _, _, _, _, err := get_repo_path_perms_from_ssh_path_pubkey(session.Context(), repo_identifier, pubkey)
-	if err != nil {
+	var repo_path string
+	if _, _, _, repo_path, _, _, _, _, err = get_repo_path_perms_from_ssh_path_pubkey(session.Context(), repo_identifier, pubkey); err != nil {
 		return err
 	}
 
@@ -25,8 +25,7 @@ func ssh_handle_upload_pack(session glider_ssh.Session, pubkey string, repo_iden
 	proc.Stdout = session
 	proc.Stderr = session.Stderr()
 
-	err = proc.Start()
-	if err != nil {
+	if err = proc.Start(); err != nil {
 		fmt.Fprintln(session.Stderr(), "Error while starting process:", err)
 		return err
 	}
diff --git a/ssh_server.go b/ssh_server.go
index 59df15a..66470d9 100644
--- a/ssh_server.go
+++ b/ssh_server.go
@@ -22,13 +22,16 @@ var (
 )
 
 func serve_ssh(listener net.Listener) error {
-	host_key_bytes, err := os.ReadFile(config.SSH.Key)
-	if err != nil {
+	var host_key_bytes []byte
+	var host_key go_ssh.Signer
+	var err error
+	var server *glider_ssh.Server
+
+	if host_key_bytes, err = os.ReadFile(config.SSH.Key); err != nil {
 		return err
 	}
 
-	host_key, err := go_ssh.ParsePrivateKey(host_key_bytes)
-	if err != nil {
+	if host_key, err = go_ssh.ParsePrivateKey(host_key_bytes); err != nil {
 		return err
 	}
 
@@ -36,7 +39,7 @@ func serve_ssh(listener net.Listener) error {
 	server_public_key_string = string(go_ssh.MarshalAuthorizedKey(server_public_key))
 	server_public_key_fingerprint = string(go_ssh.FingerprintSHA256(server_public_key))
 
-	server := &glider_ssh.Server{
+	server = &glider_ssh.Server{
 		Handler: func(session glider_ssh.Session) {
 			client_public_key := session.PublicKey()
 			var client_public_key_string string
@@ -86,8 +89,7 @@ func serve_ssh(listener net.Listener) error {
 
 	server.AddHostKey(host_key)
 
-	err = server.Serve(listener)
-	if err != nil {
+	if err = server.Serve(listener); err != nil {
 		clog.Fatal(1, "Serving SSH: "+err.Error())
 	}
 
diff --git a/ssh_utils.go b/ssh_utils.go
index b3f048c..0ec2065 100644
--- a/ssh_utils.go
+++ b/ssh_utils.go
@@ -17,7 +17,11 @@ import (
 var err_ssh_illegal_endpoint = errors.New("illegal endpoint during SSH access")
 
 func get_repo_path_perms_from_ssh_path_pubkey(ctx context.Context, ssh_path string, ssh_pubkey string) (group_name string, repo_name string, repo_id int, repo_path string, direct_access bool, contrib_requirements string, user_type string, user_id int, err error) {
-	segments := strings.Split(strings.TrimPrefix(ssh_path, "/"), "/")
+	var segments []string
+	var separator_index int
+	var module_type, module_name string
+
+	segments = strings.Split(strings.TrimPrefix(ssh_path, "/"), "/")
 
 	for i, segment := range segments {
 		var err error
@@ -31,7 +35,7 @@ func get_repo_path_perms_from_ssh_path_pubkey(ctx context.Context, ssh_path stri
 		return "", "", 0, "", false, "", "", 0, err_ssh_illegal_endpoint
 	}
 
-	separator_index := -1
+	separator_index = -1
 	for i, part := range segments {
 		if part == ":" {
 			separator_index = i
@@ -50,8 +54,8 @@ func get_repo_path_perms_from_ssh_path_pubkey(ctx context.Context, ssh_path stri
 	}
 
 	group_name = segments[0]
-	module_type := segments[separator_index+1]
-	module_name := segments[separator_index+2]
+	module_type = segments[separator_index+1]
+	module_name = segments[separator_index+2]
 	repo_name = module_name
 	switch module_type {
 	case "repos":
diff --git a/users.go b/users.go
index 884fac1..740f94f 100644
--- a/users.go
+++ b/users.go
@@ -5,22 +5,23 @@ package main
 
 import (
 	"context"
+
+	"github.com/jackc/pgx/v5"
 )
 
 func add_user_ssh(ctx context.Context, pubkey string) (user_id int, err error) {
-	tx, err := database.Begin(ctx)
-	if err != nil {
+	var tx pgx.Tx
+
+	if tx, err = database.Begin(ctx); err != nil {
 		return
 	}
 	defer tx.Rollback(ctx)
 
-	err = tx.QueryRow(ctx, `INSERT INTO users (type) VALUES ('pubkey_only') RETURNING id`).Scan(&user_id)
-	if err != nil {
+	if err = tx.QueryRow(ctx, `INSERT INTO users (type) VALUES ('pubkey_only') RETURNING id`).Scan(&user_id); err != nil {
 		return
 	}
 
-	_, err = tx.Exec(ctx, `INSERT INTO ssh_public_keys (key_string, user_id) VALUES ($1, $2)`, pubkey, user_id)
-	if err != nil {
+	if _, err = tx.Exec(ctx, `INSERT INTO ssh_public_keys (key_string, user_id) VALUES ($1, $2)`, pubkey, user_id); err != nil {
 		return
 	}