Add render hooks passthroughs and blockquotes (with GitHub alert support)

go.mod

@@ -40,7 +40,7 @@ require (
 	github.com/gohugoio/hashstructure v0.1.0
 	github.com/gohugoio/httpcache v0.7.0
 	github.com/gohugoio/hugo-goldmark-extensions/extras v0.2.0
-	github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.2.0
+	github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.3.0
 	github.com/gohugoio/locales v0.14.0
 	github.com/gohugoio/localescompressed v1.0.1
 	github.com/gohugoio/testmodBuilder/mods v0.0.0-20190520184928-c56af20f2e95

go.sum

@@ -235,6 +235,8 @@ github.com/gohugoio/hugo-goldmark-extensions/extras v0.2.0 h1:MNdY6hYCTQEekY0oAf
 github.com/gohugoio/hugo-goldmark-extensions/extras v0.2.0/go.mod h1:oBdBVuiZ0fv9xd8xflUgt53QxW5jOCb1S+xntcN4SKo=
 github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.2.0 h1:PCtO5l++psZf48yen2LxQ3JiOXxaRC6v0594NeHvGZg=
 github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.2.0/go.mod h1:g9CCh+Ci2IMbPUrVJuXbBTrA+rIIx5+hDQ4EXYaQDoM=
+github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.3.0 h1:7PY5PIJ2mck7v6R52yCFvvYHvsPMEbulgRviw3I9lP4=
+github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.3.0/go.mod h1:r8g5S7bHfdj0+9ShBog864ufCsVODKQZNjYYY8OnJpM=
 github.com/gohugoio/locales v0.14.0 h1:Q0gpsZwfv7ATHMbcTNepFd59H7GoykzWJIxi113XGDc=
 github.com/gohugoio/locales v0.14.0/go.mod h1:ip8cCAv/cnmVLzzXtiTpPwgJ4xhKZranqNqtoIu0b/4=
 github.com/gohugoio/localescompressed v1.0.1 h1:KTYMi8fCWYLswFyJAeOtuk/EkXR/KPTHHNN9OS+RTxo=

hugolib/page__per_output.go

@@ -440,8 +440,8 @@ func (pco *pageContentOutput) initRenderHooks() error {
 			var offset int
 
 			switch v := ctx.(type) {
-			case hooks.CodeblockContext:
-				offset = bytes.Index(source, []byte(v.Inner()))
+			case hooks.PositionerSourceTargetProvider:
+				offset = bytes.Index(source, v.PositionerSourceTarget())
 			}
 
 			pos := pco.po.p.posFromInput(source, offset)
@@ -476,6 +476,16 @@ func (pco *pageContentOutput) initRenderHooks() error {
 				layoutDescriptor.Kind = "render-image"
 			case hooks.HeadingRendererType:
 				layoutDescriptor.Kind = "render-heading"
+			case hooks.PassthroughRendererType:
+				layoutDescriptor.Kind = "render-passthrough"
+				if id != nil {
+					layoutDescriptor.KindVariants = id.(string)
+				}
+			case hooks.BlockquoteRendererType:
+				layoutDescriptor.Kind = "render-blockquote"
+				if id != nil {
+					layoutDescriptor.KindVariants = id.(string)
+				}
 			case hooks.CodeBlockRendererType:
 				layoutDescriptor.Kind = "render-codeblock"
 				if id != nil {

hugolib/site.go

@@ -915,6 +915,14 @@ func (hr hookRendererTemplate) RenderCodeblock(cctx context.Context, w hugio.Fle
 	return hr.templateHandler.ExecuteWithContext(cctx, hr.templ, w, ctx)
 }
 
+func (hr hookRendererTemplate) RenderPassthrough(cctx context.Context, w io.Writer, ctx hooks.PassthroughContext) error {
+	return hr.templateHandler.ExecuteWithContext(cctx, hr.templ, w, ctx)
+}
+
+func (hr hookRendererTemplate) RenderBlockquote(cctx context.Context, w hugio.FlexiWriter, ctx hooks.BlockquoteContext) error {
+	return hr.templateHandler.ExecuteWithContext(cctx, hr.templ, w, ctx)
+}
+
 func (hr hookRendererTemplate) ResolvePosition(ctx any) text.Position {
 	return hr.resolvePosition(ctx)
 }

markup/converter/hooks/hooks.go

@@ -78,6 +78,49 @@ type CodeblockContext interface {
 	Ordinal() int
 }
 
+// BlockquoteContext is the context passed to a blockquote render hook.
+type BlockquoteContext interface {
+	AttributesProvider
+	text.Positioner
+	PageProvider
+
+	// Zero-based ordinal for all block quotes in the current document.
+	Ordinal() int
+
+	// The blockquote text.
+	// If type is "alert", this will be the alert text.
+	Text() hstring.RenderedString
+
+	/// Returns the blockquote type, one of "regular" and "alert".
+	// Type "alert" indicates that this is a GitHub type alert.
+	Type() string
+
+	// The GitHub alert type converted to lowercase, e.g. "note".
+	// Only set if Type is "alert".
+	AlertType() string
+}
+
+type PositionerSourceTargetProvider interface {
+	// For internal use.
+	PositionerSourceTarget() []byte
+}
+
+// PassThroughContext is the context passed to a passthrough render hook.
+type PassthroughContext interface {
+	AttributesProvider
+	text.Positioner
+	PageProvider
+
+	// Currently one of "inline" or "block".
+	Type() string
+
+	// The inner content of the passthrough element, excluding the delimiters.
+	Inner() string
+
+	// Zero-based ordinal for all passthrough elements in the document.
+	Ordinal() int
+}
+
 type AttributesOptionsSliceProvider interface {
 	AttributesSlice() []attributes.Attribute
 	OptionsSlice() []attributes.Attribute
@@ -91,6 +134,14 @@ type CodeBlockRenderer interface {
 	RenderCodeblock(cctx context.Context, w hugio.FlexiWriter, ctx CodeblockContext) error
 }
 
+type BlockquoteRenderer interface {
+	RenderBlockquote(cctx context.Context, w hugio.FlexiWriter, ctx BlockquoteContext) error
+}
+
+type PassthroughRenderer interface {
+	RenderPassthrough(cctx context.Context, w io.Writer, ctx PassthroughContext) error
+}
+
 type IsDefaultCodeBlockRendererProvider interface {
 	IsDefaultCodeBlockRenderer() bool
 }
@@ -143,6 +194,8 @@ const (
 	ImageRendererType
 	HeadingRendererType
 	CodeBlockRendererType
+	PassthroughRendererType
+	BlockquoteRendererType
 )
 
 type GetRendererFunc func(t RendererType, id any) any

markup/goldmark/blockquotes/blockquotes.go

@@ -0,0 +1,248 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package blockquotes
+
+import (
+	"regexp"
+	"strings"
+	"sync"
+
+	"github.com/gohugoio/hugo/common/herrors"
+	htext "github.com/gohugoio/hugo/common/text"
+	"github.com/gohugoio/hugo/common/types/hstring"
+	"github.com/gohugoio/hugo/markup/converter/hooks"
+	"github.com/gohugoio/hugo/markup/goldmark/internal/render"
+	"github.com/gohugoio/hugo/markup/internal/attributes"
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/renderer/html"
+	"github.com/yuin/goldmark/util"
+)
+
+type (
+	blockquotesExtension struct{}
+	htmlRenderer         struct{}
+)
+
+func New() goldmark.Extender {
+	return &blockquotesExtension{}
+}
+
+func (e *blockquotesExtension) Extend(m goldmark.Markdown) {
+	m.Renderer().AddOptions(renderer.WithNodeRenderers(
+		util.Prioritized(newHTMLRenderer(), 100),
+	))
+}
+
+func newHTMLRenderer() renderer.NodeRenderer {
+	r := &htmlRenderer{}
+	return r
+}
+
+func (r *htmlRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	reg.Register(ast.KindBlockquote, r.renderBlockquote)
+}
+
+const (
+	typeRegular = "regular"
+	typeAlert   = "alert"
+)
+
+func (r *htmlRenderer) renderBlockquote(w util.BufWriter, src []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	ctx := w.(*render.Context)
+
+	n := node.(*ast.Blockquote)
+
+	if entering {
+		// Store the current pos so we can capture the rendered text.
+		ctx.PushPos(ctx.Buffer.Len())
+		return ast.WalkContinue, nil
+	}
+
+	pos := ctx.PopPos()
+	text := ctx.Buffer.Bytes()[pos:]
+	ctx.Buffer.Truncate(pos)
+
+	// Extract a source sample to use for position information.
+	nn := n.FirstChild()
+	var start, stop int
+	for i := 0; i < nn.Lines().Len() && i < 2; i++ {
+		line := nn.Lines().At(i)
+		if i == 0 {
+			start = line.Start
+		}
+		stop = line.Stop
+	}
+
+	// We do not mutate the source, so this is safe.
+	sourceRef := src[start:stop]
+
+	ordinal := ctx.GetAndIncrementOrdinal(ast.KindBlockquote)
+
+	texts := string(text)
+	typ := typeRegular
+	alertType := resolveGitHubAlert(texts)
+	if alertType != "" {
+		typ = typeAlert
+	}
+
+	renderer := ctx.RenderContext().GetRenderer(hooks.BlockquoteRendererType, typ)
+	if renderer == nil {
+		return r.renderBlockquoteDefault(w, n, texts)
+	}
+
+	if typ == typeAlert {
+		// Trim preamble: <p>[!NOTE]<br>\n but preserve leading paragraph.
+		// We could possibly complicate this by moving this to the parser, but
+		// keep it simple for now.
+		texts = "<p>" + texts[strings.Index(texts, "\n")+1:]
+	}
+
+	bqctx := &blockquoteContext{
+		page:             ctx.DocumentContext().Document,
+		pageInner:        r.getPageInner(ctx),
+		typ:              typ,
+		alertType:        alertType,
+		text:             hstring.RenderedString(texts),
+		sourceRef:        sourceRef,
+		ordinal:          ordinal,
+		AttributesHolder: attributes.New(n.Attributes(), attributes.AttributesOwnerGeneral),
+	}
+
+	bqctx.createPos = func() htext.Position {
+		if resolver, ok := renderer.(hooks.ElementPositionResolver); ok {
+			return resolver.ResolvePosition(bqctx)
+		}
+
+		return htext.Position{
+			Filename:     ctx.DocumentContext().Filename,
+			LineNumber:   1,
+			ColumnNumber: 1,
+		}
+	}
+
+	cr := renderer.(hooks.BlockquoteRenderer)
+
+	err := cr.RenderBlockquote(
+		ctx.RenderContext().Ctx,
+		w,
+		bqctx,
+	)
+	if err != nil {
+		return ast.WalkContinue, herrors.NewFileErrorFromPos(err, bqctx.createPos())
+	}
+
+	return ast.WalkContinue, nil
+}
+
+func (r *htmlRenderer) getPageInner(rctx *render.Context) any {
+	pid := rctx.PeekPid()
+	if pid > 0 {
+		if lookup := rctx.DocumentContext().DocumentLookup; lookup != nil {
+			if v := rctx.DocumentContext().DocumentLookup(pid); v != nil {
+				return v
+			}
+		}
+	}
+	return rctx.DocumentContext().Document
+}
+
+// Code borrowed from goldmark's html renderer.
+func (r *htmlRenderer) renderBlockquoteDefault(
+	w util.BufWriter, n ast.Node, text string,
+) (ast.WalkStatus, error) {
+	if n.Attributes() != nil {
+		_, _ = w.WriteString("<blockquote")
+		html.RenderAttributes(w, n, html.BlockquoteAttributeFilter)
+		_ = w.WriteByte('>')
+	} else {
+		_, _ = w.WriteString("<blockquote>\n")
+	}
+
+	_, _ = w.WriteString(text)
+
+	_, _ = w.WriteString("</blockquote>\n")
+	return ast.WalkContinue, nil
+}
+
+type blockquoteContext struct {
+	page      any
+	pageInner any
+	text      hstring.RenderedString
+	typ       string
+	sourceRef []byte
+	alertType string
+	ordinal   int
+
+	// This is only used in error situations and is expensive to create,
+	// so delay creation until needed.
+	pos       htext.Position
+	posInit   sync.Once
+	createPos func() htext.Position
+
+	*attributes.AttributesHolder
+}
+
+func (c *blockquoteContext) Type() string {
+	return c.typ
+}
+
+func (c *blockquoteContext) AlertType() string {
+	return c.alertType
+}
+
+func (c *blockquoteContext) Page() any {
+	return c.page
+}
+
+func (c *blockquoteContext) PageInner() any {
+	return c.pageInner
+}
+
+func (c *blockquoteContext) Text() hstring.RenderedString {
+	return c.text
+}
+
+func (c *blockquoteContext) Ordinal() int {
+	return c.ordinal
+}
+
+func (c *blockquoteContext) Position() htext.Position {
+	c.posInit.Do(func() {
+		c.pos = c.createPos()
+	})
+	return c.pos
+}
+
+func (c *blockquoteContext) PositionerSourceTarget() []byte {
+	return c.sourceRef
+}
+
+var _ hooks.PositionerSourceTargetProvider = (*blockquoteContext)(nil)
+
+// https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#alerts
+// Five types:
+// [!NOTE], [!TIP], [!WARNING], [!IMPORTANT], [!CAUTION]
+var gitHubAlertRe = regexp.MustCompile(`^<p>\[!(NOTE|TIP|WARNING|IMPORTANT|CAUTION)\]`)
+
+// resolveGitHubAlert returns one of note, tip, warning, important or caution.
+// An empty string if no match.
+func resolveGitHubAlert(s string) string {
+	m := gitHubAlertRe.FindStringSubmatch(s)
+	if len(m) == 2 {
+		return strings.ToLower(m[1])
+	}
+	return ""
+}