An inline shortcode's name must end with `.inline`, all lowercase.
E.g.:
```bash
{{< time.inline >}}{{ now }}{{< /time.inline >}}
```
The above will print the current date and time.
Note that an inline shortcode's inner content is parsed and executed as a Go text template with the same context as a regular shortcode template.
This means that the current page can be accessed via `.Page.Title` etc. This also means that there are no concept of "nested inline shortcodes".
The same inline shortcode can be reused later in the same content file, with different params if needed, using the self-closing syntax:
```
{{< time.inline />}}
```
Fixes #4011
// with the given offset from the original.
func ToFileErrorWithOffset(fe FileError, offset int) FileError {
pos := fe.Position()
- pos.LineNumber = pos.LineNumber + offset
+ return ToFileErrorWithLineNumber(fe, pos.LineNumber+offset)
+}
+
+// ToFileErrorWithOffset will return a new FileError with the given line number.
+func ToFileErrorWithLineNumber(fe FileError, lineNumber int) FileError {
+ pos := fe.Position()
+ pos.LineNumber = lineNumber
return &fileError{cause: fe, fileType: fe.Type(), position: pos}
}
v.SetDefault("debug", false)
v.SetDefault("disableFastRender", false)
v.SetDefault("timeout", 10000) // 10 seconds
-
+ v.SetDefault("enableInlineShortcodes", false)
return nil
}
"errors"
"fmt"
"html/template"
+ "path"
+
+ "github.com/gohugoio/hugo/common/herrors"
"reflect"
const shortcodePlaceholderPrefix = "HUGOSHORTCODE"
type shortcode struct {
- name string
- inner []interface{} // string or nested shortcode
- params interface{} // map or array
- ordinal int
- err error
- doMarkup bool
- pos int // the position in bytes in the source file
+ name string
+ isInline bool // inline shortcode. Any inner will be a Go template.
+ isClosing bool // whether a closing tag was provided
+ inner []interface{} // string or nested shortcode
+ params interface{} // map or array
+ ordinal int
+ err error
+ doMarkup bool
+ pos int // the position in bytes in the source file
}
func (sc shortcode) String() string {
placeholderID int
placeholderFunc func() string
+
+ enableInlineShortcodes bool
}
func (s *shortcodeHandler) nextPlaceholderID() int {
func newShortcodeHandler(p *Page) *shortcodeHandler {
s := &shortcodeHandler{
- p: p.withoutContent(),
- contentShortcodes: newOrderedMap(),
- shortcodes: newOrderedMap(),
- nameSet: make(map[string]bool),
- renderedShortcodes: make(map[string]string),
+ p: p.withoutContent(),
+ enableInlineShortcodes: p.s.enableInlineShortcodes,
+ contentShortcodes: newOrderedMap(),
+ shortcodes: newOrderedMap(),
+ nameSet: make(map[string]bool),
+ renderedShortcodes: make(map[string]string),
}
placeholderFunc := p.s.shortcodePlaceholderFunc
const innerCleanupRegexp = `\A<p>(.*)</p>\n\z`
const innerCleanupExpand = "$1"
-func prepareShortcodeForPage(placeholder string, sc *shortcode, parent *ShortcodeWithPage, p *PageWithoutContent) map[scKey]func() (string, error) {
-
+func (s *shortcodeHandler) prepareShortcodeForPage(placeholder string, sc *shortcode, parent *ShortcodeWithPage, p *PageWithoutContent) map[scKey]func() (string, error) {
m := make(map[scKey]func() (string, error))
lang := p.Lang()
+ if sc.isInline {
+ key := newScKeyFromLangAndOutputFormat(lang, p.outputFormats[0], placeholder)
+ if !s.enableInlineShortcodes {
+ m[key] = func() (string, error) {
+ return "", nil
+ }
+ } else {
+ m[key] = func() (string, error) {
+ return renderShortcode(key, sc, nil, p)
+ }
+ }
+
+ return m
+
+ }
+
for _, f := range p.outputFormats {
// The most specific template will win.
key := newScKeyFromLangAndOutputFormat(lang, f, placeholder)
parent *ShortcodeWithPage,
p *PageWithoutContent) (string, error) {
- tmpl := getShortcodeTemplateForTemplateKey(tmplKey, sc.name, p.s.Tmpl)
+ var tmpl tpl.Template
+
+ if sc.isInline {
+ templName := path.Join("_inline_shortcode", p.Path(), sc.name)
+ if sc.isClosing {
+ templStr := sc.inner[0].(string)
+
+ var err error
+ tmpl, err = p.s.TextTmpl.Parse(templName, templStr)
+ if err != nil {
+ fe := herrors.ToFileError("html", err)
+ l1, l2 := p.posFromPage(sc.pos).LineNumber, fe.Position().LineNumber
+ fe = herrors.ToFileErrorWithLineNumber(fe, l1+l2-1)
+ return "", p.errWithFileContext(fe)
+ }
+
+ } else {
+ // Re-use of shortcode defined earlier in the same page.
+ var found bool
+ tmpl, found = p.s.TextTmpl.Lookup(templName)
+ if !found {
+ return "", _errors.Errorf("no earlier definition of shortcode %q found", sc.name)
+ }
+ }
+ } else {
+ tmpl = getShortcodeTemplateForTemplateKey(tmplKey, sc.name, p.s.Tmpl)
+ }
+
if tmpl == nil {
p.s.Log.ERROR.Printf("Unable to locate template for shortcode %q in page %q", sc.name, p.Path())
return "", nil
}
- return renderShortcodeWithPage(tmpl, data)
+ s, err := renderShortcodeWithPage(tmpl, data)
+
+ if err != nil && sc.isInline {
+ fe := herrors.ToFileError("html", err)
+ l1, l2 := p.posFromPage(sc.pos).LineNumber, fe.Position().LineNumber
+ fe = herrors.ToFileErrorWithLineNumber(fe, l1+l2-1)
+ return "", fe
+ }
+
+ return s, err
}
// The delta represents new output format-versions of the shortcodes,
// the content from the previous output format, if any.
func (s *shortcodeHandler) updateDelta() bool {
s.init.Do(func() {
- s.contentShortcodes = createShortcodeRenderers(s.shortcodes, s.p.withoutContent())
+ s.contentShortcodes = s.createShortcodeRenderers(s.p.withoutContent())
})
if !s.p.shouldRenderTo(s.p.s.rc.Format) {
}
-func createShortcodeRenderers(shortcodes *orderedMap, p *PageWithoutContent) *orderedMap {
+func (s *shortcodeHandler) createShortcodeRenderers(p *PageWithoutContent) *orderedMap {
shortcodeRenderers := newOrderedMap()
- for _, k := range shortcodes.Keys() {
- v := shortcodes.getShortcode(k)
- prepared := prepareShortcodeForPage(k.(string), v, nil, p)
+ for _, k := range s.shortcodes.Keys() {
+ v := s.shortcodes.getShortcode(k)
+ prepared := s.prepareShortcodeForPage(k.(string), v, nil, p)
for kk, vv := range prepared {
shortcodeRenderers.Add(kk, vv)
}
currItem := pt.Next()
switch {
case currItem.IsLeftShortcodeDelim():
- sc.pos = currItem.Pos
+ if sc.pos == 0 {
+ sc.pos = currItem.Pos
+ }
next := pt.Peek()
if next.IsShortcodeClose() {
continue
case currItem.IsRightShortcodeDelim():
// we trust the template on this:
// if there's no inner, we're done
- if !isInner {
+ if !sc.isInline && !isInner {
return sc, nil
}
case currItem.IsShortcodeClose():
next := pt.Peek()
- if !isInner {
+ if !sc.isInline && !isInner {
if next.IsError() {
// return that error, more specific
continue
// self-closing
pt.Consume(1)
} else {
+ sc.isClosing = true
pt.Consume(2)
}
return sc, fail(_errors.Wrapf(err, "failed to handle template for shortcode %q", sc.name), currItem)
}
+ case currItem.IsInlineShortcodeName():
+ sc.name = currItem.ValStr()
+ sc.isInline = true
+
case currItem.IsShortcodeParam():
if !pt.IsValueNext() {
continue
err := tmpl.Execute(buffer, data)
isInnerShortcodeCache.RUnlock()
if err != nil {
- return "", data.Page.errorf(err, "failed to process shortcode")
+ return "", _errors.Wrap(err, "failed to process shortcode")
}
return buffer.String(), nil
}
)
}
+
+func TestInlineShortcodes(t *testing.T) {
+ for _, enableInlineShortcodes := range []bool{true, false} {
+ t.Run(fmt.Sprintf("enableInlineShortcodes=%t", enableInlineShortcodes),
+ func(t *testing.T) {
+ conf := fmt.Sprintf(`
+baseURL = "https://example.com"
+enableInlineShortcodes = %t
+`, enableInlineShortcodes)
+
+ b := newTestSitesBuilder(t)
+ b.WithConfigFile("toml", conf)
+ b.WithContent("page-md-shortcode.md", `---
+title: "Hugo"
+---
+
+FIRST:{{< myshort.inline "first" >}}
+Page: {{ .Page.Title }}
+Seq: {{ seq 3 }}
+Param: {{ .Get 0 }}
+{{< /myshort.inline >}}:END:
+
+SECOND:{{< myshort.inline "second" />}}:END
+
+`)
+
+ b.WithTemplatesAdded("layouts/_default/single.html", `
+CONTENT:{{ .Content }}
+`)
+
+ b.CreateSites().Build(BuildCfg{})
+
+ if enableInlineShortcodes {
+ b.AssertFileContent("public/page-md-shortcode/index.html",
+ "Page: Hugo",
+ "Seq: [1 2 3]",
+ "Param: first",
+ "Param: second",
+ )
+ } else {
+ b.AssertFileContent("public/page-md-shortcode/index.html",
+ "FIRST::END",
+ "SECOND::END",
+ )
+ }
+
+ })
+
+ }
+}
disabledKinds map[string]bool
+ enableInlineShortcodes bool
+
// Output formats defined in site config per Page Kind, or some defaults
// if not set.
// Output formats defined in Page front matter will override these.
// reset returns a new Site prepared for rebuild.
func (s *Site) reset() *Site {
return &Site{Deps: s.Deps,
- layoutHandler: output.NewLayoutHandler(),
- disabledKinds: s.disabledKinds,
- titleFunc: s.titleFunc,
- relatedDocsHandler: newSearchIndexHandler(s.relatedDocsHandler.cfg),
- siteRefLinker: s.siteRefLinker,
- outputFormats: s.outputFormats,
- rc: s.rc,
- outputFormatsConfig: s.outputFormatsConfig,
- frontmatterHandler: s.frontmatterHandler,
- mediaTypesConfig: s.mediaTypesConfig,
- Language: s.Language,
- owner: s.owner,
- publisher: s.publisher,
- siteConfig: s.siteConfig,
- PageCollections: newPageCollections()}
+ layoutHandler: output.NewLayoutHandler(),
+ disabledKinds: s.disabledKinds,
+ titleFunc: s.titleFunc,
+ relatedDocsHandler: newSearchIndexHandler(s.relatedDocsHandler.cfg),
+ siteRefLinker: s.siteRefLinker,
+ outputFormats: s.outputFormats,
+ rc: s.rc,
+ outputFormatsConfig: s.outputFormatsConfig,
+ frontmatterHandler: s.frontmatterHandler,
+ mediaTypesConfig: s.mediaTypesConfig,
+ Language: s.Language,
+ owner: s.owner,
+ publisher: s.publisher,
+ siteConfig: s.siteConfig,
+ enableInlineShortcodes: s.enableInlineShortcodes,
+ PageCollections: newPageCollections()}
}
}
s := &Site{
- PageCollections: c,
- layoutHandler: output.NewLayoutHandler(),
- Language: cfg.Language,
- disabledKinds: disabledKinds,
- titleFunc: titleFunc,
- relatedDocsHandler: newSearchIndexHandler(relatedContentConfig),
- outputFormats: outputFormats,
- rc: &siteRenderingContext{output.HTMLFormat},
- outputFormatsConfig: siteOutputFormatsConfig,
- mediaTypesConfig: siteMediaTypesConfig,
- frontmatterHandler: frontMatterHandler,
+ PageCollections: c,
+ layoutHandler: output.NewLayoutHandler(),
+ Language: cfg.Language,
+ disabledKinds: disabledKinds,
+ titleFunc: titleFunc,
+ relatedDocsHandler: newSearchIndexHandler(relatedContentConfig),
+ outputFormats: outputFormats,
+ rc: &siteRenderingContext{output.HTMLFormat},
+ outputFormatsConfig: siteOutputFormatsConfig,
+ mediaTypesConfig: siteMediaTypesConfig,
+ frontmatterHandler: frontMatterHandler,
+ enableInlineShortcodes: cfg.Language.GetBool("enableInlineShortcodes"),
}
return s, nil
return i.Type == tScName
}
+func (i Item) IsInlineShortcodeName() bool {
+ return i.Type == tScNameInline
+}
+
func (i Item) IsLeftShortcodeDelim() bool {
return i.Type == tLeftDelimScWithMarkup || i.Type == tLeftDelimScNoMarkup
}
tRightDelimScWithMarkup
tScClose
tScName
+ tScNameInline
tScParam
tScParamVal
type lexerShortcodeState struct {
currLeftDelimItem ItemType
currRightDelimItem ItemType
+ isInline bool
currShortcodeName string // is only set when a shortcode is in opened state
closingState int // > 0 = on its way to be closed
elementStepNum int // step number in element
for {
if l.isShortCodeStart() {
+ if l.isInline {
+ // If we're inside an inline shortcode, the only valid shortcode markup is
+ // the markup which closes it.
+ b := l.input[l.pos+3:]
+ end := indexNonWhiteSpace(b, '/')
+ if end != len(l.input)-1 {
+ b = bytes.TrimSpace(b[end+1:])
+ if end == -1 || !bytes.HasPrefix(b, []byte(l.currShortcodeName+" ")) {
+ return l.errorf("inline shortcodes do not support nesting")
+ }
+ }
+ }
+
if l.pos > l.start {
l.emit(tText)
}
func (l *pageLexer) isShortCodeStart() bool {
return l.hasPrefix(leftDelimScWithMarkup) || l.hasPrefix(leftDelimScNoMarkup)
+
+}
+
+func (l *pageLexer) posFirstNonWhiteSpace() int {
+ f := func(c rune) bool {
+ return !unicode.IsSpace(c)
+ }
+ return bytes.IndexFunc(l.input[l.pos:], f)
}
func lexIntroSection(l *pageLexer) stateFunc {
return lexInsideShortcode
}
+// Inline shortcodes has the form {{< myshortcode.inline >}}
+var inlineIdentifier = []byte("inline ")
+
// scans an alphanumeric inside shortcode
func lexIdentifierInShortcode(l *pageLexer) stateFunc {
lookForEnd := false
case isAlphaNumericOrHyphen(r):
// Allow forward slash inside names to make it possible to create namespaces.
case r == '/':
+ case r == '.':
+ l.isInline = l.hasPrefix(inlineIdentifier)
+ if !l.isInline {
+ return l.errorf("period in shortcode name only allowed for inline identifiers")
+ }
default:
l.backup()
word := string(l.input[l.start:l.pos])
l.currShortcodeName = word
l.openShortcodes[word] = true
l.elementStepNum++
- l.emit(tScName)
+ if l.isInline {
+ l.emit(tScNameInline)
+ } else {
+ l.emit(tScName)
+ }
break Loop
}
}
}
func lexEndOfShortcode(l *pageLexer) stateFunc {
+ l.isInline = false
if l.hasPrefix(l.currentRightShortcodeDelim()) {
return lexShortcodeRightDelim
}
return min
}
+func indexNonWhiteSpace(s []byte, in rune) int {
+ idx := bytes.IndexFunc(s, func(r rune) bool {
+ return !unicode.IsSpace(r)
+ })
+
+ if idx == -1 {
+ return -1
+ }
+
+ r, _ := utf8.DecodeRune(s[idx:])
+ if r == in {
+ return idx
+ }
+ return -1
+}
+
func isSpace(r rune) bool {
return r == ' ' || r == '\t'
}
tstRightMD = nti(tRightDelimScWithMarkup, "%}}")
tstSCClose = nti(tScClose, "/")
tstSC1 = nti(tScName, "sc1")
+ tstSC1Inline = nti(tScNameInline, "sc1.inline")
tstSC2 = nti(tScName, "sc2")
tstSC3 = nti(tScName, "sc3")
tstSCSlash = nti(tScName, "sc/sub")
tstParam1 = nti(tScParam, "param1")
tstParam2 = nti(tScParam, "param2")
tstVal = nti(tScParamVal, "Hello World")
+ tstText = nti(tText, "Hello World")
)
var shortCodeLexerTests = []lexerTest{
nti(tError, "comment must be closed")}},
{"commented out, misplaced close", `{{</* sc1 >}}*/`, []Item{
nti(tError, "comment must be closed")}},
+ // Inline shortcodes
+ {"basic inline", `{{< sc1.inline >}}Hello World{{< /sc1.inline >}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC1Inline, tstRightNoMD, tstEOF}},
+ {"basic inline with space", `{{< sc1.inline >}}Hello World{{< / sc1.inline >}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC1Inline, tstRightNoMD, tstEOF}},
+ {"inline self closing", `{{< sc1.inline >}}Hello World{{< /sc1.inline >}}Hello World{{< sc1.inline />}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSC1Inline, tstSCClose, tstRightNoMD, tstEOF}},
+ {"inline with nested shortcode (not supported)", `{{< sc1.inline >}}Hello World{{< sc1 >}}{{< /sc1.inline >}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, nti(tError, "inline shortcodes do not support nesting")}},
+ {"inline case mismatch", `{{< sc1.Inline >}}Hello World{{< /sc1.Inline >}}`, []Item{tstLeftNoMD, nti(tError, "period in shortcode name only allowed for inline identifiers")}},
}
func TestShortcodeLexer(t *testing.T) {
projects / brevno-suite / hugo / commitdiff