How to rewrite links?

[ivanjaros]

I need to rewrite links to local images because of dynamic access rules, how can I do that? I looked at the AST and extensions but it seems quite complicated and looks like it's mostly about adding support for custom syntax rather than being able to alter the source for specific elements. Is there an easy way to do this or do i have to use regular expressions and replace the links before passing the text to goldmark itself? I'd like to do it via extension to have the guarantee that i am altering the actual image link and not just a text that matches the regex but won't be rendered as such by goldmark(especially if there is image wrapped by a link).

[ivanjaros]

still active issue for me...

[abhinav]

You should be able to do this by adding an ASTTransformer to your parser.
Start with something like the following:

tr := &imageLinkRewriter{}
md := goldmark.New(
  goldmark.WithParserOptions(
    parser.WithASTTransformers(util.Prioritized(tr, 100)),
  ),
)

Where imageLinkRewriter is your transformer.
It should satisfy the ASTTransformer interface.
That lets you do anything to the document,
but typical usage involves traversing the document with ast.Walk.

For example,

type imageLinkRewriter struct{}

func (t *imageLinkRewriter) Transform(doc *ast.Document, reader text.Reader, pctx parser.Context) {
  ast.Walk(doc, func(node ast.Node, enter bool) (ast.WalkStatus, error) {
    if !enter {
      return ast.WalkContinue, nil
    }

    link, ok := node.(*ast.Link)
    if !ok {
      // Not a link. Leave it unchanged.
      return ast.WalkContinue, nil
    }

    // modify the link here

    // Don't descend into the link children.
    return ast.WalkSkipChildren, nil
  })
}

Link holds information about the link. It embeds baseLink, so that gives it the following fields:

Destination []byte
Title []byte

If you inspect and modify Destination, that will change what gets parsed and rendered.
For example:

u, err := url.Parse(string(link.Destination))
if err == nil && u.Host == "" && !path.IsAbs(u.Path) {
  // The URL is a relative path.
  link.Destination = whatever(u)
}

[ivanjaros]

thanks, it'll try it tomorrow.

[ivanjaros]

It works. But is there a way to pass proper context to it from md.Convert() ? I am looking at passing parser.NewContext() via Convert's parser.ParseOption but that is some custom md context, not proper context.

---

So far I am using this and it seems to be working:

	var opts []parser.ParseOption
	if len(ctx) == 1 {
		pCtx := parser.NewContext()
		pCtx.Set(contextKeyId, ctx[0]) // ctx key id constant is always 0
		opts = []parser.ParseOption{
			parser.WithContext(pCtx),
		}
	}

	buff := bytes.NewBuffer(make([]byte, 0, int(float32(len(input))*1.2))) // 120% of the input
	if err := r.md.Convert([]byte(input), buff, opts...); err != nil {
		println(err.Error()) // testing
		return ""
	}

and

type LinkRewriter struct {
	linkRewriter  func(ctx context.Context, dst []byte) []byte
	imageRewriter func(ctx context.Context, dst []byte) []byte
}

func (r *LinkRewriter) Transform(doc *ast.Document, reader text.Reader, pctx parser.Context) {
	_ = ast.Walk(doc, func(node ast.Node, enter bool) (ast.WalkStatus, error) {
		if !enter {
			return ast.WalkContinue, nil
		}

		ctx := context.Background()
		if ctxVal := pctx.Get(contextKeyId); ctxVal != nil {
			if typed, ok := ctxVal.(context.Context); ok {
				ctx = typed
			}
		}

		switch node.(type) {
		case *ast.Link:
			link := node.(*ast.Link)
			if r.linkRewriter != nil {
				link.Destination = r.linkRewriter(ctx, link.Destination)
				// link can have image children so continue
			}

		case *ast.Image:
			image := node.(*ast.Image)
			if r.imageRewriter != nil {
				image.Destination = r.imageRewriter(ctx, image.Destination)
				return ast.WalkSkipChildren, nil // image cannot have other images or links
			}
		}

		return ast.WalkContinue, nil
	})
}

[abhinav]

The parser.Context and context.Context are different types with different purposes, so you can't swap in one for the other.
parser.Context holds some amount of state for the Goldmark parser---it just happens to be called Context.

However, as you noted, you can use parser.Context to store arbitrary values and retrieve them later.
So the way you're doing this is a completely reasonable way of plumbing the context.Context through to your rewrite functions.

[ivanjaros]

ok, i just wasn't sure because it feels wrong to do it like this.