--- /dev/null
+// Copyright 2019 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 hugolib
+
+import (
+ "bytes"
+ "fmt"
+ "path"
+ "testing"
+
+ "github.com/alecthomas/assert"
+ "github.com/gohugoio/hugo/parser"
+ "github.com/gohugoio/hugo/parser/metadecoders"
+ "github.com/stretchr/testify/require"
+)
+
+func BenchmarkCascade(b *testing.B) {
+ allLangs := []string{"en", "nn", "nb", "sv", "ab", "aa", "af", "sq", "kw", "da"}
+
+ for i := 1; i <= len(allLangs); i += 2 {
+ langs := allLangs[0:i]
+ b.Run(fmt.Sprintf("langs-%d", len(langs)), func(b *testing.B) {
+ assert := require.New(b)
+ b.StopTimer()
+ builders := make([]*sitesBuilder, b.N)
+ for i := 0; i < b.N; i++ {
+ builders[i] = newCascadeTestBuilder(b, langs)
+ }
+ b.StartTimer()
+
+ for i := 0; i < b.N; i++ {
+ builder := builders[i]
+ err := builder.BuildE(BuildCfg{})
+ assert.NoError(err)
+ first := builder.H.Sites[0]
+ assert.NotNil(first)
+ }
+ })
+ }
+}
+
+func TestCascade(t *testing.T) {
+ assert := assert.New(t)
+
+ allLangs := []string{"en", "nn", "nb", "sv"}
+
+ langs := allLangs[:3]
+
+ t.Run(fmt.Sprintf("langs-%d", len(langs)), func(t *testing.T) {
+ b := newCascadeTestBuilder(t, langs)
+ b.Build(BuildCfg{})
+
+ b.AssertFileContent("public/index.html", `
+ 12|taxonomy|categories/cool/_index.md|Cascade Category|cat.png|categories|HTML-|
+ 12|taxonomy|categories/catsect1|catsect1|cat.png|categories|HTML-|
+ 12|taxonomy|categories/funny|funny|cat.png|categories|HTML-|
+ 12|taxonomyTerm|categories/_index.md|My Categories|cat.png|categories|HTML-|
+ 32|taxonomy|categories/sad/_index.md|Cascade Category|sad.png|categories|HTML-|
+ 42|taxonomy|tags/blue|blue|home.png|tags|HTML-|
+ 42|section|sect3|Cascade Home|home.png|sect3|HTML-|
+ 42|taxonomyTerm|tags|Cascade Home|home.png|tags|HTML-|
+ 42|page|p2.md|Cascade Home|home.png|page|HTML-|
+ 42|page|sect2/p2.md|Cascade Home|home.png|sect2|HTML-|
+ 42|page|sect3/p1.md|Cascade Home|home.png|sect3|HTML-|
+ 42|taxonomy|tags/green|green|home.png|tags|HTML-|
+ 42|home|_index.md|Home|home.png|page|HTML-|
+ 42|page|p1.md|p1|home.png|page|HTML-|
+ 42|section|sect1/_index.md|Sect1|sect1.png|stype|HTML-|
+ 42|section|sect1/s1_2/_index.md|Sect1_2|sect1.png|stype|HTML-|
+ 42|page|sect1/s1_2/p1.md|Sect1_2_p1|sect1.png|stype|HTML-|
+ 42|page|sect1/s1_2/p2.md|Sect1_2_p2|sect1.png|stype|HTML-|
+ 42|section|sect2/_index.md|Sect2|home.png|sect2|HTML-|
+ 42|page|sect2/p1.md|Sect2_p1|home.png|sect2|HTML-|
+ 52|page|sect4/p1.md|Cascade Home|home.png|sect4|RSS-|
+ 52|section|sect4/_index.md|Sect4|home.png|sect4|RSS-|
+`)
+
+ // Check that type set in cascade gets the correct layout.
+ b.AssertFileContent("public/sect1/index.html", `stype list: Sect1`)
+ b.AssertFileContent("public/sect1/s1_2/p2/index.html", `stype single: Sect1_2_p2`)
+
+ // Check output formats set in cascade
+ b.AssertFileContent("public/sect4/index.xml", `<link>https://example.org/sect4/index.xml</link>`)
+ b.AssertFileContent("public/sect4/p1/index.xml", `<link>https://example.org/sect4/p1/index.xml</link>`)
+ assert.False(b.CheckExists("public/sect2/index.xml"))
+
+ // Check cascade into bundled page
+ b.AssertFileContent("public/bundle1/index.html", `Resources: bp1.md|home.png|`)
+
+ })
+
+}
+
+func newCascadeTestBuilder(t testing.TB, langs []string) *sitesBuilder {
+ p := func(m map[string]interface{}) string {
+ var yamlStr string
+
+ if len(m) > 0 {
+ var b bytes.Buffer
+
+ parser.InterfaceToConfig(m, metadecoders.YAML, &b)
+ yamlStr = b.String()
+ }
+
+ metaStr := "---\n" + yamlStr + "\n---"
+
+ return metaStr
+
+ }
+
+ createLangConfig := func(lang string) string {
+ const langEntry = `
+[languages.%s]
+`
+ return fmt.Sprintf(langEntry, lang)
+ }
+
+ createMount := func(lang string) string {
+ const mountsTempl = `
+[[module.mounts]]
+source="content/%s"
+target="content"
+lang="%s"
+`
+ return fmt.Sprintf(mountsTempl, lang, lang)
+ }
+
+ config := `
+baseURL = "https://example.org"
+defaultContentLanguage = "en"
+defaultContentLanguageInSubDir = false
+
+[languages]`
+ for _, lang := range langs {
+ config += createLangConfig(lang)
+ }
+
+ config += "\n\n[module]\n"
+ for _, lang := range langs {
+ config += createMount(lang)
+ }
+
+ b := newTestSitesBuilder(t).WithConfigFile("toml", config)
+
+ createContentFiles := func(lang string) {
+
+ withContent := func(filenameContent ...string) {
+ for i := 0; i < len(filenameContent); i += 2 {
+ b.WithContent(path.Join(lang, filenameContent[i]), filenameContent[i+1])
+ }
+ }
+
+ withContent(
+ "_index.md", p(map[string]interface{}{
+ "title": "Home",
+ "cascade": map[string]interface{}{
+ "title": "Cascade Home",
+ "ICoN": "home.png",
+ "outputs": []string{"HTML"},
+ "weight": 42,
+ },
+ }),
+ "p1.md", p(map[string]interface{}{
+ "title": "p1",
+ }),
+ "p2.md", p(map[string]interface{}{}),
+ "sect1/_index.md", p(map[string]interface{}{
+ "title": "Sect1",
+ "type": "stype",
+ "cascade": map[string]interface{}{
+ "title": "Cascade Sect1",
+ "icon": "sect1.png",
+ "type": "stype",
+ "categories": []string{"catsect1"},
+ },
+ }),
+ "sect1/s1_2/_index.md", p(map[string]interface{}{
+ "title": "Sect1_2",
+ }),
+ "sect1/s1_2/p1.md", p(map[string]interface{}{
+ "title": "Sect1_2_p1",
+ }),
+ "sect1/s1_2/p2.md", p(map[string]interface{}{
+ "title": "Sect1_2_p2",
+ }),
+ "sect2/_index.md", p(map[string]interface{}{
+ "title": "Sect2",
+ }),
+ "sect2/p1.md", p(map[string]interface{}{
+ "title": "Sect2_p1",
+ "categories": []string{"cool", "funny", "sad"},
+ "tags": []string{"blue", "green"},
+ }),
+ "sect2/p2.md", p(map[string]interface{}{}),
+ "sect3/p1.md", p(map[string]interface{}{}),
+ "sect4/_index.md", p(map[string]interface{}{
+ "title": "Sect4",
+ "cascade": map[string]interface{}{
+ "weight": 52,
+ "outputs": []string{"RSS"},
+ },
+ }),
+ "sect4/p1.md", p(map[string]interface{}{}),
+ "p2.md", p(map[string]interface{}{}),
+ "bundle1/index.md", p(map[string]interface{}{}),
+ "bundle1/bp1.md", p(map[string]interface{}{}),
+ "categories/_index.md", p(map[string]interface{}{
+ "title": "My Categories",
+ "cascade": map[string]interface{}{
+ "title": "Cascade Category",
+ "icoN": "cat.png",
+ "weight": 12,
+ },
+ }),
+ "categories/cool/_index.md", p(map[string]interface{}{}),
+ "categories/sad/_index.md", p(map[string]interface{}{
+ "cascade": map[string]interface{}{
+ "icon": "sad.png",
+ "weight": 32,
+ },
+ }),
+ )
+ }
+
+ createContentFiles("en")
+
+ b.WithTemplates("index.html", `
+
+{{ range .Site.Pages }}
+{{- .Weight }}|{{ .Kind }}|{{ path.Join .Path }}|{{ .Title }}|{{ .Params.icon }}|{{ .Type }}|{{ range .OutputFormats }}{{ .Name }}-{{ end }}|
+{{ end }}
+`,
+
+ "_default/single.html", "default single: {{ .Title }}|{{ .RelPermalink }}|{{ .Content }}|Resources: {{ range .Resources }}{{ .Name }}|{{ .Params.icon }}|{{ .Content }}{{ end }}",
+ "_default/list.html", "default list: {{ .Title }}",
+ "stype/single.html", "stype single: {{ .Title }}|{{ .RelPermalink }}|{{ .Content }}",
+ "stype/list.html", "stype list: {{ .Title }}",
+ )
+
+ return b
+}
b.WithSimpleConfigFile().
WithContent("page1.md", fmt.Sprintf(pageContent, 10), "page2.md", fmt.Sprintf(pageContent, 20)).
WithTemplatesAdded("index.html", `
-
{{ $p1 := index .Site.RegularPages 0 }}{{ $p2 := index .Site.RegularPages 1 }}
{{ $pages := slice }}
b.CreateSites().Build(BuildCfg{})
assert.Equal(1, len(b.H.Sites))
- require.Len(t, b.H.Sites[0].RegularPages(), 2)
+ assert.Len(b.H.Sites[0].RegularPages(), 2)
b.AssertFileContent("public/index.html",
"pages:2:page.Pages:Page(/page2.md)/Page(/page1.md)",
"fmt"
"runtime/trace"
+ "github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/output"
+ "golang.org/x/sync/errgroup"
+ "golang.org/x/sync/semaphore"
"github.com/pkg/errors"
}
-func (h *HugoSites) assemble(config *BuildCfg) error {
+func (h *HugoSites) assemble(bcfg *BuildCfg) error {
if len(h.Sites) > 1 {
// The first is initialized during process; initialize the rest
}
}
- if !config.whatChanged.source {
+ if !bcfg.whatChanged.source {
return nil
}
+ numWorkers := config.GetNumWorkerMultiplier()
+ sem := semaphore.NewWeighted(int64(numWorkers))
+ g, ctx := errgroup.WithContext(context.Background())
+
for _, s := range h.Sites {
- if err := s.assemblePagesMap(s); err != nil {
- return err
- }
+ s := s
+ g.Go(func() error {
+ err := sem.Acquire(ctx, 1)
+ if err != nil {
+ return err
+ }
+ defer sem.Release(1)
- if err := s.pagesMap.assembleTaxonomies(s); err != nil {
- return err
- }
+ if err := s.assemblePagesMap(s); err != nil {
+ return err
+ }
- if err := s.createWorkAllPages(); err != nil {
- return err
- }
+ if err := s.pagesMap.assemblePageMeta(); err != nil {
+ return err
+ }
+
+ if err := s.pagesMap.assembleTaxonomies(s); err != nil {
+ return err
+ }
+
+ if err := s.createWorkAllPages(); err != nil {
+ return err
+ }
+
+ return nil
+ })
+ }
+
+ if err := g.Wait(); err != nil {
+ return err
}
if err := h.createPageCollections(); err != nil {
p.resources = append(p.resources, r...)
}
-func (p *pageState) mapContent(meta *pageMeta) error {
+func (p *pageState) mapContent(bucket *pagesMapBucket, meta *pageMeta) error {
s := p.shortcodeState
}
}
- if err := meta.setMetadata(p, m); err != nil {
+ if err := meta.setMetadata(bucket, p, m); err != nil {
return err
}
// Laziliy initialized dependencies.
init *lazy.Init
+ metaInit sync.Once
+ metaInitFn func(bucket *pagesMapBucket) error
+
// All of these represents the common parts of a page.Page
maps.Scratcher
navigation.PageMenusProvider
return p.weight
}
-func (pm *pageMeta) setMetadata(p *pageState, frontmatter map[string]interface{}) error {
- if frontmatter == nil {
+func (pm *pageMeta) setMetadata(bucket *pagesMapBucket, p *pageState, frontmatter map[string]interface{}) error {
+ if frontmatter == nil && bucket.cascade == nil {
return errors.New("missing frontmatter data")
}
pm.params = make(map[string]interface{})
- // Needed for case insensitive fetching of params values
- maps.ToLower(frontmatter)
+ if frontmatter != nil {
+ // Needed for case insensitive fetching of params values
+ maps.ToLower(frontmatter)
+ if p.IsNode() {
+ // Check for any cascade define on itself.
+ if cv, found := frontmatter["cascade"]; found {
+ cvm := cast.ToStringMap(cv)
+ if bucket.cascade == nil {
+ bucket.cascade = cvm
+ } else {
+ for k, v := range cvm {
+ bucket.cascade[k] = v
+ }
+ }
+ }
+ }
+
+ if bucket != nil && bucket.cascade != nil {
+ for k, v := range bucket.cascade {
+ if _, found := frontmatter[k]; !found {
+ frontmatter[k] = v
+ }
+ }
+ }
+ } else {
+ frontmatter = make(map[string]interface{})
+ for k, v := range bucket.cascade {
+ frontmatter[k] = v
+ }
+ }
var mtime time.Time
- if p.File().FileInfo() != nil {
- mtime = p.File().FileInfo().ModTime()
+ var contentBaseName string
+ if !p.File().IsZero() {
+ contentBaseName = p.File().ContentBaseName()
+ if p.File().FileInfo() != nil {
+ mtime = p.File().FileInfo().ModTime()
+ }
}
var gitAuthorDate time.Time
Params: pm.params,
Dates: &pm.Dates,
PageURLs: &pm.urlPaths,
- BaseFilename: p.File().ContentBaseName(),
+ BaseFilename: contentBaseName,
ModTime: mtime,
GitAuthorDate: gitAuthorDate,
}
if isCJKLanguage != nil {
pm.isCJKLanguage = *isCJKLanguage
- } else if p.s.siteCfg.hasCJKLanguage {
+ } else if p.s.siteCfg.hasCJKLanguage && p.source.parsed != nil {
if cjkRe.Match(p.source.parsed.Input()) {
pm.isCJKLanguage = true
} else {
}
-func newPageFromMeta(metaProvider *pageMeta) (*pageState, error) {
+func newPageFromMeta(meta map[string]interface{}, metaProvider *pageMeta) (*pageState, error) {
if metaProvider.f == nil {
metaProvider.f = page.NewZeroFile(metaProvider.s.DistinctWarningLog)
}
return nil, err
}
- if err := metaProvider.applyDefaultValues(); err != nil {
- return nil, err
+ initMeta := func(bucket *pagesMapBucket) error {
+ if meta != nil || bucket != nil {
+ if err := metaProvider.setMetadata(bucket, ps, meta); err != nil {
+ return ps.wrapError(err)
+ }
+ }
+
+ if err := metaProvider.applyDefaultValues(); err != nil {
+ return err
+ }
+
+ return nil
+ }
+
+ if metaProvider.standalone {
+ initMeta(nil)
+ } else {
+ // Because of possible cascade keywords, we need to delay this
+ // until we have the complete page graph.
+ ps.metaInitFn = initMeta
}
ps.init.Add(func() (interface{}, error) {
func newPageStandalone(m *pageMeta, f output.Format) (*pageState, error) {
m.configuredOutputFormats = output.Formats{f}
m.standalone = true
- p, err := newPageFromMeta(m)
+ p, err := newPageFromMeta(nil, m)
if err != nil {
return nil, err
ps.shortcodeState = newShortcodeHandler(ps, ps.s, nil)
- if err := ps.mapContent(metaProvider); err != nil {
- return nil, ps.wrapError(err)
- }
+ ps.metaInitFn = func(bucket *pagesMapBucket) error {
+ if err := ps.mapContent(bucket, metaProvider); err != nil {
+ return ps.wrapError(err)
+ }
- if err := metaProvider.applyDefaultValues(); err != nil {
- return nil, err
+ if err := metaProvider.applyDefaultValues(); err != nil {
+ return err
+ }
+
+ return nil
}
ps.init.Add(func() (interface{}, error) {
}
func (c *PageCollections) assemblePagesMap(s *Site) error {
+
c.pagesMap = newPagesMap(s)
rootSections := make(map[string]bool)
var (
bucketsToRemove []string
rootBuckets []*pagesMapBucket
+ walkErr error
)
c.pagesMap.r.Walk(func(s string, v interface{}) bool {
bucket := v.(*pagesMapBucket)
- var parentBucket *pagesMapBucket
+ parentBucket := c.pagesMap.parentBucket(s)
- if s != "/" {
- _, parentv, found := c.pagesMap.r.LongestPrefix(path.Dir(s))
- if !found {
- panic(fmt.Sprintf("[BUG] parent bucket not found for %q", s))
- }
- parentBucket = parentv.(*pagesMapBucket)
+ if parentBucket != nil {
if !mainSectionsFound && strings.Count(s, "/") == 1 {
// Root section
return false
})
+ if walkErr != nil {
+ return walkErr
+ }
+
c.pagesMap.s.lastmod = siteLastmod
if !mainSectionsFound {
return home
}
+func (m *pagesMap) initPageMeta(p *pageState, bucket *pagesMapBucket) error {
+ var err error
+ p.metaInit.Do(func() {
+ if p.metaInitFn != nil {
+ err = p.metaInitFn(bucket)
+ }
+ })
+ return err
+}
+
+func (m *pagesMap) initPageMetaFor(prefix string, bucket *pagesMapBucket) error {
+ parentBucket := m.parentBucket(prefix)
+
+ m.mergeCascades(bucket, parentBucket)
+
+ if err := m.initPageMeta(bucket.owner, bucket); err != nil {
+ return err
+ }
+
+ if !bucket.view {
+ for _, p := range bucket.pages {
+ ps := p.(*pageState)
+ if err := m.initPageMeta(ps, bucket); err != nil {
+ return err
+ }
+
+ for _, p := range ps.resources.ByType(pageResourceType) {
+ if err := m.initPageMeta(p.(*pageState), bucket); err != nil {
+ return err
+ }
+ }
+ }
+ }
+
+ return nil
+}
+
func (m *pagesMap) createSectionIfNotExists(section string) {
key := m.cleanKey(section)
_, found := m.r.Get(key)
bucket.pages = append(bucket.pages, p)
}
-func (m *pagesMap) withEveryPage(f func(p *pageState)) {
- m.r.Walk(func(k string, v interface{}) bool {
- b := v.(*pagesMapBucket)
- f(b.owner)
- if !b.view {
- for _, p := range b.pages {
- f(p.(*pageState))
- }
- }
+func (m *pagesMap) assemblePageMeta() error {
+ var walkErr error
+ m.r.Walk(func(s string, v interface{}) bool {
+ bucket := v.(*pagesMapBucket)
+ if err := m.initPageMetaFor(s, bucket); err != nil {
+ walkErr = err
+ return true
+ }
return false
})
+
+ return walkErr
}
func (m *pagesMap) assembleTaxonomies(s *Site) error {
key := m.cleanKey(plural)
bucket = m.addBucketFor(key, n, nil)
+ if err := m.initPageMetaFor(key, bucket); err != nil {
+ return err
+ }
}
if bucket.meta == nil {
}
- addTaxonomy := func(singular, plural, term string, weight int, p page.Page) {
+ addTaxonomy := func(singular, plural, term string, weight int, p page.Page) error {
bkey := bucketKey{
plural: plural,
}
key := m.cleanKey(path.Join(plural, termKey))
b2 = m.addBucketFor(key, n, meta)
+ if err := m.initPageMetaFor(key, b2); err != nil {
+ return err
+ }
b1.pages = append(b1.pages, b2.owner)
taxonomyBuckets[bkey] = b2
b1.owner.m.Dates.UpdateDateAndLastmodIfAfter(p)
b2.owner.m.Dates.UpdateDateAndLastmodIfAfter(p)
+
+ return nil
}
m.r.Walk(func(k string, v interface{}) bool {
if vals != nil {
if v, ok := vals.([]string); ok {
for _, idx := range v {
- addTaxonomy(singular, plural, idx, weight, p)
+ if err := addTaxonomy(singular, plural, idx, weight, p); err != nil {
+ m.s.Log.ERROR.Printf("Failed to add taxonomy %q for %q: %s", plural, p.Path(), err)
+ }
}
} else if v, ok := vals.(string); ok {
- addTaxonomy(singular, plural, v, weight, p)
+ if err := addTaxonomy(singular, plural, v, weight, p); err != nil {
+ m.s.Log.ERROR.Printf("Failed to add taxonomy %q for %q: %s", plural, p.Path(), err)
+ }
} else {
m.s.Log.ERROR.Printf("Invalid %s in %q\n", plural, p.Path())
}
return "/" + key
}
-func (m *pagesMap) dump() {
- m.r.Walk(func(s string, v interface{}) bool {
- b := v.(*pagesMapBucket)
- fmt.Println("-------\n", s, ":", b.owner.Kind(), ":")
- if b.owner != nil {
- fmt.Println("Owner:", b.owner.Path())
+func (m *pagesMap) mergeCascades(b1, b2 *pagesMapBucket) {
+ if b1.cascade == nil {
+ b1.cascade = make(map[string]interface{})
+ }
+ if b2 != nil && b2.cascade != nil {
+ for k, v := range b2.cascade {
+ if _, found := b1.cascade[k]; !found {
+ b1.cascade[k] = v
+ }
}
- for _, p := range b.pages {
- fmt.Println(p.Path())
+ }
+}
+
+func (m *pagesMap) parentBucket(prefix string) *pagesMapBucket {
+ if prefix == "/" {
+ return nil
+ }
+ _, parentv, found := m.r.LongestPrefix(path.Dir(prefix))
+ if !found {
+ panic(fmt.Sprintf("[BUG] parent bucket not found for %q", prefix))
+ }
+ return parentv.(*pagesMapBucket)
+
+}
+
+func (m *pagesMap) withEveryPage(f func(p *pageState)) {
+ m.r.Walk(func(k string, v interface{}) bool {
+ b := v.(*pagesMapBucket)
+ f(b.owner)
+ if !b.view {
+ for _, p := range b.pages {
+ f(p.(*pageState))
+ }
}
+
return false
})
}
// Some additional metatadata attached to this node.
meta map[string]interface{}
+ // Cascading front matter.
+ cascade map[string]interface{}
+
owner *pageState // The branch node
// When disableKinds is enabled for this node.
}
func (s *Site) newTaxonomyPage(title string, sections ...string) *pageState {
- p, err := newPageFromMeta(&pageMeta{
- title: title,
- s: s,
- kind: page.KindTaxonomy,
- sections: sections,
- })
+ p, err := newPageFromMeta(
+ map[string]interface{}{"title": title},
+ &pageMeta{
+ s: s,
+ kind: page.KindTaxonomy,
+ sections: sections,
+ })
if err != nil {
panic(err)
}
func (s *Site) newPage(kind string, sections ...string) *pageState {
- p, err := newPageFromMeta(&pageMeta{
- s: s,
- kind: kind,
- sections: sections,
- })
+ p, err := newPageFromMeta(
+ map[string]interface{}{},
+ &pageMeta{
+ s: s,
+ kind: kind,
+ sections: sections,
+ })
if err != nil {
panic(err)
func (s *sitesBuilder) AssertFileContent(filename string, matches ...string) {
s.T.Helper()
content := s.FileContent(filename)
- for _, match := range matches {
- if !strings.Contains(content, match) {
- s.Fatalf("No match for %q in content for %s\n%s\n%q", match, filename, content, content)
+ for _, m := range matches {
+ lines := strings.Split(m, "\n")
+ for _, match := range lines {
+ match = strings.TrimSpace(match)
+ if match == "" {
+ continue
+ }
+ if !strings.Contains(content, match) {
+ s.Fatalf("No match for %q in content for %s\n%s\n%q", match, filename, content, content)
+ }
}
}
}
projects / brevno-suite / hugo / commitdiff