path: root/routes/routes.go

package routes

import (
	"errors"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"time"

	"git.icyphox.sh/legit/config"
	"git.icyphox.sh/legit/git"
	"github.com/alexedwards/flow"
	"github.com/dustin/go-humanize"
	gogit "github.com/go-git/go-git/v5"
	"github.com/microcosm-cc/bluemonday"
	"github.com/russross/blackfriday/v2"
)

type deps struct {
	c *config.Config
}

type info struct {
	Name, Path, Desc, Idle string
	d                      time.Time
}

func (d *deps) Index(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
	}

	categories := make(map[string][]info)

	for _, dir := range dirs {
		if d.isIgnored(dir.Name()) {
			continue
		}

		path := filepath.Join(d.c.Repo.ScanPath, dir.Name())
		gr, err := git.Open(path, "")
		if errors.Is(err, gogit.ErrRepositoryNotExists) {
			log.Printf("reading category: %s", dir.Name())
			infos, err := d.IndexCategory(path, dir.Name())
			if err != nil {
				log.Printf("reading category: %s", err)
			}
			if len(infos) > 0 {
				categories[dir.Name()] = infos
			}
			continue
		} else if err != nil {
			log.Println(err)
			continue
		}

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

		desc := getDescription(path)
		name := strings.TrimSuffix(dir.Name(), ".git")

		categories[""] = append(categories[""], info{
			Name: name,
			Path: name,
			Desc: desc,
			Idle: humanize.Time(c.Author.When),
			d:    c.Author.When,
		})
	}

	for _, infos := range categories {
		sort.Slice(infos, func(i, j int) bool {
			return infos[j].d.Before(infos[i].d)
		})
	}

	tpath := filepath.Join(d.c.Dirs.Templates, "*")
	t := template.Must(template.ParseGlob(tpath))

	data := make(map[string]interface{})
	data["meta"] = d.c.Meta
	data["categories"] = categories

	if err := t.ExecuteTemplate(w, "index", data); err != nil {
		log.Println(err)
		return
	}
}

func (d *deps) IndexCategory(scanpath string, category string) ([]info, error) {
	dirs, err := os.ReadDir(scanpath)
	if err != nil {
		return nil, fmt.Errorf("reading scan path: %s", err)
	}

	infos := []info{}

	for _, dir := range dirs {
		if d.isIgnored(dir.Name()) {
			continue
		}

		path := filepath.Join(scanpath, dir.Name())
		gr, err := git.Open(path, "")
		if errors.Is(err, gogit.ErrRepositoryNotExists) {
			log.Println(path)
			folder_infos, err := d.IndexCategory(path, category)
			if err != nil {
				log.Println(err)
				continue
			}
			infos = append(infos, folder_infos...)
			continue
		} else if err != nil {
			log.Println(err)
			continue
		}

		c, err := gr.LastCommit()
		if err != nil {
			return nil, err
		}

		desc := getDescription(path)
		repodir := filepath.Join(scanpath, dir.Name())
		repopath := strings.Split(repodir, category)
		name := strings.TrimSuffix(repopath[len(repopath)-1], ".git")
		name = strings.TrimPrefix(name, "/")

		infos = append(infos, info{
			Name: name,
			Path: category + "/" + name,
			Desc: desc,
			Idle: humanize.Time(c.Author.When),
			d:    c.Author.When,
		})
	}

	return infos, nil
}

func (d *deps) RepoIndex(w http.ResponseWriter, r *http.Request) {
	name := flow.Param(r.Context(), "name")
	if d.isIgnored(name) {
		d.Write404(w)
		return
	}
	name = filepath.Clean(name)
	path := d.c.Repo.ScanPath
	category := flow.Param(r.Context(), "category")
	if category != "" {
		path = filepath.Join(path, category)
		log.Println(category)
	}
	path = filepath.Join(path, name)
	log.Println(path)

	gr, err := git.Open(path, "")
	if err != nil {
		gr, err = git.Open(path+".git", "")
		if err != nil {
			d.Write404(w)
			return
		}
	}

	commits, err := gr.Commits()
	if err != nil {
		d.Write500(w)
		log.Println(err)
		return
	}

	var readmeContent template.HTML
	for _, readme := range d.c.Repo.Readme {
		ext := filepath.Ext(readme)
		content, _ := gr.FileContent(readme)
		if len(content) > 0 {
			switch ext {
			case ".md", ".mkd", ".markdown":
				unsafe := blackfriday.Run(
					[]byte(content),
					blackfriday.WithExtensions(blackfriday.CommonExtensions),
				)
				html := bluemonday.UGCPolicy().SanitizeBytes(unsafe)
				readmeContent = template.HTML(html)
			default:
				readmeContent = template.HTML(
					fmt.Sprintf(`<pre>%s</pre>`, content),
				)
			}
			break
		}
	}

	if readmeContent == "" {
		log.Printf("no readme found for %s", name)
	}

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

	tpath := filepath.Join(d.c.Dirs.Templates, "*")
	t := template.Must(template.ParseGlob(tpath))

	if len(commits) >= 3 {
		commits = commits[:3]
	}

	data := make(map[string]any)
	data["name"] = name
	data["ref"] = mainBranch
	data["readme"] = readmeContent
	data["commits"] = commits
	data["desc"] = getDescription(path)
	data["servername"] = d.c.Server.Name
	data["meta"] = d.c.Meta
	data["gomod"] = isGoModule(gr)

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

	return
}

func (d *deps) RepoTree(w http.ResponseWriter, r *http.Request) {
	name := flow.Param(r.Context(), "name")
	if d.isIgnored(name) {
		d.Write404(w)
		return
	}
	treePath := flow.Param(r.Context(), "...")
	ref := flow.Param(r.Context(), "ref")

	name = filepath.Clean(name)
	path := d.c.Repo.ScanPath
	category := flow.Param(r.Context(), "category")
	if category != "" {
		path = filepath.Join(path, category)
	}
	path = filepath.Join(path, name)
	gr, err := git.Open(path, ref)
	if err != nil {
		gr, err = git.Open(path+".git", ref)
		if err != nil {
			d.Write404(w)
			return
		}
	}

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

	data := make(map[string]any)
	data["name"] = name
	data["ref"] = ref
	data["parent"] = treePath
	data["desc"] = getDescription(path)
	data["dotdot"] = filepath.Dir(treePath)

	d.listFiles(files, data, w)
	return
}

func (d *deps) FileContent(w http.ResponseWriter, r *http.Request) {
	name := flow.Param(r.Context(), "name")
	if d.isIgnored(name) {
		d.Write404(w)
		return
	}
	treePath := flow.Param(r.Context(), "...")
	ref := flow.Param(r.Context(), "ref")

	name = filepath.Clean(name)
	path := d.c.Repo.ScanPath
	category := flow.Param(r.Context(), "category")
	if category != "" {
		path = filepath.Join(path, category)
	}
	path = filepath.Join(path, name)
	gr, err := git.Open(path, ref)
	if err != nil {
		gr, err = git.Open(path+".git", ref)
		if err != nil {
			d.Write404(w)
			return
		}
	}

	contents, err := gr.FileContent(treePath)
	data := make(map[string]any)
	data["name"] = name
	data["ref"] = ref
	data["desc"] = getDescription(path)
	data["path"] = treePath

	d.showFile(contents, data, w)
	return
}

func (d *deps) Log(w http.ResponseWriter, r *http.Request) {
	name := flow.Param(r.Context(), "name")
	if d.isIgnored(name) {
		d.Write404(w)
		return
	}
	ref := flow.Param(r.Context(), "ref")

	path := d.c.Repo.ScanPath
	category := flow.Param(r.Context(), "category")
	if category != "" {
		path = filepath.Join(path, category)
	}
	path = filepath.Join(path, name)
	gr, err := git.Open(path, ref)
	if err != nil {
		gr, err = git.Open(path+".git", ref)
		if err != nil {
			d.Write404(w)
			return
		}
	}

	commits, err := gr.Commits()
	if err != nil {
		d.Write500(w)
		log.Println(err)
		return
	}

	tpath := filepath.Join(d.c.Dirs.Templates, "*")
	t := template.Must(template.ParseGlob(tpath))

	data := make(map[string]interface{})
	data["commits"] = commits
	data["meta"] = d.c.Meta
	data["name"] = name
	data["ref"] = ref
	data["desc"] = getDescription(path)
	data["log"] = true

	if err := t.ExecuteTemplate(w, "log", data); err != nil {
		log.Println(err)
		return
	}
}

func (d *deps) Diff(w http.ResponseWriter, r *http.Request) {
	name := flow.Param(r.Context(), "name")
	if d.isIgnored(name) {
		d.Write404(w)
		return
	}
	ref := flow.Param(r.Context(), "ref")

	path := d.c.Repo.ScanPath
	category := flow.Param(r.Context(), "category")
	if category != "" {
		path = filepath.Join(path, category)
	}
	path = filepath.Join(path, name)
	gr, err := git.Open(path, ref)
	if err != nil {
		gr, err = git.Open(path+".git", ref)
		if err != nil {
			d.Write404(w)
			return
		}
	}

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

	tpath := filepath.Join(d.c.Dirs.Templates, "*")
	t := template.Must(template.ParseGlob(tpath))

	data := make(map[string]interface{})

	data["commit"] = diff.Commit
	data["stat"] = diff.Stat
	data["diff"] = diff.Diff
	data["meta"] = d.c.Meta
	data["name"] = name
	data["ref"] = ref
	data["desc"] = getDescription(path)

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

func (d *deps) Refs(w http.ResponseWriter, r *http.Request) {
	name := flow.Param(r.Context(), "name")
	if d.isIgnored(name) {
		d.Write404(w)
		return
	}

	path := d.c.Repo.ScanPath
	category := flow.Param(r.Context(), "category")
	if category != "" {
		path = filepath.Join(path, category)
	}
	path = filepath.Join(path, name)
	gr, err := git.Open(path, "")
	if err != nil {
		gr, err = git.Open(path+".git", "")
		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
	}

	tpath := filepath.Join(d.c.Dirs.Templates, "*")
	t := template.Must(template.ParseGlob(tpath))

	data := make(map[string]interface{})

	data["meta"] = d.c.Meta
	data["name"] = name
	data["branches"] = branches
	data["tags"] = tags
	data["desc"] = getDescription(path)

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

func (d *deps) ServeStatic(w http.ResponseWriter, r *http.Request) {
	f := flow.Param(r.Context(), "file")
	f = filepath.Clean(filepath.Join(d.c.Dirs.Static, f))

	http.ServeFile(w, r, f)
}