docs.go

package server

import (

	"log"

	"net/http"

	"slices"

	"example.com/curator/internal/dochtml"

	"example.com/curator/internal/git"

	"example.com/curator/internal/godoc"

	"example.com/curator/internal/metrics"

)

func (s *Server) serveDocs(w http.ResponseWriter, r *http.Request) {

	modName, version, subpath := ParseDocPath(r.URL.Path)

	if modName == "" {

		http.NotFound(w, r)

		return

	}

	if !s.CanAccessModule(modName, r) {

		http.NotFound(w, r)

		return

	}

	mod, ok := s.Resolver.ResolveModule(modName)

	if !ok {

		http.NotFound(w, r)

		return

	}

	// Versions tab doesn't need a git checkout.

	if r.URL.Query().Get("tab") == "versions" {

		s.serveVersionsPage(w, r, modName, mod.VCS, mod.Repo)

		return

	}

	repoPath, err := s.Git.CloneOrFetch(modName, mod.Repo)

	if err != nil {

		log.Printf("docs: git error for %s: %v", modName, err)

		http.Error(w, "internal error", http.StatusInternalServerError)

		return

	}

	// Resolve version.

	if version == "" {

		tags, err := git.ListTags(repoPath)

		if err != nil || len(tags) == 0 {

			log.Printf("docs: no tags for %s: %v", modName, err)

			http.Error(w, "no versions available", http.StatusNotFound)

			return

		}

		version = tags[len(tags)-1] // latest

	}

	rv, err := git.ResolveVersion(repoPath, version)

	if err != nil {

		log.Printf("docs: resolve version %s@%s: %v", modName, version, err)

		http.NotFound(w, r)

		return

	}

	// Source view.

	if r.URL.Query().Get("view") == "source" {

		s.serveSourcePage(w, r, modName, mod.VCS, mod.Repo, repoPath, rv, subpath)

		return

	}

	// Documentation page.

	s.serveDocPage(w, r, modName, mod.VCS, mod.Repo, repoPath, rv, subpath)

}

func (s *Server) serveDocPage(w http.ResponseWriter, r *http.Request, modName, vcs, repo, repoPath string, rv *git.ResolvedVersion, subpath string) {

	metrics.DocRendersTotal.WithLabelValues("package").Inc()

	modulePath := s.Cfg.Host + "/" + modName

	importPath := modulePath

	if subpath != "" {

		importPath = modulePath + "/" + subpath

	}

	doc, err := godoc.ParsePackage(s.Git, repoPath, rv.GitRev, subpath, importPath)

	if err != nil {

		log.Printf("docs: parse %s@%s/%s: %v", modName, rv.Version, subpath, err)

		http.Error(w, "internal error", http.StatusInternalServerError)

		return

	}

	// Get versions for the selector.

	tags, _ := git.ListTags(repoPath)

	// Get sub-packages (only for root package).

	var subPkgs []godoc.SubPkgSummary

	if subpath == "" {

		subPkgs, _ = godoc.ListSubPackages(s.Git, repoPath, rv.GitRev, modulePath)

	}

	// Reverse versions so newest is first.

	versions := make([]string, len(tags))

	copy(versions, tags)

	slices.Reverse(versions)

	data := dochtml.BuildModulePageData(s.Cfg.Host, modName, rv.Version, subpath, vcs, repo, doc, versions, subPkgs)

	w.Header().Set("Content-Type", "text/html; charset=utf-8")

	if err := s.DocRenderer.RenderModule(w, data); err != nil {

		log.Printf("docs: render %s: %v", modName, err)

	}

}

func (s *Server) serveSourcePage(w http.ResponseWriter, r *http.Request, modName, vcs, repo, repoPath string, rv *git.ResolvedVersion, subpath string) {

	metrics.DocRendersTotal.WithLabelValues("source").Inc()

	fileName := r.URL.Query().Get("file")

	if fileName == "" {

		http.NotFound(w, r)

		return

	}

	filePath := fileName

	if subpath != "" {

		filePath = subpath + "/" + fileName

	}

	src, err := git.ReadFile(repoPath, rv.GitRev, filePath)

	if err != nil {

		log.Printf("docs: read source %s@%s:%s: %v", modName, rv.Version, filePath, err)

		http.NotFound(w, r)

		return

	}

	highlighted := godoc.HighlightGo(src)

	// Get file list for the package.

	files, _ := git.ReadDir(repoPath, rv.GitRev, subpath)

	var fileNames []string

	for name := range files {

		fileNames = append(fileNames, name)

	}

	slices.Sort(fileNames)

	data := &dochtml.SourcePageData{

		Host:              s.Cfg.Host,

		ImportPrefix:      s.Cfg.Host + "/" + modName,

		ModuleName:        modName,

		VCS:               vcs,

		Repo:              repo,

		Version:           rv.Version,

		SubPath:           subpath,

		FileName:          fileName,

		HighlightedSource: dochtml.TrustedHTML(highlighted),

		SourceFiles:       fileNames,

	}

	w.Header().Set("Content-Type", "text/html; charset=utf-8")

	if err := s.DocRenderer.RenderSource(w, data); err != nil {

		log.Printf("docs: render source %s: %v", fileName, err)

	}

}

func (s *Server) serveVersionsPage(w http.ResponseWriter, r *http.Request, modName, vcs, repo string) {

	metrics.DocRendersTotal.WithLabelValues("versions").Inc()

	mod, _ := s.Resolver.ResolveModule(modName)

	repoPath, err := s.Git.CloneOrFetch(modName, mod.Repo)

	if err != nil {

		log.Printf("docs: git error for %s: %v", modName, err)

		http.Error(w, "internal error", http.StatusInternalServerError)

		return

	}

	tags, _ := git.ListTags(repoPath)

	// Reverse so newest is first.

	versions := make([]string, len(tags))

	copy(versions, tags)

	slices.Reverse(versions)

	currentVersion := ""

	if len(versions) > 0 {

		currentVersion = versions[0]

	}

	data := &dochtml.VersionsPageData{

		Host:           s.Cfg.Host,

		ImportPrefix:   s.Cfg.Host + "/" + modName,

		ModuleName:     modName,

		VCS:            vcs,

		Repo:           repo,

		Versions:       versions,

		CurrentVersion: currentVersion,

	}

	w.Header().Set("Content-Type", "text/html; charset=utf-8")

	if err := s.DocRenderer.RenderVersions(w, data); err != nil {

		log.Printf("docs: render versions %s: %v", modName, err)

	}

}