godev/internal/content/content.go - telemetry - Git at Google

 // Copyright 2023 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Package content implements a basic web serving framework.
 //
 // # Content Server
 //
 // A content server is an http.Handler that serves requests from a file system.
 // Use Server(fsys) to create a new content server.
 //
 // The server is defined primarily by the content of its file system fsys,
 // which holds files to be served. It renders markdown files and golang
 // templates into HTML and transforms TypeScript into JavaScript.
 //
 // # Page Rendering
 //
 // A request for a path like "/page" will search the file system for
 // "page.md", "page.html", "page/index.md", and "page/index.html" and
 // render HTML output for the first file found.
 //
 // Partial templates with the extension ".tmpl" at the root of the file system
 // and in the same directory as the requested page are included in the
 // html/template execution step to allow for sharing and composing logic from
 // multiple templates.
 package content

 import (
 	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"html/template"
 	"io/fs"
 	"net/http"
 	"path"
 	"strconv"
 	"strings"

 	"github.com/yuin/goldmark"
 	meta "github.com/yuin/goldmark-meta"
 	"github.com/yuin/goldmark/extension"
 	"github.com/yuin/goldmark/parser"
 	"github.com/yuin/goldmark/renderer/html"
 	"golang.org/x/exp/slog"
 )

 // contentServer serves requests for a given file system. It can also render
 // templates and transform TypeScript into JavaScript.
 type contentServer struct {
 	fsys     fs.FS
 	fserv    http.Handler
 	handlers map[string]handlerFunc
 }

 type handler struct {
 	path string
 	fn   handlerFunc
 }

 type handlerFunc func(http.ResponseWriter, *http.Request, fs.FS) error

 // Server returns a handler that serves HTTP requests with the contents
 // of the file system rooted at fsys. For requests to a path without an
 // extension, the server will search fsys for markdown or html templates
 // first by appending .md, .html, /index.md, and /index.html to the
 // requested url path.
 //
 // The default behavior of looking for templates within fsys can be overriden
 // by using an optional set of content handlers.
 //
 // For example, a server can be constructed for a file system with a single
 // template, “index.html“, in a directory, “content“, and a handler:
 //
 //	 s := content.Server(os.DirFS("content"),
 //		 content.Handler("/", func(w http.ReponseWriter, _ *http.Request, fsys fs.FS) error {
 //		 	 return content.Template(w, fsys, "index.html", nil, http.StatusOK)
 //		 }))
 //
 // or without a handler:
 //
 //	content.Server(os.DirFS("content"))
 //
 // Both examples will render the template index.html for requests to "/".
 func Server(fsys fs.FS, handlers ...*handler) http.Handler {
 	fserv := http.FileServer(http.FS(fsys))
 	hs := make(map[string]handlerFunc)
 	for _, h := range handlers {
 		if _, ok := hs[h.path]; ok {
 			panic("multiple registrations for " + h.path)
 		}
 		hs[h.path] = h.fn
 	}
 	return &contentServer{fsys, fserv, hs}
 }

 func Handler(path string, h handlerFunc) *handler {
 	return &handler{path, h}
 }

 func (c *contentServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if len(r.URL.Path) > 255 {
 		Error(w, r, errors.New("url too long"), http.StatusBadRequest)
 		return
 	}

 	if handler, ok := c.handlers[r.URL.Path]; ok {
 		err := handler(w, r, c.fsys)
 		if err != nil {
 			Error(w, r, err, http.StatusInternalServerError)
 		}
 		return
 	}

 	ext := path.Ext(r.URL.Path)
 	if ext == ".md" || ext == ".html" {
 		http.Redirect(w, r, strings.TrimSuffix(r.URL.Path, ext), http.StatusMovedPermanently)
 		return
 	}

 	filepath, info, err := stat(c.fsys, r.URL.Path)
 	if errors.Is(err, fs.ErrNotExist) {
 		Error(w, r, errors.New("page not found"), http.StatusNotFound)
 		return
 	}
 	if err == nil {
 		if strings.HasSuffix(r.URL.Path, "/index") {
 			http.Redirect(w, r, strings.TrimSuffix(r.URL.Path, "/index"), http.StatusMovedPermanently)
 			return
 		}
 		switch path.Ext(filepath) {
 		case ".html":
 			err = Template(w, c.fsys, filepath, nil, http.StatusOK)
 		case ".md":
 			err = markdown(w, c.fsys, filepath, http.StatusOK)
 		case ".ts":
 			err = script(w, c.fsys, filepath, info)
 		default:
 			c.fserv.ServeHTTP(w, r)
 		}
 	}
 	if err != nil {
 		Error(w, r, err, http.StatusInternalServerError)
 	}
 }

 // Template executes a template response.
 func Template(w http.ResponseWriter, fsys fs.FS, tmplPath string, data any, code int) error {
 	patterns, err := tmplPatterns(fsys, tmplPath)
 	if err != nil {
 		return err
 	}
 	patterns = append(patterns, tmplPath)
 	tmpl, err := template.ParseFS(fsys, patterns...)
 	if err != nil {
 		return err
 	}
 	name := path.Base(tmplPath)
 	var buf bytes.Buffer
 	if err := tmpl.ExecuteTemplate(&buf, name, data); err != nil {
 		return err
 	}
 	if code != 0 {
 		w.WriteHeader(code)
 	}
 	w.Header().Set("Content-Type", "text/html")
 	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
 	if _, err := w.Write(buf.Bytes()); err != nil {
 		return err
 	}
 	return nil
 }

 // JSON encodes data as JSON response with a status code.
 func JSON(w http.ResponseWriter, data any, code int) error {
 	var buf bytes.Buffer
 	if err := json.NewEncoder(&buf).Encode(data); err != nil {
 		return err
 	}
 	if code != 0 {
 		w.WriteHeader(code)
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
 	if _, err := w.Write(buf.Bytes()); err != nil {
 		return err
 	}
 	return nil
 }

 // Text formats data as a text response with a status code.
 func Text(w http.ResponseWriter, data any, code int) error {
 	var buf bytes.Buffer
 	if _, err := fmt.Fprint(&buf, data); err != nil {
 		return err
 	}
 	if code != 0 {
 		w.WriteHeader(code)
 	}
 	w.Header().Set("Content-Type", "text/plain")
 	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
 	if _, err := w.Write(buf.Bytes()); err != nil {
 		return err
 	}
 	return nil
 }

 // Error writes an error as an HTTP response with a status code.
 func Error(w http.ResponseWriter, req *http.Request, err error, code int) {
 	if code == http.StatusInternalServerError {
 		http.Error(w, http.StatusText(http.StatusInternalServerError), code)
 	} else {
 		http.Error(w, err.Error(), code)
 	}
 	slog.Error("request error",
 		slog.String("method", req.Method),
 		slog.String("uri", req.RequestURI),
 		slog.Int("status", code),
 		slog.String("error", err.Error()),
 	)
 }

 // markdown renders a markdown template as html.
 func markdown(w http.ResponseWriter, fsys fs.FS, tmplPath string, code int) error {
 	markdown, err := fs.ReadFile(fsys, tmplPath)
 	if err != nil {
 		return err
 	}
 	md := goldmark.New(
 		goldmark.WithParserOptions(
 			parser.WithHeadingAttribute(),
 			parser.WithAutoHeadingID(),
 		),
 		goldmark.WithRendererOptions(
 			html.WithUnsafe(),
 			html.WithXHTML(),
 		),
 		goldmark.WithExtensions(
 			extension.GFM,
 			extension.NewTypographer(),
 			meta.Meta,
 		),
 	)
 	var content bytes.Buffer
 	ctx := parser.NewContext()
 	if err := md.Convert(markdown, &content, parser.WithContext(ctx)); err != nil {
 		return err
 	}
 	data := meta.Get(ctx)
 	if data == nil {
 		data = map[string]interface{}{}
 	}
 	data["Content"] = template.HTML(content.String())
 	if _, ok := data["Template"]; !ok {
 		data["Template"] = "base.html"
 	}
 	return Template(w, fsys, data["Template"].(string), data, code)
 }

 // script serves TypeScript code tranformed into JavaScript.
 func script(w http.ResponseWriter, fsys fs.FS, filepath string, info fs.FileInfo) error {
 	data, err := fs.ReadFile(fsys, filepath)
 	if err != nil {
 		return err
 	}
 	output := esbuild(data)
 	w.Header().Set("Content-Type", "text/javascript")
 	w.Header().Set("Content-Length", strconv.Itoa(output.Len()))
 	w.Header().Set("Last-Modified", info.ModTime().Format("Mon, 02 Jan 2006 15:04:05 GMT"))
 	if _, err := w.Write(output.Bytes()); err != nil {
 		return err
 	}
 	return nil
 }

 // stat trys to coerce a urlPath into an openable file then returns the
 // file path and file info.
 func stat(fsys fs.FS, urlPath string) (string, fs.FileInfo, error) {
 	cleanPath := path.Clean(strings.TrimPrefix(urlPath, "/"))
 	ext := path.Ext(cleanPath)
 	filePaths := []string{cleanPath}
 	if ext == "" || ext == "." {
 		md := cleanPath + ".md"
 		html := cleanPath + ".html"
 		indexMD := path.Join(cleanPath, "index.md")
 		indexHTML := path.Join(cleanPath, "index.html")
 		filePaths = []string{md, html, indexMD, indexHTML, cleanPath}
 	}
 	var p string
 	var stat fs.FileInfo
 	var err error
 	for _, p = range filePaths {
 		if stat, err = fs.Stat(fsys, p); err == nil {
 			break
 		}
 	}
 	return p, stat, err
 }

 // tmplPatters generates a slice of file patterns to use in template.ParseFS.
 func tmplPatterns(fsys fs.FS, tmplPath string) ([]string, error) {
 	var patterns []string
 	globs := []string{"*.tmpl", path.Join(path.Dir(tmplPath), "*.tmpl")}
 	for _, g := range globs {
 		matches, err := fs.Glob(fsys, g)
 		if err != nil {
 			return nil, err
 		}
 		patterns = append(patterns, matches...)
 	}
 	return patterns, nil
 }
	// Copyright 2023 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Package content implements a basic web serving framework.
	//
	// # Content Server
	//
	// A content server is an http.Handler that serves requests from a file system.
	// Use Server(fsys) to create a new content server.
	//
	// The server is defined primarily by the content of its file system fsys,
	// which holds files to be served. It renders markdown files and golang
	// templates into HTML and transforms TypeScript into JavaScript.
	//
	// # Page Rendering
	//
	// A request for a path like "/page" will search the file system for
	// "page.md", "page.html", "page/index.md", and "page/index.html" and
	// render HTML output for the first file found.
	//
	// Partial templates with the extension ".tmpl" at the root of the file system
	// and in the same directory as the requested page are included in the
	// html/template execution step to allow for sharing and composing logic from
	// multiple templates.
	package content

	import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"html/template"
	"io/fs"
	"net/http"
	"path"
	"strconv"
	"strings"

	"github.com/yuin/goldmark"
	meta "github.com/yuin/goldmark-meta"
	"github.com/yuin/goldmark/extension"
	"github.com/yuin/goldmark/parser"
	"github.com/yuin/goldmark/renderer/html"
	"golang.org/x/exp/slog"
	)

	// contentServer serves requests for a given file system. It can also render
	// templates and transform TypeScript into JavaScript.
	type contentServer struct {
	fsys fs.FS
	fserv http.Handler
	handlers map[string]handlerFunc
	}

	type handler struct {
	path string
	fn handlerFunc
	}

	type handlerFunc func(http.ResponseWriter, *http.Request, fs.FS) error

	// Server returns a handler that serves HTTP requests with the contents
	// of the file system rooted at fsys. For requests to a path without an
	// extension, the server will search fsys for markdown or html templates
	// first by appending .md, .html, /index.md, and /index.html to the
	// requested url path.
	//
	// The default behavior of looking for templates within fsys can be overriden
	// by using an optional set of content handlers.
	//
	// For example, a server can be constructed for a file system with a single
	// template, “index.html“, in a directory, “content“, and a handler:
	//
	// s := content.Server(os.DirFS("content"),
	// content.Handler("/", func(w http.ReponseWriter, _ *http.Request, fsys fs.FS) error {
	// return content.Template(w, fsys, "index.html", nil, http.StatusOK)
	// }))
	//
	// or without a handler:
	//
	// content.Server(os.DirFS("content"))
	//
	// Both examples will render the template index.html for requests to "/".
	func Server(fsys fs.FS, handlers ...*handler) http.Handler {
	fserv := http.FileServer(http.FS(fsys))
	hs := make(map[string]handlerFunc)
	for _, h := range handlers {
	if _, ok := hs[h.path]; ok {
	panic("multiple registrations for " + h.path)
	}
	hs[h.path] = h.fn
	}
	return &contentServer{fsys, fserv, hs}
	}

	func Handler(path string, h handlerFunc) *handler {
	return &handler{path, h}
	}

	func (c contentServer) ServeHTTP(w http.ResponseWriter, r http.Request) {
	if len(r.URL.Path) > 255 {
	Error(w, r, errors.New("url too long"), http.StatusBadRequest)
	return
	}

	if handler, ok := c.handlers[r.URL.Path]; ok {
	err := handler(w, r, c.fsys)
	if err != nil {
	Error(w, r, err, http.StatusInternalServerError)
	}
	return
	}

	ext := path.Ext(r.URL.Path)
	if ext == ".md" \|\| ext == ".html" {
	http.Redirect(w, r, strings.TrimSuffix(r.URL.Path, ext), http.StatusMovedPermanently)
	return
	}

	filepath, info, err := stat(c.fsys, r.URL.Path)
	if errors.Is(err, fs.ErrNotExist) {
	Error(w, r, errors.New("page not found"), http.StatusNotFound)
	return
	}
	if err == nil {
	if strings.HasSuffix(r.URL.Path, "/index") {
	http.Redirect(w, r, strings.TrimSuffix(r.URL.Path, "/index"), http.StatusMovedPermanently)
	return
	}
	switch path.Ext(filepath) {
	case ".html":
	err = Template(w, c.fsys, filepath, nil, http.StatusOK)
	case ".md":
	err = markdown(w, c.fsys, filepath, http.StatusOK)
	case ".ts":
	err = script(w, c.fsys, filepath, info)
	default:
	c.fserv.ServeHTTP(w, r)
	}
	}
	if err != nil {
	Error(w, r, err, http.StatusInternalServerError)
	}
	}

	// Template executes a template response.
	func Template(w http.ResponseWriter, fsys fs.FS, tmplPath string, data any, code int) error {
	patterns, err := tmplPatterns(fsys, tmplPath)
	if err != nil {
	return err
	}
	patterns = append(patterns, tmplPath)
	tmpl, err := template.ParseFS(fsys, patterns...)
	if err != nil {
	return err
	}
	name := path.Base(tmplPath)
	var buf bytes.Buffer
	if err := tmpl.ExecuteTemplate(&buf, name, data); err != nil {
	return err
	}
	if code != 0 {
	w.WriteHeader(code)
	}
	w.Header().Set("Content-Type", "text/html")
	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
	if _, err := w.Write(buf.Bytes()); err != nil {
	return err
	}
	return nil
	}

	// JSON encodes data as JSON response with a status code.
	func JSON(w http.ResponseWriter, data any, code int) error {
	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(data); err != nil {
	return err
	}
	if code != 0 {
	w.WriteHeader(code)
	}
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
	if _, err := w.Write(buf.Bytes()); err != nil {
	return err
	}
	return nil
	}

	// Text formats data as a text response with a status code.
	func Text(w http.ResponseWriter, data any, code int) error {
	var buf bytes.Buffer
	if _, err := fmt.Fprint(&buf, data); err != nil {
	return err
	}
	if code != 0 {
	w.WriteHeader(code)
	}
	w.Header().Set("Content-Type", "text/plain")
	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
	if _, err := w.Write(buf.Bytes()); err != nil {
	return err
	}
	return nil
	}

	// Error writes an error as an HTTP response with a status code.
	func Error(w http.ResponseWriter, req *http.Request, err error, code int) {
	if code == http.StatusInternalServerError {
	http.Error(w, http.StatusText(http.StatusInternalServerError), code)
	} else {
	http.Error(w, err.Error(), code)
	}
	slog.Error("request error",
	slog.String("method", req.Method),
	slog.String("uri", req.RequestURI),
	slog.Int("status", code),
	slog.String("error", err.Error()),
	)
	}

	// markdown renders a markdown template as html.
	func markdown(w http.ResponseWriter, fsys fs.FS, tmplPath string, code int) error {
	markdown, err := fs.ReadFile(fsys, tmplPath)
	if err != nil {
	return err
	}
	md := goldmark.New(
	goldmark.WithParserOptions(
	parser.WithHeadingAttribute(),
	parser.WithAutoHeadingID(),
	),
	goldmark.WithRendererOptions(
	html.WithUnsafe(),
	html.WithXHTML(),
	),
	goldmark.WithExtensions(
	extension.GFM,
	extension.NewTypographer(),
	meta.Meta,
	),
	)
	var content bytes.Buffer
	ctx := parser.NewContext()
	if err := md.Convert(markdown, &content, parser.WithContext(ctx)); err != nil {
	return err
	}
	data := meta.Get(ctx)
	if data == nil {
	data = map[string]interface{}{}
	}
	data["Content"] = template.HTML(content.String())
	if _, ok := data["Template"]; !ok {
	data["Template"] = "base.html"
	}
	return Template(w, fsys, data["Template"].(string), data, code)
	}

	// script serves TypeScript code tranformed into JavaScript.
	func script(w http.ResponseWriter, fsys fs.FS, filepath string, info fs.FileInfo) error {
	data, err := fs.ReadFile(fsys, filepath)
	if err != nil {
	return err
	}
	output := esbuild(data)
	w.Header().Set("Content-Type", "text/javascript")
	w.Header().Set("Content-Length", strconv.Itoa(output.Len()))
	w.Header().Set("Last-Modified", info.ModTime().Format("Mon, 02 Jan 2006 15:04:05 GMT"))
	if _, err := w.Write(output.Bytes()); err != nil {
	return err
	}
	return nil
	}

	// stat trys to coerce a urlPath into an openable file then returns the
	// file path and file info.
	func stat(fsys fs.FS, urlPath string) (string, fs.FileInfo, error) {
	cleanPath := path.Clean(strings.TrimPrefix(urlPath, "/"))
	ext := path.Ext(cleanPath)
	filePaths := []string{cleanPath}
	if ext == "" \|\| ext == "." {
	md := cleanPath + ".md"
	html := cleanPath + ".html"
	indexMD := path.Join(cleanPath, "index.md")
	indexHTML := path.Join(cleanPath, "index.html")
	filePaths = []string{md, html, indexMD, indexHTML, cleanPath}
	}
	var p string
	var stat fs.FileInfo
	var err error
	for _, p = range filePaths {
	if stat, err = fs.Stat(fsys, p); err == nil {
	break
	}
	}
	return p, stat, err
	}

	// tmplPatters generates a slice of file patterns to use in template.ParseFS.
	func tmplPatterns(fsys fs.FS, tmplPath string) ([]string, error) {
	var patterns []string
	globs := []string{".tmpl", path.Join(path.Dir(tmplPath), ".tmpl")}
	for _, g := range globs {
	matches, err := fs.Glob(fsys, g)
	if err != nil {
	return nil, err
	}
	patterns = append(patterns, matches...)
	}
	return patterns, nil
	}