/routes/routes.go at 8e0d9c4694b25533d3091535c75a210caf8ed645

package routes

import (
	"compress/gzip"
	"fmt"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"sort"
	"strings"
)

func (d *deps) serveIndex(w http.ResponseWriter, r *http.Request) {
	dirs, err := os.ReadDir(d.c.Repo.ScanPath)
	if err != nil {
		d.write500(w)
		log.Printf("reading scan path: %s", err)
		return
	}

	summaries := []repositorySummary{}

	for _, dir := range dirs {
		if !dir.IsDir() {
			continue
		}

		gr, name, err := d.openRepository(dir.Name(), "")
		if err != nil {
			d.write404(w)
			return
		}

		if d.isIgnored(name) || d.isUnlisted(name) {
			continue
		}

		c, err := gr.LastCommit()
		if err != nil {
			d.write500(w)
			log.Println(err)
			return
		}

		summaries = append(summaries, repositorySummary{
			DisplayName: getDisplayName(name),
			DirName:     name,
			Description: gr.GitwebDescription(),
			LastCommit:  c,
		})
	}

	sort.Slice(summaries, func(i, j int) bool {
		return summaries[j].LastCommit.Committer.When.Before(summaries[i].LastCommit.Committer.When)
	})

	data := repoListData{
		Config:       d.c,
		Repositories: summaries,
	}

	if err := d.template().ExecuteTemplate(w, "repo-list", data); err != nil {
		log.Println(err)
		return
	}
}

func (d *deps) serveRepoTree(w http.ResponseWriter, r *http.Request) {
	ref := r.PathValue("ref")
	gr, name, err := d.openRepository(r.PathValue("name"), ref)
	if err != nil {
		d.write404(w)
		return
	}
	treePath := r.PathValue("rest")

	files, err := gr.FileTree(treePath)
	if err != nil {
		d.write500(w)
		log.Println(err)
		return
	}

	relpath := []string{}
	if len(treePath) > 0 {
		relpath = strings.Split(treePath, "/")
	}

	data := repoTreeRefData{
		Config: d.c,
		Meta: repositoryMeta{
			DisplayName: getDisplayName(name),
			DirName:     name,
			Description: gr.GitwebDescription(),
			Ref:         ref,
		},
		Path:  relpath,
		Files: files,
	}

	if err := d.template().ExecuteTemplate(w, "repo-tree-ref", data); err != nil {
		log.Println(err)
		return
	}
}

func (d *deps) serveArchive(w http.ResponseWriter, r *http.Request) {
	name := r.PathValue("name")
	file := r.PathValue("file")

	// TODO: extend this to add more files compression (e.g.: xz)
	if !strings.HasSuffix(file, ".tar.gz") {
		d.write404(w)
		return
	}

	ref := strings.TrimSuffix(file, ".tar.gz")

	// This allows the browser to use a proper name for the file when
	// downloading
	filename := fmt.Sprintf("%s-%s.tar.gz", name, ref)
	setContentDisposition(w, filename)
	setGZipMIME(w)

	gr, name, err := d.openRepository(name, ref)
	if err != nil {
		d.write404(w)
		return
	}

	gw := gzip.NewWriter(w)
	defer gw.Close()

	prefix := fmt.Sprintf("%s-%s", name, ref)
	err = gr.WriteTar(gw, prefix)
	if err != nil {
		// once we start writing to the body we can't report error anymore
		// so we are only left with printing the error.
		log.Println(err)
		return
	}

	err = gw.Flush()
	if err != nil {
		// once we start writing to the body we can't report error anymore
		// so we are only left with printing the error.
		log.Println(err)
		return
	}
}

func (d *deps) serveDiff(w http.ResponseWriter, r *http.Request) {
	ref := r.PathValue("ref")
	gr, name, err := d.openRepository(r.PathValue("name"), ref)
	if err != nil {
		d.write404(w)
		return
	}

	diff, err := gr.Diff()
	if err != nil {
		d.write500(w)
		log.Println(err)
		return
	}

	data := repoCommitData{
		Config: d.c,
		Meta: repositoryMeta{
			DisplayName: getDisplayName(name),
			DirName:     name,
			Description: gr.GitwebDescription(),
			Ref:         diff.Commit.Hash.String(),
		},
		Commit: diff.Commit,
		Parent: diff.Parent,
		Diff:   diff,
	}

	if err := d.template().ExecuteTemplate(w, "repo-commit", data); err != nil {
		log.Println(err)
		return
	}
}

func (d *deps) serveRefs(w http.ResponseWriter, r *http.Request) {
	gr, name, err := d.openRepository(r.PathValue("name"), "")
	if err != nil {
		d.write404(w)
		return
	}

	tags, err := gr.Tags()
	if err != nil {
		// Non-fatal, we *should* have at least one branch to show.
		log.Println(err)
	}

	branches, err := gr.Branches()
	if err != nil {
		log.Println(err)
		d.write500(w)
		return
	}

	mainBranch, err := gr.FindMainBranch(d.c.Repo.MainBranch)
	if err != nil {
		d.write500(w)
		log.Println(err)
		return
	}

	data := repoRefsData{
		Config: d.c,
		Meta: repositoryMeta{
			DisplayName: getDisplayName(name),
			DirName:     name,
			Description: gr.GitwebDescription(),
			Ref:         mainBranch,
		},
		Tags:     tags,
		Branches: branches,
	}

	if err := d.template().ExecuteTemplate(w, "repo-refs", data); err != nil {
		log.Println(err)
		return
	}
}

func (d *deps) serveStatic(w http.ResponseWriter, r *http.Request) {
	name := r.PathValue("file")
	name = filepath.Clean(name)
	if !filepath.IsLocal(name) {
		d.write404(w)
		return
	}

	http.ServeFileFS(w, r, d.staticDir, name)
}