package main

import (

"net/http"

)

var names []string

rows, err := database.Query(r.Context(), "SELECT r.name FROM repos r JOIN groups g ON r.group_id = g.id WHERE g.name = $1;", group_name)

if err != nil {

return

}

defer rows.Close()

for rows.Next() {

var name string

if err := rows.Scan(&name); err != nil {

return

}

names = append(names, name)

}

if err := rows.Err(); err != nil {

return

}

err = templates.ExecuteTemplate(w, "group_repos", params)

if err != nil {

return

}

}

package main

import (

"net/http"

)

func handle_index(w http.ResponseWriter, r *http.Request, params map[string]any) {

rows, err := database.Query(r.Context(), "SELECT name FROM groups")

if err != nil {

return

}

defer rows.Close()

for rows.Next() {

var groupName string

if err := rows.Scan(&groupName); err != nil {

return

}

groups = append(groups, groupName)

}

if err := rows.Err(); err != nil {

return

}

err = templates.ExecuteTemplate(w, "index", params)

if err != nil {

return

}

}

package main

import (

"net/http"

)

if r.Method != "POST" {

err := templates.ExecuteTemplate(w, "login", params)

if err != nil {

return

}

}

package main

import (

"net/http"

"strings"

group_name, repo_name, commit_id_specified_string := params["group_name"].(string), params["repo_name"].(string), params["commit_id"].(string)

repo, err := open_git_repo(r.Context(), group_name, repo_name)

if err != nil {

return

}

commit_id_specified_string_without_suffix := strings.TrimSuffix(commit_id_specified_string, ".patch")

commit_id := plumbing.NewHash(commit_id_specified_string_without_suffix)

commit_object, err := repo.CommitObject(commit_id)

if err != nil {

return

}

if commit_id_specified_string_without_suffix != commit_id_specified_string {

patch, err := format_patch_from_commit(commit_object)

if err != nil {

return

}

return

}

commit_id_string := commit_object.Hash.String()

parent_commit_hash, patch, err := get_patch_from_commit(commit_object)

if err != nil {

return

}

params["parent_commit_hash"] = parent_commit_hash.String()

params["patch"] = patch

// TODO: Prepend "+"/"-"/" " instead of solely distinguishing based on color

usable_file_patches := make([]usable_file_patch, 0)

for _, file_patch := range patch.FilePatches() {

err = templates.ExecuteTemplate(w, "repo_commit", params)

if err != nil {

return

}

}

package main

import (

"net/http"

"net/url"

)

group_name, repo_name := params["group_name"].(string), params["repo_name"].(string)

repo, err := open_git_repo(r.Context(), group_name, repo_name)

if err != nil {

return

}

head, err := repo.Head()

if err != nil {

return

}

params["ref"] = head.Name().Short()

head_hash := head.Hash()

recent_commits, err := get_recent_commits(repo, head_hash, 3)

if err != nil {

return

}

params["commits"] = recent_commits

commit_object, err := repo.CommitObject(head_hash)

if err != nil {

return

}

tree, err := commit_object.Tree()

if err != nil {

return

}

err = templates.ExecuteTemplate(w, "repo_index", params)

if err != nil {

return

}

}

package main

import (

"net/http"

"github.com/go-git/go-git/v5/plumbing"

group_name, repo_name, ref_name := params["group_name"].(string), params["repo_name"].(string), params["ref"].(string)

repo, err := open_git_repo(r.Context(), group_name, repo_name)

if err != nil {

return

}

ref, err := repo.Reference(plumbing.NewBranchReferenceName(ref_name), true)

if err != nil {

return

}

ref_hash := ref.Hash()

commits, err := get_recent_commits(repo, ref_hash, -1)

if err != nil {

return

}

params["commits"] = commits

err = templates.ExecuteTemplate(w, "repo_log", params)

if err != nil {

return

}

}

package main

import (

"errors"

"net/http"

"path"

if errors.Is(err, err_no_ref_spec) {

ref_type = "head"

} else {

return

}

}

repo, err := open_git_repo(r.Context(), group_name, repo_name)

if err != nil {

return

}

ref_hash, err := get_ref_hash_from_type_and_name(repo, ref_type, ref_name)

if err != nil {

return

}

commit_object, err := repo.CommitObject(ref_hash)

if err != nil {

return

}

tree, err := commit_object.Tree()

if err != nil {

return

}

if err != nil {

file, err := tree.File(path_spec)

if err != nil {

return

}

if len(raw_path_spec) != 0 && raw_path_spec[len(raw_path_spec)-1] == '/' {

}

file_contents, err := file.Contents()

if err != nil {

return

}

return

}

}

err = templates.ExecuteTemplate(w, "repo_raw_dir", params)

if err != nil {

return

}

}

import (

"bytes"

"errors"

"html/template"

"net/http"

"path"

if errors.Is(err, err_no_ref_spec) {

ref_type = "head"

} else {

return

}

}

params["ref_type"], params["ref"], params["path_spec"] = ref_type, ref_name, path_spec

repo, err := open_git_repo(r.Context(), group_name, repo_name)

if err != nil {

return

}

ref_hash, err := get_ref_hash_from_type_and_name(repo, ref_type, ref_name)

if err != nil {

return

}

commit_object, err := repo.CommitObject(ref_hash)

if err != nil {

return

}

tree, err := commit_object.Tree()

if err != nil {

return

}

if err != nil {

file, err := tree.File(path_spec)

if err != nil {

return

}

if len(raw_path_spec) != 0 && raw_path_spec[len(raw_path_spec)-1] == '/' {

}

file_contents, err := file.Contents()

if err != nil {

return

}

lexer := chroma_lexers.Match(path_spec)

}

iterator, err := lexer.Tokenise(nil, file_contents)

if err != nil {

return

}

var formatted_unencapsulated bytes.Buffer

formatter := chroma_formatters_html.New(chroma_formatters_html.WithClasses(true), chroma_formatters_html.TabWidth(8))

err = formatter.Format(&formatted_unencapsulated, style, iterator)

if err != nil {

return

}

formatted_encapsulated := template.HTML(formatted_unencapsulated.Bytes())

err = templates.ExecuteTemplate(w, "repo_tree_file", params)

if err != nil {

return

}

return

err = templates.ExecuteTemplate(w, "repo_tree_dir", params)

if err != nil {

return

}

}