--- /dev/null
+#!/usr/bin/env bash
+diff <(gofmt -d .) <(printf '')
\ No newline at end of file
return strings.TrimPrefix(filepath.ToSlash(s), "/")
}
+// ToSlashTrimTrailing is just a filepath.ToSlash with an added / suffix trimmer.
+func ToSlashTrimTrailing(s string) string {
+ return strings.TrimSuffix(filepath.ToSlash(s), "/")
+}
+
// ToSlashPreserveLeading converts the path given to a forward slash separated path
// and preserves the leading slash if present trimming any trailing slash.
func ToSlashPreserveLeading(s string) string {
// This is only used for debugging purposes.
var InvocationCounter atomic.Int64
+
+// NewTrue returns a pointer to b.
+func NewBool(b bool) *bool {
+ return &b
+}
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/common/maps"
"github.com/gohugoio/hugo/common/paths"
+ "github.com/gohugoio/hugo/common/types"
"github.com/gohugoio/hugo/common/urls"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/config/privacy"
return nil, err
}
+ // Adjust Goldmark config defaults for multilingual, single-host sites.
+ if len(languagesConfig) > 1 && !isMultiHost && !clone.Markup.Goldmark.DuplicateResourceFiles {
+ if !clone.Markup.Goldmark.DuplicateResourceFiles {
+ if clone.Markup.Goldmark.RenderHooks.Link.EnableDefault == nil {
+ clone.Markup.Goldmark.RenderHooks.Link.EnableDefault = types.NewBool(true)
+ }
+ if clone.Markup.Goldmark.RenderHooks.Image.EnableDefault == nil {
+ clone.Markup.Goldmark.RenderHooks.Image.EnableDefault = types.NewBool(true)
+ }
+ }
+ }
+
langConfigMap[k] = clone
case maps.ParamsMergeStrategy:
default:
package hugolib
import (
+ "strings"
"testing"
)
P1 Fragments: [b c z]
`)
}
+
+func TestDefaultRenderHooksMultilingual(t *testing.T) {
+ files := `
+-- hugo.toml --
+baseURL = "https://example.org"
+disableKinds = ["taxonomy", "term", "RSS", "sitemap", "robotsTXT"]
+defaultContentLanguage = "nn"
+defaultContentLanguageInSubdir = true
+[markup]
+[markup.goldmark]
+duplicateResourceFiles = false
+[markup.goldmark.renderhooks]
+[markup.goldmark.renderhooks.link]
+#enableDefault = false
+[markup.goldmark.renderhooks.image]
+#enableDefault = false
+[languages]
+[languages.en]
+weight = 1
+[languages.nn]
+weight = 2
+-- content/p1/index.md --
+---
+title: "p1"
+---
+[P2](p2)
+
+-- content/p2/index.md --
+---
+title: "p2"
+---
+[P1](p1)
+
+-- content/p1/index.en.md --
+---
+title: "p1 en"
+---
+[P2](p2)
+
+-- content/p2/index.en.md --
+---
+title: "p2 en"
+---
+[P1](p1)
+
+
+-- content/p1/pixel.nn.png --
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
+-- content/p2/pixel.png --
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
+-- layouts/_default/single.html --
+{{ .Title }}|{{ .Content }}|$
+
+`
+
+ t.Run("Default multilingual", func(t *testing.T) {
+ b := Test(t, files)
+
+ b.AssertFileContent("public/nn/p1/index.html",
+ "p1|<p><a href=\"/nn/p2/\">P2</a\n></p>", "<img alt=\"Pixel\" src=\"/nn/p1/pixel.nn.png\">")
+ b.AssertFileContent("public/en/p1/index.html",
+ "p1 en|<p><a href=\"/en/p2/\">P2</a\n></p>", "<img alt=\"Pixel\" src=\"/nn/p1/pixel.nn.png\">")
+ })
+
+ t.Run("Disabled", func(t *testing.T) {
+ b := Test(t, strings.ReplaceAll(files, "#enableDefault = false", "enableDefault = false"))
+
+ b.AssertFileContent("public/nn/p1/index.html",
+ "p1|<p><a href=\"p2\">P2</a>", "<img src=\"pixel.png\" alt=\"Pixel\">")
+ })
+}
if err != nil {
panic(err)
}
+ if found {
+ if isitp, ok := templ.(tpl.IsInternalTemplateProvider); ok && isitp.IsInternalTemplate() {
+ renderHookConfig := pco.po.p.s.conf.Markup.Goldmark.RenderHooks
+ switch templ.Name() {
+ case "_default/_markup/render-link.html":
+ if !renderHookConfig.Link.IsEnableDefault() {
+ return nil, false
+ }
+ case "_default/_markup/render-image.html":
+ if !renderHookConfig.Image.IsEnableDefault() {
+ return nil, false
+ }
+ }
+ }
+ }
return templ, found
}
}
func (c *pageFinder) getPage(context page.Page, ref string) (page.Page, error) {
- n, err := c.getContentNode(context, false, filepath.ToSlash(ref))
+ n, err := c.getContentNode(context, false, paths.ToSlashTrimTrailing(ref))
if err != nil {
return nil, err
}
func TestPageGetPageVariations(t *testing.T) {
files := `
-- hugo.toml --
+-- content/s1/_index.md --
+---
+title: s1 section
+---
-- content/s1/p1/index.md --
---
title: p1
title: p2_root
---
-- layouts/index.html --
+/s1: {{ with .GetPage "/s1" }}{{ .Title }}{{ end }}|
+/s1/: {{ with .GetPage "/s1/" }}{{ .Title }}{{ end }}|
/s1/p2.md: {{ with .GetPage "/s1/p2.md" }}{{ .Title }}{{ end }}|
/s1/p2: {{ with .GetPage "/s1/p2" }}{{ .Title }}{{ end }}|
/s1/p1/index.md: {{ with .GetPage "/s1/p1/index.md" }}{{ .Title }}{{ end }}|
b := Test(t, files)
b.AssertFileContent("public/index.html", `
+/s1: s1 section|
+/s1/: s1 section|
/s1/p2.md: p2|
/s1/p2: p2|
/s1/p1/index.md: p1|
// Run gofmt linter
func Fmt() error {
- if !isGoLatest() {
+ if !isGoLatest() && !isUnix() {
return nil
}
- pkgs, err := hugoPackages()
+ s, err := sh.Output("./check_gofmt.sh")
if err != nil {
- return err
- }
- failed := false
- first := true
- for _, pkg := range pkgs {
- files, err := filepath.Glob(filepath.Join(pkg, "*.go"))
- if err != nil {
- return nil
- }
- for _, f := range files {
- // gofmt doesn't exit with non-zero when it finds unformatted code
- // so we have to explicitly look for output, and if we find any, we
- // should fail this target.
- s, err := sh.Output("gofmt", "-l", f)
- if err != nil {
- fmt.Printf("ERROR: running gofmt on %q: %v\n", f, err)
- failed = true
- }
- if s != "" {
- if first {
- fmt.Println("The following files are not gofmt'ed:")
- first = false
- }
- failed = true
- fmt.Println(s)
- }
- }
- }
- if failed {
- return errors.New("improperly formatted go files")
+ fmt.Println(s)
+ return fmt.Errorf("gofmt needs to be run: %s", err)
}
+
return nil
}
return strings.Contains(runtime.Version(), "1.21")
}
+func isUnix() bool {
+ return runtime.GOOS != "windows"
+}
+
func isCI() bool {
return os.Getenv("CI") != ""
}
// Config configures Goldmark.
type Config struct {
- DuplicateResourceFiles bool
Renderer Renderer
Parser Parser
Extensions Extensions
+ DuplicateResourceFiles bool
+ RenderHooks RenderHooks
+}
+
+// RenderHooks contains configuration for Goldmark render hooks.
+type RenderHooks struct {
+ Image ImageRenderHook
+ Link LinkRenderHook
+}
+
+// ImageRenderHook contains configuration for the image render hook.
+type ImageRenderHook struct {
+ // Enable the default image render hook.
+ // We need to know if it is set or not, hence the pointer.
+ EnableDefault *bool
+}
+
+func (h ImageRenderHook) IsEnableDefault() bool {
+ return h.EnableDefault != nil && *h.EnableDefault
+}
+
+// LinkRenderHook contains configuration for the link render hook.
+type LinkRenderHook struct {
+ // Disable the default image render hook.
+ // We need to know if it is set or not, hence the pointer.
+ EnableDefault *bool
+}
+
+func (h LinkRenderHook) IsEnableDefault() bool {
+ return h.EnableDefault != nil && *h.EnableDefault
}
type Extensions struct {
Filename() string
}
+type IsInternalTemplateProvider interface {
+ IsInternalTemplate() bool
+}
+
type ParseInfo struct {
// Set for shortcode templates with any {{ .Inner }}
IsInner bool
--- /dev/null
+{{- $u := urls.Parse .Destination -}}
+{{- $src := $u.String -}}
+{{- if not $u.IsAbs -}}
+ {{- with or (.Page.Resources.Get $u.Path) (resources.Get $u.Path) -}}
+ {{- $src = .RelPermalink -}}
+ {{- end -}}
+{{- end -}}
+{{- $attributes := dict "alt" .Text "src" $src "title" .Title -}}
+<img
+ {{- range $k, $v := $attributes -}}
+ {{- if $v -}}
+ {{- printf " %s=%q" $k $v | safeHTMLAttr -}}
+ {{- end -}}
+ {{- end -}}>
+{{- /**/ -}}
--- /dev/null
+{{- $u := urls.Parse .Destination -}}
+{{- $href := $u.String -}}
+{{- if not $u.IsAbs -}}
+ {{- with or
+ ($.Page.GetPage $u.Path)
+ ($.Page.Resources.Get $u.Path)
+ (resources.Get $u.Path)
+ -}}
+ {{- $href = .RelPermalink -}}
+ {{- with $u.RawQuery -}}
+ {{- $href = printf "%s?%s" $href . -}}
+ {{- end -}}
+ {{- with $u.Fragment -}}
+ {{- $href = printf "%s#%s" $href . -}}
+ {{- end -}}
+ {{- end -}}
+{{- end -}}
+{{- $attributes := dict "href" $href "title" .Title -}}
+<a
+ {{- range $k, $v := $attributes -}}
+ {{- if $v -}}
+ {{- printf " %s=%q" $k $v | safeHTMLAttr -}}
+ {{- end -}}
+ {{- end -}}
+ >{{ .Text | safeHTML }}</a>
+{{- /**/ -}}
shortcodesPathPrefix = "shortcodes/"
internalPathPrefix = "_internal/"
+ embeddedPathPrefix = "_embedded/"
baseFileBase = "baseof"
)
func (t *templateHandler) newTemplateInfo(name, tpl string) templateInfo {
var isText bool
+ var isEmbedded bool
+
+ if strings.HasPrefix(name, embeddedPathPrefix) {
+ isEmbedded = true
+ name = strings.TrimPrefix(name, embeddedPathPrefix)
+ }
+
name, isText = t.nameIsText(name)
return templateInfo{
- name: name,
- isText: isText,
- template: tpl,
+ name: name,
+ isText: isText,
+ isEmbedded: isEmbedded,
+ template: tpl,
}
}
}
if _, found := t.Lookup(templateName); !found {
- if err := t.AddTemplate(templateName, templ); err != nil {
+ if err := t.AddTemplate(embeddedPathPrefix+templateName, templ); err != nil {
return err
}
}
// TODO(bep) avoid reparsing these aliases
for _, alias := range aliases {
alias = internalPathPrefix + alias
- if err := t.AddTemplate(alias, templ); err != nil {
+ if err := t.AddTemplate(embeddedPathPrefix+alias, templ); err != nil {
return err
}
}
return ts, nil
}
+var _ tpl.IsInternalTemplateProvider = (*templateState)(nil)
+
type templateState struct {
tpl.Template
baseInfo templateInfo // Set when a base template is used.
}
+func (t *templateState) IsInternalTemplate() bool {
+ return t.info.isEmbedded
+}
+
func (t *templateState) GetIdentity() identity.Identity {
return t.id
}
var _ identity.Identity = (*templateInfo)(nil)
type templateInfo struct {
- name string
- template string
- isText bool // HTML or plain text template.
+ name string
+ template string
+ isText bool // HTML or plain text template.
+ isEmbedded bool
meta *hugofs.FileMeta
}
projects / brevno-suite / hugo / commitdiff