diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000000..efbc710bea0 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "autoHide.autoHidePanel": false +} \ No newline at end of file diff --git a/bench.sh b/bench.sh deleted file mode 100755 index c6a20a7e315..00000000000 --- a/bench.sh +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env bash - -# allow user to override go executable by running as GOEXE=xxx make ... -GOEXE="${GOEXE-go}" - -# Convenience script to -# - For a given branch -# - Run benchmark tests for a given package -# - Do the same for master -# - then compare the two runs with benchcmp - -benchFilter=".*" - -if (( $# < 2 )); - then - echo "USAGE: ./bench.sh (and (regexp, optional))" - exit 1 -fi - - - -if [ $# -eq 3 ]; then - benchFilter=$3 -fi - - -BRANCH=$1 -PACKAGE=$2 - -git checkout $BRANCH -"${GOEXE}" test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-$BRANCH.txt - -git checkout master -"${GOEXE}" test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-master.txt - - -benchcmp /tmp/bench-$PACKAGE-master.txt /tmp/bench-$PACKAGE-$BRANCH.txt diff --git a/benchSite.sh b/benchSite.sh deleted file mode 100755 index aae21231c7f..00000000000 --- a/benchSite.sh +++ /dev/null @@ -1,12 +0,0 @@ -#!/bin/bash - -# allow user to override go executable by running as GOEXE=xxx make ... -GOEXE="${GOEXE-go}" - -# Send in a regexp matching the benchmarks you want to run, i.e. './benchSite.sh "YAML"'. -# Note the quotes, which will be needed for more complex expressions. -# The above will run all variations, but only for front matter YAML. - -echo "Running with BenchmarkSiteBuilding/${1}" - -"${GOEXE}" test -run="NONE" -bench="BenchmarkSiteBuilding/${1}" -test.benchmem=true ./hugolib -memprofile mem.prof -count 3 -cpuprofile cpu.prof diff --git a/benchbep.sh b/benchbep.sh index efd616c8859..a58b12321c5 100755 --- a/benchbep.sh +++ b/benchbep.sh @@ -1 +1 @@ -gobench -package=./hugolib -bench="BenchmarkSiteNew/Deep_content_tree" \ No newline at end of file +gobench --package ./hugolib --bench "BenchmarkSiteNew/Regular_Deep" -base v0.89.4 \ No newline at end of file diff --git a/bepdock.sh b/bepdock.sh deleted file mode 100755 index a7ac0c63969..00000000000 --- a/bepdock.sh +++ /dev/null @@ -1 +0,0 @@ -docker run --rm --mount type=bind,source="$(pwd)",target=/hugo -w /hugo -i -t bepsays/ci-goreleaser:1.11-2 /bin/bash \ No newline at end of file diff --git a/cache/filecache/filecache.go b/cache/filecache/filecache.go index 5a87382aeaf..32f5affb390 100644 --- a/cache/filecache/filecache.go +++ b/cache/filecache/filecache.go @@ -15,6 +15,7 @@ package filecache import ( "bytes" + "context" "errors" "io" "io/ioutil" @@ -163,7 +164,7 @@ func (c *Cache) ReadOrCreate(id string, // GetOrCreate tries to get the file with the given id from cache. If not found or expired, create will // be invoked and the result cached. // This method is protected by a named lock using the given id as identifier. -func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (ItemInfo, io.ReadCloser, error) { +func (c *Cache) GetOrCreate(ctx context.Context, id string, create func() (io.ReadCloser, error)) (ItemInfo, io.ReadCloser, error) { id = cleanID(id) c.nlocker.Lock(id) diff --git a/cache/filecache/filecache_test.go b/cache/filecache/filecache_test.go index 6a051a26495..72b2c7742e2 100644 --- a/cache/filecache/filecache_test.go +++ b/cache/filecache/filecache_test.go @@ -14,6 +14,7 @@ package filecache import ( + "context" "errors" "fmt" "io" @@ -134,7 +135,7 @@ dir = ":cacheDir/c" for _, ca := range []*Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} { for i := 0; i < 2; i++ { - info, r, err := ca.GetOrCreate("a", rf("abc")) + info, r, err := ca.GetOrCreate(context.TODO(), "a", rf("abc")) c.Assert(err, qt.IsNil) c.Assert(r, qt.Not(qt.IsNil)) c.Assert(info.Name, qt.Equals, "a") @@ -152,7 +153,7 @@ dir = ":cacheDir/c" c.Assert(err, qt.IsNil) c.Assert(string(b), qt.Equals, "abc") - _, r, err = ca.GetOrCreate("a", rf("bcd")) + _, r, err = ca.GetOrCreate(context.TODO(), "a", rf("bcd")) c.Assert(err, qt.IsNil) b, _ = ioutil.ReadAll(r) r.Close() @@ -229,7 +230,7 @@ dir = "/cache/c" ca := caches.Get(cacheName) c.Assert(ca, qt.Not(qt.IsNil)) filename, data := filenameData(i) - _, r, err := ca.GetOrCreate(filename, func() (io.ReadCloser, error) { + _, r, err := ca.GetOrCreate(context.TODO(), filename, func() (io.ReadCloser, error) { return hugio.ToReadCloser(strings.NewReader(data)), nil }) c.Assert(err, qt.IsNil) diff --git a/cache/memcache/memcache.go b/cache/memcache/memcache.go new file mode 100644 index 00000000000..c8e1c6ca1e3 --- /dev/null +++ b/cache/memcache/memcache.go @@ -0,0 +1,525 @@ +// Copyright 2020 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 memcache provides the core memory cache used in Hugo. +package memcache + +import ( + "context" + "math" + "path" + "regexp" + "runtime" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/gohugoio/hugo/identity" + "github.com/gohugoio/hugo/tpl" + + "github.com/gohugoio/hugo/media" + + "github.com/gohugoio/hugo/config" + + "github.com/gohugoio/hugo/resources/resource" + + "github.com/gohugoio/hugo/helpers" + + "github.com/BurntSushi/locker" + "github.com/karlseguin/ccache/v2" +) + +const ( + ClearOnRebuild ClearWhen = iota + 1 + ClearOnChange + ClearNever +) + +const ( + cacheVirtualRoot = "_root/" +) + +var ( + + // Consider a change in files matching this expression a "JS change". + isJSFileRe = regexp.MustCompile(`\.(js|ts|jsx|tsx)`) + + // Consider a change in files matching this expression a "CSS change". + isCSSFileRe = regexp.MustCompile(`\.(css|scss|sass)`) + + // These config files are tightly related to CSS editing, so consider + // a change to any of them a "CSS change". + isCSSConfigRe = regexp.MustCompile(`(postcss|tailwind)\.config\.js`) +) + +const unknownExtension = "unkn" + +// New creates a new cache. +func New(conf Config) *Cache { + if conf.TTL == 0 { + conf.TTL = time.Second * 33 + } + if conf.CheckInterval == 0 { + conf.CheckInterval = time.Second * 2 + } + if conf.MaxSize == 0 { + conf.MaxSize = 100000 + } + if conf.ItemsToPrune == 0 { + conf.ItemsToPrune = 200 + } + + var m runtime.MemStats + runtime.ReadMemStats(&m) + + stats := &stats{ + memstatsStart: m, + maxSize: conf.MaxSize, + availableMemory: config.GetMemoryLimit(), + } + + conf.MaxSize = stats.adjustMaxSize(nil) + + c := &Cache{ + conf: conf, + cache: ccache.Layered(ccache.Configure().MaxSize(conf.MaxSize).ItemsToPrune(conf.ItemsToPrune)), + getters: make(map[string]*getter), + ttl: conf.TTL, + stats: stats, + nlocker: locker.NewLocker(), + } + + c.stop = c.start() + + return c +} + +// CleanKey turns s into a format suitable for a cache key for this package. +// The key will be a Unix-styled path without any leading slash. +// If the input string does not contain any slash, a root will be prepended. +// If the input string does not contain any ".", a dummy file suffix will be appended. +// These are to make sure that they can effectively partake in the "cache cleaning" +// strategy used in server mode. +func CleanKey(s string) string { + s = path.Clean(helpers.ToSlashTrimLeading(s)) + if !strings.ContainsRune(s, '/') { + s = cacheVirtualRoot + s + } + if !strings.ContainsRune(s, '.') { + s += "." + unknownExtension + } + + return s +} + +// InsertKeyPathElement inserts the given element after the first '/' in key. +func InsertKeyPathElements(key string, elements ...string) string { + slashIdx := strings.Index(key, "/") + return key[:slashIdx] + "/" + path.Join(elements...) + key[slashIdx:] +} + +// Cache configures a cache. +type Cache struct { + mu sync.Mutex + getters map[string]*getter + + conf Config + cache *ccache.LayeredCache + + ttl time.Duration + nlocker *locker.Locker + + stats *stats + stopOnce sync.Once + stop func() +} + +// Clear clears the cache state. +// This method is not thread safe. +func (c *Cache) Clear() { + c.nlocker = locker.NewLocker() + for _, g := range c.getters { + g.c.DeleteAll(g.partition) + } +} + +// ClearOn clears all the caches given a eviction strategy and (optional) a +// change set. +// This method is not thread safe. +func (c *Cache) ClearOn(when ClearWhen, changeset ...identity.Identity) { + if when == 0 { + panic("invalid ClearWhen") + } + + // Fist pass. + for _, g := range c.getters { + if g.clearWhen == ClearNever { + continue + } + + if g.clearWhen == when { + // Clear all. + g.Clear() + continue + } + + shouldDelete := func(key string, e Entry) bool { + // We always clear elements marked as stale. + if resource.IsStaleAny(e, e.Value) { + return true + } + + if e.ClearWhen == ClearNever { + return false + } + + if e.ClearWhen == when && e.ClearWhen == ClearOnRebuild { + return true + } + + // Now check if this entry has changed based on the changeset + // based on filesystem events. + + if len(changeset) == 0 { + // Nothing changed. + return false + } + + var notNotDependent bool + identity.WalkIdentities(e.Value, func(id2 identity.Identity) bool { + for _, id := range changeset { + if !identity.IsNotDependent(id2, id) { + // It's probably dependent, evict from cache. + notNotDependent = true + return true + } + } + return false + }) + + return notNotDependent + } + + // Two passes, the last one to catch any leftover values marked stale in the first. + g.c.cache.DeleteFunc(g.partition, func(key string, item *ccache.Item) bool { + e := item.Value().(Entry) + if shouldDelete(key, e) { + resource.MarkStale(e.Value) + return true + } + return false + }) + + } + + // Second pass: Clear all entries marked as stale in the first. + for _, g := range c.getters { + if g.clearWhen == ClearNever || g.clearWhen == when { + continue + } + + g.c.cache.DeleteFunc(g.partition, func(key string, item *ccache.Item) bool { + e := item.Value().(Entry) + return resource.IsStaleAny(e, e.Value) + }) + } +} + +type resourceTP interface { + ResourceTarget() resource.Resource +} + +/* + assets: css/mystyles.scss + content: blog/mybundle/data.json +*/ +func shouldEvict(key string, e Entry, when ClearWhen, changeset ...identity.PathIdentity) bool { + return false +} + +func (c *Cache) DeleteAll(primary string) bool { + return c.cache.DeleteAll(primary) +} + +func (c *Cache) GetDropped() int { + return c.cache.GetDropped() +} + +func (c *Cache) GetOrCreatePartition(partition string, clearWhen ClearWhen) Getter { + if clearWhen == 0 { + panic("GetOrCreatePartition: invalid ClearWhen") + } + c.mu.Lock() + defer c.mu.Unlock() + + g, found := c.getters[partition] + if found { + if g.clearWhen != clearWhen { + panic("GetOrCreatePartition called with the same partition but different clearing strategy.") + } + return g + } + + g = &getter{ + partition: partition, + c: c, + clearWhen: clearWhen, + } + + c.getters[partition] = g + + return g +} + +func (c *Cache) Stop() { + c.stopOnce.Do(func() { + c.stop() + c.cache.Stop() + }) +} + +func (c *Cache) start() func() { + ticker := time.NewTicker(c.conf.CheckInterval) + quit := make(chan struct{}) + + checkAndAdjustMaxSize := func() { + var m runtime.MemStats + cacheDropped := c.GetDropped() + c.stats.decr(cacheDropped) + + runtime.ReadMemStats(&m) + c.stats.memstatsCurrent = m + c.stats.adjustMaxSize(c.cache.SetMaxSize) + + // fmt.Printf("\n\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\nMemCacheDropped = %d\n\n", helpers.FormatByteCount(m.Alloc), helpers.FormatByteCount(m.TotalAlloc), helpers.FormatByteCount(m.Sys), m.NumGC, cacheDropped) + } + go func() { + for { + select { + case <-ticker.C: + checkAndAdjustMaxSize() + case <-quit: + ticker.Stop() + return + } + } + }() + + return func() { + close(quit) + } +} + +// get tries to get the value with the given cache paths. +// It returns nil if not found +func (c *Cache) get(primary, secondary string) (interface{}, error) { + if v := c.cache.Get(primary, secondary); v != nil { + e := v.Value().(Entry) + if !resource.IsStaleAny(e, e.Value) { + return e.Value, e.Err + } + } + return nil, nil +} + +// getOrCreate tries to get the value with the given cache paths, if not found +// create will be called and the result cached. +// +// This method is thread safe. +func (c *Cache) getOrCreate(primary, secondary string, create func() Entry) (interface{}, error) { + if v, err := c.get(primary, secondary); v != nil || err != nil { + return v, err + } + + // The provided create function may be a relatively time consuming operation, + // and there will in the commmon case be concurrent requests for the same key'd + // resource, so make sure we pause these until the result is ready. + path := primary + secondary + c.nlocker.Lock(path) + defer c.nlocker.Unlock(path) + + // Try again. + if v := c.cache.Get(primary, secondary); v != nil { + e := v.Value().(Entry) + if !resource.IsStaleAny(e, e.Value) { + return e.Value, e.Err + } + } + + // Create it and store it in cache. + entry := create() + + if entry.Err != nil { + entry.ClearWhen = ClearOnRebuild + } else if entry.ClearWhen == 0 { + panic("entry: invalid ClearWhen") + } + + entry.size = 1 // For now. + + c.cache.Set(primary, secondary, entry, c.ttl) + c.stats.incr(1) + + return entry.Value, entry.Err +} + +func (c *Cache) trackDependencyIfRunning(ctx context.Context, v interface{}) { + if !c.conf.Running { + return + } + + tpl.AddIdentiesToDataContext(ctx, v) +} + +type ClearWhen int + +type Config struct { + CheckInterval time.Duration + MaxSize int64 + ItemsToPrune uint32 + TTL time.Duration + Running bool +} + +type Entry struct { + Value interface{} + size int64 + Err error + StaleFunc func() bool + ClearWhen +} + +func (e Entry) Size() int64 { + return e.size +} + +func (e Entry) IsStale() bool { + return e.StaleFunc != nil && e.StaleFunc() +} + +type Getter interface { + Clear() + Get(ctx context.Context, path string) (interface{}, error) + GetOrCreate(ctx context.Context, path string, create func() Entry) (interface{}, error) +} + +type getter struct { + c *Cache + partition string + + clearWhen ClearWhen +} + +func (g *getter) Clear() { + g.c.DeleteAll(g.partition) +} + +func (g *getter) Get(ctx context.Context, path string) (interface{}, error) { + v, err := g.c.get(g.partition, path) + if err != nil { + return nil, err + } + + g.c.trackDependencyIfRunning(ctx, v) + + return v, nil +} + +func (g *getter) GetOrCreate(ctx context.Context, path string, create func() Entry) (interface{}, error) { + v, err := g.c.getOrCreate(g.partition, path, create) + if err != nil { + return nil, err + } + + g.c.trackDependencyIfRunning(ctx, v) + + return v, nil +} + +type stats struct { + memstatsStart runtime.MemStats + memstatsCurrent runtime.MemStats + maxSize int64 + availableMemory uint64 + numItems uint64 +} + +func (s *stats) getNumItems() uint64 { + return atomic.LoadUint64(&s.numItems) +} + +func (s *stats) adjustMaxSize(setter func(size int64)) int64 { + newSize := int64(float64(s.maxSize) * s.resizeFactor()) + if newSize != s.maxSize && setter != nil { + setter(newSize) + } + return newSize +} + +func (s *stats) decr(i int) { + atomic.AddUint64(&s.numItems, ^uint64(i-1)) +} + +func (s *stats) incr(i int) { + atomic.AddUint64(&s.numItems, uint64(i)) +} + +func (s *stats) resizeFactor() float64 { + if s.memstatsCurrent.Alloc == 0 { + return 1.0 + } + return math.Floor(float64(s.availableMemory/s.memstatsCurrent.Alloc)*10) / 10 +} + +// Helpers to help eviction of related media types. +func isCSSType(m media.Type) bool { + tp := m.Type() + return tp == media.CSSType.Type() || tp == media.SASSType.Type() || tp == media.SCSSType.Type() +} + +func isJSType(m media.Type) bool { + tp := m.Type() + return tp == media.JavascriptType.Type() || tp == media.TypeScriptType.Type() || tp == media.JSXType.Type() || tp == media.TSXType.Type() +} + +func keyValid(s string) bool { + if len(s) < 5 { + return false + } + if strings.ContainsRune(s, '\\') { + return false + } + if strings.HasPrefix(s, "/") { + return false + } + if !strings.ContainsRune(s, '/') { + return false + } + + dotIdx := strings.Index(s, ".") + if dotIdx == -1 || dotIdx == len(s)-1 { + return false + } + + return true +} + +// This assumes a valid key path. +func splitBasePathAndExt(path string) (string, string) { + dotIdx := strings.LastIndex(path, ".") + ext := path[dotIdx+1:] + slashIdx := strings.Index(path, "/") + + return path[:slashIdx], ext +} diff --git a/cache/memcache/memcache_test.go b/cache/memcache/memcache_test.go new file mode 100644 index 00000000000..e993a5b7ab4 --- /dev/null +++ b/cache/memcache/memcache_test.go @@ -0,0 +1,174 @@ +// Copyright 2020 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 memcache + +import ( + "context" + "fmt" + "path/filepath" + "sync" + "testing" + "time" + + qt "github.com/frankban/quicktest" +) + +func TestCache(t *testing.T) { + t.Parallel() + c := qt.New(t) + + cache := New(Config{}) + + counter := 0 + create := func() Entry { + counter++ + return Entry{Value: counter, ClearWhen: ClearOnChange} + } + + a := cache.GetOrCreatePartition("a", ClearNever) + + for i := 0; i < 5; i++ { + v1, err := a.GetOrCreate(context.TODO(), "a1", create) + c.Assert(err, qt.IsNil) + c.Assert(v1, qt.Equals, 1) + v2, err := a.GetOrCreate(context.TODO(), "a2", create) + c.Assert(err, qt.IsNil) + c.Assert(v2, qt.Equals, 2) + } + + cache.Clear() + + v3, err := a.GetOrCreate(context.TODO(), "a2", create) + c.Assert(err, qt.IsNil) + c.Assert(v3, qt.Equals, 3) +} + +func TestCacheConcurrent(t *testing.T) { + t.Parallel() + + c := qt.New(t) + + var wg sync.WaitGroup + + cache := New(Config{}) + + create := func(i int) func() Entry { + return func() Entry { + return Entry{Value: i, ClearWhen: ClearOnChange} + } + } + + for i := 0; i < 10; i++ { + wg.Add(1) + go func() { + defer wg.Done() + for j := 0; j < 100; j++ { + id := fmt.Sprintf("id%d", j) + v, err := cache.getOrCreate("a", id, create(j)) + c.Assert(err, qt.IsNil) + c.Assert(v, qt.Equals, j) + } + }() + } + wg.Wait() +} + +func TestCacheMemStats(t *testing.T) { + t.Parallel() + c := qt.New(t) + + cache := New(Config{ + ItemsToPrune: 10, + CheckInterval: 500 * time.Millisecond, + }) + + s := cache.stats + + c.Assert(s.memstatsStart.Alloc > 0, qt.Equals, true) + c.Assert(s.memstatsCurrent.Alloc, qt.Equals, uint64(0)) + c.Assert(s.availableMemory > 0, qt.Equals, true) + c.Assert(s.numItems, qt.Equals, uint64(0)) + + counter := 0 + create := func() Entry { + counter++ + return Entry{Value: counter, ClearWhen: ClearNever} + } + + for i := 1; i <= 20; i++ { + _, err := cache.getOrCreate("a", fmt.Sprintf("b%d", i), create) + c.Assert(err, qt.IsNil) + } + + c.Assert(s.getNumItems(), qt.Equals, uint64(20)) + cache.cache.SetMaxSize(10) + time.Sleep(time.Millisecond * 1200) + c.Assert(int(s.getNumItems()), qt.Equals, 10) +} + +func TestSplitBasePathAndExt(t *testing.T) { + t.Parallel() + c := qt.New(t) + + tests := []struct { + path string + a string + b string + }{ + {"a/b.json", "a", "json"}, + {"a/b/c/d.json", "a", "json"}, + } + for i, this := range tests { + msg := qt.Commentf("test %d", i) + a, b := splitBasePathAndExt(this.path) + + c.Assert(a, qt.Equals, this.a, msg) + c.Assert(b, qt.Equals, this.b, msg) + } +} + +func TestCleanKey(t *testing.T) { + c := qt.New(t) + + c.Assert(CleanKey(filepath.FromSlash("a/b/c.js")), qt.Equals, "a/b/c.js") + c.Assert(CleanKey("a//b////c.js"), qt.Equals, "a/b/c.js") + c.Assert(CleanKey("a.js"), qt.Equals, "_root/a.js") + c.Assert(CleanKey("b/a"), qt.Equals, "b/a.unkn") +} + +func TestKeyValid(t *testing.T) { + c := qt.New(t) + + c.Assert(keyValid("a/b.j"), qt.Equals, true) + c.Assert(keyValid("a/b."), qt.Equals, false) + c.Assert(keyValid("a/b"), qt.Equals, false) + c.Assert(keyValid("/a/b.txt"), qt.Equals, false) + c.Assert(keyValid("a\\b.js"), qt.Equals, false) +} + +func TestInsertKeyPathElement(t *testing.T) { + c := qt.New(t) + + c.Assert(InsertKeyPathElements("a/b.j", "en"), qt.Equals, "a/en/b.j") + c.Assert(InsertKeyPathElements("a/b.j", "en", "foo"), qt.Equals, "a/en/foo/b.j") + c.Assert(InsertKeyPathElements("a/b.j", "", "foo"), qt.Equals, "a/foo/b.j") +} + +func TestShouldEvict(t *testing.T) { + // TODO1 remove? + // c := qt.New(t) + + // fmt.Println("=>", CleanKey("kkk")) + // c.Assert(shouldEvict("key", Entry{}, ClearNever, identity.NewPathIdentity(files.ComponentFolderAssets, "a/b/c.js")), qt.Equals, true) +} diff --git a/cache/namedmemcache/named_cache.go b/cache/namedmemcache/named_cache.go deleted file mode 100644 index 4e912bf5871..00000000000 --- a/cache/namedmemcache/named_cache.go +++ /dev/null @@ -1,78 +0,0 @@ -// Copyright 2018 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 namedmemcache provides a memory cache with a named lock. This is suitable -// for situations where creating the cached resource can be time consuming or otherwise -// resource hungry, or in situations where a "once only per key" is a requirement. -package namedmemcache - -import ( - "sync" - - "github.com/BurntSushi/locker" -) - -// Cache holds the cached values. -type Cache struct { - nlocker *locker.Locker - cache map[string]cacheEntry - mu sync.RWMutex -} - -type cacheEntry struct { - value interface{} - err error -} - -// New creates a new cache. -func New() *Cache { - return &Cache{ - nlocker: locker.NewLocker(), - cache: make(map[string]cacheEntry), - } -} - -// Clear clears the cache state. -func (c *Cache) Clear() { - c.mu.Lock() - defer c.mu.Unlock() - - c.cache = make(map[string]cacheEntry) - c.nlocker = locker.NewLocker() -} - -// GetOrCreate tries to get the value with the given cache key, if not found -// create will be called and cached. -// This method is thread safe. It also guarantees that the create func for a given -// key is invoked only once for this cache. -func (c *Cache) GetOrCreate(key string, create func() (interface{}, error)) (interface{}, error) { - c.mu.RLock() - entry, found := c.cache[key] - c.mu.RUnlock() - - if found { - return entry.value, entry.err - } - - c.nlocker.Lock(key) - defer c.nlocker.Unlock(key) - - // Create it. - value, err := create() - - c.mu.Lock() - c.cache[key] = cacheEntry{value: value, err: err} - c.mu.Unlock() - - return value, err -} diff --git a/cache/namedmemcache/named_cache_test.go b/cache/namedmemcache/named_cache_test.go deleted file mode 100644 index 9feddb11f2a..00000000000 --- a/cache/namedmemcache/named_cache_test.go +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright 2018 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 namedmemcache - -import ( - "fmt" - "sync" - "testing" - - qt "github.com/frankban/quicktest" -) - -func TestNamedCache(t *testing.T) { - t.Parallel() - c := qt.New(t) - - cache := New() - - counter := 0 - create := func() (interface{}, error) { - counter++ - return counter, nil - } - - for i := 0; i < 5; i++ { - v1, err := cache.GetOrCreate("a1", create) - c.Assert(err, qt.IsNil) - c.Assert(v1, qt.Equals, 1) - v2, err := cache.GetOrCreate("a2", create) - c.Assert(err, qt.IsNil) - c.Assert(v2, qt.Equals, 2) - } - - cache.Clear() - - v3, err := cache.GetOrCreate("a2", create) - c.Assert(err, qt.IsNil) - c.Assert(v3, qt.Equals, 3) -} - -func TestNamedCacheConcurrent(t *testing.T) { - t.Parallel() - - c := qt.New(t) - - var wg sync.WaitGroup - - cache := New() - - create := func(i int) func() (interface{}, error) { - return func() (interface{}, error) { - return i, nil - } - } - - for i := 0; i < 10; i++ { - wg.Add(1) - go func() { - defer wg.Done() - for j := 0; j < 100; j++ { - id := fmt.Sprintf("id%d", j) - v, err := cache.GetOrCreate(id, create(j)) - c.Assert(err, qt.IsNil) - c.Assert(v, qt.Equals, j) - } - }() - } - wg.Wait() -} diff --git a/commands/convert.go b/commands/convert.go index 8c84423f587..fea27a6a745 100644 --- a/commands/convert.go +++ b/commands/convert.go @@ -137,7 +137,7 @@ func (cc *convertCmd) convertAndSavePage(p page.Page, site *hugolib.Site, target } } - if p.File().IsZero() { + if p.File() == nil { // No content file. return nil } diff --git a/commands/hugo.go b/commands/hugo.go index b954bf13cbf..78d99d30aa0 100644 --- a/commands/hugo.go +++ b/commands/hugo.go @@ -423,7 +423,12 @@ func (c *commandeer) initMemTicker() func() { printMem := func() { var m runtime.MemStats runtime.ReadMemStats(&m) - fmt.Printf("\n\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", formatByteCount(m.Alloc), formatByteCount(m.TotalAlloc), formatByteCount(m.Sys), m.NumGC) + fmt.Printf( + "\n\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", + helpers.FormatByteCount(m.Alloc), + helpers.FormatByteCount(m.TotalAlloc), + helpers.FormatByteCount(m.Sys), m.NumGC, + ) } go func() { @@ -738,6 +743,7 @@ func (c *commandeer) handleBuildErr(err error, msg string) { func (c *commandeer) rebuildSites(events []fsnotify.Event) error { c.buildErr = nil visited := c.visitedURLs.PeekAllSet() + if c.fastRenderMode { // Make sure we always render the home pages for _, l := range c.languages { @@ -749,7 +755,15 @@ func (c *commandeer) rebuildSites(events []fsnotify.Event) error { visited[home] = true } } - return c.hugo().Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: visited, ErrRecovery: c.wasError}, events...) + + return c.hugo().Build( + hugolib.BuildCfg{ + NoBuildLock: true, + RecentlyVisited: visited, + ErrRecovery: c.wasError, + }, + events..., + ) } func (c *commandeer) partialReRender(urls ...string) error { @@ -1219,17 +1233,3 @@ func pickOneWriteOrCreatePath(events []fsnotify.Event) string { return name } - -func formatByteCount(b uint64) string { - const unit = 1000 - if b < unit { - return fmt.Sprintf("%d B", b) - } - div, exp := int64(unit), 0 - for n := b / unit; n >= unit; n /= unit { - div *= unit - exp++ - } - return fmt.Sprintf("%.1f %cB", - float64(b)/float64(div), "kMGTPE"[exp]) -} diff --git a/commands/server.go b/commands/server.go index 7d9462b3655..7b5b24f975c 100644 --- a/commands/server.go +++ b/commands/server.go @@ -511,7 +511,7 @@ func (c *commandeer) serve(s *serverCmd) error { mu, serverURL, endpoint, err := srv.createEndpoint(i) if doLiveReload { - u, err := url.Parse(helpers.SanitizeURL(baseURLs[i])) + u, err := url.Parse(baseURLs[i]) if err != nil { return err } diff --git a/common/herrors/errors.go b/common/herrors/errors.go index 00aed1eb68c..3aed4ff53e7 100644 --- a/common/herrors/errors.go +++ b/common/herrors/errors.go @@ -65,6 +65,7 @@ type ErrorSender interface { // Recover is a helper function that can be used to capture panics. // Put this at the top of a method/function that crashes in a template: // defer herrors.Recover() +// TODO1 check usage func Recover(args ...interface{}) { if r := recover(); r != nil { fmt.Println("ERR:", r) diff --git a/common/loggers/ignorableLogger.go b/common/loggers/ignorableLogger.go index 0a130900db0..7bffac2c196 100644 --- a/common/loggers/ignorableLogger.go +++ b/common/loggers/ignorableLogger.go @@ -22,29 +22,36 @@ import ( type IgnorableLogger interface { Logger Errorsf(statementID, format string, v ...interface{}) + Warnsf(statementID, format string, v ...interface{}) Apply(logger Logger) IgnorableLogger } type ignorableLogger struct { Logger - statements map[string]bool + statementsError map[string]bool + statementsWarning map[string]bool } // NewIgnorableLogger wraps the given logger and ignores the log statement IDs given. -func NewIgnorableLogger(logger Logger, statements ...string) IgnorableLogger { - statementsSet := make(map[string]bool) - for _, s := range statements { - statementsSet[strings.ToLower(s)] = true +func NewIgnorableLogger(logger Logger, statementsError, statementsWarning []string) IgnorableLogger { + statementsSetError := make(map[string]bool) + for _, s := range statementsError { + statementsSetError[strings.ToLower(s)] = true + } + statementsSetWarning := make(map[string]bool) + for _, s := range statementsWarning { + statementsSetWarning[strings.ToLower(s)] = true } return ignorableLogger{ - Logger: logger, - statements: statementsSet, + Logger: logger, + statementsError: statementsSetError, + statementsWarning: statementsSetWarning, } } // Errorsf logs statementID as an ERROR if not configured as ignoreable. func (l ignorableLogger) Errorsf(statementID, format string, v ...interface{}) { - if l.statements[statementID] { + if l.statementsError[statementID] { // Ignore. return } @@ -57,9 +64,24 @@ ignoreErrors = [%q]`, statementID) l.Errorf(format, v...) } +// Warnsf logs statementID as an WARNING if not configured as ignoreable. +func (l ignorableLogger) Warnsf(statementID, format string, v ...interface{}) { + if l.statementsWarning[statementID] { + // Ignore. + return + } + ignoreMsg := fmt.Sprintf(` +To turn off this WARNING, you can ignore it by adding this to your site config: +ignoreWarnings = [%q]`, statementID) + + format += ignoreMsg + + l.Warnf(format, v...) +} + func (l ignorableLogger) Apply(logger Logger) IgnorableLogger { return ignorableLogger{ - Logger: logger, - statements: l.statements, + Logger: logger, + statementsError: l.statementsError, } } diff --git a/common/paths/path.go b/common/paths/path.go index 0237dd9f22a..06ad85c8e4a 100644 --- a/common/paths/path.go +++ b/common/paths/path.go @@ -16,11 +16,13 @@ package paths import ( "errors" "fmt" + "net/url" "os" "path" "path/filepath" "regexp" "strings" + "unicode" ) // FilePathSeparator as defined by os.Separator. @@ -83,15 +85,6 @@ func ReplaceExtension(path string, newExt string) string { return f + "." + newExt } -func makePathRelative(inPath string, possibleDirectories ...string) (string, error) { - for _, currentPath := range possibleDirectories { - if strings.HasPrefix(inPath, currentPath) { - return strings.TrimPrefix(inPath, currentPath), nil - } - } - return inPath, errors.New("can't extract relative path, unknown prefix") -} - // Should be good enough for Hugo. var isFileRe = regexp.MustCompile(`.*\..{1,6}$`) @@ -233,38 +226,15 @@ func GetRelativePath(path, base string) (final string, err error) { return name, nil } -// PathPrep prepares the path using the uglify setting to create paths on -// either the form /section/name/index.html or /section/name.html. -func PathPrep(ugly bool, in string) string { - if ugly { - return Uglify(in) - } - return PrettifyPath(in) -} - -// PrettifyPath is the same as PrettifyURLPath but for file paths. -// /section/name.html becomes /section/name/index.html -// /section/name/ becomes /section/name/index.html -// /section/name/index.html becomes /section/name/index.html -func PrettifyPath(in string) string { - return prettifyPath(in, fpb) +var slashFunc = func(r rune) bool { + return r == '/' } -func prettifyPath(in string, b filepathPathBridge) string { - if filepath.Ext(in) == "" { - // /section/name/ -> /section/name/index.html - if len(in) < 2 { - return b.Separator() - } - return b.Join(in, "index.html") - } - name, ext := fileAndExt(in, b) - if name == "index" { - // /section/name/index.html -> /section/name/index.html - return b.Clean(in) - } - // /section/name.html -> /section/name/index.html - return b.Join(b.Dir(in), name, "index"+ext) +// FieldsSlash cuts s into fields separated with '/'. +// TODO1 add some tests, consider leading/trailing slashes. +func FieldsSlash(s string) []string { + f := strings.FieldsFunc(s, slashFunc) + return f } type NamedSlice struct { @@ -310,3 +280,88 @@ func AddTrailingSlash(path string) string { } return path } + +// PathEscape escapes unicode letters in pth. +// Use URLEscape to escape full URLs including scheme, query etc. +// This is slightly faster for the common case. +// Note, there is a url.PathEscape function, but that also +// escapes /. +func PathEscape(pth string) string { + u, err := url.Parse(pth) + if err != nil { + panic(err) + } + return u.EscapedPath() +} + +// Sanitize sanitizes string to be used in Hugo's file paths and URLs, allowing only +// a predefined set of special Unicode characters. +// +// Spaces will be replaced with a single hyphen, and sequential hyphens will be reduced to one. +// +// This function is the core function used to normalize paths in Hugo. +// +// This function is used for key creation in Hugo's content map, which needs to be very fast. +// This key is also used as a base for URL/file path creation, so this should always be truthful: +// +// helpers.PathSpec.MakePathSanitized(anyPath) == helpers.PathSpec.MakePathSanitized(Sanitize(anyPath)) +// +// Even if the user has stricter rules defined for the final paths (e.g. removePathAccents=true). +func Sanitize(s string) string { + var willChange bool + for i, r := range s { + willChange = !isAllowedPathCharacter(s, i, r) + if willChange { + break + } + } + + if !willChange { + // Prevent allocation when nothing changes. + return s + } + + target := make([]rune, 0, len(s)) + var prependHyphen bool + + for i, r := range s { + isAllowed := isAllowedPathCharacter(s, i, r) + + if isAllowed { + if prependHyphen { + target = append(target, '-') + prependHyphen = false + } + target = append(target, r) + } else if len(target) > 0 && (r == '-' || unicode.IsSpace(r)) { + prependHyphen = true + } + } + + return string(target) +} + +func isAllowedPathCharacter(s string, i int, r rune) bool { + if r == ' ' { + return false + } + // Check for the most likely first (faster). + isAllowed := unicode.IsLetter(r) || unicode.IsDigit(r) + isAllowed = isAllowed || r == '.' || r == '/' || r == '\\' || r == '_' || r == '#' || r == '+' || r == '~' + isAllowed = isAllowed || unicode.IsMark(r) + isAllowed = isAllowed || (r == '%' && i+2 < len(s) && ishex(s[i+1]) && ishex(s[i+2])) + return isAllowed +} + +// From https://golang.org/src/net/url/url.go +func ishex(c byte) bool { + switch { + case '0' <= c && c <= '9': + return true + case 'a' <= c && c <= 'f': + return true + case 'A' <= c && c <= 'F': + return true + } + return false +} diff --git a/common/paths/path_test.go b/common/paths/path_test.go index e55493c7d7c..1970ea2bee7 100644 --- a/common/paths/path_test.go +++ b/common/paths/path_test.go @@ -52,29 +52,6 @@ func TestGetRelativePath(t *testing.T) { } } -func TestMakePathRelative(t *testing.T) { - type test struct { - inPath, path1, path2, output string - } - - data := []test{ - {"/abc/bcd/ab.css", "/abc/bcd", "/bbc/bcd", "/ab.css"}, - {"/abc/bcd/ab.css", "/abcd/bcd", "/abc/bcd", "/ab.css"}, - } - - for i, d := range data { - output, _ := makePathRelative(d.inPath, d.path1, d.path2) - if d.output != output { - t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output) - } - } - _, error := makePathRelative("a/b/c.ss", "/a/c", "/d/c", "/e/f") - - if error == nil { - t.Errorf("Test failed, expected error") - } -} - func TestGetDottedRelativePath(t *testing.T) { // on Windows this will receive both kinds, both country and western ... for _, f := range []func(string) string{filepath.FromSlash, func(s string) string { return s }} { @@ -250,3 +227,59 @@ func TestFindCWD(t *testing.T) { } } } + +func TesSanitize(t *testing.T) { + c := qt.New(t) + tests := []struct { + input string + expected string + }{ + {" Foo bar ", "Foo-bar"}, + {"Foo.Bar/foo_Bar-Foo", "Foo.Bar/foo_Bar-Foo"}, + {"fOO,bar:foobAR", "fOObarfoobAR"}, + {"FOo/BaR.html", "FOo/BaR.html"}, + {"FOo/Ba---R.html", "FOo/Ba-R.html"}, + {"FOo/Ba R.html", "FOo/Ba-R.html"}, + {"трям/трям", "трям/трям"}, + {"은행", "은행"}, + {"Банковский кассир", "Банковскии-кассир"}, + // Issue #1488 + {"संस्कृत", "संस्कृत"}, + {"a%C3%B1ame", "a%C3%B1ame"}, // Issue #1292 + {"this+is+a+test", "sthis+is+a+test"}, // Issue #1290 + {"~foo", "~foo"}, // Issue #2177 + + } + + for _, test := range tests { + c.Assert(Sanitize(test.input), qt.Equals, test.expected) + } +} + +func BenchmarkSanitize(b *testing.B) { + const ( + allAlowedPath = "foo/bar" + spacePath = "foo bar" + ) + + // This should not allocate any memory. + b.Run("All allowed", func(b *testing.B) { + for i := 0; i < b.N; i++ { + got := Sanitize(allAlowedPath) + if got != allAlowedPath { + b.Fatal(got) + } + } + }) + + // This will allocate some memory. + b.Run("Spaces", func(b *testing.B) { + for i := 0; i < b.N; i++ { + got := Sanitize(spacePath) + if got != "foo-bar" { + b.Fatal(got) + } + } + }) + +} diff --git a/common/paths/pathparser.go b/common/paths/pathparser.go new file mode 100644 index 00000000000..0ba48cce30e --- /dev/null +++ b/common/paths/pathparser.go @@ -0,0 +1,342 @@ +// Copyright 2021 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 paths + +import ( + "errors" + "os" + "runtime" + "strings" + + "github.com/gohugoio/hugo/common/types" + "github.com/gohugoio/hugo/hugofs/files" + "github.com/gohugoio/hugo/identity" +) + +var ForComponent = func(component string) func(b *Path) { + return func(b *Path) { + b.component = component + } +} + +// Parse parses s into Path using Hugo's content path rules. +func Parse(s string, parseOpts ...func(b *Path)) *Path { + p, err := parse(s, parseOpts...) + if err != nil { + panic(err) + } + return p +} + +func parse(s string, parseOpts ...func(b *Path)) (*Path, error) { + p := &Path{ + component: files.ComponentFolderContent, + posContainerLow: -1, + posContainerHigh: -1, + posSectionHigh: -1, + } + + for _, opt := range parseOpts { + opt(p) + } + + // All lower case. + s = strings.ToLower(s) + + // Leading slash, no trailing slash. + if p.component != files.ComponentFolderLayouts && !strings.HasPrefix(s, "/") { + s = "/" + s + } + + if s != "/" && s[len(s)-1] == '/' { + s = s[:len(s)-1] + } + + p.s = s + + isWindows := runtime.GOOS == "windows" + + for i := len(s) - 1; i >= 0; i-- { + c := s[i] + + if isWindows && c == os.PathSeparator { + return nil, errors.New("only forward slashes allowed") + } + + switch c { + case '.': + if p.posContainerHigh == -1 { + var high int + if len(p.identifiers) > 0 { + high = p.identifiers[len(p.identifiers)-1].Low - 1 + } else { + high = len(p.s) + } + p.identifiers = append(p.identifiers, types.LowHigh{Low: i + 1, High: high}) + } + case '/': + if p.posContainerHigh == -1 { + p.posContainerHigh = i + 1 + } else if p.posContainerLow == -1 { + p.posContainerLow = i + 1 + } + if i > 0 { + p.posSectionHigh = i + } + } + } + + isContent := p.component == files.ComponentFolderContent && files.IsContentExt(p.Ext()) + + if isContent { + id := p.identifiers[len(p.identifiers)-1] + b := p.s[p.posContainerHigh : id.Low-1] + switch b { + case "index": + p.bundleType = BundleTypeLeaf + case "_index": + p.bundleType = BundleTypeBranch + default: + p.bundleType = BundleTypeContent + } + } + + return p, nil +} + +type _Path interface { + identity.Identity + Component() string + Container() string + Section() string + Name() string + NameNoExt() string + NameNoIdentifier() string + Base() string + Dir() string + Ext() string + Identifiers() []string + Identifier(i int) string + IsContent() bool + IsBundle() bool + IsLeafBundle() bool + IsBranchBundle() bool + BundleType() BundleType +} + +func ModifyPathBundleNone(p *Path) { + p.bundleType = BundleTypeContent +} + +type PathInfos []*PathInfo + +type BundleType int + +const ( + BundleTypeFile BundleType = iota + + // All above are content files. + BundleTypeContent + + // All above are bundled content files. + BundleTypeLeaf + BundleTypeBranch +) + +// TODO1 consider creating some smaller interface for this. +type Path struct { + s string + + posContainerLow int + posContainerHigh int + posSectionHigh int + + component string + bundleType BundleType + + identifiers []types.LowHigh +} + +type PathInfo struct { + *Path + component string + filename string +} + +func (p *PathInfo) Filename() string { + return p.filename +} + +func WithInfo(p *Path, filename string) *PathInfo { + return &PathInfo{ + Path: p, + filename: filename, + } +} + +// IdentifierBase satifies identity.Identity. +// TODO1 componnt? +func (p *Path) IdentifierBase() interface{} { + return p.Base() +} + +func (p *Path) Component() string { + return p.component +} + +func (p *Path) Container() string { + if p.posContainerLow == -1 { + return "" + } + return p.s[p.posContainerLow : p.posContainerHigh-1] +} + +func (p *Path) Section() string { + if p.posSectionHigh == -1 { + return "" + } + return p.s[1:p.posSectionHigh] +} + +func (p *Path) IsContent() bool { + return p.BundleType() >= BundleTypeContent +} + +// Name returns the last element of path. +func (p *Path) Name() string { + if p.posContainerHigh > 0 { + return p.s[p.posContainerHigh:] + } + return p.s +} + +// Name returns the last element of path withhout any extension. +func (p *Path) NameNoExt() string { + if i := p.identifierIndex(0); i != -1 { + return p.s[p.posContainerHigh : p.identifiers[i].Low-1] + } + return p.s[p.posContainerHigh:] +} + +// Name returns the last element of path withhout any language identifier. +func (p *Path) NameNoLang() string { + i := p.identifierIndex(1) + if i == -1 { + return p.Name() + } + + return p.s[p.posContainerHigh:p.identifiers[i].Low-1] + p.s[p.identifiers[i].High:] +} + +func (p *Path) NameNoIdentifier() string { + if len(p.identifiers) > 0 { + return p.s[p.posContainerHigh : p.identifiers[len(p.identifiers)-1].Low-1] + } + if i := p.identifierIndex(0); i != -1 { + } + return p.s[p.posContainerHigh:] +} + +func (p *Path) Dir() (d string) { + if p.posContainerHigh > 0 { + d = p.s[:p.posContainerHigh-1] + } + if d == "" { + d = "/" + } + return +} + +// For content files, Base returns the path without any identifiers (extension, language code etc.). +// Any 'index' as the last path element is ignored. +// +// For other files (Resources), any extension is kept. +func (p *Path) Base() string { + if len(p.identifiers) > 0 { + if !p.IsContent() && len(p.identifiers) == 1 { + // Preserve extension. + return p.s + } + + id := p.identifiers[len(p.identifiers)-1] + high := id.Low - 1 + + if p.IsBundle() { + high = p.posContainerHigh - 1 + } + + if p.IsContent() { + return p.s[:high] + } + + // For txt files etc. we want to preserve the extension. + id = p.identifiers[0] + + return p.s[:high] + p.s[id.Low-1:id.High] + } + return p.s +} + +func (p *Path) Ext() string { + return p.identifierAsString(0) +} + +func (p *Path) Lang() string { + return p.identifierAsString(1) +} + +func (p *Path) Identifier(i int) string { + return p.identifierAsString(i) +} + +func (p *Path) Identifiers() []string { + ids := make([]string, len(p.identifiers)) + for i, id := range p.identifiers { + ids[i] = p.s[id.Low:id.High] + } + return ids +} + +func (p *Path) BundleType() BundleType { + return p.bundleType +} + +func (p *Path) IsBundle() bool { + return p.bundleType >= BundleTypeLeaf +} + +func (p *Path) IsBranchBundle() bool { + return p.bundleType == BundleTypeBranch +} + +func (p *Path) IsLeafBundle() bool { + return p.bundleType == BundleTypeLeaf +} + +func (p *Path) identifierAsString(i int) string { + i = p.identifierIndex(i) + if i == -1 { + return "" + } + + id := p.identifiers[i] + return p.s[id.Low:id.High] +} + +func (p *Path) identifierIndex(i int) int { + if i < 0 || i >= len(p.identifiers) { + return -1 + } + return i +} diff --git a/common/paths/pathparser_test.go b/common/paths/pathparser_test.go new file mode 100644 index 00000000000..2733c8fb1c9 --- /dev/null +++ b/common/paths/pathparser_test.go @@ -0,0 +1,173 @@ +// Copyright 2021 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 paths + +import ( + "path/filepath" + "testing" + + "github.com/gohugoio/hugo/htesting" + + qt "github.com/frankban/quicktest" +) + +func TestParse(t *testing.T) { + c := qt.New(t) + + tests := []struct { + name string + path string + assert func(c *qt.C, p *Path) + }{ + { + "Basic text file", + "/a/b.txt", + func(c *qt.C, p *Path) { + c.Assert(p.Name(), qt.Equals, "b.txt") + c.Assert(p.Base(), qt.Equals, "/a/b.txt") + c.Assert(p.Dir(), qt.Equals, "/a") + c.Assert(p.Ext(), qt.Equals, "txt") + }, + }, + { + "Basic text file, upper case", + "/A/B.txt", + func(c *qt.C, p *Path) { + c.Assert(p.Name(), qt.Equals, "b.txt") + c.Assert(p.NameNoExt(), qt.Equals, "b") + c.Assert(p.NameNoIdentifier(), qt.Equals, "b") + c.Assert(p.Base(), qt.Equals, "/a/b.txt") + c.Assert(p.Ext(), qt.Equals, "txt") + }, + }, + { + "Basic Markdown file", + "/a/b.md", + func(c *qt.C, p *Path) { + c.Assert(p.Name(), qt.Equals, "b.md") + c.Assert(p.Base(), qt.Equals, "/a/b") + c.Assert(p.Dir(), qt.Equals, "/a") + c.Assert(p.Ext(), qt.Equals, "md") + }, + }, + + { + "No ext", + "/a/b", + func(c *qt.C, p *Path) { + c.Assert(p.Name(), qt.Equals, "b") + c.Assert(p.NameNoExt(), qt.Equals, "b") + c.Assert(p.Base(), qt.Equals, "/a/b") + c.Assert(p.Ext(), qt.Equals, "") + }, + }, + { + "No ext, trailing slash", + "/a/b/", + func(c *qt.C, p *Path) { + c.Assert(p.Name(), qt.Equals, "b") + c.Assert(p.Base(), qt.Equals, "/a/b") + c.Assert(p.Ext(), qt.Equals, "") + }, + }, + { + "Identifiers", + "/a/b.a.b.c.txt", + func(c *qt.C, p *Path) { + c.Assert(p.Name(), qt.Equals, "b.a.b.c.txt") + c.Assert(p.NameNoIdentifier(), qt.Equals, "b") + c.Assert(p.NameNoLang(), qt.Equals, "b.a.b.txt") + c.Assert(p.Identifiers(), qt.DeepEquals, []string{"txt", "c", "b", "a"}) + c.Assert(p.Base(), qt.Equals, "/a/b.txt") + c.Assert(p.Ext(), qt.Equals, "txt") + }, + }, + { + "Index content file", + "/a/b/index.no.md", + func(c *qt.C, p *Path) { + c.Assert(p.Base(), qt.Equals, "/a/b") + c.Assert(p.Dir(), qt.Equals, "/a/b") + c.Assert(p.Ext(), qt.Equals, "md") + c.Assert(p.Container(), qt.Equals, "b") + c.Assert(p.Section(), qt.Equals, "a") + c.Assert(p.NameNoExt(), qt.Equals, "index.no") + c.Assert(p.NameNoLang(), qt.Equals, "index.md") + c.Assert(p.NameNoIdentifier(), qt.Equals, "index") + c.Assert(p.Identifiers(), qt.DeepEquals, []string{"md", "no"}) + c.Assert(p.IsLeafBundle(), qt.IsTrue) + c.Assert(p.IsBundle(), qt.IsTrue) + c.Assert(p.IsBranchBundle(), qt.IsFalse) + }, + }, + { + "Index branch content file", + "/a/b/_index.no.md", + func(c *qt.C, p *Path) { + c.Assert(p.Base(), qt.Equals, "/a/b") + c.Assert(p.Ext(), qt.Equals, "md") + c.Assert(p.Identifiers(), qt.DeepEquals, []string{"md", "no"}) + c.Assert(p.IsBranchBundle(), qt.IsTrue) + c.Assert(p.IsLeafBundle(), qt.IsFalse) + c.Assert(p.IsBundle(), qt.IsTrue) + }, + }, + { + "Index text file", + "/a/b/index.no.txt", + func(c *qt.C, p *Path) { + c.Assert(p.Base(), qt.Equals, "/a/b/index.txt") + c.Assert(p.Ext(), qt.Equals, "txt") + c.Assert(p.IsLeafBundle(), qt.IsFalse) + c.Assert(p.Identifiers(), qt.DeepEquals, []string{"txt", "no"}) + }, + }, + + { + "Empty", + "", + func(c *qt.C, p *Path) { + c.Assert(p.Name(), qt.Equals, "") + c.Assert(p.Base(), qt.Equals, "/") + c.Assert(p.Ext(), qt.Equals, "") + }, + }, + { + "Slash", + "/", + func(c *qt.C, p *Path) { + c.Assert(p.Name(), qt.Equals, "") + c.Assert(p.Base(), qt.Equals, "/") + c.Assert(p.Ext(), qt.Equals, "") + }, + }, + } + for _, test := range tests { + c.Run(test.name, func(c *qt.C) { + if test.name != "Identifiers" { + // c.Skip() + } + test.assert(c, Parse(test.path)) + }) + } + + // Errors + c.Run("File separator", func(c *qt.C) { + if !htesting.IsWindows() { + c.Skip() + } + _, err := parse(filepath.FromSlash("/a/b/c")) + c.Assert(err, qt.IsNotNil) + }) +} diff --git a/common/paths/url.go b/common/paths/url.go index 600e8d22db2..cbc77d0b92a 100644 --- a/common/paths/url.go +++ b/common/paths/url.go @@ -18,8 +18,6 @@ import ( "net/url" "path" "strings" - - "github.com/PuerkitoBio/purell" ) type pathBridge struct { @@ -51,51 +49,6 @@ func (pathBridge) Separator() string { var pb pathBridge -func sanitizeURLWithFlags(in string, f purell.NormalizationFlags) string { - s, err := purell.NormalizeURLString(in, f) - if err != nil { - return in - } - - // Temporary workaround for the bug fix and resulting - // behavioral change in purell.NormalizeURLString(): - // a leading '/' was inadvertently added to relative links, - // but no longer, see #878. - // - // I think the real solution is to allow Hugo to - // make relative URL with relative path, - // e.g. "../../post/hello-again/", as wished by users - // in issues #157, #622, etc., without forcing - // relative URLs to begin with '/'. - // Once the fixes are in, let's remove this kludge - // and restore SanitizeURL() to the way it was. - // -- @anthonyfok, 2015-02-16 - // - // Begin temporary kludge - u, err := url.Parse(s) - if err != nil { - panic(err) - } - if len(u.Path) > 0 && !strings.HasPrefix(u.Path, "/") { - u.Path = "/" + u.Path - } - return u.String() - // End temporary kludge - - // return s - -} - -// SanitizeURL sanitizes the input URL string. -func SanitizeURL(in string) string { - return sanitizeURLWithFlags(in, purell.FlagsSafe|purell.FlagRemoveTrailingSlash|purell.FlagRemoveDotSegments|purell.FlagRemoveDuplicateSlashes|purell.FlagRemoveUnnecessaryHostDots|purell.FlagRemoveEmptyPortSeparator) -} - -// SanitizeURLKeepTrailingSlash is the same as SanitizeURL, but will keep any trailing slash. -func SanitizeURLKeepTrailingSlash(in string) string { - return sanitizeURLWithFlags(in, purell.FlagsSafe|purell.FlagRemoveDotSegments|purell.FlagRemoveDuplicateSlashes|purell.FlagRemoveUnnecessaryHostDots|purell.FlagRemoveEmptyPortSeparator) -} - // MakePermalink combines base URL with content path to create full URL paths. // Example // base: http://spf13.com/ @@ -155,58 +108,12 @@ func AddContextRoot(baseURL, relativePath string) string { return newPath } -// URLizeAn - -// PrettifyURL takes a URL string and returns a semantic, clean URL. -func PrettifyURL(in string) string { - x := PrettifyURLPath(in) - - if path.Base(x) == "index.html" { - return path.Dir(x) - } - - if in == "" { - return "/" - } - - return x -} - -// PrettifyURLPath takes a URL path to a content and converts it -// to enable pretty URLs. -// /section/name.html becomes /section/name/index.html -// /section/name/ becomes /section/name/index.html -// /section/name/index.html becomes /section/name/index.html -func PrettifyURLPath(in string) string { - return prettifyPath(in, pb) -} - -// Uglify does the opposite of PrettifyURLPath(). -// /section/name/index.html becomes /section/name.html -// /section/name/ becomes /section/name.html -// /section/name.html becomes /section/name.html -func Uglify(in string) string { - if path.Ext(in) == "" { - if len(in) < 2 { - return "/" - } - // /section/name/ -> /section/name.html - return path.Clean(in) + ".html" - } - - name, ext := fileAndExt(in, pb) - if name == "index" { - // /section/name/index.html -> /section/name.html - d := path.Dir(in) - if len(d) > 1 { - return d + ext - } - return in - } - // /.xml -> /index.xml - if name == "" { - return path.Dir(in) + "index" + ext +// URLEscape escapes unicode letters. +func URLEscape(uri string) string { + // escape unicode letters + u, err := url.Parse(uri) + if err != nil { + panic(err) } - // /section/name.html -> /section/name.html - return path.Clean(in) + return u.String() } diff --git a/common/paths/url_test.go b/common/paths/url_test.go index 3e8391ef504..baf617f155a 100644 --- a/common/paths/url_test.go +++ b/common/paths/url_test.go @@ -14,41 +14,9 @@ package paths import ( - "strings" "testing" - - qt "github.com/frankban/quicktest" ) -func TestSanitizeURL(t *testing.T) { - tests := []struct { - input string - expected string - }{ - {"http://foo.bar/", "http://foo.bar"}, - {"http://foo.bar", "http://foo.bar"}, // issue #1105 - {"http://foo.bar/zoo/", "http://foo.bar/zoo"}, // issue #931 - } - - for i, test := range tests { - o1 := SanitizeURL(test.input) - o2 := SanitizeURLKeepTrailingSlash(test.input) - - expected2 := test.expected - - if strings.HasSuffix(test.input, "/") && !strings.HasSuffix(expected2, "/") { - expected2 += "/" - } - - if o1 != test.expected { - t.Errorf("[%d] 1: Expected %#v, got %#v\n", i, test.expected, o1) - } - if o2 != expected2 { - t.Errorf("[%d] 2: Expected %#v, got %#v\n", i, expected2, o2) - } - } -} - func TestMakePermalink(t *testing.T) { type test struct { host, link, output string @@ -95,35 +63,3 @@ func TestAddContextRoot(t *testing.T) { } } } - -func TestPretty(t *testing.T) { - c := qt.New(t) - c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name.html")) - c.Assert("/section/sub/name/index.html", qt.Equals, PrettifyURLPath("/section/sub/name.html")) - c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name/")) - c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name/index.html")) - c.Assert("/index.html", qt.Equals, PrettifyURLPath("/index.html")) - c.Assert("/name/index.xml", qt.Equals, PrettifyURLPath("/name.xml")) - c.Assert("/", qt.Equals, PrettifyURLPath("/")) - c.Assert("/", qt.Equals, PrettifyURLPath("")) - c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name.html")) - c.Assert("/section/sub/name", qt.Equals, PrettifyURL("/section/sub/name.html")) - c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name/")) - c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name/index.html")) - c.Assert("/", qt.Equals, PrettifyURL("/index.html")) - c.Assert("/name/index.xml", qt.Equals, PrettifyURL("/name.xml")) - c.Assert("/", qt.Equals, PrettifyURL("/")) - c.Assert("/", qt.Equals, PrettifyURL("")) -} - -func TestUgly(t *testing.T) { - c := qt.New(t) - c.Assert("/section/name.html", qt.Equals, Uglify("/section/name.html")) - c.Assert("/section/sub/name.html", qt.Equals, Uglify("/section/sub/name.html")) - c.Assert("/section/name.html", qt.Equals, Uglify("/section/name/")) - c.Assert("/section/name.html", qt.Equals, Uglify("/section/name/index.html")) - c.Assert("/index.html", qt.Equals, Uglify("/index.html")) - c.Assert("/name.xml", qt.Equals, Uglify("/name.xml")) - c.Assert("/", qt.Equals, Uglify("/")) - c.Assert("/", qt.Equals, Uglify("")) -} diff --git a/common/types/types.go b/common/types/types.go index 4f9f02c8d7d..9e67c296752 100644 --- a/common/types/types.go +++ b/common/types/types.go @@ -90,3 +90,21 @@ func IsNil(v interface{}) bool { type DevMarker interface { DevOnly() } + +// Identifier identifies a resource. +type Identifier interface { + Key() string +} + +// KeyString is a string that implements Identifier. +type KeyString string + +func (k KeyString) Key() string { + return string(k) +} + +// LowHigh is typically used to represent a slice boundary. +type LowHigh struct { + Low int + High int +} diff --git a/config/env.go b/config/env.go index 1e7d4721655..95d5296c584 100644 --- a/config/env.go +++ b/config/env.go @@ -18,6 +18,12 @@ import ( "runtime" "strconv" "strings" + + "github.com/pbnjay/memory" +) + +const ( + gigabyte = 1 << 30 ) // GetNumWorkerMultiplier returns the base value used to calculate the number @@ -33,6 +39,37 @@ func GetNumWorkerMultiplier() int { return runtime.NumCPU() } +// GetMemoryLimit returns the upper memory limit in bytes for Hugo's in-memory caches. +// Note that this does not represent "all of the memory" that Hugo will use, +// so it needs to be set to a lower number than the available system memory. +// It will read from the HUGO_MEMORYLIMIT (in Gigabytes) environment variable. +// If that is not set, it will set aside a quarter of the total system memory. +func GetMemoryLimit() uint64 { + if mem := os.Getenv("HUGO_MEMORYLIMIT"); mem != "" { + if v := stringToGibabyte(mem); v > 0 { + return v + } + + } + + // There is a FreeMemory function, but as the kernel in most situations + // will take whatever memory that is left and use for caching etc., + // that value is not something that we can use. + m := memory.TotalMemory() + if m != 0 { + return uint64(m / 4) + } + + return 2 * gigabyte +} + +func stringToGibabyte(f string) uint64 { + if v, err := strconv.ParseFloat(f, 32); err == nil && v > 0 { + return uint64(v * gigabyte) + } + return 0 +} + // SetEnvVars sets vars on the form key=value in the oldVars slice. func SetEnvVars(oldVars *[]string, keyValues ...string) { for i := 0; i < len(keyValues); i += 2 { diff --git a/config/security/securityConfig.go b/config/security/securityConfig.go index 09c5cb62573..144cd72fc22 100644 --- a/config/security/securityConfig.go +++ b/config/security/securityConfig.go @@ -110,7 +110,6 @@ func (c Config) CheckAllowedExec(name string) error { } } return nil - } func (c Config) CheckAllowedGetEnv(name string) error { @@ -159,7 +158,6 @@ func (c Config) ToSecurityMap() map[string]interface{} { "security": m, } return sec - } // DecodeConfig creates a privacy Config from a given Hugo configuration. @@ -189,7 +187,6 @@ func DecodeConfig(cfg config.Provider) (Config, error) { } return sc, nil - } func stringSliceToWhitelistHook() mapstructure.DecodeHookFuncType { @@ -205,7 +202,6 @@ func stringSliceToWhitelistHook() mapstructure.DecodeHookFuncType { wl := types.ToStringSlicePreserveString(data) return NewWhitelist(wl...), nil - } } diff --git a/create/content.go b/create/content.go index 6ae91288264..b86cb2bb72a 100644 --- a/create/content.go +++ b/create/content.go @@ -102,7 +102,6 @@ func NewContent(h *hugolib.HugoSites, kind, targetPath string) error { } return b.buildFile() - } filename, err := withBuildLock() @@ -115,7 +114,6 @@ func NewContent(h *hugolib.HugoSites, kind, targetPath string) error { } return nil - } type contentBuilder struct { @@ -168,7 +166,6 @@ func (b *contentBuilder) buildDir() error { } return false }) - } if err := b.h.Build(hugolib.BuildCfg{NoBuildLock: true, SkipRender: true, ContentInclusionFilter: contentInclusionFilter}); err != nil { @@ -267,7 +264,6 @@ func (b *contentBuilder) setArcheTypeFilenameToUse(ext string) { return } } - } func (b *contentBuilder) applyArcheType(contentFilename, archetypeFilename string) error { @@ -287,7 +283,6 @@ func (b *contentBuilder) applyArcheType(contentFilename, archetypeFilename strin } return b.cf.AppplyArchetypeFilename(f, p, b.kind, archetypeFilename) - } func (b *contentBuilder) mapArcheTypeDir() error { @@ -351,7 +346,6 @@ func (b *contentBuilder) openInEditorIfConfigured(filename string) error { hexec.WithStderr(os.Stderr), hexec.WithStdout(os.Stdout), ) - if err != nil { return err } @@ -369,7 +363,6 @@ func (b *contentBuilder) usesSiteVar(filename string) (bool, error) { } return bytes.Contains(bb, []byte(".Site")) || bytes.Contains(bb, []byte("site.")), nil - } type archetypeMap struct { diff --git a/deps/deps.go b/deps/deps.go index 191193b9b93..32310eac0bf 100644 --- a/deps/deps.go +++ b/deps/deps.go @@ -8,6 +8,7 @@ import ( "github.com/pkg/errors" "github.com/gohugoio/hugo/cache/filecache" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/common/hexec" "github.com/gohugoio/hugo/common/loggers" "github.com/gohugoio/hugo/config" @@ -64,9 +65,12 @@ type Deps struct { // The configuration to use Cfg config.Provider `json:"-"` - // The file cache to use. + // The file caches to use. FileCaches filecache.Caches + // The memory cache to use. + MemCache *memcache.Cache + // The translation func to use Translate func(translationID string, templateData interface{}) string `json:"-"` @@ -166,6 +170,13 @@ type ResourceProvider interface { Clone(deps *Deps) error } +// Stop stops all running caches etc. +func (d *Deps) Stop() { + if d.MemCache != nil { + d.MemCache.Stop() + } +} + func (d *Deps) Tmpl() tpl.TemplateHandler { return d.tmpl } @@ -249,11 +260,12 @@ func New(cfg DepsCfg) (*Deps, error) { if err != nil { return nil, errors.WithMessage(err, "failed to create file caches from configuration") } + memCache := memcache.New(memcache.Config{Running: cfg.Running}) errorHandler := &globalErrHandler{} buildState := &BuildState{} - resourceSpec, err := resources.NewSpec(ps, fileCaches, buildState, logger, errorHandler, execHelper, cfg.OutputFormats, cfg.MediaTypes) + resourceSpec, err := resources.NewSpec(ps, fileCaches, memCache, buildState, logger, errorHandler, execHelper, cfg.OutputFormats, cfg.MediaTypes) if err != nil { return nil, err } @@ -271,9 +283,10 @@ func New(cfg DepsCfg) (*Deps, error) { } ignoreErrors := cast.ToStringSlice(cfg.Cfg.Get("ignoreErrors")) - ignorableLogger := loggers.NewIgnorableLogger(logger, ignoreErrors...) + ignoreWarnings := cast.ToStringSlice(cfg.Cfg.Get("ignoreWarnings")) logDistinct := helpers.NewDistinctLogger(logger) + ignorableLogger := loggers.NewIgnorableLogger(logDistinct, ignoreErrors, ignoreWarnings) d := &Deps{ Fs: fs, @@ -292,6 +305,7 @@ func New(cfg DepsCfg) (*Deps, error) { Language: cfg.Language, Site: cfg.Site, FileCaches: fileCaches, + MemCache: memCache, BuildStartListeners: &Listeners{}, BuildClosers: &Closers{}, BuildState: buildState, @@ -333,7 +347,7 @@ func (d Deps) ForLanguage(cfg DepsCfg, onCreated func(d *Deps) error) (*Deps, er // TODO(bep) clean up these inits. resourceCache := d.ResourceSpec.ResourceCache postBuildAssets := d.ResourceSpec.PostBuildAssets - d.ResourceSpec, err = resources.NewSpec(d.PathSpec, d.ResourceSpec.FileCaches, d.BuildState, d.Log, d.globalErrHandler, d.ExecHelper, cfg.OutputFormats, cfg.MediaTypes) + d.ResourceSpec, err = resources.NewSpec(d.PathSpec, d.ResourceSpec.FileCaches, d.MemCache, d.BuildState, d.Log, d.globalErrHandler, d.ExecHelper, cfg.OutputFormats, cfg.MediaTypes) if err != nil { return nil, err } diff --git a/go.mod b/go.mod index f10b4a91e66..894653e6ffa 100644 --- a/go.mod +++ b/go.mod @@ -2,8 +2,6 @@ module github.com/gohugoio/hugo require ( github.com/BurntSushi/locker v0.0.0-20171006230638-a6e239ea1c69 - github.com/PuerkitoBio/purell v1.1.1 - github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect github.com/alecthomas/chroma v0.9.4 github.com/armon/go-radix v1.0.0 github.com/aws/aws-sdk-go v1.41.14 @@ -17,8 +15,7 @@ require ( github.com/cli/safeexec v1.0.0 github.com/disintegration/gift v1.2.1 github.com/dustin/go-humanize v1.0.0 - github.com/evanw/esbuild v0.14.8 - github.com/fortytw2/leaktest v1.3.0 + github.com/evanw/esbuild v0.14.5 github.com/frankban/quicktest v1.14.0 github.com/fsnotify/fsnotify v1.5.1 github.com/getkin/kin-openapi v0.85.0 @@ -32,6 +29,7 @@ require ( github.com/google/go-cmp v0.5.6 github.com/gorilla/websocket v1.4.2 github.com/jdkato/prose v1.2.1 + github.com/karlseguin/ccache/v2 v2.0.8 github.com/kylelemons/godebug v1.1.0 github.com/kyokomi/emoji/v2 v2.2.8 github.com/magefile/mage v1.11.0 @@ -42,6 +40,7 @@ require ( github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect github.com/niklasfasching/go-org v1.6.0 github.com/olekukonko/tablewriter v0.0.5 + github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 github.com/pelletier/go-toml/v2 v2.0.0-beta.3.0.20210727221244-fa0796069526 github.com/pkg/errors v0.9.1 github.com/rogpeppe/go-internal v1.8.0 @@ -63,6 +62,7 @@ require ( golang.org/x/net v0.0.0-20210614182718-04defd469f4e golang.org/x/sync v0.0.0-20210220032951-036812b2e83c golang.org/x/text v0.3.7 + golang.org/x/tools v0.1.5 google.golang.org/api v0.61.0 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect gopkg.in/yaml.v2 v2.4.0 diff --git a/go.sum b/go.sum index fa4bc50416b..61d1191497d 100644 --- a/go.sum +++ b/go.sum @@ -101,10 +101,6 @@ github.com/GeertJohan/go.rice v1.0.0/go.mod h1:eH6gbSOAUv07dQuZVnBmoDP8mgsM1rtix github.com/GoogleCloudPlatform/cloudsql-proxy v0.0.0-20191009163259-e802c2cb94ae/go.mod h1:mjwGPas4yKduTyubHvD1Atl9r1rUq8DfVy+gkVvZ+oo= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= -github.com/PuerkitoBio/purell v1.1.1 h1:WEQqlqaGbrPkxLJWfBwQmfEAE1Z7ONdDLqrN38tNFfI= -github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= -github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 h1:d+Bc7a5rLufV/sSk/8dngufqelfh6jnri85riMAaF/M= -github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/akavel/rsrc v0.8.0/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c= github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38/go.mod h1:r7bzyVFMNntcxPZXK3/+KdruV1H5KSlyVY0gc+NgInI= github.com/alecthomas/chroma v0.7.2-0.20200305040604-4f3623dce67a/go.mod h1:fv5SzZPFJbwp2NXJWpFIX7DZS4HgV1K4ew4Pc2OZD9s= @@ -200,10 +196,9 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0 h1:d github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/protoc-gen-validate v0.1.0 h1:EQciDnbrYxy13PgWoY8AqoxGiPrpgBZ1R8UNe3ddc+A= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/evanw/esbuild v0.14.8 h1:klNT2CPoaBAWw2S3+j4joPWVqbwJBDUrOf+F+dGZ4EM= -github.com/evanw/esbuild v0.14.8/go.mod h1:GG+zjdi59yh3ehDn4ZWfPcATxjPDUH53iU4ZJbp7dkY= +github.com/evanw/esbuild v0.14.5 h1:Gh/vGvDL/g++7erzQZofohZqFBzQblWfLdtYCf15zcQ= +github.com/evanw/esbuild v0.14.5/go.mod h1:GG+zjdi59yh3ehDn4ZWfPcATxjPDUH53iU4ZJbp7dkY= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= github.com/frankban/quicktest v1.4.1/go.mod h1:36zfPVQyHxymz4cH7wlDmVwDrJuljRB60qkgn7rorfQ= github.com/frankban/quicktest v1.7.2/go.mod h1:jaStnuzAqU1AJdCO0l53JDCJrVDKcS03DbaAcR7Ks/o= @@ -382,6 +377,10 @@ github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/karlseguin/ccache/v2 v2.0.8 h1:lT38cE//uyf6KcFok0rlgXtGFBWxkI6h/qg4tbFyDnA= +github.com/karlseguin/ccache/v2 v2.0.8/go.mod h1:2BDThcfQMf/c0jnZowt16eW405XIqZPavt+HoYEtcxQ= +github.com/karlseguin/expect v1.0.2-0.20190806010014-778a5f0c6003 h1:vJ0Snvo+SLMY72r5J4sEfkuE7AFbixEP2qRbEcum/wA= +github.com/karlseguin/expect v1.0.2-0.20190806010014-778a5f0c6003/go.mod h1:zNBxMY8P21owkeogJELCLeHIt+voOSduHYTFUbwRAV8= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= @@ -449,6 +448,8 @@ github.com/nkovacs/streamquote v0.0.0-20170412213628-49af9bddb229/go.mod h1:0aYX github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= +github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 h1:onHthvaw9LFnH4t2DcNVpwGmV9E1BkGknEliJkfwQj0= +github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y= github.com/pelletier/go-toml v1.9.3 h1:zeC5b1GviRUyKYd6OJPvBU/mcVDVoL1OhT17FCt5dSQ= github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= github.com/pelletier/go-toml/v2 v2.0.0-beta.3.0.20210727221244-fa0796069526 h1:o8tGfr0zuKDD+3qIdzD1pK78melGepDQMb55F4Q6qlo= @@ -525,6 +526,8 @@ github.com/tdewolff/test v1.0.6 h1:76mzYJQ83Op284kMT+63iCNCI7NEERsIN8dLM+RiKr4= github.com/tdewolff/test v1.0.6/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8= +github.com/wsxiaoys/terminal v0.0.0-20160513160801-0940f3fc43a0 h1:3UeQBvD0TFrlVjOeLOBz+CPAI8dnbqNSVwUwRrkp7vQ= +github.com/wsxiaoys/terminal v0.0.0-20160513160801-0940f3fc43a0/go.mod h1:IXCdmsXIht47RaVFLEdVnh1t+pgYtTAhQGj73kz+2DM= github.com/yuin/goldmark v1.1.22/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= @@ -548,6 +551,7 @@ go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= go.opencensus.io v0.23.0 h1:gqCw0LfLxScz8irSi8exQc7fyQ0fKQU/qnC/X8+V/1M= go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= @@ -806,6 +810,7 @@ golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/helpers/general.go b/helpers/general.go index 74053123fa3..6776c788b70 100644 --- a/helpers/general.go +++ b/helpers/general.go @@ -517,6 +517,24 @@ func PrintFs(fs afero.Fs, path string, w io.Writer) { }) } +// FormatByteCount pretty formats b. +func FormatByteCount(bc uint64) string { + const ( + Gigabyte = 1 << 30 + Megabyte = 1 << 20 + Kilobyte = 1 << 10 + ) + switch { + case bc > Gigabyte || -bc > Gigabyte: + return fmt.Sprintf("%.2f GB", float64(bc)/Gigabyte) + case bc > Megabyte || -bc > Megabyte: + return fmt.Sprintf("%.2f MB", float64(bc)/Megabyte) + case bc > Kilobyte || -bc > Kilobyte: + return fmt.Sprintf("%.2f KB", float64(bc)/Kilobyte) + } + return fmt.Sprintf("%d B", bc) +} + // HashString returns a hash from the given elements. // It will panic if the hash cannot be calculated. func HashString(elements ...interface{}) string { diff --git a/helpers/path.go b/helpers/path.go index b504f5251dc..1a8a0c4bb22 100644 --- a/helpers/path.go +++ b/helpers/path.go @@ -22,12 +22,12 @@ import ( "regexp" "sort" "strings" - "unicode" "github.com/gohugoio/hugo/common/text" "github.com/gohugoio/hugo/config" + "github.com/gohugoio/hugo/common/paths" "github.com/gohugoio/hugo/hugofs" "github.com/gohugoio/hugo/common/hugio" @@ -44,7 +44,11 @@ var ErrThemeUndefined = errors.New("no theme set") // whilst preserving the original casing of the string. // E.g. Social Media -> Social-Media func (p *PathSpec) MakePath(s string) string { - return p.UnicodeSanitize(s) + s = paths.Sanitize(s) + if p.RemovePathAccents { + s = text.RemoveAccentsString(s) + } + return s } // MakePathsSanitized applies MakePathSanitized on every item in the slice @@ -73,52 +77,6 @@ func MakeTitle(inpath string) string { return strings.Replace(strings.TrimSpace(inpath), "-", " ", -1) } -// From https://golang.org/src/net/url/url.go -func ishex(c rune) bool { - switch { - case '0' <= c && c <= '9': - return true - case 'a' <= c && c <= 'f': - return true - case 'A' <= c && c <= 'F': - return true - } - return false -} - -// UnicodeSanitize sanitizes string to be used in Hugo URL's, allowing only -// a predefined set of special Unicode characters. -// If RemovePathAccents configuration flag is enabled, Unicode accents -// are also removed. -// Spaces will be replaced with a single hyphen, and sequential hyphens will be reduced to one. -func (p *PathSpec) UnicodeSanitize(s string) string { - if p.RemovePathAccents { - s = text.RemoveAccentsString(s) - } - - source := []rune(s) - target := make([]rune, 0, len(source)) - var prependHyphen bool - - for i, r := range source { - isAllowed := r == '.' || r == '/' || r == '\\' || r == '_' || r == '#' || r == '+' || r == '~' - isAllowed = isAllowed || unicode.IsLetter(r) || unicode.IsDigit(r) || unicode.IsMark(r) - isAllowed = isAllowed || (r == '%' && i+2 < len(source) && ishex(source[i+1]) && ishex(source[i+2])) - - if isAllowed { - if prependHyphen { - target = append(target, '-') - prependHyphen = false - } - target = append(target, r) - } else if len(target) > 0 && (r == '-' || unicode.IsSpace(r)) { - prependHyphen = true - } - } - - return string(target) -} - func makePathRelative(inPath string, possibleDirectories ...string) (string, error) { for _, currentPath := range possibleDirectories { if strings.HasPrefix(inPath, currentPath) { @@ -479,3 +437,18 @@ func AddTrailingSlash(path string) string { } return path } + +// AddLeadingSlash adds a leading Unix styled slash (/) if not already +// there. +func AddLeadingSlash(path string) string { + if !strings.HasPrefix(path, "/") { + path = "/" + path + } + return path +} + +// AddLeadingAndTrailingSlash adds a leading and trailing Unix styled slash (/) +// if not already there. +func AddLeadingAndTrailingSlash(path string) string { + return AddTrailingSlash(AddLeadingSlash(path)) +} diff --git a/helpers/path_test.go b/helpers/path_test.go index 1d2dc118431..e6fd899d5a4 100644 --- a/helpers/path_test.go +++ b/helpers/path_test.go @@ -44,6 +44,8 @@ func TestMakePath(t *testing.T) { {"Foo.Bar/foo_Bar-Foo", "Foo.Bar/foo_Bar-Foo", true}, {"fOO,bar:foobAR", "fOObarfoobAR", true}, {"FOo/BaR.html", "FOo/BaR.html", true}, + {"FOo/Ba---R.html", "FOo/Ba-R.html", true}, + {"FOo/Ba R.html", "FOo/Ba-R.html", true}, {"трям/трям", "трям/трям", true}, {"은행", "은행", true}, {"Банковский кассир", "Банковскии-кассир", true}, diff --git a/helpers/url.go b/helpers/url.go index 193dd3c8641..40740677163 100644 --- a/helpers/url.go +++ b/helpers/url.go @@ -20,79 +20,20 @@ import ( "strings" "github.com/gohugoio/hugo/common/paths" - - "github.com/PuerkitoBio/purell" ) -func sanitizeURLWithFlags(in string, f purell.NormalizationFlags) string { - s, err := purell.NormalizeURLString(in, f) - if err != nil { - return in - } - - // Temporary workaround for the bug fix and resulting - // behavioral change in purell.NormalizeURLString(): - // a leading '/' was inadvertently added to relative links, - // but no longer, see #878. - // - // I think the real solution is to allow Hugo to - // make relative URL with relative path, - // e.g. "../../post/hello-again/", as wished by users - // in issues #157, #622, etc., without forcing - // relative URLs to begin with '/'. - // Once the fixes are in, let's remove this kludge - // and restore SanitizeURL() to the way it was. - // -- @anthonyfok, 2015-02-16 - // - // Begin temporary kludge - u, err := url.Parse(s) - if err != nil { - panic(err) - } - if len(u.Path) > 0 && !strings.HasPrefix(u.Path, "/") { - u.Path = "/" + u.Path - } - return u.String() - // End temporary kludge - - // return s - -} - -// SanitizeURL sanitizes the input URL string. -func SanitizeURL(in string) string { - return sanitizeURLWithFlags(in, purell.FlagsSafe|purell.FlagRemoveTrailingSlash|purell.FlagRemoveDotSegments|purell.FlagRemoveDuplicateSlashes|purell.FlagRemoveUnnecessaryHostDots|purell.FlagRemoveEmptyPortSeparator) -} - -// SanitizeURLKeepTrailingSlash is the same as SanitizeURL, but will keep any trailing slash. -func SanitizeURLKeepTrailingSlash(in string) string { - return sanitizeURLWithFlags(in, purell.FlagsSafe|purell.FlagRemoveDotSegments|purell.FlagRemoveDuplicateSlashes|purell.FlagRemoveUnnecessaryHostDots|purell.FlagRemoveEmptyPortSeparator) -} - // URLize is similar to MakePath, but with Unicode handling // Example: // uri: Vim (text editor) // urlize: vim-text-editor func (p *PathSpec) URLize(uri string) string { - return p.URLEscape(p.MakePathSanitized(uri)) + return paths.URLEscape(p.MakePathSanitized(uri)) } // URLizeFilename creates an URL from a filename by escaping unicode letters // and turn any filepath separator into forward slashes. func (p *PathSpec) URLizeFilename(filename string) string { - return p.URLEscape(filepath.ToSlash(filename)) -} - -// URLEscape escapes unicode letters. -func (p *PathSpec) URLEscape(uri string) string { - // escape unicode letters - parsedURI, err := url.Parse(uri) - if err != nil { - // if net/url can not parse URL it means Sanitize works incorrectly - panic(err) - } - x := parsedURI.String() - return x + return filepath.ToSlash(paths.PathEscape(filename)) } // AbsURL creates an absolute URL from the relative path given and the BaseURL set in config. @@ -214,25 +155,3 @@ func (p *PathSpec) PrependBasePath(rel string, isAbs bool) string { } return rel } - -// URLizeAndPrep applies misc sanitation to the given URL to get it in line -// with the Hugo standard. -func (p *PathSpec) URLizeAndPrep(in string) string { - return p.URLPrep(p.URLize(in)) -} - -// URLPrep applies misc sanitation to the given URL. -func (p *PathSpec) URLPrep(in string) string { - if p.UglyURLs { - return paths.Uglify(SanitizeURL(in)) - } - pretty := paths.PrettifyURL(SanitizeURL(in)) - if path.Ext(pretty) == ".xml" { - return pretty - } - url, err := purell.NormalizeURLString(pretty, purell.FlagAddTrailingSlash) - if err != nil { - return pretty - } - return url -} diff --git a/helpers/url_test.go b/helpers/url_test.go index f899e1cdbb9..2090bd579d1 100644 --- a/helpers/url_test.go +++ b/helpers/url_test.go @@ -14,9 +14,13 @@ package helpers import ( + "net/url" + "path" "strings" "testing" + "github.com/gohugoio/hugo/common/paths" + "github.com/gohugoio/hugo/hugofs" "github.com/gohugoio/hugo/langs" ) @@ -46,6 +50,72 @@ func TestURLize(t *testing.T) { } } +// TODO1 remove this. +func BenchmarkURLEscape(b *testing.B) { + const ( + input = "трям/трям" + expect = "%D1%82%D1%80%D1%8F%D0%BC/%D1%82%D1%80%D1%8F%D0%BC" + forwardSlashReplacement = "ABC" + ) + + fn1 := func(s string) string { + ss, err := url.Parse(s) + if err != nil { + panic(err) + } + return ss.EscapedPath() + } + + fn2 := func(s string) string { + s = strings.ReplaceAll(s, "/", forwardSlashReplacement) + s = url.PathEscape(s) + s = strings.ReplaceAll(s, forwardSlashReplacement, "/") + + return s + } + + fn3 := func(s string) string { + parts := paths.FieldsSlash(s) + for i, part := range parts { + parts[i] = url.PathEscape(part) + } + + return path.Join(parts...) + } + + benchFunc := func(b *testing.B, fn func(s string) string) { + for i := 0; i < b.N; i++ { + res := fn(input) + if res != expect { + b.Fatal(res) + } + } + } + + b.Run("url.Parse", func(b *testing.B) { + benchFunc(b, fn1) + }) + + b.Run("url.PathEscape_replace", func(b *testing.B) { + benchFunc(b, fn2) + }) + + b.Run("url.PathEscape_fields", func(b *testing.B) { + benchFunc(b, fn3) + }) + + b.Run("url.PathEscape", func(b *testing.B) { + for i := 0; i < b.N; i++ { + res := url.PathEscape(input) + // url.PathEscape also escapes forward slash. + if res != "%D1%82%D1%80%D1%8F%D0%BC%2F%D1%82%D1%80%D1%8F%D0%BC" { + panic(res) + } + } + }) + +} + func TestAbsURL(t *testing.T) { for _, defaultInSubDir := range []bool{true, false} { for _, addLanguage := range []bool{true, false} { @@ -194,57 +264,3 @@ func doTestRelURL(t *testing.T, defaultInSubDir, addLanguage, multilingual bool, } } } - -func TestSanitizeURL(t *testing.T) { - tests := []struct { - input string - expected string - }{ - {"http://foo.bar/", "http://foo.bar"}, - {"http://foo.bar", "http://foo.bar"}, // issue #1105 - {"http://foo.bar/zoo/", "http://foo.bar/zoo"}, // issue #931 - } - - for i, test := range tests { - o1 := SanitizeURL(test.input) - o2 := SanitizeURLKeepTrailingSlash(test.input) - - expected2 := test.expected - - if strings.HasSuffix(test.input, "/") && !strings.HasSuffix(expected2, "/") { - expected2 += "/" - } - - if o1 != test.expected { - t.Errorf("[%d] 1: Expected %#v, got %#v\n", i, test.expected, o1) - } - if o2 != expected2 { - t.Errorf("[%d] 2: Expected %#v, got %#v\n", i, expected2, o2) - } - } -} - -func TestURLPrep(t *testing.T) { - type test struct { - ugly bool - input string - output string - } - - data := []test{ - {false, "/section/name.html", "/section/name/"}, - {true, "/section/name/index.html", "/section/name.html"}, - } - - for i, d := range data { - v := newTestCfg() - v.Set("uglyURLs", d.ugly) - l := langs.NewDefaultLanguage(v) - p, _ := NewPathSpec(hugofs.NewMem(v), l, nil) - - output := p.URLPrep(d.input) - if d.output != output { - t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output) - } - } -} diff --git a/htesting/test_helpers.go b/htesting/test_helpers.go index fa3f29c44cb..d39bd6d35d2 100644 --- a/htesting/test_helpers.go +++ b/htesting/test_helpers.go @@ -14,14 +14,18 @@ package htesting import ( + "fmt" "math/rand" "os" "regexp" "runtime" "strconv" "strings" + "testing" "time" + qt "github.com/frankban/quicktest" + "github.com/spf13/afero" ) @@ -107,6 +111,11 @@ func IsCI() bool { return (os.Getenv("CI") != "" || os.Getenv("CI_LOCAL") != "") && os.Getenv("CIRCLE_BRANCH") == "" } +// IsWindows reports whether this runs on Windows. +func IsWindows() bool { + return runtime.GOOS == "windows" +} + // IsGitHubAction reports whether we're running in a GitHub Action. func IsGitHubAction() bool { return os.Getenv("GITHUB_ACTION") != "" @@ -140,5 +149,47 @@ func extractMinorVersionFromGoTag(tag string) int { // a commit hash, not useful. return -1 +} + +// Println should only be used for temporary debugging. +func Println(a ...interface{}) { + if !IsTest { + panic("tprintln left in production code") + } + fmt.Println(a...) +} + +// Printf should only be used for temporary debugging. +func Printf(format string, a ...interface{}) { + if !IsTest { + // panic("tprintf left in production code") + } + fmt.Printf(format, a...) +} + +func NewPinnedRunner(t testing.TB, pinnedTestRe string) *PinnedRunner { + if pinnedTestRe == "" { + pinnedTestRe = ".*" + } + re := regexp.MustCompile("(?i)" + pinnedTestRe) + return &PinnedRunner{ + c: qt.New(t), + re: re, + } +} +type PinnedRunner struct { + c *qt.C + re *regexp.Regexp +} + +func (r *PinnedRunner) Run(name string, f func(c *qt.C)) bool { + if !r.re.MatchString(name) { + if IsCI() { + // TODO1 enable + // r.c.Fatal("found pinned test when running in CI") + } + return true + } + return r.c.Run(name, f) } diff --git a/hugofs/fileinfo.go b/hugofs/fileinfo.go index 0a958a0c547..42f0f007c47 100644 --- a/hugofs/fileinfo.go +++ b/hugofs/fileinfo.go @@ -31,6 +31,7 @@ import ( "github.com/pkg/errors" "github.com/gohugoio/hugo/common/hreflect" + "github.com/gohugoio/hugo/common/paths" "github.com/spf13/afero" ) @@ -42,12 +43,14 @@ func NewFileMeta() *FileMeta { // PathFile returns the relative file path for the file source. func (f *FileMeta) PathFile() string { if f.BaseDir == "" { - return "" + return f.Filename } return strings.TrimPrefix(strings.TrimPrefix(f.Filename, f.BaseDir), filepathSeparator) } type FileMeta struct { + PathInfo *paths.Path + Name string Filename string Path string @@ -58,6 +61,7 @@ type FileMeta struct { SourceRoot string MountRoot string Module string + Component string Weight int Ordinal int @@ -71,10 +75,11 @@ type FileMeta struct { SkipDir bool - Lang string - TranslationBaseName string - TranslationBaseNameWithExt string - Translations []string + Lang string + Translations []string + + // TranslationBaseName string + // TranslationBaseNameWithExt string Fs afero.Fs OpenFunc func() (afero.File, error) @@ -133,6 +138,10 @@ type FileMetaInfo interface { Meta() *FileMeta } +type FileInfoProvider interface { + FileInfo() FileMetaInfo +} + type fileInfoMeta struct { os.FileInfo diff --git a/hugofs/files/classifier.go b/hugofs/files/classifier.go index 09b239c21a9..f352dc6df14 100644 --- a/hugofs/files/classifier.go +++ b/hugofs/files/classifier.go @@ -89,6 +89,7 @@ func IsContentExt(ext string) bool { type ContentClass string const ( + // TODO1 remove this. ContentClassLeaf ContentClass = "leaf" ContentClassBranch ContentClass = "branch" ContentClassFile ContentClass = "zfile" // Sort below diff --git a/hugofs/filter_fs.go b/hugofs/filter_fs.go index 9da63bbb794..8edc476ca06 100644 --- a/hugofs/filter_fs.go +++ b/hugofs/filter_fs.go @@ -19,7 +19,6 @@ import ( "os" "path/filepath" "sort" - "strings" "syscall" "time" @@ -44,9 +43,10 @@ func NewLanguageFs(langs map[string]int, fs afero.Fs) (afero.Fs, error) { } meta := fi.(FileMetaInfo).Meta() + pathInfo := meta.PathInfo lang := meta.Lang + fileLang := pathInfo.Lang() - fileLang, translationBaseName, translationBaseNameWithExt := langInfoFrom(langs, fi.Name()) weight := 0 if fileLang != "" { @@ -61,12 +61,11 @@ func NewLanguageFs(langs map[string]int, fs afero.Fs) (afero.Fs, error) { fim := NewFileMetaInfo( fi, &FileMeta{ - Lang: lang, - Weight: weight, - Ordinal: langs[lang], - TranslationBaseName: translationBaseName, - TranslationBaseNameWithExt: translationBaseNameWithExt, - Classifier: files.ClassifyContentFile(fi.Name(), meta.OpenFunc), + Lang: lang, + Weight: weight, + Ordinal: langs[lang], + PathInfo: pathInfo, + Classifier: files.ClassifyContentFile(fi.Name(), meta.OpenFunc), }) fis[i] = fim @@ -77,7 +76,7 @@ func NewLanguageFs(langs map[string]int, fs afero.Fs) (afero.Fs, error) { // Maps translation base name to a list of language codes. translations := make(map[string][]string) trackTranslation := func(meta *FileMeta) { - name := meta.TranslationBaseNameWithExt + name := meta.PathInfo.NameNoLang() translations[name] = append(translations[name], meta.Lang) } for _, fi := range fis { @@ -92,18 +91,25 @@ func NewLanguageFs(langs map[string]int, fs afero.Fs) (afero.Fs, error) { for _, fi := range fis { fim := fi.(FileMetaInfo) - langs := translations[fim.Meta().TranslationBaseNameWithExt] + langs := translations[fim.Meta().PathInfo.NameNoLang()] if len(langs) > 0 { fim.Meta().Translations = sortAndremoveStringDuplicates(langs) } } } - return &FilterFs{ + ffs := &FilterFs{ fs: fs, applyPerSource: applyMeta, applyAll: all, - }, nil + } + + if rfs, ok := fs.(ReverseLookupProvider); ok { + // Preserve that interface. + return NewExtendedFs(ffs, rfs), nil + } + + return ffs, nil } func NewFilterFs(fs afero.Fs) (afero.Fs, error) { @@ -120,6 +126,11 @@ func NewFilterFs(fs afero.Fs) (afero.Fs, error) { applyPerSource: applyMeta, } + if rfs, ok := fs.(ReverseLookupProvider); ok { + // Preserve that interface. + return NewExtendedFs(ffs, rfs), nil + } + return ffs, nil } @@ -281,37 +292,6 @@ func (f *filterDir) Readdirnames(count int) ([]string, error) { return dirs, nil } -// Try to extract the language from the given filename. -// Any valid language identifier in the name will win over the -// language set on the file system, e.g. "mypost.en.md". -func langInfoFrom(languages map[string]int, name string) (string, string, string) { - var lang string - - baseName := filepath.Base(name) - ext := filepath.Ext(baseName) - translationBaseName := baseName - - if ext != "" { - translationBaseName = strings.TrimSuffix(translationBaseName, ext) - } - - fileLangExt := filepath.Ext(translationBaseName) - fileLang := strings.TrimPrefix(fileLangExt, ".") - - if _, found := languages[fileLang]; found { - lang = fileLang - translationBaseName = strings.TrimSuffix(translationBaseName, fileLangExt) - } - - translationBaseNameWithExt := translationBaseName - - if ext != "" { - translationBaseNameWithExt += ext - } - - return lang, translationBaseName, translationBaseNameWithExt -} - func printFs(fs afero.Fs, path string, w io.Writer) { if fs == nil { return diff --git a/hugofs/filter_fs_test.go b/hugofs/filter_fs_test.go deleted file mode 100644 index 524d957d678..00000000000 --- a/hugofs/filter_fs_test.go +++ /dev/null @@ -1,46 +0,0 @@ -// 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 hugofs - -import ( - "path/filepath" - "testing" - - qt "github.com/frankban/quicktest" -) - -func TestLangInfoFrom(t *testing.T) { - langs := map[string]int{ - "sv": 10, - "en": 20, - } - - c := qt.New(t) - - tests := []struct { - input string - expected []string - }{ - {"page.sv.md", []string{"sv", "page", "page.md"}}, - {"page.en.md", []string{"en", "page", "page.md"}}, - {"page.no.md", []string{"", "page.no", "page.no.md"}}, - {filepath.FromSlash("tc-lib-color/class-Com.Tecnick.Color.Css"), []string{"", "class-Com.Tecnick.Color", "class-Com.Tecnick.Color.Css"}}, - {filepath.FromSlash("class-Com.Tecnick.Color.sv.Css"), []string{"sv", "class-Com.Tecnick.Color", "class-Com.Tecnick.Color.Css"}}, - } - - for _, test := range tests { - v1, v2, v3 := langInfoFrom(langs, test.input) - c.Assert([]string{v1, v2, v3}, qt.DeepEquals, test.expected) - } -} diff --git a/hugofs/language_composite_fs.go b/hugofs/language_composite_fs.go index 09c4540a97b..4a5ed77aab7 100644 --- a/hugofs/language_composite_fs.go +++ b/hugofs/language_composite_fs.go @@ -26,6 +26,8 @@ var ( ) type languageCompositeFs struct { + base ExtendedFs + overlay ExtendedFs *afero.CopyOnWriteFs } @@ -33,8 +35,12 @@ type languageCompositeFs struct { // This is a hybrid filesystem. To get a specific file in Open, Stat etc., use the full filename // to the target filesystem. This information is available in Readdir, Stat etc. via the // special LanguageFileInfo FileInfo implementation. -func NewLanguageCompositeFs(base, overlay afero.Fs) afero.Fs { - return &languageCompositeFs{afero.NewCopyOnWriteFs(base, overlay).(*afero.CopyOnWriteFs)} +func NewLanguageCompositeFs(base, overlay ExtendedFs) ExtendedFs { + return &languageCompositeFs{ + base: base, + overlay: overlay, + CopyOnWriteFs: afero.NewCopyOnWriteFs(base, overlay).(*afero.CopyOnWriteFs), + } } // Open takes the full path to the file in the target filesystem. If it is a directory, it gets merged @@ -53,6 +59,16 @@ func (fs *languageCompositeFs) Open(name string) (afero.File, error) { return f, nil } +func (fs *languageCompositeFs) ReverseLookup(name string) (string, error) { + // Try the overlay first. + s, err := fs.overlay.ReverseLookup(name) + if s != "" || err != nil { + return s, err + } + + return fs.base.ReverseLookup(name) +} + // LanguageDirsMerger implements the afero.DirsMerger interface, which is used // to merge two directories. var LanguageDirsMerger = func(lofi, bofi []os.FileInfo) ([]os.FileInfo, error) { diff --git a/hugofs/rootmapping_fs.go b/hugofs/rootmapping_fs.go index 9fdce3ad760..82696ffe728 100644 --- a/hugofs/rootmapping_fs.go +++ b/hugofs/rootmapping_fs.go @@ -27,6 +27,27 @@ import ( "github.com/spf13/afero" ) +var _ ReverseLookupProvider = (*RootMappingFs)(nil) + +type ExtendedFs interface { + afero.Fs + ReverseLookupProvider +} + +func NewExtendedFs(fs afero.Fs, rl ReverseLookupProvider) ExtendedFs { + return struct { + afero.Fs + ReverseLookupProvider + }{ + fs, + rl, + } +} + +type ReverseLookupProvider interface { + ReverseLookup(name string) (string, error) +} + var filepathSeparator = string(filepath.Separator) // NewRootMappingFs creates a new RootMappingFs on top of the provided with @@ -34,8 +55,20 @@ var filepathSeparator = string(filepath.Separator) // Note that From represents a virtual root that maps to the actual filename in To. func NewRootMappingFs(fs afero.Fs, rms ...RootMapping) (*RootMappingFs, error) { rootMapToReal := radix.New() + realMapToRoot := radix.New() var virtualRoots []RootMapping + addMapping := func(key string, rm RootMapping, to *radix.Tree) { + var mappings []RootMapping + v, found := to.Get(key) + if found { + // There may be more than one language pointing to the same root. + mappings = v.([]RootMapping) + } + mappings = append(mappings, rm) + to.Insert(key, mappings) + } + for _, rm := range rms { (&rm).clean() @@ -62,6 +95,7 @@ func NewRootMappingFs(fs afero.Fs, rms ...RootMapping) (*RootMappingFs, error) { rm.Meta.BaseDir = rm.ToBasedir rm.Meta.MountRoot = rm.path rm.Meta.Module = rm.Module + rm.Meta.Component = fromBase rm.Meta.IsProject = rm.IsProject meta := rm.Meta.Copy() @@ -73,15 +107,8 @@ func NewRootMappingFs(fs afero.Fs, rms ...RootMapping) (*RootMappingFs, error) { rm.fi = NewFileMetaInfo(fi, meta) - key := filepathSeparator + rm.From - var mappings []RootMapping - v, found := rootMapToReal.Get(key) - if found { - // There may be more than one language pointing to the same root. - mappings = v.([]RootMapping) - } - mappings = append(mappings, rm) - rootMapToReal.Insert(key, mappings) + addMapping(filepathSeparator+rm.From, rm, rootMapToReal) + addMapping(strings.TrimPrefix(rm.To, rm.ToBasedir), rm, realMapToRoot) virtualRoots = append(virtualRoots, rm) } @@ -91,6 +118,7 @@ func NewRootMappingFs(fs afero.Fs, rms ...RootMapping) (*RootMappingFs, error) { rfs := &RootMappingFs{ Fs: fs, rootMapToReal: rootMapToReal, + realMapToRoot: realMapToRoot, } return rfs, nil @@ -151,12 +179,11 @@ func (r RootMapping) trimFrom(name string) string { return strings.TrimPrefix(name, r.From) } -// A RootMappingFs maps several roots into one. Note that the root of this filesystem -// is directories only, and they will be returned in Readdir and Readdirnames -// in the order given. +// A RootMappingFs maps several roots into one. type RootMappingFs struct { afero.Fs rootMapToReal *radix.Tree + realMapToRoot *radix.Tree } func (fs *RootMappingFs) Dirs(base string) ([]FileMetaInfo, error) { @@ -248,6 +275,26 @@ func (fs *RootMappingFs) Stat(name string) (os.FileInfo, error) { return fi, err } +func (fs *RootMappingFs) ReverseLookup(name string) (string, error) { + name = fs.cleanName(name) + key := filepathSeparator + name + s, roots := fs.getRootsReverse(key) + + if roots == nil { + // TODO1 lang + return "", nil + } + + first := roots[0] + if !first.fi.IsDir() { + return first.path, nil + } + + name = strings.TrimPrefix(key, s) + + return filepath.Join(first.path, name), nil +} + func (fs *RootMappingFs) hasPrefix(prefix string) bool { hasPrefix := false fs.rootMapToReal.WalkPrefix(prefix, func(b string, v interface{}) bool { @@ -268,7 +315,15 @@ func (fs *RootMappingFs) getRoot(key string) []RootMapping { } func (fs *RootMappingFs) getRoots(key string) (string, []RootMapping) { - s, v, found := fs.rootMapToReal.LongestPrefix(key) + return fs.getRootsIn(key, fs.rootMapToReal) +} + +func (fs *RootMappingFs) getRootsReverse(key string) (string, []RootMapping) { + return fs.getRootsIn(key, fs.realMapToRoot) +} + +func (fs *RootMappingFs) getRootsIn(key string, tree *radix.Tree) (string, []RootMapping) { + s, v, found := tree.LongestPrefix(key) if !found || (s == filepathSeparator && key != filepathSeparator) { return "", nil } @@ -276,11 +331,17 @@ func (fs *RootMappingFs) getRoots(key string) (string, []RootMapping) { } func (fs *RootMappingFs) debug() { - fmt.Println("debug():") + fmt.Println("rootMapToReal:") fs.rootMapToReal.Walk(func(s string, v interface{}) bool { fmt.Println("Key", s) return false }) + + fmt.Println("realMapToRoot:") + fs.realMapToRoot.Walk(func(s string, v interface{}) bool { + fmt.Println("Key", s) + return false + }) } func (fs *RootMappingFs) getRootsWithPrefix(prefix string) []RootMapping { diff --git a/hugofs/rootmapping_fs_test.go b/hugofs/rootmapping_fs_test.go index c650e8f110d..647f50bbe29 100644 --- a/hugofs/rootmapping_fs_test.go +++ b/hugofs/rootmapping_fs_test.go @@ -288,6 +288,9 @@ func TestRootMappingFsMount(t *testing.T) { c.Assert(fi.Meta().Lang, qt.Equals, lang) c.Assert(fi.Name(), qt.Equals, "p1.md") } + + //s, _ := rfs.ReverseLookup("singlefiles/sv.txt") + //TODO1 fixme c.Assert(s, qt.Equals, filepath.FromSlash("singles/p1.md")) } func TestRootMappingFsMountOverlap(t *testing.T) { diff --git a/hugofs/walk.go b/hugofs/walk.go index 44d58f06085..7a68f44c1aa 100644 --- a/hugofs/walk.go +++ b/hugofs/walk.go @@ -21,6 +21,7 @@ import ( "strings" "github.com/gohugoio/hugo/common/loggers" + "github.com/gohugoio/hugo/common/paths" "github.com/pkg/errors" @@ -37,6 +38,8 @@ type Walkway struct { root string basePath string + doFoo bool + logger loggers.Logger // May be pre-set @@ -55,8 +58,10 @@ type Walkway struct { } type WalkwayConfig struct { - Fs afero.Fs - Root string + Fs afero.Fs + Root string + + // TODO1 check if we can remove. BasePath string Logger loggers.Logger @@ -65,6 +70,9 @@ type WalkwayConfig struct { Info FileMetaInfo DirEntries []FileMetaInfo + // TODO1 + DoFoo bool + WalkFn WalkFunc HookPre WalkHook HookPost WalkHook @@ -97,6 +105,7 @@ func NewWalkway(cfg WalkwayConfig) *Walkway { walkFn: cfg.WalkFn, hookPre: cfg.HookPre, hookPost: cfg.HookPost, + doFoo: cfg.DoFoo, logger: logger, seen: make(map[string]bool), } @@ -260,15 +269,19 @@ func (w *Walkway) walk(path string, info FileMetaInfo, dirEntries []FileMetaInfo if name == "" { panic(fmt.Sprintf("[%s] no name set in %v", path, meta)) } - pathn := filepath.Join(path, name) - pathMeta := pathn - if w.basePath != "" { - pathMeta = strings.TrimPrefix(pathn, w.basePath) - } + if meta.PathInfo == nil { + pathn := filepath.Join(path, name) - meta.Path = normalizeFilename(pathMeta) - meta.PathWalk = pathn + pathMeta := pathn + if w.basePath != "" { + pathMeta = strings.TrimPrefix(pathn, w.basePath) // TODO1 basePath usage? + } + + meta.Path = normalizeFilename(pathMeta) + meta.PathInfo = paths.Parse(meta.Path, paths.ForComponent(meta.Component)) + meta.PathWalk = pathn + } if fim.IsDir() && w.isSeen(meta.Filename) { // Prevent infinite recursion diff --git a/hugolib/alias.go b/hugolib/alias.go index 2609cd6bb49..a9832ab6cd3 100644 --- a/hugolib/alias.go +++ b/hugolib/alias.go @@ -43,7 +43,11 @@ func newAliasHandler(t tpl.TemplateHandler, l loggers.Logger, allowRoot bool) al type aliasPage struct { Permalink string - page.Page + p page.Page +} + +func (p aliasPage) Page() page.Page { + return p.p } func (a aliasHandler) renderAlias(permalink string, p page.Page) (io.Reader, error) { diff --git a/hugolib/breaking_changes_test.go b/hugolib/breaking_changes_test.go index 495baff3ec4..c5ca87a911c 100644 --- a/hugolib/breaking_changes_test.go +++ b/hugolib/breaking_changes_test.go @@ -23,7 +23,6 @@ import ( func Test073(t *testing.T) { assertDisabledTaxonomyAndTerm := func(b *sitesBuilder, taxonomy, term bool) { b.Assert(b.CheckExists("public/tags/index.html"), qt.Equals, taxonomy) - b.Assert(b.CheckExists("public/tags/tag1/index.html"), qt.Equals, term) } assertOutputTaxonomyAndTerm := func(b *sitesBuilder, taxonomy, term bool) { diff --git a/hugolib/cascade_test.go b/hugolib/cascade_test.go index 000b641e54d..2e73df51a6a 100644 --- a/hugolib/cascade_test.go +++ b/hugolib/cascade_test.go @@ -106,13 +106,10 @@ cascade: "draft": bool(false), "iscjklanguage": bool(false), }) - } - }) } - } func TestCascade(t *testing.T) { @@ -126,14 +123,14 @@ func TestCascade(t *testing.T) { b.AssertFileContent("public/index.html", ` 12|term|categories/cool/_index.md|Cascade Category|cat.png|categories|HTML-| -12|term|categories/catsect1|catsect1|cat.png|categories|HTML-| -12|term|categories/funny|funny|cat.png|categories|HTML-| +12|term|/categories/catsect1|catsect1|cat.png|categories|HTML-| +12|term|/categories/funny|funny|cat.png|categories|HTML-| 12|taxonomy|categories/_index.md|My Categories|cat.png|categories|HTML-| 32|term|categories/sad/_index.md|Cascade Category|sad.png|categories|HTML-| -42|term|tags/blue|blue|home.png|tags|HTML-| -42|taxonomy|tags|Cascade Home|home.png|tags|HTML-| -42|section|sectnocontent|Cascade Home|home.png|sectnocontent|HTML-| -42|section|sect3|Cascade Home|home.png|sect3|HTML-| +42|term|/tags/blue|blue|home.png|tags|HTML-| +42|taxonomy|/tags|Cascade Home|home.png|tags|HTML-| +42|section|/sectnocontent|Cascade Home|home.png|sectnocontent|HTML-| +42|section|/sect3|Cascade Home|home.png|sect3|HTML-| 42|page|bundle1/index.md|Cascade Home|home.png|page|HTML-| 42|page|p2.md|Cascade Home|home.png|page|HTML-| 42|page|sect2/p2.md|Cascade Home|home.png|sect2|HTML-| @@ -141,7 +138,7 @@ func TestCascade(t *testing.T) { 42|page|sect3/p1.md|Cascade Home|home.png|sect3|HTML-| 42|page|sectnocontent/p1.md|Cascade Home|home.png|sectnocontent|HTML-| 42|section|sectnofrontmatter/_index.md|Cascade Home|home.png|sectnofrontmatter|HTML-| -42|term|tags/green|green|home.png|tags|HTML-| +42|term|/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-| diff --git a/hugolib/case_insensitive_test.go b/hugolib/case_insensitive_test.go index 9aa88ab5bb0..2b149dc96fe 100644 --- a/hugolib/case_insensitive_test.go +++ b/hugolib/case_insensitive_test.go @@ -34,7 +34,7 @@ defaultContentLanguageInSubdir = true AngledQuotes = true HrefTargetBlank = true -[Params] +[Params] Search = true Color = "green" mood = "Happy" diff --git a/hugolib/collections_test.go b/hugolib/collections_test.go index 6925d41cdd3..24e1f7bf2fe 100644 --- a/hugolib/collections_test.go +++ b/hugolib/collections_test.go @@ -82,8 +82,8 @@ tags_weight: %d c.Assert(len(b.H.Sites[0].RegularPages()), qt.Equals, 2) b.AssertFileContent("public/index.html", - "pages:2:page.Pages:Page(/page1.md)/Page(/page2.md)", - "pageGroups:2:page.PagesGroup:Page(/page1.md)/Page(/page2.md)", + "pages:2:page.Pages:Page(/page1)/Page(/page2)", + "pageGroups:2:page.PagesGroup:Page(/page1)/Page(/page2)", `weightedPages:2::page.WeightedPages:[WeightedPage(10,"Page") WeightedPage(20,"Page")]`) } @@ -96,7 +96,6 @@ title: "Page" tags: ["blue", "green"] tags_weight: %d --- - ` b := newTestSitesBuilder(t) b.WithSimpleConfigFile(). diff --git a/hugolib/content_factory.go b/hugolib/content_factory.go index cc87dd9e559..3487a0cbc69 100644 --- a/hugolib/content_factory.go +++ b/hugolib/content_factory.go @@ -14,12 +14,13 @@ package hugolib import ( + "context" "io" "path/filepath" "strings" "time" - "github.com/gohugoio/hugo/helpers" + "github.com/gohugoio/hugo/common/paths" "github.com/gohugoio/hugo/source" @@ -41,7 +42,6 @@ type ContentFactory struct { // AppplyArchetypeFilename archetypeFilename to w as a template using the given Page p as the foundation for the data context. func (f ContentFactory) AppplyArchetypeFilename(w io.Writer, p page.Page, archetypeKind, archetypeFilename string) error { - fi, err := f.h.SourceFilesystems.Archetypes.Fs.Stat(archetypeFilename) if err != nil { return err @@ -54,11 +54,9 @@ func (f ContentFactory) AppplyArchetypeFilename(w io.Writer, p page.Page, archet templateSource, err := afero.ReadFile(f.h.SourceFilesystems.Archetypes.Fs, archetypeFilename) if err != nil { return errors.Wrapf(err, "failed to read archetype file %q: %s", archetypeFilename, err) - } return f.AppplyArchetypeTemplate(w, p, archetypeKind, string(templateSource)) - } // AppplyArchetypeFilename templateSource to w as a template using the given Page p as the foundation for the data context. @@ -82,7 +80,7 @@ func (f ContentFactory) AppplyArchetypeTemplate(w io.Writer, p page.Page, archet return errors.Wrapf(err, "failed to parse archetype template: %s", err) } - result, err := executeToString(ps.s.Tmpl(), templ, d) + result, err := executeToString(context.Background(), ps.s.Tmpl(), templ, d) if err != nil { return errors.Wrapf(err, "failed to execute archetype template: %s", err) } @@ -90,7 +88,6 @@ func (f ContentFactory) AppplyArchetypeTemplate(w io.Writer, p page.Page, archet _, err = io.WriteString(w, f.shortocdeReplacerPost.Replace(result)) return err - } func (f ContentFactory) SectionFromFilename(filename string) (string, error) { @@ -99,12 +96,7 @@ func (f ContentFactory) SectionFromFilename(filename string) (string, error) { if err != nil { return "", err } - - parts := strings.Split(helpers.ToSlashTrimLeading(rel), "/") - if len(parts) < 2 { - return "", nil - } - return parts[0], nil + return paths.Parse(filepath.ToSlash(rel)).Section(), nil } // CreateContentPlaceHolder creates a content placeholder file inside the @@ -163,7 +155,7 @@ type archetypeFileData struct { // File is the same as Page.File, embedded here for historic reasons. // TODO(bep) make this a method. - source.File + *source.File } func (f *archetypeFileData) Site() page.Site { diff --git a/hugolib/content_map.go b/hugolib/content_map.go index 29e821f754f..75537243afd 100644 --- a/hugolib/content_map.go +++ b/hugolib/content_map.go @@ -14,1049 +14,515 @@ package hugolib import ( - "fmt" "path" "path/filepath" + "reflect" "strings" "sync" + "unicode" - "github.com/gohugoio/hugo/helpers" + "github.com/gohugoio/hugo/common/maps" + "github.com/gohugoio/hugo/common/paths" + "github.com/gohugoio/hugo/identity" + "github.com/gohugoio/hugo/parser/pageparser" - "github.com/gohugoio/hugo/resources/page" - "github.com/pkg/errors" + "github.com/gohugoio/hugo/resources/page/pagekinds" - "github.com/gohugoio/hugo/hugofs/files" + "github.com/gobuffalo/flect" + "github.com/gohugoio/hugo/output" - "github.com/gohugoio/hugo/hugofs" + "github.com/gohugoio/hugo/common/types" - radix "github.com/armon/go-radix" -) + "github.com/gohugoio/hugo/helpers" -// We store the branch nodes in either the `sections` or `taxonomies` tree -// with their path as a key; Unix style slashes, a leading and trailing slash. -// -// E.g. "/blog/" or "/categories/funny/" -// -// Pages that belongs to a section are stored in the `pages` tree below -// the section name and a branch separator, e.g. "/blog/__hb_". A page is -// given a key using the path below the section and the base filename with no extension -// with a leaf separator added. -// -// For bundled pages (/mybundle/index.md), we use the folder name. -// -// An exmple of a full page key would be "/blog/__hb_page1__hl_" -// -// Bundled resources are stored in the `resources` having their path prefixed -// with the bundle they belong to, e.g. -// "/blog/__hb_bundle__hl_data.json". -// -// The weighted taxonomy entries extracted from page front matter are stored in -// the `taxonomyEntries` tree below /plural/term/page-key, e.g. -// "/categories/funny/blog/__hb_bundle__hl_". -const ( - cmBranchSeparator = "__hb_" - cmLeafSeparator = "__hl_" + "github.com/gohugoio/hugo/hugofs" ) // Used to mark ambiguous keys in reverse index lookups. var ambiguousContentNode = &contentNode{} -func newContentMap(cfg contentMapConfig) *contentMap { - m := &contentMap{ - cfg: &cfg, - pages: &contentTree{Name: "pages", Tree: radix.New()}, - sections: &contentTree{Name: "sections", Tree: radix.New()}, - taxonomies: &contentTree{Name: "taxonomies", Tree: radix.New()}, - taxonomyEntries: &contentTree{Name: "taxonomyEntries", Tree: radix.New()}, - resources: &contentTree{Name: "resources", Tree: radix.New()}, - } - - m.pageTrees = []*contentTree{ - m.pages, m.sections, m.taxonomies, - } - - m.bundleTrees = []*contentTree{ - m.pages, m.sections, m.taxonomies, m.resources, - } - - m.branchTrees = []*contentTree{ - m.sections, m.taxonomies, - } - - addToReverseMap := func(k string, n *contentNode, m map[interface{}]*contentNode) { - k = strings.ToLower(k) - existing, found := m[k] - if found && existing != ambiguousContentNode { - m[k] = ambiguousContentNode - } else if !found { - m[k] = n +var ( + contentTreeNoListAlwaysFilter = func(s string, n *contentNode) bool { + if n.p == nil { + return true } + return n.p.m.noListAlways() } - m.pageReverseIndex = &contentTreeReverseIndex{ - t: []*contentTree{m.pages, m.sections, m.taxonomies}, - contentTreeReverseIndexMap: &contentTreeReverseIndexMap{ - initFn: func(t *contentTree, m map[interface{}]*contentNode) { - t.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) - if n.p != nil && !n.p.File().IsZero() { - meta := n.p.File().FileInfo().Meta() - if meta.Path != meta.PathFile() { - // Keep track of the original mount source. - mountKey := filepath.ToSlash(filepath.Join(meta.Module, meta.PathFile())) - addToReverseMap(mountKey, n, m) - } - } - k := strings.TrimPrefix(strings.TrimSuffix(path.Base(s), cmLeafSeparator), cmBranchSeparator) - addToReverseMap(k, n, m) - return false - }) - }, - }, + contentTreeNoRenderFilter = func(s string, n *contentNode) bool { + if n.p == nil { + return true + } + return n.p.m.noRender() } - return m -} - -type cmInsertKeyBuilder struct { - m *contentMap - - err error - - // Builder state - tree *contentTree - baseKey string // Section or page key - key string -} - -func (b cmInsertKeyBuilder) ForPage(s string) *cmInsertKeyBuilder { - // fmt.Println("ForPage:", s, "baseKey:", b.baseKey, "key:", b.key) - baseKey := b.baseKey - b.baseKey = s - - if baseKey != "/" { - // Don't repeat the section path in the key. - s = strings.TrimPrefix(s, baseKey) + contentTreeNoLinkFilter = func(s string, n *contentNode) bool { + if n.p == nil { + return true + } + return n.p.m.noLink() } - s = strings.TrimPrefix(s, "/") +) - switch b.tree { - case b.m.sections: - b.tree = b.m.pages - b.key = baseKey + cmBranchSeparator + s + cmLeafSeparator - case b.m.taxonomies: - b.key = path.Join(baseKey, s) - default: - panic("invalid state") - } +var ( + _ contentKindProvider = (*contentBundleViewInfo)(nil) + _ viewInfoTrait = (*contentBundleViewInfo)(nil) +) - return &b +var trimCutsetDotSlashSpace = func(r rune) bool { + return r == '.' || r == '/' || unicode.IsSpace(r) } -func (b cmInsertKeyBuilder) ForResource(s string) *cmInsertKeyBuilder { - // fmt.Println("ForResource:", s, "baseKey:", b.baseKey, "key:", b.key) - - baseKey := helpers.AddTrailingSlash(b.baseKey) - s = strings.TrimPrefix(s, baseKey) +func newcontentTreeNodeCallbackChain(callbacks ...contentTreeNodeCallback) contentTreeNodeCallback { + return func(s string, n *contentNode) bool { + for i, cb := range callbacks { + // Allow the last callback to stop the walking. + if i == len(callbacks)-1 { + return cb(s, n) + } - switch b.tree { - case b.m.pages: - b.key = b.key + s - case b.m.sections, b.m.taxonomies: - b.key = b.key + cmLeafSeparator + s - default: - panic(fmt.Sprintf("invalid state: %#v", b.tree)) + if cb(s, n) { + // Skip the rest of the callbacks, but continue walking. + return false + } + } + return false } - b.tree = b.m.resources - return &b } -func (b *cmInsertKeyBuilder) Insert(n *contentNode) *cmInsertKeyBuilder { - if b.err == nil { - b.tree.Insert(b.Key(), n) - } - return b +type contentBundleViewInfo struct { + name viewName + term string } -func (b *cmInsertKeyBuilder) Key() string { - switch b.tree { - case b.m.sections, b.m.taxonomies: - return cleanSectionTreeKey(b.key) - default: - return cleanTreeKey(b.key) +func (c *contentBundleViewInfo) Kind() string { + if c.term != "" { + return pagekinds.Term } + return pagekinds.Taxonomy } -func (b *cmInsertKeyBuilder) DeleteAll() *cmInsertKeyBuilder { - if b.err == nil { - b.tree.DeletePrefix(b.Key()) - } - return b +func (c *contentBundleViewInfo) Term() string { + return c.term } -func (b *cmInsertKeyBuilder) WithFile(fi hugofs.FileMetaInfo) *cmInsertKeyBuilder { - b.newTopLevel() - m := b.m - meta := fi.Meta() - p := cleanTreeKey(meta.Path) - bundlePath := m.getBundleDir(meta) - isBundle := meta.Classifier.IsBundle() - if isBundle { - panic("not implemented") - } - - p, k := b.getBundle(p) - if k == "" { - b.err = errors.Errorf("no bundle header found for %q", bundlePath) - return b +func (c *contentBundleViewInfo) ViewInfo() *contentBundleViewInfo { + if c == nil { + panic("ViewInfo() called on nil") } - - id := k + m.reduceKeyPart(p, fi.Meta().Path) - b.tree = b.m.resources - b.key = id - b.baseKey = p - - return b + return c } -func (b *cmInsertKeyBuilder) WithSection(s string) *cmInsertKeyBuilder { - s = cleanSectionTreeKey(s) - b.newTopLevel() - b.tree = b.m.sections - b.baseKey = s - b.key = s - return b +type contentGetBranchProvider interface { + // GetBranch returns the the current branch, which will be itself + // for branch nodes (e.g. sections). + // To always navigate upwards, use GetContainerBranch(). + GetBranch() *contentBranchNode } -func (b *cmInsertKeyBuilder) WithTaxonomy(s string) *cmInsertKeyBuilder { - s = cleanSectionTreeKey(s) - b.newTopLevel() - b.tree = b.m.taxonomies - b.baseKey = s - b.key = s - return b +type contentGetContainerBranchProvider interface { + // GetContainerBranch returns the container for pages and sections. + GetContainerBranch() *contentBranchNode } -// getBundle gets both the key to the section and the prefix to where to store -// this page bundle and its resources. -func (b *cmInsertKeyBuilder) getBundle(s string) (string, string) { - m := b.m - section, _ := m.getSection(s) - - p := strings.TrimPrefix(s, section) - - bundlePathParts := strings.Split(p, "/") - basePath := section + cmBranchSeparator - - // Put it into an existing bundle if found. - for i := len(bundlePathParts) - 2; i >= 0; i-- { - bundlePath := path.Join(bundlePathParts[:i]...) - searchKey := basePath + bundlePath + cmLeafSeparator - if _, found := m.pages.Get(searchKey); found { - return section + bundlePath, searchKey - } - } - - // Put it into the section bundle. - return section, section + cmLeafSeparator +type contentGetContainerNodeProvider interface { + // GetContainerNode returns the container for resources. + GetContainerNode() *contentNode } -func (b *cmInsertKeyBuilder) newTopLevel() { - b.key = "" +type contentGetNodeProvider interface { + GetNode() *contentNode } -type contentBundleViewInfo struct { - ordinal int - name viewName - termKey string - termOrigin string - weight int - ref *contentNode +type contentKindProvider interface { + Kind() string } -func (c *contentBundleViewInfo) kind() string { - if c.termKey != "" { - return page.KindTerm - } - return page.KindTaxonomy +type contentMapConfig struct { + lang string + taxonomyConfig taxonomiesConfigValues + taxonomyDisabled bool + taxonomyTermDisabled bool + pageDisabled bool + isRebuild bool } -func (c *contentBundleViewInfo) sections() []string { - if c.kind() == page.KindTaxonomy { - return []string{c.name.plural} +func (cfg contentMapConfig) getTaxonomyConfig(s string) (v viewName) { + s = strings.TrimPrefix(s, "/") + if s == "" { + return } - - return []string{c.name.plural, c.termKey} -} - -func (c *contentBundleViewInfo) term() string { - if c.termOrigin != "" { - return c.termOrigin + for _, n := range cfg.taxonomyConfig.views { + if strings.HasPrefix(s, n.plural) { + return n + } } - return c.termKey + return } -type contentMap struct { - cfg *contentMapConfig - - // View of regular pages, sections, and taxonomies. - pageTrees contentTrees - - // View of pages, sections, taxonomies, and resources. - bundleTrees contentTrees - - // View of sections and taxonomies. - branchTrees contentTrees +var ( + _ identity.IdentityProvider = (*contentNode)(nil) + _ identity.DependencyManagerProvider = (*contentNode)(nil) +) - // Stores page bundles keyed by its path's directory or the base filename, - // e.g. "blog/post.md" => "/blog/post", "blog/post/index.md" => "/blog/post" - // These are the "regular pages" and all of them are bundles. - pages *contentTree +type contentNode struct { + key string - // A reverse index used as a fallback in GetPage. - // There are currently two cases where this is used: - // 1. Short name lookups in ref/relRef, e.g. using only "mypage.md" without a path. - // 2. Links resolved from a remounted content directory. These are restricted to the same module. - // Both of the above cases can result in ambigous lookup errors. - pageReverseIndex *contentTreeReverseIndex + keyPartsInit sync.Once + keyParts []string - // Section nodes. - sections *contentTree + p *pageState - // Taxonomy nodes. - taxonomies *contentTree + running bool - // Pages in a taxonomy. - taxonomyEntries *contentTree + // Additional traits for this node. + traits interface{} - // Resources stored per bundle below a common prefix, e.g. "/blog/post__hb_". - resources *contentTree + // Tracks dependencies in server mode. + idmInit sync.Once + idm identity.Manager } -func (m *contentMap) AddFiles(fis ...hugofs.FileMetaInfo) error { - for _, fi := range fis { - if err := m.addFile(fi); err != nil { - return err - } - } - - return nil +type contentNodeIdentity struct { + n *contentNode } -func (m *contentMap) AddFilesBundle(header hugofs.FileMetaInfo, resources ...hugofs.FileMetaInfo) error { - var ( - meta = header.Meta() - classifier = meta.Classifier - isBranch = classifier == files.ContentClassBranch - bundlePath = m.getBundleDir(meta) - - n = m.newContentNodeFromFi(header) - b = m.newKeyBuilder() - - section string - ) - - if isBranch { - // Either a section or a taxonomy node. - section = bundlePath - if tc := m.cfg.getTaxonomyConfig(section); !tc.IsZero() { - term := strings.TrimPrefix(strings.TrimPrefix(section, "/"+tc.plural), "/") - - n.viewInfo = &contentBundleViewInfo{ - name: tc, - termKey: term, - termOrigin: term, - } - - n.viewInfo.ref = n - b.WithTaxonomy(section).Insert(n) - } else { - b.WithSection(section).Insert(n) - } - } else { - // A regular page. Attach it to its section. - section, _ = m.getOrCreateSection(n, bundlePath) - b = b.WithSection(section).ForPage(bundlePath).Insert(n) - } - - if m.cfg.isRebuild { - // The resource owner will be either deleted or overwritten on rebuilds, - // but make sure we handle deletion of resources (images etc.) as well. - b.ForResource("").DeleteAll() - } - - for _, r := range resources { - rb := b.ForResource(cleanTreeKey(r.Meta().Path)) - rb.Insert(&contentNode{fi: r}) - } - - return nil +func (n *contentNode) IdentifierBase() interface{} { + return n.key } -func (m *contentMap) CreateMissingNodes() error { - // Create missing home and root sections - rootSections := make(map[string]interface{}) - trackRootSection := func(s string, b *contentNode) { - parts := strings.Split(s, "/") - if len(parts) > 2 { - root := strings.TrimSuffix(parts[1], cmBranchSeparator) - if root != "" { - if _, found := rootSections[root]; !found { - rootSections[root] = b - } - } - } - } - - m.sections.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) +func (b *contentNode) GetIdentity() identity.Identity { + return b +} - if s == "/" { - return false +func (b *contentNode) GetDependencyManager() identity.Manager { + b.idmInit.Do(func() { + // TODO1 + if true || b.running { + b.idm = identity.NewManager(b) + } else { + b.idm = identity.NopManager } - - trackRootSection(s, n) - return false }) - - m.pages.Walk(func(s string, v interface{}) bool { - trackRootSection(s, v.(*contentNode)) - return false - }) - - if _, found := rootSections["/"]; !found { - rootSections["/"] = true - } - - for sect, v := range rootSections { - var sectionPath string - if n, ok := v.(*contentNode); ok && n.path != "" { - sectionPath = n.path - firstSlash := strings.Index(sectionPath, "/") - if firstSlash != -1 { - sectionPath = sectionPath[:firstSlash] - } - } - sect = cleanSectionTreeKey(sect) - _, found := m.sections.Get(sect) - if !found { - m.sections.Insert(sect, &contentNode{path: sectionPath}) - } - } - - for _, view := range m.cfg.taxonomyConfig { - s := cleanSectionTreeKey(view.plural) - _, found := m.taxonomies.Get(s) - if !found { - b := &contentNode{ - viewInfo: &contentBundleViewInfo{ - name: view, - }, - } - b.viewInfo.ref = b - m.taxonomies.Insert(s, b) - } - } - - return nil + return b.idm } -func (m *contentMap) getBundleDir(meta *hugofs.FileMeta) string { - dir := cleanTreeKey(filepath.Dir(meta.Path)) - - switch meta.Classifier { - case files.ContentClassContent: - return path.Join(dir, meta.TranslationBaseName) - default: - return dir - } +func (b *contentNode) GetContainerNode() *contentNode { + return b } -func (m *contentMap) newContentNodeFromFi(fi hugofs.FileMetaInfo) *contentNode { - return &contentNode{ - fi: fi, - path: strings.TrimPrefix(filepath.ToSlash(fi.Meta().Path), "/"), - } +func (b *contentNode) HasFi() bool { + _, ok := b.traits.(hugofs.FileInfoProvider) + return ok } -func (m *contentMap) getFirstSection(s string) (string, *contentNode) { - s = helpers.AddTrailingSlash(s) - for { - k, v, found := m.sections.LongestPrefix(s) - - if !found { - return "", nil - } - - if strings.Count(k, "/") <= 2 { - return k, v.(*contentNode) - } - - s = helpers.AddTrailingSlash(path.Dir(strings.TrimSuffix(s, "/"))) - +func (b *contentNode) FileInfo() hugofs.FileMetaInfo { + fip, ok := b.traits.(hugofs.FileInfoProvider) + if !ok { + return nil } + return fip.FileInfo() } -func (m *contentMap) newKeyBuilder() *cmInsertKeyBuilder { - return &cmInsertKeyBuilder{m: m} +func (b *contentNode) Key() string { + return b.key } -func (m *contentMap) getOrCreateSection(n *contentNode, s string) (string, *contentNode) { - level := strings.Count(s, "/") - k, b := m.getSection(s) - - mustCreate := false - - if k == "" { - mustCreate = true - } else if level > 1 && k == "/" { - // We found the home section, but this page needs to be placed in - // the root, e.g. "/blog", section. - mustCreate = true - } - - if mustCreate { - k = cleanSectionTreeKey(s[:strings.Index(s[1:], "/")+1]) - - b = &contentNode{ - path: n.rootSection(), +func (b *contentNode) KeyParts() []string { + b.keyPartsInit.Do(func() { + if b.key != "" { + b.keyParts = paths.FieldsSlash(b.key) } - - m.sections.Insert(k, b) - } - - return k, b + }) + return b.keyParts } -func (m *contentMap) getPage(section, name string) *contentNode { - section = helpers.AddTrailingSlash(section) - key := section + cmBranchSeparator + name + cmLeafSeparator - - v, found := m.pages.Get(key) - if found { - return v.(*contentNode) - } - return nil +func (b *contentNode) GetNode() *contentNode { + return b } -func (m *contentMap) getSection(s string) (string, *contentNode) { - s = helpers.AddTrailingSlash(path.Dir(strings.TrimSuffix(s, "/"))) - - k, v, found := m.sections.LongestPrefix(s) - - if found { - return k, v.(*contentNode) - } - return "", nil +func (b *contentNode) IsStandalone() bool { + _, ok := b.traits.(kindOutputFormat) + return ok } -func (m *contentMap) getTaxonomyParent(s string) (string, *contentNode) { - s = helpers.AddTrailingSlash(path.Dir(strings.TrimSuffix(s, "/"))) - k, v, found := m.taxonomies.LongestPrefix(s) +// IsView returns whether this is a view node (a taxonomy or a term). +func (b *contentNode) IsView() bool { + _, ok := b.traits.(viewInfoTrait) + return ok +} - if found { - return k, v.(*contentNode) +// isCascadingEdit parses any front matter and returns whether it has a cascade section and +// if that has changed. +func (n *contentNode) isCascadingEdit() bool { + if n.p == nil { + return false } - - v, found = m.sections.Get("/") - if found { - return s, v.(*contentNode) + fi := n.FileInfo() + if fi == nil { + return false } - - return "", nil -} - -func (m *contentMap) addFile(fi hugofs.FileMetaInfo) error { - b := m.newKeyBuilder() - return b.WithFile(fi).Insert(m.newContentNodeFromFi(fi)).err -} - -func cleanTreeKey(k string) string { - k = "/" + strings.ToLower(strings.Trim(path.Clean(filepath.ToSlash(k)), "./")) - return k -} - -func cleanSectionTreeKey(k string) string { - k = cleanTreeKey(k) - if k != "/" { - k += "/" + f, err := fi.Meta().Open() + if err != nil { + // File may have been removed, assume a cascading edit. + // Some false positives are OK. + return true } - return k -} - -func (m *contentMap) onSameLevel(s1, s2 string) bool { - return strings.Count(s1, "/") == strings.Count(s2, "/") -} - -func (m *contentMap) deleteBundleMatching(matches func(b *contentNode) bool) { - // Check sections first - s := m.sections.getMatch(matches) - if s != "" { - m.deleteSectionByPath(s) - return + pf, err := pageparser.ParseFrontMatterAndContent(f) + f.Close() + if err != nil { + return true } - s = m.pages.getMatch(matches) - if s != "" { - m.deletePage(s) - return + if n.p == nil || n.p.bucket == nil { + return false } - s = m.resources.getMatch(matches) - if s != "" { - m.resources.Delete(s) + maps.PrepareParams(pf.FrontMatter) + cascade1, ok := pf.FrontMatter["cascade"] + hasCascade := n.p.bucket.cascade != nil && len(n.p.bucket.cascade) > 0 + if !ok { + return hasCascade } -} - -// Deletes any empty root section that's not backed by a content file. -func (m *contentMap) deleteOrphanSections() { - var sectionsToDelete []string - - m.sections.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) - - if n.fi != nil { - // Section may be empty, but is backed by a content file. - return false - } - - if s == "/" || strings.Count(s, "/") > 2 { - return false - } - prefixBundle := s + cmBranchSeparator + if !hasCascade { + return true + } - if !(m.sections.hasBelow(s) || m.pages.hasBelow(prefixBundle) || m.resources.hasBelow(prefixBundle)) { - sectionsToDelete = append(sectionsToDelete, s) + for _, v := range n.p.bucket.cascade { + if !reflect.DeepEqual(cascade1, v) { + return true } - - return false - }) - - for _, s := range sectionsToDelete { - m.sections.Delete(s) } -} -func (m *contentMap) deletePage(s string) { - m.pages.DeletePrefix(s) - m.resources.DeletePrefix(s) + return false } -func (m *contentMap) deleteSectionByPath(s string) { - if !strings.HasSuffix(s, "/") { - panic("section must end with a slash") - } - if !strings.HasPrefix(s, "/") { - panic("section must start with a slash") - } - m.sections.DeletePrefix(s) - m.pages.DeletePrefix(s) - m.resources.DeletePrefix(s) +type contentNodeInfo struct { + branch *contentBranchNode + isBranch bool + isResource bool } -func (m *contentMap) deletePageByPath(s string) { - m.pages.Walk(func(s string, v interface{}) bool { - fmt.Println("S", s) - - return false - }) +func (info *contentNodeInfo) SectionsEntries() []string { + return info.branch.n.KeyParts() } -func (m *contentMap) deleteTaxonomy(s string) { - m.taxonomies.DeletePrefix(s) +// TDOO1 somehow document that this will now return a leading slash, "" for home page. +func (info *contentNodeInfo) SectionsPath() string { + k := info.branch.n.Key() + if k == "" { + // TODO1 consider this. + return "/" + } + return k } -func (m *contentMap) reduceKeyPart(dir, filename string) string { - dir, filename = filepath.ToSlash(dir), filepath.ToSlash(filename) - dir, filename = strings.TrimPrefix(dir, "/"), strings.TrimPrefix(filename, "/") - - return strings.TrimPrefix(strings.TrimPrefix(filename, dir), "/") +type contentNodeInfoProvider interface { + SectionsEntries() []string + SectionsPath() string } -func (m *contentMap) splitKey(k string) []string { - if k == "" || k == "/" { - return nil - } - - return strings.Split(k, "/")[1:] +type contentNodeProvider interface { + contentGetNodeProvider + types.Identifier } -func (m *contentMap) testDump() string { - var sb strings.Builder - - for i, r := range []*contentTree{m.pages, m.sections, m.resources} { - sb.WriteString(fmt.Sprintf("Tree %d:\n", i)) - r.Walk(func(s string, v interface{}) bool { - sb.WriteString("\t" + s + "\n") - return false - }) - } - - for i, r := range []*contentTree{m.pages, m.sections} { - r.Walk(func(s string, v interface{}) bool { - c := v.(*contentNode) - cpToString := func(c *contentNode) string { - var sb strings.Builder - if c.p != nil { - sb.WriteString("|p:" + c.p.Title()) - } - if c.fi != nil { - sb.WriteString("|f:" + filepath.ToSlash(c.fi.Meta().Path)) - } - return sb.String() - } - sb.WriteString(path.Join(m.cfg.lang, r.Name) + s + cpToString(c) + "\n") - - resourcesPrefix := s - - if i == 1 { - resourcesPrefix += cmLeafSeparator - - m.pages.WalkPrefix(s+cmBranchSeparator, func(s string, v interface{}) bool { - sb.WriteString("\t - P: " + filepath.ToSlash((v.(*contentNode).fi.(hugofs.FileMetaInfo)).Meta().Filename) + "\n") - return false - }) - } - - m.resources.WalkPrefix(resourcesPrefix, func(s string, v interface{}) bool { - sb.WriteString("\t - R: " + filepath.ToSlash((v.(*contentNode).fi.(hugofs.FileMetaInfo)).Meta().Filename) + "\n") - return false - }) +type contentTreeNodeCallback func(s string, n *contentNode) bool - return false - }) - } +type contentTreeNodeCallbackNew func(node contentNodeProvider) bool - return sb.String() +type contentTreeRefProvider interface { + contentGetBranchProvider + contentGetContainerNodeProvider + contentNodeInfoProvider + contentNodeProvider } -type contentMapConfig struct { - lang string - taxonomyConfig []viewName - taxonomyDisabled bool - taxonomyTermDisabled bool - pageDisabled bool - isRebuild bool +type fileInfoHolder struct { + fi hugofs.FileMetaInfo } -func (cfg contentMapConfig) getTaxonomyConfig(s string) (v viewName) { - s = strings.TrimPrefix(s, "/") - if s == "" { - return - } - for _, n := range cfg.taxonomyConfig { - if strings.HasPrefix(s, n.plural) { - return n - } - } - - return +func (f fileInfoHolder) FileInfo() hugofs.FileMetaInfo { + return f.fi } -type contentNode struct { - p *pageState - - // Set for taxonomy nodes. - viewInfo *contentBundleViewInfo - - // Set if source is a file. - // We will soon get other sources. - fi hugofs.FileMetaInfo +type kindOutputFormat struct { + kind string + output output.Format +} - // The source path. Unix slashes. No leading slash. - path string +func (k kindOutputFormat) Kind() string { + return k.kind } -func (b *contentNode) rootSection() string { - if b.path == "" { - return "" - } - firstSlash := strings.Index(b.path, "/") - if firstSlash == -1 { - return b.path - } - return b.path[:firstSlash] +func (k kindOutputFormat) OutputFormat() output.Format { + return k.output } -type contentTree struct { - Name string - *radix.Tree +type kindOutputFormatTrait interface { + Kind() string + OutputFormat() output.Format } -type contentTrees []*contentTree +// bookmark3 +func (m *pageMap) AddFilesBundle(header hugofs.FileMetaInfo, resources ...hugofs.FileMetaInfo) error { + var ( + n *contentNode + pageTree *contentBranchNode + pathInfo = header.Meta().PathInfo + ) -func (t contentTrees) DeletePrefix(prefix string) int { - var count int - for _, tree := range t { - tree.Walk(func(s string, v interface{}) bool { - return false - }) - count += tree.DeletePrefix(prefix) + if !pathInfo.IsBranchBundle() && m.cfg.pageDisabled { + return nil } - return count -} -type contentTreeNodeCallback func(s string, n *contentNode) bool + if pathInfo.IsBranchBundle() { + // Apply some metadata if it's a taxonomy node. + if tc := m.cfg.getTaxonomyConfig(pathInfo.Base()); !tc.IsZero() { + term := strings.TrimPrefix(strings.TrimPrefix(pathInfo.Base(), "/"+tc.plural), "/") -func newContentTreeFilter(fn func(n *contentNode) bool) contentTreeNodeCallback { - return func(s string, n *contentNode) bool { - return fn(n) - } -} + n = m.NewContentNode( + viewInfoFileInfoHolder{ + &contentBundleViewInfo{ + name: tc, + term: term, + }, + fileInfoHolder{fi: header}, + }, + pathInfo.Base(), + ) -var ( - contentTreeNoListAlwaysFilter = func(s string, n *contentNode) bool { - if n.p == nil { - return true + } else { + n = m.NewContentNode( + fileInfoHolder{fi: header}, + pathInfo.Base(), + ) } - return n.p.m.noListAlways() - } - contentTreeNoRenderFilter = func(s string, n *contentNode) bool { - if n.p == nil { - return true - } - return n.p.m.noRender() - } + pageTree = m.InsertBranch(n) - contentTreeNoLinkFilter = func(s string, n *contentNode) bool { - if n.p == nil { - return true + for _, r := range resources { + n := m.NewContentNode( + fileInfoHolder{fi: r}, + r.Meta().PathInfo.Base(), + ) + pageTree.resources.nodes.Insert(n.key, n) } - return n.p.m.noLink() - } -) -func (c *contentTree) WalkQuery(query pageMapQuery, walkFn contentTreeNodeCallback) { - filter := query.Filter - if filter == nil { - filter = contentTreeNoListAlwaysFilter + return nil } - if query.Prefix != "" { - c.WalkBelow(query.Prefix, func(s string, v interface{}) bool { - n := v.(*contentNode) - if filter != nil && filter(s, n) { - return false - } - return walkFn(s, n) - }) - return - } + n = m.NewContentNode( + fileInfoHolder{fi: header}, + pathInfo.Base(), + ) - c.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) - if filter != nil && filter(s, n) { - return false + // A regular page. Attach it to its section. + var created bool + _, pageTree, created = m.getOrCreateSection(n) + + if created { + // This means there are most likely no content file for this + // section. + // Apply some default metadata to the node. + sectionName := helpers.FirstUpper(pathInfo.Section()) + var title string + if m.s.Cfg.GetBool("pluralizeListTitles") { + title = flect.Pluralize(sectionName) + } else { + title = sectionName } - return walkFn(s, n) - }) -} - -func (c contentTrees) WalkRenderable(fn contentTreeNodeCallback) { - query := pageMapQuery{Filter: contentTreeNoRenderFilter} - for _, tree := range c { - tree.WalkQuery(query, fn) + pageTree.defaultTitle = title } -} -func (c contentTrees) WalkLinkable(fn contentTreeNodeCallback) { - query := pageMapQuery{Filter: contentTreeNoLinkFilter} - for _, tree := range c { - tree.WalkQuery(query, fn) - } -} - -func (c contentTrees) Walk(fn contentTreeNodeCallback) { - for _, tree := range c { - tree.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) - return fn(s, n) - }) - } -} + pageTree.InsertPage(n.key, n) -func (c contentTrees) WalkPrefix(prefix string, fn contentTreeNodeCallback) { - for _, tree := range c { - tree.WalkPrefix(prefix, func(s string, v interface{}) bool { - n := v.(*contentNode) - return fn(s, n) - }) + for _, r := range resources { + n := m.NewContentNode( + fileInfoHolder{fi: r}, + r.Meta().PathInfo.Base(), + ) + pageTree.pageResources.nodes.Insert(n.key, n) } -} - -// WalkBelow walks the tree below the given prefix, i.e. it skips the -// node with the given prefix as key. -func (c *contentTree) WalkBelow(prefix string, fn radix.WalkFn) { - c.Tree.WalkPrefix(prefix, func(s string, v interface{}) bool { - if s == prefix { - return false - } - return fn(s, v) - }) -} -func (c *contentTree) getMatch(matches func(b *contentNode) bool) string { - var match string - c.Walk(func(s string, v interface{}) bool { - n, ok := v.(*contentNode) - if !ok { - return false - } - - if matches(n) { - match = s - return true - } - - return false - }) - - return match -} - -func (c *contentTree) hasBelow(s1 string) bool { - var t bool - c.WalkBelow(s1, func(s2 string, v interface{}) bool { - t = true - return true - }) - return t + return nil } -func (c *contentTree) printKeys() { - c.Walk(func(s string, v interface{}) bool { - fmt.Println(s) - return false - }) -} +func (m *pageMap) getOrCreateSection(n *contentNode) (string, *contentBranchNode, bool) { + level := strings.Count(n.key, "/") -func (c *contentTree) printKeysPrefix(prefix string) { - c.WalkPrefix(prefix, func(s string, v interface{}) bool { - fmt.Println(s) - return false - }) -} + k, pageTree := m.LongestPrefix(path.Dir(n.key)) -// contentTreeRef points to a node in the given tree. -type contentTreeRef struct { - m *pageMap - t *contentTree - n *contentNode - key string -} + mustCreate := false -func (c *contentTreeRef) getCurrentSection() (string, *contentNode) { - if c.isSection() { - return c.key, c.n + if pageTree == nil { + mustCreate = true + } else if level > 1 && k == "" { + // We found the home section, but this page needs to be placed in + // the root, e.g. "/blog", section. + mustCreate = true + } else { + return k, pageTree, false } - return c.getSection() -} - -func (c *contentTreeRef) isSection() bool { - return c.t == c.m.sections -} -func (c *contentTreeRef) getSection() (string, *contentNode) { - if c.t == c.m.taxonomies { - return c.m.getTaxonomyParent(c.key) + if !mustCreate { + return k, pageTree, false } - return c.m.getSection(c.key) -} - -func (c *contentTreeRef) getPages() page.Pages { - var pas page.Pages - c.m.collectPages( - pageMapQuery{ - Prefix: c.key + cmBranchSeparator, - Filter: c.n.p.m.getListFilter(true), - }, - func(c *contentNode) { - pas = append(pas, c.p) - }, - ) - page.SortByDefault(pas) - - return pas -} - -func (c *contentTreeRef) getPagesRecursive() page.Pages { - var pas page.Pages - query := pageMapQuery{ - Filter: c.n.p.m.getListFilter(true), + var keyParts []string + if level > 1 { + keyParts = n.KeyParts()[:1] } + n = m.NewContentNode(nil, keyParts...) - query.Prefix = c.key - c.m.collectPages(query, func(c *contentNode) { - pas = append(pas, c.p) - }) - - page.SortByDefault(pas) - - return pas -} - -func (c *contentTreeRef) getPagesAndSections() page.Pages { - var pas page.Pages - - query := pageMapQuery{ - Filter: c.n.p.m.getListFilter(true), - Prefix: c.key, + if k != "" { + // Make sure we always have the root/home node. + if m.Get("") == nil { + m.InsertBranch(&contentNode{}) + } } - c.m.collectPagesAndSections(query, func(c *contentNode) { - pas = append(pas, c.p) - }) - - page.SortByDefault(pas) - - return pas + pageTree = m.InsertBranch(n) + return k, pageTree, true } -func (c *contentTreeRef) getSections() page.Pages { - var pas page.Pages - - query := pageMapQuery{ - Filter: c.n.p.m.getListFilter(true), - Prefix: c.key, - } +type stringKindProvider string - c.m.collectSections(query, func(c *contentNode) { - pas = append(pas, c.p) - }) - - page.SortByDefault(pas) - - return pas +func (k stringKindProvider) Kind() string { + return string(k) } -type contentTreeReverseIndex struct { - t []*contentTree - *contentTreeReverseIndexMap +type viewInfoFileInfoHolder struct { + viewInfoTrait + hugofs.FileInfoProvider } -type contentTreeReverseIndexMap struct { - m map[interface{}]*contentNode - init sync.Once - initFn func(*contentTree, map[interface{}]*contentNode) -} - -func (c *contentTreeReverseIndex) Reset() { - c.contentTreeReverseIndexMap = &contentTreeReverseIndexMap{ - initFn: c.initFn, - } +type viewInfoTrait interface { + Kind() string + ViewInfo() *contentBundleViewInfo } -func (c *contentTreeReverseIndex) Get(key interface{}) *contentNode { - c.init.Do(func() { - c.m = make(map[interface{}]*contentNode) - for _, tree := range c.t { - c.initFn(tree, c.m) +// The home page is represented with the zero string. +// All other keys starts with a leading slash. No trailing slash. +// Slashes are Unix-style. +func cleanTreeKey(elem ...string) string { + var s string + if len(elem) > 0 { + s = elem[0] + if len(elem) > 1 { + s = path.Join(elem...) } - }) - return c.m[key] + } + s = strings.TrimFunc(s, trimCutsetDotSlashSpace) + s = filepath.ToSlash(strings.ToLower(paths.Sanitize(s))) + if s == "" || s == "/" { + return "" + } + if s[0] != '/' { + s = "/" + s + } + return s } diff --git a/hugolib/content_map_branch.go b/hugolib/content_map_branch.go new file mode 100644 index 00000000000..e81e1eef113 --- /dev/null +++ b/hugolib/content_map_branch.go @@ -0,0 +1,858 @@ +// Copyright 2020 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 ( + "fmt" + "io" + "os" + "path" + "path/filepath" + "strings" + + "github.com/gohugoio/hugo/common/types" + + "github.com/gohugoio/hugo/common/hugio" + "github.com/gohugoio/hugo/resources" + + "github.com/gohugoio/hugo/resources/resource" + + radix "github.com/armon/go-radix" + "github.com/pkg/errors" +) + +var noTaxonomiesFilter = func(s string, n *contentNode) bool { + return n != nil && n.IsView() +} + +func newBranchMap(createBranchNode func(elem ...string) *contentNode) *branchMap { + return &branchMap{ + branches: newNodeTree("branches"), + createBranchNode: createBranchNode, + } +} + +func newBranchMapQueryKey(value string, isPrefix bool) branchMapQueryKey { + return branchMapQueryKey{Value: value, isPrefix: isPrefix, isSet: true} +} + +func newContentBranchNode(n *contentNode) *contentBranchNode { + return &contentBranchNode{ + n: n, + resources: &contentBranchNodeTree{nodes: newNodeTree("resources")}, + pages: &contentBranchNodeTree{nodes: newNodeTree("pages")}, + pageResources: &contentBranchNodeTree{nodes: newNodeTree("pageResources")}, + refs: make(map[interface{}]ordinalWeight), + } +} + +func newNodeTree(name string) nodeTree { + tree := &defaultNodeTree{nodeTree: radix.New()} + return tree + // return &nodeTreeUpdateTracer{name: name, nodeTree: tree} +} + +type branchMap struct { + // branches stores *contentBranchNode + branches nodeTree + + createBranchNode func(elem ...string) *contentNode +} + +func (m *branchMap) GetBranchOrLeaf(key string) *contentNode { + s, branch := m.LongestPrefix(key) + if branch == nil { + return nil + } + + if key == s { + // A branch node. + return branch.n + } + n, found := branch.pages.nodes.Get(key) + if !found { + return nil + } + + return n.(*contentNode) +} + +func (m *branchMap) GetNode(key string) *contentNode { + n, _ := m.GetNodeAndTree(key) + return n +} + +func (m *branchMap) GetNodeAndTree(key string) (*contentNode, nodeTree) { + s, branch := m.LongestPrefix(key) + if branch == nil { + return nil, nil + } + + if key == s { + // It's a branch node (e.g. a section). + return branch.n, m.branches + } + + findFirst := func(s string, trees ...*contentBranchNodeTree) (*contentNode, nodeTree) { + for _, tree := range trees { + if v, found := tree.nodes.Get(s); found { + return v.(*contentNode), tree.nodes + } + } + return nil, nil + } + + return findFirst(key, branch.pages, branch.pageResources, branch.resources) +} + +// GetFirstSection walks up the tree from s and returns the first +// section below root. +func (m *branchMap) GetFirstSection(s string) (string, *contentNode) { + for { + k, v, found := m.branches.LongestPrefix(s) + + if !found { + return "", nil + } + + // /blog + if strings.Count(k, "/") <= 1 { + return k, v.(*contentBranchNode).n + } + + s = path.Dir(s) + + } +} + +// InsertBranch inserts or updates a branch. +func (m *branchMap) InsertBranch(n *contentNode) *contentBranchNode { + _, b := m.InsertRootAndBranch(n) + return b +} + +func (m *branchMap) InsertResource(key string, n *contentNode) error { + if err := validateSectionMapKey(key); err != nil { + return err + } + + _, v, found := m.branches.LongestPrefix(key) + if !found { + return errors.Errorf("no section found for resource %q", key) + } + + v.(*contentBranchNode).resources.nodes.Insert(key, n) + + return nil +} + +// InsertBranchAndRoot inserts or updates a branch. +// The return values are the branch's root or nil and then the branch itself. +func (m *branchMap) InsertRootAndBranch(n *contentNode) (root *contentBranchNode, branch *contentBranchNode) { + mustValidateSectionMapKey(n.key) + if v, found := m.branches.Get(n.key); found { + // Update existing. + branch = v.(*contentBranchNode) + branch.n = n + return + } + + if strings.Count(n.key, "/") > 1 { + // Make sure we have a root section. + s, v, found := m.branches.LongestPrefix(n.key) + if !found || s == "" { + nkey := n.KeyParts() + rkey := nkey[:1] + root = newContentBranchNode(m.createBranchNode(rkey...)) + m.branches.Insert(root.n.key, root) + } else { + root = v.(*contentBranchNode) + } + } + + if branch == nil { + branch = newContentBranchNode(n) + m.branches.Insert(n.key, branch) + } + + return +} + +// GetLeaf gets the leaf node identified with s, nil if not found. +func (m *branchMap) GetLeaf(s string) *contentNode { + _, branch := m.LongestPrefix(s) + if branch != nil { + n, found := branch.pages.nodes.Get(s) + if found { + return n.(*contentNode) + } + } + // Not found. + return nil +} + +// LongestPrefix returns the branch with the longest prefix match of s. +func (m *branchMap) LongestPrefix(s string) (string, *contentBranchNode) { + k, v, found := m.branches.LongestPrefix(s) + if !found { + return "", nil + } + return k, v.(*contentBranchNode) +} + +// Returns +// 0 if s2 is a descendant of s1 +// 1 if s2 is a sibling of s1 +// else -1 +func (m *branchMap) TreeRelation(s1, s2 string) int { + if s1 == "" && s2 != "" { + return 0 + } + + if strings.HasPrefix(s1, s2) { + return 0 + } + + for { + s2 = s2[:strings.LastIndex(s2, "/")] + if s2 == "" { + break + } + + if s1 == s2 { + return 0 + } + + if strings.HasPrefix(s1, s2) { + return 1 + } + } + + return -1 +} + +// Walk walks m filtering the nodes with q. +func (m *branchMap) Walk(q branchMapQuery) error { + if q.Branch.Key.IsZero() == q.Leaf.Key.IsZero() { + return errors.New("must set at most one Key") + } + + if q.Leaf.Key.IsPrefix() { + return errors.New("prefix search is currently only implemented starting for branch keys") + } + + if q.Exclude != nil { + // Apply global node filters. + applyFilterPage := func(c contentTreeNodeCallbackNew) contentTreeNodeCallbackNew { + if c == nil { + return nil + } + return func(n contentNodeProvider) bool { + if q.Exclude(n.Key(), n.GetNode()) { + // Skip this node, but continue walk. + return false + } + return c(n) + } + } + + applyFilterResource := func(c contentTreeNodeCallbackNew) contentTreeNodeCallbackNew { + if c == nil { + return nil + } + return func(n contentNodeProvider) bool { + if q.Exclude(n.Key(), n.GetNode()) { + // Skip this node, but continue walk. + return false + } + return c(n) + } + } + + q.Branch.Page = applyFilterPage(q.Branch.Page) + q.Branch.Resource = applyFilterResource(q.Branch.Resource) + q.Leaf.Page = applyFilterPage(q.Leaf.Page) + q.Leaf.Resource = applyFilterResource(q.Leaf.Resource) + + } + + if q.BranchExclude != nil { + cb := q.Branch.Page + q.Branch.Page = func(n contentNodeProvider) bool { + if q.BranchExclude(n.Key(), n.GetNode()) { + return true + } + return cb(n) + } + } + + type depthType int + + const ( + depthAll depthType = iota + depthBranch + depthLeaf + ) + + newNodeProviderResource := func(s string, n, owner *contentNode, b *contentBranchNode) contentNodeProvider { + var np contentNodeProvider + if !q.Deep { + np = n + } else { + var nInfo contentNodeInfoProvider = &contentNodeInfo{ + branch: b, + isResource: true, + } + + np = struct { + types.Identifier + contentNodeInfoProvider + contentGetNodeProvider + contentGetContainerNodeProvider + contentGetBranchProvider + }{ + n, + nInfo, + n, + owner, + b, + } + } + + return np + } + + handleBranchPage := func(depth depthType, s string, v interface{}) bool { + bn := v.(*contentBranchNode) + + if depth <= depthBranch { + + if q.Branch.Page != nil && q.Branch.Page(m.newNodeProviderPage(s, bn.n, nil, bn, q.Deep)) { + return false + } + + if q.Branch.Resource != nil { + bn.resources.nodes.Walk(func(s string, v interface{}) bool { + n := v.(*contentNode) + return q.Branch.Resource(newNodeProviderResource(s, n, bn.n, bn)) + }) + } + } + + if q.OnlyBranches || depth == depthBranch { + return false + } + + if q.Leaf.Page != nil || q.Leaf.Resource != nil { + bn.pages.nodes.Walk(func(s string, v interface{}) bool { + n := v.(*contentNode) + if q.Leaf.Page != nil && q.Leaf.Page(m.newNodeProviderPage(s, n, bn, bn, q.Deep)) { + return true + } + if q.Leaf.Resource != nil { + // Interleave the Page's resources. + bn.pageResources.nodes.WalkPrefix(s+"/", func(s string, v interface{}) bool { + return q.Leaf.Resource(newNodeProviderResource(s, v.(*contentNode), n, bn)) + }) + } + return false + }) + } + + return false + } + + if !q.Branch.Key.IsZero() { + // Filter by section. + if q.Branch.Key.IsPrefix() { + if q.Branch.Key.Value != "" && q.Leaf.Page != nil { + // Need to include the leaf pages of the owning branch. + s := q.Branch.Key.Value[:len(q.Branch.Key.Value)-1] + owner := m.Get(s) + if owner != nil { + if handleBranchPage(depthLeaf, s, owner) { + // Done. + return nil + } + } + } + + var level int + if q.NoRecurse { + level = strings.Count(q.Branch.Key.Value, "/") + } + m.branches.WalkPrefix( + q.Branch.Key.Value, func(s string, v interface{}) bool { + if q.NoRecurse && strings.Count(s, "/") > level { + return false + } + + depth := depthAll + if q.NoRecurse { + depth = depthBranch + } + + return handleBranchPage(depth, s, v) + }, + ) + + // Done. + return nil + } + + // Exact match. + section := m.Get(q.Branch.Key.Value) + if section != nil { + if handleBranchPage(depthAll, q.Branch.Key.Value, section) { + return nil + } + } + // Done. + return nil + } + + if q.OnlyBranches || q.Leaf.Key.IsZero() || !q.Leaf.HasCallback() { + // Done. + return nil + } + + _, section := m.LongestPrefix(q.Leaf.Key.Value) + if section == nil { + return nil + } + + // Exact match. + v, found := section.pages.nodes.Get(q.Leaf.Key.Value) + if !found { + return nil + } + if q.Leaf.Page != nil && q.Leaf.Page(m.newNodeProviderPage(q.Leaf.Key.Value, v.(*contentNode), section, section, q.Deep)) { + return nil + } + + if q.Leaf.Resource != nil { + section.pageResources.nodes.WalkPrefix(q.Leaf.Key.Value+"/", func(s string, v interface{}) bool { + return q.Leaf.Resource(newNodeProviderResource(s, v.(*contentNode), section.n, section)) + }) + } + + return nil +} + +// WalkBranches invokes cb for all branch nodes. +func (m *branchMap) WalkBranches(cb func(s string, n *contentBranchNode) bool) { + m.branches.Walk(func(s string, v interface{}) bool { + return cb(s, v.(*contentBranchNode)) + }) +} + +// WalkBranches invokes cb for all branch nodes matching the given prefix. +func (m *branchMap) WalkBranchesPrefix(prefix string, cb func(s string, n *contentBranchNode) bool) { + m.branches.WalkPrefix(prefix, func(s string, v interface{}) bool { + return cb(s, v.(*contentBranchNode)) + }) +} + +func (m *branchMap) WalkPagesAllPrefixSection( + prefix string, + branchExclude, exclude contentTreeNodeCallback, + callback contentTreeNodeCallbackNew) error { + q := branchMapQuery{ + BranchExclude: branchExclude, + Exclude: exclude, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey(prefix, true), + Page: callback, + }, + Leaf: branchMapQueryCallBacks{ + Page: callback, + }, + } + return m.Walk(q) +} + +func (m *branchMap) WalkPagesLeafsPrefixSection( + prefix string, + branchExclude, exclude contentTreeNodeCallback, + callback contentTreeNodeCallbackNew) error { + q := branchMapQuery{ + BranchExclude: branchExclude, + Exclude: exclude, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey(prefix, true), + Page: nil, + }, + Leaf: branchMapQueryCallBacks{ + Page: callback, + }, + } + return m.Walk(q) +} + +func (m *branchMap) WalkPagesPrefixSectionNoRecurse( + prefix string, + branchExclude, exclude contentTreeNodeCallback, + callback contentTreeNodeCallbackNew) error { + q := branchMapQuery{ + NoRecurse: true, + BranchExclude: branchExclude, + Exclude: exclude, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey(prefix, true), + Page: callback, + }, + Leaf: branchMapQueryCallBacks{ + Page: callback, + }, + } + return m.Walk(q) +} + +func (m *branchMap) Get(key string) *contentBranchNode { + v, found := m.branches.Get(key) + if !found { + return nil + } + return v.(*contentBranchNode) +} + +func (m *branchMap) Has(key string) bool { + _, found := m.branches.Get(key) + return found +} + +func (m *branchMap) newNodeProviderPage(s string, n *contentNode, owner, branch *contentBranchNode, deep bool) contentNodeProvider { + if !deep { + return n + } + + var np contentNodeProvider + if owner == nil { + if s != "" { + _, owner = m.LongestPrefix(path.Dir(s)) + } + } + + var ownerNode *contentNode + if owner != nil { + ownerNode = owner.n + } + + var nInfo contentNodeInfoProvider = &contentNodeInfo{ + branch: branch, + isBranch: owner != branch, + } + + np = struct { + types.Identifier + contentNodeInfoProvider + contentGetNodeProvider + contentGetContainerBranchProvider + contentGetContainerNodeProvider + contentGetBranchProvider + }{ + n, + nInfo, + n, + owner, + ownerNode, + branch, + } + + return np +} + +func (m *branchMap) debug(prefix string, w io.Writer) { + fmt.Fprintf(w, "[%s] Start:\n", prefix) + m.WalkBranches(func(s string, n *contentBranchNode) bool { + var notes []string + sectionType := "Section" + if n.n.IsView() { + sectionType = "View" + } + if n.n.p != nil { + sectionType = n.n.p.Kind() + } + if n.n.p == nil { + notes = append(notes, "MISSING_PAGE") + } + fmt.Fprintf(w, "[%s] %s: %q %v\n", prefix, sectionType, s, notes) + n.pages.Walk(func(s string, n *contentNode) bool { + fmt.Fprintf(w, "\t[%s] Page: %q\n", prefix, s) + return false + }) + n.pageResources.Walk(func(s string, n *contentNode) bool { + fmt.Fprintf(w, "\t[%s] Branch Resource: %q\n", prefix, s) + return false + }) + n.pageResources.Walk(func(s string, n *contentNode) bool { + fmt.Fprintf(w, "\t[%s] Leaf Resource: %q\n", prefix, s) + return false + }) + return false + }) +} + +func (m *branchMap) debugDefault() { + m.debug("", os.Stdout) +} + +type branchMapQuery struct { + // Restrict query to one level. + NoRecurse bool + // Deep/full callback objects. + Deep bool + // Do not navigate down to the leaf nodes. + OnlyBranches bool + // Global node filter. Return true to skip. + Exclude contentTreeNodeCallback + // Branch node filter. Return true to skip. + BranchExclude contentTreeNodeCallback + // Handle branch (sections and taxonomies) nodes. + Branch branchMapQueryCallBacks + // Handle leaf nodes (pages) + Leaf branchMapQueryCallBacks +} + +type branchMapQueryCallBacks struct { + Key branchMapQueryKey + Page contentTreeNodeCallbackNew + Resource contentTreeNodeCallbackNew +} + +func (q branchMapQueryCallBacks) HasCallback() bool { + return q.Page != nil || q.Resource != nil +} + +type branchMapQueryKey struct { + Value string + + isSet bool + isPrefix bool +} + +func (q branchMapQueryKey) Eq(key string) bool { + if q.IsZero() || q.isPrefix { + return false + } + return q.Value == key +} + +func (q branchMapQueryKey) IsPrefix() bool { + return !q.IsZero() && q.isPrefix +} + +func (q branchMapQueryKey) IsZero() bool { + return !q.isSet +} + +type contentBranchNode struct { + n *contentNode + resources *contentBranchNodeTree + pages *contentBranchNodeTree + pageResources *contentBranchNodeTree + + refs map[interface{}]ordinalWeight + + // Some default metadata if not provided in front matter. + defaultTitle string +} + +func (b *contentBranchNode) GetBranch() *contentBranchNode { + return b +} + +func (b *contentBranchNode) GetContainerBranch() *contentBranchNode { + return b +} + +func (b *contentBranchNode) InsertPage(key string, n *contentNode) { + mustValidateSectionMapKey(key) + b.pages.nodes.Insert(key, n) +} + +func (b *contentBranchNode) InsertResource(key string, n *contentNode) error { + mustValidateSectionMapKey(key) + + if _, _, found := b.pages.nodes.LongestPrefix(key); !found { + return errors.Errorf("no page found for resource %q", key) + } + + b.pageResources.nodes.Insert(key, n) + + return nil +} + +func (m *contentBranchNode) newResource(n *contentNode, owner *pageState) (resource.Resource, error) { + if owner == nil { + panic("owner is nil") + } + + // TODO(bep) consolidate with multihost logic + clean up + outputFormats := owner.m.outputFormats() + seen := make(map[string]bool) + var targetBasePaths []string + + // Make sure bundled resources are published to all of the output formats' + // sub paths. + for _, f := range outputFormats { + p := f.Path + if seen[p] { + continue + } + seen[p] = true + targetBasePaths = append(targetBasePaths, p) + + } + + fim := n.FileInfo() + resourcePath := fim.Meta().PathInfo + ownerPath := owner.File().FileInfo().Meta().PathInfo + meta := fim.Meta() + r := func() (hugio.ReadSeekCloser, error) { + return meta.Open() + } + + target := strings.TrimPrefix(resourcePath.Base(), ownerPath.Dir()) + + return owner.s.ResourceSpec.New( + resources.ResourceSourceDescriptor{ + TargetPaths: owner.getTargetPaths, + OpenReadSeekCloser: r, + FileInfo: fim, + RelTargetFilename: filepath.FromSlash(target), + TargetBasePaths: targetBasePaths, + LazyPublish: !owner.m.buildConfig.PublishResources, + GroupIdentity: n.GetIdentity(), + DependencyManager: n.GetDependencyManager(), + }) +} + +type contentBranchNodeTree struct { + nodes nodeTree +} + +func (t contentBranchNodeTree) Walk(cb ...contentTreeNodeCallback) { + cbs := newcontentTreeNodeCallbackChain(cb...) + t.nodes.Walk(func(s string, v interface{}) bool { + return cbs(s, v.(*contentNode)) + }) +} + +func (t contentBranchNodeTree) WalkPrefix(prefix string, cb ...contentTreeNodeCallback) { + cbs := newcontentTreeNodeCallbackChain(cb...) + t.nodes.WalkPrefix(prefix, func(s string, v interface{}) bool { + return cbs(s, v.(*contentNode)) + }) +} + +func (t contentBranchNodeTree) Has(s string) bool { + _, b := t.nodes.Get(s) + return b +} + +type defaultNodeTree struct { + nodeTree +} + +func (t *defaultNodeTree) Delete(s string) (interface{}, bool) { + return t.nodeTree.Delete(s) +} + +func (t *defaultNodeTree) DeletePrefix(s string) int { + return t.nodeTree.DeletePrefix(s) +} + +func (t *defaultNodeTree) Insert(s string, v interface{}) (interface{}, bool) { + switch n := v.(type) { + case *contentNode: + n.key = s + case *contentBranchNode: + n.n.key = s + } + return t.nodeTree.Insert(s, v) +} + +// Below some utils used for debugging. + +// nodeTree defines the operations we use in radix.Tree. +type nodeTree interface { + Delete(s string) (interface{}, bool) + DeletePrefix(s string) int + + // Update ops. + Insert(s string, v interface{}) (interface{}, bool) + Len() int + + LongestPrefix(s string) (string, interface{}, bool) + // Read ops + Walk(fn radix.WalkFn) + WalkPrefix(prefix string, fn radix.WalkFn) + Get(s string) (interface{}, bool) +} + +type nodeTreeUpdateTracer struct { + name string + nodeTree +} + +func (t *nodeTreeUpdateTracer) Delete(s string) (interface{}, bool) { + fmt.Printf("[%s]\t[Delete] %q\n", t.name, s) + return t.nodeTree.Delete(s) +} + +func (t *nodeTreeUpdateTracer) DeletePrefix(s string) int { + n := t.nodeTree.DeletePrefix(s) + fmt.Printf("[%s]\t[DeletePrefix] %q => %d\n", t.name, s, n) + return n +} + +func (t *nodeTreeUpdateTracer) Insert(s string, v interface{}) (interface{}, bool) { + var typeInfo string + switch n := v.(type) { + case *contentNode: + typeInfo = "n" + case *contentBranchNode: + typeInfo = fmt.Sprintf("b:isView:%t", n.n.IsView()) + } + fmt.Printf("[%s]\t[Insert] %q %s\n", t.name, s, typeInfo) + return t.nodeTree.Insert(s, v) +} + +func mustValidateSectionMapKey(key string) { + if err := validateSectionMapKey(key); err != nil { + panic(err) + } +} + +func validateSectionMapKey(key string) error { + if key == "" { + // Home page. + return nil + } + + if len(key) < 2 { + return errors.Errorf("too short key: %q", key) + } + + if key[0] != '/' { + return errors.Errorf("key must start with '/': %q", key) + } + + if key[len(key)-1] == '/' { + return errors.Errorf("key must not end with '/': %q", key) + } + + return nil +} diff --git a/hugolib/content_map_branch_test.go b/hugolib/content_map_branch_test.go new file mode 100644 index 00000000000..e8530eff2dc --- /dev/null +++ b/hugolib/content_map_branch_test.go @@ -0,0 +1,274 @@ +// Copyright 2020 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 ( + "fmt" + "testing" + + qt "github.com/frankban/quicktest" +) + +func TestBranchMap(t *testing.T) { + c := qt.New(t) + + m := newBranchMap(nil) + + walkAndGetOne := func(c *qt.C, m *branchMap, s string) contentNodeProvider { + var result contentNodeProvider + h := func(np contentNodeProvider) bool { + if np.Key() != s { + return false + } + result = np + return true + } + + q := branchMapQuery{ + Deep: true, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey("", true), + Page: h, + Resource: h, + }, + Leaf: branchMapQueryCallBacks{ + Page: h, + Resource: h, + }, + } + + c.Assert(m.Walk(q), qt.IsNil) + c.Assert(result, qt.Not(qt.IsNil)) + + return result + } + + c.Run("Node methods", func(c *qt.C) { + m := newBranchMap(nil) + bn, ln := &contentNode{key: "/my/section"}, &contentNode{key: "/my/section/mypage"} + m.InsertBranch(&contentNode{key: "/my"}) // We need a root section. + b := m.InsertBranch(bn) + b.InsertPage(ln.key, ln) + + branch := walkAndGetOne(c, m, "/my/section").(contentNodeInfoProvider) + page := walkAndGetOne(c, m, "/my/section/mypage").(contentNodeInfoProvider) + c.Assert(branch.SectionsEntries(), qt.DeepEquals, []string{"my", "section"}) + c.Assert(page.SectionsEntries(), qt.DeepEquals, []string{"my", "section"}) + }) + + c.Run("Tree relation", func(c *qt.C) { + for _, test := range []struct { + name string + s1 string + s2 string + expect int + }{ + {"Sibling", "/blog/sub1", "/blog/sub2", 1}, + {"Root child", "", "/blog", 0}, + {"Child", "/blog/sub1", "/blog/sub1/sub2", 0}, + {"New root", "/blog/sub1", "/docs/sub2", -1}, + } { + c.Run(test.name, func(c *qt.C) { + c.Assert(m.TreeRelation(test.s1, test.s2), qt.Equals, test.expect) + }) + } + }) + + home, blog, blog_sub, blog_sub2, docs, docs_sub := &contentNode{}, &contentNode{key: "/blog"}, &contentNode{key: "/blog/sub"}, &contentNode{key: "/blog/sub2"}, &contentNode{key: "/docs"}, &contentNode{key: "/docs/sub"} + docs_sub2, docs_sub2_sub := &contentNode{key: "/docs/sub2"}, &contentNode{key: "/docs/sub2/sub"} + + article1, article2 := &contentNode{}, &contentNode{} + + image1, image2, image3 := &contentNode{}, &contentNode{}, &contentNode{} + json1, json2, json3 := &contentNode{}, &contentNode{}, &contentNode{} + xml1, xml2 := &contentNode{}, &contentNode{} + + c.Assert(m.InsertBranch(home), qt.Not(qt.IsNil)) + c.Assert(m.InsertBranch(docs), qt.Not(qt.IsNil)) + c.Assert(m.InsertResource("/docs/data1.json", json1), qt.IsNil) + c.Assert(m.InsertBranch(docs_sub), qt.Not(qt.IsNil)) + c.Assert(m.InsertResource("/docs/sub/data2.json", json2), qt.IsNil) + c.Assert(m.InsertBranch(docs_sub2), qt.Not(qt.IsNil)) + c.Assert(m.InsertResource("/docs/sub2/data1.xml", xml1), qt.IsNil) + c.Assert(m.InsertBranch(docs_sub2_sub), qt.Not(qt.IsNil)) + c.Assert(m.InsertResource("/docs/sub2/sub/data2.xml", xml2), qt.IsNil) + c.Assert(m.InsertBranch(blog), qt.Not(qt.IsNil)) + c.Assert(m.InsertResource("/blog/logo.png", image3), qt.IsNil) + c.Assert(m.InsertBranch(blog_sub), qt.Not(qt.IsNil)) + c.Assert(m.InsertBranch(blog_sub2), qt.Not(qt.IsNil)) + c.Assert(m.InsertResource("/blog/sub2/data3.json", json3), qt.IsNil) + + blogSection := m.Get("/blog") + c.Assert(blogSection.n, qt.Equals, blog) + + _, section := m.LongestPrefix("/blog/asdfadf") + c.Assert(section, qt.Equals, blogSection) + + blogSection.InsertPage("/blog/my-article", article1) + blogSection.InsertPage("/blog/my-article2", article2) + c.Assert(blogSection.InsertResource("/blog/my-article/sunset.jpg", image1), qt.IsNil) + c.Assert(blogSection.InsertResource("/blog/my-article2/sunrise.jpg", image2), qt.IsNil) + + type querySpec struct { + key string + isBranchKey bool + isPrefix bool + noRecurse bool + doBranch bool + doBranchResource bool + doPage bool + doPageResource bool + } + + type queryResult struct { + query branchMapQuery + result []string + } + + newQuery := func(spec querySpec) *queryResult { + qr := &queryResult{} + + addResult := func(typ, key string) { + qr.result = append(qr.result, fmt.Sprintf("%s:%s", typ, key)) + } + + var ( + handleSection func(np contentNodeProvider) bool + handlePage func(np contentNodeProvider) bool + handleLeafResource func(np contentNodeProvider) bool + handleBranchResource func(np contentNodeProvider) bool + + keyBranch branchMapQueryKey + keyLeaf branchMapQueryKey + ) + + if spec.isBranchKey { + keyBranch = newBranchMapQueryKey(spec.key, spec.isPrefix) + } else { + keyLeaf = newBranchMapQueryKey(spec.key, spec.isPrefix) + } + + if spec.doBranch { + handleSection = func(np contentNodeProvider) bool { + addResult("section", np.Key()) + return false + } + } + + if spec.doPage { + handlePage = func(np contentNodeProvider) bool { + addResult("page", np.Key()) + return false + } + } + + if spec.doPageResource { + handleLeafResource = func(np contentNodeProvider) bool { + addResult("resource", np.Key()) + return false + } + } + + if spec.doBranchResource { + handleBranchResource = func(np contentNodeProvider) bool { + addResult("resource-branch", np.Key()) + return false + } + } + + qr.query = branchMapQuery{ + NoRecurse: spec.noRecurse, + Branch: branchMapQueryCallBacks{ + Key: keyBranch, + Page: handleSection, + Resource: handleBranchResource, + }, + Leaf: branchMapQueryCallBacks{ + Key: keyLeaf, + Page: handlePage, + Resource: handleLeafResource, + }, + } + + return qr + } + + for _, test := range []struct { + name string + spec querySpec + expect []string + }{ + { + "Branch", + querySpec{key: "/blog", isBranchKey: true, doBranch: true}, + []string{"section:/blog"}, + }, + { + "Branch pages", + querySpec{key: "/blog", isBranchKey: true, doPage: true}, + []string{"page:/blog/my-article", "page:/blog/my-article2"}, + }, + { + "Branch resources", + querySpec{key: "/docs/", isPrefix: true, isBranchKey: true, doBranchResource: true}, + []string{"resource-branch:/docs/sub/data2.json", "resource-branch:/docs/sub2/data1.xml", "resource-branch:/docs/sub2/sub/data2.xml"}, + }, + { + "Branch section and resources", + querySpec{key: "/docs/", isPrefix: true, isBranchKey: true, doBranch: true, doBranchResource: true}, + []string{"section:/docs/sub", "resource-branch:/docs/sub/data2.json", "section:/docs/sub2", "resource-branch:/docs/sub2/data1.xml", "section:/docs/sub2/sub", "resource-branch:/docs/sub2/sub/data2.xml"}, + }, + { + "Branch section and page resources", + querySpec{key: "/blog", isPrefix: false, isBranchKey: true, doBranchResource: true, doPageResource: true}, + []string{"resource-branch:/blog/logo.png", "resource:/blog/my-article/sunset.jpg", "resource:/blog/my-article2/sunrise.jpg"}, + }, + { + "Branch section and pages", + querySpec{key: "/blog", isBranchKey: true, doBranch: true, doPage: true}, + []string{"section:/blog", "page:/blog/my-article", "page:/blog/my-article2"}, + }, + { + "Branch pages and resources", + querySpec{key: "/blog", isBranchKey: true, doPage: true, doPageResource: true}, + []string{"page:/blog/my-article", "resource:/blog/my-article/sunset.jpg", "page:/blog/my-article2", "resource:/blog/my-article2/sunrise.jpg"}, + }, + { + "Leaf page", + querySpec{key: "/blog/my-article", isBranchKey: false, doPage: true}, + []string{"page:/blog/my-article"}, + }, + { + "Leaf page and resources", + querySpec{key: "/blog/my-article", isBranchKey: false, doPage: true, doPageResource: true}, + []string{"page:/blog/my-article", "resource:/blog/my-article/sunset.jpg"}, + }, + { + "Root sections", + querySpec{key: "/", isBranchKey: true, isPrefix: true, doBranch: true, noRecurse: true}, + []string{"section:/blog", "section:/docs"}, + }, + { + "All sections", + querySpec{key: "", isBranchKey: true, isPrefix: true, doBranch: true}, + []string{"section:", "section:/blog", "section:/blog/sub", "section:/blog/sub2", "section:/docs", "section:/docs/sub", "section:/docs/sub2", "section:/docs/sub2/sub"}, + }, + } { + c.Run(test.name, func(c *qt.C) { + qr := newQuery(test.spec) + c.Assert(m.Walk(qr.query), qt.IsNil) + c.Assert(qr.result, qt.DeepEquals, test.expect) + }) + } +} diff --git a/hugolib/content_map_page.go b/hugolib/content_map_page.go index 228564351e3..9c6e3568bf2 100644 --- a/hugolib/content_map_page.go +++ b/hugolib/content_map_page.go @@ -16,679 +16,779 @@ package hugolib import ( "context" "fmt" + "io" "path" "path/filepath" "strings" "sync" + "time" - "github.com/gohugoio/hugo/common/maps" + "github.com/gohugoio/hugo/common/paths" + + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gohugoio/hugo/resources/page/siteidentities" + + "github.com/gohugoio/hugo/output" "github.com/gohugoio/hugo/common/types" - "github.com/gohugoio/hugo/resources" + "github.com/spf13/cast" + + "github.com/gohugoio/hugo/common/maps" - "github.com/gohugoio/hugo/common/hugio" - "github.com/gohugoio/hugo/hugofs" - "github.com/gohugoio/hugo/hugofs/files" - "github.com/gohugoio/hugo/parser/pageparser" "github.com/gohugoio/hugo/resources/page" "github.com/gohugoio/hugo/resources/resource" - "github.com/spf13/cast" "github.com/gohugoio/hugo/common/para" - "github.com/pkg/errors" ) +func newPageMap(i int, s *Site) *pageMap { + var m *pageMap + + taxonomiesConfig := s.siteCfg.taxonomiesConfig.Values() + createBranchNode := func(elem ...string) *contentNode { + var traits interface{} + key := cleanTreeKey(path.Join(elem...)) + if view, found := taxonomiesConfig.viewsByTreeKey[key]; found { + traits = &contentBundleViewInfo{ + name: view, + } + } + return m.NewContentNode(traits, key) + } + + m = &pageMap{ + cfg: contentMapConfig{ + lang: s.Lang(), + taxonomyConfig: taxonomiesConfig, + taxonomyDisabled: !s.isEnabled(pagekinds.Taxonomy), + taxonomyTermDisabled: !s.isEnabled(pagekinds.Term), + pageDisabled: !s.isEnabled(pagekinds.Page), + }, + i: i, + s: s, + branchMap: newBranchMap(createBranchNode), + } + + m.nav = pageMapNavigation{m: m} + + m.pageReverseIndex = &contentTreeReverseIndex{ + initFn: func(rm map[interface{}]*contentNode) { + m.WalkPagesAllPrefixSection("", nil, contentTreeNoListAlwaysFilter, func(np contentNodeProvider) bool { + n := np.GetNode() + fi := n.FileInfo() + + addKey := func(k string) { + existing, found := rm[k] + if found && existing != ambiguousContentNode { + rm[k] = ambiguousContentNode + } else if !found { + rm[k] = n + } + } + + k1 := cleanTreeKey(path.Base(n.Key())) + addKey(k1) + + if fi != nil { + // TODO1 + meta := fi.Meta() + k2 := paths.Parse(cleanTreeKey(filepath.Base(meta.Filename))).Base() + if k2 != k1 { + // addKey(k2) + } + } + + return false + }) + }, + contentTreeReverseIndexMap: &contentTreeReverseIndexMap{}, + } + + return m +} + func newPageMaps(h *HugoSites) *pageMaps { mps := make([]*pageMap, len(h.Sites)) for i, s := range h.Sites { mps[i] = s.pageMap } return &pageMaps{ - workers: para.New(h.numWorkers), + workers: para.New(1), // TODO1 h.numWorkers), pmaps: mps, } } -type pageMap struct { - s *Site - *contentMap +type contentTreeReverseIndex struct { + initFn func(rm map[interface{}]*contentNode) + *contentTreeReverseIndexMap } -func (m *pageMap) Len() int { - l := 0 - for _, t := range m.contentMap.pageTrees { - l += t.Len() +func (c *contentTreeReverseIndex) Reset() { + c.contentTreeReverseIndexMap = &contentTreeReverseIndexMap{ + m: make(map[interface{}]*contentNode), } - return l } -func (m *pageMap) createMissingTaxonomyNodes() error { - if m.cfg.taxonomyDisabled { - return nil - } - m.taxonomyEntries.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) - vi := n.viewInfo - k := cleanSectionTreeKey(vi.name.plural + "/" + vi.termKey) - - if _, found := m.taxonomies.Get(k); !found { - vic := &contentBundleViewInfo{ - name: vi.name, - termKey: vi.termKey, - termOrigin: vi.termOrigin, - } - m.taxonomies.Insert(k, &contentNode{viewInfo: vic}) - } - return false +func (c *contentTreeReverseIndex) Get(key interface{}) *contentNode { + c.init.Do(func() { + c.m = make(map[interface{}]*contentNode) + c.initFn(c.contentTreeReverseIndexMap.m) }) - - return nil + return c.m[key] } -func (m *pageMap) newPageFromContentNode(n *contentNode, parentBucket *pagesMapBucket, owner *pageState) (*pageState, error) { - if n.fi == nil { - panic("FileInfo must (currently) be set") - } - - f, err := newFileInfo(m.s.SourceSpec, n.fi) - if err != nil { - return nil, err - } - - meta := n.fi.Meta() - content := func() (hugio.ReadSeekCloser, error) { - return meta.Open() - } +type contentTreeReverseIndexMap struct { + init sync.Once + m map[interface{}]*contentNode +} - bundled := owner != nil - s := m.s +type ordinalWeight struct { + ordinal int + weight int +} - sections := s.sectionsFromFile(f) +type pageMap struct { + cfg contentMapConfig + i int + s *Site - kind := s.kindFromFileInfoOrSections(f, sections) - if kind == page.KindTerm { - s.PathSpec.MakePathsSanitized(sections) - } + nav pageMapNavigation - metaProvider := &pageMeta{kind: kind, sections: sections, bundled: bundled, s: s, f: f} + *branchMap - ps, err := newPageBase(metaProvider) - if err != nil { - return nil, err - } + // A reverse index used as a fallback in GetPage for short references. + pageReverseIndex *contentTreeReverseIndex +} - if n.fi.Meta().IsRootFile { - // Make sure that the bundle/section we start walking from is always - // rendered. - // This is only relevant in server fast render mode. - ps.forceRender = true +func (m *pageMap) NewContentNode(traits interface{}, elem ...string) *contentNode { + switch v := traits.(type) { + case string: + panic("traits can not be a string") + case *contentBundleViewInfo: + if v == nil { + panic("traits can not be nil") + } } - n.p = ps - if ps.IsNode() { - ps.bucket = newPageBucket(ps) + var pth string + if len(elem) > 0 { + pth = elem[0] + if len(elem) > 1 { + pth = path.Join(elem...) + } } - gi, err := s.h.gitInfoForPage(ps) - if err != nil { - return nil, errors.Wrap(err, "failed to load Git data") - } - ps.gitInfo = gi + key := cleanTreeKey(pth) - r, err := content() - if err != nil { - return nil, err + n := &contentNode{ + key: key, + traits: traits, + running: m.s.running(), } - defer r.Close() - parseResult, err := pageparser.Parse( - r, - pageparser.Config{EnableEmoji: s.siteCfg.enableEmoji}, - ) - if err != nil { - return nil, err - } + return n +} - ps.pageContent = pageContent{ - source: rawPageContent{ - parsed: parseResult, - posMainContent: -1, - posSummaryEnd: -1, - posBodyStart: -1, - }, +func (m *pageMap) AssemblePages(changeTracker *whatChanged) error { + isRebuild := m.cfg.isRebuild + if isRebuild { + siteLastMod := m.s.lastmod + defer func() { + if siteLastMod != m.s.lastmod { + changeTracker.Add(siteidentities.Stats) + } + }() } - ps.shortcodeState = newShortcodeHandler(ps, ps.s, nil) + var theErr error - if err := ps.mapContent(parentBucket, metaProvider); err != nil { - return nil, ps.wrapError(err) - } - - if err := metaProvider.applyDefaultValues(n); err != nil { - return nil, err + if isRebuild { + m.WalkTaxonomyTerms(func(s string, b *contentBranchNode) bool { + b.refs = make(map[interface{}]ordinalWeight) + return false + }) } - ps.init.Add(func() (interface{}, error) { - pp, err := newPagePaths(s, ps, metaProvider) - if err != nil { - return nil, err - } - - outputFormatsForPage := ps.m.outputFormats() - - // Prepare output formats for all sites. - // We do this even if this page does not get rendered on - // its own. It may be referenced via .Site.GetPage and - // it will then need an output format. - ps.pageOutputs = make([]*pageOutput, len(ps.s.h.renderFormats)) - created := make(map[string]*pageOutput) - shouldRenderPage := !ps.m.noRender() - - for i, f := range ps.s.h.renderFormats { - if po, found := created[f.Name]; found { - ps.pageOutputs[i] = po - continue - } - - render := shouldRenderPage - if render { - _, render = outputFormatsForPage.GetByName(f.Name) - } + // Holds references to sections or pages to exlude from the build + // because front matter dictated it (e.g. a draft). + var ( + sectionsToDelete = make(map[string]bool) + pagesToDelete []contentTreeRefProvider + ) - po := newPageOutput(ps, pp, f, render) + // handleBranch creates the Page in np if not already set. + handleBranch := func(np contentNodeProvider) bool { + n := np.GetNode() + s := np.Key() + tref := np.(contentTreeRefProvider) + branch := tref.GetBranch() + var err error - // Create a content provider for the first, - // we may be able to reuse it. - if i == 0 { - contentProvider, err := newPageContentOutput(ps, po) + if n.p != nil { + if n.p.buildState > 0 { + n.p, err = m.s.newPageFromTreeRef(tref, n.p.pageContent) if err != nil { - return nil, err + theErr = err + return true } - po.initContentProvider(contentProvider) + } + // Page already set, nothing more to do. + if n.p.IsHome() { + m.s.home = n.p + } + return false + } else { + n.p, err = m.s.newPageFromTreeRef(tref, zeroContent) + if err != nil { + theErr = err + return true } - ps.pageOutputs[i] = po - created[f.Name] = po + } + if n.p.IsHome() { + m.s.home = n.p } - if err := ps.initCommonProviders(pp); err != nil { - return nil, err + if !m.s.shouldBuild(n.p) { + sectionsToDelete[s] = true + if s == "" { + // Home page, abort. + return true + } } - return nil, nil - }) + branch.n.p.m.calculated.UpdateDateAndLastmodIfAfter(n.p.m.userProvided) - ps.parent = owner + return false + } - return ps, nil -} + // handlePage creates the page in np. + handlePage := func(np contentNodeProvider) bool { + n := np.GetNode() + tref2 := np.(contentTreeRefProvider) + branch := np.(contentGetBranchProvider).GetBranch() -func (m *pageMap) newResource(fim hugofs.FileMetaInfo, owner *pageState) (resource.Resource, error) { - if owner == nil { - panic("owner is nil") - } - // TODO(bep) consolidate with multihost logic + clean up - outputFormats := owner.m.outputFormats() - seen := make(map[string]bool) - var targetBasePaths []string - // Make sure bundled resources are published to all of the output formats' - // sub paths. - for _, f := range outputFormats { - p := f.Path - if seen[p] { - continue + if n.p == nil { + var err error + n.p, err = m.s.newPageFromTreeRef(tref2, zeroContent) + if err != nil { + theErr = err + return true + } + + } else if n.p.buildState > 0 { + var err error + n.p, err = m.s.newPageFromTreeRef(tref2, n.p.pageContent) + if err != nil { + theErr = err + return true + } + } else { + return false } - seen[p] = true - targetBasePaths = append(targetBasePaths, p) - } + if !m.s.shouldBuild(n.p) { + pagesToDelete = append(pagesToDelete, tref2) + return false + } + + branch.n.p.m.calculated.UpdateDateAndLastmodIfAfter(n.p.m.userProvided) - meta := fim.Meta() - r := func() (hugio.ReadSeekCloser, error) { - return meta.Open() + return false } - target := strings.TrimPrefix(meta.Path, owner.File().Dir()) + // handleResource creates the resources in np. + handleResource := func(np contentNodeProvider) bool { + n := np.GetNode() - return owner.s.ResourceSpec.New( - resources.ResourceSourceDescriptor{ - TargetPaths: owner.getTargetPaths, - OpenReadSeekCloser: r, - FileInfo: fim, - RelTargetFilename: target, - TargetBasePaths: targetBasePaths, - LazyPublish: !owner.m.buildConfig.PublishResources, - }) -} + if n.p != nil { + return false + } -func (m *pageMap) createSiteTaxonomies() error { - m.s.taxonomies = make(TaxonomyList) - var walkErr error - m.taxonomies.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) - t := n.viewInfo + branch := np.(contentGetBranchProvider).GetBranch() + owner := np.(contentGetContainerNodeProvider).GetContainerNode() + tref2 := np.(contentTreeRefProvider) - viewName := t.name + if owner.p == nil { + panic("invalid state, page not set on resource owner") + } - if t.termKey == "" { - m.s.taxonomies[viewName.plural] = make(Taxonomy) - } else { - taxonomy := m.s.taxonomies[viewName.plural] - if taxonomy == nil { - walkErr = errors.Errorf("missing taxonomy: %s", viewName.plural) + p := owner.p + meta := n.FileInfo().Meta() + classifier := meta.PathInfo.BundleType() + var r resource.Resource + switch classifier { + case paths.BundleTypeContent: + var rp *pageState + var err error + rp, err = m.s.newPageFromTreeRef(tref2, zeroContent) + if err != nil { + theErr = err return true } - m.taxonomyEntries.WalkPrefix(s, func(ss string, v interface{}) bool { - b2 := v.(*contentNode) - info := b2.viewInfo - taxonomy.add(info.termKey, page.NewWeightedPage(info.weight, info.ref.p, n.p)) - - return false - }) + r = rp + case paths.BundleTypeFile: + var err error + r, err = branch.newResource(n, p) + if err != nil { + theErr = err + return true + } + default: + panic(fmt.Sprintf("invalid classifier: %d", classifier)) } - return false - }) + p.resources = append(p.resources, r) - for _, taxonomy := range m.s.taxonomies { - for _, v := range taxonomy { - v.Sort() - } + return false } - return walkErr -} - -func (m *pageMap) createListAllPages() page.Pages { - pages := make(page.Pages, 0) + // Create home page if it does not exist. + hn := m.Get("") + if hn == nil { + hn = m.InsertBranch(&contentNode{}) + } - m.contentMap.pageTrees.Walk(func(s string, n *contentNode) bool { - if n.p == nil { - panic(fmt.Sprintf("BUG: page not set for %q", s)) + // Create the fixed output pages if not already there. + addStandalone := func(s, kind string, f output.Format) { + if !m.s.isEnabled(kind) { + return } - if contentTreeNoListAlwaysFilter(s, n) { - return false + + if !hn.pages.Has(s) { + hn.InsertPage(s, &contentNode{key: s, traits: kindOutputFormat{kind: kind, output: f}}) } - pages = append(pages, n.p) - return false - }) + } - page.SortByDefault(pages) - return pages -} + addStandalone("/404", pagekinds.Status404, output.HTTPStatusHTMLFormat) -func (m *pageMap) assemblePages() error { - m.taxonomyEntries.DeletePrefix("/") + if m.i == 0 || m.s.h.IsMultihost() { + addStandalone("/robots", pagekinds.RobotsTXT, output.RobotsTxtFormat) + } - if err := m.assembleSections(); err != nil { - return err + // TODO1 coordinate + addStandalone("/sitemap", pagekinds.Sitemap, output.SitemapFormat) + + if !m.cfg.taxonomyDisabled { + // Create the top level taxonomy nodes if they don't exist. + for _, viewName := range m.cfg.taxonomyConfig.views { + key := viewName.pluralTreeKey + if sectionsToDelete[key] { + continue + } + taxonomy := m.Get(key) + if taxonomy == nil { + n := m.NewContentNode( + &contentBundleViewInfo{ + name: viewName, + }, + viewName.plural, + ) + m.InsertRootAndBranch(n) + } + } } - var err error + // First pass: Create Pages and Resources. + m.Walk( + branchMapQuery{ + Deep: true, // Need the branch tree + Exclude: func(s string, n *contentNode) bool { return false }, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey("", true), + Page: handleBranch, + Resource: handleResource, + }, + Leaf: branchMapQueryCallBacks{ + Page: handlePage, + Resource: handleResource, + }, + }) - if err != nil { - return err + if theErr != nil { + return theErr } - m.pages.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) + // Delete pages and sections marked for deletion. + for _, p := range pagesToDelete { + p.GetBranch().pages.nodes.Delete(p.Key()) + p.GetBranch().pageResources.nodes.Delete(p.Key() + "/") + if !p.GetBranch().n.HasFi() && p.GetBranch().pages.nodes.Len() == 0 { + // Delete orphan section. + sectionsToDelete[p.GetBranch().n.key] = true + } + } - var shouldBuild bool + for s := range sectionsToDelete { + m.branches.Delete(s) + m.branches.DeletePrefix(s + "/") + } - defer func() { - // Make sure we always rebuild the view cache. - if shouldBuild && err == nil && n.p != nil { - m.attachPageToViews(s, n) + // Attach pages to views. + if !m.cfg.taxonomyDisabled { + handleTaxonomyEntries := func(np contentNodeProvider) bool { + if m.cfg.taxonomyTermDisabled { + return false } - }() - if n.p != nil { - // A rebuild - shouldBuild = true - return false - } + for _, viewName := range m.cfg.taxonomyConfig.views { + if sectionsToDelete[viewName.pluralTreeKey] { + continue + } - var parent *contentNode - var parentBucket *pagesMapBucket + taxonomy := m.Get(viewName.pluralTreeKey) - _, parent = m.getSection(s) - if parent == nil { - panic(fmt.Sprintf("BUG: parent not set for %q", s)) - } - parentBucket = parent.p.bucket + n := np.GetNode() + s := np.Key() - n.p, err = m.newPageFromContentNode(n, parentBucket, nil) - if err != nil { - return true - } + if n.p == nil { + panic("page is nil: " + s) + } + vals := types.ToStringSlicePreserveString(getParam(n.p, viewName.plural, false)) + if vals == nil { + continue + } - shouldBuild = !(n.p.Kind() == page.KindPage && m.cfg.pageDisabled) && m.s.shouldBuild(n.p) - if !shouldBuild { - m.deletePage(s) - return false - } + w := getParamToLower(n.p, viewName.plural+"_weight") + weight, err := cast.ToIntE(w) + if err != nil { + m.s.Log.Errorf("Unable to convert taxonomy weight %#v to int for %q", w, n.p.Path()) + // weight will equal zero, so let the flow continue + } - n.p.treeRef = &contentTreeRef{ - m: m, - t: m.pages, - n: n, - key: s, - } + for i, v := range vals { + keyParts := append(viewName.pluralParts(), v) + key := cleanTreeKey(keyParts...) - if err = m.assembleResources(s, n.p, parentBucket); err != nil { - return true - } + // It may have been added with the content files + termBranch := m.Get(key) - return false - }) + if termBranch == nil { + vic := &contentBundleViewInfo{ + name: viewName, + term: v, + } - m.deleteOrphanSections() + n := m.NewContentNode(vic, key) - return err -} + _, termBranch = m.InsertRootAndBranch(n) -func (m *pageMap) assembleResources(s string, p *pageState, parentBucket *pagesMapBucket) error { - var err error + treeRef := m.newNodeProviderPage(key, n, taxonomy, termBranch, true).(contentTreeRefProvider) + n.p, err = m.s.newPageFromTreeRef(treeRef, zeroContent) + if err != nil { + return true + } + } - m.resources.WalkPrefix(s, func(s string, v interface{}) bool { - n := v.(*contentNode) - meta := n.fi.Meta() - classifier := meta.Classifier - var r resource.Resource - switch classifier { - case files.ContentClassContent: - var rp *pageState - rp, err = m.newPageFromContentNode(n, parentBucket, p) - if err != nil { - return true - } - rp.m.resourcePath = filepath.ToSlash(strings.TrimPrefix(rp.File().Path(), p.File().Dir())) - r = rp + termBranch.refs[n.p] = ordinalWeight{ordinal: i, weight: weight} + termBranch.n.p.m.calculated.UpdateDateAndLastmodIfAfter(n.p.m.userProvided) + } - case files.ContentClassFile: - r, err = m.newResource(n.fi, p) - if err != nil { - return true } - default: - panic(fmt.Sprintf("invalid classifier: %q", classifier)) + return false } - p.resources = append(p.resources, r) - return false - }) - - return err -} + m.Walk( + branchMapQuery{ + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey("", true), + Page: handleTaxonomyEntries, + }, + Leaf: branchMapQueryCallBacks{ + Page: handleTaxonomyEntries, + }, + }, + ) -func (m *pageMap) assembleSections() error { - var sectionsToDelete []string - var err error + } - m.sections.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) - var shouldBuild bool + // Finally, collect aggregate values from the content tree. + var ( + siteLastChanged time.Time + rootSectionCounters map[string]int + ) - defer func() { - // Make sure we always rebuild the view cache. - if shouldBuild && err == nil && n.p != nil { - m.attachPageToViews(s, n) - if n.p.IsHome() { - m.s.home = n.p - } - } - }() + _, mainSectionsSet := m.s.s.Info.Params()["mainsections"] + if !mainSectionsSet { + rootSectionCounters = make(map[string]int) + } - sections := m.splitKey(s) + handleAggregatedValues := func(np contentNodeProvider) bool { + n := np.GetNode() + s := np.Key() + branch := np.(contentGetBranchProvider).GetBranch() + owner := np.(contentGetContainerBranchProvider).GetContainerBranch() - if n.p != nil { - if n.p.IsHome() { - m.s.home = n.p + if s == "" { + if n.p.m.calculated.Lastmod().After(siteLastChanged) { + siteLastChanged = n.p.m.calculated.Lastmod() } - shouldBuild = true return false } - var parent *contentNode - var parentBucket *pagesMapBucket - - if s != "/" { - _, parent = m.getSection(s) - if parent == nil || parent.p == nil { - panic(fmt.Sprintf("BUG: parent not set for %q", s)) + if rootSectionCounters != nil { + // Keep track of the page count per root section + rootSection := s[1:] + firstSlash := strings.Index(rootSection, "/") + if firstSlash != -1 { + rootSection = rootSection[:firstSlash] } + rootSectionCounters[rootSection] += branch.pages.nodes.Len() } - if parent != nil { - parentBucket = parent.p.bucket - } else if s == "/" { - parentBucket = m.s.siteBucket - } + parent := owner.n.p + for parent != nil { + parent.m.calculated.UpdateDateAndLastmodIfAfter(n.p.m.calculated) - kind := page.KindSection - if s == "/" { - kind = page.KindHome - } + if n.p.m.calculated.Lastmod().After(siteLastChanged) { + siteLastChanged = n.p.m.calculated.Lastmod() + } - if n.fi != nil { - n.p, err = m.newPageFromContentNode(n, parentBucket, nil) - if err != nil { - return true + if parent.bucket == nil { + panic("bucket not set") } - } else { - n.p = m.s.newPage(n, parentBucket, kind, "", sections...) - } - shouldBuild = m.s.shouldBuild(n.p) - if !shouldBuild { - sectionsToDelete = append(sectionsToDelete, s) - return false - } + if parent.bucket.parent == nil { + break + } - n.p.treeRef = &contentTreeRef{ - m: m, - t: m.sections, - n: n, - key: s, + parent = parent.bucket.parent.self } - if err = m.assembleResources(s+cmLeafSeparator, n.p, parentBucket); err != nil { - return true + return false + } + + m.Walk( + branchMapQuery{ + Deep: true, // Need the branch relations + OnlyBranches: true, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey("", true), + Page: handleAggregatedValues, + }, + }, + ) + + m.s.lastmod = siteLastChanged + if rootSectionCounters != nil { + var mainSection string + var mainSectionCount int + + for k, v := range rootSectionCounters { + if v > mainSectionCount { + mainSection = k + mainSectionCount = v + } } - return false - }) + mainSections := []string{mainSection} + m.s.s.Info.Params()["mainSections"] = mainSections + m.s.s.Info.Params()["mainsections"] = mainSections - for _, s := range sectionsToDelete { - m.deleteSectionByPath(s) } - return err + return nil } -func (m *pageMap) assembleTaxonomies() error { - var taxonomiesToDelete []string - var err error - - m.taxonomies.Walk(func(s string, v interface{}) bool { - n := v.(*contentNode) +func (m *pageMap) CreateListAllPages() page.Pages { + pages := make(page.Pages, 0) - if n.p != nil { - return false + m.WalkPagesAllPrefixSection("", nil, contentTreeNoListAlwaysFilter, func(np contentNodeProvider) bool { + n := np.GetNode() + if n.p == nil { + panic(fmt.Sprintf("BUG: page not set for %q", np.Key())) } + pages = append(pages, n.p) + return false + }) - kind := n.viewInfo.kind() - sections := n.viewInfo.sections() - - _, parent := m.getTaxonomyParent(s) - if parent == nil || parent.p == nil { - panic(fmt.Sprintf("BUG: parent not set for %q", s)) - } - parentBucket := parent.p.bucket + page.SortByDefault(pages) + return pages +} - if n.fi != nil { - n.p, err = m.newPageFromContentNode(n, parent.p.bucket, nil) - if err != nil { - return true - } - } else { - title := "" - if kind == page.KindTerm { - title = n.viewInfo.term() +func (m *pageMap) CreateSiteTaxonomies() error { + m.s.taxonomies = make(TaxonomyList) + for _, viewName := range m.cfg.taxonomyConfig.views { + taxonomy := make(Taxonomy) + m.s.taxonomies[viewName.plural] = taxonomy + prefix := viewName.pluralTreeKey + "/" + m.WalkBranchesPrefix(prefix, func(s string, b *contentBranchNode) bool { + termKey := strings.TrimPrefix(s, prefix) + for k, v := range b.refs { + taxonomy.add(termKey, page.NewWeightedPage(v.weight, k.(*pageState), b.n.p)) } - n.p = m.s.newPage(n, parent.p.bucket, kind, title, sections...) - } - if !m.s.shouldBuild(n.p) { - taxonomiesToDelete = append(taxonomiesToDelete, s) return false - } + }) + } - n.p.treeRef = &contentTreeRef{ - m: m, - t: m.taxonomies, - n: n, - key: s, + for _, taxonomy := range m.s.taxonomies { + for _, v := range taxonomy { + v.Sort() } + } - if err = m.assembleResources(s+cmLeafSeparator, n.p, parentBucket); err != nil { - return true - } + return nil +} - return false - }) +func (m *pageMap) WalkTaxonomyTerms(fn func(s string, b *contentBranchNode) bool) { + for _, viewName := range m.cfg.taxonomyConfig.views { + m.WalkBranchesPrefix(viewName.pluralTreeKey+"/", func(s string, b *contentBranchNode) bool { + return fn(s, b) + }) + } +} - for _, s := range taxonomiesToDelete { - m.deleteTaxonomy(s) +func (m *pageMap) WithEveryBundleNode(fn func(n *contentNode) bool) error { + callbackPage := func(np contentNodeProvider) bool { + return fn(np.GetNode()) } - return err -} + callbackResource := func(np contentNodeProvider) bool { + return fn(np.GetNode()) + } -func (m *pageMap) attachPageToViews(s string, b *contentNode) { - if m.cfg.taxonomyDisabled { - return + q := branchMapQuery{ + Exclude: func(s string, n *contentNode) bool { return n.p == nil }, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey("", true), + Page: callbackPage, + Resource: callbackResource, + }, + Leaf: branchMapQueryCallBacks{ + Page: callbackPage, + Resource: callbackResource, + }, } - for _, viewName := range m.cfg.taxonomyConfig { - vals := types.ToStringSlicePreserveString(getParam(b.p, viewName.plural, false)) - if vals == nil { - continue - } - w := getParamToLower(b.p, viewName.plural+"_weight") - weight, err := cast.ToIntE(w) - if err != nil { - m.s.Log.Errorf("Unable to convert taxonomy weight %#v to int for %q", w, b.p.Pathc()) - // weight will equal zero, so let the flow continue + return m.Walk(q) +} + +// WithEveryBundlePage applies fn to every Page, including those bundled inside +// leaf bundles. +func (m *pageMap) WithEveryBundlePage(fn func(p *pageState) bool) error { + return m.WithEveryBundleNode(func(n *contentNode) bool { + if n.p != nil { + return fn(n.p) } + return false + }) +} - for i, v := range vals { - termKey := m.s.getTaxonomyKey(v) - - bv := &contentNode{ - viewInfo: &contentBundleViewInfo{ - ordinal: i, - name: viewName, - termKey: termKey, - termOrigin: v, - weight: weight, - ref: b, - }, - } +func (m *pageMap) debug(prefix string, w io.Writer) { + m.branchMap.debug(prefix, w) - var key string - if strings.HasSuffix(s, "/") { - key = cleanSectionTreeKey(path.Join(viewName.plural, termKey, s)) - } else { - key = cleanTreeKey(path.Join(viewName.plural, termKey, s)) - } - m.taxonomyEntries.Insert(key, bv) - } + fmt.Fprintln(w) + for k := range m.pageReverseIndex.m { + fmt.Fprintln(w, k) } } -type pageMapQuery struct { - Prefix string - Filter contentTreeNodeCallback +type pageMapNavigation struct { + m *pageMap } -func (m *pageMap) collectPages(query pageMapQuery, fn func(c *contentNode)) error { - if query.Filter == nil { - query.Filter = contentTreeNoListAlwaysFilter +func (nav pageMapNavigation) getPagesAndSections(in contentNodeProvider) page.Pages { + if in == nil { + return nil } - m.pages.WalkQuery(query, func(s string, n *contentNode) bool { - fn(n) - return false - }) + var pas page.Pages - return nil + nav.m.WalkPagesPrefixSectionNoRecurse( + in.Key()+"/", + noTaxonomiesFilter, + in.GetNode().p.m.getListFilter(true), + func(n contentNodeProvider) bool { + pas = append(pas, n.GetNode().p) + return false + }, + ) + + page.SortByDefault(pas) + + return pas } -func (m *pageMap) collectPagesAndSections(query pageMapQuery, fn func(c *contentNode)) error { - if err := m.collectSections(query, fn); err != nil { - return err +func (nav pageMapNavigation) getRegularPages(in contentNodeProvider) page.Pages { + if in == nil { + return nil } - query.Prefix = query.Prefix + cmBranchSeparator - if err := m.collectPages(query, fn); err != nil { - return err + var pas page.Pages + + q := branchMapQuery{ + Exclude: in.GetNode().p.m.getListFilter(true), + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey(in.Key(), false), + }, + Leaf: branchMapQueryCallBacks{ + Page: func(n contentNodeProvider) bool { + pas = append(pas, n.GetNode().p) + return false + }, + }, } - return nil -} + nav.m.Walk(q) -func (m *pageMap) collectSections(query pageMapQuery, fn func(c *contentNode)) error { - level := strings.Count(query.Prefix, "/") + page.SortByDefault(pas) - return m.collectSectionsFn(query, func(s string, c *contentNode) bool { - if strings.Count(s, "/") != level+1 { - return false - } + return pas +} - fn(c) +func (nav pageMapNavigation) getRegularPagesRecursive(in contentNodeProvider) page.Pages { + if in == nil { + return nil + } - return false - }) -} + var pas page.Pages -func (m *pageMap) collectSectionsFn(query pageMapQuery, fn func(s string, c *contentNode) bool) error { - if !strings.HasSuffix(query.Prefix, "/") { - query.Prefix += "/" + q := branchMapQuery{ + Exclude: in.GetNode().p.m.getListFilter(true), + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey(in.Key()+"/", true), + }, + Leaf: branchMapQueryCallBacks{ + Page: func(n contentNodeProvider) bool { + pas = append(pas, n.GetNode().p) + return false + }, + }, } - m.sections.WalkQuery(query, func(s string, n *contentNode) bool { - return fn(s, n) - }) + nav.m.Walk(q) - return nil -} + page.SortByDefault(pas) -func (m *pageMap) collectSectionsRecursiveIncludingSelf(query pageMapQuery, fn func(c *contentNode)) error { - return m.collectSectionsFn(query, func(s string, c *contentNode) bool { - fn(c) - return false - }) + return pas } -func (m *pageMap) collectTaxonomies(prefix string, fn func(c *contentNode)) error { - m.taxonomies.WalkQuery(pageMapQuery{Prefix: prefix}, func(s string, n *contentNode) bool { - fn(n) - return false - }) - return nil -} +func (nav pageMapNavigation) getSections(in contentNodeProvider) page.Pages { + if in == nil { + return nil + } + var pas page.Pages -// withEveryBundlePage applies fn to every Page, including those bundled inside -// leaf bundles. -func (m *pageMap) withEveryBundlePage(fn func(p *pageState) bool) { - m.bundleTrees.Walk(func(s string, n *contentNode) bool { - if n.p != nil { - return fn(n.p) - } - return false - }) + q := branchMapQuery{ + NoRecurse: true, + Exclude: in.GetNode().p.m.getListFilter(true), + BranchExclude: noTaxonomiesFilter, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey(in.Key()+"/", true), + Page: func(n contentNodeProvider) bool { + pas = append(pas, n.GetNode().p) + return false + }, + }, + } + + nav.m.Walk(q) + + page.SortByDefault(pas) + + return pas } type pageMaps struct { @@ -696,89 +796,64 @@ type pageMaps struct { pmaps []*pageMap } +func (m *pageMaps) AssemblePages(changeTracker *whatChanged) error { + return m.withMaps(func(runner para.Runner, pm *pageMap) error { + if err := pm.AssemblePages(changeTracker); err != nil { + return err + } + return nil + }) +} + // deleteSection deletes the entire section from s. func (m *pageMaps) deleteSection(s string) { - m.withMaps(func(pm *pageMap) error { - pm.deleteSectionByPath(s) + m.withMaps(func(runner para.Runner, pm *pageMap) error { + pm.branches.Delete(s) + pm.branches.DeletePrefix(s + "/") return nil }) } -func (m *pageMaps) AssemblePages() error { - return m.withMaps(func(pm *pageMap) error { - if err := pm.CreateMissingNodes(); err != nil { - return err - } - - if err := pm.assemblePages(); err != nil { - return err - } - - if err := pm.createMissingTaxonomyNodes(); err != nil { - return err - } - - // Handle any new sections created in the step above. - if err := pm.assembleSections(); err != nil { - return err - } - - if pm.s.home == nil { - // Home is disabled, everything is. - pm.bundleTrees.DeletePrefix("") - return nil - } - - if err := pm.assembleTaxonomies(); err != nil { - return err - } - - if err := pm.createSiteTaxonomies(); err != nil { - return err - } - - sw := §ionWalker{m: pm.contentMap} - a := sw.applyAggregates() - _, mainSectionsSet := pm.s.s.Info.Params()["mainsections"] - if !mainSectionsSet && a.mainSection != "" { - mainSections := []string{strings.TrimRight(a.mainSection, "/")} - pm.s.s.Info.Params()["mainSections"] = mainSections - pm.s.s.Info.Params()["mainsections"] = mainSections +func (m *pageMaps) walkBranchesPrefix(prefix string, fn func(s string, n *contentNode) bool) error { + return m.withMaps(func(runner para.Runner, pm *pageMap) error { + callbackPage := func(np contentNodeProvider) bool { + return fn(np.Key(), np.GetNode()) } - pm.s.lastmod = a.datesAll.Lastmod() - if resource.IsZeroDates(pm.s.home) { - pm.s.home.m.Dates = a.datesAll + q := branchMapQuery{ + OnlyBranches: true, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey(prefix, true), + Page: callbackPage, + }, } - return nil + return pm.Walk(q) }) } -func (m *pageMaps) walkBundles(fn func(n *contentNode) bool) { - _ = m.withMaps(func(pm *pageMap) error { - pm.bundleTrees.Walk(func(s string, n *contentNode) bool { - return fn(n) - }) - return nil +func (m *pageMaps) walkBundles(fn func(n *contentNode) bool) error { + return m.withMaps(func(runner para.Runner, pm *pageMap) error { + return pm.WithEveryBundleNode(fn) }) } -func (m *pageMaps) walkBranchesPrefix(prefix string, fn func(s string, n *contentNode) bool) { - _ = m.withMaps(func(pm *pageMap) error { - pm.branchTrees.WalkPrefix(prefix, func(s string, n *contentNode) bool { - return fn(s, n) - }) - return nil - }) +func (m *pageMaps) withMaps(fn func(runner para.Runner, pm *pageMap) error) error { + for _, pm := range m.pmaps { + pm := pm + if err := fn(nil, pm); err != nil { + return err + } + } + return nil } -func (m *pageMaps) withMaps(fn func(pm *pageMap) error) error { +func (m *pageMaps) withMapsPara(fn func(runner para.Runner, pm *pageMap) error) error { g, _ := m.workers.Start(context.Background()) for _, pm := range m.pmaps { pm := pm g.Run(func() error { - return fn(pm) + return fn(g, pm) }) } return g.Wait() @@ -788,249 +863,146 @@ type pagesMapBucket struct { // Cascading front matter. cascade map[page.PageMatcher]maps.Params - owner *pageState // The branch node + parent *pagesMapBucket // The parent bucket, nil if the home page. + self *pageState // The branch node. *pagesMapBucketPages } -type pagesMapBucketPages struct { - pagesInit sync.Once - pages page.Pages - - pagesAndSectionsInit sync.Once - pagesAndSections page.Pages - - sectionsInit sync.Once - sections page.Pages -} - -func (b *pagesMapBucket) getPages() page.Pages { - b.pagesInit.Do(func() { - b.pages = b.owner.treeRef.getPages() - page.SortByDefault(b.pages) - }) - return b.pages -} - -func (b *pagesMapBucket) getPagesRecursive() page.Pages { - pages := b.owner.treeRef.getPagesRecursive() - page.SortByDefault(pages) - return pages -} - func (b *pagesMapBucket) getPagesAndSections() page.Pages { + if b == nil { + return nil + } + b.pagesAndSectionsInit.Do(func() { - b.pagesAndSections = b.owner.treeRef.getPagesAndSections() + b.pagesAndSections = b.self.s.pageMap.nav.getPagesAndSections(b.self.m.treeRef) }) + return b.pagesAndSections } -func (b *pagesMapBucket) getSections() page.Pages { - b.sectionsInit.Do(func() { - if b.owner.treeRef == nil { - return - } - b.sections = b.owner.treeRef.getSections() - }) +func (b *pagesMapBucket) getPagesInTerm() page.Pages { + if b == nil { + return nil + } - return b.sections -} + b.pagesInTermInit.Do(func() { + branch := b.self.m.treeRef.(contentGetBranchProvider).GetBranch() + for k := range branch.refs { + b.pagesInTerm = append(b.pagesInTerm, k.(*pageState)) + } -func (b *pagesMapBucket) getTaxonomies() page.Pages { - b.sectionsInit.Do(func() { - var pas page.Pages - ref := b.owner.treeRef - ref.m.collectTaxonomies(ref.key, func(c *contentNode) { - pas = append(pas, c.p) - }) - page.SortByDefault(pas) - b.sections = pas + page.SortByDefault(b.pagesInTerm) }) - return b.sections + return b.pagesInTerm } -func (b *pagesMapBucket) getTaxonomyEntries() page.Pages { - var pas page.Pages - ref := b.owner.treeRef - viewInfo := ref.n.viewInfo - prefix := strings.ToLower("/" + viewInfo.name.plural + "/" + viewInfo.termKey + "/") - ref.m.taxonomyEntries.WalkPrefix(prefix, func(s string, v interface{}) bool { - n := v.(*contentNode) - pas = append(pas, n.viewInfo.ref.p) - return false +func (b *pagesMapBucket) getRegularPages() page.Pages { + if b == nil { + return nil + } + + b.regularPagesInit.Do(func() { + b.regularPages = b.self.s.pageMap.nav.getRegularPages(b.self.m.treeRef) }) - page.SortByDefault(pas) - return pas -} -type sectionAggregate struct { - datesAll resource.Dates - datesSection resource.Dates - pageCount int - mainSection string - mainSectionPageCount int + return b.regularPages } -type sectionAggregateHandler struct { - sectionAggregate - sectionPageCount int +func (b *pagesMapBucket) getRegularPagesInTerm() page.Pages { + if b == nil { + return nil + } - // Section - b *contentNode - s string -} + b.regularPagesInTermInit.Do(func() { + all := b.getPagesInTerm() -func (h *sectionAggregateHandler) String() string { - return fmt.Sprintf("%s/%s - %d - %s", h.sectionAggregate.datesAll, h.sectionAggregate.datesSection, h.sectionPageCount, h.s) -} - -func (h *sectionAggregateHandler) isRootSection() bool { - return h.s != "/" && strings.Count(h.s, "/") == 2 -} + for _, p := range all { + if p.IsPage() { + b.regularPagesInTerm = append(b.regularPagesInTerm, p) + } + } + }) -func (h *sectionAggregateHandler) handleNested(v sectionWalkHandler) error { - nested := v.(*sectionAggregateHandler) - h.sectionPageCount += nested.pageCount - h.pageCount += h.sectionPageCount - h.datesAll.UpdateDateAndLastmodIfAfter(nested.datesAll) - h.datesSection.UpdateDateAndLastmodIfAfter(nested.datesAll) - return nil + return b.regularPagesInTerm } -func (h *sectionAggregateHandler) handlePage(s string, n *contentNode) error { - h.sectionPageCount++ - - var d resource.Dated - if n.p != nil { - d = n.p - } else if n.viewInfo != nil && n.viewInfo.ref != nil { - d = n.viewInfo.ref.p - } else { +func (b *pagesMapBucket) getRegularPagesRecursive() page.Pages { + if b == nil { return nil } - h.datesAll.UpdateDateAndLastmodIfAfter(d) - h.datesSection.UpdateDateAndLastmodIfAfter(d) - return nil -} - -func (h *sectionAggregateHandler) handleSectionPost() error { - if h.sectionPageCount > h.mainSectionPageCount && h.isRootSection() { - h.mainSectionPageCount = h.sectionPageCount - h.mainSection = strings.TrimPrefix(h.s, "/") - } - - if resource.IsZeroDates(h.b.p) { - h.b.p.m.Dates = h.datesSection - } - - h.datesSection = resource.Dates{} - - return nil -} + b.regularPagesRecursiveInit.Do(func() { + b.regularPagesRecursive = b.self.s.pageMap.nav.getRegularPagesRecursive(b.self.m.treeRef) + }) -func (h *sectionAggregateHandler) handleSectionPre(s string, b *contentNode) error { - h.s = s - h.b = b - h.sectionPageCount = 0 - h.datesAll.UpdateDateAndLastmodIfAfter(b.p) - return nil + return b.regularPagesRecursive } -type sectionWalkHandler interface { - handleNested(v sectionWalkHandler) error - handlePage(s string, b *contentNode) error - handleSectionPost() error - handleSectionPre(s string, b *contentNode) error -} +func (b *pagesMapBucket) getSections() page.Pages { + if b == nil { + return nil + } -type sectionWalker struct { - err error - m *contentMap -} + b.sectionsInit.Do(func() { + b.sections = b.self.s.pageMap.nav.getSections(b.self.m.treeRef) + }) -func (w *sectionWalker) applyAggregates() *sectionAggregateHandler { - return w.walkLevel("/", func() sectionWalkHandler { - return §ionAggregateHandler{} - }).(*sectionAggregateHandler) + return b.sections } -func (w *sectionWalker) walkLevel(prefix string, createVisitor func() sectionWalkHandler) sectionWalkHandler { - level := strings.Count(prefix, "/") - - visitor := createVisitor() +func (b *pagesMapBucket) getTaxonomies() page.Pages { + if b == nil { + return nil + } - w.m.taxonomies.WalkBelow(prefix, func(s string, v interface{}) bool { - currentLevel := strings.Count(s, "/") + b.taxonomiesInit.Do(func() { + ref := b.self.m.treeRef - if currentLevel > level+1 { + b.self.s.pageMap.WalkBranchesPrefix(ref.Key()+"/", func(s string, branch *contentBranchNode) bool { + b.taxonomies = append(b.taxonomies, branch.n.p) return false - } - - n := v.(*contentNode) - - if w.err = visitor.handleSectionPre(s, n); w.err != nil { - return true - } - - if currentLevel == 2 { - nested := w.walkLevel(s, createVisitor) - if w.err = visitor.handleNested(nested); w.err != nil { - return true - } - } else { - w.m.taxonomyEntries.WalkPrefix(s, func(ss string, v interface{}) bool { - n := v.(*contentNode) - w.err = visitor.handlePage(ss, n) - return w.err != nil - }) - } - - w.err = visitor.handleSectionPost() - - return w.err != nil + }) + page.SortByDefault(b.taxonomies) }) - w.m.sections.WalkBelow(prefix, func(s string, v interface{}) bool { - currentLevel := strings.Count(s, "/") - if currentLevel > level+1 { - return false - } - - n := v.(*contentNode) + return b.taxonomies +} - if w.err = visitor.handleSectionPre(s, n); w.err != nil { - return true - } +type pagesMapBucketPages struct { + pagesAndSectionsInit sync.Once + pagesAndSections page.Pages - w.m.pages.WalkPrefix(s+cmBranchSeparator, func(s string, v interface{}) bool { - w.err = visitor.handlePage(s, v.(*contentNode)) - return w.err != nil - }) + regularPagesInit sync.Once + regularPages page.Pages - if w.err != nil { - return true - } + regularPagesRecursiveInit sync.Once + regularPagesRecursive page.Pages - nested := w.walkLevel(s, createVisitor) - if w.err = visitor.handleNested(nested); w.err != nil { - return true - } + sectionsInit sync.Once + sections page.Pages - w.err = visitor.handleSectionPost() + taxonomiesInit sync.Once + taxonomies page.Pages - return w.err != nil - }) + pagesInTermInit sync.Once + pagesInTerm page.Pages - return visitor + regularPagesInTermInit sync.Once + regularPagesInTerm page.Pages } type viewName struct { - singular string // e.g. "category" - plural string // e.g. "categories" + singular string // e.g. "category" + plural string // e.g. "categories" + pluralTreeKey string } func (v viewName) IsZero() bool { return v.singular == "" } + +func (v viewName) pluralParts() []string { + return paths.FieldsSlash(v.plural) +} diff --git a/hugolib/content_map_test.go b/hugolib/content_map_test.go index 014ef9c7d98..0457f78525e 100644 --- a/hugolib/content_map_test.go +++ b/hugolib/content_map_test.go @@ -15,296 +15,9 @@ package hugolib import ( "fmt" - "path/filepath" - "strings" "testing" - - "github.com/gohugoio/hugo/common/paths" - - "github.com/gohugoio/hugo/htesting/hqt" - - "github.com/gohugoio/hugo/hugofs/files" - - "github.com/gohugoio/hugo/hugofs" - "github.com/spf13/afero" - - qt "github.com/frankban/quicktest" ) -func BenchmarkContentMap(b *testing.B) { - writeFile := func(c *qt.C, fs afero.Fs, filename, content string) hugofs.FileMetaInfo { - c.Helper() - filename = filepath.FromSlash(filename) - c.Assert(fs.MkdirAll(filepath.Dir(filename), 0777), qt.IsNil) - c.Assert(afero.WriteFile(fs, filename, []byte(content), 0777), qt.IsNil) - - fi, err := fs.Stat(filename) - c.Assert(err, qt.IsNil) - - mfi := fi.(hugofs.FileMetaInfo) - return mfi - } - - createFs := func(fs afero.Fs, lang string) afero.Fs { - return hugofs.NewBaseFileDecorator(fs, - func(fi hugofs.FileMetaInfo) { - meta := fi.Meta() - // We have a more elaborate filesystem setup in the - // real flow, so simulate this here. - meta.Lang = lang - meta.Path = meta.Filename - meta.Classifier = files.ClassifyContentFile(fi.Name(), meta.OpenFunc) - }) - } - - b.Run("CreateMissingNodes", func(b *testing.B) { - c := qt.New(b) - b.StopTimer() - mps := make([]*contentMap, b.N) - for i := 0; i < b.N; i++ { - m := newContentMap(contentMapConfig{lang: "en"}) - mps[i] = m - memfs := afero.NewMemMapFs() - fs := createFs(memfs, "en") - for i := 1; i <= 20; i++ { - c.Assert(m.AddFilesBundle(writeFile(c, fs, fmt.Sprintf("sect%d/a/index.md", i), "page")), qt.IsNil) - c.Assert(m.AddFilesBundle(writeFile(c, fs, fmt.Sprintf("sect2%d/%sindex.md", i, strings.Repeat("b/", i)), "page")), qt.IsNil) - } - - } - - b.StartTimer() - - for i := 0; i < b.N; i++ { - m := mps[i] - c.Assert(m.CreateMissingNodes(), qt.IsNil) - - b.StopTimer() - m.pages.DeletePrefix("/") - m.sections.DeletePrefix("/") - b.StartTimer() - } - }) -} - -func TestContentMap(t *testing.T) { - c := qt.New(t) - - writeFile := func(c *qt.C, fs afero.Fs, filename, content string) hugofs.FileMetaInfo { - c.Helper() - filename = filepath.FromSlash(filename) - c.Assert(fs.MkdirAll(filepath.Dir(filename), 0777), qt.IsNil) - c.Assert(afero.WriteFile(fs, filename, []byte(content), 0777), qt.IsNil) - - fi, err := fs.Stat(filename) - c.Assert(err, qt.IsNil) - - mfi := fi.(hugofs.FileMetaInfo) - return mfi - } - - createFs := func(fs afero.Fs, lang string) afero.Fs { - return hugofs.NewBaseFileDecorator(fs, - func(fi hugofs.FileMetaInfo) { - meta := fi.Meta() - // We have a more elaborate filesystem setup in the - // real flow, so simulate this here. - meta.Lang = lang - meta.Path = meta.Filename - meta.TranslationBaseName = paths.Filename(fi.Name()) - meta.Classifier = files.ClassifyContentFile(fi.Name(), meta.OpenFunc) - }) - } - - c.Run("AddFiles", func(c *qt.C) { - memfs := afero.NewMemMapFs() - - fsl := func(lang string) afero.Fs { - return createFs(memfs, lang) - } - - fs := fsl("en") - - header := writeFile(c, fs, "blog/a/index.md", "page") - - c.Assert(header.Meta().Lang, qt.Equals, "en") - - resources := []hugofs.FileMetaInfo{ - writeFile(c, fs, "blog/a/b/data.json", "data"), - writeFile(c, fs, "blog/a/logo.png", "image"), - } - - m := newContentMap(contentMapConfig{lang: "en"}) - - c.Assert(m.AddFilesBundle(header, resources...), qt.IsNil) - - c.Assert(m.AddFilesBundle(writeFile(c, fs, "blog/b/c/index.md", "page")), qt.IsNil) - - c.Assert(m.AddFilesBundle( - writeFile(c, fs, "blog/_index.md", "section page"), - writeFile(c, fs, "blog/sectiondata.json", "section resource"), - ), qt.IsNil) - - got := m.testDump() - - expect := ` - Tree 0: - /blog/__hb_a__hl_ - /blog/__hb_b/c__hl_ - Tree 1: - /blog/ - Tree 2: - /blog/__hb_a__hl_b/data.json - /blog/__hb_a__hl_logo.png - /blog/__hl_sectiondata.json - en/pages/blog/__hb_a__hl_|f:blog/a/index.md - - R: blog/a/b/data.json - - R: blog/a/logo.png - en/pages/blog/__hb_b/c__hl_|f:blog/b/c/index.md - en/sections/blog/|f:blog/_index.md - - P: blog/a/index.md - - P: blog/b/c/index.md - - R: blog/sectiondata.json - -` - - c.Assert(got, hqt.IsSameString, expect, qt.Commentf(got)) - - // Add a data file to the section bundle - c.Assert(m.AddFiles( - writeFile(c, fs, "blog/sectiondata2.json", "section resource"), - ), qt.IsNil) - - // And then one to the leaf bundles - c.Assert(m.AddFiles( - writeFile(c, fs, "blog/a/b/data2.json", "data2"), - ), qt.IsNil) - - c.Assert(m.AddFiles( - writeFile(c, fs, "blog/b/c/d/data3.json", "data3"), - ), qt.IsNil) - - got = m.testDump() - - expect = ` - Tree 0: - /blog/__hb_a__hl_ - /blog/__hb_b/c__hl_ - Tree 1: - /blog/ - Tree 2: - /blog/__hb_a__hl_b/data.json - /blog/__hb_a__hl_b/data2.json - /blog/__hb_a__hl_logo.png - /blog/__hb_b/c__hl_d/data3.json - /blog/__hl_sectiondata.json - /blog/__hl_sectiondata2.json - en/pages/blog/__hb_a__hl_|f:blog/a/index.md - - R: blog/a/b/data.json - - R: blog/a/b/data2.json - - R: blog/a/logo.png - en/pages/blog/__hb_b/c__hl_|f:blog/b/c/index.md - - R: blog/b/c/d/data3.json - en/sections/blog/|f:blog/_index.md - - P: blog/a/index.md - - P: blog/b/c/index.md - - R: blog/sectiondata.json - - R: blog/sectiondata2.json - -` - - c.Assert(got, hqt.IsSameString, expect, qt.Commentf(got)) - - // Add a regular page (i.e. not a bundle) - c.Assert(m.AddFilesBundle(writeFile(c, fs, "blog/b.md", "page")), qt.IsNil) - - c.Assert(m.testDump(), hqt.IsSameString, ` - Tree 0: - /blog/__hb_a__hl_ - /blog/__hb_b/c__hl_ - /blog/__hb_b__hl_ - Tree 1: - /blog/ - Tree 2: - /blog/__hb_a__hl_b/data.json - /blog/__hb_a__hl_b/data2.json - /blog/__hb_a__hl_logo.png - /blog/__hb_b/c__hl_d/data3.json - /blog/__hl_sectiondata.json - /blog/__hl_sectiondata2.json - en/pages/blog/__hb_a__hl_|f:blog/a/index.md - - R: blog/a/b/data.json - - R: blog/a/b/data2.json - - R: blog/a/logo.png - en/pages/blog/__hb_b/c__hl_|f:blog/b/c/index.md - - R: blog/b/c/d/data3.json - en/pages/blog/__hb_b__hl_|f:blog/b.md - en/sections/blog/|f:blog/_index.md - - P: blog/a/index.md - - P: blog/b/c/index.md - - P: blog/b.md - - R: blog/sectiondata.json - - R: blog/sectiondata2.json - - - `, qt.Commentf(m.testDump())) - }) - - c.Run("CreateMissingNodes", func(c *qt.C) { - memfs := afero.NewMemMapFs() - - fsl := func(lang string) afero.Fs { - return createFs(memfs, lang) - } - - fs := fsl("en") - - m := newContentMap(contentMapConfig{lang: "en"}) - - c.Assert(m.AddFilesBundle(writeFile(c, fs, "blog/page.md", "page")), qt.IsNil) - c.Assert(m.AddFilesBundle(writeFile(c, fs, "blog/a/index.md", "page")), qt.IsNil) - c.Assert(m.AddFilesBundle(writeFile(c, fs, "bundle/index.md", "page")), qt.IsNil) - - c.Assert(m.CreateMissingNodes(), qt.IsNil) - - got := m.testDump() - - c.Assert(got, hqt.IsSameString, ` - - Tree 0: - /__hb_bundle__hl_ - /blog/__hb_a__hl_ - /blog/__hb_page__hl_ - Tree 1: - / - /blog/ - Tree 2: - en/pages/__hb_bundle__hl_|f:bundle/index.md - en/pages/blog/__hb_a__hl_|f:blog/a/index.md - en/pages/blog/__hb_page__hl_|f:blog/page.md - en/sections/ - - P: bundle/index.md - en/sections/blog/ - - P: blog/a/index.md - - P: blog/page.md - - `, qt.Commentf(got)) - }) - - c.Run("cleanKey", func(c *qt.C) { - for _, test := range []struct { - in string - expected string - }{ - {"/a/b/", "/a/b"}, - {filepath.FromSlash("/a/b/"), "/a/b"}, - {"/a//b/", "/a/b"}, - } { - c.Assert(cleanTreeKey(test.in), qt.Equals, test.expected) - } - }) -} - func TestContentMapSite(t *testing.T) { b := newTestSitesBuilder(t) @@ -313,13 +26,17 @@ func TestContentMapSite(t *testing.T) { title: "Page %d" date: "2019-06-0%d" lastMod: "2019-06-0%d" -categories: ["funny"] +categories: [%q] --- Page content. ` createPage := func(i int) string { - return fmt.Sprintf(pageTempl, i, i, i+1) + return fmt.Sprintf(pageTempl, i, i, i+1, "funny") + } + + createPageInCategory := func(i int, category string) string { + return fmt.Sprintf(pageTempl, i, i, i+1, category) } draftTemplate := `--- @@ -358,8 +75,8 @@ Home Content. b.WithContent("blog/draftsection/sub/_index.md", createPage(12)) b.WithContent("blog/draftsection/sub/page.md", createPage(13)) b.WithContent("docs/page6.md", createPage(11)) - b.WithContent("tags/_index.md", createPage(32)) - b.WithContent("overlap/_index.md", createPage(33)) + b.WithContent("tags/_index.md", createPageInCategory(32, "sad")) + b.WithContent("overlap/_index.md", createPageInCategory(33, "sad")) b.WithContent("overlap2/_index.md", createPage(34)) b.WithTemplatesAdded("layouts/index.html", ` @@ -394,13 +111,13 @@ InSection: true: {{ $page.InSection $blog }} false: {{ $page.InSection $blogSub Next: {{ $page2.Next.RelPermalink }} NextInSection: {{ $page2.NextInSection.RelPermalink }} Pages: {{ range $blog.Pages }}{{ .RelPermalink }}|{{ end }} -Sections: {{ range $home.Sections }}{{ .RelPermalink }}|{{ end }} -Categories: {{ range .Site.Taxonomies.categories }}{{ .Page.RelPermalink }}; {{ .Page.Title }}; {{ .Count }}|{{ end }} -Category Terms: {{ $categories.Kind}}: {{ range $categories.Data.Terms.Alphabetical }}{{ .Page.RelPermalink }}; {{ .Page.Title }}; {{ .Count }}|{{ end }} -Category Funny: {{ $funny.Kind}}; {{ $funny.Data.Term }}: {{ range $funny.Pages }}{{ .RelPermalink }};|{{ end }} +Sections: {{ range $home.Sections }}{{ .RelPermalink }}|{{ end }}:END +Categories: {{ range .Site.Taxonomies.categories }}{{ .Page.RelPermalink }}; {{ .Page.Title }}; {{ .Count }}|{{ end }}:END +Category Terms: {{ $categories.Kind}}: {{ range $categories.Data.Terms.Alphabetical }}{{ .Page.RelPermalink }}; {{ .Page.Title }}; {{ .Count }}|{{ end }}:END +Category Funny: {{ $funny.Kind}}; {{ $funny.Data.Term }}: {{ range $funny.Pages }}{{ .RelPermalink }};|{{ end }}:END Pag Num Pages: {{ len .Paginator.Pages }} Pag Blog Num Pages: {{ len $blog.Paginator.Pages }} -Blog Num RegularPages: {{ len $blog.RegularPages }} +Blog Num RegularPages: {{ len $blog.RegularPages }}|{{ range $blog.RegularPages }}P: {{ .RelPermalink }}|{{ end }} Blog Num Pages: {{ len $blog.Pages }} Draft1: {{ if (.Site.GetPage "blog/subsection/draft") }}FOUND{{ end }}| @@ -421,11 +138,11 @@ Draft5: {{ if (.Site.GetPage "blog/draftsection/sub/page") }}FOUND{{ end }}| Main Sections: [blog] Pag Num Pages: 7 - Home: Hugo Home|/|2019-06-08|Current Section: |Resources: - Blog Section: Blogs|/blog/|2019-06-08|Current Section: blog|Resources: - Blog Sub Section: Page 3|/blog/subsection/|2019-06-03|Current Section: blog/subsection|Resources: application: /blog/subsection/subdata.json| - Page: Page 1|/blog/page1/|2019-06-01|Current Section: blog|Resources: - Bundle: Page 12|/blog/bundle/|0001-01-01|Current Section: blog|Resources: application: /blog/bundle/data.json|page: | + Home: Hugo Home|/|2019-06-08|Current Section: /|Resources: + Blog Section: Blogs|/blog/|2019-06-08|Current Section: /blog|Resources: + Blog Sub Section: Page 3|/blog/subsection/|2019-06-03|Current Section: /blog/subsection|Resources: application: /blog/subsection/subdata.json| + Page: Page 1|/blog/page1/|2019-06-01|Current Section: /blog|Resources: + Bundle: Page 12|/blog/bundle/|0001-01-01|Current Section: /blog|Resources: application: /blog/bundle/data.json|page: | IsDescendant: true: true true: true true: true true: true true: true true: true false: false IsAncestor: true: true true: true true: true true: true true: true true: true true: true false: false false: false false: false IsDescendant overlap1: false: false @@ -437,10 +154,10 @@ Draft5: {{ if (.Site.GetPage "blog/draftsection/sub/page") }}FOUND{{ end }}| Next: /blog/page3/ NextInSection: /blog/page3/ Pages: /blog/page3/|/blog/subsection/|/blog/page2/|/blog/page1/|/blog/bundle/| - Sections: /blog/|/docs/| - Categories: /categories/funny/; funny; 11| - Category Terms: taxonomy: /categories/funny/; funny; 11| - Category Funny: term; funny: /blog/subsection/page4/;|/blog/page3/;|/blog/subsection/;|/blog/page2/;|/blog/page1/;|/blog/subsection/page5/;|/docs/page6/;|/blog/bundle/;|;| + Sections: /blog/|/docs/|/overlap/|/overlap2/|:END + Categories: /categories/funny/; funny; 9|/categories/sad/; sad; 2|:END + Category Terms: taxonomy: /categories/funny/; funny; 9|/categories/sad/; sad; 2|:END + Category Funny: term; funny: /blog/subsection/page4/;|/blog/page3/;|/blog/subsection/;|/blog/page2/;|/blog/page1/;|/blog/subsection/page5/;|/docs/page6/;|/blog/bundle/;|/overlap2/;|:END Pag Num Pages: 7 Pag Blog Num Pages: 4 Blog Num RegularPages: 4 diff --git a/hugolib/content_render_hooks_test.go b/hugolib/content_render_hooks_test.go index f1c27d51191..4dc5d4830fd 100644 --- a/hugolib/content_render_hooks_test.go +++ b/hugolib/content_render_hooks_test.go @@ -14,7 +14,6 @@ package hugolib import ( - "fmt" "testing" qt "github.com/frankban/quicktest" @@ -57,10 +56,13 @@ title: P1 } func TestRenderHooks(t *testing.T) { - config := ` + files := ` +-- config.toml -- baseURL="https://example.org" workingDir="/mywork" - +disableKinds=["home", "section", "taxonomy", "term", "sitemap", "robotsTXT"] +[outputs] + page = ['HTML'] [markup] [markup.goldmark] [markup.goldmark.parser] @@ -69,42 +71,26 @@ autoHeadingIDType = "github" [markup.goldmark.parser.attribute] block = true title = true +-- content/blog/notempl1.md -- +--- +title: No Template +--- -` - b := newTestSitesBuilder(t).WithWorkingDir("/mywork").WithConfigFile("toml", config).Running() - b.WithTemplatesAdded("_default/single.html", `{{ .Content }}`) - b.WithTemplatesAdded("shortcodes/myshortcode1.html", `{{ partial "mypartial1" }}`) - b.WithTemplatesAdded("shortcodes/myshortcode2.html", `{{ partial "mypartial2" }}`) - b.WithTemplatesAdded("shortcodes/myshortcode3.html", `SHORT3|`) - b.WithTemplatesAdded("shortcodes/myshortcode4.html", ` -
-{{ .Inner | markdownify }} -
-`) - b.WithTemplatesAdded("shortcodes/myshortcode5.html", ` -Inner Inline: {{ .Inner | .Page.RenderString }} -Inner Block: {{ .Inner | .Page.RenderString (dict "display" "block" ) }} -`) - - b.WithTemplatesAdded("shortcodes/myshortcode6.html", `.Render: {{ .Page.Render "myrender" }}`) - b.WithTemplatesAdded("partials/mypartial1.html", `PARTIAL1`) - b.WithTemplatesAdded("partials/mypartial2.html", `PARTIAL2 {{ partial "mypartial3.html" }}`) - b.WithTemplatesAdded("partials/mypartial3.html", `PARTIAL3`) - b.WithTemplatesAdded("partials/mypartial4.html", `PARTIAL4`) - b.WithTemplatesAdded("customview/myrender.html", `myrender: {{ .Title }}|P4: {{ partial "mypartial4" }}`) - b.WithTemplatesAdded("_default/_markup/render-link.html", `{{ with .Page }}{{ .Title }}{{ end }}|{{ .Destination | safeURL }}|Title: {{ .Title | safeHTML }}|Text: {{ .Text | safeHTML }}|END`) - b.WithTemplatesAdded("docs/_markup/render-link.html", `Link docs section: {{ .Text | safeHTML }}|END`) - b.WithTemplatesAdded("_default/_markup/render-image.html", `IMAGE: {{ .Page.Title }}||{{ .Destination | safeURL }}|Title: {{ .Title | safeHTML }}|Text: {{ .Text | safeHTML }}|END`) - b.WithTemplatesAdded("_default/_markup/render-heading.html", `HEADING: {{ .Page.Title }}||Level: {{ .Level }}|Anchor: {{ .Anchor | safeURL }}|Text: {{ .Text | safeHTML }}|Attributes: {{ .Attributes }}|END`) - b.WithTemplatesAdded("docs/_markup/render-heading.html", `Docs Level: {{ .Level }}|END`) - - b.WithContent("customview/p1.md", `--- -title: Custom View +## Content +-- content/blog/notempl2.md -- +--- +title: No Template --- -{{< myshortcode6 >}} +## Content +-- content/blog/notempl3.md -- +--- +title: No Template +--- - `, "blog/p1.md", `--- +## Content +-- content/blog/p1.md -- +--- title: Cool Page --- @@ -124,10 +110,9 @@ Image: Attributes: -## Some Heading {.text-serif #a-heading title="Hovered"} - - -`, "blog/p2.md", `--- +## Some Heading {.text-serif #a-heading title="Hovered"} +-- content/blog/p2.md -- +--- title: Cool Page2 layout: mylayout --- @@ -137,48 +122,36 @@ layout: mylayout [Some Text](https://www.google.com "Google's Homepage") ,[No Whitespace Please](https://gohugo.io), - - - -`, "blog/p3.md", `--- +-- content/blog/p3.md -- +--- title: Cool Page3 --- {{< myshortcode2 >}} - - -`, "docs/docs1.md", `--- -title: Docs 1 +-- content/blog/p4.md -- --- - - -[Docs 1](https://www.google.com "Google's Homepage") - - -`, "blog/p4.md", `--- title: Cool Page With Image --- Image: ![Drag Racing](/images/Dragster.jpg "image title") - - -`, "blog/p5.md", `--- +-- content/blog/p5.md -- +--- title: Cool Page With Markdownify --- {{< myshortcode4 >}} Inner Link: [Inner Link](https://www.google.com "Google's Homepage") {{< /myshortcode4 >}} - -`, "blog/p6.md", `--- +-- content/blog/p6.md -- +--- title: With RenderString --- {{< myshortcode5 >}}Inner Link: [Inner Link](https://www.gohugo.io "Hugo's Homepage"){{< /myshortcode5 >}} - -`, "blog/p7.md", `--- +-- content/blog/p7.md -- +--- title: With Headings --- @@ -188,28 +161,82 @@ some text ## Heading Level 2 ### Heading Level 3 -`, - "docs/p8.md", `--- -title: Doc With Heading +-- content/customview/p1.md -- +--- +title: Custom View --- +{{< myshortcode6 >}} +-- content/docs/docs1.md -- +--- +title: Docs 1 +--- +[Docs 1](https://www.google.com "Google's Homepage") +-- content/docs/p8.md -- +--- +title: Doc With Heading +--- # Docs lvl 1 +-- data/hugo.toml -- +slogan = "Hugo Rocks!" +-- layouts/_default/_markup/render-heading.html -- +HEADING: {{ .Page.Title }}||Level: {{ .Level }}|Anchor: {{ .Anchor | safeURL }}|Text: {{ .Text | safeHTML }}|Attributes: {{ .Attributes }}|END +-- layouts/_default/_markup/render-image.html -- +IMAGE: {{ .Page.Title }}||{{ .Destination | safeURL }}|Title: {{ .Title | safeHTML }}|Text: {{ .Text | safeHTML }}|END +-- layouts/_default/_markup/render-link.html -- +{{ with .Page }}{{ .Title }}{{ end }}|{{ .Destination | safeURL }}|Title: {{ .Title | safeHTML }}|Text: {{ .Text | safeHTML }}|END +-- layouts/_default/single.html -- +{{ .Content }} +-- layouts/customview/myrender.html -- +myrender: {{ .Title }}|P4: {{ partial "mypartial4" }} +-- layouts/docs/_markup/render-heading.html -- +Docs Level: {{ .Level }}|END +-- layouts/docs/_markup/render-link.html -- +Link docs section: {{ .Text | safeHTML }}|END +-- layouts/partials/mypartial1.html -- +PARTIAL1 +-- layouts/partials/mypartial2.html -- +PARTIAL2 {{ partial "mypartial3.html" }} +-- layouts/partials/mypartial3.html -- +PARTIAL3 +-- layouts/partials/mypartial4.html -- +PARTIAL4 +-- layouts/robots.txt -- +robots|{{ .Lang }}|{{ .Title }} +-- layouts/shortcodes/lingo.fr.html -- +LingoFrench +-- layouts/shortcodes/lingo.html -- +LingoDefault +-- layouts/shortcodes/myshortcode1.html -- +{{ partial "mypartial1" }} +-- layouts/shortcodes/myshortcode2.html -- +{{ partial "mypartial2" }} +-- layouts/shortcodes/myshortcode3.html -- +SHORT3| +-- layouts/shortcodes/myshortcode4.html -- +
+{{ .Inner | markdownify }} +
+-- layouts/shortcodes/myshortcode5.html -- +Inner Inline: {{ .Inner | .Page.RenderString }} +Inner Block: {{ .Inner | .Page.RenderString (dict "display" "block" ) }} +-- layouts/shortcodes/myshortcode6.html -- +.Render: {{ .Page.Render "myrender" }} -`, - ) + ` - for i := 1; i <= 30; i++ { - // Add some content with no shortcodes or links, i.e no templates needed. - b.WithContent(fmt.Sprintf("blog/notempl%d.md", i), `--- -title: No Template ---- + c := qt.New(t) -## Content -`) - } - counters := &testCounters{} - b.Build(BuildCfg{testCounters: counters}) - b.Assert(int(counters.contentRenderCounter), qt.Equals, 45) + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: files, + WorkingDir: "/mywork", + Running: true, + }, + ).Build() + + b.AssertRenderCountContent(13) b.AssertFileContent("public/blog/p1/index.html", ` Cool Page|https://www.google.com|Title: Google's Homepage|Text: First Link|END @@ -246,12 +273,10 @@ SHORT3| "layouts/partials/mypartial3.html", `PARTIAL3_EDITED`, "layouts/partials/mypartial4.html", `PARTIAL4_EDITED`, "layouts/shortcodes/myshortcode3.html", `SHORT3_EDITED|`, - ) + ).Build() - counters = &testCounters{} - b.Build(BuildCfg{testCounters: counters}) // Make sure that only content using the changed templates are re-rendered. - b.Assert(int(counters.contentRenderCounter), qt.Equals, 7) + // TODO1 b.AssertRenderCountContent(7) b.AssertFileContent("public/customview/p1/index.html", `.Render: myrender: Custom View|P4: PARTIAL4_EDITED`) b.AssertFileContent("public/blog/p1/index.html", `

EDITED: https://www.google.com|

`, "SHORT3_EDITED|") @@ -294,28 +319,36 @@ title: P1 } func TestRenderHookAddTemplate(t *testing.T) { - config := ` + c := qt.New(t) + + files := ` +-- config.toml -- baseURL="https://example.org" workingDir="/mywork" -` - b := newTestSitesBuilder(t).WithWorkingDir("/mywork").WithConfigFile("toml", config).Running() - b.WithTemplatesAdded("_default/single.html", `{{ .Content }}`) - - b.WithContent("p1.md", `--- -title: P1 ---- +-- content/p1.md -- [First Link](https://www.google.com "Google's Homepage") +-- content/p2.md -- +No link. +-- layouts/_default/single.html -- +{{ .Content }} -`) - b.Build(BuildCfg{}) + ` - b.AssertFileContent("public/p1/index.html", `

First Link

`) + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + WorkingDir: "/mywork", + TxtarString: files, + Running: true, + }).Build() - b.EditFiles("layouts/_default/_markup/render-link.html", `html-render-link`) + b.AssertFileContent("public/p1/index.html", `

First Link

`) + b.AssertRenderCountContent(2) - b.Build(BuildCfg{}) + b.EditFiles("layouts/_default/_markup/render-link.html", `html-render-link`).Build() b.AssertFileContent("public/p1/index.html", `

html-render-link

`) + b.AssertRenderCountContent(1) } func TestRenderHooksRSS(t *testing.T) { diff --git a/hugolib/disableKinds_test.go b/hugolib/disableKinds_test.go index 87a60d636ec..096c25f184e 100644 --- a/hugolib/disableKinds_test.go +++ b/hugolib/disableKinds_test.go @@ -16,6 +16,8 @@ import ( "fmt" "testing" + "github.com/gohugoio/hugo/resources/page/pagekinds" + qt "github.com/frankban/quicktest" "github.com/gohugoio/hugo/resources/page" ) @@ -109,10 +111,10 @@ title: Headless Local Lists Sub } getPageInSitePages := func(b *sitesBuilder, ref string) page.Page { - b.Helper() for _, pages := range []page.Pages{b.H.Sites[0].Pages(), b.H.Sites[0].RegularPages()} { for _, p := range pages { - if ref == p.(*pageState).sourceRef() { + pth := p.(*pageState).m.Path() + if ref == pth { return p } } @@ -126,7 +128,8 @@ title: Headless Local Lists Sub } for _, pages := range pageCollections { for _, p := range pages { - if ref == p.(*pageState).sourceRef() { + pth := p.(*pageState).m.Path() + if ref == pth { return p } } @@ -134,22 +137,22 @@ title: Headless Local Lists Sub return nil } - disableKind := page.KindPage + disableKind := pagekinds.Page c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) s := b.H.Sites[0] b.Assert(getPage(b, "/sect/page.md"), qt.IsNil) b.Assert(b.CheckExists("public/sect/page/index.html"), qt.Equals, false) - b.Assert(getPageInSitePages(b, "/sect/page.md"), qt.IsNil) - b.Assert(getPageInPagePages(getPage(b, "/"), "/sect/page.md"), qt.IsNil) + b.Assert(getPageInSitePages(b, "/sect"), qt.IsNil) + b.Assert(getPageInPagePages(getPage(b, "/"), "/sect/page"), qt.IsNil) // Also check the side effects b.Assert(b.CheckExists("public/categories/mycat/index.html"), qt.Equals, false) b.Assert(len(s.Taxonomies()["categories"]), qt.Equals, 0) }) - disableKind = page.KindTerm + disableKind = pagekinds.Term c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) @@ -161,23 +164,22 @@ title: Headless Local Lists Sub b.Assert(getPage(b, "/categories/mycat"), qt.IsNil) }) - disableKind = page.KindTaxonomy + disableKind = pagekinds.Taxonomy c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) s := b.H.Sites[0] - b.Assert(b.CheckExists("public/categories/mycat/index.html"), qt.Equals, true) - b.Assert(b.CheckExists("public/categories/index.html"), qt.Equals, false) - b.Assert(len(s.Taxonomies()["categories"]), qt.Equals, 1) - b.Assert(getPage(b, "/categories/mycat"), qt.Not(qt.IsNil)) + b.Assert(b.CheckExists("public/categories/mycat/index.html"), qt.IsFalse) + b.Assert(b.CheckExists("public/categories/index.html"), qt.IsFalse) + b.Assert(len(s.Taxonomies()["categories"]), qt.Equals, 0) + b.Assert(getPage(b, "/categories/mycat"), qt.IsNil) categories := getPage(b, "/categories") - b.Assert(categories, qt.Not(qt.IsNil)) - b.Assert(categories.RelPermalink(), qt.Equals, "") + b.Assert(categories, qt.IsNil) b.Assert(getPageInSitePages(b, "/categories"), qt.IsNil) b.Assert(getPageInPagePages(getPage(b, "/"), "/categories"), qt.IsNil) }) - disableKind = page.KindHome + disableKind = pagekinds.Home c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) @@ -185,12 +187,12 @@ title: Headless Local Lists Sub home := getPage(b, "/") b.Assert(home, qt.Not(qt.IsNil)) b.Assert(home.RelPermalink(), qt.Equals, "") - b.Assert(getPageInSitePages(b, "/"), qt.IsNil) - b.Assert(getPageInPagePages(home, "/"), qt.IsNil) + b.Assert(getPageInSitePages(b, ""), qt.IsNil) + b.Assert(getPageInPagePages(home, ""), qt.IsNil) b.Assert(getPage(b, "/sect/page.md"), qt.Not(qt.IsNil)) }) - disableKind = page.KindSection + disableKind = pagekinds.Section c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) @@ -205,12 +207,12 @@ title: Headless Local Lists Sub page := getPage(b, "/sect/page.md") b.Assert(page, qt.Not(qt.IsNil)) b.Assert(page.CurrentSection(), qt.Equals, sect) - b.Assert(getPageInPagePages(sect, "/sect/page.md"), qt.Not(qt.IsNil)) + b.Assert(getPageInPagePages(sect, "/sect/page"), qt.Not(qt.IsNil)) b.AssertFileContent("public/sitemap.xml", "sitemap") b.AssertFileContent("public/index.xml", "rss") }) - disableKind = kindRSS + disableKind = "RSS" c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) @@ -219,21 +221,21 @@ title: Headless Local Lists Sub b.Assert(home.OutputFormats(), qt.HasLen, 1) }) - disableKind = kindSitemap + disableKind = pagekinds.Sitemap c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) b.Assert(b.CheckExists("public/sitemap.xml"), qt.Equals, false) }) - disableKind = kind404 + disableKind = pagekinds.Status404 c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) b.Assert(b.CheckExists("public/404.html"), qt.Equals, false) }) - disableKind = kindRobotsTXT + disableKind = pagekinds.RobotsTXT c.Run("Disable "+disableKind, func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.WithTemplatesAdded("robots.txt", "myrobots") @@ -276,10 +278,10 @@ title: Headless Local Lists Sub b.Assert(sect, qt.Not(qt.IsNil)) b.Assert(getPageInSitePages(b, ref), qt.IsNil) - b.Assert(getPageInSitePages(b, "/headless-local/_index.md"), qt.IsNil) - b.Assert(getPageInSitePages(b, "/headless-local/headless-local-page.md"), qt.IsNil) + b.Assert(getPageInSitePages(b, "/headless-local"), qt.IsNil) + b.Assert(getPageInSitePages(b, "/headless-local/headless-local-page"), qt.IsNil) - localPageRef := ref + "/headless-local-page.md" + localPageRef := ref + "/headless-local-page" b.Assert(getPageInPagePages(sect, localPageRef, sect.RegularPages()), qt.Not(qt.IsNil)) b.Assert(getPageInPagePages(sect, localPageRef, sect.RegularPagesRecursive()), qt.Not(qt.IsNil)) @@ -290,14 +292,14 @@ title: Headless Local Lists Sub sect = getPage(b, ref) b.Assert(sect, qt.Not(qt.IsNil)) - localPageRef = ref + "/headless-local-sub-page.md" + localPageRef = ref + "/headless-local-sub-page" b.Assert(getPageInPagePages(sect, localPageRef), qt.Not(qt.IsNil)) }) c.Run("Build config, no render", func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) - ref := "/sect/no-render.md" + ref := "/sect/no-render" b.Assert(b.CheckExists("public/sect/no-render/index.html"), qt.Equals, false) p := getPage(b, ref) b.Assert(p, qt.Not(qt.IsNil)) @@ -311,7 +313,7 @@ title: Headless Local Lists Sub c.Run("Build config, no render link", func(c *qt.C) { b := newSitesBuilder(c, disableKind) b.Build(BuildCfg{}) - ref := "/sect/no-render-link.md" + ref := "/sect/no-render-link" b.Assert(b.CheckExists("public/sect/no-render/index.html"), qt.Equals, false) p := getPage(b, ref) b.Assert(p, qt.Not(qt.IsNil)) diff --git a/hugolib/fileInfo.go b/hugolib/fileInfo.go index fdfd34b168a..75b5ecf56c3 100644 --- a/hugolib/fileInfo.go +++ b/hugolib/fileInfo.go @@ -13,68 +13,7 @@ package hugolib -import ( - "strings" - - "github.com/gohugoio/hugo/hugofs/files" - - "github.com/pkg/errors" - - "github.com/gohugoio/hugo/hugofs" - - "github.com/spf13/afero" - - "github.com/gohugoio/hugo/source" -) - -// fileInfo implements the File and ReadableFile interface. -var ( - _ source.File = (*fileInfo)(nil) -) - -type fileInfo struct { - source.File - - overriddenLang string -} - -func (fi *fileInfo) Open() (afero.File, error) { - f, err := fi.FileInfo().Meta().Open() - if err != nil { - err = errors.Wrap(err, "fileInfo") - } - - return f, err -} - -func (fi *fileInfo) Lang() string { - if fi.overriddenLang != "" { - return fi.overriddenLang - } - return fi.File.Lang() -} - -func (fi *fileInfo) String() string { - if fi == nil || fi.File == nil { - return "" - } - return fi.Path() -} - -// TODO(bep) rename -func newFileInfo(sp *source.SourceSpec, fi hugofs.FileMetaInfo) (*fileInfo, error) { - baseFi, err := sp.NewFileInfo(fi) - if err != nil { - return nil, err - } - - f := &fileInfo{ - File: baseFi, - } - - return f, nil -} - +// TODO1 remove type bundleDirType int const ( @@ -85,23 +24,6 @@ const ( bundleBranch ) -// Returns the given file's name's bundle type and whether it is a content -// file or not. -func classifyBundledFile(name string) (bundleDirType, bool) { - if !files.IsContentFile(name) { - return bundleNot, false - } - if strings.HasPrefix(name, "_index.") { - return bundleBranch, true - } - - if strings.HasPrefix(name, "index.") { - return bundleLeaf, true - } - - return bundleNot, true -} - func (b bundleDirType) String() string { switch b { case bundleNot: diff --git a/hugolib/filesystems/basefs.go b/hugolib/filesystems/basefs.go index aae3613f247..292b732ef7c 100644 --- a/hugolib/filesystems/basefs.go +++ b/hugolib/filesystems/basefs.go @@ -24,6 +24,8 @@ import ( "strings" "sync" + hpaths "github.com/gohugoio/hugo/hugolib/paths" + "github.com/gohugoio/hugo/htesting" "github.com/gohugoio/hugo/hugofs/glob" @@ -40,7 +42,7 @@ import ( "github.com/gohugoio/hugo/hugofs" - "github.com/gohugoio/hugo/hugolib/paths" + "github.com/gohugoio/hugo/common/paths" "github.com/spf13/afero" ) @@ -323,6 +325,25 @@ func (s SourceFilesystems) IsAsset(filename string) bool { return s.Assets.Contains(filename) } +// CollectPathIdentities collects paths relative to their component root. +func (s SourceFilesystems) CollectPathIdentities(filename string) []*paths.PathInfo { + var identities []*paths.PathInfo + + for _, fs := range []*SourceFilesystem{s.Assets, s.Content, s.Data, s.I18n, s.Layouts} { + fs.withEachRelativePath(filename, func(rel string, fim hugofs.FileMetaInfo) { + meta := fim.Meta() + pth := paths.Parse(filepath.ToSlash(rel), paths.ForComponent(fs.Name)) + filename = meta.Filename + if fim.IsDir() { + filename = filepath.Join(filename, rel) + } + identities = append(identities, paths.WithInfo(pth, filename)) + }) + } + + return identities +} + // IsI18n returns true if the given filename is a member of the i18n filesystem. func (s SourceFilesystems) IsI18n(filename string) bool { return s.I18n.Contains(filename) @@ -342,19 +363,68 @@ func (s SourceFilesystems) MakeStaticPathRelative(filename string) string { // MakePathRelative creates a relative path from the given filename. func (d *SourceFilesystem) MakePathRelative(filename string) (string, bool) { + paths := d.collectRelativePaths(filename) + if paths == nil { + return "", false + } + return paths[0], true +} + +func (d *SourceFilesystem) collectRelativePaths(filename string) []string { + var paths []string + d.withEachRelativePath(filename, func(rel string, meta hugofs.FileMetaInfo) { + paths = append(paths, rel) + }) + + return paths +} + +func (d *SourceFilesystem) withEachRelativePath(filename string, cb func(rel string, meta hugofs.FileMetaInfo)) { + relFromFim := func(fim hugofs.FileMetaInfo) string { + meta := fim.Meta() + if !fim.IsDir() { + if filename == meta.Filename { + return filepath.Base(filename) + } + } else if rel := relFilename(meta, filename); rel != "" { + return rel + } + return "" + } + for _, dir := range d.Dirs { - meta := dir.(hugofs.FileMetaInfo).Meta() - currentPath := meta.Filename + fim := dir.(hugofs.FileMetaInfo) + if rel := relFromFim(fim); rel != "" { + cb(rel, fim) + } + } - if strings.HasPrefix(filename, currentPath) { - rel := strings.TrimPrefix(filename, currentPath) - if mp := meta.Path; mp != "" { - rel = filepath.Join(mp, rel) + if rev, ok := d.Fs.(hugofs.ReverseLookupProvider); ok { + for _, dir := range d.Dirs { + fim := dir.(hugofs.FileMetaInfo) + if rel := relFromFim(fim); rel != "" { + relReverse, _ := rev.ReverseLookup(rel) + if relReverse != "" { + cb(relReverse, fim) + } } - return strings.TrimPrefix(rel, filePathSeparator), true } } - return "", false +} + +func relFilename(meta *hugofs.FileMeta, filename string) string { + dirname := meta.Filename + if !strings.HasSuffix(dirname, filePathSeparator) { + dirname += filePathSeparator + } + if !strings.HasPrefix(filename, dirname) { + return "" + } + rel := strings.TrimPrefix(filename, dirname) + if mp := meta.Path; mp != "" { + rel = filepath.Join(mp, rel) + } + return strings.TrimPrefix(rel, filePathSeparator) } func (d *SourceFilesystem) RealFilename(rel string) string { @@ -422,7 +492,7 @@ func WithBaseFs(b *BaseFs) func(*BaseFs) error { } // NewBase builds the filesystems used by Hugo given the paths and options provided.NewBase -func NewBase(p *paths.Paths, logger loggers.Logger, options ...func(*BaseFs) error) (*BaseFs, error) { +func NewBase(p *hpaths.Paths, logger loggers.Logger, options ...func(*BaseFs) error) (*BaseFs, error) { fs := p.Fs if logger == nil { logger = loggers.NewWarningLogger() @@ -466,13 +536,13 @@ func NewBase(p *paths.Paths, logger loggers.Logger, options ...func(*BaseFs) err type sourceFilesystemsBuilder struct { logger loggers.Logger - p *paths.Paths + p *hpaths.Paths sourceFs afero.Fs result *SourceFilesystems theBigFs *filesystemsCollector } -func newSourceFilesystemsBuilder(p *paths.Paths, logger loggers.Logger, b *BaseFs) *sourceFilesystemsBuilder { +func newSourceFilesystemsBuilder(p *hpaths.Paths, logger loggers.Logger, b *BaseFs) *sourceFilesystemsBuilder { sourceFs := hugofs.NewBaseFileDecorator(p.Fs.Source) return &sourceFilesystemsBuilder{p: p, logger: logger, sourceFs: sourceFs, theBigFs: b.theBigFs, result: &SourceFilesystems{}} } @@ -530,7 +600,10 @@ func (b *sourceFilesystemsBuilder) Build() (*SourceFilesystems, error) { b.result.I18n = b.newSourceFilesystem(files.ComponentFolderI18n, i18nFs, i18nDirs) contentDirs := b.theBigFs.overlayDirs[files.ComponentFolderContent] - contentBfs := afero.NewBasePathFs(b.theBigFs.overlayMountsContent, files.ComponentFolderContent) + contentBfs := hugofs.NewExtendedFs( + afero.NewBasePathFs(b.theBigFs.overlayMountsContent, files.ComponentFolderContent), + b.theBigFs.overlayMountsContent, + ) contentFs, err := hugofs.NewLanguageFs(b.p.LanguagesDefaultFirst.AsOrdinalSet(), contentBfs) if err != nil { @@ -561,7 +634,7 @@ func (b *sourceFilesystemsBuilder) Build() (*SourceFilesystems, error) { return b.result, nil } -func (b *sourceFilesystemsBuilder) createMainOverlayFs(p *paths.Paths) (*filesystemsCollector, error) { +func (b *sourceFilesystemsBuilder) createMainOverlayFs(p *hpaths.Paths) (*filesystemsCollector, error) { var staticFsMap map[string]afero.Fs if b.p.Cfg.GetBool("multihost") { staticFsMap = make(map[string]afero.Fs) @@ -625,7 +698,7 @@ func (b *sourceFilesystemsBuilder) createModFs( if filepath.IsAbs(path) { return "", path } - return md.dir, paths.AbsPathify(md.dir, path) + return md.dir, hpaths.AbsPathify(md.dir, path) } for _, mount := range md.Mounts() { @@ -773,8 +846,8 @@ type filesystemsCollector struct { sourceModules afero.Fs // Source for modules/themes overlayMounts afero.Fs - overlayMountsContent afero.Fs - overlayMountsStatic afero.Fs + overlayMountsContent hugofs.ExtendedFs + overlayMountsStatic hugofs.ExtendedFs overlayFull afero.Fs overlayResources afero.Fs diff --git a/hugolib/filesystems/basefs_test.go b/hugolib/filesystems/basefs_test.go index a119d4c1790..de60aad0912 100644 --- a/hugolib/filesystems/basefs_test.go +++ b/hugolib/filesystems/basefs_test.go @@ -33,7 +33,6 @@ import ( "github.com/gohugoio/hugo/hugofs" "github.com/gohugoio/hugo/hugolib/paths" "github.com/gohugoio/hugo/modules" - ) func initConfig(fs afero.Fs, cfg config.Provider) error { diff --git a/hugolib/hugo_modules_test.go b/hugolib/hugo_modules_test.go index 46423043750..b62dcbe1196 100644 --- a/hugolib/hugo_modules_test.go +++ b/hugolib/hugo_modules_test.go @@ -820,50 +820,26 @@ title: "My Page" } // https://github.com/gohugoio/hugo/issues/6684 -func TestMountsContentFile(t *testing.T) { - t.Parallel() +func TestMountsContentFileNew(t *testing.T) { c := qt.New(t) - workingDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-modules-content-file") - c.Assert(err, qt.IsNil) - defer clean() - configTemplate := ` + files := ` +-- README.md -- +--- +title: "Readme Title" +--- +Readme Content. +-- config.toml -- baseURL = "https://example.com" title = "My Modular Site" -workingDir = %q - [module] - [[module.mounts]] - source = "README.md" - target = "content/_index.md" - [[module.mounts]] - source = "mycontent" - target = "content/blog" - -` - - tomlConfig := fmt.Sprintf(configTemplate, workingDir) - - b := newTestSitesBuilder(t).Running() - - b.Fs = hugofs.NewDefault(config.New()) - - b.WithWorkingDir(workingDir).WithConfigFile("toml", tomlConfig) - b.WithTemplatesAdded("index.html", ` -{{ .Title }} -{{ .Content }} - -{{ $readme := .Site.GetPage "/README.md" }} -{{ with $readme }}README: {{ .Title }}|Filename: {{ path.Join .File.Filename }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }} - - -{{ $mypage := .Site.GetPage "/blog/mypage.md" }} -{{ with $mypage }}MYPAGE: {{ .Title }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }} -{{ $mybundle := .Site.GetPage "/blog/mybundle" }} -{{ with $mybundle }}MYBUNDLE: {{ .Title }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }} - - -`, "_default/_markup/render-link.html", ` +[[module.mounts]] +source = "README.md" +target = "content/_index.md" +[[module.mounts]] +source = "mycontent" +target = "content/blog" +-- layouts/_default/_markup/render-link.html -- {{ $link := .Destination }} {{ $isRemote := strings.HasPrefix $link "http" }} {{- if not $isRemote -}} @@ -872,18 +848,31 @@ workingDir = %q {{- with $url.Fragment }}{{ $fragment = printf "#%s" . }}{{ end -}} {{- with .Page.GetPage $url.Path }}{{ $link = printf "%s%s" .Permalink $fragment }}{{ end }}{{ end -}} {{ .Text | safeHTML }} -`) +-- layouts/_default/single.html -- +Single: {{ .Title }}|{{ .Content }}| +-- layouts/index.html -- +{{ .Title }} +{{ .Content }} +{{ $readme := .Site.GetPage "/README.md" }} +{{ if not $readme }}{{ errorf "README.md not found in GetPage" }}{{ end}} +{{ with $readme }}README: {{ .Title }}|Filename: {{ path.Join .File.Filename }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }} - os.Mkdir(filepath.Join(workingDir, "mycontent"), 0777) - os.Mkdir(filepath.Join(workingDir, "mycontent", "mybundle"), 0777) - b.WithSourceFile("README.md", `--- -title: "Readme Title" +{{ $mypage := .Site.GetPage "/blog/mypage.md" }} +{{ with $mypage }}MYPAGE: {{ .Title }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }} +{{ $mybundle := .Site.GetPage "/blog/mybundle" }} +{{ with $mybundle }}MYBUNDLE: {{ .Title }}|Path: {{ path.Join .File.Path }}|FilePath: {{ path.Join .File.FileInfo.Meta.PathFile }}|{{ end }} +-- mycontent/mybundle/index.md -- +--- +title: "My Bundle" --- -Readme Content. -`, - filepath.Join("mycontent", "mypage.md"), ` +* [Dot Relative Link From Bundle](../mypage.md) +* [Link using original path](/mycontent/mypage.md) +* [Link to Home](/) +* [Link to Home, README.md](/README.md) +* [Link to Home, _index.md](/_index.md) +-- mycontent/mypage.md -- --- title: "My Page" --- @@ -893,25 +882,20 @@ title: "My Page" * [Relative Link From Page, filename](mybundle/index.md) * [Link using original path](/mycontent/mybundle/index.md) +` -`, filepath.Join("mycontent", "mybundle", "index.md"), ` ---- -title: "My Bundle" ---- - -* [Dot Relative Link From Bundle](../mypage.md) -* [Link using original path](/mycontent/mypage.md) -* [Link to Home](/) -* [Link to Home, README.md](/README.md) -* [Link to Home, _index.md](/_index.md) - -`) - - b.Build(BuildCfg{}) + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + NeedsOsFS: true, + TxtarString: files, + Running: true, + }, + ).Build() b.AssertFileContent("public/index.html", ` README: Readme Title -/README.md|Path: _index.md|FilePath: README.md +README.md|Path: _index.md|FilePath: README.md Readme Content. MYPAGE: My Page|Path: blog/mypage.md|FilePath: mycontent/mypage.md| MYBUNDLE: My Bundle|Path: blog/mybundle/index.md|FilePath: mycontent/mybundle/index.md| @@ -935,7 +919,7 @@ title: "Readme Edit" --- `) - b.Build(BuildCfg{}) + b.Build() b.AssertFileContent("public/index.html", ` Readme Edit @@ -995,6 +979,7 @@ title: P1 b.Build(BuildCfg{}) p := b.GetPage("blog/p1.md") + b.Assert(p, qt.IsNotNil) f := p.File().FileInfo().Meta() b.Assert(filepath.ToSlash(f.Path), qt.Equals, "blog/p1.md") b.Assert(filepath.ToSlash(f.PathFile()), qt.Equals, "content/blog/p1.md") diff --git a/hugolib/hugo_sites.go b/hugolib/hugo_sites.go index 91703091bb5..9481a382b54 100644 --- a/hugolib/hugo_sites.go +++ b/hugolib/hugo_sites.go @@ -16,13 +16,13 @@ package hugolib import ( "context" "io" - "path/filepath" "sort" "strings" "sync" "sync/atomic" "github.com/gohugoio/hugo/hugofs/glob" + "github.com/gohugoio/hugo/resources/page/pagekinds" "github.com/fsnotify/fsnotify" @@ -53,7 +53,6 @@ import ( "github.com/gohugoio/hugo/langs/i18n" "github.com/gohugoio/hugo/resources/page" - "github.com/gohugoio/hugo/resources/page/pagemeta" "github.com/gohugoio/hugo/tpl" "github.com/gohugoio/hugo/tpl/tplimpl" ) @@ -117,6 +116,7 @@ func (h *HugoSites) getContentMaps() *pageMaps { // Only used in tests. type testCounters struct { contentRenderCounter uint64 + pageRenderCounter uint64 } func (h *testCounters) IncrContentRender() { @@ -126,6 +126,13 @@ func (h *testCounters) IncrContentRender() { atomic.AddUint64(&h.contentRenderCounter, 1) } +func (h *testCounters) IncrPageRender() { + if h == nil { + return + } + atomic.AddUint64(&h.pageRenderCounter, 1) +} + type fatalErrorHandler struct { mu sync.Mutex @@ -276,11 +283,11 @@ func (h *HugoSites) GetContentPage(filename string) page.Page { var p page.Page h.getContentMaps().walkBundles(func(b *contentNode) bool { - if b.p == nil || b.fi == nil { + if b.p == nil || !b.HasFi() { return false } - if b.fi.Meta().Filename == filename { + if b.FileInfo().Meta().Filename == filename { p = b.p return true } @@ -424,7 +431,7 @@ func (l configLoader) applyDeps(cfg deps.DepsCfg, sites ...*Site) error { err error ) - for _, s := range sites { + for i, s := range sites { if s.Deps != nil { continue } @@ -455,16 +462,7 @@ func (l configLoader) applyDeps(cfg deps.DepsCfg, sites ...*Site) error { } s.siteConfigConfig = siteConfig - pm := &pageMap{ - contentMap: newContentMap(contentMapConfig{ - lang: s.Lang(), - taxonomyConfig: s.siteCfg.taxonomiesConfig.Values(), - taxonomyDisabled: !s.isEnabled(page.KindTerm), - taxonomyTermDisabled: !s.isEnabled(page.KindTaxonomy), - pageDisabled: !s.isEnabled(page.KindPage), - }), - s: s, - } + pm := newPageMap(i, s) s.PageCollections = newPageCollections(pm) @@ -559,6 +557,7 @@ func createSitesFromConfig(cfg deps.DepsCfg) ([]*Site, error) { } // Reset resets the sites and template caches etc., making it ready for a full rebuild. +// TODO1 func (h *HugoSites) reset(config *BuildCfg) { if config.ResetState { for i, s := range h.Sites { @@ -691,25 +690,26 @@ type BuildCfg struct { // For regular builds, this will allways return true. // TODO(bep) rename/work this. func (cfg *BuildCfg) shouldRender(p *pageState) bool { - if p.forceRender { - return true - } + return p.renderState == 0 + /* + if p.forceRender { + //panic("TODO1") + } - if len(cfg.RecentlyVisited) == 0 { - return true - } + if len(cfg.RecentlyVisited) == 0 { + return true + } - if cfg.RecentlyVisited[p.RelPermalink()] { - return true - } + if cfg.RecentlyVisited[p.RelPermalink()] { + return true + } - if cfg.whatChanged != nil && !p.File().IsZero() { - return cfg.whatChanged.files[p.File().Filename()] - } + // TODO1 stale? - return false + return false*/ } +// TODO(bep) improve this. func (h *HugoSites) renderCrossSitesSitemap() error { if !h.multilingual.enabled() || h.IsMultihost() { return nil @@ -717,7 +717,7 @@ func (h *HugoSites) renderCrossSitesSitemap() error { sitemapEnabled := false for _, s := range h.Sites { - if s.isEnabled(kindSitemap) { + if s.isEnabled(pagekinds.Sitemap) { sitemapEnabled = true break } @@ -735,50 +735,61 @@ func (h *HugoSites) renderCrossSitesSitemap() error { s.siteCfg.sitemap.Filename, h.toSiteInfos(), templ) } -func (h *HugoSites) renderCrossSitesRobotsTXT() error { - if h.multihost { - return nil - } - if !h.Cfg.GetBool("enableRobotsTXT") { - return nil - } - - s := h.Sites[0] - - p, err := newPageStandalone(&pageMeta{ - s: s, - kind: kindRobotsTXT, - urlPaths: pagemeta.URLPath{ - URL: "robots.txt", - }, - }, - output.RobotsTxtFormat) - if err != nil { - return err - } +func (h *HugoSites) removePageByFilename(filename string) error { + exclude := func(s string, n *contentNode) bool { + if n.p == nil { + return true + } - if !p.render { - return nil - } + fi := n.FileInfo() + if fi == nil { + return true + } - templ := s.lookupLayouts("robots.txt", "_default/robots.txt", "_internal/_default/robots.txt") + return fi.Meta().Filename != filename + } + + return h.getContentMaps().withMaps(func(runner para.Runner, m *pageMap) error { + var sectionsToDelete []string + var pagesToDelete []contentTreeRefProvider + + q := branchMapQuery{ + Exclude: exclude, + Branch: branchMapQueryCallBacks{ + Key: newBranchMapQueryKey("", true), + Page: func(np contentNodeProvider) bool { + sectionsToDelete = append(sectionsToDelete, np.Key()) + return false + }, + }, + Leaf: branchMapQueryCallBacks{ + Page: func(np contentNodeProvider) bool { + n := np.GetNode() + pagesToDelete = append(pagesToDelete, n.p.m.treeRef) + return false + }, + }, + } - return s.renderAndWritePage(&s.PathSpec.ProcessingStats.Pages, "Robots Txt", "robots.txt", p, templ) -} + if err := m.Walk(q); err != nil { + return err + } -func (h *HugoSites) removePageByFilename(filename string) { - h.getContentMaps().withMaps(func(m *pageMap) error { - m.deleteBundleMatching(func(b *contentNode) bool { - if b.p == nil { - return false + // Delete pages and sections marked for deletion. + for _, p := range pagesToDelete { + p.GetBranch().pages.nodes.Delete(p.Key()) + p.GetBranch().pageResources.nodes.Delete(p.Key() + "/") + if !p.GetBranch().n.HasFi() && p.GetBranch().pages.nodes.Len() == 0 { + // Delete orphan section. + sectionsToDelete = append(sectionsToDelete, p.GetBranch().n.key) } + } - if b.fi == nil { - return false - } + for _, s := range sectionsToDelete { + m.branches.Delete(s) + m.branches.DeletePrefix(s + "/") + } - return b.fi.Meta().Filename == filename - }) return nil }) } @@ -796,7 +807,7 @@ func (h *HugoSites) createPageCollections() error { }) allRegularPages := newLazyPagesFactory(func() page.Pages { - return h.findPagesByKindIn(page.KindPage, allPages.get()) + return h.findPagesByKindIn(pagekinds.Page, allPages.get()) }) for _, s := range h.Sites { @@ -809,13 +820,19 @@ func (h *HugoSites) createPageCollections() error { func (s *Site) preparePagesForRender(isRenderingSite bool, idx int) error { var err error - s.pageMap.withEveryBundlePage(func(p *pageState) bool { + + walkErr := s.pageMap.WithEveryBundlePage(func(p *pageState) bool { if err = p.initOutputFormat(isRenderingSite, idx); err != nil { return true } return false }) - return nil + + if err == nil { + err = walkErr + } + + return err } // Pages returns all pages for all sites. @@ -828,22 +845,19 @@ func (h *HugoSites) loadData(fis []hugofs.FileMetaInfo) (err error) { h.data = make(map[string]interface{}) for _, fi := range fis { - fileSystem := spec.NewFilesystemFromFileMetaInfo(fi) - files, err := fileSystem.Files() + src := spec.NewFilesystemFromFileMetaInfo(fi) + err := src.Walk(func(file *source.File) error { + return h.handleDataFile(file) + }) if err != nil { return err } - for _, r := range files { - if err := h.handleDataFile(r); err != nil { - return err - } - } } return } -func (h *HugoSites) handleDataFile(r source.File) error { +func (h *HugoSites) handleDataFile(r *source.File) error { var current map[string]interface{} f, err := r.FileInfo().Meta().Open() @@ -921,12 +935,8 @@ func (h *HugoSites) handleDataFile(r source.File) error { return nil } -func (h *HugoSites) errWithFileContext(err error, f source.File) error { - fim, ok := f.FileInfo().(hugofs.FileMetaInfo) - if !ok { - return err - } - +func (h *HugoSites) errWithFileContext(err error, f *source.File) error { + fim := f.FileInfo() realFilename := fim.Meta().Filename err, _ = herrors.WithFileContextForFile( @@ -939,7 +949,7 @@ func (h *HugoSites) errWithFileContext(err error, f source.File) error { return err } -func (h *HugoSites) readData(f source.File) (interface{}, error) { +func (h *HugoSites) readData(f *source.File) (interface{}, error) { file, err := f.FileInfo().Meta().Open() if err != nil { return nil, errors.Wrap(err, "readData: failed to open data file") @@ -955,61 +965,60 @@ func (h *HugoSites) findPagesByKindIn(kind string, inPages page.Pages) page.Page return h.Sites[0].findPagesByKindIn(kind, inPages) } -func (h *HugoSites) resetPageState() { +// TODO1 + +func (h *HugoSites) resetPageRenderStateForIdentities(ids ...identity.Identity) { + if ids == nil { + return + } + h.getContentMaps().walkBundles(func(n *contentNode) bool { - if n.p == nil { - return false - } - p := n.p - for _, po := range p.pageOutputs { - if po.cp == nil { - continue + /*if p.IsStale() { + //panic("stale") + // TODO1 + }*/ + + var mayBeDependant bool + for _, id := range ids { + // /blog/b1 is used in /docs + // /docs is dependent on /blog/b1, not the other way. + if !identity.IsNotDependent(n.GetIdentity(), id) { + mayBeDependant = true + break } - po.cp.Reset() } - return false - }) -} + if mayBeDependant { + if n.p != nil { + // This will re-render the top level Page. + for _, po := range n.p.pageOutputs { + po.renderState = 0 + } + } + } -func (h *HugoSites) resetPageStateFromEvents(idset identity.Identities) { - h.getContentMaps().walkBundles(func(n *contentNode) bool { if n.p == nil { return false } + p := n.p + + // We may also need to re-render one or more .Content + // for this Page's output formats (e.g. when a shortcode template changes). OUTPUTS: for _, po := range p.pageOutputs { if po.cp == nil { continue } - for id := range idset { - if po.cp.dependencyTracker.Search(id) != nil { + for _, id := range ids { + if !identity.IsNotDependent(po.GetDependencyManager(), id) { po.cp.Reset() + po.renderState = 0 continue OUTPUTS } } } - if p.shortcodeState == nil { - return false - } - - for _, s := range p.shortcodeState.shortcodes { - for _, templ := range s.templs { - sid := templ.(identity.Manager) - for id := range idset { - if sid.Search(id) != nil { - for _, po := range p.pageOutputs { - if po.cp != nil { - po.cp.Reset() - } - } - return false - } - } - } - } return false }) } @@ -1033,10 +1042,13 @@ type contentChangeMap struct { // This map is only used in watch mode. // It maps either file to files or the real dir to a set of content directories // where it is in use. + // TODO1 replace all of this with DependencyManager symContentMu sync.Mutex symContent map[string]map[string]bool } +// TODO1 remove +/* func (m *contentChangeMap) add(dirname string, tp bundleDirType) { m.mu.Lock() if !strings.HasSuffix(dirname, helpers.FilePathSeparator) { @@ -1053,38 +1065,9 @@ func (m *contentChangeMap) add(dirname string, tp bundleDirType) { } m.mu.Unlock() } +*/ -func (m *contentChangeMap) resolveAndRemove(filename string) (string, bundleDirType) { - m.mu.RLock() - defer m.mu.RUnlock() - - // Bundles share resources, so we need to start from the virtual root. - relFilename := m.pathSpec.RelContentDir(filename) - dir, name := filepath.Split(relFilename) - if !strings.HasSuffix(dir, helpers.FilePathSeparator) { - dir += helpers.FilePathSeparator - } - - if _, found := m.branchBundles[dir]; found { - delete(m.branchBundles, dir) - return dir, bundleBranch - } - - if key, _, found := m.leafBundles.LongestPrefix(dir); found { - m.leafBundles.Delete(key) - dir = string(key) - return dir, bundleLeaf - } - - fileTp, isContent := classifyBundledFile(name) - if isContent && fileTp != bundleNot { - // A new bundle. - return dir, fileTp - } - - return dir, bundleNot -} - +// TODO1 add test for this and replace this. Also re remove. func (m *contentChangeMap) addSymbolicLinkMapping(fim hugofs.FileMetaInfo) { meta := fim.Meta() if !meta.IsSymlink { diff --git a/hugolib/hugo_sites_build.go b/hugolib/hugo_sites_build.go index 6f3955b80a7..9b224ece445 100644 --- a/hugolib/hugo_sites_build.go +++ b/hugolib/hugo_sites_build.go @@ -23,6 +23,7 @@ import ( "runtime/trace" "strings" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/publisher" "github.com/gohugoio/hugo/hugofs" @@ -84,7 +85,7 @@ func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error { if conf.whatChanged == nil { // Assume everything has changed - conf.whatChanged = &whatChanged{source: true} + conf.whatChanged = &whatChanged{contentChanged: true} } var prepareErr error @@ -106,7 +107,6 @@ func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error { return errors.Wrap(err, "initSites") } } - return nil } @@ -217,10 +217,10 @@ func (h *HugoSites) initRebuild(config *BuildCfg) error { } for _, s := range h.Sites { - s.resetBuildState(config.whatChanged.source) + s.resetBuildState(config.whatChanged.contentChanged) } - h.reset(config) + // TODO1 h.reset(config) h.resetLogs() helpers.InitLoggers() @@ -228,11 +228,8 @@ func (h *HugoSites) initRebuild(config *BuildCfg) error { } func (h *HugoSites) process(config *BuildCfg, init func(config *BuildCfg) error, events ...fsnotify.Event) error { - // We should probably refactor the Site and pull up most of the logic from there to here, - // but that seems like a daunting task. - // So for now, if there are more than one site (language), + // If there are more than one site (language), // we pre-process the first one, then configure all the sites based on that. - firstSite := h.Sites[0] if len(events) > 0 { @@ -253,16 +250,25 @@ func (h *HugoSites) assemble(bcfg *BuildCfg) error { } } - if !bcfg.whatChanged.source { - return nil - } + if bcfg.whatChanged.contentChanged { + if err := h.getContentMaps().AssemblePages(bcfg.whatChanged); err != nil { + return err + } + + if err := h.createPageCollections(); err != nil { + return err + } - if err := h.getContentMaps().AssemblePages(); err != nil { - return err } - if err := h.createPageCollections(); err != nil { - return err + changes := bcfg.whatChanged.Changes() + if len(changes) > 0 { + // 1. Clear the memory cache. This allows any changed/depdendant resource fetched/processed + // via resources.Get etc. to be re-fetched/-processed. + h.MemCache.ClearOn(memcache.ClearOnRebuild, changes...) + + // 2. Prepare the Page render state. + h.resetPageRenderStateForIdentities(changes...) } return nil @@ -329,9 +335,6 @@ func (h *HugoSites) render(config *BuildCfg) error { if err := h.renderCrossSitesSitemap(); err != nil { return err } - if err := h.renderCrossSitesRobotsTXT(); err != nil { - return err - } } return nil diff --git a/hugolib/hugo_sites_build_errors_test.go b/hugolib/hugo_sites_build_errors_test.go index 8b23e7ac734..c95fede0d41 100644 --- a/hugolib/hugo_sites_build_errors_test.go +++ b/hugolib/hugo_sites_build_errors_test.go @@ -213,7 +213,7 @@ func TestSiteBuildErrors(t *testing.T) { for _, test := range tests { test := test t.Run(test.name, func(t *testing.T) { - t.Parallel() + //t.Parallel() c := qt.New(t) errorAsserter := testSiteBuildErrorAsserter{ c: c, diff --git a/hugolib/hugo_sites_build_test.go b/hugolib/hugo_sites_build_test.go index fdfc33c5a15..7658df2d4f6 100644 --- a/hugolib/hugo_sites_build_test.go +++ b/hugolib/hugo_sites_build_test.go @@ -5,14 +5,11 @@ import ( "path/filepath" "strings" "testing" - "time" qt "github.com/frankban/quicktest" "github.com/gohugoio/hugo/htesting" - "github.com/gohugoio/hugo/resources/page" + "github.com/gohugoio/hugo/resources/page/pagekinds" - "github.com/fortytw2/leaktest" - "github.com/fsnotify/fsnotify" "github.com/gohugoio/hugo/helpers" "github.com/gohugoio/hugo/hugofs" "github.com/spf13/afero" @@ -98,7 +95,7 @@ func doTestMultiSitesMainLangInRoot(t *testing.T, defaultInSubDir bool) { // Check list pages b.AssertFileContent(pathMod("public/fr/sect/index.html"), "List", "Bonjour") b.AssertFileContent("public/en/sect/index.html", "List", "Hello") - b.AssertFileContent(pathMod("public/fr/plaques/FRtag1/index.html"), "Taxonomy List", "Bonjour") + // TODO1 b.AssertFileContent(pathMod("public/fr/plaques/FRtag1/index.html"), "Taxonomy List", "Bonjour") b.AssertFileContent("public/en/tags/tag1/index.html", "Taxonomy List", "Hello") // Check sitemaps @@ -123,9 +120,9 @@ func doTestMultiSitesMainLangInRoot(t *testing.T, defaultInSubDir bool) { pathMod("public/fr/sect/index.xml"), pathMod(`doc2\n\n

some content") - - enSite := sites[0] - frSite := sites[1] - - c.Assert(len(enSite.RegularPages()), qt.Equals, 5) - c.Assert(len(frSite.RegularPages()), qt.Equals, 4) - - // Verify translations - b.AssertFileContent("public/en/sect/doc1-slug/index.html", "Hello") - b.AssertFileContent("public/fr/sect/doc1/index.html", "Bonjour") - - // check single page content - b.AssertFileContent("public/fr/sect/doc1/index.html", "Single", "Shortcode: Bonjour") - b.AssertFileContent("public/en/sect/doc1-slug/index.html", "Single", "Shortcode: Hello") - - homeEn := enSite.getPage(page.KindHome) - c.Assert(homeEn, qt.Not(qt.IsNil)) - c.Assert(len(homeEn.Translations()), qt.Equals, 3) - - contentFs := b.H.Fs.Source - - for i, this := range []struct { - preFunc func(t *testing.T) - events []fsnotify.Event - assertFunc func(t *testing.T) - }{ - // * Remove doc - // * Add docs existing languages - // (Add doc new language: TODO(bep) we should load config.toml as part of these so we can add languages). - // * Rename file - // * Change doc - // * Change a template - // * Change language file - { - func(t *testing.T) { - fs.Source.Remove("content/sect/doc2.en.md") - }, - []fsnotify.Event{{Name: filepath.FromSlash("content/sect/doc2.en.md"), Op: fsnotify.Remove}}, - func(t *testing.T) { - c.Assert(len(enSite.RegularPages()), qt.Equals, 4, qt.Commentf("1 en removed")) - }, - }, - { - func(t *testing.T) { - writeNewContentFile(t, contentFs, "new_en_1", "2016-07-31", "content/new1.en.md", -5) - writeNewContentFile(t, contentFs, "new_en_2", "1989-07-30", "content/new2.en.md", -10) - writeNewContentFile(t, contentFs, "new_fr_1", "2016-07-30", "content/new1.fr.md", 10) - }, - []fsnotify.Event{ - {Name: filepath.FromSlash("content/new1.en.md"), Op: fsnotify.Create}, - {Name: filepath.FromSlash("content/new2.en.md"), Op: fsnotify.Create}, - {Name: filepath.FromSlash("content/new1.fr.md"), Op: fsnotify.Create}, - }, - func(t *testing.T) { - c.Assert(len(enSite.RegularPages()), qt.Equals, 6) - c.Assert(len(enSite.AllPages()), qt.Equals, 34) - c.Assert(len(frSite.RegularPages()), qt.Equals, 5) - c.Assert(frSite.RegularPages()[3].Title(), qt.Equals, "new_fr_1") - c.Assert(enSite.RegularPages()[0].Title(), qt.Equals, "new_en_2") - c.Assert(enSite.RegularPages()[1].Title(), qt.Equals, "new_en_1") - - rendered := readDestination(t, fs, "public/en/new1/index.html") - c.Assert(strings.Contains(rendered, "new_en_1"), qt.Equals, true) - }, - }, - { - func(t *testing.T) { - p := "content/sect/doc1.en.md" - doc1 := readFileFromFs(t, contentFs, p) - doc1 += "CHANGED" - writeToFs(t, contentFs, p, doc1) - }, - []fsnotify.Event{{Name: filepath.FromSlash("content/sect/doc1.en.md"), Op: fsnotify.Write}}, - func(t *testing.T) { - c.Assert(len(enSite.RegularPages()), qt.Equals, 6) - doc1 := readDestination(t, fs, "public/en/sect/doc1-slug/index.html") - c.Assert(strings.Contains(doc1, "CHANGED"), qt.Equals, true) - }, - }, - // Rename a file - { - func(t *testing.T) { - if err := contentFs.Rename("content/new1.en.md", "content/new1renamed.en.md"); err != nil { - t.Fatalf("Rename failed: %s", err) - } - }, - []fsnotify.Event{ - {Name: filepath.FromSlash("content/new1renamed.en.md"), Op: fsnotify.Rename}, - {Name: filepath.FromSlash("content/new1.en.md"), Op: fsnotify.Rename}, - }, - func(t *testing.T) { - c.Assert(len(enSite.RegularPages()), qt.Equals, 6, qt.Commentf("Rename")) - c.Assert(enSite.RegularPages()[1].Title(), qt.Equals, "new_en_1") - rendered := readDestination(t, fs, "public/en/new1renamed/index.html") - c.Assert(rendered, qt.Contains, "new_en_1") - }, - }, - { - // Change a template - func(t *testing.T) { - template := "layouts/_default/single.html" - templateContent := readSource(t, fs, template) - templateContent += "{{ print \"Template Changed\"}}" - writeSource(t, fs, template, templateContent) - }, - []fsnotify.Event{{Name: filepath.FromSlash("layouts/_default/single.html"), Op: fsnotify.Write}}, - func(t *testing.T) { - c.Assert(len(enSite.RegularPages()), qt.Equals, 6) - c.Assert(len(enSite.AllPages()), qt.Equals, 34) - c.Assert(len(frSite.RegularPages()), qt.Equals, 5) - doc1 := readDestination(t, fs, "public/en/sect/doc1-slug/index.html") - c.Assert(strings.Contains(doc1, "Template Changed"), qt.Equals, true) - }, - }, - { - // Change a language file - func(t *testing.T) { - languageFile := "i18n/fr.yaml" - langContent := readSource(t, fs, languageFile) - langContent = strings.Replace(langContent, "Bonjour", "Salut", 1) - writeSource(t, fs, languageFile, langContent) - }, - []fsnotify.Event{{Name: filepath.FromSlash("i18n/fr.yaml"), Op: fsnotify.Write}}, - func(t *testing.T) { - c.Assert(len(enSite.RegularPages()), qt.Equals, 6) - c.Assert(len(enSite.AllPages()), qt.Equals, 34) - c.Assert(len(frSite.RegularPages()), qt.Equals, 5) - docEn := readDestination(t, fs, "public/en/sect/doc1-slug/index.html") - c.Assert(strings.Contains(docEn, "Hello"), qt.Equals, true) - docFr := readDestination(t, fs, "public/fr/sect/doc1/index.html") - c.Assert(strings.Contains(docFr, "Salut"), qt.Equals, true) - - homeEn := enSite.getPage(page.KindHome) - c.Assert(homeEn, qt.Not(qt.IsNil)) - c.Assert(len(homeEn.Translations()), qt.Equals, 3) - c.Assert(homeEn.Translations()[0].Language().Lang, qt.Equals, "fr") - }, - }, - // Change a shortcode - { - func(t *testing.T) { - writeSource(t, fs, "layouts/shortcodes/shortcode.html", "Modified Shortcode: {{ i18n \"hello\" }}") - }, - []fsnotify.Event{ - {Name: filepath.FromSlash("layouts/shortcodes/shortcode.html"), Op: fsnotify.Write}, - }, - func(t *testing.T) { - c.Assert(len(enSite.RegularPages()), qt.Equals, 6) - c.Assert(len(enSite.AllPages()), qt.Equals, 34) - c.Assert(len(frSite.RegularPages()), qt.Equals, 5) - b.AssertFileContent("public/fr/sect/doc1/index.html", "Single", "Modified Shortcode: Salut") - b.AssertFileContent("public/en/sect/doc1-slug/index.html", "Single", "Modified Shortcode: Hello") - }, - }, - } { - - if this.preFunc != nil { - this.preFunc(t) - } - - err := b.H.Build(BuildCfg{}, this.events...) - if err != nil { - t.Fatalf("[%d] Failed to rebuild sites: %s", i, err) - } - - this.assertFunc(t) - } -} - // https://github.com/gohugoio/hugo/issues/4706 func TestContentStressTest(t *testing.T) { b := newTestSitesBuilder(t) @@ -1229,11 +1044,6 @@ func newTestPage(title, date string, weight int) string { return fmt.Sprintf(testPageTemplate, title, date, weight, title) } -func writeNewContentFile(t *testing.T, fs afero.Fs, title, date, filename string, weight int) { - content := newTestPage(title, date, weight) - writeToFs(t, fs, filename, content) -} - type multiSiteTestBuilder struct { configData interface{} config string @@ -1450,19 +1260,3 @@ other = %q return &multiSiteTestBuilder{sitesBuilder: b, configFormat: configFormat, config: config, configData: configData} } - -func TestRebuildOnAssetChange(t *testing.T) { - b := newTestSitesBuilder(t).Running() - b.WithTemplatesAdded("index.html", ` -{{ (resources.Get "data.json").Content }} -`) - b.WithSourceFile("assets/data.json", "orig data") - - b.Build(BuildCfg{}) - b.AssertFileContent("public/index.html", `orig data`) - - b.EditFiles("assets/data.json", "changed data") - - b.Build(BuildCfg{}) - b.AssertFileContent("public/index.html", `changed data`) -} diff --git a/hugolib/hugo_sites_multihost_test.go b/hugolib/hugo_sites_multihost_test.go index b008fbdef76..cfaa909924d 100644 --- a/hugolib/hugo_sites_multihost_test.go +++ b/hugolib/hugo_sites_multihost_test.go @@ -3,17 +3,16 @@ package hugolib import ( "testing" - "github.com/gohugoio/hugo/resources/page" + "github.com/gohugoio/hugo/resources/page/pagekinds" qt "github.com/frankban/quicktest" ) func TestMultihosts(t *testing.T) { - t.Parallel() - c := qt.New(t) - configTemplate := ` + files := ` +-- config.toml -- paginate = 1 disablePathToLower = true defaultContentLanguage = "fr" @@ -27,38 +26,160 @@ other = "/somewhere/else/:filename" [Taxonomies] tag = "tags" -[Languages] -[Languages.en] +[languages] +[languages.en] staticDir2 = ["ens1", "ens2"] baseURL = "https://example.com/docs" weight = 10 title = "In English" languageName = "English" -[Languages.fr] +[languages.fr] staticDir2 = ["frs1", "frs2"] baseURL = "https://example.fr" weight = 20 title = "Le Français" languageName = "Français" -[Languages.nn] +[languages.nn] staticDir2 = ["nns1", "nns2"] baseURL = "https://example.no" weight = 30 title = "På nynorsk" languageName = "Nynorsk" - -` - - b := newMultiSiteTestDefaultBuilder(t).WithConfigFile("toml", configTemplate) - b.CreateSites().Build(BuildCfg{}) +-- content/bundles/b1/index.en.md -- +--- +title: Bundle EN +publishdate: "2000-01-06" +weight: 2001 +--- +# Bundle Content EN +-- content/bundles/b1/index.md -- +--- +title: Bundle Default +publishdate: "2000-01-06" +weight: 2002 +--- +# Bundle Content Default +-- content/bundles/b1/logo.png -- +PNG Data +-- content/other/doc5.fr.md -- +--- +title: doc5 +weight: 5 +publishdate: "2000-01-06" +--- +# doc5 +*autre contenu francophone* +NOTE: should use the "permalinks" configuration with :filename +-- content/root.en.md -- +--- +title: root +weight: 10000 +slug: root +publishdate: "2000-01-01" +--- +# root +-- content/sect/doc1.en.md -- +--- +title: doc1 +weight: 1 +slug: doc1-slug +tags: + - tag1 +publishdate: "2000-01-01" +--- +# doc1 +*some "content"* +-- content/sect/doc1.fr.md -- +--- +title: doc1 +weight: 1 +plaques: + - FRtag1 + - FRtag2 +publishdate: "2000-01-04" +--- +# doc1 +*quelque "contenu"* +NOTE: date is after "doc3" +-- content/sect/doc2.en.md -- +--- +title: doc2 +weight: 2 +publishdate: "2000-01-02" +--- +# doc2 +*some content* +NOTE: without slug, "doc2" should be used, without ".en" as URL +-- content/sect/doc3.en.md -- +--- +title: doc3 +weight: 3 +publishdate: "2000-01-03" +aliases: [/en/al/alias1,/al/alias2/] +tags: + - tag2 + - tag1 +url: /superbob/ +--- +# doc3 +*some content* +NOTE: third 'en' doc, should trigger pagination on home page. +-- content/sect/doc4.md -- +--- +title: doc4 +weight: 4 +plaques: + - FRtag1 +publishdate: "2000-01-05" +--- +# doc4 +*du contenu francophone* +-- i18n/en.toml -- +[hello] +other = "Hello" +-- i18n/en.yaml -- +hello: + other: "Hello" +-- i18n/fr.toml -- +[hello] +other = "Bonjour" +-- i18n/fr.yaml -- +hello: + other: "Bonjour" +-- i18n/nb.toml -- +[hello] +other = "Hallo" +-- i18n/nn.toml -- +[hello] +other = "Hallo" +-- layouts/_default/list.html -- +List Page {{ $p := .Paginator }}{{ $p.PageNumber }}|{{ .Title }}|{{ i18n "hello" }}|{{ .Permalink }}|Pager: {{ template "_internal/pagination.html" . }}|Kind: {{ .Kind }}|Content: {{ .Content }}|Len Pages: {{ len .Pages }}|Len RegularPages: {{ len .RegularPages }}| HasParent: {{ if .Parent }}YES{{ else }}NO{{ end }} +-- layouts/_default/single.html -- +Single: {{ .Title }}|{{ i18n "hello" }}|{{.Language.Lang}}|RelPermalink: {{ .RelPermalink }}|Permalink: {{ .Permalink }}|{{ .Content }}|Resources: {{ range .Resources }}{{ .MediaType }}: {{ .RelPermalink}} -- {{ end }}|Summary: {{ .Summary }}|Truncated: {{ .Truncated }}|Parent: {{ .Parent.Title }} +-- layouts/_default/taxonomy.html -- +-- layouts/index.fr.html -- +{{ $p := .Paginator }}French Home Page {{ $p.PageNumber }}: {{ .Title }}|{{ .IsHome }}|{{ i18n "hello" }}|{{ .Permalink }}|{{ .Site.Data.hugo.slogan }}|String Resource: {{ ( "Hugo Pipes" | resources.FromString "text/pipes.txt").RelPermalink }} +-- layouts/index.html -- +{{ $p := .Paginator }}Default Home Page {{ $p.PageNumber }}: {{ .Title }}|{{ .IsHome }}|{{ i18n "hello" }}|{{ .Permalink }}|{{ .Site.Data.hugo.slogan }}|String Resource: {{ ( "Hugo Pipes" | resources.FromString "text/pipes.txt").RelPermalink }} +-- layouts/robots.txt -- +robots|{{ .Lang }}|{{ .Title }} + ` + + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + NeedsOsFS: false, + NeedsNpmInstall: false, + TxtarString: files, + }).Build() b.AssertFileContent("public/en/sect/doc1-slug/index.html", "Hello") s1 := b.H.Sites[0] - s1h := s1.getPage(page.KindHome) + s1h := s1.getPage(pagekinds.Home) c.Assert(s1h.IsTranslated(), qt.Equals, true) c.Assert(len(s1h.Translations()), qt.Equals, 2) c.Assert(s1h.Permalink(), qt.Equals, "https://example.com/docs/") @@ -69,7 +190,7 @@ languageName = "Nynorsk" // For multihost, we never want any content in the root. // // check url in front matter: - pageWithURLInFrontMatter := s1.getPage(page.KindPage, "sect/doc3.en.md") + pageWithURLInFrontMatter := s1.getPage(pagekinds.Page, "sect/doc3.en.md") c.Assert(pageWithURLInFrontMatter, qt.Not(qt.IsNil)) c.Assert(pageWithURLInFrontMatter.RelPermalink(), qt.Equals, "/docs/superbob/") b.AssertFileContent("public/en/superbob/index.html", "doc3|Hello|en") @@ -78,7 +199,7 @@ languageName = "Nynorsk" b.AssertFileContent("public/en/robots.txt", "robots|en") b.AssertFileContent("public/fr/robots.txt", "robots|fr") b.AssertFileContent("public/nn/robots.txt", "robots|nn") - b.AssertFileDoesNotExist("public/robots.txt") + b.AssertDestinationExists("public/robots.txt", false) // check alias: b.AssertFileContent("public/en/al/alias1/index.html", `content="0; url=https://example.com/docs/superbob/"`) @@ -86,10 +207,10 @@ languageName = "Nynorsk" s2 := b.H.Sites[1] - s2h := s2.getPage(page.KindHome) + s2h := s2.getPage(pagekinds.Home) c.Assert(s2h.Permalink(), qt.Equals, "https://example.fr/") - b.AssertFileContent("public/fr/index.html", "French Home Page", "String Resource: /docs/text/pipes.txt") + b.AssertFileContent("public/fr/index.html", "French Home Page", "String Resource: /text/pipes.txt") b.AssertFileContent("public/fr/text/pipes.txt", "Hugo Pipes") b.AssertFileContent("public/en/index.html", "Default Home Page", "String Resource: /docs/text/pipes.txt") b.AssertFileContent("public/en/text/pipes.txt", "Hugo Pipes") @@ -102,7 +223,7 @@ languageName = "Nynorsk" // Check bundles - bundleEn := s1.getPage(page.KindPage, "bundles/b1/index.en.md") + bundleEn := s1.getPage(pagekinds.Page, "bundles/b1/index.en.md") c.Assert(bundleEn, qt.Not(qt.IsNil)) c.Assert(bundleEn.RelPermalink(), qt.Equals, "/docs/bundles/b1/") c.Assert(len(bundleEn.Resources()), qt.Equals, 1) @@ -110,7 +231,7 @@ languageName = "Nynorsk" b.AssertFileContent("public/en/bundles/b1/logo.png", "PNG Data") b.AssertFileContent("public/en/bundles/b1/index.html", " image/png: /docs/bundles/b1/logo.png") - bundleFr := s2.getPage(page.KindPage, "bundles/b1/index.md") + bundleFr := s2.getPage(pagekinds.Page, "bundles/b1/index.md") c.Assert(bundleFr, qt.Not(qt.IsNil)) c.Assert(bundleFr.RelPermalink(), qt.Equals, "/bundles/b1/") c.Assert(len(bundleFr.Resources()), qt.Equals, 1) diff --git a/hugolib/hugo_sites_rebuild_test.go b/hugolib/hugo_sites_rebuild_test.go index d312d21992c..90a8bff5297 100644 --- a/hugolib/hugo_sites_rebuild_test.go +++ b/hugolib/hugo_sites_rebuild_test.go @@ -14,303 +14,584 @@ package hugolib import ( + "strings" "testing" qt "github.com/frankban/quicktest" + "github.com/gohugoio/hugo/htesting" ) -func TestSitesRebuild(t *testing.T) { - configFile := ` -baseURL = "https://example.com" -title = "Rebuild this" -contentDir = "content" -enableInlineShortcodes = true -timeout = "5s" - +func TestRebuildAddPageToSection(t *testing.T) { + c := qt.New(t) + + files := ` +-- config.toml -- +disableKinds=["home", "taxonomy", "term", "sitemap", "robotsTXT"] +[outputs] + section = ['HTML'] + page = ['HTML'] +-- content/blog/b1.md -- +-- content/blog/b3.md -- +-- content/doc/d1.md -- +-- content/doc/d3.md -- +-- layouts/_default/single.html -- +{{ .Path }} +-- layouts/_default/list.html -- +List: +{{ range $i, $e := .RegularPages }} +{{ $i }}: {{ .Path }} +{{ end }} ` - var ( - contentFilename = "content/blog/page1.md" - dataFilename = "data/mydata.toml" - ) - - createSiteBuilder := func(t testing.TB) *sitesBuilder { - b := newTestSitesBuilder(t).WithConfigFile("toml", configFile).Running() - - b.WithSourceFile(dataFilename, `hugo = "Rocks!"`) - - b.WithContent("content/_index.md", `--- -title: Home, Sweet Home! ---- - + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: files, + Running: true, + }, + ).Build() + + b.AssertRenderCountPage(6) + b.AssertFileContent("public/blog/index.html", ` +0: /blog/b1 +1: /blog/b3 `) - b.WithContent(contentFilename, ` ---- -title: "Page 1" -summary: "Initial summary" -paginate: 3 ---- - -Content. - -{{< badge.inline >}} -Data Inline: {{ site.Data.mydata.hugo }} -{{< /badge.inline >}} + b.AddFiles("content/blog/b2.md", "").Build() + b.AssertFileContent("public/blog/index.html", ` +0: /blog/b1 +1: /blog/b2 +2: /blog/b3 `) - // For .Page.Render tests - b.WithContent("prender.md", `--- -title: Page 1 ---- - -Content for Page 1. - -{{< dorender >}} + // The 3 sections. + b.AssertRenderCountPage(3) +} -`) +func TestRebuildAddPageToSectionListItFromAnotherSection(t *testing.T) { + c := qt.New(t) + + files := ` +-- config.toml -- +disableKinds=["home", "taxonomy", "term", "sitemap", "robotsTXT"] +[outputs] + section = ['HTML'] + page = ['HTML'] +-- content/blog/b1.md -- +-- content/blog/b3.md -- +-- content/doc/d1.md -- +-- content/doc/d3.md -- +-- layouts/_default/single.html -- +{{ .Path }} +-- layouts/_default/list.html -- +List Default +-- layouts/doc/list.html -- +{{ $blog := site.GetPage "blog" }} +List Doc: +{{ range $i, $e := $blog.RegularPages }} +{{ $i }}: {{ .Path }} +{{ end }} - b.WithTemplatesAdded( - "layouts/shortcodes/dorender.html", ` -{{ $p := .Page }} -Render {{ $p.RelPermalink }}: {{ $p.Render "single" }} +` + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: files, + Running: true, + }, + ).Build() + + b.AssertRenderCountPage(6) + b.AssertFileContent("public/doc/index.html", ` +0: /blog/b1 +1: /blog/b3 `) - b.WithTemplatesAdded("index.html", ` -{{ range (.Paginate .Site.RegularPages).Pages }} -* Page Paginate: {{ .Title }}|Summary: {{ .Summary }}|Content: {{ .Content }} -{{ end }} -{{ range .Site.RegularPages }} -* Page Pages: {{ .Title }}|Summary: {{ .Summary }}|Content: {{ .Content }} -{{ end }} -Content: {{ .Content }} -Data: {{ site.Data.mydata.hugo }} + b.AddFiles("content/blog/b2.md", "").Build() + b.AssertFileContent("public/doc/index.html", ` +0: /blog/b1 +1: /blog/b2 +2: /blog/b3 `) - b.WithTemplatesAdded("layouts/partials/mypartial1.html", `Mypartial1`) - b.WithTemplatesAdded("layouts/partials/mypartial2.html", `Mypartial2`) - b.WithTemplatesAdded("layouts/partials/mypartial3.html", `Mypartial3`) - b.WithTemplatesAdded("_default/single.html", `{{ define "main" }}Single Main: {{ .Title }}|Mypartial1: {{ partial "mypartial1.html" }}{{ end }}`) - b.WithTemplatesAdded("_default/list.html", `{{ define "main" }}List Main: {{ .Title }}{{ end }}`) - b.WithTemplatesAdded("_default/baseof.html", `Baseof:{{ block "main" . }}Baseof Main{{ end }}|Mypartial3: {{ partial "mypartial3.html" }}:END`) - - return b - } - - t.Run("Refresh paginator on edit", func(t *testing.T) { - b := createSiteBuilder(t) - - b.Build(BuildCfg{}) - - b.AssertFileContent("public/index.html", "* Page Paginate: Page 1|Summary: Initial summary|Content:

Content.

") + // Just the 3 sections. + b.AssertRenderCountPage(3) +} - b.EditFiles(contentFilename, ` ---- -title: "Page 1 edit" -summary: "Edited summary" ---- +func TestRebuildChangePartialUsedInShortcode(t *testing.T) { + c := qt.New(t) + + files := ` +-- config.toml -- +disableKinds=["home", "section", "taxonomy", "term", "sitemap", "robotsTXT"] +[outputs] + page = ['HTML'] +-- content/blog/p1.md -- +Shortcode: {{< c >}} +-- content/blog/p2.md -- +CONTENT +-- layouts/_default/single.html -- +{{ .Path }}: {{ .Content }} +-- layouts/shortcodes/c.html -- +{{ partial "p.html" . }} +-- layouts/partials/p.html -- +MYPARTIAL -Edited content. +` -`) + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: files, + Running: true, + }, + ).Build() - b.Build(BuildCfg{}) + b.AssertRenderCountPage(2) + b.AssertFileContent("public/blog/p1/index.html", `/blog/p1:

Shortcode: MYPARTIAL`) - b.AssertFileContent("public/index.html", "* Page Paginate: Page 1 edit|Summary: Edited summary|Content:

Edited content.

") - // https://github.com/gohugoio/hugo/issues/5833 - b.AssertFileContent("public/index.html", "* Page Pages: Page 1 edit|Summary: Edited summary|Content:

Edited content.

") - }) + b.EditFiles("layouts/partials/p.html", "MYPARTIAL CHANGED").Build() - // https://github.com/gohugoio/hugo/issues/6768 - t.Run("Edit data", func(t *testing.T) { - b := createSiteBuilder(t) + b.AssertRenderCountPage(1) + b.AssertFileContent("public/blog/p1/index.html", `/blog/p1:

Shortcode: MYPARTIAL CHANGED`) +} - b.Build(BuildCfg{}) +func TestRebuildEditPartials(t *testing.T) { + c := qt.New(t) + + files := ` +-- config.toml -- +disableKinds=["home", "section", "taxonomy", "term", "sitemap", "robotsTXT"] +[outputs] + page = ['HTML'] +-- content/blog/p1.md -- +Shortcode: {{< c >}} +-- content/blog/p2.md -- +CONTENT +-- content/blog/p3.md -- +Shortcode: {{< d >}} +-- content/blog/p4.md -- +Shortcode: {{< d >}} +-- content/blog/p5.md -- +Shortcode: {{< d >}} +-- content/blog/p6.md -- +Shortcode: {{< d >}} +-- content/blog/p7.md -- +Shortcode: {{< d >}} +-- layouts/_default/single.html -- +{{ .Path }}: {{ .Content }} +-- layouts/shortcodes/c.html -- +{{ partial "p.html" . }} +-- layouts/shortcodes/d.html -- +{{ partialCached "p.html" . }} +-- layouts/partials/p.html -- +MYPARTIAL - b.AssertFileContent("public/index.html", ` -Data: Rocks! -Data Inline: Rocks! -`) +` - b.EditFiles(dataFilename, `hugo = "Rules!"`) + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: files, + Running: true, + }, + ).Build() - b.Build(BuildCfg{}) + b.AssertRenderCountPage(7) + b.AssertFileContent("public/blog/p1/index.html", `/blog/p1:

Shortcode: MYPARTIAL`) + b.AssertFileContent("public/blog/p3/index.html", `/blog/p3:

Shortcode: MYPARTIAL`) - b.AssertFileContent("public/index.html", ` -Data: Rules! -Data Inline: Rules!`) - }) + b.EditFiles("layouts/partials/p.html", "MYPARTIAL CHANGED").Build() - // https://github.com/gohugoio/hugo/issues/6968 - t.Run("Edit single.html with base", func(t *testing.T) { - b := newTestSitesBuilder(t).Running() + b.AssertRenderCountPage(6) + b.AssertFileContent("public/blog/p1/index.html", `/blog/p1:

Shortcode: MYPARTIAL CHANGED`) + b.AssertFileContent("public/blog/p3/index.html", `/blog/p3:

Shortcode: MYPARTIAL CHANGED`) + b.AssertFileContent("public/blog/p4/index.html", `/blog/p4:

Shortcode: MYPARTIAL CHANGED`) +} - b.WithTemplates( - "_default/single.html", `{{ define "main" }}Single{{ end }}`, - "_default/baseof.html", `Base: {{ block "main" .}}Block{{ end }}`, - ) +// bookmark1 +func TestRebuildBasic(t *testing.T) { + // TODO1 + pinnedTestCase := "" + tt := htesting.NewPinnedRunner(t, pinnedTestCase) - b.WithContent("p1.md", "---\ntitle: Page\n---") + var ( + twoPagesAndHomeDataInP1 = ` +-- config.toml -- +disableKinds=["section", "taxonomy", "term", "sitemap", "robotsTXT"] +[permalinks] +"/"="/:filename/" +[outputs] + home = ['HTML'] + page = ['HTML'] +-- data/mydata.toml -- +hugo="Rocks!" +-- content/p1.md -- +--- +includeData: true +--- +CONTENT +-- content/p2.md -- +CONTENT +-- layouts/_default/single.html -- +{{ if .Params.includeData }} +Hugo {{ site.Data.mydata.hugo }} +{{ else }} +NO DATA USED +{{ end }} +Title: {{ .Title }}|Content Start: {{ .Content }}:End: +-- layouts/index.html -- +Home: Len site.Pages: {{ len site.Pages}}|Len site.RegularPages: {{ len site.RegularPages}}|Len site.AllPages: {{ len site.AllPages}}:End: +` - b.Build(BuildCfg{}) + twoPagesDataInShortcodeInP2HTMLAndRSS = ` +-- config.toml -- +disableKinds=["home", "section", "taxonomy", "term", "sitemap", "robotsTXT"] +[outputs] + page = ['HTML', 'RSS'] +-- data/mydata.toml -- +hugo="Rocks!" +-- content/p1.md -- +--- +slug: p1 +--- +CONTENT +-- content/p2.md -- +--- +slug: p2 +--- +{{< foo >}} +CONTENT +-- layouts/_default/single.html -- +HTML: {{ .Slug }}: {{ .Content }} +-- layouts/_default/single.xml -- +XML: {{ .Slug }}: {{ .Content }} +-- layouts/shortcodes/foo.html -- +Hugo {{ site.Data.mydata.hugo }} +-- layouts/shortcodes/foo.xml -- +No Data +` - b.EditFiles("layouts/_default/single.html", `Single Edit: {{ define "main" }}Single{{ end }}`) + twoPagesDataInRenderHookInP2 = ` +-- config.toml -- +disableKinds=["home", "section", "taxonomy", "term", "sitemap", "robotsTXT"] +-- data/mydata.toml -- +hugo="Rocks!" +-- content/p1.md -- +--- +slug: p1 +--- +-- content/p2.md -- +--- +slug: p2 +--- +[Text](https://www.gohugo.io "Title") +-- layouts/_default/single.html -- +{{ .Slug }}: {{ .Content }} +-- layouts/_default/_markup/render-link.html -- +Hugo {{ site.Data.mydata.hugo }} +` - counters := &testCounters{} + twoPagesAndHomeWithBaseTemplate = ` +-- config.toml -- +disableKinds=[ "section", "taxonomy", "term", "sitemap", "robotsTXT"] +[outputs] + home = ['HTML'] + page = ['HTML'] +-- data/mydata.toml -- +hugo="Rocks!" +-- content/_index.md -- +--- +title: MyHome +--- +-- content/p1.md -- +--- +slug: p1 +--- +-- content/p2.md -- +--- +slug: p2 +--- +-- layouts/_default/baseof.html -- +Block Main Start:{{ block "main" . }}{{ end }}:End: +-- layouts/_default/single.html -- +{{ define "main" }}Single Main Start:{{ .Slug }}: {{ .Content }}:End:{{ end }} +-- layouts/_default/list.html -- +{{ define "main" }}List Main Start:{{ .Title }}: {{ .Content }}:End{{ end }} +` + ) - b.Build(BuildCfg{testCounters: counters}) + // * Remove doc + // * Add + // * Rename file + // * Change doc + // * Change a template + // * Change language file + // OK * Site.LastChange - mod, no mod + + // Tests for Site.LastChange + for _, changeSiteLastChanged := range []bool{false, true} { + name := "Site.LastChange" + if changeSiteLastChanged { + name += " Changed" + } else { + name += " Not Changed" + } + + const files = ` +-- config.toml -- +disableKinds=["section", "taxonomy", "term", "sitemap", "robotsTXT", "404"] +[outputs] + home = ['HTML'] + page = ['HTML'] +-- content/_index.md -- +--- +title: Home +lastMod: 2020-02-01 +--- +-- content/p1.md -- +--- +title: P1 +lastMod: 2020-03-01 +--- +CONTENT +-- content/p2.md -- +--- +title: P2 +lastMod: 2020-03-02 +--- +CONTENT +-- layouts/_default/single.html -- +Title: {{ .Title }}|Lastmod: {{ .Lastmod.Format "2006-01-02" }}|Content Start: {{ .Content }}:End: +-- layouts/index.html -- +Home: Lastmod: {{ .Lastmod.Format "2006-01-02" }}|site.LastChange: {{ site.LastChange.Format "2006-01-02" }}:End: + ` + + tt.Run(name, func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: files, + Running: true, + }, + ).Build() + + b.AssertFileContent("public/p1/index.html", "Title: P1|Lastmod: 2020-03-01") + b.AssertFileContent("public/index.html", "Home: Lastmod: 2020-02-01|site.LastChange: 2020-03-02") + b.AssertRenderCountPage(3) + + if changeSiteLastChanged { + b.EditFileReplace("content/p1.md", func(s string) string { return strings.ReplaceAll(s, "lastMod: 2020-03-01", "lastMod: 2020-05-01") }) + } else { + b.EditFileReplace("content/p1.md", func(s string) string { return strings.ReplaceAll(s, "CONTENT", "Content Changed") }) + } + + b.Build() + + if changeSiteLastChanged { + b.AssertFileContent("public/p1/index.html", "Title: P1|Lastmod: 2020-05-01") + b.AssertFileContent("public/index.html", "Home: Lastmod: 2020-02-01|site.LastChange: 2020-05-01") + b.AssertRenderCountPage(2) + } else { + b.AssertRenderCountPage(1) + b.AssertFileContent("public/p1/index.html", "Content Changed") + + } + }) + } - b.Assert(int(counters.contentRenderCounter), qt.Equals, 0) + tt.Run("Content Edit, Add, Rename, Remove", func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: twoPagesAndHomeDataInP1, + Running: true, + }, + ).Build() + + b.AssertFileContent("public/p1/index.html", "Hugo Rocks!") + b.AssertFileContent("public/index.html", `Home: Len site.Pages: 3|Len site.RegularPages: 2|Len site.AllPages: 3:End:`) + b.AssertRenderCountPage(3) + b.AssertBuildCountData(1) + b.AssertBuildCountLayouts(1) + + // Edit + b.EditFileReplace("content/p1.md", func(s string) string { return strings.ReplaceAll(s, "CONTENT", "Changed Content") }).Build() + + b.AssertFileContent("public/p1/index.html", "Changed Content") + b.AssertRenderCountPage(1) + b.AssertRenderCountContent(1) + b.AssertBuildCountData(1) + b.AssertBuildCountLayouts(1) + + b.AddFiles("content/p3.md", `ADDED`).Build() + b.AssertFileContent("public/index.html", `Home: Len site.Pages: 4|Len site.RegularPages: 3|Len site.AllPages: 4:End:`) + + // Remove + b.RemoveFiles("content/p1.md").Build() + + b.AssertFileContent("public/index.html", `Home: Len site.Pages: 3|Len site.RegularPages: 2|Len site.AllPages: 3:End:`) + b.AssertRenderCountPage(1) + b.AssertRenderCountContent(0) + b.AssertBuildCountData(1) + b.AssertBuildCountLayouts(1) + + // Rename + b.RenameFile("content/p2.md", "content/p2n.md").Build() + + b.AssertFileContent("public/index.html", `Home: Len site.Pages: 3|Len site.RegularPages: 2|Len site.AllPages: 3:End:`) + b.AssertFileContent("public/p2n/index.html", "NO DATA USED") + b.AssertRenderCountPage(2) + b.AssertRenderCountContent(1) + b.AssertBuildCountData(1) + b.AssertBuildCountLayouts(1) }) - t.Run("Page.Render, edit baseof", func(t *testing.T) { - b := createSiteBuilder(t) - - b.WithTemplatesAdded("index.html", ` -{{ $p := site.GetPage "prender.md" }} -prender: {{ $p.Title }}|{{ $p.Content }} - -`) - - b.Build(BuildCfg{}) + tt.Run("Data in page template", func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: twoPagesAndHomeDataInP1, + Running: true, + }, + ).Build() - b.AssertFileContent("public/index.html", ` - Render /prender/: Baseof:Single Main: Page 1|Mypartial1: Mypartial1|Mypartial3: Mypartial3:END -`) + b.AssertFileContent("public/p1/index.html", "Hugo Rocks!") + b.AssertFileContent("public/p2/index.html", "NO DATA USED") + b.AssertRenderCountPage(3) + b.AssertBuildCountData(1) + b.AssertBuildCountLayouts(1) - b.EditFiles("layouts/_default/baseof.html", `Baseof Edited:{{ block "main" . }}Baseof Main{{ end }}:END`) + b.EditFiles("data/mydata.toml", `hugo="Rules!"`).Build() - b.Build(BuildCfg{}) + b.AssertFileContent("public/p1/index.html", "Hugo Rules!") - b.AssertFileContent("public/index.html", ` -Render /prender/: Baseof Edited:Single Main: Page 1|Mypartial1: Mypartial1:END -`) + b.AssertBuildCountData(2) + b.AssertBuildCountLayouts(1) + b.AssertRenderCountPage(1) // We only need to re-render the one page that uses site.Data. }) - t.Run("Page.Render, edit partial in baseof", func(t *testing.T) { - b := createSiteBuilder(t) - - b.WithTemplatesAdded("index.html", ` -{{ $p := site.GetPage "prender.md" }} -prender: {{ $p.Title }}|{{ $p.Content }} - -`) - - b.Build(BuildCfg{}) - - b.AssertFileContent("public/index.html", ` - Render /prender/: Baseof:Single Main: Page 1|Mypartial1: Mypartial1|Mypartial3: Mypartial3:END -`) - - b.EditFiles("layouts/partials/mypartial3.html", `Mypartial3 Edited`) - - b.Build(BuildCfg{}) - - b.AssertFileContent("public/index.html", ` -Render /prender/: Baseof:Single Main: Page 1|Mypartial1: Mypartial1|Mypartial3: Mypartial3 Edited:END -`) + tt.Run("Data in shortcode", func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: twoPagesDataInShortcodeInP2HTMLAndRSS, + Running: true, + }, + ).Build() + + b.AssertFileContent("public/p2/index.html", "Hugo Rocks!") + b.AssertFileContent("public/p2/index.xml", "No Data") + + b.AssertRenderCountContent(3) // p2 (2 variants), p1 + b.AssertRenderCountPage(4) // p2 (2), p1 (2) + b.AssertBuildCountData(1) + b.AssertBuildCountLayouts(1) + + b.EditFiles("data/mydata.toml", `hugo="Rules!"`).Build() + + b.AssertFileContent("public/p2/index.html", "Hugo Rules!") + b.AssertFileContent("public/p2/index.xml", "No Data") + + // We only need to re-render the one page that uses the shortcode with site.Data (p2) + b.AssertRenderCountContent(1) + b.AssertRenderCountPage(1) + b.AssertBuildCountData(2) + b.AssertBuildCountLayouts(1) }) - t.Run("Edit RSS shortcode", func(t *testing.T) { - b := createSiteBuilder(t) + // TODO1 site date(s). - b.WithContent("output.md", `--- -title: Output -outputs: ["HTML", "AMP"] -layout: output ---- - -Content for Output. - -{{< output >}} - -`) - - b.WithTemplates( - "layouts/_default/output.html", `Output HTML: {{ .RelPermalink }}|{{ .Content }}`, - "layouts/_default/output.amp.html", `Output AMP: {{ .RelPermalink }}|{{ .Content }}`, - "layouts/shortcodes/output.html", `Output Shortcode HTML`, - "layouts/shortcodes/output.amp.html", `Output Shortcode AMP`) - - b.Build(BuildCfg{}) + tt.Run("Layout Shortcode", func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: twoPagesDataInShortcodeInP2HTMLAndRSS, + Running: true, + }, + ).Build() - b.AssertFileContent("public/output/index.html", ` -Output Shortcode HTML -`) - b.AssertFileContent("public/amp/output/index.html", ` -Output Shortcode AMP -`) + b.AssertBuildCountLayouts(1) + b.AssertBuildCountData(1) - b.EditFiles("layouts/shortcodes/output.amp.html", `Output Shortcode AMP Edited`) + b.EditFiles("layouts/shortcodes/foo.html", `Shortcode changed"`).Build() - b.Build(BuildCfg{}) - - b.AssertFileContent("public/amp/output/index.html", ` -Output Shortcode AMP Edited -`) + b.AssertFileContent("public/p2/index.html", "Shortcode changed") + b.AssertRenderCountContent(1) + b.AssertRenderCountPage(1) + b.AssertBuildCountLayouts(2) + b.AssertBuildCountData(1) }) -} -// Issues #7623 #7625 -func TestSitesRebuildOnFilesIncludedWithGetPage(t *testing.T) { - b := newTestSitesBuilder(t).Running() - b.WithContent("pages/p1.md", `--- -title: p1 ---- -P3: {{< GetPage "pages/p3" >}} -`) - - b.WithContent("pages/p2.md", `--- -title: p2 ---- -P4: {{< site_GetPage "pages/p4" >}} -P5: {{< site_GetPage "p5" >}} -P6: {{< dot_site_GetPage "p6" >}} -`) - - b.WithContent("pages/p3/index.md", "---\ntitle: p3\nheadless: true\n---\nP3 content") - b.WithContent("pages/p4/index.md", "---\ntitle: p4\nheadless: true\n---\nP4 content") - b.WithContent("pages/p5.md", "---\ntitle: p5\n---\nP5 content") - b.WithContent("pages/p6.md", "---\ntitle: p6\n---\nP6 content") - - b.WithTemplates( - "_default/single.html", `{{ .Content }}`, - "shortcodes/GetPage.html", ` -{{ $arg := .Get 0 }} -{{ $p := .Page.GetPage $arg }} -{{ $p.Content }} - `, - "shortcodes/site_GetPage.html", ` -{{ $arg := .Get 0 }} -{{ $p := site.GetPage $arg }} -{{ $p.Content }} - `, "shortcodes/dot_site_GetPage.html", ` -{{ $arg := .Get 0 }} -{{ $p := .Site.GetPage $arg }} -{{ $p.Content }} - `, - ) - - b.Build(BuildCfg{}) - - b.AssertFileContent("public/pages/p1/index.html", "P3 content") - b.AssertFileContent("public/pages/p2/index.html", `P4 content -P5 content -P6 content -`) + tt.Run("Data in Render Hook", func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: twoPagesDataInRenderHookInP2, + Running: true, + }, + ).Build() + + b.AssertFileContent("public/p2/index.html", "Hugo Rocks!") + b.AssertBuildCountData(1) + + b.EditFiles("data/mydata.toml", `hugo="Rules!"`).Build() + + b.AssertFileContent("public/p2/index.html", "Hugo Rules!") + // We only need to re-render the one page that contains a link (p2) + b.AssertRenderCountContent(1) + b.AssertRenderCountPage(1) + b.AssertBuildCountData(2) + }) - b.EditFiles("content/pages/p3/index.md", "---\ntitle: p3\n---\nP3 changed content") - b.EditFiles("content/pages/p4/index.md", "---\ntitle: p4\n---\nP4 changed content") - b.EditFiles("content/pages/p5.md", "---\ntitle: p5\n---\nP5 changed content") - b.EditFiles("content/pages/p6.md", "---\ntitle: p6\n---\nP6 changed content") + tt.Run("Layout Single", func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: twoPagesAndHomeWithBaseTemplate, + Running: true, + }, + ).Build() + + b.EditFiles("layouts/_default/single.html", `Single template changed"`).Build() + b.AssertFileContent("public/p1/index.html", "Single template changed") + b.AssertFileContent("public/p2/index.html", "Single template changed") + b.AssertRenderCountContent(0) // Reuse .Content + b.AssertRenderCountPage(2) // Re-render both pages using single.html + }) - b.Build(BuildCfg{}) + tt.Run("Layout List", func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: twoPagesAndHomeWithBaseTemplate, + Running: true, + }, + ).Build() + + b.EditFiles("layouts/_default/list.html", `List template changed"`).Build() + b.AssertFileContent("public/index.html", "List template changed") + b.AssertFileContent("public/p2/index.html", "Block Main Start:Single Main Start:p2: :End::End:") + b.AssertRenderCountContent(0) // Reuse .Content + b.AssertRenderCountPage(1) // Re-render home page only + }) - b.AssertFileContent("public/pages/p1/index.html", "P3 changed content") - b.AssertFileContent("public/pages/p2/index.html", `P4 changed content -P5 changed content -P6 changed content -`) + tt.Run("Layout Base", func(c *qt.C) { + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: twoPagesAndHomeWithBaseTemplate, + Running: true, + }, + ).Build() + + b.AssertFileContent("public/index.html", "Block Main Start:List Main Start:MyHome: :End:End:") + b.EditFiles("layouts/_default/baseof.html", `Block Main Changed Start:{{ block "main" . }}{{ end }}:End:"`).Build() + b.AssertFileContent("public/index.html", "Block Main Changed Start:List Main Start:MyHome: :End:End:") + b.AssertFileContent("public/p2/index.html", "Block Main Changed Start:Single Main Start:p2: :End::End:") + b.AssertRenderCountContent(0) // Reuse .Content + b.AssertRenderCountPage(3) // Re-render all 3 pages + }) } diff --git a/hugolib/hugo_smoke_test.go b/hugolib/hugo_smoke_test.go index 798504f0d14..fed1d23f62c 100644 --- a/hugolib/hugo_smoke_test.go +++ b/hugolib/hugo_smoke_test.go @@ -42,6 +42,103 @@ title: Page b.AssertFileContent("public/index.html", `Site: EN`) } +// TODO1 remove. +func TestSmokeNew(t *testing.T) { + c := qt.New(t) + + files := ` +-- config.toml -- +baseURL = "https://example.com" +disableKinds=["home", "taxonomy", "term", "sitemap", "robotsTXT"] +[languages] +[languages.en] +weight = 1 +title = "Title in English" +[languages.nn] +weight = 2 +title = "Tittel på nynorsk" + +[outputs] + section = ['HTML'] + page = ['HTML'] +-- content/mysection/_index.md -- +--- +title: "My Section" +--- +-- content/mysection/p1.md -- +-- content/mysection/mysectiontext.txt -- +Hello Section! +-- content/mysection/d1/mysectiontext.txt -- +Hello Section1! +-- content/mysection/mybundle1/index.md -- +--- +title: "My Bundle1" +--- +-- content/mysection/mybundle1/index.nn.md -- +--- +title: "My Bundle1 NN" +--- +-- content/mysection/mybundle2/index.en.md -- +--- +title: "My Bundle2" +--- +-- content/mysection/mybundle1/mybundletext.txt -- +Hello Bundle! +-- content/mysection/mybundle1/mybundletext.nn.txt -- +Hallo Bundle! +-- content/mysection/mybundle1/d1/mybundletext2.txt -- +Hello Bundle2! +-- layouts/_default/single.html -- +Single: {{ .Path }}|{{ .Lang }}|{{ .Title }}| +Resources: {{ range .Resources }}{{ .RelPermalink }}|{{ .Content }}|{{ end }} +{{ with .File }} +File1: Filename: {{ .Filename}}|Path: {{ .Path }}|Dir: {{ .Dir }}|Extension: {{ .Extension }}|Ext: {{ .Ext }}| +File2: Lang: {{ .Lang }}|LogicalName: {{ .LogicalName }}|BaseFileName: {{ .BaseFileName }}| +File3: TranslationBaseName: {{ .TranslationBaseName }}|ContentBaseName: {{ .ContentBaseName }}|Section: {{ .Section}}|UniqueID: {{ .UniqueID}}| +{{ end }} +-- layouts/_default/list.html -- +List: {{ .Path }}|{{ .Title }}| +Pages: {{ range .Pages }}{{ .RelPermalink }}|{{ end }} +Resources: {{ range .Resources }}{{ .RelPermalink }}|{{ end }} +` + + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + NeedsOsFS: false, + TxtarString: files, + }).Build() + + b.AssertFileContent("public/mysection/mybundle1/index.html", ` +Single: /mysection/mybundle1|en|My Bundle1| +Resources: /mysection/mybundle1/d1/mybundletext2.txt|Hello Bundle2!|/mysection/mybundle1/mybundletext.txt|Hello Bundle!| +`) + + b.AssertFileContent("public/nn/mysection/mybundle1/index.html", ` +Single: /mysection/mybundle1|nn|My Bundle1 NN| +Resources: /nn/mysection/mybundle1/d1/mybundletext2.txt|Hello Bundle2!|/nn/mysection/mybundle1/mybundletext.txt|Hallo Bundle!| +`) + + b.AssertFileContent("public/mysection/mybundle1/index.html", ` +File1: Filename: content/mysection/mybundle1/index.md|Path: mysection/mybundle1/index.md|Dir: mysection/mybundle1/|Extension: md|Ext: md| +File2: Lang: |LogicalName: index.md|BaseFileName: index| +File3: TranslationBaseName: index|ContentBaseName: mybundle1|Section: mysection|UniqueID: cfe009c850a931b15e6b90d9d1d2d08b| +`) + + b.AssertFileContent("public/mysection/mybundle2/index.html", ` +Single: /mysection/mybundle2|en|My Bundle2| +File1: Filename: content/mysection/mybundle2/index.en.md|Path: mysection/mybundle2/index.en.md|Dir: mysection/mybundle2/|Extension: md|Ext: md| +File2: Lang: en|LogicalName: index.en.md|BaseFileName: index.en| +File3: TranslationBaseName: index|ContentBaseName: mybundle2|Section: mysection|UniqueID: 514f2911b671de703d891fbc58e94792| +`) + + b.AssertFileContent("public/mysection/index.html", ` +List: /mysection|My Section| +Pages: /mysection/p1/|/mysection/mybundle1/|/mysection/mybundle2/| +Resources: /mysection/mysectiontext.txt| +`) +} + func TestSmoke(t *testing.T) { t.Parallel() @@ -229,6 +326,7 @@ Some **Markdown** in JSON shortcode. // .Render should use template/content from the current output format // even if that output format isn't configured for that page. + // TODO1 b.AssertFileContent( "public/index.json", "Render 0: page|JSON: LI|false|Params: Rocks!", @@ -264,9 +362,10 @@ Some **Markdown** in JSON shortcode. b.AssertFileContent("public/page/1/index.html", `rel="canonical" href="https://example.com/"`) b.AssertFileContent("public/page/2/index.html", "HTML: List|home|In English|", "Paginator: 2") - // 404 b.AssertFileContent("public/404.html", "404|404 Page not found") + // 404 TODO1 + // Sitemaps b.AssertFileContent("public/en/sitemap.xml", "https://example.com/blog/") b.AssertFileContent("public/no/sitemap.xml", `hreflang="no"`) diff --git a/hugolib/integrationtest_builder.go b/hugolib/integrationtest_builder.go new file mode 100644 index 00000000000..31f3e5fffdb --- /dev/null +++ b/hugolib/integrationtest_builder.go @@ -0,0 +1,442 @@ +package hugolib + +import ( + "bytes" + "fmt" + "os" + "path/filepath" + "strings" + "sync" + "testing" + + jww "github.com/spf13/jwalterweatherman" + + qt "github.com/frankban/quicktest" + "github.com/fsnotify/fsnotify" + "github.com/gohugoio/hugo/common/herrors" + "github.com/gohugoio/hugo/common/hexec" + "github.com/gohugoio/hugo/common/loggers" + "github.com/gohugoio/hugo/config" + "github.com/gohugoio/hugo/config/security" + "github.com/gohugoio/hugo/deps" + "github.com/gohugoio/hugo/helpers" + "github.com/gohugoio/hugo/htesting" + "github.com/gohugoio/hugo/hugofs" + "github.com/spf13/afero" + "golang.org/x/tools/txtar" +) + +func NewIntegrationTestBuilder(conf IntegrationTestConfig) *IntegrationTestBuilder { + data := txtar.Parse([]byte(conf.TxtarString)) + + c, ok := conf.T.(*qt.C) + if !ok { + c = qt.New(conf.T) + } + + if conf.NeedsOsFS { + doClean := true + tempDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-integration-test") + c.Assert(err, qt.IsNil) + conf.WorkingDir = filepath.Join(tempDir, conf.WorkingDir) + if doClean { + c.Cleanup(clean) + } + } + + return &IntegrationTestBuilder{ + Cfg: conf, + C: c, + data: data, + } +} + +// IntegrationTestBuilder is a (partial) rewrite of sitesBuilder. +// The main problem with the "old" one was that it was that the test data was often a little hidden, +// so it became hard to look at a test and determine what it should do, especially coming back to the +// test after a year or so. +type IntegrationTestBuilder struct { + *qt.C + + data *txtar.Archive + + fs *hugofs.Fs + H *HugoSites + + Cfg IntegrationTestConfig + + changedFiles []string + createdFiles []string + removedFiles []string + renamedFiles []string + + buildCount int + counters *testCounters + logBuff lockingBuffer + + builderInit sync.Once +} + +type lockingBuffer struct { + sync.Mutex + bytes.Buffer +} + +func (b *lockingBuffer) Write(p []byte) (n int, err error) { + b.Lock() + n, err = b.Buffer.Write(p) + b.Unlock() + return +} + +func (s *IntegrationTestBuilder) AssertLogContains(text string) { + s.Helper() + s.Assert(s.logBuff.String(), qt.Contains, text) +} + +func (s *IntegrationTestBuilder) AssertBuildCountData(count int) { + s.Helper() + s.Assert(s.H.init.data.InitCount(), qt.Equals, count) +} + +func (s *IntegrationTestBuilder) AssertBuildCountGitInfo(count int) { + s.Helper() + s.Assert(s.H.init.gitInfo.InitCount(), qt.Equals, count) +} + +func (s *IntegrationTestBuilder) AssertBuildCountLayouts(count int) { + s.Helper() + s.Assert(s.H.init.layouts.InitCount(), qt.Equals, count) +} + +func (s *IntegrationTestBuilder) AssertBuildCountTranslations(count int) { + s.Helper() + s.Assert(s.H.init.translations.InitCount(), qt.Equals, count) +} + +func (s *IntegrationTestBuilder) AssertFileContent(filename string, matches ...string) { + s.Helper() + content := strings.TrimSpace(s.FileContent(filename)) + for _, m := range matches { + lines := strings.Split(m, "\n") + for _, match := range lines { + match = strings.TrimSpace(match) + if match == "" || strings.HasPrefix(match, "#") { + continue + } + s.Assert(content, qt.Contains, match, qt.Commentf(content)) + } + } +} + +func (s *IntegrationTestBuilder) AssertDestinationExists(filename string, b bool) { + checker := qt.IsTrue + if !b { + checker = qt.IsFalse + } + s.Assert(s.destinationExists(filepath.Clean(filename)), checker) +} + +func (s *IntegrationTestBuilder) destinationExists(filename string) bool { + b, err := helpers.Exists(filename, s.fs.Destination) + if err != nil { + panic(err) + } + return b +} + +func (s *IntegrationTestBuilder) AssertIsFileError(err error) { + var ferr *herrors.ErrorWithFileContext + s.Assert(err, qt.ErrorAs, &ferr) +} + +func (s *IntegrationTestBuilder) AssertRenderCountContent(count int) { + s.Helper() + s.Assert(s.counters.contentRenderCounter, qt.Equals, uint64(count)) +} + +func (s *IntegrationTestBuilder) AssertRenderCountPage(count int) { + s.Helper() + s.Assert(s.counters.pageRenderCounter, qt.Equals, uint64(count)) +} + +func (s *IntegrationTestBuilder) Build() *IntegrationTestBuilder { + s.Helper() + _, err := s.BuildE() + if s.Cfg.Verbose { + fmt.Println(s.logBuff.String()) + } + s.Assert(err, qt.IsNil) + return s +} + +func (s *IntegrationTestBuilder) BuildE() (*IntegrationTestBuilder, error) { + s.Helper() + s.initBuilder() + err := s.build(BuildCfg{}) + return s, err +} + +func (s *IntegrationTestBuilder) Debug() { + fmt.Println("/public:") + helpers.PrintFs(s.fs.Destination, "public", os.Stdout) +} + +func (s *IntegrationTestBuilder) EditFileReplace(filename string, replacementFunc func(s string) string) *IntegrationTestBuilder { + absFilename := s.absFilename(filename) + b, err := afero.ReadFile(s.fs.Source, absFilename) + s.Assert(err, qt.IsNil) + s.changedFiles = append(s.changedFiles, absFilename) + oldContent := string(b) + s.writeSource(absFilename, replacementFunc(oldContent)) + return s +} + +func (s *IntegrationTestBuilder) EditFiles(filenameContent ...string) *IntegrationTestBuilder { + for i := 0; i < len(filenameContent); i += 2 { + filename, content := filepath.FromSlash(filenameContent[i]), filenameContent[i+1] + absFilename := s.absFilename(filename) + s.changedFiles = append(s.changedFiles, absFilename) + s.writeSource(absFilename, content) + } + return s +} + +func (s *IntegrationTestBuilder) AddFiles(filenameContent ...string) *IntegrationTestBuilder { + for i := 0; i < len(filenameContent); i += 2 { + filename, content := filepath.FromSlash(filenameContent[i]), filenameContent[i+1] + absFilename := s.absFilename(filename) + s.createdFiles = append(s.createdFiles, absFilename) + s.writeSource(absFilename, content) + } + return s +} + +func (s *IntegrationTestBuilder) RemoveFiles(filenames ...string) *IntegrationTestBuilder { + for _, filename := range filenames { + absFilename := s.absFilename(filename) + s.removedFiles = append(s.removedFiles, absFilename) + s.Assert(s.fs.Source.Remove(absFilename), qt.IsNil) + + } + + return s +} + +func (s *IntegrationTestBuilder) RenameFile(old, new string) *IntegrationTestBuilder { + absOldFilename := s.absFilename(old) + absNewFilename := s.absFilename(new) + s.renamedFiles = append(s.renamedFiles, absOldFilename) + s.createdFiles = append(s.createdFiles, absNewFilename) + s.Assert(s.fs.Source.Rename(absOldFilename, absNewFilename), qt.IsNil) + return s +} + +func (s *IntegrationTestBuilder) FileContent(filename string) string { + s.Helper() + filename = filepath.FromSlash(filename) + if !strings.HasPrefix(filename, s.Cfg.WorkingDir) { + filename = filepath.Join(s.Cfg.WorkingDir, filename) + } + return s.readDestination(s, s.fs, filename) +} + +func (s *IntegrationTestBuilder) initBuilder() { + s.builderInit.Do(func() { + var afs afero.Fs + if s.Cfg.NeedsOsFS { + afs = afero.NewOsFs() + } else { + afs = afero.NewMemMapFs() + } + + if s.Cfg.LogLevel == 0 { + s.Cfg.LogLevel = jww.LevelWarn + } + + logger := loggers.NewBasicLoggerForWriter(s.Cfg.LogLevel, &s.logBuff) + + fs := hugofs.NewFrom(afs, config.New()) + + for _, f := range s.data.Files { + filename := filepath.Join(s.Cfg.WorkingDir, f.Name) + s.Assert(afs.MkdirAll(filepath.Dir(filename), 0777), qt.IsNil) + s.Assert(afero.WriteFile(afs, filename, bytes.TrimSuffix(f.Data, []byte("\n")), 0666), qt.IsNil) + } + + cfg, _, err := LoadConfig( + ConfigSourceDescriptor{ + WorkingDir: s.Cfg.WorkingDir, + Fs: afs, + Logger: logger, + Environ: []string{}, + Filename: "config.toml", + }, + func(cfg config.Provider) error { + return nil + }, + ) + + s.Assert(err, qt.IsNil) + + cfg.Set("workingDir", s.Cfg.WorkingDir) + + depsCfg := deps.DepsCfg{Cfg: cfg, Fs: fs, Running: s.Cfg.Running, Logger: logger} + sites, err := NewHugoSites(depsCfg) + s.Assert(err, qt.IsNil) + + s.H = sites + s.fs = fs + + if s.Cfg.NeedsNpmInstall { + wd, _ := os.Getwd() + s.Assert(os.Chdir(s.Cfg.WorkingDir), qt.IsNil) + s.C.Cleanup(func() { os.Chdir(wd) }) + sc := security.DefaultConfig + sc.Exec.Allow = security.NewWhitelist("npm") + ex := hexec.New(sc) + command, err := ex.New("npm", "install") + s.Assert(err, qt.IsNil) + s.Assert(command.Run(), qt.IsNil) + + } + }) +} + +func (s *IntegrationTestBuilder) absFilename(filename string) string { + filename = filepath.FromSlash(filename) + if filepath.IsAbs(filename) { + return filename + } + if s.Cfg.WorkingDir != "" && !strings.HasPrefix(filename, s.Cfg.WorkingDir) { + filename = filepath.Join(s.Cfg.WorkingDir, filename) + } + return filename +} + +func (s *IntegrationTestBuilder) build(cfg BuildCfg) error { + s.Helper() + defer func() { + s.changedFiles = nil + s.createdFiles = nil + s.removedFiles = nil + s.renamedFiles = nil + }() + + changeEvents := s.changeEvents() + s.logBuff.Reset() + s.counters = &testCounters{} + cfg.testCounters = s.counters + + if s.buildCount > 0 && (len(changeEvents) == 0) { + return nil + } + + s.buildCount++ + + err := s.H.Build(cfg, changeEvents...) + if err != nil { + return err + } + logErrorCount := s.H.NumLogErrors() + if logErrorCount > 0 { + return fmt.Errorf("logged %d error(s): %s", logErrorCount, s.logBuff.String()) + } + + return nil +} + +func (s *IntegrationTestBuilder) changeEvents() []fsnotify.Event { + var events []fsnotify.Event + for _, v := range s.removedFiles { + events = append(events, fsnotify.Event{ + Name: v, + Op: fsnotify.Remove, + }) + } + for _, v := range s.renamedFiles { + events = append(events, fsnotify.Event{ + Name: v, + Op: fsnotify.Rename, + }) + } + for _, v := range s.changedFiles { + events = append(events, fsnotify.Event{ + Name: v, + Op: fsnotify.Write, + }) + } + for _, v := range s.createdFiles { + events = append(events, fsnotify.Event{ + Name: v, + Op: fsnotify.Create, + }) + } + + return events +} + +func (s *IntegrationTestBuilder) readDestination(t testing.TB, fs *hugofs.Fs, filename string) string { + t.Helper() + return s.readFileFromFs(t, fs.Destination, filename) +} + +func (s *IntegrationTestBuilder) readFileFromFs(t testing.TB, fs afero.Fs, filename string) string { + t.Helper() + filename = filepath.Clean(filename) + b, err := afero.ReadFile(fs, filename) + if err != nil { + // Print some debug info + hadSlash := strings.HasPrefix(filename, helpers.FilePathSeparator) + start := 0 + if hadSlash { + start = 1 + } + end := start + 1 + + parts := strings.Split(filename, helpers.FilePathSeparator) + if parts[start] == "work" { + end++ + } + + s.Assert(err, qt.IsNil) + + } + return string(b) +} + +func (s *IntegrationTestBuilder) writeSource(filename, content string) { + s.Helper() + s.writeToFs(s.fs.Source, filename, content) +} + +func (s *IntegrationTestBuilder) writeToFs(fs afero.Fs, filename, content string) { + s.Helper() + if err := afero.WriteFile(fs, filepath.FromSlash(filename), []byte(content), 0755); err != nil { + s.Fatalf("Failed to write file: %s", err) + } +} + +type IntegrationTestConfig struct { + T testing.TB + + // The files to use on txtar format, see + // https://pkg.go.dev/golang.org/x/exp/cmd/txtar + TxtarString string + + // Whether to simulate server mode. + Running bool + + // Will print the log buffer after the build + Verbose bool + + LogLevel jww.Threshold + + // Whether it needs the real file system (e.g. for js.Build tests). + NeedsOsFS bool + + // Whether to run npm install before Build. + NeedsNpmInstall bool + + WorkingDir string +} diff --git a/hugolib/js_test.go b/hugolib/js_test.go deleted file mode 100644 index aaffee27bd2..00000000000 --- a/hugolib/js_test.go +++ /dev/null @@ -1,218 +0,0 @@ -// Copyright 2020 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 ( - "fmt" - "os" - "path/filepath" - "runtime" - "testing" - - "github.com/gohugoio/hugo/config" - - "github.com/gohugoio/hugo/htesting" - - qt "github.com/frankban/quicktest" - - "github.com/gohugoio/hugo/hugofs" - - "github.com/gohugoio/hugo/common/loggers" -) - -func TestJSBuildWithNPM(t *testing.T) { - if !htesting.IsCI() { - t.Skip("skip (relative) long running modules test when running locally") - } - - wd, _ := os.Getwd() - defer func() { - os.Chdir(wd) - }() - - c := qt.New(t) - - mainJS := ` - import "./included"; - import { toCamelCase } from "to-camel-case"; - - console.log("main"); - console.log("To camel:", toCamelCase("space case")); -` - includedJS := ` - console.log("included"); - - ` - - jsxContent := ` -import * as React from 'react' -import * as ReactDOM from 'react-dom' - - ReactDOM.render( -

Hello, world!

, - document.getElementById('root') - ); -` - - tsContent := `function greeter(person: string) { - return "Hello, " + person; -} - -let user = [0, 1, 2]; - -document.body.textContent = greeter(user);` - - packageJSON := `{ - "scripts": {}, - - "dependencies": { - "to-camel-case": "1.0.0" - } -} -` - - workDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-test-js-npm") - c.Assert(err, qt.IsNil) - defer clean() - - v := config.New() - v.Set("workingDir", workDir) - v.Set("disableKinds", []string{"taxonomy", "term", "page"}) - b := newTestSitesBuilder(t).WithLogger(loggers.NewWarningLogger()) - - // Need to use OS fs for this. - b.Fs = hugofs.NewDefault(v) - b.WithWorkingDir(workDir) - b.WithViper(v) - b.WithContent("p1.md", "") - - b.WithTemplates("index.html", ` -{{ $options := dict "minify" false "externals" (slice "react" "react-dom") }} -{{ $js := resources.Get "js/main.js" | js.Build $options }} -JS: {{ template "print" $js }} -{{ $jsx := resources.Get "js/myjsx.jsx" | js.Build $options }} -JSX: {{ template "print" $jsx }} -{{ $ts := resources.Get "js/myts.ts" | js.Build (dict "sourcemap" "inline")}} -TS: {{ template "print" $ts }} -{{ $ts2 := resources.Get "js/myts.ts" | js.Build (dict "sourcemap" "external" "TargetPath" "js/myts2.js")}} -TS2: {{ template "print" $ts2 }} -{{ define "print" }}RelPermalink: {{.RelPermalink}}|MIME: {{ .MediaType }}|Content: {{ .Content | safeJS }}{{ end }} - -`) - - jsDir := filepath.Join(workDir, "assets", "js") - fmt.Println(workDir) - b.Assert(os.MkdirAll(jsDir, 0777), qt.IsNil) - b.Assert(os.Chdir(workDir), qt.IsNil) - b.WithSourceFile("package.json", packageJSON) - b.WithSourceFile("assets/js/main.js", mainJS) - b.WithSourceFile("assets/js/myjsx.jsx", jsxContent) - b.WithSourceFile("assets/js/myts.ts", tsContent) - - b.WithSourceFile("assets/js/included.js", includedJS) - - cmd := b.NpmInstall() - err = cmd.Run() - b.Assert(err, qt.IsNil) - - b.Build(BuildCfg{}) - - b.AssertFileContent("public/js/myts.js", `//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJz`) - b.AssertFileContent("public/js/myts2.js.map", `"version": 3,`) - b.AssertFileContent("public/index.html", ` -console.log("included"); -if (hasSpace.test(string)) -var React = __toESM(__require("react")); -function greeter(person) { -`) -} - -func TestJSBuild(t *testing.T) { - if !htesting.IsCI() { - t.Skip("skip (relative) long running modules test when running locally") - } - - if runtime.GOOS == "windows" { - // TODO(bep) we really need to get this working on Travis. - t.Skip("skip npm test on Windows") - } - - wd, _ := os.Getwd() - defer func() { - os.Chdir(wd) - }() - - c := qt.New(t) - - workDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-test-js-mod") - c.Assert(err, qt.IsNil) - defer clean() - - tomlConfig := fmt.Sprintf(` -baseURL = "https://example.org" -workingDir = %q - -disableKinds = ["page", "section", "term", "taxonomy"] - -[module] -[[module.imports]] -path="github.com/gohugoio/hugoTestProjectJSModImports" - - - -`, workDir) - - b := newTestSitesBuilder(t) - b.Fs = hugofs.NewDefault(config.New()) - b.WithWorkingDir(workDir).WithConfigFile("toml", tomlConfig).WithLogger(loggers.NewInfoLogger()) - b.WithSourceFile("go.mod", `module github.com/gohugoio/tests/testHugoModules - -go 1.15 - -require github.com/gohugoio/hugoTestProjectJSModImports v0.9.0 // indirect - -`) - - b.WithContent("p1.md", "").WithNothingAdded() - - b.WithSourceFile("package.json", `{ - "dependencies": { - "date-fns": "^2.16.1" - } -}`) - - b.Assert(os.Chdir(workDir), qt.IsNil) - cmd := b.NpmInstall() - err = cmd.Run() - b.Assert(err, qt.IsNil) - - b.Build(BuildCfg{}) - - b.AssertFileContent("public/js/main.js", ` -greeting: "greeting configured in mod2" -Hello1 from mod1: $ -return "Hello2 from mod1"; -var Hugo = "Rocks!"; -Hello3 from mod2. Date from date-fns: ${today} -Hello from lib in the main project -Hello5 from mod2. -var myparam = "Hugo Rocks!"; -shim cwd -`) - - // React JSX, verify the shimming. - b.AssertFileContent("public/js/like.js", `@v0.9.0/assets/js/shims/react.js -module.exports = window.ReactDOM; -`) -} diff --git a/hugolib/language_content_dir_test.go b/hugolib/language_content_dir_test.go index 117fdfb1431..0db57a03408 100644 --- a/hugolib/language_content_dir_test.go +++ b/hugolib/language_content_dir_test.go @@ -16,13 +16,14 @@ package hugolib import ( "fmt" "os" + + "github.com/gohugoio/hugo/resources/page/pagekinds" + "path/filepath" "testing" "github.com/spf13/cast" - "github.com/gohugoio/hugo/resources/page" - qt "github.com/frankban/quicktest" ) @@ -311,7 +312,7 @@ Content. b.AssertFileContent("/my/project/public/sv/sect/mybundle/logo.png", "PNG Data") b.AssertFileContent("/my/project/public/nn/sect/mybundle/logo.png", "PNG Data") - nnSect := nnSite.getPage(page.KindSection, "sect") + nnSect := nnSite.getPage(pagekinds.Section, "sect") c.Assert(nnSect, qt.Not(qt.IsNil)) c.Assert(len(nnSect.Pages()), qt.Equals, 12) nnHome, _ := nnSite.Info.Home() diff --git a/hugolib/page.go b/hugolib/page.go index d2d96204408..a4fc18466ae 100644 --- a/hugolib/page.go +++ b/hugolib/page.go @@ -15,13 +15,13 @@ package hugolib import ( "bytes" + "context" "fmt" "html/template" "os" "path" "path/filepath" "sort" - "strings" "github.com/mitchellh/mapstructure" @@ -31,8 +31,6 @@ import ( "github.com/gohugoio/hugo/tpl" - "github.com/gohugoio/hugo/hugofs/files" - "github.com/bep/gitmap" "github.com/gohugoio/hugo/helpers" @@ -46,7 +44,7 @@ import ( "github.com/gohugoio/hugo/output" "github.com/gohugoio/hugo/media" - "github.com/gohugoio/hugo/source" + "github.com/gohugoio/hugo/resources/page/pagekinds" "github.com/spf13/cast" "github.com/gohugoio/hugo/common/collections" @@ -58,9 +56,10 @@ import ( ) var ( - _ page.Page = (*pageState)(nil) - _ collections.Grouper = (*pageState)(nil) - _ collections.Slicer = (*pageState)(nil) + _ page.Page = (*pageState)(nil) + _ collections.Grouper = (*pageState)(nil) + _ collections.Slicer = (*pageState)(nil) + _ identity.DependencyManagerProvider = (*pageState)(nil) ) var ( @@ -78,7 +77,7 @@ type pageContext interface { posOffset(offset int) text.Position wrapError(err error) error getContentConverter() converter.Converter - addDependency(dep identity.Provider) + addDependency(dep identity.Identity) } // wrapErr adds some context to the given error if possible. @@ -94,18 +93,6 @@ type pageSiteAdapter struct { s *Site } -func (pa pageSiteAdapter) GetPageWithTemplateInfo(info tpl.Info, ref string) (page.Page, error) { - p, err := pa.GetPage(ref) - if p != nil { - // Track pages referenced by templates/shortcodes - // when in server mode. - if im, ok := info.(identity.Manager); ok { - im.Add(p) - } - } - return p, err -} - func (pa pageSiteAdapter) GetPage(ref string) (page.Page, error) { p, err := pa.s.getPageNew(pa.p, ref) if p == nil { @@ -120,6 +107,7 @@ func (pa pageSiteAdapter) GetPage(ref string) (page.Page, error) { type pageState struct { // This slice will be of same length as the number of global slice of output // formats (for all sites). + // TODO1 update doc pageOutputs []*pageOutput // This will be shifted out when we start to render a new output format. @@ -144,8 +132,8 @@ func (p *pageState) Eq(other interface{}) bool { return p == pp } -func (p *pageState) GetIdentity() identity.Identity { - return identity.NewPathIdentity(files.ComponentFolderContent, filepath.FromSlash(p.Pathc())) +func (p *pageState) IdentifierBase() interface{} { + return p.Path() } func (p *pageState) GitInfo() *gitmap.GitInfo { @@ -155,23 +143,12 @@ func (p *pageState) GitInfo() *gitmap.GitInfo { // GetTerms gets the terms defined on this page in the given taxonomy. // The pages returned will be ordered according to the front matter. func (p *pageState) GetTerms(taxonomy string) page.Pages { - if p.treeRef == nil { - return nil - } - - m := p.s.pageMap - - taxonomy = strings.ToLower(taxonomy) - prefix := cleanSectionTreeKey(taxonomy) - self := strings.TrimPrefix(p.treeRef.key, "/") - var pas page.Pages - - m.taxonomies.WalkQuery(pageMapQuery{Prefix: prefix}, func(s string, n *contentNode) bool { - key := s + self - if tn, found := m.taxonomyEntries.Get(key); found { - vi := tn.(*contentNode).viewInfo - pas = append(pas, pageWithOrdinal{pageState: n.p, ordinal: vi.ordinal}) + taxonomyKey := cleanTreeKey(taxonomy) + p.s.pageMap.WalkBranchesPrefix(taxonomyKey+"/", func(s string, b *contentBranchNode) bool { + v, found := b.refs[p] + if found { + pas = append(pas, pageWithOrdinal{pageState: b.n.p, ordinal: v.ordinal}) } return false }) @@ -185,93 +162,41 @@ func (p *pageState) MarshalJSON() ([]byte, error) { return page.MarshalPageToJSON(p) } -func (p *pageState) getPages() page.Pages { - b := p.bucket - if b == nil { - return nil - } - return b.getPages() -} - -func (p *pageState) getPagesRecursive() page.Pages { - b := p.bucket - if b == nil { - return nil +func (p *pageState) RegularPagesRecursive() page.Pages { + switch p.Kind() { + case pagekinds.Section, pagekinds.Home: + return p.bucket.getRegularPagesRecursive() + default: + return p.RegularPages() } - return b.getPagesRecursive() } -func (p *pageState) getPagesAndSections() page.Pages { - b := p.bucket - if b == nil { - return nil +func (p *pageState) RegularPages() page.Pages { + switch p.Kind() { + case pagekinds.Page: + case pagekinds.Section, pagekinds.Home, pagekinds.Taxonomy: + return p.bucket.getRegularPages() + case pagekinds.Term: + return p.bucket.getRegularPagesInTerm() + default: + return p.s.RegularPages() } - return b.getPagesAndSections() -} - -func (p *pageState) RegularPagesRecursive() page.Pages { - p.regularPagesRecursiveInit.Do(func() { - var pages page.Pages - switch p.Kind() { - case page.KindSection: - pages = p.getPagesRecursive() - default: - pages = p.RegularPages() - } - p.regularPagesRecursive = pages - }) - return p.regularPagesRecursive -} - -func (p *pageState) PagesRecursive() page.Pages { return nil } -func (p *pageState) RegularPages() page.Pages { - p.regularPagesInit.Do(func() { - var pages page.Pages - - switch p.Kind() { - case page.KindPage: - case page.KindSection, page.KindHome, page.KindTaxonomy: - pages = p.getPages() - case page.KindTerm: - all := p.Pages() - for _, p := range all { - if p.IsPage() { - pages = append(pages, p) - } - } - default: - pages = p.s.RegularPages() - } - - p.regularPages = pages - }) - - return p.regularPages -} - func (p *pageState) Pages() page.Pages { - p.pagesInit.Do(func() { - var pages page.Pages - - switch p.Kind() { - case page.KindPage: - case page.KindSection, page.KindHome: - pages = p.getPagesAndSections() - case page.KindTerm: - pages = p.bucket.getTaxonomyEntries() - case page.KindTaxonomy: - pages = p.bucket.getTaxonomies() - default: - pages = p.s.Pages() - } - - p.pages = pages - }) - - return p.pages + switch p.Kind() { + case pagekinds.Page: + case pagekinds.Section, pagekinds.Home: + return p.bucket.getPagesAndSections() + case pagekinds.Term: + return p.bucket.getPagesInTerm() + case pagekinds.Taxonomy: + return p.bucket.getTaxonomies() + default: + return p.s.Pages() + } + return nil } // RawContent returns the un-rendered source content without @@ -335,8 +260,8 @@ func (p *pageState) Site() page.Site { } func (p *pageState) String() string { - if sourceRef := p.sourceRef(); sourceRef != "" { - return fmt.Sprintf("Page(%s)", sourceRef) + if pth := p.Path(); pth != "" { + return fmt.Sprintf("Page(%s)", helpers.AddLeadingSlash(filepath.ToSlash(pth))) } return fmt.Sprintf("Page(%q)", p.Title()) } @@ -356,7 +281,7 @@ func (p *pageState) TranslationKey() string { p.translationKeyInit.Do(func() { if p.m.translationKey != "" { p.translationKey = p.Kind() + "/" + p.m.translationKey - } else if p.IsPage() && !p.File().IsZero() { + } else if p.IsPage() && p.File() != nil { p.translationKey = path.Join(p.Kind(), filepath.ToSlash(p.File().Dir()), p.File().TranslationBaseName()) } else if p.IsNode() { p.translationKey = path.Join(p.Kind(), p.SectionsPath()) @@ -410,7 +335,6 @@ func (p *pageState) createRenderHooks(f output.Format) (hooks.Renderers, error) if templFound { renderers.LinkRenderer = hookRenderer{ templateHandler: p.s.Tmpl(), - SearchProvider: templ.(identity.SearchProvider), templ: templ, } } @@ -423,7 +347,7 @@ func (p *pageState) createRenderHooks(f output.Format) (hooks.Renderers, error) if templFound { renderers.ImageRenderer = hookRenderer{ templateHandler: p.s.Tmpl(), - SearchProvider: templ.(identity.SearchProvider), + Identity: templ.(tpl.Info), templ: templ, } } @@ -436,7 +360,7 @@ func (p *pageState) createRenderHooks(f output.Format) (hooks.Renderers, error) if templFound { renderers.HeadingRenderer = hookRenderer{ templateHandler: p.s.Tmpl(), - SearchProvider: templ.(identity.SearchProvider), + Identity: templ.(tpl.Info), templ: templ, } } @@ -450,13 +374,16 @@ func (p *pageState) getLayoutDescriptor() output.LayoutDescriptor { sections := p.SectionsEntries() switch p.Kind() { - case page.KindSection: + case pagekinds.Section: if len(sections) > 0 { section = sections[0] } - case page.KindTaxonomy, page.KindTerm: - b := p.getTreeRef().n - section = b.viewInfo.name.singular + case pagekinds.Taxonomy, pagekinds.Term: + v, ok := p.getTreeRef().GetNode().traits.(viewInfoTrait) + if !ok || v.ViewInfo() == nil { + panic(fmt.Sprintf("no view info set for %q", p.getTreeRef().GetNode().Key())) + } + section = v.ViewInfo().name.singular default: } @@ -490,10 +417,12 @@ func (p *pageState) resolveTemplate(layouts ...string) (tpl.Template, bool, erro d.LayoutOverride = true } - return p.s.Tmpl().LookupLayout(d, f) + tp, found, err := p.s.Tmpl().LookupLayout(d, f) + + return tp, found, err } -// This is serialized +// This is serialized. func (p *pageState) initOutputFormat(isRenderingSite bool, idx int) error { if err := p.shiftToOutputFormat(isRenderingSite, idx); err != nil { return err @@ -651,19 +580,19 @@ func (p *pageState) RenderString(args ...interface{}) (template.HTML, error) { return template.HTML(string(b)), nil } -func (p *pageState) addDependency(dep identity.Provider) { - if !p.s.running() || p.pageOutput.cp == nil { +// TODO1 check if this can be removed entirely? +func (p *pageState) addDependency(dep identity.Identity) { + if !p.s.running() { return } - p.pageOutput.cp.dependencyTracker.Add(dep) + p.pageOutput.dependencyManager.AddIdentity(dep) } -func (p *pageState) RenderWithTemplateInfo(info tpl.Info, layout ...string) (template.HTML, error) { - p.addDependency(info) - return p.Render(layout...) +func (p *pageState) GetDependencyManager() identity.Manager { + return p.getTreeRef().GetNode().GetDependencyManager() } -func (p *pageState) Render(layout ...string) (template.HTML, error) { +func (p *pageState) Render(ctx context.Context, layout ...string) (template.HTML, error) { templ, found, err := p.resolveTemplate(layout...) if err != nil { return "", p.wrapError(err) @@ -673,8 +602,7 @@ func (p *pageState) Render(layout ...string) (template.HTML, error) { return "", nil } - p.addDependency(templ.(tpl.Info)) - res, err := executeToString(p.s.Tmpl(), templ, p) + res, err := executeToString(ctx, p.s.Tmpl(), templ, p) if err != nil { return "", p.wrapError(errors.Wrapf(err, "failed to execute template %q v", layout)) } @@ -688,7 +616,7 @@ func (p *pageState) wrapError(err error) error { return err } var filename string - if !p.File().IsZero() { + if p.File() != nil { filename = p.File().Filename() } @@ -719,7 +647,9 @@ func (p *pageState) getContentConverter() converter.Converter { return p.m.contentConverter } -func (p *pageState) mapContent(bucket *pagesMapBucket, meta *pageMeta) error { +func (p *pageState) mapContent(meta *pageMeta) (map[string]interface{}, error) { + var result map[string]interface{} + s := p.shortcodeState rn := &pageContentMap{ @@ -736,7 +666,6 @@ func (p *pageState) mapContent(bucket *pagesMapBucket, meta *pageMeta) error { // … it's safe to keep some "global" state var currShortcode shortcode var ordinal int - var frontMatterSet bool Loop: for { @@ -746,31 +675,20 @@ Loop: case it.Type == pageparser.TypeIgnore: case it.IsFrontMatter(): f := pageparser.FormatFromFrontMatterType(it.Type) - m, err := metadecoders.Default.UnmarshalToMap(it.Val, f) + var err error + result, err = metadecoders.Default.UnmarshalToMap(it.Val, f) if err != nil { if fe, ok := err.(herrors.FileError); ok { - return herrors.ToFileErrorWithOffset(fe, iter.LineNumber()-1) + return nil, herrors.ToFileErrorWithOffset(fe, iter.LineNumber()-1) } else { - return err + return nil, err } } - if err := meta.setMetadata(bucket, p, m); err != nil { - return err - } - - frontMatterSet = true - next := iter.Peek() if !next.IsDone() { p.source.posMainContent = next.Pos } - - if !p.s.shouldBuild(p) { - // Nothing more to do. - return nil - } - case it.Type == pageparser.TypeLeadSummaryDivider: posBody := -1 f := func(item pageparser.Item) bool { @@ -805,7 +723,7 @@ Loop: currShortcode, err := s.extractShortcode(ordinal, 0, iter) if err != nil { - return fail(errors.Wrap(err, "failed to extract shortcode"), it) + return nil, fail(errors.Wrap(err, "failed to extract shortcode"), it) } currShortcode.pos = it.Pos @@ -840,24 +758,16 @@ Loop: case it.IsError(): err := fail(errors.WithStack(errors.New(it.ValStr())), it) currShortcode.err = err - return err + return nil, err default: rn.AddBytes(it) } } - if !frontMatterSet { - // Page content without front matter. Assign default front matter from - // cascades etc. - if err := meta.setMetadata(bucket, p, nil); err != nil { - return err - } - } - p.cmap = rn - return nil + return result, nil } func (p *pageState) errorf(err error, format string, a ...interface{}) error { @@ -891,12 +801,12 @@ func (p *pageState) parseError(err error, input []byte, offset int) error { } func (p *pageState) pathOrTitle() string { - if !p.File().IsZero() { + if p.File() != nil { return p.File().Filename() } - if p.Pathc() != "" { - return p.Pathc() + if p.Path() != "" { + return p.Path() } return p.Title() @@ -965,7 +875,7 @@ func (p *pageState) shiftToOutputFormat(isRenderingSite bool, idx int) error { if cp == nil { var err error - cp, err = newPageContentOutput(p, p.pageOutput) + cp, err = newPageContentOutput(p.pageOutput) if err != nil { return err } @@ -977,48 +887,6 @@ func (p *pageState) shiftToOutputFormat(isRenderingSite bool, idx int) error { return nil } -// sourceRef returns the reference used by GetPage and ref/relref shortcodes to refer to -// this page. It is prefixed with a "/". -// -// For pages that have a source file, it is returns the path to this file as an -// absolute path rooted in this site's content dir. -// For pages that do not (sections without content page etc.), it returns the -// virtual path, consistent with where you would add a source file. -func (p *pageState) sourceRef() string { - if !p.File().IsZero() { - sourcePath := p.File().Path() - if sourcePath != "" { - return "/" + filepath.ToSlash(sourcePath) - } - } - - if len(p.SectionsEntries()) > 0 { - // no backing file, return the virtual source path - return "/" + p.SectionsPath() - } - - return "" -} - -func (s *Site) sectionsFromFile(fi source.File) []string { - dirname := fi.Dir() - - dirname = strings.Trim(dirname, helpers.FilePathSeparator) - if dirname == "" { - return nil - } - parts := strings.Split(dirname, helpers.FilePathSeparator) - - if fii, ok := fi.(*fileInfo); ok { - if len(parts) > 0 && fii.FileInfo().Meta().Classifier == files.ContentClassLeaf { - // my-section/mybundle/index.md => my-section - return parts[:len(parts)-1] - } - } - - return parts -} - var ( _ page.Page = (*pageWithOrdinal)(nil) _ collections.Order = (*pageWithOrdinal)(nil) diff --git a/hugolib/page__common.go b/hugolib/page__common.go index e718721f7fc..09f5d6269a3 100644 --- a/hugolib/page__common.go +++ b/hugolib/page__common.go @@ -27,11 +27,11 @@ import ( ) type treeRefProvider interface { - getTreeRef() *contentTreeRef + getTreeRef() contentTreeRefProvider } -func (p *pageCommon) getTreeRef() *contentTreeRef { - return p.treeRef +func (p *pageCommon) getTreeRef() contentTreeRefProvider { + return p.m.treeRef } type nextPrevProvider interface { @@ -54,8 +54,7 @@ type pageCommon struct { s *Site m *pageMeta - bucket *pagesMapBucket - treeRef *contentTreeRef + bucket *pagesMapBucket // Set for the branch nodes. // Lazily initialized dependencies. init *lazy.Init @@ -79,7 +78,7 @@ type pageCommon struct { page.RefProvider page.ShortcodeInfoProvider page.SitesProvider - page.DeprecatedWarningPageMethods + // Removed in 0.93.0, keep this a little in case we need to re-introduce it. page.DeprecatedWarningPageMethods page.TranslationsProvider page.TreeProvider resource.LanguageProvider @@ -101,6 +100,8 @@ type pageCommon struct { // The parsed page content. pageContent + shortcodeState *shortcodeHandler + // Set if feature enabled and this is in a Git repo. gitInfo *gitmap.GitInfo @@ -114,9 +115,6 @@ type pageCommon struct { // Internal use page.InternalDependencies - // The children. Regular pages will have none. - *pagePages - // Any bundled resources resources resource.Resources resourcesInit sync.Once @@ -129,19 +127,15 @@ type pageCommon struct { translationKey string translationKeyInit sync.Once - // Will only be set for bundled pages. - parent *pageState - - // Set in fast render mode to force render a given page. - forceRender bool + buildState int } -type pagePages struct { - pagesInit sync.Once - pages page.Pages +func (p *pageCommon) IdentifierBase() interface{} { + return p.Path() +} - regularPagesInit sync.Once - regularPages page.Pages - regularPagesRecursiveInit sync.Once - regularPagesRecursive page.Pages +// IsStale returns whether the Page is stale and needs a full rebuild. +func (p *pageCommon) IsStale() bool { + // TODO1 MarkStale + return p.resources.IsStale() } diff --git a/hugolib/page__content.go b/hugolib/page__content.go index c08ac67af4e..d366ffe8a5d 100644 --- a/hugolib/page__content.go +++ b/hugolib/page__content.go @@ -26,6 +26,8 @@ var ( internalSummaryDividerPre = []byte("\n\n" + internalSummaryDividerBase + "\n\n") ) +var zeroContent = pageContent{} + // The content related items on a Page. type pageContent struct { selfLayout string @@ -33,8 +35,6 @@ type pageContent struct { cmap *pageContentMap - shortcodeState *shortcodeHandler - source rawPageContent } diff --git a/hugolib/page__data.go b/hugolib/page__data.go index 7ab66850341..fd00b5ac4ce 100644 --- a/hugolib/page__data.go +++ b/hugolib/page__data.go @@ -16,6 +16,10 @@ package hugolib import ( "sync" + "github.com/gohugoio/hugo/resources/page/pagekinds" + + "github.com/gohugoio/hugo/common/herrors" + "github.com/gohugoio/hugo/resources/page" ) @@ -27,28 +31,29 @@ type pageData struct { } func (p *pageData) Data() interface{} { + defer herrors.Recover() p.dataInit.Do(func() { p.data = make(page.Data) - if p.Kind() == page.KindPage { + if p.Kind() == pagekinds.Page { return } switch p.Kind() { - case page.KindTerm: - b := p.treeRef.n - name := b.viewInfo.name - termKey := b.viewInfo.termKey + case pagekinds.Term: + b := p.m.treeRef.GetNode() + name := b.traits.(viewInfoTrait).ViewInfo().name + termKey := b.traits.(viewInfoTrait).ViewInfo().term taxonomy := p.s.Taxonomies()[name.plural].Get(termKey) p.data[name.singular] = taxonomy p.data["Singular"] = name.singular p.data["Plural"] = name.plural - p.data["Term"] = b.viewInfo.term() - case page.KindTaxonomy: - b := p.treeRef.n - name := b.viewInfo.name + p.data["Term"] = b.traits.(viewInfoTrait).ViewInfo().Term() + case pagekinds.Taxonomy: + b := p.m.treeRef.GetNode() + name := b.traits.(viewInfoTrait).ViewInfo().name p.data["Singular"] = name.singular p.data["Plural"] = name.plural diff --git a/hugolib/page__meta.go b/hugolib/page__meta.go index 6a10b1d36a8..1c8ed68083c 100644 --- a/hugolib/page__meta.go +++ b/hugolib/page__meta.go @@ -22,9 +22,10 @@ import ( "sync" "time" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gohugoio/hugo/langs" - "github.com/gobuffalo/flect" "github.com/gohugoio/hugo/markup/converter" "github.com/gohugoio/hugo/hugofs/files" @@ -49,7 +50,15 @@ import ( var cjkRe = regexp.MustCompile(`\p{Han}|\p{Hangul}|\p{Hiragana}|\p{Katakana}`) +var _ resource.Dated = (*pageMeta)(nil) + type pageMeta struct { + // Reference to this node in the content map. + treeRef contentTreeRefProvider + + // Same as treeRef, but embeds some common Page methods directly. + contentNodeInfoProvider + // kind is the discriminator that identifies the different page types // in the different page collections. This can, as an example, be used // to to filter regular pages, find sections etc. @@ -57,12 +66,7 @@ type pageMeta struct { // page, home, section, taxonomy and term. // It is of string type to make it easy to reason about in // the templates. - kind string - - // This is a standalone page not part of any page collection. These - // include sitemap, robotsTXT and similar. It will have no pageOutputs, but - // a fixed pageOutput. - standalone bool + contentKindProvider draft bool // Only published when running with -D flag buildConfig pagemeta.BuildConfig @@ -77,8 +81,6 @@ type pageMeta struct { summary string - resourcePath string - weight int markup string @@ -96,7 +98,7 @@ type pageMeta struct { urlPaths pagemeta.URLPath - resource.Dates + pageMetaDates // Set if this page is bundled inside another. bundled bool @@ -112,9 +114,7 @@ type pageMeta struct { // the Resources above. resourcesMetadata []map[string]interface{} - f source.File - - sections []string + f *source.File // Sitemap overrides from front matter. sitemap config.Sitemap @@ -126,6 +126,51 @@ type pageMeta struct { contentConverter converter.Converter } +type pageMetaDates struct { + datesInit sync.Once + dates resource.Dates + + calculated resource.Dates + userProvided resource.Dates +} + +// If not user provided, the calculated dates may change, +// but this will be good enough for determining if we should +// not build a given page (publishDate in the future, expiryDate in the past). +func (d *pageMetaDates) getTemporaryDates() resource.Dates { + if !resource.IsZeroDates(d.userProvided) { + return d.userProvided + } + return d.calculated +} + +func (d *pageMetaDates) initDates() resource.Dates { + d.datesInit.Do(func() { + if !resource.IsZeroDates(d.userProvided) { + d.dates = d.userProvided + } else { + d.dates = d.calculated + } + }) + return d.dates +} + +func (d *pageMetaDates) Date() time.Time { + return d.initDates().Date() +} + +func (d *pageMetaDates) Lastmod() time.Time { + return d.initDates().Lastmod() +} + +func (d *pageMetaDates) PublishDate() time.Time { + return d.initDates().PublishDate() +} + +func (d *pageMetaDates) ExpiryDate() time.Time { + return d.initDates().ExpiryDate() +} + func (p *pageMeta) Aliases() []string { return p.aliases } @@ -175,22 +220,18 @@ func (p *pageMeta) Draft() bool { return p.draft } -func (p *pageMeta) File() source.File { +func (p *pageMeta) File() *source.File { return p.f } func (p *pageMeta) IsHome() bool { - return p.Kind() == page.KindHome + return p.Kind() == pagekinds.Home } func (p *pageMeta) Keywords() []string { return p.keywords } -func (p *pageMeta) Kind() string { - return p.kind -} - func (p *pageMeta) Layout() string { return p.layout } @@ -204,8 +245,8 @@ func (p *pageMeta) LinkTitle() string { } func (p *pageMeta) Name() string { - if p.resourcePath != "" { - return p.resourcePath + if p.File() != nil { + return p.File().LogicalName() } return p.Title() } @@ -215,7 +256,7 @@ func (p *pageMeta) IsNode() bool { } func (p *pageMeta) IsPage() bool { - return p.Kind() == page.KindPage + return p.Kind() == pagekinds.Page } // Param is a convenience method to do lookups in Page's and Site's Params map, @@ -232,28 +273,13 @@ func (p *pageMeta) Params() maps.Params { } func (p *pageMeta) Path() string { - if !p.File().IsZero() { - const example = ` - {{ $path := "" }} - {{ with .File }} - {{ $path = .Path }} - {{ else }} - {{ $path = .Path }} - {{ end }} -` - helpers.Deprecated(".Path when the page is backed by a file", "We plan to use Path for a canonical source path and you probably want to check the source is a file. To get the current behaviour, you can use a construct simlar to the below:\n"+example, false) - - } - - return p.Pathc() -} - -// This is just a bridge method, use Path in templates. -func (p *pageMeta) Pathc() string { - if !p.File().IsZero() { - return p.File().Path() + k := p.treeRef.Key() + if k == "" { + // Home page is represented by an empty string in the internal content map, + // for technical reasons, but in the templates we need a value. + return "/" } - return p.SectionsPath() + return k } // RelatedKeywords implements the related.Document interface needed for fast page searches. @@ -267,35 +293,14 @@ func (p *pageMeta) RelatedKeywords(cfg related.IndexConfig) ([]related.Keyword, } func (p *pageMeta) IsSection() bool { - return p.Kind() == page.KindSection + return p.Kind() == pagekinds.Section } func (p *pageMeta) Section() string { - if p.IsHome() { + if len(p.SectionsEntries()) == 0 { return "" } - - if p.IsNode() { - if len(p.sections) == 0 { - // May be a sitemap or similar. - return "" - } - return p.sections[0] - } - - if !p.File().IsZero() { - return p.File().Section() - } - - panic("invalid page state") -} - -func (p *pageMeta) SectionsEntries() []string { - return p.sections -} - -func (p *pageMeta) SectionsPath() string { - return path.Join(p.SectionsEntries()...) + return p.SectionsEntries()[0] } func (p *pageMeta) Sitemap() config.Sitemap { @@ -331,7 +336,6 @@ func (pm *pageMeta) mergeBucketCascades(b1, b2 *pagesMapBucket) { if b2 != nil && b2.cascade != nil { for k, v := range b2.cascade { - vv, found := b1.cascade[k] if !found { b1.cascade[k] = v @@ -347,12 +351,10 @@ func (pm *pageMeta) mergeBucketCascades(b1, b2 *pagesMapBucket) { } } -func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, frontmatter map[string]interface{}) error { +func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, n *contentNode, frontmatter map[string]interface{}) error { pm.params = make(maps.Params) - if frontmatter == nil && (parentBucket == nil || parentBucket.cascade == nil) { - return nil - } + p := n.p if frontmatter != nil { // Needed for case insensitive fetching of params values @@ -396,7 +398,7 @@ func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, fron var mtime time.Time var contentBaseName string - if !p.File().IsZero() { + if p.File() != nil { contentBaseName = p.File().ContentBaseName() if p.File().FileInfo() != nil { mtime = p.File().FileInfo().ModTime() @@ -411,7 +413,7 @@ func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, fron descriptor := &pagemeta.FrontMatterDescriptor{ Frontmatter: frontmatter, Params: pm.params, - Dates: &pm.Dates, + Dates: &pm.pageMetaDates.userProvided, PageURLs: &pm.urlPaths, BaseFilename: contentBaseName, ModTime: mtime, @@ -432,6 +434,11 @@ func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, fron return err } + if n.IsStandalone() { + // Standalone pages, e.g. 404. + pm.buildConfig.List = pagemeta.Never + } + var sitemapSet bool var draft, published, isCJKLanguage *bool @@ -613,6 +620,7 @@ func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, fron } default: pm.params[loki] = vv + } } } @@ -654,11 +662,16 @@ func (p *pageMeta) noListAlways() bool { } func (p *pageMeta) getListFilter(local bool) contentTreeNodeCallback { - return newContentTreeFilter(func(n *contentNode) bool { + return func(s string, n *contentNode) bool { if n == nil { return true } + if n.IsStandalone() { + // Never list 404, sitemap and similar. + return true + } + var shouldList bool switch n.p.m.buildConfig.List { case pagemeta.Always: @@ -670,7 +683,7 @@ func (p *pageMeta) getListFilter(local bool) contentTreeNodeCallback { } return !shouldList - }) + } } func (p *pageMeta) noRender() bool { @@ -681,7 +694,7 @@ func (p *pageMeta) noLink() bool { return p.buildConfig.Render == pagemeta.Never } -func (p *pageMeta) applyDefaultValues(n *contentNode) error { +func (p *pageMeta) applyDefaultValues(np contentTreeRefProvider) error { if p.buildConfig.IsZero() { p.buildConfig, _ = pagemeta.DecodeBuildConfig(nil) } @@ -691,7 +704,7 @@ func (p *pageMeta) applyDefaultValues(n *contentNode) error { } if p.markup == "" { - if !p.File().IsZero() { + if p.File() != nil { // Fall back to file extension p.markup = p.s.ContentSpec.ResolveMarkup(p.File().Ext()) } @@ -700,31 +713,18 @@ func (p *pageMeta) applyDefaultValues(n *contentNode) error { } } - if p.title == "" && p.f.IsZero() { + if p.title == "" && p.f == nil { switch p.Kind() { - case page.KindHome: + case pagekinds.Home: p.title = p.s.Info.title - case page.KindSection: - var sectionName string - if n != nil { - sectionName = n.rootSection() - } else { - sectionName = p.sections[0] - } - - sectionName = helpers.FirstUpper(sectionName) - if p.s.Cfg.GetBool("pluralizeListTitles") { - p.title = flect.Pluralize(sectionName) - } else { - p.title = sectionName - } - case page.KindTerm: - // TODO(bep) improve - key := p.sections[len(p.sections)-1] + case pagekinds.Section: + p.title = np.GetBranch().defaultTitle + case pagekinds.Term: + key := p.SectionsEntries()[len(p.SectionsEntries())-1] p.title = strings.Replace(p.s.titleFunc(key), "-", " ", -1) - case page.KindTaxonomy: - p.title = p.s.titleFunc(p.sections[0]) - case kind404: + case pagekinds.Taxonomy: + p.title = p.s.titleFunc(path.Join(p.SectionsEntries()...)) + case pagekinds.Status404: p.title = "404 Page not found" } @@ -732,18 +732,16 @@ func (p *pageMeta) applyDefaultValues(n *contentNode) error { if p.IsNode() { p.bundleType = files.ContentClassBranch - } else { - source := p.File() - if fi, ok := source.(*fileInfo); ok { - class := fi.FileInfo().Meta().Classifier - switch class { - case files.ContentClassBranch, files.ContentClassLeaf: - p.bundleType = class - } + } else if p.File() != nil { + class := p.File().FileInfo().Meta().Classifier + switch class { + case files.ContentClassBranch, files.ContentClassLeaf: + p.bundleType = class } + } - if !p.f.IsZero() { + if p.f != nil { var renderingConfigOverrides map[string]interface{} bfParam := getParamToLower(p, "blackfriday") if bfParam != nil { @@ -768,16 +766,18 @@ func (p *pageMeta) newContentConverter(ps *pageState, markup string, renderingCo var id string var filename string + var documentName string if !p.f.IsZero() { id = p.f.UniqueID() filename = p.f.Filename() + documentName = p.f.Path() } cpp, err := cp.New( converter.DocumentContext{ Document: newPageForRenderHook(ps), DocumentID: id, - DocumentName: p.File().Path(), + DocumentName: documentName, Filename: filename, ConfigOverrides: renderingConfigOverrides, }, diff --git a/hugolib/page__new.go b/hugolib/page__new.go index 8c96d5014dd..5380cf79b30 100644 --- a/hugolib/page__new.go +++ b/hugolib/page__new.go @@ -14,15 +14,7 @@ package hugolib import ( - "html/template" - "strings" - - "github.com/gohugoio/hugo/common/hugo" - "github.com/gohugoio/hugo/common/maps" - "github.com/gohugoio/hugo/source" - - "github.com/gohugoio/hugo/output" "github.com/gohugoio/hugo/lazy" @@ -54,7 +46,6 @@ func newPageBase(metaProvider *pageMeta) (*pageState, error) { RefProvider: page.NopPage, ShortcodeInfoProvider: page.NopPage, LanguageProvider: s, - pagePages: &pagePages{}, InternalDependencies: s, init: lazy.New(), @@ -65,15 +56,6 @@ func newPageBase(metaProvider *pageMeta) (*pageState, error) { siteAdapter := pageSiteAdapter{s: s, p: ps} - deprecatedWarningPage := struct { - source.FileWithoutOverlap - page.DeprecatedWarningPageMethods1 - }{ - FileWithoutOverlap: metaProvider.File(), - DeprecatedWarningPageMethods1: &pageDeprecatedWarning{p: ps}, - } - - ps.DeprecatedWarningPageMethods = page.NewDeprecatedWarningPage(deprecatedWarningPage) ps.pageMenus = &pageMenus{p: ps} ps.PageMenusProvider = ps.pageMenus ps.GetPageProvider = siteAdapter @@ -92,127 +74,6 @@ func newPageBase(metaProvider *pageMeta) (*pageState, error) { return ps, nil } -func newPageBucket(p *pageState) *pagesMapBucket { - return &pagesMapBucket{owner: p, pagesMapBucketPages: &pagesMapBucketPages{}} -} - -func newPageFromMeta( - n *contentNode, - parentBucket *pagesMapBucket, - meta map[string]interface{}, - metaProvider *pageMeta) (*pageState, error) { - if metaProvider.f == nil { - metaProvider.f = page.NewZeroFile(metaProvider.s.LogDistinct) - } - - ps, err := newPageBase(metaProvider) - if err != nil { - return nil, err - } - - bucket := parentBucket - - if ps.IsNode() { - ps.bucket = newPageBucket(ps) - } - - if meta != nil || parentBucket != nil { - if err := metaProvider.setMetadata(bucket, ps, meta); err != nil { - return nil, ps.wrapError(err) - } - } - - if err := metaProvider.applyDefaultValues(n); err != nil { - return nil, err - } - - ps.init.Add(func() (interface{}, error) { - pp, err := newPagePaths(metaProvider.s, ps, metaProvider) - if err != nil { - return nil, err - } - - makeOut := func(f output.Format, render bool) *pageOutput { - return newPageOutput(ps, pp, f, render) - } - - shouldRenderPage := !ps.m.noRender() - - if ps.m.standalone { - ps.pageOutput = makeOut(ps.m.outputFormats()[0], shouldRenderPage) - } else { - outputFormatsForPage := ps.m.outputFormats() - - // Prepare output formats for all sites. - // We do this even if this page does not get rendered on - // its own. It may be referenced via .Site.GetPage and - // it will then need an output format. - ps.pageOutputs = make([]*pageOutput, len(ps.s.h.renderFormats)) - created := make(map[string]*pageOutput) - for i, f := range ps.s.h.renderFormats { - po, found := created[f.Name] - if !found { - render := shouldRenderPage - if render { - _, render = outputFormatsForPage.GetByName(f.Name) - } - po = makeOut(f, render) - created[f.Name] = po - } - ps.pageOutputs[i] = po - } - } - - if err := ps.initCommonProviders(pp); err != nil { - return nil, err - } - - return nil, nil - }) - - return ps, err -} - -// Used by the legacy 404, sitemap and robots.txt rendering -func newPageStandalone(m *pageMeta, f output.Format) (*pageState, error) { - m.configuredOutputFormats = output.Formats{f} - m.standalone = true - p, err := newPageFromMeta(nil, nil, nil, m) - if err != nil { - return nil, err - } - - if err := p.initPage(); err != nil { - return nil, err - } - - return p, nil -} - -type pageDeprecatedWarning struct { - p *pageState -} - -func (p *pageDeprecatedWarning) IsDraft() bool { return p.p.m.draft } -func (p *pageDeprecatedWarning) Hugo() hugo.Info { return p.p.s.Info.Hugo() } -func (p *pageDeprecatedWarning) LanguagePrefix() string { return p.p.s.Info.LanguagePrefix } -func (p *pageDeprecatedWarning) GetParam(key string) interface{} { - return p.p.m.params[strings.ToLower(key)] -} - -func (p *pageDeprecatedWarning) RSSLink() template.URL { - f := p.p.OutputFormats().Get("RSS") - if f == nil { - return "" - } - return template.URL(f.Permalink()) -} - -func (p *pageDeprecatedWarning) URL() string { - if p.p.IsPage() && p.p.m.urlPaths.URL != "" { - // This is the url set in front matter - return p.p.m.urlPaths.URL - } - // Fall back to the relative permalink. - return p.p.RelPermalink() +func newPageBucket(parent *pagesMapBucket, self *pageState) *pagesMapBucket { + return &pagesMapBucket{parent: parent, self: self, pagesMapBucketPages: &pagesMapBucketPages{}} } diff --git a/hugolib/page__output.go b/hugolib/page__output.go index 377e16df522..c04fc2e7b9c 100644 --- a/hugolib/page__output.go +++ b/hugolib/page__output.go @@ -14,6 +14,7 @@ package hugolib import ( + "github.com/gohugoio/hugo/identity" "github.com/gohugoio/hugo/markup/converter" "github.com/gohugoio/hugo/output" "github.com/gohugoio/hugo/resources/page" @@ -54,13 +55,20 @@ func newPageOutput( targetPathsProvider, } + var dependencyManager identity.Manager = identity.NopManager + if ps.s.running() { + dependencyManager = identity.NewManager(identity.Anonymous) + } + po := &pageOutput{ f: f, + dependencyManager: dependencyManager, pagePerOutputProviders: providers, ContentProvider: page.NopPage, TableOfContentsProvider: page.NopPage, render: render, paginator: pag, + ps: ps, } return po @@ -69,7 +77,7 @@ func newPageOutput( // We create a pageOutput for every output format combination, even if this // particular page isn't configured to be rendered to that format. type pageOutput struct { - // Set if this page isn't configured to be rendered to this format. + // Enabled if this page is configured to be rendered to this format. render bool f output.Format @@ -85,8 +93,19 @@ type pageOutput struct { page.ContentProvider page.TableOfContentsProvider + // We have one per output so we can do a fine grained page resets. + dependencyManager identity.Manager + + ps *pageState + // May be nil. cp *pageContentOutput + + renderState int +} + +func (o *pageOutput) GetDependencyManager() identity.Manager { + return o.dependencyManager } func (o *pageOutput) initRenderHooks() error { @@ -97,10 +116,10 @@ func (o *pageOutput) initRenderHooks() error { var initErr error o.cp.renderHooks.init.Do(func() { - ps := o.cp.p + ps := o.ps c := ps.getContentConverter() - if c == nil || !c.Supports(converter.FeatureRenderHooks) { + if c == nil || !c.Supports(converter.FeatureRenderHookImage) { return } diff --git a/hugolib/page__paginator.go b/hugolib/page__paginator.go index a5a3f07a630..39be69f69e4 100644 --- a/hugolib/page__paginator.go +++ b/hugolib/page__paginator.go @@ -16,6 +16,10 @@ package hugolib import ( "sync" + "github.com/gohugoio/hugo/resources/page/pagekinds" + + "github.com/gohugoio/hugo/common/herrors" + "github.com/gohugoio/hugo/resources/page" ) @@ -69,6 +73,8 @@ func (p *pagePaginator) Paginate(seq interface{}, options ...interface{}) (*page } func (p *pagePaginator) Paginator(options ...interface{}) (*page.Pager, error) { + defer herrors.Recover() + var initErr error p.init.Do(func() { pagerSize, err := page.ResolvePagerSize(p.source.s.Cfg, options...) @@ -83,12 +89,12 @@ func (p *pagePaginator) Paginator(options ...interface{}) (*page.Pager, error) { var pages page.Pages switch p.source.Kind() { - case page.KindHome: + case pagekinds.Home: // From Hugo 0.57 we made home.Pages() work like any other // section. To avoid the default paginators for the home page // changing in the wild, we make this a special case. pages = p.source.s.RegularPages() - case page.KindTerm, page.KindTaxonomy: + case pagekinds.Term, pagekinds.Taxonomy: pages = p.source.Pages() default: pages = p.source.RegularPages() diff --git a/hugolib/page__paths.go b/hugolib/page__paths.go index 947cdde9d73..c9108b285d5 100644 --- a/hugolib/page__paths.go +++ b/hugolib/page__paths.go @@ -15,8 +15,13 @@ package hugolib import ( "net/url" + "path" "strings" + "github.com/gohugoio/hugo/resources/page/pagekinds" + + "github.com/gohugoio/hugo/output" + "github.com/gohugoio/hugo/helpers" "github.com/gohugoio/hugo/resources/page" @@ -24,20 +29,25 @@ import ( func newPagePaths( s *Site, - p page.Page, + n *contentNode, pm *pageMeta) (pagePaths, error) { - targetPathDescriptor, err := createTargetPathDescriptor(s, p, pm) + targetPathDescriptor, err := createTargetPathDescriptor(s, n, pm) if err != nil { return pagePaths{}, err } - outputFormats := pm.outputFormats() - if len(outputFormats) == 0 { - return pagePaths{}, nil - } + var outputFormats output.Formats + if n.IsStandalone() { + outputFormats = output.Formats{n.traits.(kindOutputFormatTrait).OutputFormat()} + } else { + outputFormats = pm.outputFormats() + if len(outputFormats) == 0 { + return pagePaths{}, nil + } - if pm.noRender() { - outputFormats = outputFormats[:1] + if pm.noRender() { + outputFormats = outputFormats[:1] + } } pageOutputFormats := make(page.OutputFormats, len(outputFormats)) @@ -47,7 +57,6 @@ func newPagePaths( desc := targetPathDescriptor desc.Type = f paths := page.CreateTargetPaths(desc) - var relPermalink, permalink string // If a page is headless or bundled in another, @@ -100,7 +109,7 @@ func (l pagePaths) OutputFormats() page.OutputFormats { return l.outputFormats } -func createTargetPathDescriptor(s *Site, p page.Page, pm *pageMeta) (page.TargetPathDescriptor, error) { +func createTargetPathDescriptor(s *Site, n *contentNode, pm *pageMeta) (page.TargetPathDescriptor, error) { var ( dir string baseName string @@ -108,21 +117,27 @@ func createTargetPathDescriptor(s *Site, p page.Page, pm *pageMeta) (page.Target ) d := s.Deps + p := n.p - if !p.File().IsZero() { + // TODO1 HttpStatus layout warning. + + if p.File() == nil { + if n.key != "" && !p.IsNode() { + baseName = path.Base(n.key) + } + } else { dir = p.File().Dir() baseName = p.File().TranslationBaseName() contentBaseName = p.File().ContentBaseName() + if baseName != contentBaseName { + // See https://github.com/gohugoio/hugo/issues/4870 + // A leaf bundle + dir = strings.TrimSuffix(dir, contentBaseName+helpers.FilePathSeparator) + baseName = contentBaseName + } } - if baseName != contentBaseName { - // See https://github.com/gohugoio/hugo/issues/4870 - // A leaf bundle - dir = strings.TrimSuffix(dir, contentBaseName+helpers.FilePathSeparator) - baseName = contentBaseName - } - - alwaysInSubDir := p.Kind() == kindSitemap + alwaysInSubDir := p.Kind() == pagekinds.Sitemap desc := page.TargetPathDescriptor{ PathSpec: d.PathSpec, @@ -143,12 +158,12 @@ func createTargetPathDescriptor(s *Site, p page.Page, pm *pageMeta) (page.Target desc.PrefixFilePath = s.getLanguageTargetPathLang(alwaysInSubDir) desc.PrefixLink = s.getLanguagePermalinkLang(alwaysInSubDir) - // Expand only page.KindPage and page.KindTaxonomy; don't expand other Kinds of Pages - // like page.KindSection or page.KindTaxonomyTerm because they are "shallower" and + // Expand only pagekinds.KindPage and pagekinds.KindTaxonomy; don't expand other Kinds of Pages + // like pagekinds.KindSection or pagekinds.KindTaxonomyTerm because they are "shallower" and // the permalink configuration values are likely to be redundant, e.g. // naively expanding /category/:slug/ would give /category/categories/ for - // the "categories" page.KindTaxonomyTerm. - if p.Kind() == page.KindPage || p.Kind() == page.KindTerm { + // the "categories" pagekinds.KindTaxonomyTerm. + if p.Kind() == pagekinds.Page || p.Kind() == pagekinds.Term { opath, err := d.ResourceSpec.Permalinks.Expand(p.Section(), p) if err != nil { return desc, err diff --git a/hugolib/page__per_output.go b/hugolib/page__per_output.go index f59b5f9b545..6f11d8a3812 100644 --- a/hugolib/page__per_output.go +++ b/hugolib/page__per_output.go @@ -35,7 +35,6 @@ import ( "github.com/gohugoio/hugo/tpl" "github.com/gohugoio/hugo/helpers" - "github.com/gohugoio/hugo/output" "github.com/gohugoio/hugo/resources/page" "github.com/gohugoio/hugo/resources/resource" ) @@ -62,27 +61,18 @@ var ( } ) -var pageContentOutputDependenciesID = identity.KeyValueIdentity{Key: "pageOutput", Value: "dependencies"} - -func newPageContentOutput(p *pageState, po *pageOutput) (*pageContentOutput, error) { - parent := p.init - - var dependencyTracker identity.Manager - if p.s.running() { - dependencyTracker = identity.NewManager(pageContentOutputDependenciesID) - } +func newPageContentOutput(po *pageOutput) (*pageContentOutput, error) { + parent := po.ps.init cp := &pageContentOutput{ - dependencyTracker: dependencyTracker, - p: p, - f: po.f, - renderHooks: &renderHooks{}, + po: po, + renderHooks: &renderHooks{}, } - initContent := func() (err error) { - p.s.h.IncrContentRender() + p := po.ps - if p.cmap == nil { + initContent := func() (err error) { + if po.ps.cmap == nil { // Nothing to do. return nil } @@ -120,7 +110,7 @@ func newPageContentOutput(p *pageState, po *pageOutput) (*pageContentOutput, err cp.workContent = p.contentToRender(cp.contentPlaceholders) - isHTML := cp.p.m.markup == "html" + isHTML := p.m.markup == "html" if !isHTML { r, err := cp.renderContent(cp.workContent, true) @@ -160,7 +150,7 @@ func newPageContentOutput(p *pageState, po *pageOutput) (*pageContentOutput, err } } - if cp.p.source.hasSummaryDivider { + if p.source.hasSummaryDivider { if isHTML { src := p.source.parsed.Input() @@ -169,25 +159,25 @@ func newPageContentOutput(p *pageState, po *pageOutput) (*pageContentOutput, err cp.summary = helpers.BytesToHTML(src[p.source.posMainContent:p.source.posSummaryEnd]) } - if cp.p.source.posBodyStart != -1 { - cp.workContent = src[cp.p.source.posBodyStart:] + if p.source.posBodyStart != -1 { + cp.workContent = src[p.source.posBodyStart:] } } else { - summary, content, err := splitUserDefinedSummaryAndContent(cp.p.m.markup, cp.workContent) + summary, content, err := splitUserDefinedSummaryAndContent(p.m.markup, cp.workContent) if err != nil { - cp.p.s.Log.Errorf("Failed to set user defined summary for page %q: %s", cp.p.pathOrTitle(), err) + p.s.Log.Errorf("Failed to set user defined summary for page %q: %s", p.pathOrTitle(), err) } else { cp.workContent = content cp.summary = helpers.BytesToHTML(summary) } } - } else if cp.p.m.summary != "" { - b, err := cp.renderContent([]byte(cp.p.m.summary), false) + } else if p.m.summary != "" { + b, err := cp.renderContent([]byte(p.m.summary), false) if err != nil { return err } - html := cp.p.s.ContentSpec.TrimShortHTML(b.Bytes()) + html := p.s.ContentSpec.TrimShortHTML(b.Bytes()) cp.summary = helpers.BytesToHTML(html) } @@ -232,14 +222,12 @@ type renderHooks struct { // pageContentOutput represents the Page content for a given output format. type pageContentOutput struct { - f output.Format + po *pageOutput // If we can reuse this for other output formats. reuse bool reuseInit sync.Once - p *pageState - // Lazy load dependencies initMain *lazy.Init initPlain *lazy.Init @@ -254,8 +242,7 @@ type pageContentOutput struct { // Content state - workContent []byte - dependencyTracker identity.Manager // Set in server mode. + workContent []byte // Temporary storage of placeholders mapped to their content. // These are shortcodes etc. Some of these will need to be replaced @@ -276,91 +263,87 @@ type pageContentOutput struct { readingTime int } -func (p *pageContentOutput) trackDependency(id identity.Provider) { - if p.dependencyTracker != nil { - p.dependencyTracker.Add(id) - } +func (p *pageContentOutput) trackDependency(id identity.Identity) { + p.po.dependencyManager.AddIdentity(id) } func (p *pageContentOutput) Reset() { - if p.dependencyTracker != nil { - p.dependencyTracker.Reset() - } + p.po.dependencyManager.Reset() p.initMain.Reset() p.initPlain.Reset() p.renderHooks = &renderHooks{} } func (p *pageContentOutput) Content() (interface{}, error) { - if p.p.s.initInit(p.initMain, p.p) { + if p.po.ps.s.initInit(p.initMain, p.po.ps) { return p.content, nil } return nil, nil } func (p *pageContentOutput) FuzzyWordCount() int { - p.p.s.initInit(p.initPlain, p.p) + p.po.ps.s.initInit(p.initPlain, p.po.ps) return p.fuzzyWordCount } func (p *pageContentOutput) Len() int { - p.p.s.initInit(p.initMain, p.p) + p.po.ps.s.initInit(p.initMain, p.po.ps) return len(p.content) } func (p *pageContentOutput) Plain() string { - p.p.s.initInit(p.initPlain, p.p) + p.po.ps.s.initInit(p.initPlain, p.po.ps) return p.plain } func (p *pageContentOutput) PlainWords() []string { - p.p.s.initInit(p.initPlain, p.p) + p.po.ps.s.initInit(p.initPlain, p.po.ps) return p.plainWords } func (p *pageContentOutput) ReadingTime() int { - p.p.s.initInit(p.initPlain, p.p) + p.po.ps.s.initInit(p.initPlain, p.po.ps) return p.readingTime } func (p *pageContentOutput) Summary() template.HTML { - p.p.s.initInit(p.initMain, p.p) - if !p.p.source.hasSummaryDivider { - p.p.s.initInit(p.initPlain, p.p) + p.po.ps.s.initInit(p.initMain, p.po.ps) + if !p.po.ps.source.hasSummaryDivider { + p.po.ps.s.initInit(p.initPlain, p.po.ps) } return p.summary } func (p *pageContentOutput) TableOfContents() template.HTML { - p.p.s.initInit(p.initMain, p.p) + p.po.ps.s.initInit(p.initMain, p.po.ps) return p.tableOfContents } func (p *pageContentOutput) Truncated() bool { - if p.p.truncated { + if p.po.ps.truncated { return true } - p.p.s.initInit(p.initPlain, p.p) + p.po.ps.s.initInit(p.initPlain, p.po.ps) return p.truncated } func (p *pageContentOutput) WordCount() int { - p.p.s.initInit(p.initPlain, p.p) + p.po.ps.s.initInit(p.initPlain, p.po.ps) return p.wordCount } func (p *pageContentOutput) setAutoSummary() error { - if p.p.source.hasSummaryDivider || p.p.m.summary != "" { + if p.po.ps.source.hasSummaryDivider || p.po.ps.m.summary != "" { return nil } var summary string var truncated bool - if p.p.m.isCJKLanguage { - summary, truncated = p.p.s.ContentSpec.TruncateWordsByRune(p.plainWords) + if p.po.ps.m.isCJKLanguage { + summary, truncated = p.po.ps.s.ContentSpec.TruncateWordsByRune(p.plainWords) } else { - summary, truncated = p.p.s.ContentSpec.TruncateWordsToWholeSentence(p.plain) + summary, truncated = p.po.ps.s.ContentSpec.TruncateWordsToWholeSentence(p.plain) } p.summary = template.HTML(summary) @@ -370,7 +353,8 @@ func (p *pageContentOutput) setAutoSummary() error { } func (cp *pageContentOutput) renderContent(content []byte, renderTOC bool) (converter.Result, error) { - c := cp.p.getContentConverter() + cp.po.ps.s.h.IncrContentRender() + c := cp.po.ps.getContentConverter() return cp.renderContentWithConverter(c, content, renderTOC) } @@ -384,8 +368,8 @@ func (cp *pageContentOutput) renderContentWithConverter(c converter.Converter, c if err == nil { if ids, ok := r.(identity.IdentitiesProvider); ok { - for _, v := range ids.GetIdentities() { - cp.trackDependency(v) + for id := range ids.GetIdentities() { + cp.trackDependency(id) } } } @@ -454,10 +438,10 @@ func (t targetPathsHolder) targetPaths() page.TargetPaths { return t.paths } -func executeToString(h tpl.TemplateHandler, templ tpl.Template, data interface{}) (string, error) { +func executeToString(ctx context.Context, h tpl.TemplateHandler, templ tpl.Template, data interface{}) (string, error) { b := bp.GetBuffer() defer bp.PutBuffer(b) - if err := h.Execute(templ, b, data); err != nil { + if err := h.ExecuteWithContext(ctx, templ, b, data); err != nil { return "", err } return b.String(), nil diff --git a/hugolib/page__tree.go b/hugolib/page__tree.go index e4f3c6b5192..f377622a2fd 100644 --- a/hugolib/page__tree.go +++ b/hugolib/page__tree.go @@ -17,19 +17,15 @@ import ( "path" "strings" - "github.com/gohugoio/hugo/common/types" "github.com/gohugoio/hugo/resources/page" ) +// pageTree holds the treen navigational method for a Page. type pageTree struct { p *pageState } func (pt pageTree) IsAncestor(other interface{}) (bool, error) { - if pt.p == nil { - return false, nil - } - tp, ok := other.(treeRefProvider) if !ok { return false, nil @@ -37,45 +33,23 @@ func (pt pageTree) IsAncestor(other interface{}) (bool, error) { ref1, ref2 := pt.p.getTreeRef(), tp.getTreeRef() - if ref1 != nil && ref1.key == "/" { + if ref1.Key() == "" { return true, nil } - if ref1 == nil || ref2 == nil { - if ref1 == nil { - // A 404 or other similar standalone page. - return false, nil - } - - return ref1.n.p.IsHome(), nil - } - - if ref1.key == ref2.key { + if ref1.Key() == ref2.Key() { return true, nil } - if strings.HasPrefix(ref2.key, ref1.key) { - return true, nil - } - - return strings.HasPrefix(ref2.key, ref1.key+cmBranchSeparator), nil + return strings.HasPrefix(ref2.Key(), ref1.Key()+"/"), nil } +// 2 TODO1 create issue: CurrentSection should navigate sideways for all branch nodes. func (pt pageTree) CurrentSection() page.Page { - p := pt.p - - if p.IsHome() || p.IsSection() { - return p - } - - return p.Parent() + return pt.p.m.treeRef.GetBranch().n.p } func (pt pageTree) IsDescendant(other interface{}) (bool, error) { - if pt.p == nil { - return false, nil - } - tp, ok := other.(treeRefProvider) if !ok { return false, nil @@ -83,42 +57,27 @@ func (pt pageTree) IsDescendant(other interface{}) (bool, error) { ref1, ref2 := pt.p.getTreeRef(), tp.getTreeRef() - if ref2 != nil && ref2.key == "/" { + if ref2.Key() == "" { return true, nil } - if ref1 == nil || ref2 == nil { - if ref2 == nil { - // A 404 or other similar standalone page. - return false, nil - } - - return ref2.n.p.IsHome(), nil - } - - if ref1.key == ref2.key { + if ref1.Key() == ref2.Key() { return true, nil } - if strings.HasPrefix(ref1.key, ref2.key) { - return true, nil - } - - return strings.HasPrefix(ref1.key, ref2.key+cmBranchSeparator), nil + return strings.HasPrefix(ref1.Key(), ref2.Key()+"/"), nil } func (pt pageTree) FirstSection() page.Page { ref := pt.p.getTreeRef() - if ref == nil { - return pt.p.s.home - } - key := ref.key + key := ref.Key() + n := ref.GetNode() + branch := ref.GetBranch() - if !ref.isSection() { + if branch.n != n { key = path.Dir(key) } - - _, b := ref.m.getFirstSection(key) + _, b := pt.p.s.pageMap.GetFirstSection(key) if b == nil { return nil } @@ -126,10 +85,6 @@ func (pt pageTree) FirstSection() page.Page { } func (pt pageTree) InSection(other interface{}) (bool, error) { - if pt.p == nil || types.IsNil(other) { - return false, nil - } - tp, ok := other.(treeRefProvider) if !ok { return false, nil @@ -137,53 +92,21 @@ func (pt pageTree) InSection(other interface{}) (bool, error) { ref1, ref2 := pt.p.getTreeRef(), tp.getTreeRef() - if ref1 == nil || ref2 == nil { - if ref1 == nil { - // A 404 or other similar standalone page. - return false, nil - } - return ref1.n.p.IsHome(), nil - } - - s1, _ := ref1.getCurrentSection() - s2, _ := ref2.getCurrentSection() - - return s1 == s2, nil -} - -func (pt pageTree) Page() page.Page { - return pt.p + return ref1.GetBranch() == ref2.GetBranch(), nil } func (pt pageTree) Parent() page.Page { - p := pt.p - - if p.parent != nil { - return p.parent - } - - if pt.p.IsHome() { - return nil - } - - tree := p.getTreeRef() - - if tree == nil || pt.p.Kind() == page.KindTaxonomy { - return pt.p.s.home - } - - _, b := tree.getSection() - if b == nil { + owner := pt.p.getTreeRef().GetContainerNode() + if owner == nil { return nil } - - return b.p + return owner.p } func (pt pageTree) Sections() page.Pages { - if pt.p.bucket == nil { - return nil - } - return pt.p.bucket.getSections() } + +func (pt pageTree) Page() page.Page { + return pt.p +} diff --git a/hugolib/page_kinds.go b/hugolib/page_kinds.go index b63da1d1361..4e46128b624 100644 --- a/hugolib/page_kinds.go +++ b/hugolib/page_kinds.go @@ -14,39 +14,12 @@ package hugolib import ( - "strings" - - "github.com/gohugoio/hugo/resources/page" + "github.com/gohugoio/hugo/resources/page/pagekinds" ) // This is all the kinds we can expect to find in .Site.Pages. -var allKindsInPages = []string{page.KindPage, page.KindHome, page.KindSection, page.KindTerm, page.KindTaxonomy} +var allKindsInPages = []string{pagekinds.Page, pagekinds.Home, pagekinds.Section, pagekinds.Term, pagekinds.Taxonomy} const ( - - // Temporary state. - kindUnknown = "unknown" - - // The following are (currently) temporary nodes, - // i.e. nodes we create just to render in isolation. - kindRSS = "RSS" - kindSitemap = "sitemap" - kindRobotsTXT = "robotsTXT" - kind404 = "404" - pageResourceType = "page" ) - -var kindMap = map[string]string{ - strings.ToLower(kindRSS): kindRSS, - strings.ToLower(kindSitemap): kindSitemap, - strings.ToLower(kindRobotsTXT): kindRobotsTXT, - strings.ToLower(kind404): kind404, -} - -func getKind(s string) string { - if pkind := page.GetKind(s); pkind != "" { - return pkind - } - return kindMap[strings.ToLower(s)] -} diff --git a/hugolib/page_permalink_test.go b/hugolib/page_permalink_test.go index 0939cc1ff51..d400f8b2f75 100644 --- a/hugolib/page_permalink_test.go +++ b/hugolib/page_permalink_test.go @@ -60,6 +60,9 @@ func TestPermalink(t *testing.T) { // test URL overrides {"x/y/z/boofar.md", "", "", "/z/y/q/", false, false, "/z/y/q/", "/z/y/q/"}, + + // Unicode encode + {"трям/boo-makeindex.md", "http://barnew/", "трям", "", false, false, "http://barnew/%D1%82%D1%80%D1%8F%D0%BC/%D1%82%D1%80%D1%8F%D0%BC/", "/%D1%82%D1%80%D1%8F%D0%BC/%D1%82%D1%80%D1%8F%D0%BC/"}, } for i, test := range tests { diff --git a/hugolib/page_test.go b/hugolib/page_test.go index 7d55787c8e3..433f25850d3 100644 --- a/hugolib/page_test.go +++ b/hugolib/page_test.go @@ -545,6 +545,7 @@ date: 2012-01-12 s := b.H.Sites[0] checkDate := func(p page.Page, year int) { + b.Helper() b.Assert(p.Date().Year(), qt.Equals, year) b.Assert(p.Lastmod().Year(), qt.Equals, year) } @@ -1034,22 +1035,53 @@ func TestPagePaths(t *testing.T) { func TestTranslationKey(t *testing.T) { t.Parallel() c := qt.New(t) - cfg, fs := newTestCfg() - - writeSource(t, fs, filepath.Join("content", filepath.FromSlash("sect/simple.no.md")), "---\ntitle: \"A1\"\ntranslationKey: \"k1\"\n---\nContent\n") - writeSource(t, fs, filepath.Join("content", filepath.FromSlash("sect/simple.en.md")), "---\ntitle: \"A2\"\n---\nContent\n") - - s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{SkipRender: true}) - c.Assert(len(s.RegularPages()), qt.Equals, 2) - - home, _ := s.Info.Home() - c.Assert(home, qt.Not(qt.IsNil)) - c.Assert(home.TranslationKey(), qt.Equals, "home") - c.Assert(s.RegularPages()[0].TranslationKey(), qt.Equals, "page/k1") - p2 := s.RegularPages()[1] - - c.Assert(p2.TranslationKey(), qt.Equals, "page/sect/simple") + files := `-- config.toml -- +baseURL = "https://example.com" +disableKinds=["taxonomy", "term", "sitemap", "robotsTXT"] +[languages] +[languages.en] +weight = 1 +title = "Title in English" +[languages.nn] +weight = 2 +title = "Tittel på nynorsk" +[outputs] + home = ['HTML'] + page = ['HTML'] + +-- content/sect/simple.en.md -- +--- +title: A1 +translationKey: k1 +--- +-- content/sect/simple.nn.md -- +--- +title: A2 +--- +-- layouts/index.html -- +{{ range site.Pages }} +Path: {{ .Path }}|Kind: {{ .Kind }}|TranslationKey: {{ .TranslationKey }}|Title: {{ .Title }} +{{ end }} + ` + + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: files, + }).Build() + + b.AssertFileContent("public/index.html", ` +Path: /sect/simple|Kind: page|TranslationKey: page/k1|Title: A1 +Path: /sect|Kind: section|TranslationKey: section/sect|Title: Sects +Path: /|Kind: home|TranslationKey: home|Title: Title in English + `) + + b.AssertFileContent("public/nn/index.html", ` +Path: /sect/simple|Kind: page|TranslationKey: page/sect/simple|Title: A2 +Path: /sect|Kind: section|TranslationKey: section/sect|Title: Sects +Path: /|Kind: home|TranslationKey: home|Title: Tittel på nynorsk + `) } func TestChompBOM(t *testing.T) { @@ -1277,11 +1309,15 @@ Content:{{ .Content }} // https://github.com/gohugoio/hugo/issues/5781 func TestPageWithZeroFile(t *testing.T) { + t.Parallel() + newTestSitesBuilder(t).WithLogger(loggers.NewWarningLogger()).WithSimpleConfigFile(). WithTemplatesAdded("index.html", "{{ .File.Filename }}{{ with .File }}{{ .Dir }}{{ end }}").Build(BuildCfg{}) } func TestHomePageWithNoTitle(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t).WithConfigFile("toml", ` title = "Site Title" `) diff --git a/hugolib/page_unwrap.go b/hugolib/page_unwrap.go index eda6636d162..49843f84525 100644 --- a/hugolib/page_unwrap.go +++ b/hugolib/page_unwrap.go @@ -31,8 +31,8 @@ func unwrapPage(in interface{}) (page.Page, error) { return v, nil case pageWrapper: return v.page(), nil - case page.Page: - return v, nil + case page.PageProvider: + return v.Page(), nil case nil: return nil, nil default: diff --git a/hugolib/pagebundler_test.go b/hugolib/pagebundler_test.go index 1694b02ee8a..c9fe180f495 100644 --- a/hugolib/pagebundler_test.go +++ b/hugolib/pagebundler_test.go @@ -24,6 +24,7 @@ import ( "testing" "github.com/gohugoio/hugo/config" + "github.com/gohugoio/hugo/resources/page/pagekinds" "github.com/gohugoio/hugo/hugofs/files" @@ -98,7 +99,7 @@ func TestPageBundlerSiteRegular(t *testing.T) { c.Assert(len(s.RegularPages()), qt.Equals, 8) - singlePage := s.getPage(page.KindPage, "a/1.md") + singlePage := s.getPage(pagekinds.Page, "a/1.md") c.Assert(singlePage.BundleType(), qt.Equals, files.ContentClass("")) c.Assert(singlePage, qt.Not(qt.IsNil)) @@ -144,18 +145,18 @@ func TestPageBundlerSiteRegular(t *testing.T) { // This should be just copied to destination. b.AssertFileContent(filepath.FromSlash("/work/public/assets/pic1.png"), "content") - leafBundle1 := s.getPage(page.KindPage, "b/my-bundle/index.md") + leafBundle1 := s.getPage(pagekinds.Page, "b/my-bundle/index.md") c.Assert(leafBundle1, qt.Not(qt.IsNil)) c.Assert(leafBundle1.BundleType(), qt.Equals, files.ContentClassLeaf) c.Assert(leafBundle1.Section(), qt.Equals, "b") - sectionB := s.getPage(page.KindSection, "b") + sectionB := s.getPage(pagekinds.Section, "b") c.Assert(sectionB, qt.Not(qt.IsNil)) home, _ := s.Info.Home() c.Assert(home.BundleType(), qt.Equals, files.ContentClassBranch) // This is a root bundle and should live in the "home section" // See https://github.com/gohugoio/hugo/issues/4332 - rootBundle := s.getPage(page.KindPage, "root") + rootBundle := s.getPage(pagekinds.Page, "root") c.Assert(rootBundle, qt.Not(qt.IsNil)) c.Assert(rootBundle.Parent().IsHome(), qt.Equals, true) if !ugly { @@ -163,9 +164,9 @@ func TestPageBundlerSiteRegular(t *testing.T) { b.AssertFileContent(filepath.FromSlash("/work/public/cpath/root/cindex.html"), "Single RelPermalink: "+relURLBase+"/cpath/root/") } - leafBundle2 := s.getPage(page.KindPage, "a/b/index.md") + leafBundle2 := s.getPage(pagekinds.Page, "a/b/index.md") c.Assert(leafBundle2, qt.Not(qt.IsNil)) - unicodeBundle := s.getPage(page.KindPage, "c/bundle/index.md") + unicodeBundle := s.getPage(pagekinds.Page, "c/bundle/index.md") c.Assert(unicodeBundle, qt.Not(qt.IsNil)) pageResources := leafBundle1.Resources().ByType(pageResourceType) @@ -290,11 +291,11 @@ func TestPageBundlerSiteMultilingual(t *testing.T) { c.Assert(len(s.RegularPages()), qt.Equals, 8) c.Assert(len(s.Pages()), qt.Equals, 16) - //dumpPages(s.AllPages()...) + // dumpPages(s.AllPages()...) c.Assert(len(s.AllPages()), qt.Equals, 31) - bundleWithSubPath := s.getPage(page.KindPage, "lb/index") + bundleWithSubPath := s.getPage(pagekinds.Page, "lb/index") c.Assert(bundleWithSubPath, qt.Not(qt.IsNil)) // See https://github.com/gohugoio/hugo/issues/4312 @@ -308,22 +309,22 @@ func TestPageBundlerSiteMultilingual(t *testing.T) { // and probably also just b (aka "my-bundle") // These may also be translated, so we also need to test that. // "bf", "my-bf-bundle", "index.md + nn - bfBundle := s.getPage(page.KindPage, "bf/my-bf-bundle/index") + bfBundle := s.getPage(pagekinds.Page, "bf/my-bf-bundle/index") c.Assert(bfBundle, qt.Not(qt.IsNil)) c.Assert(bfBundle.Language().Lang, qt.Equals, "en") - c.Assert(s.getPage(page.KindPage, "bf/my-bf-bundle/index.md"), qt.Equals, bfBundle) - c.Assert(s.getPage(page.KindPage, "bf/my-bf-bundle"), qt.Equals, bfBundle) - c.Assert(s.getPage(page.KindPage, "my-bf-bundle"), qt.Equals, bfBundle) + c.Assert(s.getPage(pagekinds.Page, "bf/my-bf-bundle/index.md"), qt.Equals, bfBundle) + c.Assert(s.getPage(pagekinds.Page, "bf/my-bf-bundle"), qt.Equals, bfBundle) + c.Assert(s.getPage(pagekinds.Page, "my-bf-bundle"), qt.Equals, bfBundle) nnSite := sites.Sites[1] c.Assert(len(nnSite.RegularPages()), qt.Equals, 7) - bfBundleNN := nnSite.getPage(page.KindPage, "bf/my-bf-bundle/index") + bfBundleNN := nnSite.getPage(pagekinds.Page, "bf/my-bf-bundle/index") c.Assert(bfBundleNN, qt.Not(qt.IsNil)) c.Assert(bfBundleNN.Language().Lang, qt.Equals, "nn") - c.Assert(nnSite.getPage(page.KindPage, "bf/my-bf-bundle/index.nn.md"), qt.Equals, bfBundleNN) - c.Assert(nnSite.getPage(page.KindPage, "bf/my-bf-bundle"), qt.Equals, bfBundleNN) - c.Assert(nnSite.getPage(page.KindPage, "my-bf-bundle"), qt.Equals, bfBundleNN) + c.Assert(nnSite.getPage(pagekinds.Page, "bf/my-bf-bundle/index.nn.md"), qt.Equals, bfBundleNN) + c.Assert(nnSite.getPage(pagekinds.Page, "bf/my-bf-bundle"), qt.Equals, bfBundleNN) + c.Assert(nnSite.getPage(pagekinds.Page, "my-bf-bundle"), qt.Equals, bfBundleNN) // See https://github.com/gohugoio/hugo/issues/4295 // Every resource should have its Name prefixed with its base folder. @@ -342,7 +343,7 @@ func TestPageBundlerSiteMultilingual(t *testing.T) { b.AssertFileContent("public/en/bc/data1.json", "data1") b.AssertFileContent("public/en/bc/data2.json", "data2") b.AssertFileContent("public/en/bc/logo-bc.png", "logo") - b.AssertFileContent("public/nn/bc/data1.nn.json", "data1.nn") + b.AssertFileContent("public/nn/bc/data1.json", "data1.nn") b.AssertFileContent("public/nn/bc/data2.json", "data2") b.AssertFileContent("public/nn/bc/logo-bc.png", "logo") }) @@ -382,7 +383,7 @@ func TestMultilingualDisableLanguage(t *testing.T) { c.Assert(len(s.Pages()), qt.Equals, 16) // No nn pages c.Assert(len(s.AllPages()), qt.Equals, 16) - s.pageMap.withEveryBundlePage(func(p *pageState) bool { + s.pageMap.WithEveryBundlePage(func(p *pageState) bool { c.Assert(p.Language().Lang != "nn", qt.Equals, true) return false }) @@ -483,7 +484,7 @@ TheContent. s := b.H.Sites[0] c.Assert(len(s.RegularPages()), qt.Equals, 7) - a1Bundle := s.getPage(page.KindPage, "symbolic2/a1/index.md") + a1Bundle := s.getPage(pagekinds.Page, "symbolic2/a1/index.md") c.Assert(a1Bundle, qt.Not(qt.IsNil)) c.Assert(len(a1Bundle.Resources()), qt.Equals, 2) c.Assert(len(a1Bundle.Resources().ByType(pageResourceType)), qt.Equals, 1) @@ -541,10 +542,10 @@ HEADLESS {{< myShort >}} c.Assert(len(s.RegularPages()), qt.Equals, 1) - regular := s.getPage(page.KindPage, "a/index") + regular := s.getPage(pagekinds.Page, "a/index") c.Assert(regular.RelPermalink(), qt.Equals, "/s1/") - headless := s.getPage(page.KindPage, "b/index") + headless := s.getPage(pagekinds.Page, "b/index") c.Assert(headless, qt.Not(qt.IsNil)) c.Assert(headless.Title(), qt.Equals, "Headless Bundle in Topless Bar") c.Assert(headless.RelPermalink(), qt.Equals, "") @@ -1013,6 +1014,8 @@ slug: %s } func TestBundleMisc(t *testing.T) { + t.Parallel() + config := ` baseURL = "https://example.com" defaultContentLanguage = "en" @@ -1092,15 +1095,15 @@ slug: leaf b.Build(BuildCfg{}) b.AssertFileContent("public/en/index.html", - filepath.FromSlash("section|sect1/sect2/_index.md|CurrentSection: sect1/sect2/_index.md"), - "myen.md|CurrentSection: enonly") + filepath.FromSlash("section|/sect1/sect2|CurrentSection: /sect1/sect2"), + "/enonly/myen|CurrentSection: /enonly|") b.AssertFileContentFn("public/en/index.html", func(s string) bool { // Check ignored files return !regexp.MustCompile("README|ignore").MatchString(s) }) - b.AssertFileContent("public/nn/index.html", filepath.FromSlash("page|sect1/sect2/page.md|CurrentSection: sect1")) + b.AssertFileContent("public/nn/index.html", "page|/sect1/sect2/page|", "CurrentSection: /sect1") b.AssertFileContentFn("public/nn/index.html", func(s string) bool { return !strings.Contains(s, "enonly") }) @@ -1241,23 +1244,28 @@ title: %q } func TestBundleTransformMany(t *testing.T) { - b := newTestSitesBuilder(t).WithSimpleConfigFile().Running() + c := qt.New(t) + + var files strings.Builder + addFile := func(filename, content string) { + files.WriteString(fmt.Sprintf("-- %s --\n%s\n", filename, content)) + } for i := 1; i <= 50; i++ { - b.WithContent(fmt.Sprintf("bundle%d/index.md", i), fmt.Sprintf(` + addFile(fmt.Sprintf("content/bundle%d/index.md", i), fmt.Sprintf(` --- title: "Page" weight: %d --- `, i)) - b.WithSourceFile(fmt.Sprintf("content/bundle%d/data.yaml", i), fmt.Sprintf(`data: v%d`, i)) - b.WithSourceFile(fmt.Sprintf("content/bundle%d/data.json", i), fmt.Sprintf(`{ "data": "v%d" }`, i)) - b.WithSourceFile(fmt.Sprintf("assets/data%d/data.yaml", i), fmt.Sprintf(`vdata: v%d`, i)) + addFile(fmt.Sprintf("content/bundle%d/data.yaml", i), fmt.Sprintf("data: v%d\n", i)) + addFile(fmt.Sprintf("content/bundle%d/data.json", i), fmt.Sprintf("{ \"data\": \"v%d\" }\n", i)) + addFile(fmt.Sprintf("assets/data%d/data.yaml", i), fmt.Sprintf("vdata: v%d\n", i)) } - b.WithTemplatesAdded("_default/single.html", ` + addFile("layouts/_default/single.html", ` {{ $bundleYaml := .Resources.GetMatch "*.yaml" }} {{ $bundleJSON := .Resources.GetMatch "*.json" }} {{ $assetsYaml := resources.GetMatch (printf "data%d/*.yaml" .Weight) }} @@ -1275,13 +1283,19 @@ bundle fingerprinted: {{ $bundleFingerprinted.RelPermalink }} assets fingerprinted: {{ $assetsFingerprinted.RelPermalink }} bundle min min min: {{ $jsonMinMinMin.RelPermalink }} -bundle min min key: {{ $jsonMinMin.Key }} `) + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + Running: true, + TxtarString: files.String(), + }).Build() + for i := 0; i < 3; i++ { - b.Build(BuildCfg{}) + b.Build() for i := 1; i <= 50; i++ { index := fmt.Sprintf("public/bundle%d/index.html", i) @@ -1289,22 +1303,21 @@ bundle min min key: {{ $jsonMinMin.Key }} b.AssertFileContent(index, fmt.Sprintf("data content unmarshaled: v%d", i)) b.AssertFileContent(index, fmt.Sprintf("data assets content unmarshaled: v%d", i)) - md5Asset := helpers.MD5String(fmt.Sprintf(`vdata: v%d`, i)) + md5Asset := helpers.MD5String(fmt.Sprintf("vdata: v%d\n", i)) b.AssertFileContent(index, fmt.Sprintf("assets fingerprinted: /data%d/data.%s.yaml", i, md5Asset)) // The original is not used, make sure it's not published. - b.Assert(b.CheckExists(fmt.Sprintf("public/data%d/data.yaml", i)), qt.Equals, false) + b.AssertDestinationExists(fmt.Sprintf("public/data%d/data.yaml", i), false) - md5Bundle := helpers.MD5String(fmt.Sprintf(`data: v%d`, i)) + md5Bundle := helpers.MD5String(fmt.Sprintf("data: v%d\n", i)) b.AssertFileContent(index, fmt.Sprintf("bundle fingerprinted: /bundle%d/data.%s.yaml", i, md5Bundle)) b.AssertFileContent(index, fmt.Sprintf("bundle min min min: /bundle%d/data.min.min.min.json", i), - fmt.Sprintf("bundle min min key: /bundle%d/data.min.min.json", i), ) - b.Assert(b.CheckExists(fmt.Sprintf("public/bundle%d/data.min.min.min.json", i)), qt.Equals, true) - b.Assert(b.CheckExists(fmt.Sprintf("public/bundle%d/data.min.json", i)), qt.Equals, false) - b.Assert(b.CheckExists(fmt.Sprintf("public/bundle%d/data.min.min.json", i)), qt.Equals, false) + b.AssertDestinationExists(fmt.Sprintf("public/bundle%d/data.min.min.min.json", i), true) + b.AssertDestinationExists(fmt.Sprintf("public/bundle%d/data.min.json", i), false) + b.AssertDestinationExists(fmt.Sprintf("public/bundle%d/data.min.min.json", i), false) } diff --git a/hugolib/pagecollections.go b/hugolib/pagecollections.go index 811fb602553..801428ab4ee 100644 --- a/hugolib/pagecollections.go +++ b/hugolib/pagecollections.go @@ -20,12 +20,13 @@ import ( "strings" "sync" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gohugoio/hugo/common/paths" + "github.com/gohugoio/hugo/hugofs" "github.com/gohugoio/hugo/hugofs/files" - "github.com/gohugoio/hugo/helpers" - "github.com/gohugoio/hugo/resources/page" ) @@ -88,11 +89,11 @@ func newPageCollections(m *pageMap) *PageCollections { c := &PageCollections{pageMap: m} c.pages = newLazyPagesFactory(func() page.Pages { - return m.createListAllPages() + return m.CreateListAllPages() }) c.regularPages = newLazyPagesFactory(func() page.Pages { - return c.findPagesByKindIn(page.KindPage, c.pages.get()) + return c.findPagesByKindIn(pagekinds.Page, c.pages.get()) }) return c @@ -120,10 +121,10 @@ func (c *PageCollections) getPageOldVersion(ref ...string) (page.Page, error) { return nil, fmt.Errorf(`too many arguments to .Site.GetPage: %v. Use lookups on the form {{ .Site.GetPage "/posts/mypage-md" }}`, ref) } - if len(refs) == 0 || refs[0] == page.KindHome { + if len(refs) == 0 || refs[0] == pagekinds.Home { key = "/" } else if len(refs) == 1 { - if len(ref) == 2 && refs[0] == page.KindSection { + if len(ref) == 2 && refs[0] == pagekinds.Section { // This is an old style reference to the "Home Page section". // Typically fetched via {{ .Site.GetPage "section" .Section }} // See https://github.com/gohugoio/hugo/issues/4989 @@ -161,86 +162,96 @@ func (c *PageCollections) getPageRef(context page.Page, ref string) (page.Page, } func (c *PageCollections) getPageNew(context page.Page, ref string) (page.Page, error) { - n, err := c.getContentNode(context, false, ref) + n, err := c.getContentNode(context, false, filepath.ToSlash(ref)) if err != nil || n == nil || n.p == nil { return nil, err } return n.p, nil } -func (c *PageCollections) getSectionOrPage(ref string) (*contentNode, string) { - var n *contentNode - - pref := helpers.AddTrailingSlash(ref) - s, v, found := c.pageMap.sections.LongestPrefix(pref) - - if found { - n = v.(*contentNode) - } - - if found && s == pref { - // A section - return n, "" - } - +func (c *PageCollections) getContentNode(context page.Page, isReflink bool, ref string) (*contentNode, error) { + navUp := strings.HasPrefix(ref, "..") + inRef := ref m := c.pageMap - filename := strings.TrimPrefix(strings.TrimPrefix(ref, s), "/") - langSuffix := "." + m.s.Lang() + cleanRef := func(s string) (string, bundleDirType) { + key := cleanTreeKey(s) + if !strings.HasSuffix(key, ".") { + key = paths.PathNoExt(key) + } + key = strings.TrimSuffix(key, "."+m.s.Lang()) - // Trim both extension and any language code. - name := paths.PathNoExt(filename) - name = strings.TrimSuffix(name, langSuffix) + isBranch := strings.HasSuffix(key, "/_index") + isLeaf := strings.HasSuffix(key, "/index") + key = strings.TrimSuffix(key, "/_index") + if !isBranch { + key = strings.TrimSuffix(key, "/index") + } - // These are reserved bundle names and will always be stored by their owning - // folder name. - name = strings.TrimSuffix(name, "/index") - name = strings.TrimSuffix(name, "/_index") + if isBranch { + return key, bundleBranch + } - if !found { - return nil, name - } + if isLeaf { + return key, bundleLeaf + } - // Check if it's a section with filename provided. - if !n.p.File().IsZero() && n.p.File().LogicalName() == filename { - return n, name + return key, bundleNot } - return m.getPage(s, name), name -} - -// For Ref/Reflink and .Site.GetPage do simple name lookups for the potentially ambigous myarticle.md and /myarticle.md, -// but not when we get ./myarticle*, section/myarticle. -func shouldDoSimpleLookup(ref string) bool { - if ref[0] == '.' { - return false - } + refKey, bundleTp := cleanRef(ref) - slashCount := strings.Count(ref, "/") + getNode := func(refKey string, bundleTp bundleDirType) (*contentNode, error) { + if bundleTp == bundleBranch { + b := c.pageMap.Get(refKey) + if b == nil { + return nil, nil + } + return b.n, nil + } else if bundleTp == bundleLeaf { + n := m.GetLeaf(refKey) + if n == nil { + n = m.GetLeaf(refKey + "/index") + } + if n != nil { + return n, nil + } + } else { + n := m.GetBranchOrLeaf(refKey) + if n != nil { + return n, nil + } + } - if slashCount > 1 { - return false - } + rfs := m.s.BaseFs.Content.Fs.(hugofs.ReverseLookupProvider) + // Try first with the ref as is. It may be a file mount. + realToVirtual, err := rfs.ReverseLookup(ref) + if err != nil { + return nil, err + } - return slashCount == 0 || ref[0] == '/' -} + if realToVirtual == "" { + realToVirtual, err = rfs.ReverseLookup(refKey) + if err != nil { + return nil, err + } + } -func (c *PageCollections) getContentNode(context page.Page, isReflink bool, ref string) (*contentNode, error) { - ref = filepath.ToSlash(strings.ToLower(strings.TrimSpace(ref))) + if realToVirtual != "" { + key, _ := cleanRef(realToVirtual) - if ref == "" { - ref = "/" - } + n := m.GetBranchOrLeaf(key) + if n != nil { + return n, nil + } + } - inRef := ref - navUp := strings.HasPrefix(ref, "..") - var doSimpleLookup bool - if isReflink || context == nil { - doSimpleLookup = shouldDoSimpleLookup(ref) + return nil, nil } if context != nil && !strings.HasPrefix(ref, "/") { - // Try the page-relative path. + + // Try the page-relative path first. var base string if context.File().IsZero() { base = context.SectionsPath() @@ -256,68 +267,32 @@ func (c *PageCollections) getContentNode(context page.Page, isReflink bool, ref } } } - ref = path.Join("/", strings.ToLower(base), ref) - } - if !strings.HasPrefix(ref, "/") { - ref = "/" + ref - } - - m := c.pageMap + s, _ := cleanRef(path.Join(base, ref)) - // It's either a section, a page in a section or a taxonomy node. - // Start with the most likely: - n, name := c.getSectionOrPage(ref) - if n != nil { - return n, nil - } - - if !strings.HasPrefix(inRef, "/") { - // Many people will have "post/foo.md" in their content files. - if n, _ := c.getSectionOrPage("/" + inRef); n != nil { - return n, nil + n, err := getNode(s, bundleTp) + if n != nil || err != nil { + return n, err } - } - // Check if it's a taxonomy node - pref := helpers.AddTrailingSlash(ref) - s, v, found := m.taxonomies.LongestPrefix(pref) - - if found { - if !m.onSameLevel(pref, s) { - return nil, nil - } - return v.(*contentNode), nil } - getByName := func(s string) (*contentNode, error) { - n := m.pageReverseIndex.Get(s) - if n != nil { - if n == ambiguousContentNode { - return nil, fmt.Errorf("page reference %q is ambiguous", ref) - } - return n, nil - } - + if strings.HasPrefix(ref, ".") { + // Page relative, no need to look further. return nil, nil } - var module string - if context != nil && !context.File().IsZero() { - module = context.File().FileInfo().Meta().Module - } + n, err := getNode(refKey, bundleTp) - if module == "" && !c.pageMap.s.home.File().IsZero() { - module = c.pageMap.s.home.File().FileInfo().Meta().Module + if n != nil || err != nil { + return n, err } - if module != "" { - n, err := getByName(module + ref) - if err != nil { - return nil, err - } - if n != nil { - return n, nil + var doSimpleLookup bool + if isReflink || context == nil { + slashCount := strings.Count(inRef, "/") + if slashCount <= 1 { + doSimpleLookup = slashCount == 0 || ref[0] == '/' } } @@ -325,8 +300,12 @@ func (c *PageCollections) getContentNode(context page.Page, isReflink bool, ref return nil, nil } - // Ref/relref supports this potentially ambigous lookup. - return getByName(path.Base(name)) + n = m.pageReverseIndex.Get(cleanTreeKey(path.Base(refKey))) + if n == ambiguousContentNode { + return nil, fmt.Errorf("page reference %q is ambiguous", ref) + } + + return n, nil } func (*PageCollections) findPagesByKindIn(kind string, inPages page.Pages) page.Pages { diff --git a/hugolib/pagecollections_test.go b/hugolib/pagecollections_test.go index d664b7f4e56..6e9fe364535 100644 --- a/hugolib/pagecollections_test.go +++ b/hugolib/pagecollections_test.go @@ -15,6 +15,9 @@ package hugolib import ( "fmt" + + "github.com/gohugoio/hugo/resources/page/pagekinds" + "math/rand" "path" "path/filepath" @@ -218,72 +221,72 @@ func TestGetPage(t *testing.T) { tests := []getPageTest{ // legacy content root relative paths - {"Root relative, no slash, home", page.KindHome, nil, []string{""}, "home page"}, - {"Root relative, no slash, root page", page.KindPage, nil, []string{"about.md", "ABOUT.md"}, "about page"}, - {"Root relative, no slash, section", page.KindSection, nil, []string{"sect3"}, "section 3"}, - {"Root relative, no slash, section page", page.KindPage, nil, []string{"sect3/page1.md"}, "Title3_1"}, - {"Root relative, no slash, sub setion", page.KindSection, nil, []string{"sect3/sect7"}, "another sect7"}, - {"Root relative, no slash, nested page", page.KindPage, nil, []string{"sect3/subsect/deep.md"}, "deep page"}, - {"Root relative, no slash, OS slashes", page.KindPage, nil, []string{filepath.FromSlash("sect5/page3.md")}, "Title5_3"}, - - {"Short ref, unique", page.KindPage, nil, []string{"unique.md", "unique"}, "UniqueBase"}, - {"Short ref, unique, upper case", page.KindPage, nil, []string{"Unique2.md", "unique2.md", "unique2"}, "UniqueBase2"}, + {"Root relative, no slash, home", pagekinds.Home, nil, []string{""}, "home page"}, + {"Root relative, no slash, root page", pagekinds.Page, nil, []string{"about.md", "ABOUT.md"}, "about page"}, + {"Root relative, no slash, section", pagekinds.Section, nil, []string{"sect3"}, "section 3"}, + {"Root relative, no slash, section page", pagekinds.Page, nil, []string{"sect3/page1.md"}, "Title3_1"}, + {"Root relative, no slash, sub setion", pagekinds.Section, nil, []string{"sect3/sect7"}, "another sect7"}, + {"Root relative, no slash, nested page", pagekinds.Page, nil, []string{"sect3/subsect/deep.md"}, "deep page"}, + {"Root relative, no slash, OS slashes", pagekinds.Page, nil, []string{filepath.FromSlash("sect5/page3.md")}, "Title5_3"}, + + {"Short ref, unique", pagekinds.Page, nil, []string{"unique.md", "unique"}, "UniqueBase"}, + {"Short ref, unique, upper case", pagekinds.Page, nil, []string{"Unique2.md", "unique2.md", "unique2"}, "UniqueBase2"}, {"Short ref, ambiguous", "Ambiguous", nil, []string{"page1.md"}, ""}, // ISSUE: This is an ambiguous ref, but because we have to support the legacy // content root relative paths without a leading slash, the lookup // returns /sect7. This undermines ambiguity detection, but we have no choice. //{"Ambiguous", nil, []string{"sect7"}, ""}, - {"Section, ambigous", page.KindSection, nil, []string{"sect7"}, "Sect7s"}, - - {"Absolute, home", page.KindHome, nil, []string{"/", ""}, "home page"}, - {"Absolute, page", page.KindPage, nil, []string{"/about.md", "/about"}, "about page"}, - {"Absolute, sect", page.KindSection, nil, []string{"/sect3"}, "section 3"}, - {"Absolute, page in subsection", page.KindPage, nil, []string{"/sect3/page1.md", "/Sect3/Page1.md"}, "Title3_1"}, - {"Absolute, section, subsection with same name", page.KindSection, nil, []string{"/sect3/sect7"}, "another sect7"}, - {"Absolute, page, deep", page.KindPage, nil, []string{"/sect3/subsect/deep.md"}, "deep page"}, - {"Absolute, page, OS slashes", page.KindPage, nil, []string{filepath.FromSlash("/sect5/page3.md")}, "Title5_3"}, // test OS-specific path - {"Absolute, unique", page.KindPage, nil, []string{"/sect3/unique.md"}, "UniqueBase"}, - {"Absolute, unique, case", page.KindPage, nil, []string{"/sect3/Unique2.md", "/sect3/unique2.md", "/sect3/unique2", "/sect3/Unique2"}, "UniqueBase2"}, + {"Section, ambigous", pagekinds.Section, nil, []string{"sect7"}, "Sect7s"}, + + {"Absolute, home", pagekinds.Home, nil, []string{"/", ""}, "home page"}, + {"Absolute, page", pagekinds.Page, nil, []string{"/about.md", "/about"}, "about page"}, + {"Absolute, sect", pagekinds.Section, nil, []string{"/sect3"}, "section 3"}, + {"Absolute, page in subsection", pagekinds.Page, nil, []string{"/sect3/page1.md", "/Sect3/Page1.md"}, "Title3_1"}, + {"Absolute, section, subsection with same name", pagekinds.Section, nil, []string{"/sect3/sect7"}, "another sect7"}, + {"Absolute, page, deep", pagekinds.Page, nil, []string{"/sect3/subsect/deep.md"}, "deep page"}, + {"Absolute, page, OS slashes", pagekinds.Page, nil, []string{filepath.FromSlash("/sect5/page3.md")}, "Title5_3"}, // test OS-specific path + {"Absolute, unique", pagekinds.Page, nil, []string{"/sect3/unique.md"}, "UniqueBase"}, + {"Absolute, unique, case", pagekinds.Page, nil, []string{"/sect3/Unique2.md", "/sect3/unique2.md", "/sect3/unique2", "/sect3/Unique2"}, "UniqueBase2"}, // next test depends on this page existing // {"NoPage", nil, []string{"/unique.md"}, ""}, // ISSUE #4969: this is resolving to /sect3/unique.md {"Absolute, missing page", "NoPage", nil, []string{"/missing-page.md"}, ""}, {"Absolute, missing section", "NoPage", nil, []string{"/missing-section"}, ""}, // relative paths - {"Dot relative, home", page.KindHome, sec3, []string{".."}, "home page"}, - {"Dot relative, home, slash", page.KindHome, sec3, []string{"../"}, "home page"}, - {"Dot relative about", page.KindPage, sec3, []string{"../about.md"}, "about page"}, - {"Dot", page.KindSection, sec3, []string{"."}, "section 3"}, - {"Dot slash", page.KindSection, sec3, []string{"./"}, "section 3"}, - {"Page relative, no dot", page.KindPage, sec3, []string{"page1.md"}, "Title3_1"}, - {"Page relative, dot", page.KindPage, sec3, []string{"./page1.md"}, "Title3_1"}, - {"Up and down another section", page.KindPage, sec3, []string{"../sect4/page2.md"}, "Title4_2"}, - {"Rel sect7", page.KindSection, sec3, []string{"sect7"}, "another sect7"}, - {"Rel sect7 dot", page.KindSection, sec3, []string{"./sect7"}, "another sect7"}, - {"Dot deep", page.KindPage, sec3, []string{"./subsect/deep.md"}, "deep page"}, - {"Dot dot inner", page.KindPage, sec3, []string{"./subsect/../../sect7/page9.md"}, "Title7_9"}, - {"Dot OS slash", page.KindPage, sec3, []string{filepath.FromSlash("../sect5/page3.md")}, "Title5_3"}, // test OS-specific path - {"Dot unique", page.KindPage, sec3, []string{"./unique.md"}, "UniqueBase"}, + {"Dot relative, home", pagekinds.Home, sec3, []string{".."}, "home page"}, + {"Dot relative, home, slash", pagekinds.Home, sec3, []string{"../"}, "home page"}, + {"Dot relative about", pagekinds.Page, sec3, []string{"../about.md"}, "about page"}, + {"Dot", pagekinds.Section, sec3, []string{"."}, "section 3"}, + {"Dot slash", pagekinds.Section, sec3, []string{"./"}, "section 3"}, + {"Page relative, no dot", pagekinds.Page, sec3, []string{"page1.md"}, "Title3_1"}, + {"Page relative, dot", pagekinds.Page, sec3, []string{"./page1.md"}, "Title3_1"}, + {"Up and down another section", pagekinds.Page, sec3, []string{"../sect4/page2.md"}, "Title4_2"}, + {"Rel sect7", pagekinds.Section, sec3, []string{"sect7"}, "another sect7"}, + {"Rel sect7 dot", pagekinds.Section, sec3, []string{"./sect7"}, "another sect7"}, + {"Dot deep", pagekinds.Page, sec3, []string{"./subsect/deep.md"}, "deep page"}, + {"Dot dot inner", pagekinds.Page, sec3, []string{"./subsect/../../sect7/page9.md"}, "Title7_9"}, + {"Dot OS slash", pagekinds.Page, sec3, []string{filepath.FromSlash("../sect5/page3.md")}, "Title5_3"}, // test OS-specific path + {"Dot unique", pagekinds.Page, sec3, []string{"./unique.md"}, "UniqueBase"}, {"Dot sect", "NoPage", sec3, []string{"./sect2"}, ""}, //{"NoPage", sec3, []string{"sect2"}, ""}, // ISSUE: /sect3 page relative query is resolving to /sect2 - {"Abs, ignore context, home", page.KindHome, sec3, []string{"/"}, "home page"}, - {"Abs, ignore context, about", page.KindPage, sec3, []string{"/about.md"}, "about page"}, - {"Abs, ignore context, page in section", page.KindPage, sec3, []string{"/sect4/page2.md"}, "Title4_2"}, - {"Abs, ignore context, page subsect deep", page.KindPage, sec3, []string{"/sect3/subsect/deep.md"}, "deep page"}, // next test depends on this page existing + {"Abs, ignore context, home", pagekinds.Home, sec3, []string{"/"}, "home page"}, + {"Abs, ignore context, about", pagekinds.Page, sec3, []string{"/about.md"}, "about page"}, + {"Abs, ignore context, page in section", pagekinds.Page, sec3, []string{"/sect4/page2.md"}, "Title4_2"}, + {"Abs, ignore context, page subsect deep", pagekinds.Page, sec3, []string{"/sect3/subsect/deep.md"}, "deep page"}, // next test depends on this page existing {"Abs, ignore context, page deep", "NoPage", sec3, []string{"/subsect/deep.md"}, ""}, // Taxonomies - {"Taxonomy term", page.KindTaxonomy, nil, []string{"categories"}, "Categories"}, - {"Taxonomy", page.KindTerm, nil, []string{"categories/hugo", "categories/Hugo"}, "Hugo"}, + {"Taxonomy term", pagekinds.Taxonomy, nil, []string{"categories"}, "Categories"}, + {"Taxonomy", pagekinds.Term, nil, []string{"categories/hugo", "categories/Hugo"}, "Hugo"}, // Bundle variants - {"Bundle regular", page.KindPage, nil, []string{"sect3/b1", "sect3/b1/index.md", "sect3/b1/index.en.md"}, "b1 bundle"}, - {"Bundle index name", page.KindPage, nil, []string{"sect3/index/index.md", "sect3/index"}, "index bundle"}, + {"Bundle regular", pagekinds.Page, nil, []string{"sect3/b1", "sect3/b1/index.md", "sect3/b1/index.en.md"}, "b1 bundle"}, + {"Bundle index name", pagekinds.Page, nil, []string{"sect3/index/index.md", "sect3/index"}, "index bundle"}, // https://github.com/gohugoio/hugo/issues/7301 - {"Section and bundle overlap", page.KindPage, nil, []string{"section_bundle_overlap_bundle"}, "index overlap bundle"}, + {"Section and bundle overlap", pagekinds.Page, nil, []string{"section_bundle_overlap_bundle"}, "index overlap bundle"}, } for _, test := range tests { @@ -372,15 +375,6 @@ NOT FOUND b.AssertFileContent("public/en/index.html", `NOT FOUND`) } -func TestShouldDoSimpleLookup(t *testing.T) { - c := qt.New(t) - - c.Assert(shouldDoSimpleLookup("foo.md"), qt.Equals, true) - c.Assert(shouldDoSimpleLookup("/foo.md"), qt.Equals, true) - c.Assert(shouldDoSimpleLookup("./foo.md"), qt.Equals, false) - c.Assert(shouldDoSimpleLookup("docs/foo.md"), qt.Equals, false) -} - func TestRegularPagesRecursive(t *testing.T) { b := newTestSitesBuilder(t) diff --git a/hugolib/pages_capture.go b/hugolib/pages_capture.go index da7515fc22b..b4ac1cfc957 100644 --- a/hugolib/pages_capture.go +++ b/hugolib/pages_capture.go @@ -1,4 +1,4 @@ -// Copyright 2019 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -19,13 +19,8 @@ import ( "os" pth "path" "path/filepath" - "reflect" - "github.com/gohugoio/hugo/common/maps" - - "github.com/gohugoio/hugo/parser/pageparser" - - "github.com/gohugoio/hugo/hugofs/files" + "github.com/gohugoio/hugo/common/paths" "github.com/gohugoio/hugo/source" @@ -34,23 +29,19 @@ import ( "github.com/spf13/afero" ) -const ( - walkIsRootFileMetaKey = "walkIsRootFileMetaKey" -) - func newPagesCollector( sp *source.SourceSpec, contentMap *pageMaps, logger loggers.Logger, contentTracker *contentChangeMap, - proc pagesCollectorProcessorProvider, filenames ...string) *pagesCollector { + proc pagesCollectorProcessorProvider, ids paths.PathInfos) *pagesCollector { return &pagesCollector{ fs: sp.SourceFs, contentMap: contentMap, proc: proc, sp: sp, logger: logger, - filenames: filenames, + ids: ids, tracker: contentTracker, } } @@ -86,7 +77,8 @@ type pagesCollector struct { contentMap *pageMaps // Ordered list (bundle headers first) used in partial builds. - filenames []string + // TODO1 check order + ids paths.PathInfos // Content files tracker used in partial builds. tracker *contentChangeMap @@ -94,70 +86,9 @@ type pagesCollector struct { proc pagesCollectorProcessorProvider } -// isCascadingEdit returns whether the dir represents a cascading edit. -// That is, if a front matter cascade section is removed, added or edited. -// If this is the case we must re-evaluate its descendants. -func (c *pagesCollector) isCascadingEdit(dir contentDirKey) (bool, string) { - // This is either a section or a taxonomy node. Find it. - prefix := cleanTreeKey(dir.dirname) - - section := "/" - var isCascade bool - - c.contentMap.walkBranchesPrefix(prefix, func(s string, n *contentNode) bool { - if n.fi == nil || dir.filename != n.fi.Meta().Filename { - return false - } - - f, err := n.fi.Meta().Open() - if err != nil { - // File may have been removed, assume a cascading edit. - // Some false positives is not too bad. - isCascade = true - return true - } - - pf, err := pageparser.ParseFrontMatterAndContent(f) - f.Close() - if err != nil { - isCascade = true - return true - } - - if n.p == nil || n.p.bucket == nil { - return true - } - - section = s - - maps.PrepareParams(pf.FrontMatter) - cascade1, ok := pf.FrontMatter["cascade"] - hasCascade := n.p.bucket.cascade != nil && len(n.p.bucket.cascade) > 0 - if !ok { - isCascade = hasCascade - - return true - } - - if !hasCascade { - isCascade = true - return true - } - - for _, v := range n.p.bucket.cascade { - isCascade = !reflect.DeepEqual(cascade1, v) - if isCascade { - break - } - } - - return true - }) - - return isCascade, section -} - -// Collect. +// Collect collects content by walking the file system and storing +// it in the content tree. +// It may be restricted by filenames set on the collector (partial build). func (c *pagesCollector) Collect() (collectErr error) { c.proc.Start(context.Background()) defer func() { @@ -167,38 +98,23 @@ func (c *pagesCollector) Collect() (collectErr error) { } }() - if len(c.filenames) == 0 { + if c.ids == nil { // Collect everything. - collectErr = c.collectDir("", false, nil) + collectErr = c.collectDir(nil, false, nil) } else { for _, pm := range c.contentMap.pmaps { pm.cfg.isRebuild = true } - dirs := make(map[contentDirKey]bool) - for _, filename := range c.filenames { - dir, btype := c.tracker.resolveAndRemove(filename) - dirs[contentDirKey{dir, filename, btype}] = true - } - - for dir := range dirs { - for _, pm := range c.contentMap.pmaps { - pm.s.ResourceSpec.DeleteBySubstring(dir.dirname) - } - switch dir.tp { - case bundleLeaf: - collectErr = c.collectDir(dir.dirname, true, nil) - case bundleBranch: - isCascading, section := c.isCascadingEdit(dir) - - if isCascading { - c.contentMap.deleteSection(section) - } - collectErr = c.collectDir(dir.dirname, !isCascading, nil) - default: + for _, id := range c.ids { + if id.IsLeafBundle() { + collectErr = c.collectDir(id.Path, true, nil) + } else if id.IsBranchBundle() { + collectErr = c.collectDir(id.Path, true, nil) + } else { // We always start from a directory. - collectErr = c.collectDir(dir.dirname, true, func(fim hugofs.FileMetaInfo) bool { - return dir.filename == fim.Meta().Filename + collectErr = c.collectDir(id.Path, true, func(fim hugofs.FileMetaInfo) bool { + return id.Filename() == fim.Meta().Filename }) } @@ -212,11 +128,6 @@ func (c *pagesCollector) Collect() (collectErr error) { return } -func (c *pagesCollector) isBundleHeader(fi hugofs.FileMetaInfo) bool { - class := fi.Meta().Classifier - return class == files.ContentClassLeaf || class == files.ContentClassBranch -} - func (c *pagesCollector) getLang(fi hugofs.FileMetaInfo) string { lang := fi.Meta().Lang if lang != "" { @@ -226,11 +137,7 @@ func (c *pagesCollector) getLang(fi hugofs.FileMetaInfo) string { return c.sp.DefaultContentLanguage } -func (c *pagesCollector) addToBundle(info hugofs.FileMetaInfo, btyp bundleDirType, bundles pageBundles) error { - getBundle := func(lang string) *fileinfoBundle { - return bundles[lang] - } - +func (c *pagesCollector) addToBundle(info hugofs.FileMetaInfo, btyp paths.BundleType, bundles pageBundles) error { cloneBundle := func(lang string) *fileinfoBundle { // Every bundled content file needs a content file header. // Use the default content language if found, else just @@ -259,23 +166,21 @@ func (c *pagesCollector) addToBundle(info hugofs.FileMetaInfo, btyp bundleDirTyp header: clone, } } - + pi := info.Meta().PathInfo lang := c.getLang(info) - bundle := getBundle(lang) - isBundleHeader := c.isBundleHeader(info) + bundle := bundles[lang] + isBundleHeader := pi.IsBundle() if bundle != nil && isBundleHeader { // index.md file inside a bundle, see issue 6208. - info.Meta().Classifier = files.ContentClassContent + paths.ModifyPathBundleNone(info.Meta().PathInfo) isBundleHeader = false } - classifier := info.Meta().Classifier - isContent := classifier == files.ContentClassContent if bundle == nil { if isBundleHeader { bundle = &fileinfoBundle{header: info} bundles[lang] = bundle } else { - if btyp == bundleBranch { + if btyp == paths.BundleTypeBranch { // No special logic for branch bundles. // Every language needs its own _index.md file. // Also, we only clone bundle headers for lonesome, bundled, @@ -283,7 +188,7 @@ func (c *pagesCollector) addToBundle(info hugofs.FileMetaInfo, btyp bundleDirTyp return c.handleFiles(info) } - if isContent { + if pi.IsContent() { bundle = cloneBundle(lang) bundles[lang] = bundle } @@ -294,12 +199,12 @@ func (c *pagesCollector) addToBundle(info hugofs.FileMetaInfo, btyp bundleDirTyp bundle.resources = append(bundle.resources, info) } - if classifier == files.ContentClassFile { + if !(pi.IsBundle() || pi.IsContent()) { + // E.g. a data file; make sure it's available in all languages. translations := info.Meta().Translations for lang, b := range bundles { if !stringSliceContains(lang, translations...) && !b.containsResource(info.Name()) { - // Clone and add it to the bundle. clone := c.cloneFileInfo(info) clone.Meta().Lang = lang @@ -315,7 +220,12 @@ func (c *pagesCollector) cloneFileInfo(fi hugofs.FileMetaInfo) hugofs.FileMetaIn return hugofs.NewFileMetaInfo(fi, hugofs.NewFileMeta()) } -func (c *pagesCollector) collectDir(dirname string, partial bool, inFilter func(fim hugofs.FileMetaInfo) bool) error { +func (c *pagesCollector) collectDir(dir *paths.Path, partial bool, inFilter func(fim hugofs.FileMetaInfo) bool) error { + var dirname string + if dir != nil { + dirname = filepath.FromSlash(dir.Dir()) + } + fi, err := c.fs.Stat(dirname) if err != nil { if os.IsNotExist(err) { @@ -326,21 +236,24 @@ func (c *pagesCollector) collectDir(dirname string, partial bool, inFilter func( } handleDir := func( - btype bundleDirType, + btype paths.BundleType, dir hugofs.FileMetaInfo, path string, readdir []hugofs.FileMetaInfo) error { - if btype > bundleNot && c.tracker != nil { - c.tracker.add(path, btype) - } - if btype == bundleBranch { + /* + TODO1 + if btype > paths.BundleTypeNone && c.tracker != nil { + c.tracker.add(path, btype) + }*/ + + if btype == paths.BundleTypeBranch { if err := c.handleBundleBranch(readdir); err != nil { return err } // A branch bundle is only this directory level, so keep walking. return nil - } else if btype == bundleLeaf { + } else if btype == paths.BundleTypeLeaf { if err := c.handleBundleLeaf(dir, path, readdir); err != nil { return err } @@ -371,7 +284,7 @@ func (c *pagesCollector) collectDir(dirname string, partial bool, inFilter func( } preHook := func(dir hugofs.FileMetaInfo, path string, readdir []hugofs.FileMetaInfo) ([]hugofs.FileMetaInfo, error) { - var btype bundleDirType + var btype paths.BundleType filtered := readdir[:0] for _, fi := range readdir { @@ -387,10 +300,13 @@ func (c *pagesCollector) collectDir(dirname string, partial bool, inFilter func( walkRoot := dir.Meta().IsRootFile readdir = filtered - // We merge language directories, so there can be duplicates, but they - // will be ordered, most important first. - var duplicates []int - seen := make(map[string]bool) + var ( + // We merge language directories, so there can be duplicates, but they + // will be ordered, most important first. + duplicates []int + seen = make(map[string]bool) + bundleFileCounter int + ) for i, fi := range readdir { @@ -398,10 +314,14 @@ func (c *pagesCollector) collectDir(dirname string, partial bool, inFilter func( continue } + // TODO1 PathInfo vs BundleType vs HTML with not front matter. + meta := fi.Meta() + pi := meta.PathInfo + meta.IsRootFile = walkRoot - class := meta.Classifier - translationBase := meta.TranslationBaseNameWithExt + // TODO1 remove the classifier class := meta.Classifier + translationBase := meta.PathInfo.NameNoLang() key := pth.Join(meta.Lang, translationBase) if seen[key] { @@ -410,26 +330,20 @@ func (c *pagesCollector) collectDir(dirname string, partial bool, inFilter func( } seen[key] = true - var thisBtype bundleDirType - - switch class { - case files.ContentClassLeaf: - thisBtype = bundleLeaf - case files.ContentClassBranch: - thisBtype = bundleBranch + if pi.IsBundle() { + btype = pi.BundleType() + bundleFileCounter++ } // Folders with both index.md and _index.md type of files have // undefined behaviour and can never work. // The branch variant will win because of sort order, but log // a warning about it. - if thisBtype > bundleNot && btype > bundleNot && thisBtype != btype { + if bundleFileCounter > 1 { c.logger.Warnf("Content directory %q have both index.* and _index.* files, pick one.", dir.Meta().Filename) // Reclassify it so it will be handled as a content file inside the // section, which is in line with the <= 0.55 behaviour. - meta.Classifier = files.ContentClassContent - } else if thisBtype > bundleNot { - btype = thisBtype + // TODO1 create issue, we now make it a bundle. meta.Classifier = files.ContentClassContent } } @@ -446,7 +360,7 @@ func (c *pagesCollector) collectDir(dirname string, partial bool, inFilter func( return nil, err } - if btype == bundleLeaf || partial { + if btype == paths.BundleTypeLeaf || partial { return nil, filepath.SkipDir } @@ -477,6 +391,7 @@ func (c *pagesCollector) collectDir(dirname string, partial bool, inFilter func( fim := fi.(hugofs.FileMetaInfo) // Make sure the pages in this directory gets re-rendered, // even in fast render mode. + // TODO1 fim.Meta().IsRootFile = true w := hugofs.NewWalkway(hugofs.WalkwayConfig{ @@ -499,22 +414,19 @@ func (c *pagesCollector) handleBundleBranch(readdir []hugofs.FileMetaInfo) error var contentFiles []hugofs.FileMetaInfo for _, fim := range readdir { - if fim.IsDir() { continue } - meta := fim.Meta() - - switch meta.Classifier { - case files.ContentClassContent: + pi := fim.Meta().PathInfo + if !pi.IsBundle() && pi.IsContent() { contentFiles = append(contentFiles, fim) - default: - if err := c.addToBundle(fim, bundleBranch, bundles); err != nil { - return err - } + continue } + if err := c.addToBundle(fim, paths.BundleTypeBranch, bundles); err != nil { + return err + } } // Make sure the section is created before its pages. @@ -537,7 +449,7 @@ func (c *pagesCollector) handleBundleLeaf(dir hugofs.FileMetaInfo, path string, return nil } - return c.addToBundle(info, bundleLeaf, bundles) + return c.addToBundle(info, paths.BundleTypeLeaf, bundles) } // Start a new walker from the given path. diff --git a/hugolib/pages_capture_test.go b/hugolib/pages_capture_test.go index 4b2979a0ada..98913f57efc 100644 --- a/hugolib/pages_capture_test.go +++ b/hugolib/pages_capture_test.go @@ -56,7 +56,7 @@ func TestPagesCapture(t *testing.T) { t.Run("Collect", func(t *testing.T) { c := qt.New(t) proc := &testPagesCollectorProcessor{} - coll := newPagesCollector(sourceSpec, nil, loggers.NewErrorLogger(), nil, proc) + coll := newPagesCollector(sourceSpec, nil, loggers.NewErrorLogger(), nil, proc, nil) c.Assert(coll.Collect(), qt.IsNil) c.Assert(len(proc.items), qt.Equals, 4) }) diff --git a/hugolib/resource_chain_babel_test.go b/hugolib/resource_chain_babel_test.go deleted file mode 100644 index 7a97e820a54..00000000000 --- a/hugolib/resource_chain_babel_test.go +++ /dev/null @@ -1,146 +0,0 @@ -// Copyright 2020 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" - "os" - "path/filepath" - "testing" - - "github.com/gohugoio/hugo/config" - - jww "github.com/spf13/jwalterweatherman" - - "github.com/gohugoio/hugo/htesting" - - qt "github.com/frankban/quicktest" - - "github.com/gohugoio/hugo/hugofs" - - "github.com/gohugoio/hugo/common/loggers" -) - -func TestResourceChainBabel(t *testing.T) { - if !htesting.IsCI() { - t.Skip("skip (relative) long running modules test when running locally") - } - - wd, _ := os.Getwd() - defer func() { - os.Chdir(wd) - }() - - c := qt.New(t) - - packageJSON := `{ - "scripts": {}, - - "devDependencies": { - "@babel/cli": "7.8.4", - "@babel/core": "7.9.0", - "@babel/preset-env": "7.9.5" - } -} -` - - babelConfig := ` -console.error("Hugo Environment:", process.env.HUGO_ENVIRONMENT ); - -module.exports = { - presets: ["@babel/preset-env"], -}; - -` - - js := ` -/* A Car */ -class Car { - constructor(brand) { - this.carname = brand; - } -} -` - - js2 := ` -/* A Car2 */ -class Car2 { - constructor(brand) { - this.carname = brand; - } -} -` - - workDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-test-babel") - c.Assert(err, qt.IsNil) - defer clean() - - var logBuf bytes.Buffer - logger := loggers.NewBasicLoggerForWriter(jww.LevelInfo, &logBuf) - - v := config.New() - v.Set("workingDir", workDir) - v.Set("disableKinds", []string{"taxonomy", "term", "page"}) - v.Set("security", map[string]interface{}{ - "exec": map[string]interface{}{ - "allow": []string{"^npx$", "^babel$"}, - }, - }) - - b := newTestSitesBuilder(t).WithLogger(logger) - - // Need to use OS fs for this. - b.Fs = hugofs.NewDefault(v) - b.WithWorkingDir(workDir) - b.WithViper(v) - b.WithContent("p1.md", "") - - b.WithTemplates("index.html", ` -{{ $options := dict "noComments" true }} -{{ $transpiled := resources.Get "js/main.js" | babel -}} -Transpiled: {{ $transpiled.Content | safeJS }} - -{{ $transpiled := resources.Get "js/main2.js" | babel (dict "sourceMap" "inline") -}} -Transpiled2: {{ $transpiled.Content | safeJS }} - -{{ $transpiled := resources.Get "js/main2.js" | babel (dict "sourceMap" "external") -}} -Transpiled3: {{ $transpiled.Permalink }} - -`) - - jsDir := filepath.Join(workDir, "assets", "js") - b.Assert(os.MkdirAll(jsDir, 0777), qt.IsNil) - b.WithSourceFile("assets/js/main.js", js) - b.WithSourceFile("assets/js/main2.js", js2) - b.WithSourceFile("package.json", packageJSON) - b.WithSourceFile("babel.config.js", babelConfig) - - b.Assert(os.Chdir(workDir), qt.IsNil) - cmd := b.NpmInstall() - err = cmd.Run() - b.Assert(err, qt.IsNil) - - b.Build(BuildCfg{}) - - // Make sure Node sees this. - b.Assert(logBuf.String(), qt.Contains, "babel: Hugo Environment: production") - b.Assert(err, qt.IsNil) - - b.AssertFileContent("public/index.html", `var Car =`) - b.AssertFileContent("public/index.html", `var Car2 =`) - b.AssertFileContent("public/js/main2.js", `var Car2 =`) - b.AssertFileContent("public/js/main2.js.map", `{"version":3,`) - b.AssertFileContent("public/index.html", ` -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozL`) -} diff --git a/hugolib/resource_chain_test.go b/hugolib/resource_chain_test.go index 8b17b01a484..68f6b082388 100644 --- a/hugolib/resource_chain_test.go +++ b/hugolib/resource_chain_test.go @@ -14,7 +14,6 @@ package hugolib import ( - "bytes" "fmt" "io" "io/ioutil" @@ -27,353 +26,14 @@ import ( "testing" "time" - "github.com/gohugoio/hugo/config" - - "github.com/gohugoio/hugo/resources/resource_transformers/tocss/dartsass" - - jww "github.com/spf13/jwalterweatherman" - - "github.com/gohugoio/hugo/common/herrors" - "github.com/gohugoio/hugo/helpers" - "github.com/gohugoio/hugo/htesting" qt "github.com/frankban/quicktest" - "github.com/gohugoio/hugo/hugofs" - "github.com/gohugoio/hugo/common/loggers" "github.com/gohugoio/hugo/resources/resource_transformers/tocss/scss" ) -func TestSCSSWithIncludePaths(t *testing.T) { - c := qt.New(t) - - for _, test := range []struct { - name string - supports func() bool - }{ - {"libsass", func() bool { return scss.Supports() }}, - {"dartsass", func() bool { return dartsass.Supports() }}, - } { - c.Run(test.name, func(c *qt.C) { - if !test.supports() { - c.Skip(fmt.Sprintf("Skip %s", test.name)) - } - - workDir, clean, err := htesting.CreateTempDir(hugofs.Os, fmt.Sprintf("hugo-scss-include-%s", test.name)) - c.Assert(err, qt.IsNil) - defer clean() - - v := config.New() - v.Set("workingDir", workDir) - b := newTestSitesBuilder(c).WithLogger(loggers.NewErrorLogger()) - // Need to use OS fs for this. - b.Fs = hugofs.NewDefault(v) - b.WithWorkingDir(workDir) - b.WithViper(v) - - fooDir := filepath.Join(workDir, "node_modules", "foo") - scssDir := filepath.Join(workDir, "assets", "scss") - c.Assert(os.MkdirAll(fooDir, 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "content", "sect"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "data"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "i18n"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "layouts", "shortcodes"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "layouts", "_default"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(scssDir), 0777), qt.IsNil) - - b.WithSourceFile(filepath.Join(fooDir, "_moo.scss"), ` -$moolor: #fff; - -moo { - color: $moolor; -} -`) - - b.WithSourceFile(filepath.Join(scssDir, "main.scss"), ` -@import "moo"; - -`) - - b.WithTemplatesAdded("index.html", fmt.Sprintf(` -{{ $cssOpts := (dict "includePaths" (slice "node_modules/foo") "transpiler" %q ) }} -{{ $r := resources.Get "scss/main.scss" | toCSS $cssOpts | minify }} -T1: {{ $r.Content }} -`, test.name)) - b.Build(BuildCfg{}) - - b.AssertFileContent(filepath.Join(workDir, "public/index.html"), `T1: moo{color:#fff}`) - }) - } -} - -func TestSCSSWithRegularCSSImport(t *testing.T) { - c := qt.New(t) - - for _, test := range []struct { - name string - supports func() bool - }{ - {"libsass", func() bool { return scss.Supports() }}, - {"dartsass", func() bool { return dartsass.Supports() }}, - } { - c.Run(test.name, func(c *qt.C) { - if !test.supports() { - c.Skip(fmt.Sprintf("Skip %s", test.name)) - } - - workDir, clean, err := htesting.CreateTempDir(hugofs.Os, fmt.Sprintf("hugo-scss-include-regular-%s", test.name)) - c.Assert(err, qt.IsNil) - defer clean() - - v := config.New() - v.Set("workingDir", workDir) - b := newTestSitesBuilder(c).WithLogger(loggers.NewErrorLogger()) - // Need to use OS fs for this. - b.Fs = hugofs.NewDefault(v) - b.WithWorkingDir(workDir) - b.WithViper(v) - - scssDir := filepath.Join(workDir, "assets", "scss") - c.Assert(os.MkdirAll(filepath.Join(workDir, "content", "sect"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "data"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "i18n"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "layouts", "shortcodes"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "layouts", "_default"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(scssDir), 0777), qt.IsNil) - b.WithSourceFile(filepath.Join(scssDir, "regular.css"), ``) - b.WithSourceFile(filepath.Join(scssDir, "another.css"), ``) - b.WithSourceFile(filepath.Join(scssDir, "_moo.scss"), ` -$moolor: #fff; - -moo { - color: $moolor; -} -`) - - b.WithSourceFile(filepath.Join(scssDir, "main.scss"), ` -@import "moo"; -@import "regular.css"; -@import "moo"; -@import "another.css"; - -/* foo */ -`) - - b.WithTemplatesAdded("index.html", fmt.Sprintf(` -{{ $r := resources.Get "scss/main.scss" | toCSS (dict "transpiler" %q) }} -T1: {{ $r.Content | safeHTML }} -`, test.name)) - b.Build(BuildCfg{}) - - if test.name == "libsass" { - // LibSass does not support regular CSS imports. There - // is an open bug about it that probably will never be resolved. - // Hugo works around this by preserving them in place: - b.AssertFileContent(filepath.Join(workDir, "public/index.html"), ` - T1: moo { - color: #fff; } - -@import "regular.css"; -moo { - color: #fff; } - -@import "another.css"; -/* foo */ - -`) - } else { - // Dart Sass does not follow regular CSS import, but they - // get pulled to the top. - b.AssertFileContent(filepath.Join(workDir, "public/index.html"), `T1: @import "regular.css"; -@import "another.css"; -moo { - color: #fff; -} - -moo { - color: #fff; -} - -/* foo */`) - } - }) - } -} - -func TestSCSSWithThemeOverrides(t *testing.T) { - c := qt.New(t) - - for _, test := range []struct { - name string - supports func() bool - }{ - {"libsass", func() bool { return scss.Supports() }}, - {"dartsass", func() bool { return dartsass.Supports() }}, - } { - c.Run(test.name, func(c *qt.C) { - if !test.supports() { - c.Skip(fmt.Sprintf("Skip %s", test.name)) - } - - workDir, clean1, err := htesting.CreateTempDir(hugofs.Os, fmt.Sprintf("hugo-scss-include-theme-overrides-%s", test.name)) - c.Assert(err, qt.IsNil) - defer clean1() - - theme := "mytheme" - themesDir := filepath.Join(workDir, "themes") - themeDirs := filepath.Join(themesDir, theme) - v := config.New() - v.Set("workingDir", workDir) - v.Set("theme", theme) - b := newTestSitesBuilder(c).WithLogger(loggers.NewErrorLogger()) - // Need to use OS fs for this. - b.Fs = hugofs.NewDefault(v) - b.WithWorkingDir(workDir) - b.WithViper(v) - - fooDir := filepath.Join(workDir, "node_modules", "foo") - scssDir := filepath.Join(workDir, "assets", "scss") - scssThemeDir := filepath.Join(themeDirs, "assets", "scss") - c.Assert(os.MkdirAll(fooDir, 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "content", "sect"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "data"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "i18n"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "layouts", "shortcodes"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(workDir, "layouts", "_default"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(scssDir, "components"), 0777), qt.IsNil) - c.Assert(os.MkdirAll(filepath.Join(scssThemeDir, "components"), 0777), qt.IsNil) - - b.WithSourceFile(filepath.Join(scssThemeDir, "components", "_imports.scss"), ` -@import "moo"; -@import "_boo"; -@import "_zoo"; - -`) - - b.WithSourceFile(filepath.Join(scssThemeDir, "components", "_moo.scss"), ` -$moolor: #fff; - -moo { - color: $moolor; -} -`) - - // Only in theme. - b.WithSourceFile(filepath.Join(scssThemeDir, "components", "_zoo.scss"), ` -$zoolor: pink; - -zoo { - color: $zoolor; -} -`) - - b.WithSourceFile(filepath.Join(scssThemeDir, "components", "_boo.scss"), ` -$boolor: orange; - -boo { - color: $boolor; -} -`) - - b.WithSourceFile(filepath.Join(scssThemeDir, "main.scss"), ` -@import "components/imports"; - -`) - - b.WithSourceFile(filepath.Join(scssDir, "components", "_moo.scss"), ` -$moolor: #ccc; - -moo { - color: $moolor; -} -`) - - b.WithSourceFile(filepath.Join(scssDir, "components", "_boo.scss"), ` -$boolor: green; - -boo { - color: $boolor; -} -`) - - b.WithTemplatesAdded("index.html", fmt.Sprintf(` -{{ $cssOpts := (dict "includePaths" (slice "node_modules/foo" ) "transpiler" %q ) }} -{{ $r := resources.Get "scss/main.scss" | toCSS $cssOpts | minify }} -T1: {{ $r.Content }} -`, test.name)) - b.Build(BuildCfg{}) - - b.AssertFileContent( - filepath.Join(workDir, "public/index.html"), - `T1: moo{color:#ccc}boo{color:green}zoo{color:pink}`, - ) - }) - } -} - -// https://github.com/gohugoio/hugo/issues/6274 -func TestSCSSWithIncludePathsSass(t *testing.T) { - c := qt.New(t) - - for _, test := range []struct { - name string - supports func() bool - }{ - {"libsass", func() bool { return scss.Supports() }}, - {"dartsass", func() bool { return dartsass.Supports() }}, - } { - c.Run(test.name, func(c *qt.C) { - if !test.supports() { - c.Skip(fmt.Sprintf("Skip %s", test.name)) - } - }) - } - if !scss.Supports() { - t.Skip("Skip SCSS") - } - workDir, clean1, err := htesting.CreateTempDir(hugofs.Os, "hugo-scss-includepaths") - c.Assert(err, qt.IsNil) - defer clean1() - - v := config.New() - v.Set("workingDir", workDir) - v.Set("theme", "mytheme") - b := newTestSitesBuilder(t).WithLogger(loggers.NewErrorLogger()) - // Need to use OS fs for this. - b.Fs = hugofs.NewDefault(v) - b.WithWorkingDir(workDir) - b.WithViper(v) - - hulmaDir := filepath.Join(workDir, "node_modules", "hulma") - scssDir := filepath.Join(workDir, "themes/mytheme/assets", "scss") - c.Assert(os.MkdirAll(hulmaDir, 0777), qt.IsNil) - c.Assert(os.MkdirAll(scssDir, 0777), qt.IsNil) - - b.WithSourceFile(filepath.Join(scssDir, "main.scss"), ` -@import "hulma/hulma"; - -`) - - b.WithSourceFile(filepath.Join(hulmaDir, "hulma.sass"), ` -$hulma: #ccc; - -foo - color: $hulma; - -`) - - b.WithTemplatesAdded("index.html", ` - {{ $scssOptions := (dict "targetPath" "css/styles.css" "enableSourceMap" false "includePaths" (slice "node_modules")) }} -{{ $r := resources.Get "scss/main.scss" | toCSS $scssOptions | minify }} -T1: {{ $r.Content }} -`) - b.Build(BuildCfg{}) - - b.AssertFileContent(filepath.Join(workDir, "public/index.html"), `T1: foo{color:#ccc}`) -} - func TestResourceChainBasic(t *testing.T) { ts := httptest.NewServer(http.FileServer(http.Dir("testdata/"))) t.Cleanup(func() { @@ -450,7 +110,7 @@ PRINT PROTOCOL ERROR2: error calling resources.GetRemote: Get "gopher://example. `, helpers.HashString(ts.URL+"/sunset.jpg", map[string]interface{}{}))) b.AssertFileContent("public/styles.min.a1df58687c3c9cc38bf26532f7b4b2f2c2b0315dcde212376959995c04f11fef.css", "body{background-color:#add8e6}") - b.AssertFileContent("public//styles2.min.1cfc52986836405d37f9998a63fd6dd8608e8c410e5e3db1daaa30f78bc273ba.css", "body{background-color:orange}") + b.AssertFileContent("public/styles2.min.1cfc52986836405d37f9998a63fd6dd8608e8c410e5e3db1daaa30f78bc273ba.css", "body{background-color:orange}") b.EditFiles("page1.md", ` --- @@ -461,10 +121,6 @@ summary: "Edited summary" Edited content. `) - - b.Assert(b.Fs.Destination.Remove("public"), qt.IsNil) - b.H.ResourceSpec.ClearCaches() - } } @@ -610,7 +266,6 @@ func TestResourceChains(t *testing.T) { return case "/authenticated/": - w.Header().Set("Content-Type", "text/plain") if r.Header.Get("Authorization") == "Bearer abcd" { w.Write([]byte(`Welcome`)) return @@ -619,7 +274,6 @@ func TestResourceChains(t *testing.T) { return case "/post": - w.Header().Set("Content-Type", "text/plain") if r.Method == http.MethodPost { body, err := ioutil.ReadAll(r.Body) if err != nil { @@ -634,7 +288,6 @@ func TestResourceChains(t *testing.T) { } http.Error(w, "Not found", http.StatusNotFound) - return })) t.Cleanup(func() { ts.Close() @@ -1042,270 +695,3 @@ JSON: {{ $json.RelPermalink }}: {{ $json.Content }} "JSON: /jsons/data1.json: json1 content", "JSONS: 2", "/jsons/data1.json: json1 content") } - -func TestExecuteAsTemplateWithLanguage(t *testing.T) { - b := newMultiSiteTestDefaultBuilder(t) - indexContent := ` -Lang: {{ site.Language.Lang }} -{{ $templ := "{{T \"hello\"}}" | resources.FromString "f1.html" }} -{{ $helloResource := $templ | resources.ExecuteAsTemplate (print "f%s.html" .Lang) . }} -Hello1: {{T "hello"}} -Hello2: {{ $helloResource.Content }} -LangURL: {{ relLangURL "foo" }} -` - b.WithTemplatesAdded("index.html", indexContent) - b.WithTemplatesAdded("index.fr.html", indexContent) - - b.Build(BuildCfg{}) - - b.AssertFileContent("public/en/index.html", ` -Hello1: Hello -Hello2: Hello -`) - - b.AssertFileContent("public/fr/index.html", ` -Hello1: Bonjour -Hello2: Bonjour -`) -} - -func TestResourceChainPostCSS(t *testing.T) { - if !htesting.IsCI() { - t.Skip("skip (relative) long running modules test when running locally") - } - - wd, _ := os.Getwd() - defer func() { - os.Chdir(wd) - }() - - c := qt.New(t) - - packageJSON := `{ - "scripts": {}, - - "devDependencies": { - "postcss-cli": "7.1.0", - "tailwindcss": "1.2.0" - } -} -` - - postcssConfig := ` -console.error("Hugo Environment:", process.env.HUGO_ENVIRONMENT ); -// https://github.com/gohugoio/hugo/issues/7656 -console.error("package.json:", process.env.HUGO_FILE_PACKAGE_JSON ); -console.error("PostCSS Config File:", process.env.HUGO_FILE_POSTCSS_CONFIG_JS ); - - -module.exports = { - plugins: [ - require('tailwindcss') - ] -} -` - - tailwindCss := ` -@tailwind base; -@tailwind components; -@tailwind utilities; - -@import "components/all.css"; - -h1 { - @apply text-2xl font-bold; -} - -` - - workDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-test-postcss") - c.Assert(err, qt.IsNil) - defer clean() - - var logBuf bytes.Buffer - - newTestBuilder := func(v config.Provider) *sitesBuilder { - v.Set("workingDir", workDir) - v.Set("disableKinds", []string{"taxonomy", "term", "page"}) - logger := loggers.NewBasicLoggerForWriter(jww.LevelInfo, &logBuf) - b := newTestSitesBuilder(t).WithLogger(logger) - // Need to use OS fs for this. - b.Fs = hugofs.NewDefault(v) - b.WithWorkingDir(workDir) - b.WithViper(v) - - b.WithContent("p1.md", "") - b.WithTemplates("index.html", ` -{{ $options := dict "inlineImports" true }} -{{ $styles := resources.Get "css/styles.css" | resources.PostCSS $options }} -Styles RelPermalink: {{ $styles.RelPermalink }} -{{ $cssContent := $styles.Content }} -Styles Content: Len: {{ len $styles.Content }}| - -`) - - return b - } - - b := newTestBuilder(config.New()) - - cssDir := filepath.Join(workDir, "assets", "css", "components") - b.Assert(os.MkdirAll(cssDir, 0777), qt.IsNil) - - b.WithSourceFile("assets/css/styles.css", tailwindCss) - b.WithSourceFile("assets/css/components/all.css", ` -@import "a.css"; -@import "b.css"; -`, "assets/css/components/a.css", ` -class-in-a { - color: blue; -} -`, "assets/css/components/b.css", ` -@import "a.css"; - -class-in-b { - color: blue; -} -`) - - b.WithSourceFile("package.json", packageJSON) - b.WithSourceFile("postcss.config.js", postcssConfig) - - b.Assert(os.Chdir(workDir), qt.IsNil) - cmd := b.NpmInstall() - err = cmd.Run() - b.Assert(err, qt.IsNil) - b.Build(BuildCfg{}) - - // Make sure Node sees this. - b.Assert(logBuf.String(), qt.Contains, "Hugo Environment: production") - b.Assert(logBuf.String(), qt.Contains, filepath.FromSlash(fmt.Sprintf("PostCSS Config File: %s/postcss.config.js", workDir))) - b.Assert(logBuf.String(), qt.Contains, filepath.FromSlash(fmt.Sprintf("package.json: %s/package.json", workDir))) - - b.AssertFileContent("public/index.html", ` -Styles RelPermalink: /css/styles.css -Styles Content: Len: 770878| -`) - - assertCss := func(b *sitesBuilder) { - content := b.FileContent("public/css/styles.css") - - b.Assert(strings.Contains(content, "class-in-a"), qt.Equals, true) - b.Assert(strings.Contains(content, "class-in-b"), qt.Equals, true) - } - - assertCss(b) - - build := func(s string, shouldFail bool) error { - b.Assert(os.RemoveAll(filepath.Join(workDir, "public")), qt.IsNil) - - v := config.New() - v.Set("build", map[string]interface{}{ - "useResourceCacheWhen": s, - }) - - b = newTestBuilder(v) - - b.Assert(os.RemoveAll(filepath.Join(workDir, "public")), qt.IsNil) - - err := b.BuildE(BuildCfg{}) - if shouldFail { - b.Assert(err, qt.Not(qt.IsNil)) - } else { - b.Assert(err, qt.IsNil) - assertCss(b) - } - - return err - } - - build("always", false) - build("fallback", false) - - // Introduce a syntax error in an import - b.WithSourceFile("assets/css/components/b.css", `@import "a.css"; - -class-in-b { - @apply asdf; -} -`) - - err = build("never", true) - - err = herrors.UnwrapErrorWithFileContext(err) - _, ok := err.(*herrors.ErrorWithFileContext) - b.Assert(ok, qt.Equals, true) - - // TODO(bep) for some reason, we have starting to get - // execute of template failed: template: index.html:5:25 - // on CI (GitHub action). - // b.Assert(fe.Position().LineNumber, qt.Equals, 5) - // b.Assert(fe.Error(), qt.Contains, filepath.Join(workDir, "assets/css/components/b.css:4:1")) - - // Remove PostCSS - b.Assert(os.RemoveAll(filepath.Join(workDir, "node_modules")), qt.IsNil) - - build("always", false) - build("fallback", false) - build("never", true) - - // Remove cache - b.Assert(os.RemoveAll(filepath.Join(workDir, "resources")), qt.IsNil) - - build("always", true) - build("fallback", true) - build("never", true) -} - -func TestResourceMinifyDisabled(t *testing.T) { - t.Parallel() - - b := newTestSitesBuilder(t).WithConfigFile("toml", ` -baseURL = "https://example.org" - -[minify] -disableXML=true - - -`) - - b.WithContent("page.md", "") - - b.WithSourceFile( - "assets/xml/data.xml", " asdfasdf ", - ) - - b.WithTemplates("index.html", ` -{{ $xml := resources.Get "xml/data.xml" | minify | fingerprint }} -XML: {{ $xml.Content | safeHTML }}|{{ $xml.RelPermalink }} -`) - - b.Build(BuildCfg{}) - - b.AssertFileContent("public/index.html", ` -XML: asdfasdf |/xml/data.min.3be4fddd19aaebb18c48dd6645215b822df74701957d6d36e59f203f9c30fd9f.xml -`) -} - -// Issue 8954 -func TestMinifyWithError(t *testing.T) { - b := newTestSitesBuilder(t).WithSimpleConfigFile() - b.WithSourceFile( - "assets/js/test.js", ` -new Date(2002, 04, 11) -`, - ) - b.WithTemplates("index.html", ` -{{ $js := resources.Get "js/test.js" | minify | fingerprint }} - -`) - b.WithContent("page.md", "") - - err := b.BuildE(BuildCfg{}) - - if err == nil || !strings.Contains(err.Error(), "04") { - t.Fatalf("expected a message about a legacy octal number, but got: %v", err) - } -} diff --git a/hugolib/rss_test.go b/hugolib/rss_test.go index 634843e3dda..34822afc044 100644 --- a/hugolib/rss_test.go +++ b/hugolib/rss_test.go @@ -45,7 +45,7 @@ func TestRSSOutput(t *testing.T) { // Home RSS th.assertFileContent(filepath.Join("public", rssURI), "Sects on RSSTest") // Taxonomy RSS th.assertFileContent(filepath.Join("public", "categories", "hugo", rssURI), "}} b.Assert(len(h.Sites), qt.Equals, 1) s := h.Sites[0] - home := s.getPage(page.KindHome) + home := s.getPage(pagekinds.Home) b.Assert(home, qt.Not(qt.IsNil)) b.Assert(len(home.OutputFormats()), qt.Equals, 3) @@ -948,40 +949,61 @@ C-%s` func TestShortcodeParentResourcesOnRebuild(t *testing.T) { t.Parallel() - b := newTestSitesBuilder(t).Running().WithSimpleConfigFile() - b.WithTemplatesAdded( - "index.html", ` + files := ` +-- config.toml -- +baseURL = 'http://example.com/' +-- content/b1/index.md -- +--- +title: MyPage +--- +CONTENT +-- content/b1/logo.png -- +PNG logo +-- content/b1/p1.md -- +--- +title: MyPage +--- + +SHORTCODE: {{< c >}} +-- content/blog/_index.md -- +--- +title: MyPage +--- + +SHORTCODE: {{< c >}} +-- content/blog/article.md -- +--- +title: MyPage +--- + +SHORTCODE: {{< c >}} +-- content/blog/logo-article.png -- +PNG logo +-- layouts/index.html -- {{ $b := .Site.GetPage "b1" }} b1 Content: {{ $b.Content }} {{$p := $b.Resources.GetMatch "p1*" }} Content: {{ $p.Content }} {{ $article := .Site.GetPage "blog/article" }} Article Content: {{ $article.Content }} -`, - "shortcodes/c.html", ` +-- layouts/shortcodes/c.html -- {{ range .Page.Parent.Resources }} * Parent resource: {{ .Name }}: {{ .RelPermalink }} {{ end }} -`) - pageContent := ` ---- -title: MyPage ---- -SHORTCODE: {{< c >}} -` + ` - b.WithContent("b1/index.md", pageContent, - "b1/logo.png", "PNG logo", - "b1/p1.md", pageContent, - "blog/_index.md", pageContent, - "blog/logo-article.png", "PNG logo", - "blog/article.md", pageContent, - ) + c := qt.New(t) - b.Build(BuildCfg{}) + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + TxtarString: files, + Running: true, + }, + ).Build() assert := func(matchers ...string) { allMatchers := append(matchers, "Parent resource: logo.png: /b1/logo.png", @@ -995,11 +1017,11 @@ SHORTCODE: {{< c >}} assert() - b.EditFiles("content/b1/index.md", pageContent+" Edit.") + b.EditFileReplace("content/b1/index.md", func(s string) string { return strings.ReplaceAll(s, "CONTENT", "Content Edit") }) - b.Build(BuildCfg{}) + b.Build() - assert("Edit.") + assert("Content Edit") } func TestShortcodePreserveOrder(t *testing.T) { diff --git a/hugolib/site.go b/hugolib/site.go index bde8a2199a5..9d7e07be90d 100644 --- a/hugolib/site.go +++ b/hugolib/site.go @@ -14,6 +14,7 @@ package hugolib import ( + "context" "fmt" "html/template" "io" @@ -21,24 +22,28 @@ import ( "mime" "net/url" "os" - "path" "path/filepath" "regexp" "sort" "strconv" "strings" + "sync" "time" + "github.com/gohugoio/hugo/cache/memcache" + "github.com/gohugoio/hugo/common/types" "github.com/gohugoio/hugo/common/paths" + "github.com/gohugoio/hugo/parser/pageparser" + + "github.com/gohugoio/hugo/common/hugio" + "github.com/gohugoio/hugo/common/constants" "github.com/gohugoio/hugo/common/loggers" - "github.com/gohugoio/hugo/resources" - "github.com/gohugoio/hugo/identity" "github.com/gohugoio/hugo/markup/converter/hooks" @@ -57,7 +62,8 @@ import ( "github.com/gohugoio/hugo/common/hugo" "github.com/gohugoio/hugo/publisher" - _errors "github.com/pkg/errors" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gohugoio/hugo/resources/page/siteidentities" "github.com/gohugoio/hugo/langs" @@ -175,18 +181,32 @@ func (s *Site) Taxonomies() TaxonomyList { return s.taxonomies } -type taxonomiesConfig map[string]string +type ( + taxonomiesConfig map[string]string + taxonomiesConfigValues struct { + views []viewName + viewsByTreeKey map[string]viewName + } +) -func (t taxonomiesConfig) Values() []viewName { - var vals []viewName +func (t taxonomiesConfig) Values() taxonomiesConfigValues { + var views []viewName for k, v := range t { - vals = append(vals, viewName{singular: k, plural: v}) + views = append(views, viewName{singular: k, plural: v, pluralTreeKey: cleanTreeKey(v)}) } - sort.Slice(vals, func(i, j int) bool { - return vals[i].plural < vals[j].plural + sort.Slice(views, func(i, j int) bool { + return views[i].plural < views[j].plural }) - return vals + viewsByTreeKey := make(map[string]viewName) + for _, v := range views { + viewsByTreeKey[v.pluralTreeKey] = v + } + + return taxonomiesConfigValues{ + views: views, + viewsByTreeKey: viewsByTreeKey, + } } type siteConfigHolder struct { @@ -253,11 +273,6 @@ func (s *Site) prepareInits() { }) s.init.prevNextInSection = init.Branch(func() (interface{}, error) { - var sections page.Pages - s.home.treeRef.m.collectSectionsRecursiveIncludingSelf(pageMapQuery{Prefix: s.home.treeRef.key}, func(n *contentNode) { - sections = append(sections, n.p) - }) - setNextPrev := func(pas page.Pages) { for i, p := range pas { np, ok := p.(nextPrevInSectionProvider) @@ -283,28 +298,25 @@ func (s *Site) prepareInits() { } } - for _, sect := range sections { - treeRef := sect.(treeRefProvider).getTreeRef() - + s.pageMap.WalkBranches(func(s string, b *contentBranchNode) bool { + if b.n.IsView() { + return false + } + if contentTreeNoListAlwaysFilter(s, b.n) { + return false + } var pas page.Pages - treeRef.m.collectPages(pageMapQuery{Prefix: treeRef.key + cmBranchSeparator}, func(c *contentNode) { - pas = append(pas, c.p) - }) + b.pages.Walk( + contentTreeNoListAlwaysFilter, + func(s string, c *contentNode) bool { + pas = append(pas, c.p) + return false + }, + ) page.SortByDefault(pas) - setNextPrev(pas) - } - - // The root section only goes one level down. - treeRef := s.home.getTreeRef() - - var pas page.Pages - treeRef.m.collectPages(pageMapQuery{Prefix: treeRef.key + cmBranchSeparator}, func(c *contentNode) { - pas = append(pas, c.p) + return false }) - page.SortByDefault(pas) - - setNextPrev(pas) return nil, nil }) @@ -315,8 +327,7 @@ func (s *Site) prepareInits() { }) s.init.taxonomies = init.Branch(func() (interface{}, error) { - err := s.pageMap.assembleTaxonomies() - return nil, err + return nil, s.pageMap.CreateSiteTaxonomies() }) } @@ -332,7 +343,9 @@ func (s *Site) Menus() navigation.Menus { func (s *Site) initRenderFormats() { formatSet := make(map[string]bool) formats := output.Formats{} - s.pageMap.pageTrees.WalkRenderable(func(s string, n *contentNode) bool { + + s.pageMap.WalkPagesAllPrefixSection("", nil, contentTreeNoRenderFilter, func(np contentNodeProvider) bool { + n := np.GetNode() for _, f := range n.p.m.configuredOutputFormats { if !formatSet[f.Name] { formats = append(formats, f) @@ -367,9 +380,6 @@ func (s *Site) Language() *langs.Language { } func (s *Site) isEnabled(kind string) bool { - if kind == kindUnknown { - panic("Unknown kind") - } return !s.disabledKinds[kind] } @@ -407,7 +417,8 @@ func newSite(cfg deps.DepsCfg) (*Site, error) { } ignoreErrors := cast.ToStringSlice(cfg.Language.Get("ignoreErrors")) - ignorableLogger := loggers.NewIgnorableLogger(cfg.Logger, ignoreErrors...) + ignoreWarnings := cast.ToStringSlice(cfg.Language.Get("ignoreWarnings")) + ignorableLogger := loggers.NewIgnorableLogger(cfg.Logger, ignoreErrors, ignoreWarnings) disabledKinds := make(map[string]bool) for _, disabled := range cast.ToStringSlice(cfg.Language.Get("disableKinds")) { @@ -416,14 +427,14 @@ func newSite(cfg deps.DepsCfg) (*Site, error) { if disabledKinds["taxonomyTerm"] { // Correct from the value it had before Hugo 0.73.0. - if disabledKinds[page.KindTaxonomy] { - disabledKinds[page.KindTerm] = true + if disabledKinds[pagekinds.Taxonomy] { + disabledKinds[pagekinds.Term] = true } else { - disabledKinds[page.KindTaxonomy] = true + disabledKinds[pagekinds.Taxonomy] = true } delete(disabledKinds, "taxonomyTerm") - } else if disabledKinds[page.KindTaxonomy] && !disabledKinds[page.KindTerm] { + } else if disabledKinds[pagekinds.Taxonomy] && !disabledKinds[pagekinds.Term] { // This is a potentially ambigous situation. It may be correct. ignorableLogger.Errorsf(constants.ErrIDAmbigousDisableKindTaxonomy, `You have the value 'taxonomy' in the disabledKinds list. In Hugo 0.73.0 we fixed these to be what most people expect (taxonomy and term). But this also means that your site configuration may not do what you expect. If it is correct, you can suppress this message by following the instructions below.`) @@ -458,7 +469,7 @@ But this also means that your site configuration may not do what you expect. If return nil, err } - rssDisabled := disabledKinds[kindRSS] + rssDisabled := disabledKinds["RSS"] if rssDisabled { // Legacy tmp := siteOutputFormatsConfig[:0] @@ -476,11 +487,11 @@ But this also means that your site configuration may not do what you expect. If // Check and correct taxonomy kinds vs pre Hugo 0.73.0. v1, hasTaxonomyTerm := siteOutputs["taxonomyterm"] - v2, hasTaxonomy := siteOutputs[page.KindTaxonomy] - _, hasTerm := siteOutputs[page.KindTerm] + v2, hasTaxonomy := siteOutputs[pagekinds.Taxonomy] + _, hasTerm := siteOutputs[pagekinds.Term] if hasTaxonomy && hasTaxonomyTerm { - siteOutputs[page.KindTaxonomy] = v1 - siteOutputs[page.KindTerm] = v2 + siteOutputs[pagekinds.Taxonomy] = v1 + siteOutputs[pagekinds.Term] = v2 delete(siteOutputs, "taxonomyTerm") } else if hasTaxonomy && !hasTerm { // This is a potentially ambigous situation. It may be correct. @@ -488,7 +499,7 @@ But this also means that your site configuration may not do what you expect. If But this also means that your site configuration may not do what you expect. If it is correct, you can suppress this message by following the instructions below.`) } if !hasTaxonomy && hasTaxonomyTerm { - siteOutputs[page.KindTaxonomy] = v1 + siteOutputs[pagekinds.Taxonomy] = v1 delete(siteOutputs, "taxonomyterm") } } @@ -644,6 +655,8 @@ func NewSiteForCfg(cfg deps.DepsCfg) (*Site, error) { return h.Sites[0], nil } +var _ identity.IdentityLookupProvider = (*SiteInfo)(nil) + type SiteInfo struct { Authors page.AuthorList Social SiteSocial @@ -673,6 +686,10 @@ type SiteInfo struct { sectionPagesMenu string } +func (s *SiteInfo) LookupIdentity(name string) (identity.Identity, bool) { + return siteidentities.FromString(name) +} + func (s *SiteInfo) Pages() page.Pages { return s.s.Pages() } @@ -819,7 +836,7 @@ func (s siteRefLinker) logNotFound(ref, what string, p page.Page, position text. } else if p == nil { s.errorLogger.Printf("[%s] REF_NOT_FOUND: Ref %q: %s", s.s.Lang(), ref, what) } else { - s.errorLogger.Printf("[%s] REF_NOT_FOUND: Ref %q from page %q: %s", s.s.Lang(), ref, p.Pathc(), what) + s.errorLogger.Printf("[%s] REF_NOT_FOUND: Ref %q from page %q: %s", s.s.Lang(), ref, p.Path(), what) } } @@ -845,6 +862,7 @@ func (s *siteRefLinker) refLink(ref string, source interface{}, relative bool, o if refURL.Path != "" { var err error target, err = s.s.getPageRef(p, refURL.Path) + var pos text.Position if err != nil || target == nil { if p, ok := source.(text.Positioner); ok { @@ -911,8 +929,34 @@ func (s *Site) multilingual() *Multilingual { } type whatChanged struct { - source bool - files map[string]bool + mu sync.Mutex + + contentChanged bool + identitySet identity.Identities +} + +func (w *whatChanged) Add(ids ...identity.Identity) { + if w == nil { + return + } + + w.mu.Lock() + defer w.mu.Unlock() + + if w.identitySet == nil { + return + } + + for _, id := range ids { + w.identitySet[id] = true + } +} + +func (w *whatChanged) Changes() []identity.Identity { + if w == nil || w.identitySet == nil { + return nil + } + return w.identitySet.AsSlice() } // RegisterMediaTypes will register the Site's media types in the mime @@ -962,7 +1006,7 @@ func (s *Site) translateFileEvents(events []fsnotify.Event) []fsnotify.Event { eventMap := make(map[string][]fsnotify.Event) // We often get a Remove etc. followed by a Create, a Create followed by a Write. - // Remove the superfluous events to mage the update logic simpler. + // Remove the superfluous events to make the update logic simpler. for _, ev := range events { eventMap[ev.Name] = append(eventMap[ev.Name], ev) } @@ -995,101 +1039,191 @@ func (s *Site) translateFileEvents(events []fsnotify.Event) []fsnotify.Event { } var ( - // These are only used for cache busting, so false positives are fine. - // We also deliberately do not match for file suffixes to also catch - // directory names. - // TODO(bep) consider this when completing the relevant PR rewrite on this. - cssFileRe = regexp.MustCompile("(css|sass|scss)") - cssConfigRe = regexp.MustCompile(`(postcss|tailwind)\.config\.js`) - jsFileRe = regexp.MustCompile("(js|ts|jsx|tsx)") + renderHookImageTemplateRe = regexp.MustCompile(`/_markup/render-image\.`) + renderHookLinkTemplateRe = regexp.MustCompile(`/_markup/render-link\.`) + renderHookHeadingTemplateRe = regexp.MustCompile(`/_markup/render-heading\.`) ) -// reBuild partially rebuilds a site given the filesystem events. -// It returns whatever the content source was changed. -// TODO(bep) clean up/rewrite this method. +// processPartial prepares the Sites' sources for a partial rebuild. +// TODO1 .CurrentSection -- no win slashes. Issue? func (s *Site) processPartial(config *BuildCfg, init func(config *BuildCfg) error, events []fsnotify.Event) error { events = s.filterFileEvents(events) events = s.translateFileEvents(events) - changeIdentities := make(identity.Identities) - - s.Log.Debugf("Rebuild for events %q", events) - h := s.h - // First we need to determine what changed - var ( - sourceChanged = []fsnotify.Event{} - sourceReallyChanged = []fsnotify.Event{} - contentFilesChanged []string - - tmplChanged bool - tmplAdded bool - dataChanged bool - i18nChanged bool - - sourceFilesChanged = make(map[string]bool) + tmplChanged bool + tmplAdded bool + i18nChanged bool + contentChanged bool // prevent spamming the log on changes logger = helpers.NewDistinctErrorLogger() ) - var cachePartitions []string - // Special case - // TODO(bep) I have a ongoing branch where I have redone the cache. Consider this there. + // Paths relative to their component folder. + // Changes and addition. + // pathSetChanges := make(identity.PathIdentitySet) + // Deletes. + // pathSetDeletes := make(identity.PathIdentitySet) + var ( - evictCSSRe *regexp.Regexp - evictJSRe *regexp.Regexp + pathsChanges []*paths.PathInfo + pathsDeletes []*paths.PathInfo ) for _, ev := range events { - if assetsFilename, _ := s.BaseFs.Assets.MakePathRelative(ev.Name); assetsFilename != "" { - cachePartitions = append(cachePartitions, resources.ResourceKeyPartitions(assetsFilename)...) - if evictCSSRe == nil { - if cssFileRe.MatchString(assetsFilename) || cssConfigRe.MatchString(assetsFilename) { - evictCSSRe = cssFileRe - } - } - if evictJSRe == nil && jsFileRe.MatchString(assetsFilename) { - evictJSRe = jsFileRe + removed := false + + if ev.Op&fsnotify.Remove == fsnotify.Remove { + removed = true + } + + // Some editors (Vim) sometimes issue only a Rename operation when writing an existing file + // Sometimes a rename operation means that file has been renamed other times it means + // it's been updated. + if ev.Op&fsnotify.Rename == fsnotify.Rename { + // If the file is still on disk, it's only been updated, if it's not, it's been moved + if ex, err := afero.Exists(s.Fs.Source, ev.Name); !ex || err != nil { + removed = true } } - id, found := s.eventToIdentity(ev) - if found { - changeIdentities[id] = id - - switch id.Type { - case files.ComponentFolderContent: - logger.Println("Source changed", ev) - sourceChanged = append(sourceChanged, ev) - case files.ComponentFolderLayouts: - tmplChanged = true - if !s.Tmpl().HasTemplate(id.Path) { - tmplAdded = true + paths := s.BaseFs.CollectPathIdentities(ev.Name) + + if removed { + pathsDeletes = append(pathsDeletes, paths...) + } else { + pathsChanges = append(pathsChanges, paths...) + } + + } + + var addedOrChangedContent []*paths.PathInfo + + // Find the most specific identity possible (the most specific being the Go pointer to a given Page). + // TODO1 bookmark1 + var ( + identities []identity.Identity + ) + + handleChange := func(id *paths.PathInfo, delete bool) { + switch id.Component() { + case files.ComponentFolderContent: + logger.Println("Source changed", id.Filename()) + contentChanged = true + m := h.getContentMaps() + + var found bool + for _, pm := range m.pmaps { + n, tree := pm.GetNodeAndTree(id.Base()) + if n != nil { + found = true + identities = append(identities, n.GetIdentity()) + + if delete { + // TODO1 resources + tree.Delete(id.Base()) + } + + if id.IsBranchBundle() && n.isCascadingEdit() { + pm.WalkPagesAllPrefixSection(id.Base(), nil, nil, func(node contentNodeProvider) bool { + n := node.GetNode() + if n.p != nil { + n.p.buildState++ + } + return false + }) + } + } - if tmplAdded { - logger.Println("Template added", ev) - } else { - logger.Println("Template changed", ev) + } + + if delete || !found { + // TODO1 tie this in with the reset logic, also Add. + identities = append(identities, siteidentities.PageCollections) + + if !found { + // A new content file is added. Collect all branch nodes. + // This will handle all $blog.RegularPages and similar, both direct and indirectly via site.GetPage. + for _, pm := range m.pmaps { + pm.WalkBranches(func(s string, n *contentBranchNode) bool { + identities = append(identities, n.n) + return false + }) + } } + } - case files.ComponentFolderData: - logger.Println("Data changed", ev) - dataChanged = true - case files.ComponentFolderI18n: - logger.Println("i18n changed", ev) - i18nChanged = true + if !delete { + addedOrChangedContent = append(addedOrChangedContent, id) + } + case files.ComponentFolderLayouts: + tmplChanged = true + if !s.Tmpl().HasTemplate(id.Base()) { + tmplAdded = true } + identities = append(identities, id) + if tmplAdded { + logger.Println("Template added", id.Filename()) + // A new template requires a more coarse grained build. + if renderHookImageTemplateRe.MatchString(id.Base()) { + identities = append(identities, converter.FeatureRenderHookImage) + } else if renderHookLinkTemplateRe.MatchString(id.Base()) { + identities = append(identities, converter.FeatureRenderHookLink) + } else if renderHookHeadingTemplateRe.MatchString(id.Base()) { + identities = append(identities, converter.FeatureRenderHookHeading) + } else { + // TODO1 + } + } else { + logger.Println("Template changed", id.Filename()) + identities = append(identities, id) + } + case files.ComponentFolderAssets: + r, _ := h.ResourceSpec.ResourceCache.Get(context.Background(), memcache.CleanKey(id.Base())) + if !identity.WalkIdentities(r, func(rid identity.Identity) bool { + identities = append(identities, rid) + return false + }) { + identities = append(identities, id) + } + + case files.ComponentFolderData: + logger.Println("Data changed", id.Filename()) + + // This should cover all usage of site.Data. + // Currently very coarse grained. + identities = append(identities, siteidentities.Data) + s.h.init.data.Reset() + case files.ComponentFolderI18n: + logger.Println("i18n changed", id.Filename()) + i18nChanged = true + identities = append(identities, id) + default: + panic(fmt.Sprintf("unknown component: %q", id.Component())) } } + for _, id := range pathsDeletes { + handleChange(id, true) + } + + for _, id := range pathsChanges { + handleChange(id, false) + } + + // TODO1 if config.ErrRecovery || tmplAdded { + + resourceFiles := addedOrChangedContent // TODO1 + remove the PathIdentities .ToPathIdentities().Sort() + changed := &whatChanged{ - source: len(sourceChanged) > 0, - files: sourceFilesChanged, + contentChanged: contentChanged, + identitySet: make(identity.Identities), } + changed.Add(identities...) config.whatChanged = changed @@ -1097,22 +1231,12 @@ func (s *Site) processPartial(config *BuildCfg, init func(config *BuildCfg) erro return err } - // These in memory resource caches will be rebuilt on demand. - for _, s := range s.h.Sites { - s.ResourceSpec.ResourceCache.DeletePartitions(cachePartitions...) - if evictCSSRe != nil { - s.ResourceSpec.ResourceCache.DeleteMatches(evictCSSRe) - } - if evictJSRe != nil { - s.ResourceSpec.ResourceCache.DeleteMatches(evictJSRe) - } - } - if tmplChanged || i18nChanged { sites := s.h.Sites first := sites[0] - s.h.init.Reset() + s.h.init.layouts.Reset() + s.h.init.translations.Reset() // TOD(bep) globals clean if err := first.Deps.LoadResources(); err != nil { @@ -1137,56 +1261,10 @@ func (s *Site) processPartial(config *BuildCfg, init func(config *BuildCfg) erro } } - if dataChanged { - s.h.init.data.Reset() - } - - for _, ev := range sourceChanged { - removed := false - - if ev.Op&fsnotify.Remove == fsnotify.Remove { - removed = true - } - - // Some editors (Vim) sometimes issue only a Rename operation when writing an existing file - // Sometimes a rename operation means that file has been renamed other times it means - // it's been updated - if ev.Op&fsnotify.Rename == fsnotify.Rename { - // If the file is still on disk, it's only been updated, if it's not, it's been moved - if ex, err := afero.Exists(s.Fs.Source, ev.Name); !ex || err != nil { - removed = true - } - } - - if removed && files.IsContentFile(ev.Name) { - h.removePageByFilename(ev.Name) - } - - sourceReallyChanged = append(sourceReallyChanged, ev) - sourceFilesChanged[ev.Name] = true - } - - if config.ErrRecovery || tmplAdded || dataChanged { - h.resetPageState() - } else { - h.resetPageStateFromEvents(changeIdentities) - } - - if len(sourceReallyChanged) > 0 || len(contentFilesChanged) > 0 { - var filenamesChanged []string - for _, e := range sourceReallyChanged { - filenamesChanged = append(filenamesChanged, e.Name) - } - if len(contentFilesChanged) > 0 { - filenamesChanged = append(filenamesChanged, contentFilesChanged...) - } - - filenamesChanged = helpers.UniqueStringsReuse(filenamesChanged) - - if err := s.readAndProcessContent(*config, filenamesChanged...); err != nil { + if resourceFiles != nil { + if err := s.readAndProcessContent(*config, resourceFiles); err != nil { return err } - } return nil @@ -1197,7 +1275,7 @@ func (s *Site) process(config BuildCfg) (err error) { err = errors.Wrap(err, "initialize") return } - if err = s.readAndProcessContent(config); err != nil { + if err = s.readAndProcessContent(config, nil); err != nil { err = errors.Wrap(err, "readAndProcessContent") return } @@ -1228,23 +1306,7 @@ func (s *Site) render(ctx *siteRenderContext) (err error) { return } - if ctx.outIdx == 0 { - if err = s.renderSitemap(); err != nil { - return - } - - if ctx.multihost { - if err = s.renderRobotsTXT(); err != nil { - return - } - } - - if err = s.render404(); err != nil { - return - } - } - - if !ctx.renderSingletonPages() { + if !ctx.shouldRenderSingletonPages() { return } @@ -1348,7 +1410,7 @@ func (s *Site) initializeSiteInfo() error { hugoInfo: hugo.NewInfo(s.Cfg.GetString("environment")), } - rssOutputFormat, found := s.outputFormats[page.KindHome].GetByName(output.RSSFormat.Name) + rssOutputFormat, found := s.outputFormats[pagekinds.Home].GetByName(output.RSSFormat.Name) if found { s.Info.RSSLink = s.permalink(rssOutputFormat.BaseFilename()) @@ -1357,21 +1419,12 @@ func (s *Site) initializeSiteInfo() error { return nil } -func (s *Site) eventToIdentity(e fsnotify.Event) (identity.PathIdentity, bool) { - for _, fs := range s.BaseFs.SourceFilesystems.FileSystems() { - if p := fs.Path(e.Name); p != "" { - return identity.NewPathIdentity(fs.Name, filepath.ToSlash(p)), true - } - } - return identity.PathIdentity{}, false -} - -func (s *Site) readAndProcessContent(buildConfig BuildCfg, filenames ...string) error { +func (s *Site) readAndProcessContent(buildConfig BuildCfg, ids paths.PathInfos) error { sourceSpec := source.NewSourceSpec(s.PathSpec, buildConfig.ContentInclusionFilter, s.BaseFs.Content.Fs) proc := newPagesProcessor(s.h, sourceSpec) - c := newPagesCollector(sourceSpec, s.h.getContentMaps(), s.Log, s.h.ContentChanges, proc, filenames...) + c := newPagesCollector(sourceSpec, s.h.getContentMaps(), s.Log, s.h.ContentChanges, proc, ids) if err := c.Collect(); err != nil { return err @@ -1429,7 +1482,7 @@ func (s *SiteInfo) createNodeMenuEntryURL(in string) string { } // make it match the nodes menuEntryURL := in - menuEntryURL = helpers.SanitizeURLKeepTrailingSlash(s.s.PathSpec.URLize(menuEntryURL)) + menuEntryURL = paths.URLEscape(s.s.PathSpec.URLize(menuEntryURL)) if !s.canonifyURLs { menuEntryURL = paths.AddContextRoot(s.s.PathSpec.BaseURL.String(), menuEntryURL) } @@ -1460,11 +1513,16 @@ func (s *Site) assembleMenus() { sectionPagesMenu := s.Info.sectionPagesMenu if sectionPagesMenu != "" { - s.pageMap.sections.Walk(func(s string, v interface{}) bool { - p := v.(*contentNode).p - if p.IsHome() { + s.pageMap.WalkPagesAllPrefixSection("", noTaxonomiesFilter, contentTreeNoListAlwaysFilter, func(np contentNodeProvider) bool { + s := np.Key() + n := np.GetNode() + + if s == "" { return false } + + p := n.p + // From Hugo 0.22 we have nested sections, but until we get a // feel of how that would work in this setting, let us keep // this menu for the top level only. @@ -1486,7 +1544,8 @@ func (s *Site) assembleMenus() { } // Add menu entries provided by pages - s.pageMap.pageTrees.WalkRenderable(func(ss string, n *contentNode) bool { + s.pageMap.WalkPagesAllPrefixSection("", noTaxonomiesFilter, contentTreeNoRenderFilter, func(np contentNodeProvider) bool { + n := np.GetNode() p := n.p for name, me := range p.pageMenus.menus() { @@ -1571,19 +1630,18 @@ func (s *Site) resetBuildState(sourceChanged bool) { s.init.Reset() if sourceChanged { - s.pageMap.contentMap.pageReverseIndex.Reset() + s.pageMap.pageReverseIndex.Reset() s.PageCollections = newPageCollections(s.pageMap) - s.pageMap.withEveryBundlePage(func(p *pageState) bool { - p.pagePages = &pagePages{} + s.pageMap.WithEveryBundlePage(func(p *pageState) bool { if p.bucket != nil { p.bucket.pagesMapBucketPages = &pagesMapBucketPages{} } - p.parent = nil p.Scratcher = maps.NewScratcher() return false }) + } else { - s.pageMap.withEveryBundlePage(func(p *pageState) bool { + s.pageMap.WithEveryBundlePage(func(p *pageState) bool { p.Scratcher = maps.NewScratcher() return false }) @@ -1621,18 +1679,6 @@ func (s *SiteInfo) GetPage(ref ...string) (page.Page, error) { return p, err } -func (s *SiteInfo) GetPageWithTemplateInfo(info tpl.Info, ref ...string) (page.Page, error) { - p, err := s.GetPage(ref...) - if p != nil { - // Track pages referenced by templates/shortcodes - // when in server mode. - if im, ok := info.(identity.Manager); ok { - im.Add(p) - } - } - return p, err -} - func (s *Site) permalink(link string) string { return s.PathSpec.PermalinkForBaseURL(link, s.PathSpec.BaseURL.String()) } @@ -1686,10 +1732,12 @@ func (s *Site) renderAndWriteXML(statCounter *uint64, name string, targetPath st func (s *Site) renderAndWritePage(statCounter *uint64, name string, targetPath string, p *pageState, templ tpl.Template) error { s.Log.Debugf("Render %s to %q", name, targetPath) + s.h.IncrPageRender() renderBuffer := bp.GetBuffer() defer bp.PutBuffer(renderBuffer) of := p.outputFormat() + p.pageOutput.renderState++ if err := s.renderForTemplate(p.Kind(), of.Name, p, renderBuffer, templ); err != nil { return err @@ -1743,7 +1791,7 @@ var infoOnMissingLayout = map[string]bool{ // where ITEM is the thing being hooked. type hookRenderer struct { templateHandler tpl.TemplateHandler - identity.SearchProvider + identity.Identity templ tpl.Template } @@ -1755,6 +1803,10 @@ func (hr hookRenderer) RenderHeading(w io.Writer, ctx hooks.HeadingContext) erro return hr.templateHandler.Execute(hr.templ, w, ctx) } +func (hr hookRenderer) Template() identity.Identity { + return hr.templ.(tpl.Info) +} + func (s *Site) renderForTemplate(name, outputFormat string, d interface{}, w io.Writer, templ tpl.Template) (err error) { if templ == nil { s.logMissingLayout(name, "", "", outputFormat) @@ -1762,7 +1814,7 @@ func (s *Site) renderForTemplate(name, outputFormat string, d interface{}, w io. } if err = s.Tmpl().Execute(templ, w, d); err != nil { - return _errors.Wrapf(err, "render of %q failed", name) + return errors.Wrapf(err, "render of %q failed", name) } return } @@ -1783,71 +1835,217 @@ func (s *Site) publish(statCounter *uint64, path string, r io.Reader) (err error return helpers.WriteToDisk(filepath.Clean(path), r, s.BaseFs.PublishFs) } -func (s *Site) kindFromFileInfoOrSections(fi *fileInfo, sections []string) string { - if fi.TranslationBaseName() == "_index" { - if fi.Dir() == "" { - return page.KindHome +func (s *Site) newPageFromTreeRef(np contentTreeRefProvider, pc pageContent) (*pageState, error) { + n := np.GetNode() + + var f *source.File + var content func() (hugio.ReadSeekCloser, error) + + fi := n.FileInfo() + if fi != nil { + var err error + f, err = s.SourceSpec.NewFileInfo(fi) + if err != nil { + return nil, err + } + + meta := fi.Meta() + content = func() (hugio.ReadSeekCloser, error) { + return meta.Open() + } + } + + container := np.GetContainerNode() + branch := np.GetBranch() + bundled := container != nil && container.p.IsPage() + + var kindProvider contentKindProvider + if kp, ok := n.traits.(contentKindProvider); ok { + kindProvider = kp + } else { + var kind string + if np.Key() == "" { + kind = pagekinds.Home + } else if container != nil && container.IsView() { + panic("2 TODO1 remove me") + } else if n.IsView() { + panic(fmt.Sprintf("2 TODO1 remove me: %T", n.traits)) + } else if branch.n == n { + kind = pagekinds.Section + } else { + kind = pagekinds.Page } - return s.kindFromSections(sections) + kindProvider = stringKindProvider(kind) } - return page.KindPage -} + metaProvider := &pageMeta{ + contentKindProvider: kindProvider, + treeRef: np, + contentNodeInfoProvider: np, + bundled: bundled, + s: s, + f: f, + } -func (s *Site) kindFromSections(sections []string) string { - if len(sections) == 0 { - return page.KindHome + ps, err := newPageBase(metaProvider) + if err != nil { + return nil, err } + n.p = ps - return s.kindFromSectionPath(path.Join(sections...)) -} + if fi != nil && fi.Meta().IsRootFile { + // Make sure that the bundle/section we start walking from is always + // rendered. + // This is only relevant in server fast render mode. + // TODO1 ps.forceRender = true + } + + var parentBucket *pagesMapBucket + if kindProvider.Kind() == pagekinds.Home { + parentBucket = ps.s.siteBucket + } else if bundled { + parentBucket = branch.n.p.bucket + } else if container != nil { + parentBucket = container.p.bucket + } + + if ps.IsNode() { + ps.bucket = newPageBucket(parentBucket, ps) + } -func (s *Site) kindFromSectionPath(sectionPath string) string { - for _, plural := range s.siteCfg.taxonomiesConfig { - if plural == sectionPath { - return page.KindTaxonomy + if fi == nil { + var meta map[string]interface{} + if kindProvider.Kind() == pagekinds.Term { + meta = map[string]interface{}{ + "title": n.traits.(viewInfoTrait).ViewInfo().Term(), + } + } + if err := metaProvider.setMetadata(parentBucket, n, meta); err != nil { + return nil, ps.wrapError(err) } + } else { + gi, err := s.h.gitInfoForPage(ps) + if err != nil { + return nil, errors.Wrap(err, "failed to load Git data") + } + ps.gitInfo = gi + + if pc.source.posMainContent > 0 { // TODO1 + ps.pageContent = pc + } else { + r, err := content() + if err != nil { + return nil, err + } + defer r.Close() + + parseResult, err := pageparser.Parse( + r, + pageparser.Config{EnableEmoji: s.siteCfg.enableEmoji}, + ) + if err != nil { + return nil, err + } + + ps.pageContent = pageContent{ + source: rawPageContent{ + parsed: parseResult, + posMainContent: -1, + posSummaryEnd: -1, + posBodyStart: -1, + }, + } - if strings.HasPrefix(sectionPath, plural) { - return page.KindTerm } - } + ps.shortcodeState = newShortcodeHandler(ps, ps.s, nil) - return page.KindSection -} + // TODO1 + meta, err := ps.mapContent(metaProvider) + if err != nil { + return nil, ps.wrapError(err) + } + + if err := metaProvider.setMetadata(parentBucket, n, meta); err != nil { + return nil, ps.wrapError(err) + } -func (s *Site) newPage( - n *contentNode, - parentbBucket *pagesMapBucket, - kind, title string, - sections ...string) *pageState { - m := map[string]interface{}{} - if title != "" { - m["title"] = title } - p, err := newPageFromMeta( - n, - parentbBucket, - m, - &pageMeta{ - s: s, - kind: kind, - sections: sections, - }) - if err != nil { - panic(err) + if err := metaProvider.applyDefaultValues(np); err != nil { + return nil, err } - return p + ps.init.Add(func() (interface{}, error) { + pp, err := newPagePaths(s, n, metaProvider) + if err != nil { + return nil, err + } + + var outputFormatsForPage output.Formats + var renderFormats output.Formats + + if !n.IsStandalone() { + outputFormatsForPage = ps.m.outputFormats() + renderFormats = ps.s.h.renderFormats + } else { + // One of the fixed output format pages, e.g. 404. + outputFormatsForPage = output.Formats{n.traits.(kindOutputFormatTrait).OutputFormat()} + renderFormats = outputFormatsForPage + } + + // Prepare output formats for all sites. + // We do this even if this page does not get rendered on + // its own. It may be referenced via .Site.GetPage and + // it will then need an output format. + ps.pageOutputs = make([]*pageOutput, len(renderFormats)) + created := make(map[string]*pageOutput) + shouldRenderPage := !ps.m.noRender() + + for i, f := range renderFormats { + if po, found := created[f.Name]; found { + ps.pageOutputs[i] = po + continue + } + + render := shouldRenderPage + if render { + _, render = outputFormatsForPage.GetByName(f.Name) + } + + po := newPageOutput(ps, pp, f, render) + + // Create a content provider for the first, + // we may be able to reuse it. + if i == 0 { + contentProvider, err := newPageContentOutput(po) + if err != nil { + return nil, err + } + po.initContentProvider(contentProvider) + } + + ps.pageOutputs[i] = po + created[f.Name] = po + + } + + if err := ps.initCommonProviders(pp); err != nil { + return nil, err + } + + return nil, nil + }) + + return ps, nil } -func (s *Site) shouldBuild(p page.Page) bool { +func (s *Site) shouldBuild(p *pageState) bool { + dates := p.pageCommon.m.getTemporaryDates() return shouldBuild(s.BuildFuture, s.BuildExpired, - s.BuildDrafts, p.Draft(), p.PublishDate(), p.ExpiryDate()) + s.BuildDrafts, p.Draft(), dates.PublishDate(), dates.ExpiryDate()) } func shouldBuild(buildFuture bool, buildExpired bool, buildDrafts bool, Draft bool, diff --git a/hugolib/site_benchmark_new_test.go b/hugolib/site_benchmark_new_test.go index ea3f223dcef..24ac5b45671 100644 --- a/hugolib/site_benchmark_new_test.go +++ b/hugolib/site_benchmark_new_test.go @@ -101,7 +101,6 @@ title="My Page" My page content. ` - } var categoryKey string @@ -241,7 +240,6 @@ canonifyURLs = true return sb }, func(s *sitesBuilder) { - }, }, { @@ -274,6 +272,8 @@ canonifyURLs = true sb := newTestSitesBuilder(b).WithConfigFile("toml", ` baseURL = "https://example.com" +ignoreWarnings = ["warn-path-file"] + [languages] [languages.en] weight=1 @@ -421,6 +421,7 @@ baseURL = "https://example.com" createContent := func(dir, name string) { var content string if strings.Contains(name, "_index") { + // TODO(bep) fixme content = pageContent(1) } else { content = pageContentWithCategory(1, fmt.Sprintf("category%d", r.Intn(5)+1)) @@ -535,7 +536,7 @@ func BenchmarkSiteNew(b *testing.B) { panic("infinite loop") } p = pages[rnd.Intn(len(pages))] - if !p.File().IsZero() { + if p.File() != nil { break } } diff --git a/hugolib/site_output.go b/hugolib/site_output.go index c9c9f0ae501..b9a763c7d8d 100644 --- a/hugolib/site_output.go +++ b/hugolib/site_output.go @@ -17,8 +17,9 @@ import ( "fmt" "strings" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gohugoio/hugo/output" - "github.com/gohugoio/hugo/resources/page" "github.com/spf13/cast" ) @@ -34,20 +35,20 @@ func createDefaultOutputFormats(allFormats output.Formats) map[string]output.For } m := map[string]output.Formats{ - page.KindPage: {htmlOut}, - page.KindHome: defaultListTypes, - page.KindSection: defaultListTypes, - page.KindTerm: defaultListTypes, - page.KindTaxonomy: defaultListTypes, + pagekinds.Page: {htmlOut}, + pagekinds.Home: defaultListTypes, + pagekinds.Section: defaultListTypes, + pagekinds.Term: defaultListTypes, + pagekinds.Taxonomy: defaultListTypes, // Below are for consistency. They are currently not used during rendering. - kindSitemap: {sitemapOut}, - kindRobotsTXT: {robotsOut}, - kind404: {htmlOut}, + pagekinds.Sitemap: {sitemapOut}, + pagekinds.RobotsTXT: {robotsOut}, + pagekinds.Status404: {htmlOut}, } // May be disabled if rssFound { - m[kindRSS] = output.Formats{rssOut} + m["RSS"] = output.Formats{rssOut} } return m @@ -69,7 +70,7 @@ func createSiteOutputFormats(allFormats output.Formats, outputs map[string]inter seen := make(map[string]bool) for k, v := range outputs { - k = getKind(k) + k = pagekinds.Get(k) if k == "" { // Invalid kind continue diff --git a/hugolib/site_output_test.go b/hugolib/site_output_test.go index 815625ff10d..9c5f0c00024 100644 --- a/hugolib/site_output_test.go +++ b/hugolib/site_output_test.go @@ -18,9 +18,10 @@ import ( "strings" "testing" + "github.com/gohugoio/hugo/resources/page/pagekinds" + qt "github.com/frankban/quicktest" "github.com/gohugoio/hugo/config" - "github.com/gohugoio/hugo/resources/page" "github.com/spf13/afero" @@ -141,7 +142,7 @@ Len Pages: {{ .Kind }} {{ len .Site.RegularPages }} Page Number: {{ .Paginator.P s := b.H.Sites[0] b.Assert(s.language.Lang, qt.Equals, "en") - home := s.getPage(page.KindHome) + home := s.getPage(pagekinds.Home) b.Assert(home, qt.Not(qt.IsNil)) @@ -217,6 +218,8 @@ Len Pages: {{ .Kind }} {{ len .Site.RegularPages }} Page Number: {{ .Paginator.P // Issue #3447 func TestRedefineRSSOutputFormat(t *testing.T) { + t.Parallel() + siteConfig := ` baseURL = "http://example.com/blog" @@ -313,7 +316,7 @@ baseName = "customdelimbase" th.assertFileContent("public/nosuffixbase", "no suffix") th.assertFileContent("public/customdelimbase_del", "custom delim") - home := s.getPage(page.KindHome) + home := s.getPage(pagekinds.Home) c.Assert(home, qt.Not(qt.IsNil)) outputs := home.OutputFormats() @@ -359,8 +362,8 @@ func TestCreateSiteOutputFormats(t *testing.T) { c := qt.New(t) outputsConfig := map[string]interface{}{ - page.KindHome: []string{"HTML", "JSON"}, - page.KindSection: []string{"JSON"}, + pagekinds.Home: []string{"HTML", "JSON"}, + pagekinds.Section: []string{"JSON"}, } cfg := config.New() @@ -368,21 +371,21 @@ func TestCreateSiteOutputFormats(t *testing.T) { outputs, err := createSiteOutputFormats(output.DefaultFormats, cfg.GetStringMap("outputs"), false) c.Assert(err, qt.IsNil) - c.Assert(outputs[page.KindSection], deepEqualsOutputFormats, output.Formats{output.JSONFormat}) - c.Assert(outputs[page.KindHome], deepEqualsOutputFormats, output.Formats{output.HTMLFormat, output.JSONFormat}) + c.Assert(outputs[pagekinds.Section], deepEqualsOutputFormats, output.Formats{output.JSONFormat}) + c.Assert(outputs[pagekinds.Home], deepEqualsOutputFormats, output.Formats{output.HTMLFormat, output.JSONFormat}) // Defaults - c.Assert(outputs[page.KindTerm], deepEqualsOutputFormats, output.Formats{output.HTMLFormat, output.RSSFormat}) - c.Assert(outputs[page.KindTaxonomy], deepEqualsOutputFormats, output.Formats{output.HTMLFormat, output.RSSFormat}) - c.Assert(outputs[page.KindPage], deepEqualsOutputFormats, output.Formats{output.HTMLFormat}) + c.Assert(outputs[pagekinds.Term], deepEqualsOutputFormats, output.Formats{output.HTMLFormat, output.RSSFormat}) + c.Assert(outputs[pagekinds.Taxonomy], deepEqualsOutputFormats, output.Formats{output.HTMLFormat, output.RSSFormat}) + c.Assert(outputs[pagekinds.Page], deepEqualsOutputFormats, output.Formats{output.HTMLFormat}) // These aren't (currently) in use when rendering in Hugo, // but the pages needs to be assigned an output format, // so these should also be correct/sensible. - c.Assert(outputs[kindRSS], deepEqualsOutputFormats, output.Formats{output.RSSFormat}) - c.Assert(outputs[kindSitemap], deepEqualsOutputFormats, output.Formats{output.SitemapFormat}) - c.Assert(outputs[kindRobotsTXT], deepEqualsOutputFormats, output.Formats{output.RobotsTxtFormat}) - c.Assert(outputs[kind404], deepEqualsOutputFormats, output.Formats{output.HTMLFormat}) + c.Assert(outputs["RSS"], deepEqualsOutputFormats, output.Formats{output.RSSFormat}) + c.Assert(outputs[pagekinds.Sitemap], deepEqualsOutputFormats, output.Formats{output.SitemapFormat}) + c.Assert(outputs[pagekinds.RobotsTXT], deepEqualsOutputFormats, output.Formats{output.RobotsTxtFormat}) + c.Assert(outputs[pagekinds.Status404], deepEqualsOutputFormats, output.Formats{output.HTMLFormat}) }) // Issue #4528 @@ -399,7 +402,7 @@ func TestCreateSiteOutputFormats(t *testing.T) { outputs, err := createSiteOutputFormats(output.DefaultFormats, cfg.GetStringMap("outputs"), false) c.Assert(err, qt.IsNil) - c.Assert(outputs[page.KindTaxonomy], deepEqualsOutputFormats, output.Formats{output.JSONFormat}) + c.Assert(outputs[pagekinds.Taxonomy], deepEqualsOutputFormats, output.Formats{output.JSONFormat}) }) } @@ -407,7 +410,7 @@ func TestCreateSiteOutputFormatsInvalidConfig(t *testing.T) { c := qt.New(t) outputsConfig := map[string]interface{}{ - page.KindHome: []string{"FOO", "JSON"}, + pagekinds.Home: []string{"FOO", "JSON"}, } cfg := config.New() @@ -418,10 +421,12 @@ func TestCreateSiteOutputFormatsInvalidConfig(t *testing.T) { } func TestCreateSiteOutputFormatsEmptyConfig(t *testing.T) { + t.Parallel() + c := qt.New(t) outputsConfig := map[string]interface{}{ - page.KindHome: []string{}, + pagekinds.Home: []string{}, } cfg := config.New() @@ -429,14 +434,14 @@ func TestCreateSiteOutputFormatsEmptyConfig(t *testing.T) { outputs, err := createSiteOutputFormats(output.DefaultFormats, cfg.GetStringMap("outputs"), false) c.Assert(err, qt.IsNil) - c.Assert(outputs[page.KindHome], deepEqualsOutputFormats, output.Formats{output.HTMLFormat, output.RSSFormat}) + c.Assert(outputs[pagekinds.Home], deepEqualsOutputFormats, output.Formats{output.HTMLFormat, output.RSSFormat}) } func TestCreateSiteOutputFormatsCustomFormats(t *testing.T) { c := qt.New(t) outputsConfig := map[string]interface{}{ - page.KindHome: []string{}, + pagekinds.Home: []string{}, } cfg := config.New() @@ -449,7 +454,7 @@ func TestCreateSiteOutputFormatsCustomFormats(t *testing.T) { outputs, err := createSiteOutputFormats(output.Formats{customRSS, customHTML}, cfg.GetStringMap("outputs"), false) c.Assert(err, qt.IsNil) - c.Assert(outputs[page.KindHome], deepEqualsOutputFormats, output.Formats{customHTML, customRSS}) + c.Assert(outputs[pagekinds.Home], deepEqualsOutputFormats, output.Formats{customHTML, customRSS}) } // https://github.com/gohugoio/hugo/issues/5849 diff --git a/hugolib/site_render.go b/hugolib/site_render.go index 77ece780bbe..5e7e3bb9436 100644 --- a/hugolib/site_render.go +++ b/hugolib/site_render.go @@ -19,15 +19,15 @@ import ( "strings" "sync" + "github.com/gohugoio/hugo/output" + "github.com/gohugoio/hugo/tpl" "github.com/gohugoio/hugo/config" - "github.com/gohugoio/hugo/output" "github.com/pkg/errors" "github.com/gohugoio/hugo/resources/page" - "github.com/gohugoio/hugo/resources/page/pagemeta" ) type siteRenderContext struct { @@ -45,7 +45,7 @@ type siteRenderContext struct { // Whether to render 404.html, robotsTXT.txt which usually is rendered // once only in the site root. -func (s siteRenderContext) renderSingletonPages() bool { +func (s siteRenderContext) shouldRenderSingletonPages() bool { if s.multihost { // 1 per site return s.outIdx == 0 @@ -55,8 +55,7 @@ func (s siteRenderContext) renderSingletonPages() bool { return s.sitesOutIdx == 0 } -// renderPages renders pages each corresponding to a markdown file. -// TODO(bep np doc +// renderPages renders this Site's pages for the output format defined in ctx. func (s *Site) renderPages(ctx *siteRenderContext) error { numWorkers := config.GetNumWorkerMultiplier() @@ -67,15 +66,20 @@ func (s *Site) renderPages(ctx *siteRenderContext) error { go s.errorCollator(results, errs) wg := &sync.WaitGroup{} - for i := 0; i < numWorkers; i++ { wg.Add(1) - go pageRenderer(ctx, s, pages, results, wg) + go s.renderPage(ctx, pages, results, wg) } cfg := ctx.cfg - s.pageMap.pageTrees.Walk(func(ss string, n *contentNode) bool { + s.pageMap.WalkPagesAllPrefixSection("", nil, nil, func(np contentNodeProvider) bool { + n := np.GetNode() + if ctx.outIdx > 0 && n.p.getTreeRef().GetNode().IsStandalone() { + // Only render the standalone pages (e.g. 404) once. + return false + } + if cfg.shouldRender(n.p) { select { case <-s.h.Done(): @@ -100,9 +104,8 @@ func (s *Site) renderPages(ctx *siteRenderContext) error { return nil } -func pageRenderer( +func (s *Site) renderPage( ctx *siteRenderContext, - s *Site, pages <-chan *pageState, results chan<- error, wg *sync.WaitGroup) { @@ -134,7 +137,15 @@ func pageRenderer( targetPath := p.targetPaths().TargetFilename - if err := s.renderAndWritePage(&s.PathSpec.ProcessingStats.Pages, "page "+p.Title(), targetPath, p, templ); err != nil { + var statCounter *uint64 + switch p.outputFormat().Name { + case output.SitemapFormat.Name: + statCounter = &s.PathSpec.ProcessingStats.Sitemaps + default: + statCounter = &s.PathSpec.ProcessingStats.Pages + } + + if err := s.renderAndWritePage(statCounter, "page "+p.Title(), targetPath, p, templ); err != nil { results <- err } @@ -221,108 +232,17 @@ func (s *Site) renderPaginator(p *pageState, templ tpl.Template) error { return nil } -func (s *Site) render404() error { - p, err := newPageStandalone(&pageMeta{ - s: s, - kind: kind404, - urlPaths: pagemeta.URLPath{ - URL: "404.html", - }, - }, - output.HTMLFormat, - ) - if err != nil { - return err - } - - if !p.render { - return nil - } - - var d output.LayoutDescriptor - d.Kind = kind404 - - templ, found, err := s.Tmpl().LookupLayout(d, output.HTMLFormat) - if err != nil { - return err - } - if !found { - return nil - } - - targetPath := p.targetPaths().TargetFilename - - if targetPath == "" { - return errors.New("failed to create targetPath for 404 page") - } - - return s.renderAndWritePage(&s.PathSpec.ProcessingStats.Pages, "404 page", targetPath, p, templ) -} - -func (s *Site) renderSitemap() error { - p, err := newPageStandalone(&pageMeta{ - s: s, - kind: kindSitemap, - urlPaths: pagemeta.URLPath{ - URL: s.siteCfg.sitemap.Filename, - }, - }, - output.HTMLFormat, - ) - if err != nil { - return err - } - - if !p.render { - return nil - } - - targetPath := p.targetPaths().TargetFilename - - if targetPath == "" { - return errors.New("failed to create targetPath for sitemap") - } - - templ := s.lookupLayouts("sitemap.xml", "_default/sitemap.xml", "_internal/_default/sitemap.xml") - - return s.renderAndWriteXML(&s.PathSpec.ProcessingStats.Sitemaps, "sitemap", targetPath, p, templ) -} - -func (s *Site) renderRobotsTXT() error { - if !s.Cfg.GetBool("enableRobotsTXT") { - return nil - } - - p, err := newPageStandalone(&pageMeta{ - s: s, - kind: kindRobotsTXT, - urlPaths: pagemeta.URLPath{ - URL: "robots.txt", - }, - }, - output.RobotsTxtFormat) - if err != nil { - return err - } - - if !p.render { - return nil - } - - templ := s.lookupLayouts("robots.txt", "_default/robots.txt", "_internal/_default/robots.txt") - - return s.renderAndWritePage(&s.PathSpec.ProcessingStats.Pages, "Robots Txt", p.targetPaths().TargetFilename, p, templ) -} - // renderAliases renders shell pages that simply have a redirect in the header. func (s *Site) renderAliases() error { var err error - s.pageMap.pageTrees.WalkLinkable(func(ss string, n *contentNode) bool { + + s.pageMap.WalkPagesAllPrefixSection("", nil, contentTreeNoLinkFilter, func(np contentNodeProvider) bool { + n := np.GetNode() p := n.p + if len(p.Aliases()) == 0 { return false } - pathSeen := make(map[string]bool) for _, of := range p.OutputFormats() { diff --git a/hugolib/site_sections_test.go b/hugolib/site_sections_test.go index 2a4c39533a2..44bd119991f 100644 --- a/hugolib/site_sections_test.go +++ b/hugolib/site_sections_test.go @@ -19,6 +19,8 @@ import ( "strings" "testing" + "github.com/gohugoio/hugo/resources/page/pagekinds" + qt "github.com/frankban/quicktest" "github.com/gohugoio/hugo/deps" "github.com/gohugoio/hugo/resources/page" @@ -32,7 +34,7 @@ func TestNestedSections(t *testing.T) { ) cfg.Set("permalinks", map[string]string{ - "perm a": ":sections/:title", + "perm-a": ":sections/:title", }) pageTemplate := `--- @@ -125,7 +127,7 @@ PAG|{{ .Title }}|{{ $sect.InSection . }} {"elsewhere", func(c *qt.C, p page.Page) { c.Assert(len(p.Pages()), qt.Equals, 1) for _, p := range p.Pages() { - c.Assert(p.SectionsPath(), qt.Equals, "elsewhere") + c.Assert(p.SectionsPath(), qt.Equals, "/elsewhere") } }}, {"post", func(c *qt.C, p page.Page) { @@ -273,6 +275,10 @@ PAG|{{ .Title }}|{{ $sect.InSection . }} isAncestor, err = nilp.IsAncestor(l1) c.Assert(err, qt.IsNil) c.Assert(isAncestor, qt.Equals, false) + + l3 := getPage(p, "/l1/l2/l3") + c.Assert(l3.FirstSection(), qt.Equals, l1) + }}, {"perm a,link", func(c *qt.C, p page.Page) { c.Assert(p.Title(), qt.Equals, "T9_-1") @@ -287,7 +293,7 @@ PAG|{{ .Title }}|{{ $sect.InSection . }} }}, } - home := s.getPage(page.KindHome) + home := s.getPage(pagekinds.Home) for _, test := range tests { test := test @@ -295,7 +301,7 @@ PAG|{{ .Title }}|{{ $sect.InSection . }} t.Parallel() c := qt.New(t) sections := strings.Split(test.sections, ",") - p := s.getPage(page.KindSection, sections...) + p := s.getPage(pagekinds.Section, sections...) c.Assert(p, qt.Not(qt.IsNil), qt.Commentf(fmt.Sprint(sections))) if p.Pages() != nil { @@ -308,10 +314,9 @@ PAG|{{ .Title }}|{{ $sect.InSection . }} c.Assert(home, qt.Not(qt.IsNil)) - c.Assert(len(home.Sections()), qt.Equals, 9) c.Assert(s.Info.Sections(), deepEqualsPages, home.Sections()) - rootPage := s.getPage(page.KindPage, "mypage.md") + rootPage := s.getPage(pagekinds.Page, "mypage.md") c.Assert(rootPage, qt.Not(qt.IsNil)) c.Assert(rootPage.Parent().IsHome(), qt.Equals, true) // https://github.com/gohugoio/hugo/issues/6365 @@ -323,7 +328,7 @@ PAG|{{ .Title }}|{{ $sect.InSection . }} // If we later decide to do something about this, we will have to do some normalization in // getPage. // TODO(bep) - sectionWithSpace := s.getPage(page.KindSection, "Spaces in Section") + sectionWithSpace := s.getPage(pagekinds.Section, "Spaces in Section") c.Assert(sectionWithSpace, qt.Not(qt.IsNil)) c.Assert(sectionWithSpace.RelPermalink(), qt.Equals, "/spaces-in-section/") diff --git a/hugolib/site_stats_test.go b/hugolib/site_stats_test.go index df1f64840da..b460ce65376 100644 --- a/hugolib/site_stats_test.go +++ b/hugolib/site_stats_test.go @@ -94,5 +94,5 @@ aliases: [/Ali%d] helpers.ProcessingStatsTable(&buff, stats...) - c.Assert(buff.String(), qt.Contains, "Pages | 19 | 6") + c.Assert(buff.String(), qt.Contains, "Pages | 20 | 6") } diff --git a/hugolib/site_test.go b/hugolib/site_test.go index 73cea855a5f..15e4bab4de0 100644 --- a/hugolib/site_test.go +++ b/hugolib/site_test.go @@ -22,6 +22,8 @@ import ( "strings" "testing" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gobuffalo/flect" "github.com/gohugoio/hugo/config" "github.com/gohugoio/hugo/publisher" @@ -609,7 +611,7 @@ func TestOrderedPages(t *testing.T) { s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{SkipRender: true}) - if s.getPage(page.KindSection, "sect").Pages()[1].Title() != "Three" || s.getPage(page.KindSection, "sect").Pages()[2].Title() != "Four" { + if s.getPage(pagekinds.Section, "sect").Pages()[1].Title() != "Three" || s.getPage(pagekinds.Section, "sect").Pages()[2].Title() != "Four" { t.Error("Pages in unexpected order.") } @@ -897,7 +899,7 @@ func TestRefLinking(t *testing.T) { t.Parallel() site := setupLinkingMockSite(t) - currentPage := site.getPage(page.KindPage, "level2/level3/start.md") + currentPage := site.getPage(pagekinds.Page, "level2/level3/start.md") if currentPage == nil { t.Fatalf("failed to find current page in site") } @@ -937,9 +939,6 @@ func TestRefLinking(t *testing.T) { {".", "", true, "/level2/level3/"}, {"./", "", true, "/level2/level3/"}, - // try to confuse parsing - {"embedded.dot.md", "", true, "/level2/level3/embedded.dot/"}, - // test empty link, as well as fragment only link {"", "", true, ""}, } { @@ -957,12 +956,14 @@ func TestRefLinking(t *testing.T) { func checkLinkCase(site *Site, link string, currentPage page.Page, relative bool, outputFormat string, expected string, t *testing.T, i int) { t.Helper() if out, err := site.refLink(link, currentPage, relative, outputFormat); err != nil || out != expected { - t.Fatalf("[%d] Expected %q from %q to resolve to %q, got %q - error: %s", i, link, currentPage.Pathc(), expected, out, err) + t.Fatalf("[%d] Expected %q from %q to resolve to %q, got %q - error: %s", i, link, currentPage.Path(), expected, out, err) } } // https://github.com/gohugoio/hugo/issues/6952 func TestRefIssues(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t) b.WithContent( "post/b1/index.md", "---\ntitle: pb1\n---\nRef: {{< ref \"b2\" >}}", @@ -982,6 +983,8 @@ func TestRefIssues(t *testing.T) { func TestClassCollector(t *testing.T) { for _, minify := range []bool{false, true} { t.Run(fmt.Sprintf("minify-%t", minify), func(t *testing.T) { + t.Parallel() + statsFilename := "hugo_stats.json" defer os.Remove(statsFilename) diff --git a/hugolib/site_url_test.go b/hugolib/site_url_test.go index d668095b913..d7ce7bc2a2b 100644 --- a/hugolib/site_url_test.go +++ b/hugolib/site_url_test.go @@ -19,7 +19,7 @@ import ( "path/filepath" "testing" - "github.com/gohugoio/hugo/resources/page" + "github.com/gohugoio/hugo/resources/page/pagekinds" qt "github.com/frankban/quicktest" "github.com/gohugoio/hugo/deps" @@ -121,12 +121,12 @@ Do not go gentle into that good night. c.Assert(len(s.RegularPages()), qt.Equals, 2) - notUgly := s.getPage(page.KindPage, "sect1/p1.md") + notUgly := s.getPage(pagekinds.Page, "sect1/p1.md") c.Assert(notUgly, qt.Not(qt.IsNil)) c.Assert(notUgly.Section(), qt.Equals, "sect1") c.Assert(notUgly.RelPermalink(), qt.Equals, "/sect1/p1/") - ugly := s.getPage(page.KindPage, "sect2/p2.md") + ugly := s.getPage(pagekinds.Page, "sect2/p2.md") c.Assert(ugly, qt.Not(qt.IsNil)) c.Assert(ugly.Section(), qt.Equals, "sect2") c.Assert(ugly.RelPermalink(), qt.Equals, "/sect2/p2.html") @@ -179,7 +179,7 @@ Do not go gentle into that good night. c.Assert(len(s.RegularPages()), qt.Equals, 10) - sect1 := s.getPage(page.KindSection, "sect1") + sect1 := s.getPage(pagekinds.Section, "sect1") c.Assert(sect1, qt.Not(qt.IsNil)) c.Assert(sect1.RelPermalink(), qt.Equals, "/ss1/") th.assertFileContent(filepath.Join("public", "ss1", "index.html"), "P1|URL: /ss1/|Next: /ss1/page/2/") diff --git a/hugolib/taxonomy_test.go b/hugolib/taxonomy_test.go index b2603217402..cf8eac6be58 100644 --- a/hugolib/taxonomy_test.go +++ b/hugolib/taxonomy_test.go @@ -1,4 +1,4 @@ -// Copyright 2019 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -20,6 +20,8 @@ import ( "strings" "testing" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gohugoio/hugo/resources/page" qt "github.com/frankban/quicktest" @@ -153,8 +155,8 @@ permalinkeds: s := b.H.Sites[0] - // Make sure that each page.KindTaxonomyTerm page has an appropriate number - // of page.KindTaxonomy pages in its Pages slice. + // Make sure that each pagekinds.KindTaxonomyTerm page has an appropriate number + // of pagekinds.KindTaxonomy pages in its Pages slice. taxonomyTermPageCounts := map[string]int{ "tags": 3, "categories": 2, @@ -165,16 +167,16 @@ permalinkeds: for taxonomy, count := range taxonomyTermPageCounts { msg := qt.Commentf(taxonomy) - term := s.getPage(page.KindTaxonomy, taxonomy) + term := s.getPage(pagekinds.Taxonomy, taxonomy) b.Assert(term, qt.Not(qt.IsNil), msg) b.Assert(len(term.Pages()), qt.Equals, count, msg) for _, p := range term.Pages() { - b.Assert(p.Kind(), qt.Equals, page.KindTerm) + b.Assert(p.Kind(), qt.Equals, pagekinds.Term) } } - cat1 := s.getPage(page.KindTerm, "categories", "cat1") + cat1 := s.getPage(pagekinds.Term, "categories", "cat1") b.Assert(cat1, qt.Not(qt.IsNil)) if uglyURLs { b.Assert(cat1.RelPermalink(), qt.Equals, "/blog/categories/cat1.html") @@ -182,8 +184,8 @@ permalinkeds: b.Assert(cat1.RelPermalink(), qt.Equals, "/blog/categories/cat1/") } - pl1 := s.getPage(page.KindTerm, "permalinkeds", "pl1") - permalinkeds := s.getPage(page.KindTaxonomy, "permalinkeds") + pl1 := s.getPage(pagekinds.Term, "permalinkeds", "pl1") + permalinkeds := s.getPage(pagekinds.Taxonomy, "permalinkeds") b.Assert(pl1, qt.Not(qt.IsNil)) b.Assert(permalinkeds, qt.Not(qt.IsNil)) if uglyURLs { @@ -194,7 +196,7 @@ permalinkeds: b.Assert(permalinkeds.RelPermalink(), qt.Equals, "/blog/permalinkeds/") } - helloWorld := s.getPage(page.KindTerm, "others", "hello-hugo-world") + helloWorld := s.getPage(pagekinds.Term, "others", "hello-hugo-world") b.Assert(helloWorld, qt.Not(qt.IsNil)) b.Assert(helloWorld.Title(), qt.Equals, "Hello Hugo world") @@ -266,11 +268,13 @@ title: "This is S3s" return pages } - ta := filterbyKind(page.KindTerm) - te := filterbyKind(page.KindTaxonomy) + te := filterbyKind(pagekinds.Term) + ta := filterbyKind(pagekinds.Taxonomy) + + // b.PrintDebug() - b.Assert(len(te), qt.Equals, 4) - b.Assert(len(ta), qt.Equals, 7) + b.Assert(len(ta), qt.Equals, 4) + b.Assert(len(te), qt.Equals, 7) b.AssertFileContent("public/news/categories/a/index.html", "Taxonomy List Page 1|a|Hello|https://example.com/news/categories/a/|") b.AssertFileContent("public/news/categories/b/index.html", "Taxonomy List Page 1|This is B|Hello|https://example.com/news/categories/b/|") @@ -279,6 +283,8 @@ title: "This is S3s" b.AssertFileContent("public/t1/t2/t3s/t4/t5/index.html", "Taxonomy List Page 1|This is T5|Hello|https://example.com/t1/t2/t3s/t4/t5/|") b.AssertFileContent("public/t1/t2/t3s/t4/t5/t6/index.html", "Taxonomy List Page 1|t4/t5/t6|Hello|https://example.com/t1/t2/t3s/t4/t5/t6/|") + // b.PrintDebug() + b.AssertFileContent("public/news/categories/index.html", "Taxonomy Term Page 1|News/Categories|Hello|https://example.com/news/categories/|") b.AssertFileContent("public/t1/t2/t3s/index.html", "Taxonomy Term Page 1|T1/T2/T3s|Hello|https://example.com/t1/t2/t3s/|") b.AssertFileContent("public/s1/s2/s3s/index.html", "Taxonomy Term Page 1|This is S3s|Hello|https://example.com/s1/s2/s3s/|") @@ -286,6 +292,8 @@ title: "This is S3s" // https://github.com/gohugoio/hugo/issues/5719 func TestTaxonomiesNextGenLoops(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t).WithSimpleConfigFile() b.WithTemplatesAdded("index.html", ` @@ -521,7 +529,7 @@ Funny:|/p1/| Funny:|/p2/|`) } -//https://github.com/gohugoio/hugo/issues/6590 +// https://github.com/gohugoio/hugo/issues/6590 func TestTaxonomiesListPages(t *testing.T) { b := newTestSitesBuilder(t) b.WithTemplates("_default/list.html", ` @@ -672,25 +680,27 @@ baseURL = "https://example.org" abc: {{ template "print-page" $abc }}|IsAncestor: {{ $abc.IsAncestor $abcdefgs }}|IsDescendant: {{ $abc.IsDescendant $abcdefgs }} abcdefgs: {{ template "print-page" $abcdefgs }}|IsAncestor: {{ $abcdefgs.IsAncestor $abc }}|IsDescendant: {{ $abcdefgs.IsDescendant $abc }} -{{ define "print-page" }}{{ .RelPermalink }}|{{ .Title }}|{{.Kind }}|Parent: {{ with .Parent }}{{ .RelPermalink }}{{ end }}|CurrentSection: {{ .CurrentSection.RelPermalink}}|FirstSection: {{ .FirstSection.RelPermalink }}{{ end }} +{{ define "print-page" }}{{ .RelPermalink }}|{{ .Title }}|Kind: {{.Kind }}|Parent: {{ with .Parent }}{{ .RelPermalink }}{{ end }}|CurrentSection: {{ .CurrentSection.RelPermalink}}|FirstSection: {{ .FirstSection.RelPermalink }}{{ end }} `) b.Build(BuildCfg{}) + // b.H.Sites[0].pageMap.debugDefault() + b.AssertFileContent("public/index.html", ` - Page: /||home|Parent: |CurrentSection: /| - Page: /abc/|abc|section|Parent: /|CurrentSection: /abc/| - Page: /abc/p1/|abc-p|page|Parent: /abc/|CurrentSection: /abc/| - Page: /abcdefgh/|abcdefgh|section|Parent: /|CurrentSection: /abcdefgh/| - Page: /abcdefgh/p1/|abcdefgh-p|page|Parent: /abcdefgh/|CurrentSection: /abcdefgh/| - Page: /abcdefghijk/|abcdefghijk|page|Parent: /|CurrentSection: /| - Page: /abcdefghis/|Abcdefghis|taxonomy|Parent: /|CurrentSection: /| - Page: /abcdefgs/|Abcdefgs|taxonomy|Parent: /|CurrentSection: /| - Page: /abcdefs/|Abcdefs|taxonomy|Parent: /|CurrentSection: /| - abc: /abcdefgs/abc/|abc|term|Parent: /abcdefgs/|CurrentSection: /abcdefgs/| - abcdefgs: /abcdefgs/|Abcdefgs|taxonomy|Parent: /|CurrentSection: /| - abc: /abcdefgs/abc/|abc|term|Parent: /abcdefgs/|CurrentSection: /abcdefgs/|FirstSection: /|IsAncestor: false|IsDescendant: true - abcdefgs: /abcdefgs/|Abcdefgs|taxonomy|Parent: /|CurrentSection: /|FirstSection: /|IsAncestor: true|IsDescendant: false -`) + Page: /||Kind: home|Parent: |CurrentSection: /| + Page: /abc/|abc|Kind: section|Parent: /|CurrentSection: /abc/| + Page: /abc/p1/|abc-p|Kind: page|Parent: /abc/|CurrentSection: /abc/| + Page: /abcdefgh/|abcdefgh|Kind: section|Parent: /|CurrentSection: /abcdefgh/| + Page: /abcdefgh/p1/|abcdefgh-p|Kind: page|Parent: /abcdefgh/|CurrentSection: /abcdefgh/| + Page: /abcdefghijk/|abcdefghijk|Kind: page|Parent: /|CurrentSection: /| + Page: /abcdefghis/|Abcdefghis|Kind: taxonomy|Parent: /|CurrentSection: /abcdefghis/| + Page: /abcdefgs/|Abcdefgs|Kind: taxonomy|Parent: /|CurrentSection: /abcdefgs/| + Page: /abcdefs/|Abcdefs|Kind: taxonomy|Parent: /|CurrentSection: /abcdefs/| + abc: /abcdefgs/abc/|abc|Kind: term|Parent: /abcdefgs/|CurrentSection: /abcdefgs/abc/| + abcdefgs: /abcdefgs/|Abcdefgs|Kind: taxonomy|Parent: /|CurrentSection: /abcdefgs/| + + abc: /abcdefgs/abc/|abc|Kind: term|Parent: /abcdefgs/|CurrentSection: /abcdefgs/abc/|FirstSection: /abcdefgs/|IsAncestor: false|IsDescendant: true + abcdefgs: /abcdefgs/|Abcdefgs|Kind: taxonomy|Parent: /|CurrentSection: /abcdefgs/|FirstSection: /abcdefgs/|IsAncestor: true|IsDescendant: false`) } diff --git a/hugolib/template_test.go b/hugolib/template_test.go index 2908fdf71a1..b5dd8c29f66 100644 --- a/hugolib/template_test.go +++ b/hugolib/template_test.go @@ -16,16 +16,13 @@ package hugolib import ( "fmt" "path/filepath" - "strings" "testing" "github.com/gohugoio/hugo/config" - "github.com/gohugoio/hugo/identity" qt "github.com/frankban/quicktest" "github.com/gohugoio/hugo/deps" "github.com/gohugoio/hugo/hugofs" - "github.com/gohugoio/hugo/tpl" ) func TestTemplateLookupOrder(t *testing.T) { @@ -211,6 +208,8 @@ Some content // https://github.com/gohugoio/hugo/issues/4895 func TestTemplateBOM(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t).WithSimpleConfigFile() bom := "\ufeff" @@ -376,6 +375,8 @@ title: My Page } func TestTemplateFuncs(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t).WithDefaultMultiSiteConfig() homeTpl := `Site: {{ site.Language.Lang }} / {{ .Site.Language.Lang }} / {{ site.BaseURL }} @@ -402,6 +403,8 @@ Hugo: {{ hugo.Generator }} } func TestPartialWithReturn(t *testing.T) { + t.Parallel() + c := qt.New(t) newBuilder := func(t testing.TB) *sitesBuilder { @@ -460,6 +463,7 @@ complex: 80: 80 // Issue 7528 func TestPartialWithZeroedArgs(t *testing.T) { + t.Parallel() b := newTestSitesBuilder(t) b.WithTemplatesAdded("index.html", @@ -483,10 +487,11 @@ X123X X123X X123X `) - } func TestPartialCached(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t) b.WithTemplatesAdded( @@ -512,6 +517,8 @@ Partial cached3: {{ partialCached "p1" "input3" $key2 }} // https://github.com/gohugoio/hugo/issues/6615 func TestTemplateTruth(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t) b.WithTemplatesAdded("index.html", ` {{ $p := index site.RegularPages 0 }} @@ -538,57 +545,9 @@ with: Zero OK `) } -func TestTemplateDependencies(t *testing.T) { - b := newTestSitesBuilder(t).Running() - - b.WithTemplates("index.html", ` -{{ $p := site.GetPage "p1" }} -{{ partial "p1.html" $p }} -{{ partialCached "p2.html" "foo" }} -{{ partials.Include "p3.html" "data" }} -{{ partials.IncludeCached "p4.html" "foo" }} -{{ $p := partial "p5" }} -{{ partial "sub/p6.html" }} -{{ partial "P7.html" }} -{{ template "_default/foo.html" }} -Partial nested: {{ partial "p10" }} - -`, - "partials/p1.html", `ps: {{ .Render "li" }}`, - "partials/p2.html", `p2`, - "partials/p3.html", `p3`, - "partials/p4.html", `p4`, - "partials/p5.html", `p5`, - "partials/sub/p6.html", `p6`, - "partials/P7.html", `p7`, - "partials/p8.html", `p8 {{ partial "p9.html" }}`, - "partials/p9.html", `p9`, - "partials/p10.html", `p10 {{ partial "p11.html" }}`, - "partials/p11.html", `p11`, - "_default/foo.html", `foo`, - "_default/li.html", `li {{ partial "p8.html" }}`, - ) - - b.WithContent("p1.md", `--- -title: P1 ---- - - -`) - - b.Build(BuildCfg{}) - - s := b.H.Sites[0] - - templ, found := s.lookupTemplate("index.html") - b.Assert(found, qt.Equals, true) - - idset := make(map[identity.Identity]bool) - collectIdentities(idset, templ.(tpl.Info)) - b.Assert(idset, qt.HasLen, 11) -} - func TestTemplateGoIssues(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t) b.WithTemplatesAdded( @@ -627,21 +586,9 @@ Population in Norway is 5 MILLIONS `) } -func collectIdentities(set map[identity.Identity]bool, provider identity.Provider) { - if ids, ok := provider.(identity.IdentitiesProvider); ok { - for _, id := range ids.GetIdentities() { - collectIdentities(set, id) - } - } else { - set[provider.GetIdentity()] = true - } -} - -func ident(level int) string { - return strings.Repeat(" ", level) -} - func TestPartialInline(t *testing.T) { + t.Parallel() + b := newTestSitesBuilder(t) b.WithContent("p1.md", "") @@ -676,6 +623,7 @@ P2: 32`, } func TestPartialInlineBase(t *testing.T) { + t.Parallel() b := newTestSitesBuilder(t) b.WithContent("p1.md", "") @@ -719,6 +667,7 @@ P3: Inline: p3 // https://github.com/gohugoio/hugo/issues/7478 func TestBaseWithAndWithoutDefine(t *testing.T) { + t.Parallel() b := newTestSitesBuilder(t) b.WithContent("p1.md", "---\ntitle: P\n---\nContent") diff --git a/hugolib/testhelpers_test.go b/hugolib/testhelpers_test.go index 105654c4f30..1a87ee5d041 100644 --- a/hugolib/testhelpers_test.go +++ b/hugolib/testhelpers_test.go @@ -5,6 +5,7 @@ import ( "fmt" "image/jpeg" "io" + "io/fs" "math/rand" "os" "path/filepath" @@ -19,7 +20,6 @@ import ( "unicode/utf8" "github.com/gohugoio/hugo/config/security" - "github.com/gohugoio/hugo/htesting" "github.com/gohugoio/hugo/output" @@ -58,6 +58,8 @@ var ( ) type sitesBuilder struct { + RewriteTest bool + Cfg config.Provider environ []string @@ -593,6 +595,32 @@ func (s *sitesBuilder) build(cfg BuildCfg, shouldFail bool) *sitesBuilder { s.Helper() defer func() { s.changedFiles = nil + s.removedFiles = nil + + if s.RewriteTest { + files := s.DumpTxtar() + name := s.Name() + + newTestTempl := `func %sNew(t *testing.T) { + c := qt.New(t) + + files := %s + + b := NewIntegrationTestBuilder( + IntegrationTestConfig{ + T: c, + NeedsOsFS: false, + NeedsNpmInstall: false, + TxtarString: files, + }).Build() + + b.Assert(true, qt.IsTrue) + } + ` + + newTest := fmt.Sprintf(newTestTempl, name, "`\n"+files+"\n`") + fmt.Println(newTest) + } }() if s.H == nil { @@ -702,22 +730,50 @@ func (s *sitesBuilder) AssertFileContentFn(filename string, f func(s string) boo } } +// Helper to migrate tests to new format. +func (s *sitesBuilder) DumpTxtar() string { + var sb strings.Builder + + skipRe := regexp.MustCompile(`^(public|resources|package-lock.json|go.sum)`) + + afero.Walk(s.Fs.Source, s.workingDir, func(path string, info fs.FileInfo, err error) error { + rel := strings.TrimPrefix(path, s.workingDir+"/") + if skipRe.MatchString(rel) { + if info.IsDir() { + return filepath.SkipDir + } + return nil + } + if info == nil || info.IsDir() { + return nil + } + sb.WriteString(fmt.Sprintf("-- %s --\n", rel)) + b, err := afero.ReadFile(s.Fs.Source, path) + s.Assert(err, qt.IsNil) + sb.WriteString(strings.TrimSpace(string(b))) + sb.WriteString("\n") + return nil + }) + + return sb.String() +} + func (s *sitesBuilder) AssertHome(matches ...string) { s.AssertFileContent("public/index.html", matches...) } func (s *sitesBuilder) AssertFileContent(filename string, matches ...string) { s.T.Helper() - content := s.FileContent(filename) + content := strings.TrimSpace(s.FileContent(filename)) for _, m := range matches { lines := strings.Split(m, "\n") for _, match := range lines { match = strings.TrimSpace(match) - if match == "" { + if match == "" || strings.HasPrefix(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) + s.Fatalf("No match for %q in content for %q:\n\n%q", match, filename, content) } } } @@ -761,9 +817,10 @@ func (s *sitesBuilder) AssertObject(expected string, object interface{}) { expected = strings.TrimSpace(expected) if expected != got { - fmt.Println(got) - diff := htesting.DiffStrings(expected, got) - s.Fatalf("diff:\n%s\nexpected\n%s\ngot\n%s", diff, expected, got) + s.Fatal("object diff") + // fmt.Println(got) + // diff := htesting.DiffStrings(expected, got) + // s.Fatalf("diff:\n%s\nexpected\n%s\ngot\n%s", diff, expected, got) } } @@ -787,6 +844,14 @@ func (s *sitesBuilder) GetPage(ref string) page.Page { return p } +func (s *sitesBuilder) PrintDebug() { + for _, ss := range s.H.Sites { + fmt.Println("Page map for site", ss.Lang()) + ss.pageMap.debug("", os.Stdout) + + } +} + func (s *sitesBuilder) GetPageRel(p page.Page, ref string) page.Page { p, err := s.H.Sites[0].getPageNew(p, ref) s.Assert(err, qt.IsNil) @@ -997,7 +1062,7 @@ func content(c resource.ContentProvider) string { func pagesToString(pages ...page.Page) string { var paths []string for _, p := range pages { - paths = append(paths, p.Pathc()) + paths = append(paths, p.Path()) } sort.Strings(paths) return strings.Join(paths, "|") @@ -1019,7 +1084,7 @@ func dumpPages(pages ...page.Page) { fmt.Println("---------") for _, p := range pages { fmt.Printf("Kind: %s Title: %-10s RelPermalink: %-10s Path: %-10s sections: %s Lang: %s\n", - p.Kind(), p.Title(), p.RelPermalink(), p.Pathc(), p.SectionsPath(), p.Lang()) + p.Kind(), p.Title(), p.RelPermalink(), p.Path(), p.SectionsPath(), p.Lang()) } } @@ -1027,7 +1092,7 @@ func dumpSPages(pages ...*pageState) { for i, p := range pages { fmt.Printf("%d: Kind: %s Title: %-10s RelPermalink: %-10s Path: %-10s sections: %s\n", i+1, - p.Kind(), p.Title(), p.RelPermalink(), p.Pathc(), p.SectionsPath()) + p.Kind(), p.Title(), p.RelPermalink(), p.Path(), p.SectionsPath()) } } diff --git a/hugolib/translations.go b/hugolib/translations.go index 76beafba9f9..b63c090e7e3 100644 --- a/hugolib/translations.go +++ b/hugolib/translations.go @@ -21,7 +21,8 @@ func pagesToTranslationsMap(sites []*Site) map[string]page.Pages { out := make(map[string]page.Pages) for _, s := range sites { - s.pageMap.pageTrees.Walk(func(ss string, n *contentNode) bool { + s.pageMap.WalkPagesAllPrefixSection("", nil, nil, func(np contentNodeProvider) bool { + n := np.GetNode() p := n.p // TranslationKey is implemented for all page types. base := p.TranslationKey() @@ -43,7 +44,8 @@ func pagesToTranslationsMap(sites []*Site) map[string]page.Pages { func assignTranslationsToPages(allTranslations map[string]page.Pages, sites []*Site) { for _, s := range sites { - s.pageMap.pageTrees.Walk(func(ss string, n *contentNode) bool { + s.pageMap.WalkPagesAllPrefixSection("", nil, nil, func(np contentNodeProvider) bool { + n := np.GetNode() p := n.p base := p.TranslationKey() translations, found := allTranslations[base] diff --git a/identity/identity.go b/identity/identity.go index 0527406756c..63d22412d94 100644 --- a/identity/identity.go +++ b/identity/identity.go @@ -1,52 +1,101 @@ +// Copyright 2020 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 provides ways to identify values in Hugo. Used for dependency tracking etc. package identity import ( - "path/filepath" + "fmt" + "reflect" "strings" "sync" "sync/atomic" ) -// NewIdentityManager creates a new Manager starting at id. -func NewManager(id Provider) Manager { +const ( + // Anonymous is an Identity that can be used when identity doesn't matter. + Anonymous = StringIdentity("__anonymous") + + // GenghisKhan is an Identity almost everyone relates to. + GenghisKhan = StringIdentity("__genghiskhan") +) + +var baseIdentifierIncr = &IncrementByOne{} + +// NewIdentityManager creates a new Manager. +func NewManager(root Identity) Manager { return &identityManager{ - Provider: id, - ids: Identities{id.GetIdentity(): id}, + Identity: root, + ids: Identities{root: true}, } } -// NewPathIdentity creates a new Identity with the two identifiers -// type and path. -func NewPathIdentity(typ, pat string) PathIdentity { - pat = strings.ToLower(strings.TrimPrefix(filepath.ToSlash(pat), "/")) - return PathIdentity{Type: typ, Path: pat} -} - // Identities stores identity providers. -type Identities map[Identity]Provider +type Identities map[Identity]bool -func (ids Identities) search(depth int, id Identity) Provider { - if v, found := ids[id.GetIdentity()]; found { - return v +func (ids Identities) AsSlice() []Identity { + s := make([]Identity, len(ids)) + i := 0 + for v := range ids { + s[i] = v + i++ + } + return s +} + +func (ids Identities) contains(depth int, probableMatch bool, id Identity) bool { + if id == Anonymous { + return false + } + if probableMatch && id == GenghisKhan { + return true + } + if _, found := ids[id]; found { + return true } depth++ // There may be infinite recursion in templates. if depth > 100 { - // Bail out. - return nil + // Bail out.¨ + if probableMatch { + return true + } + panic("probable infinite recursion in identity search") } - for _, v := range ids { - switch t := v.(type) { + for id2 := range ids { + if id2 == id { + // TODO1 Eq interface. + return true + } + + if probableMatch { + if id2.IdentifierBase() == id.IdentifierBase() { + return true + } + } + + switch t := id2.(type) { case IdentitiesProvider: - if nested := t.GetIdentities().search(depth, id); nested != nil { + if nested := t.GetIdentities().contains(depth, probableMatch, id); nested { return nested } } } - return nil + + return false } // IdentitiesProvider provides all Identities. @@ -54,97 +103,136 @@ type IdentitiesProvider interface { GetIdentities() Identities } -// Identity represents an thing that can provide an identify. This can be -// any Go type, but the Identity returned by GetIdentify must be hashable. +// DependencyManagerProvider provides a manager for dependencies. +type DependencyManagerProvider interface { + GetDependencyManager() Manager +} + +// Identity represents a thing in Hugo (a Page, a template etc.) +// Any implementation must be comparable/hashable. type Identity interface { - Provider - Name() string + IdentifierBase() interface{} } -// Manager manages identities, and is itself a Provider of Identity. -type Manager interface { - SearchProvider - Add(ids ...Provider) - Reset() +// IdentityProvider can be implemented by types that isn't itself and Identity, +// usually because they're not comparable/hashable. +type IdentityProvider interface { + GetIdentity() Identity } -// SearchProvider provides access to the chained set of identities. -type SearchProvider interface { - Provider +// IdentityGroupProvider can be implemented by tightly connected types. +// Current use case is Resource transformation via Hugo Pipes. +type IdentityGroupProvider interface { + GetIdentityGroup() Identity +} + +// IdentityLookupProvider provides a way to look up an Identity by name. +type IdentityLookupProvider interface { + LookupIdentity(name string) (Identity, bool) +} + +// Manager is an Identity that also manages identities, typically dependencies. +type Manager interface { + Identity IdentitiesProvider - Search(id Identity) Provider + AddIdentity(ids ...Identity) + Contains(id Identity) bool + ContainsProbably(id Identity) bool + Reset() } -// A PathIdentity is a common identity identified by a type and a path, e.g. "layouts" and "_default/single.html". -type PathIdentity struct { - Type string - Path string +type nopManager int + +var NopManager = new(nopManager) + +func (m *nopManager) GetIdentities() Identities { + return nil } -// GetIdentity returns itself. -func (id PathIdentity) GetIdentity() Identity { - return id +func (m *nopManager) GetIdentity() Identity { + return nil } -// Name returns the Path. -func (id PathIdentity) Name() string { - return id.Path +func (m *nopManager) AddIdentity(ids ...Identity) { } -// A KeyValueIdentity a general purpose identity. -type KeyValueIdentity struct { - Key string - Value string +func (m *nopManager) Contains(id Identity) bool { + return false } -// GetIdentity returns itself. -func (id KeyValueIdentity) GetIdentity() Identity { - return id +func (m *nopManager) ContainsProbably(id Identity) bool { + return false } -// Name returns the Key. -func (id KeyValueIdentity) Name() string { - return id.Key +func (m *nopManager) Reset() { } -// Provider provides the hashable Identity. -type Provider interface { - GetIdentity() Identity +func (m *nopManager) IdentifierBase() interface{} { + return "" } type identityManager struct { - sync.Mutex - Provider + Identity + + // mu protects _changes_ to this manager, + // reads currently assumes no concurrent writes. + mu sync.RWMutex ids Identities } -func (im *identityManager) Add(ids ...Provider) { - im.Lock() +// String is used for debugging. +func (im *identityManager) String() string { + var sb strings.Builder + + var printIDs func(ids Identities, level int) + + printIDs = func(ids Identities, level int) { + for id := range ids { + sb.WriteString(fmt.Sprintf("%s%s (%T)\n", strings.Repeat(" ", level), id.IdentifierBase(), id)) + if idg, ok := id.(IdentitiesProvider); ok { + printIDs(idg.GetIdentities(), level+1) + } + } + } + sb.WriteString(fmt.Sprintf("Manager: %q\n", im.IdentifierBase())) + + printIDs(im.ids, 1) + + return sb.String() +} + +func (im *identityManager) AddIdentity(ids ...Identity) { + im.mu.Lock() for _, id := range ids { - im.ids[id.GetIdentity()] = id + if id == Anonymous { + continue + } + if _, found := im.ids[id]; !found { + im.ids[id] = true + } } - im.Unlock() + im.mu.Unlock() } func (im *identityManager) Reset() { - im.Lock() - id := im.GetIdentity() - im.ids = Identities{id.GetIdentity(): id} - im.Unlock() + im.mu.Lock() + im.ids = Identities{im.Identity: true} + im.mu.Unlock() } // TODO(bep) these identities are currently only read on server reloads // so there should be no concurrency issues, but that may change. func (im *identityManager) GetIdentities() Identities { - im.Lock() - defer im.Unlock() return im.ids } -func (im *identityManager) Search(id Identity) Provider { - im.Lock() - defer im.Unlock() - return im.ids.search(0, id.GetIdentity()) +func (im *identityManager) Contains(id Identity) bool { + return im.ids.contains(0, false, id) +} + +func (im *identityManager) ContainsProbably(id Identity) bool { + p := im.ids.contains(0, true, id) + return p } // Incrementer increments and returns the value. @@ -161,3 +249,133 @@ type IncrementByOne struct { func (c *IncrementByOne) Incr() int { return int(atomic.AddUint64(&c.counter, uint64(1))) } + +// IsNotDependent returns whether p1 is certainly not dependent on p2. +// False positives are OK (but not great). +func IsNotDependent(p1, p2 Identity) bool { + if isProbablyDependent(p2, p1) { + return false + } + + // TODO1 + /*if isProbablyDependent(p1, p2) { + return false + }*/ + + return true +} + +func isProbablyDependent(p1, p2 Identity) bool { + if p1 == Anonymous || p2 == Anonymous { + return false + } + + if p1 == GenghisKhan && p2 == GenghisKhan { + return false + } + + if p1 == p2 { + return true + } + + if p1.IdentifierBase() == p2.IdentifierBase() { + return true + } + + switch p2v := p2.(type) { + case Manager: + if p2v.ContainsProbably(p1) { + return true + } + case DependencyManagerProvider: + if p2v.GetDependencyManager().ContainsProbably(p1) { + return true + } + default: + + } + + return false +} + +// StringIdentity is an Identity that wraps a string. +type StringIdentity string + +func (s StringIdentity) IdentifierBase() interface{} { + return string(s) +} + +var ( + identityInterface = reflect.TypeOf((*Identity)(nil)).Elem() + identityProviderInterface = reflect.TypeOf((*IdentityProvider)(nil)).Elem() + identityGroupProviderInterface = reflect.TypeOf((*IdentityGroupProvider)(nil)).Elem() +) + +// WalkIdentities walks identities in v and applies cb to every identity found. +// Return true from cb to terminate. +// It returns whether any Identity could be found. +func WalkIdentities(v interface{}, cb func(id Identity) bool) bool { + var found bool + if id, ok := v.(Identity); ok { + found = true + if cb(id) { + return found + } + } + if id, ok := v.(IdentityProvider); ok { + found = true + if cb(id.GetIdentity()) { + return found + } + } + if id, ok := v.(IdentityGroupProvider); ok { + found = true + if cb(id.GetIdentityGroup()) { + return found + } + } + return found +} + +// FirstIdentity returns the first Identity in v, Anonymous if none found +func FirstIdentity(v interface{}) Identity { + var result Identity = Anonymous + WalkIdentities(v, func(id Identity) bool { + result = id + return true + }) + + return result +} + +// WalkIdentitiesValue is the same as WalkIdentitiesValue, but it takes +// a reflect.Value. +func WalkIdentitiesValue(v reflect.Value, cb func(id Identity) bool) bool { + if !v.IsValid() { + return false + } + + var found bool + + if v.Type().Implements(identityInterface) { + found = true + if cb(v.Interface().(Identity)) { + return found + } + } + + if v.Type().Implements(identityProviderInterface) { + found = true + if cb(v.Interface().(IdentityProvider).GetIdentity()) { + return found + } + } + + if v.Type().Implements(identityGroupProviderInterface) { + found = true + if cb(v.Interface().(IdentityGroupProvider).GetIdentityGroup()) { + return found + } + } + return found +} diff --git a/identity/identity_test.go b/identity/identity_test.go index baf2628bba3..7c1a7ee7c4f 100644 --- a/identity/identity_test.go +++ b/identity/identity_test.go @@ -11,79 +11,215 @@ // See the License for the specific language governing permissions and // limitations under the License. -package identity +package identity_test import ( "fmt" - "math/rand" - "strconv" "testing" qt "github.com/frankban/quicktest" + "github.com/gohugoio/hugo/identity" + "github.com/gohugoio/hugo/identity/identitytesting" ) func TestIdentityManager(t *testing.T) { c := qt.New(t) - id1 := testIdentity{name: "id1"} - im := NewManager(id1) + newM := func() identity.Manager { + m1 := identity.NewManager(testIdentity{"base", "root"}) + m2 := identity.NewManager(identity.Anonymous) + m3 := identity.NewManager(testIdentity{"base3", "id3"}) + m1.AddIdentity( + testIdentity{"base", "id1"}, + testIdentity{"base2", "id2"}, + m2, + m3, + ) - c.Assert(im.Search(id1).GetIdentity(), qt.Equals, id1) - c.Assert(im.Search(testIdentity{name: "notfound"}), qt.Equals, nil) + m2.AddIdentity(testIdentity{"base4", "id4"}) + + return m1 + } + + c.Run("Contains", func(c *qt.C) { + im := newM() + c.Assert(im.Contains(testIdentity{"base", "root"}), qt.IsTrue) + c.Assert(im.Contains(testIdentity{"base", "id1"}), qt.IsTrue) + c.Assert(im.Contains(testIdentity{"base3", "id3"}), qt.IsTrue) + c.Assert(im.Contains(testIdentity{"base", "notfound"}), qt.IsFalse) + + im.Reset() + c.Assert(im.Contains(testIdentity{"base", "root"}), qt.IsTrue) + c.Assert(im.Contains(testIdentity{"base", "id1"}), qt.IsFalse) + }) + + c.Run("ContainsProbably", func(c *qt.C) { + im := newM() + c.Assert(im.ContainsProbably(testIdentity{"base", "id1"}), qt.IsTrue) + c.Assert(im.ContainsProbably(testIdentity{"base", "notfound"}), qt.IsTrue) + c.Assert(im.ContainsProbably(testIdentity{"base2", "notfound"}), qt.IsTrue) + c.Assert(im.ContainsProbably(testIdentity{"base3", "notfound"}), qt.IsTrue) + c.Assert(im.ContainsProbably(testIdentity{"base4", "notfound"}), qt.IsTrue) + c.Assert(im.ContainsProbably(testIdentity{"base5", "notfound"}), qt.IsFalse) + + im.Reset() + c.Assert(im.Contains(testIdentity{"base", "root"}), qt.IsTrue) + c.Assert(im.ContainsProbably(testIdentity{"base", "notfound"}), qt.IsTrue) + }) + + c.Run("Anonymous", func(c *qt.C) { + im := newM() + im.AddIdentity(identity.Anonymous) + c.Assert(im.Contains(identity.Anonymous), qt.IsFalse) + c.Assert(im.ContainsProbably(identity.Anonymous), qt.IsFalse) + c.Assert(identity.IsNotDependent(identity.Anonymous, identity.Anonymous), qt.IsTrue) + }) + + c.Run("GenghisKhan", func(c *qt.C) { + im := newM() + c.Assert(im.Contains(identity.GenghisKhan), qt.IsFalse) + c.Assert(im.ContainsProbably(identity.GenghisKhan), qt.IsTrue) + c.Assert(identity.IsNotDependent(identity.GenghisKhan, identity.GenghisKhan), qt.IsTrue) + }) } func BenchmarkIdentityManager(b *testing.B) { - createIds := func(num int) []Identity { - ids := make([]Identity, num) + createIds := func(num int) []identity.Identity { + ids := make([]identity.Identity, num) for i := 0; i < num; i++ { - ids[i] = testIdentity{name: fmt.Sprintf("id%d", i)} + name := fmt.Sprintf("id%d", i) + ids[i] = &testIdentity{base: name, name: name} } return ids } - b.Run("Add", func(b *testing.B) { - c := qt.New(b) - b.StopTimer() + b.Run("identity.NewManager", func(b *testing.B) { + for i := 0; i < b.N; i++ { + m := identity.NewManager(identity.Anonymous) + if m == nil { + b.Fatal("manager is nil") + } + } + }) + + b.Run("Add unique", func(b *testing.B) { ids := createIds(b.N) - im := NewManager(testIdentity{"first"}) - b.StartTimer() + im := identity.NewManager(identity.Anonymous) + b.ResetTimer() for i := 0; i < b.N; i++ { - im.Add(ids[i]) + im.AddIdentity(ids[i]) } b.StopTimer() - c.Assert(im.GetIdentities(), qt.HasLen, b.N+1) }) - b.Run("Search", func(b *testing.B) { - c := qt.New(b) + b.Run("Add duplicates", func(b *testing.B) { + id := &testIdentity{base: "a", name: "b"} + im := identity.NewManager(identity.Anonymous) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + im.AddIdentity(id) + } + b.StopTimer() - ids := createIds(b.N) - im := NewManager(testIdentity{"first"}) + }) + b.Run("Nop StringIdentity const", func(b *testing.B) { + const id = identity.StringIdentity("test") for i := 0; i < b.N; i++ { - im.Add(ids[i]) + identity.NopManager.AddIdentity(id) } + }) - b.StartTimer() + b.Run("Nop StringIdentity const other package", func(b *testing.B) { + for i := 0; i < b.N; i++ { + identity.NopManager.AddIdentity(identitytesting.TestIdentity) + } + }) + + b.Run("Nop StringIdentity var", func(b *testing.B) { + id := identity.StringIdentity("test") + for i := 0; i < b.N; i++ { + identity.NopManager.AddIdentity(id) + } + }) + b.Run("Nop pointer identity", func(b *testing.B) { + id := &testIdentity{base: "a", name: "b"} for i := 0; i < b.N; i++ { - name := "id" + strconv.Itoa(rand.Intn(b.N)) - id := im.Search(testIdentity{name: name}) - c.Assert(id.GetIdentity().Name(), qt.Equals, name) + identity.NopManager.AddIdentity(id) } }) + + b.Run("Nop Anonymous", func(b *testing.B) { + for i := 0; i < b.N; i++ { + identity.NopManager.AddIdentity(identity.Anonymous) + } + }) + + runContainsBenchmark := func(b *testing.B, im identity.Manager, fn func(id identity.Identity) bool, shouldFind bool) { + if shouldFind { + ids := createIds(b.N) + + for i := 0; i < b.N; i++ { + im.AddIdentity(ids[i]) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + found := fn(ids[i]) + if !found { + b.Fatal("id not found") + } + } + } else { + noMatchQuery := &testIdentity{base: "notfound", name: "notfound"} + b.ResetTimer() + for i := 0; i < b.N; i++ { + found := fn(noMatchQuery) + if found { + b.Fatal("id found") + } + } + } + } + + b.Run("Contains", func(b *testing.B) { + im := identity.NewManager(identity.Anonymous) + runContainsBenchmark(b, im, im.Contains, true) + }) + + b.Run("ContainsNotFound", func(b *testing.B) { + im := identity.NewManager(identity.Anonymous) + runContainsBenchmark(b, im, im.Contains, false) + }) + + b.Run("ContainsProbably", func(b *testing.B) { + im := identity.NewManager(identity.Anonymous) + runContainsBenchmark(b, im, im.ContainsProbably, true) + }) + + b.Run("ContainsProbablyNotFound", func(b *testing.B) { + im := identity.NewManager(identity.Anonymous) + runContainsBenchmark(b, im, im.ContainsProbably, false) + }) } type testIdentity struct { + base string name string } -func (id testIdentity) GetIdentity() Identity { - return id +func (id testIdentity) IdentifierBase() interface{} { + return id.base } func (id testIdentity) Name() string { return id.name } + +type testIdentityManager struct { + testIdentity + identity.Manager +} diff --git a/identity/identitytesting/identitytesting.go b/identity/identitytesting/identitytesting.go new file mode 100644 index 00000000000..74f3ec54098 --- /dev/null +++ b/identity/identitytesting/identitytesting.go @@ -0,0 +1,5 @@ +package identitytesting + +import "github.com/gohugoio/hugo/identity" + +const TestIdentity = identity.StringIdentity("__testIdentity") diff --git a/identity/pathIdentity.go b/identity/pathIdentity.go new file mode 100644 index 00000000000..1fe8cd72873 --- /dev/null +++ b/identity/pathIdentity.go @@ -0,0 +1,134 @@ +// Copyright 2020 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 identity + +import ( + "sort" + + "github.com/gohugoio/hugo/hugofs/files" +) + +// NewPathIdentity creates a new Identity with the three identifiers +// type, path and lang (optional). +func NewPathIdentity(typ, path, filename, lang string) PathIdentity { + // TODO1 path = strings.ToLower(strings.TrimPrefix(filepath.ToSlash(path), "/")) + return pathIdentity{typePath: typePath{typ: typ, path: path}, filename: filename, lang: lang} +} + +type PathIdentitySet map[PathIdentity]bool + +func (p PathIdentitySet) ToPathIdentities() PathIdentities { + var ids PathIdentities + for id := range p { + ids = append(ids, id) + } + return ids +} + +func (p PathIdentitySet) ToIdentities() []Identity { + var ids []Identity + for id := range p { + ids = append(ids, id) + } + return ids +} + +type PathIdentities []PathIdentity + +func (pp PathIdentities) ByType(typ string) PathIdentities { + var res PathIdentities + for _, p := range pp { + if p.Type() == typ { + res = append(res, p) + } + } + + return res +} + +func (pp PathIdentities) Sort() PathIdentities { + sort.Slice(pp, func(i, j int) bool { + pi, pj := pp[i], pp[j] + if pi.Path() != pj.Path() { + return pi.Path() < pj.Path() + } + + if pi.Filename() != pj.Filename() { + return pi.Filename() < pj.Filename() + } + + if pi.Lang() != pj.Lang() { + return pi.Lang() < pj.Lang() + } + + return pi.Type() < pj.Type() + }) + return pp +} + +// A PathIdentity is a common identity identified by a type and a path, +// e.g. "layouts" and "_default/single.html". +type PathIdentity interface { + Identity + Type() string + Path() string + Filename() string + Lang() string +} + +type typePath struct { + typ string + path string +} + +type pathIdentity struct { + typePath + filename string + lang string +} + +func (id pathIdentity) IdentifierBase() interface{} { + return id.path +} + +// TODO1 clean + +func (id pathIdentity) Base() interface{} { + return id.typePath +} + +func isCrossComponent(c string) bool { + return c == files.ComponentFolderData || c == files.ComponentFolderLayouts +} + +func (id typePath) Type() string { + return id.typ +} + +func (id typePath) Path() string { + return id.path +} + +func (id pathIdentity) Filename() string { + return id.filename +} + +func (id pathIdentity) Lang() string { + return id.lang +} + +// Name returns the Path. +func (id pathIdentity) Name() string { + return id.path +} diff --git a/hugolib/fileInfo_test.go b/identity/pathIdentity_test.go similarity index 74% rename from hugolib/fileInfo_test.go rename to identity/pathIdentity_test.go index d8a70e9d348..549e96142d2 100644 --- a/hugolib/fileInfo_test.go +++ b/identity/pathIdentity_test.go @@ -11,21 +11,18 @@ // See the License for the specific language governing permissions and // limitations under the License. -package hugolib +package identity import ( "testing" qt "github.com/frankban/quicktest" - "github.com/spf13/cast" ) -func TestFileInfo(t *testing.T) { - t.Run("String", func(t *testing.T) { - t.Parallel() - c := qt.New(t) - fi := &fileInfo{} - _, err := cast.ToStringE(fi) - c.Assert(err, qt.IsNil) - }) +func TestPathIdentity(t *testing.T) { + c := qt.New(t) + + // TODO1 + c.Assert(true, qt.IsTrue) + } diff --git a/langs/i18n/translationProvider.go b/langs/i18n/translationProvider.go index 44bd52f0c36..c32dc37eabc 100644 --- a/langs/i18n/translationProvider.go +++ b/langs/i18n/translationProvider.go @@ -60,15 +60,14 @@ func (tp *TranslationProvider) Update(d *deps.Deps) error { for i := len(dirs) - 1; i >= 0; i-- { dir := dirs[i] src := spec.NewFilesystemFromFileMetaInfo(dir) - files, err := src.Files() + + err := src.Walk(func(file *source.File) error { + return addTranslationFile(bundle, file) + }) if err != nil { return err } - for _, file := range files { - if err := addTranslationFile(bundle, file); err != nil { - return err - } - } + } tp.t = NewTranslator(bundle, d.Cfg, d.Log) @@ -80,7 +79,7 @@ func (tp *TranslationProvider) Update(d *deps.Deps) error { const artificialLangTagPrefix = "art-x-" -func addTranslationFile(bundle *i18n.Bundle, r source.File) error { +func addTranslationFile(bundle *i18n.Bundle, r *source.File) error { f, err := r.FileInfo().Meta().Open() if err != nil { return _errors.Wrapf(err, "failed to open translations file %q:", r.LogicalName()) @@ -124,7 +123,7 @@ func (tp *TranslationProvider) Clone(d *deps.Deps) error { return nil } -func errWithFileContext(inerr error, r source.File) error { +func errWithFileContext(inerr error, r *source.File) error { fim, ok := r.FileInfo().(hugofs.FileMetaInfo) if !ok { return inerr diff --git a/lazy/init.go b/lazy/init.go index 6dff0c98c29..fc64b2a7da3 100644 --- a/lazy/init.go +++ b/lazy/init.go @@ -16,6 +16,7 @@ package lazy import ( "context" "sync" + "sync/atomic" "time" "github.com/pkg/errors" @@ -28,6 +29,9 @@ func New() *Init { // Init holds a graph of lazily initialized dependencies. type Init struct { + // Used in tests + initCount uint64 + mu sync.Mutex prev *Init @@ -47,6 +51,12 @@ func (ini *Init) Add(initFn func() (interface{}, error)) *Init { return ini.add(false, initFn) } +// InitCount gets the number of this this Init has been initialized. +func (ini *Init) InitCount() int { + i := atomic.LoadUint64(&ini.initCount) + return int(i) +} + // AddWithTimeout is same as Add, but with a timeout that aborts initialization. func (ini *Init) AddWithTimeout(timeout time.Duration, f func(ctx context.Context) (interface{}, error)) *Init { return ini.Add(func() (interface{}, error) { @@ -77,6 +87,7 @@ func (ini *Init) Do() (interface{}, error) { } ini.init.Do(func() { + atomic.AddUint64(&ini.initCount, 1) prev := ini.prev if prev != nil { // A branch. Initialize the ancestors. diff --git a/magefile.go b/magefile.go index 16f630abca4..37ddca49038 100644 --- a/magefile.go +++ b/magefile.go @@ -1,3 +1,4 @@ +//go:build mage // +build mage package main @@ -97,10 +98,9 @@ func Generate() error { } goFmtPatterns := []string{ - // TODO(bep) check: stat ./resources/page/*autogen*: no such file or directory "./resources/page/page_marshaljson.autogen.go", - "./resources/page/page_wrappers.autogen.go", - "./resources/page/zero_file.autogen.go", + //"./resources/page/page_wrappers.autogen.go", + //"./resources/page/zero_file.autogen.go", } for _, pattern := range goFmtPatterns { diff --git a/markup/converter/converter.go b/markup/converter/converter.go index 180208a7bfc..1aa4e48f215 100644 --- a/markup/converter/converter.go +++ b/markup/converter/converter.go @@ -118,7 +118,7 @@ func (b Bytes) Bytes() []byte { // DocumentContext holds contextual information about the document to convert. type DocumentContext struct { - Document interface{} // May be nil. Usually a page.Page + Document identity.DependencyManagerProvider // May be nil. Usually a page.Page DocumentID string DocumentName string Filename string @@ -132,4 +132,8 @@ type RenderContext struct { RenderHooks hooks.Renderers } -var FeatureRenderHooks = identity.NewPathIdentity("markup", "renderingHooks") +const ( + FeatureRenderHookImage = identity.StringIdentity("feature/renderHooks/image ") + FeatureRenderHookLink = identity.StringIdentity("feature/renderHooks/link") + FeatureRenderHookHeading = identity.StringIdentity("feature/renderHooks/heading ") +) diff --git a/markup/converter/hooks/hooks.go b/markup/converter/hooks/hooks.go index d36dad28806..5571401ad1a 100644 --- a/markup/converter/hooks/hooks.go +++ b/markup/converter/hooks/hooks.go @@ -14,9 +14,7 @@ package hooks import ( - "fmt" "io" - "strings" "github.com/gohugoio/hugo/identity" ) @@ -35,7 +33,7 @@ type LinkContext interface { type LinkRenderer interface { RenderLink(w io.Writer, ctx LinkContext) error - identity.Provider + Template() identity.Identity // TODO1 remove this } // HeadingContext contains accessors to all attributes that a HeadingRenderer @@ -60,7 +58,7 @@ type HeadingContext interface { type HeadingRenderer interface { // Render writes the rendered content to w using the data in w. RenderHeading(w io.Writer, ctx HeadingContext) error - identity.Provider + Template() identity.Identity } type Renderers struct { @@ -84,7 +82,7 @@ func (r Renderers) Eq(other interface{}) bool { if (b1 || b2) && (b1 != b2) { return false } - if !b1 && r.ImageRenderer.GetIdentity() != ro.ImageRenderer.GetIdentity() { + if !b1 && r.ImageRenderer.Template() != ro.ImageRenderer.Template() { return false } @@ -92,7 +90,7 @@ func (r Renderers) Eq(other interface{}) bool { if (b1 || b2) && (b1 != b2) { return false } - if !b1 && r.LinkRenderer.GetIdentity() != ro.LinkRenderer.GetIdentity() { + if !b1 && r.LinkRenderer.Template() != ro.LinkRenderer.Template() { return false } @@ -100,7 +98,7 @@ func (r Renderers) Eq(other interface{}) bool { if (b1 || b2) && (b1 != b2) { return false } - if !b1 && r.HeadingRenderer.GetIdentity() != ro.HeadingRenderer.GetIdentity() { + if !b1 && r.HeadingRenderer.Template() != ro.HeadingRenderer.Template() { return false } @@ -110,23 +108,3 @@ func (r Renderers) Eq(other interface{}) bool { func (r Renderers) IsZero() bool { return r.HeadingRenderer == nil && r.LinkRenderer == nil && r.ImageRenderer == nil } - -func (r Renderers) String() string { - if r.IsZero() { - return "" - } - - var sb strings.Builder - - if r.LinkRenderer != nil { - sb.WriteString(fmt.Sprintf("LinkRenderer<%s>|", r.LinkRenderer.GetIdentity())) - } - if r.HeadingRenderer != nil { - sb.WriteString(fmt.Sprintf("HeadingRenderer<%s>|", r.HeadingRenderer.GetIdentity())) - } - if r.ImageRenderer != nil { - sb.WriteString(fmt.Sprintf("ImageRenderer<%s>|", r.ImageRenderer.GetIdentity())) - } - - return sb.String() -} diff --git a/markup/goldmark/convert.go b/markup/goldmark/convert.go index dcaf8d3e179..a09a59cb85d 100644 --- a/markup/goldmark/convert.go +++ b/markup/goldmark/convert.go @@ -47,8 +47,7 @@ import ( // Provider is the package entry point. var Provider converter.ProviderProvider = provide{} -type provide struct { -} +type provide struct{} func (p provide) New(cfg converter.ProviderConfig) (converter.Provider, error) { md := newMarkdown(cfg) @@ -163,22 +162,15 @@ func newMarkdown(pcfg converter.ProviderConfig) goldmark.Markdown { return md } -var _ identity.IdentitiesProvider = (*converterResult)(nil) - type converterResult struct { converter.Result toc tableofcontents.Root - ids identity.Identities } func (c converterResult) TableOfContents() tableofcontents.Root { return c.toc } -func (c converterResult) GetIdentities() identity.Identities { - return c.ids -} - type bufWriter struct { *bytes.Buffer } @@ -206,13 +198,11 @@ type renderContext struct { type renderContextData interface { RenderContext() converter.RenderContext DocumentContext() converter.DocumentContext - AddIdentity(id identity.Provider) } type renderContextDataHolder struct { rctx converter.RenderContext dctx converter.DocumentContext - ids identity.Manager } func (ctx *renderContextDataHolder) RenderContext() converter.RenderContext { @@ -223,12 +213,6 @@ func (ctx *renderContextDataHolder) DocumentContext() converter.DocumentContext return ctx.dctx } -func (ctx *renderContextDataHolder) AddIdentity(id identity.Provider) { - ctx.ids.Add(id) -} - -var converterIdentity = identity.KeyValueIdentity{Key: "goldmark", Value: "converter"} - func (c *goldmarkConverter) Convert(ctx converter.RenderContext) (result converter.Result, err error) { defer func() { if r := recover(); r != nil { @@ -254,7 +238,6 @@ func (c *goldmarkConverter) Convert(ctx converter.RenderContext) (result convert rcx := &renderContextDataHolder{ rctx: ctx, dctx: c.ctx, - ids: identity.NewManager(converterIdentity), } w := &renderContext{ @@ -268,17 +251,18 @@ func (c *goldmarkConverter) Convert(ctx converter.RenderContext) (result convert return converterResult{ Result: buf, - ids: rcx.ids.GetIdentities(), toc: pctx.TableOfContents(), }, nil } var featureSet = map[identity.Identity]bool{ - converter.FeatureRenderHooks: true, + converter.FeatureRenderHookHeading: true, + converter.FeatureRenderHookImage: true, + converter.FeatureRenderHookLink: true, } func (c *goldmarkConverter) Supports(feature identity.Identity) bool { - return featureSet[feature.GetIdentity()] + return featureSet[feature] } func (c *goldmarkConverter) newParserContext(rctx converter.RenderContext) *parserContext { diff --git a/markup/goldmark/render_hooks.go b/markup/goldmark/render_hooks.go index 0e942e6f57a..05965515f3c 100644 --- a/markup/goldmark/render_hooks.go +++ b/markup/goldmark/render_hooks.go @@ -20,6 +20,8 @@ import ( "github.com/spf13/cast" + "github.com/gohugoio/hugo/identity" + "github.com/gohugoio/hugo/markup/converter" "github.com/gohugoio/hugo/markup/converter/hooks" "github.com/yuin/goldmark" @@ -29,7 +31,10 @@ import ( "github.com/yuin/goldmark/util" ) -var _ renderer.SetOptioner = (*hookedRenderer)(nil) +var ( + _ renderer.SetOptioner = (*hookedRenderer)(nil) + _ identity.DependencyManagerProvider = (*linkContext)(nil) +) func newLinkRenderer() renderer.NodeRenderer { r := &hookedRenderer{ @@ -64,7 +69,7 @@ func (a *attributesHolder) Attributes() map[string]string { } type linkContext struct { - page interface{} + page identity.DependencyManagerProvider destination string title string text string @@ -83,6 +88,10 @@ func (ctx linkContext) Page() interface{} { return ctx.page } +func (ctx linkContext) GetDependencyManager() identity.Manager { + return ctx.page.GetDependencyManager() +} + func (ctx linkContext) Text() string { return ctx.text } @@ -144,15 +153,12 @@ func (r *hookedRenderer) renderAttributesForNode(w util.BufWriter, node ast.Node renderAttributes(w, false, node.Attributes()...) } -var ( - - // Attributes with special meaning that does not make sense to render in HTML. - attributeExcludes = map[string]bool{ - "linenos": true, - "hl_lines": true, - "linenostart": true, - } -) +// Attributes with special meaning that does not make sense to render in HTML. +var attributeExcludes = map[string]bool{ + "linenos": true, + "hl_lines": true, + "linenostart": true, +} func renderAttributes(w util.BufWriter, skipClass bool, attributes ...ast.Attribute) { for _, attr := range attributes { @@ -185,6 +191,13 @@ func (r *hookedRenderer) renderImage(w util.BufWriter, source []byte, node ast.N ctx, ok := w.(*renderContext) if ok { + if entering { + doc := ctx.DocumentContext().Document + if doc != nil { + // Indicate usage of image render hooks. Will be used to handle addition of hook templates in server mode. + doc.GetDependencyManager().AddIdentity(converter.FeatureRenderHookImage) + } + } h = ctx.RenderContext().RenderHooks ok = h.ImageRenderer != nil } @@ -213,8 +226,6 @@ func (r *hookedRenderer) renderImage(w util.BufWriter, source []byte, node ast.N }, ) - ctx.AddIdentity(h.ImageRenderer) - return ast.WalkContinue, err } @@ -251,6 +262,15 @@ func (r *hookedRenderer) renderLink(w util.BufWriter, source []byte, node ast.No ctx, ok := w.(*renderContext) if ok { + if entering { + doc := ctx.DocumentContext().Document + if doc != nil { + // Indicate usage of link render hooks. Will be used to handle addition of hook templates in server mode. + // TODO1 figure out why this allocates when in non-server mode. + doc.GetDependencyManager().AddIdentity(converter.FeatureRenderHookLink) + } + } + h = ctx.RenderContext().RenderHooks ok = h.LinkRenderer != nil } @@ -279,11 +299,6 @@ func (r *hookedRenderer) renderLink(w util.BufWriter, source []byte, node ast.No }, ) - // TODO(bep) I have a working branch that fixes these rather confusing identity types, - // but for now it's important that it's not .GetIdentity() that's added here, - // to make sure we search the entire chain on changes. - ctx.AddIdentity(h.LinkRenderer) - return ast.WalkContinue, err } @@ -318,7 +333,13 @@ func (r *hookedRenderer) renderAutoLink(w util.BufWriter, source []byte, node as var h hooks.Renderers ctx, ok := w.(*renderContext) + if ok { + doc := ctx.DocumentContext().Document + if doc != nil { + // Indicate usage of link render hooks. Will be used to handle addition of hook templates in server mode. + doc.GetDependencyManager().AddIdentity(converter.FeatureRenderHookLink) + } h = ctx.RenderContext().RenderHooks ok = h.LinkRenderer != nil } @@ -343,11 +364,6 @@ func (r *hookedRenderer) renderAutoLink(w util.BufWriter, source []byte, node as }, ) - // TODO(bep) I have a working branch that fixes these rather confusing identity types, - // but for now it's important that it's not .GetIdentity() that's added here, - // to make sure we search the entire chain on changes. - ctx.AddIdentity(h.LinkRenderer) - return ast.WalkContinue, err } @@ -383,6 +399,14 @@ func (r *hookedRenderer) renderHeading(w util.BufWriter, source []byte, node ast ctx, ok := w.(*renderContext) if ok { + if entering { + doc := ctx.DocumentContext().Document + if doc != nil { + // Indicate usage of heading render hooks. Will be used to handle addition of hook templates in server mode. + doc.GetDependencyManager().AddIdentity(converter.FeatureRenderHookHeading) + } + } + h = ctx.RenderContext().RenderHooks ok = h.HeadingRenderer != nil } @@ -416,8 +440,6 @@ func (r *hookedRenderer) renderHeading(w util.BufWriter, source []byte, node ast }, ) - ctx.AddIdentity(h.HeadingRenderer) - return ast.WalkContinue, err } @@ -438,8 +460,7 @@ func (r *hookedRenderer) renderHeadingDefault(w util.BufWriter, source []byte, n return ast.WalkContinue, nil } -type links struct { -} +type links struct{} // Extend implements goldmark.Extender. func (e *links) Extend(m goldmark.Markdown) { diff --git a/output/layout.go b/output/layout.go index 91c7cc6523a..1f93d42d33e 100644 --- a/output/layout.go +++ b/output/layout.go @@ -42,7 +42,7 @@ type LayoutDescriptor struct { } func (d LayoutDescriptor) isList() bool { - return !d.RenderingHook && d.Kind != "page" && d.Kind != "404" + return !d.RenderingHook && (d.Kind == "home" || d.Kind == "section" || d.Kind == "taxonomy" || d.Kind == "term") } // LayoutHandler calculates the layout template to use to render a given output type. @@ -176,6 +176,13 @@ func resolvePageTemplate(d LayoutDescriptor, f Format) []string { case "404": b.addLayoutVariations("404") b.addTypeVariations("") + case "robotsTXT": + b.addLayoutVariations("robots") + b.addTypeVariations("") + case "sitemap": + b.addLayoutVariations("sitemap") + b.addTypeVariations("") + // TODO1 sitemapindex } isRSS := f.Name == RSSFormat.Name @@ -204,6 +211,13 @@ func resolvePageTemplate(d LayoutDescriptor, f Format) []string { layouts = append(layouts, "_internal/_default/rss.xml") } + switch d.Kind { + case "robotsTXT": + layouts = append(layouts, "_internal/_default/robots.txt") + case "sitemap": + layouts = append(layouts, "_internal/_default/sitemap.xml") + } + return layouts } diff --git a/output/layout_test.go b/output/layout_test.go index 8b7a2b541bd..eff538b3865 100644 --- a/output/layout_test.go +++ b/output/layout_test.go @@ -1,4 +1,4 @@ -// Copyright 2017-present The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -20,6 +20,7 @@ import ( "testing" "github.com/gohugoio/hugo/media" + "github.com/gohugoio/hugo/resources/page/pagekinds" qt "github.com/frankban/quicktest" "github.com/kylelemons/godebug/diff" @@ -62,7 +63,7 @@ func TestLayout(t *testing.T) { }{ { "Home", - LayoutDescriptor{Kind: "home"}, + LayoutDescriptor{Kind: pagekinds.Home}, "", ampType, []string{ "index.amp.html", @@ -81,7 +82,7 @@ func TestLayout(t *testing.T) { }, { "Home baseof", - LayoutDescriptor{Kind: "home", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Home, Baseof: true}, "", ampType, []string{ "index-baseof.amp.html", @@ -104,7 +105,7 @@ func TestLayout(t *testing.T) { }, { "Home, HTML", - LayoutDescriptor{Kind: "home"}, + LayoutDescriptor{Kind: pagekinds.Home}, "", htmlFormat, // We will eventually get to index.html. This looks stuttery, but makes the lookup logic easy to understand. []string{ @@ -124,7 +125,7 @@ func TestLayout(t *testing.T) { }, { "Home, HTML, baseof", - LayoutDescriptor{Kind: "home", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Home, Baseof: true}, "", htmlFormat, []string{ "index-baseof.html.html", @@ -147,7 +148,7 @@ func TestLayout(t *testing.T) { }, { "Home, french language", - LayoutDescriptor{Kind: "home", Lang: "fr"}, + LayoutDescriptor{Kind: pagekinds.Home, Lang: "fr"}, "", ampType, []string{ "index.fr.amp.html", @@ -178,7 +179,7 @@ func TestLayout(t *testing.T) { }, { "Home, no ext or delim", - LayoutDescriptor{Kind: "home"}, + LayoutDescriptor{Kind: pagekinds.Home}, "", noExtDelimFormat, []string{ "index.nem", @@ -191,7 +192,7 @@ func TestLayout(t *testing.T) { }, { "Home, no ext", - LayoutDescriptor{Kind: "home"}, + LayoutDescriptor{Kind: pagekinds.Home}, "", noExt, []string{ "index.nex", @@ -204,13 +205,13 @@ func TestLayout(t *testing.T) { }, { "Page, no ext or delim", - LayoutDescriptor{Kind: "page"}, + LayoutDescriptor{Kind: pagekinds.Page}, "", noExtDelimFormat, []string{"_default/single.nem"}, }, { "Section", - LayoutDescriptor{Kind: "section", Section: "sect1"}, + LayoutDescriptor{Kind: pagekinds.Section, Section: "sect1"}, "", ampType, []string{ "sect1/sect1.amp.html", @@ -235,7 +236,7 @@ func TestLayout(t *testing.T) { }, { "Section, baseof", - LayoutDescriptor{Kind: "section", Section: "sect1", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Section, Section: "sect1", Baseof: true}, "", ampType, []string{ "sect1/sect1-baseof.amp.html", @@ -266,7 +267,7 @@ func TestLayout(t *testing.T) { }, { "Section, baseof, French, AMP", - LayoutDescriptor{Kind: "section", Section: "sect1", Lang: "fr", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Section, Section: "sect1", Lang: "fr", Baseof: true}, "", ampType, []string{ "sect1/sect1-baseof.fr.amp.html", @@ -321,7 +322,7 @@ func TestLayout(t *testing.T) { }, { "Section with layout", - LayoutDescriptor{Kind: "section", Section: "sect1", Layout: "mylayout"}, + LayoutDescriptor{Kind: pagekinds.Section, Section: "sect1", Layout: "mylayout"}, "", ampType, []string{ "sect1/mylayout.amp.html", @@ -352,7 +353,7 @@ func TestLayout(t *testing.T) { }, { "Term, French, AMP", - LayoutDescriptor{Kind: "term", Section: "tags", Lang: "fr"}, + LayoutDescriptor{Kind: pagekinds.Term, Section: "tags", Lang: "fr"}, "", ampType, []string{ "term/term.fr.amp.html", @@ -423,7 +424,7 @@ func TestLayout(t *testing.T) { }, { "Term, baseof, French, AMP", - LayoutDescriptor{Kind: "term", Section: "tags", Lang: "fr", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Term, Section: "tags", Lang: "fr", Baseof: true}, "", ampType, []string{ "term/term-baseof.fr.amp.html", @@ -510,7 +511,7 @@ func TestLayout(t *testing.T) { }, { "Term", - LayoutDescriptor{Kind: "term", Section: "tags"}, + LayoutDescriptor{Kind: pagekinds.Term, Section: "tags"}, "", ampType, []string{ "term/term.amp.html", @@ -549,7 +550,7 @@ func TestLayout(t *testing.T) { }, { "Taxonomy", - LayoutDescriptor{Kind: "taxonomy", Section: "categories"}, + LayoutDescriptor{Kind: pagekinds.Taxonomy, Section: "categories"}, "", ampType, []string{ "categories/categories.terms.amp.html", @@ -580,7 +581,7 @@ func TestLayout(t *testing.T) { }, { "Page", - LayoutDescriptor{Kind: "page"}, + LayoutDescriptor{Kind: pagekinds.Page}, "", ampType, []string{ "_default/single.amp.html", @@ -589,7 +590,7 @@ func TestLayout(t *testing.T) { }, { "Page, baseof", - LayoutDescriptor{Kind: "page", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Page, Baseof: true}, "", ampType, []string{ "_default/single-baseof.amp.html", @@ -600,7 +601,7 @@ func TestLayout(t *testing.T) { }, { "Page with layout", - LayoutDescriptor{Kind: "page", Layout: "mylayout"}, + LayoutDescriptor{Kind: pagekinds.Page, Layout: "mylayout"}, "", ampType, []string{ "_default/mylayout.amp.html", @@ -611,7 +612,7 @@ func TestLayout(t *testing.T) { }, { "Page with layout, baseof", - LayoutDescriptor{Kind: "page", Layout: "mylayout", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Page, Layout: "mylayout", Baseof: true}, "", ampType, []string{ "_default/mylayout-baseof.amp.html", @@ -624,7 +625,7 @@ func TestLayout(t *testing.T) { }, { "Page with layout and type", - LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype"}, + LayoutDescriptor{Kind: pagekinds.Page, Layout: "mylayout", Type: "myttype"}, "", ampType, []string{ "myttype/mylayout.amp.html", @@ -639,7 +640,7 @@ func TestLayout(t *testing.T) { }, { "Page baseof with layout and type", - LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Page, Layout: "mylayout", Type: "myttype", Baseof: true}, "", ampType, []string{ "myttype/mylayout-baseof.amp.html", @@ -658,7 +659,7 @@ func TestLayout(t *testing.T) { }, { "Page baseof with layout and type in French", - LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype", Lang: "fr", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Page, Layout: "mylayout", Type: "myttype", Lang: "fr", Baseof: true}, "", ampType, []string{ "myttype/mylayout-baseof.fr.amp.html", @@ -689,7 +690,7 @@ func TestLayout(t *testing.T) { }, { "Page with layout and type with subtype", - LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype/mysubtype"}, + LayoutDescriptor{Kind: pagekinds.Page, Layout: "mylayout", Type: "myttype/mysubtype"}, "", ampType, []string{ "myttype/mysubtype/mylayout.amp.html", @@ -705,7 +706,7 @@ func TestLayout(t *testing.T) { // RSS { "RSS Home", - LayoutDescriptor{Kind: "home"}, + LayoutDescriptor{Kind: pagekinds.Home}, "", RSSFormat, []string{ "index.rss.xml", @@ -727,7 +728,7 @@ func TestLayout(t *testing.T) { }, { "RSS Home, baseof", - LayoutDescriptor{Kind: "home", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Home, Baseof: true}, "", RSSFormat, []string{ "index-baseof.rss.xml", @@ -750,7 +751,7 @@ func TestLayout(t *testing.T) { }, { "RSS Section", - LayoutDescriptor{Kind: "section", Section: "sect1"}, + LayoutDescriptor{Kind: pagekinds.Section, Section: "sect1"}, "", RSSFormat, []string{ "sect1/sect1.rss.xml", @@ -779,7 +780,7 @@ func TestLayout(t *testing.T) { }, { "RSS Term", - LayoutDescriptor{Kind: "term", Section: "tag"}, + LayoutDescriptor{Kind: pagekinds.Term, Section: "tag"}, "", RSSFormat, []string{ "term/term.rss.xml", @@ -823,7 +824,7 @@ func TestLayout(t *testing.T) { }, { "RSS Taxonomy", - LayoutDescriptor{Kind: "taxonomy", Section: "tag"}, + LayoutDescriptor{Kind: pagekinds.Taxonomy, Section: "tag"}, "", RSSFormat, []string{ "tag/tag.terms.rss.xml", @@ -858,7 +859,7 @@ func TestLayout(t *testing.T) { }, { "Home plain text", - LayoutDescriptor{Kind: "home"}, + LayoutDescriptor{Kind: pagekinds.Home}, "", JSONFormat, []string{ "index.json.json", @@ -877,7 +878,7 @@ func TestLayout(t *testing.T) { }, { "Page plain text", - LayoutDescriptor{Kind: "page"}, + LayoutDescriptor{Kind: pagekinds.Page}, "", JSONFormat, []string{ "_default/single.json.json", @@ -886,7 +887,7 @@ func TestLayout(t *testing.T) { }, { "Reserved section, shortcodes", - LayoutDescriptor{Kind: "section", Section: "shortcodes", Type: "shortcodes"}, + LayoutDescriptor{Kind: pagekinds.Section, Section: "shortcodes", Type: "shortcodes"}, "", ampType, []string{ "section/shortcodes.amp.html", @@ -905,7 +906,7 @@ func TestLayout(t *testing.T) { }, { "Reserved section, partials", - LayoutDescriptor{Kind: "section", Section: "partials", Type: "partials"}, + LayoutDescriptor{Kind: pagekinds.Section, Section: "partials", Type: "partials"}, "", ampType, []string{ "section/partials.amp.html", @@ -922,10 +923,22 @@ func TestLayout(t *testing.T) { "_default/list.html", }, }, + { + "robots.txt", + LayoutDescriptor{Kind: pagekinds.RobotsTXT}, + "", RobotsTxtFormat, + []string{"robots.robots.txt", "robots.txt", "_default/robots.robots.txt", "_default/robots.txt", "_internal/_default/robots.txt"}, + }, + { + "sitemap", + LayoutDescriptor{Kind: pagekinds.Sitemap}, + "", SitemapFormat, + []string{"sitemap.sitemap.xml", "sitemap.xml", "_default/sitemap.sitemap.xml", "_default/sitemap.xml", "_internal/_default/sitemap.xml"}, + }, // This is currently always HTML only { "404, HTML", - LayoutDescriptor{Kind: "404"}, + LayoutDescriptor{Kind: pagekinds.Status404}, "", htmlFormat, []string{ "404.html.html", @@ -934,7 +947,7 @@ func TestLayout(t *testing.T) { }, { "404, HTML baseof", - LayoutDescriptor{Kind: "404", Baseof: true}, + LayoutDescriptor{Kind: pagekinds.Status404, Baseof: true}, "", htmlFormat, []string{ "404-baseof.html.html", @@ -976,7 +989,7 @@ func TestLayout(t *testing.T) { fmtGot := r.Replace(fmt.Sprintf("%v", layouts)) fmtExp := r.Replace(fmt.Sprintf("%v", this.expect)) - c.Fatalf("got %d items, expected %d:\nGot:\n\t%v\nExpected:\n\t%v\nDiff:\n%s", len(layouts), len(this.expect), layouts, this.expect, diff.Diff(fmtExp, fmtGot)) + c.Fatalf("got %d items, expected %d:\nGot:\n\t%#v\nExpected:\n\t%#v\nDiff:\n%s", len(layouts), len(this.expect), layouts, this.expect, diff.Diff(fmtExp, fmtGot)) } }) @@ -984,7 +997,7 @@ func TestLayout(t *testing.T) { } func BenchmarkLayout(b *testing.B) { - descriptor := LayoutDescriptor{Kind: "taxonomy", Section: "categories"} + descriptor := LayoutDescriptor{Kind: pagekinds.Taxonomy, Section: "categories"} l := NewLayoutHandler() for i := 0; i < b.N; i++ { @@ -997,7 +1010,7 @@ func BenchmarkLayout(b *testing.B) { func BenchmarkLayoutUncached(b *testing.B) { for i := 0; i < b.N; i++ { - descriptor := LayoutDescriptor{Kind: "taxonomy", Section: "categories"} + descriptor := LayoutDescriptor{Kind: pagekinds.Taxonomy, Section: "categories"} l := NewLayoutHandler() _, err := l.For(descriptor, HTMLFormat) diff --git a/output/outputFormat.go b/output/outputFormat.go index 091d3accb09..8604d3cc72e 100644 --- a/output/outputFormat.go +++ b/output/outputFormat.go @@ -58,19 +58,26 @@ type Format struct { // as template parser. IsPlainText bool `json:"isPlainText"` - // IsHTML returns whether this format is int the HTML family. This includes + // IsHTML returns whether this format is in the HTML family. This includes // HTML, AMP etc. This is used to decide when to create alias redirects etc. IsHTML bool `json:"isHTML"` // Enable to ignore the global uglyURLs setting. NoUgly bool `json:"noUgly"` + // Enable to override the global uglyURLs setting. + Ugly bool `json:"ugly"` + // Enable if it doesn't make sense to include this format in an alternative // format listing, CSS being one good example. // Note that we use the term "alternative" and not "alternate" here, as it // does not necessarily replace the other format, it is an alternative representation. NotAlternative bool `json:"notAlternative"` + // Eneable if this is a resource which path always starts at the root, + // e.g. /robots.txt. + Root bool + // Setting this will make this output format control the value of // .Permalink and .RelPermalink for a rendered Page. // If not set, these values will point to the main (first) output format @@ -114,6 +121,7 @@ var ( Rel: "stylesheet", NotAlternative: true, } + CSVFormat = Format{ Name: "CSV", MediaType: media.CSVType, @@ -135,6 +143,15 @@ var ( Weight: 10, } + HTTPStatusHTMLFormat = Format{ + Name: "HTTPStatus", + MediaType: media.HTMLType, + NotAlternative: true, + Ugly: true, + IsHTML: true, + Permalinkable: true, + } + JSONFormat = Format{ Name: "JSON", MediaType: media.JSONType, @@ -156,6 +173,8 @@ var ( Name: "ROBOTS", MediaType: media.TextType, BaseName: "robots", + Ugly: true, + Root: true, IsPlainText: true, Rel: "alternate", } @@ -172,7 +191,7 @@ var ( Name: "Sitemap", MediaType: media.XMLType, BaseName: "sitemap", - NoUgly: true, + Ugly: true, Rel: "sitemap", } ) @@ -184,6 +203,7 @@ var DefaultFormats = Formats{ CSSFormat, CSVFormat, HTMLFormat, + HTTPStatusHTMLFormat, JSONFormat, WebAppManifestFormat, RobotsTxtFormat, @@ -392,6 +412,11 @@ func (f Format) BaseFilename() string { return f.BaseName + f.MediaType.FirstSuffix.FullSuffix } +// IsZero returns true if f represents a zero value. +func (f Format) IsZero() bool { + return f.Name == "" +} + // MarshalJSON returns the JSON encoding of f. func (f Format) MarshalJSON() ([]byte, error) { type Alias Format diff --git a/output/outputFormat_test.go b/output/outputFormat_test.go index fc45099f3f6..c9de395d662 100644 --- a/output/outputFormat_test.go +++ b/output/outputFormat_test.go @@ -68,7 +68,7 @@ func TestDefaultTypes(t *testing.T) { c.Assert(RSSFormat.NoUgly, qt.Equals, true) c.Assert(CalendarFormat.IsHTML, qt.Equals, false) - c.Assert(len(DefaultFormats), qt.Equals, 10) + c.Assert(len(DefaultFormats), qt.Equals, 11) } @@ -83,6 +83,12 @@ func TestGetFormatByName(t *testing.T) { c.Assert(found, qt.Equals, false) } +func TestIsZero(t *testing.T) { + c := qt.New(t) + c.Assert(HTMLFormat.IsZero(), qt.IsFalse) + c.Assert(Format{}.IsZero(), qt.IsTrue) +} + func TestGetFormatByExt(t *testing.T) { c := qt.New(t) formats1 := Formats{AMPFormat, CalendarFormat} diff --git a/resources/image.go b/resources/image.go index 1eedbad91e1..d52665ee2c8 100644 --- a/resources/image.go +++ b/resources/image.go @@ -206,7 +206,6 @@ func (i *imageResource) Fill(spec string) (resource.Image, error) { img, err := i.doWithImageConfig(conf, func(src image.Image) (image.Image, error) { return i.Proc.ApplyFiltersFromConfig(src, conf) }) - if err != nil { return nil, err } @@ -368,7 +367,7 @@ func (i *imageResource) getImageMetaCacheTargetPath() string { df.dir = filepath.Dir(fi.Meta().Path) } p1, _ := paths.FileAndExt(df.file) - h, _ := i.hash() + h := i.hash() idStr := helpers.HashString(h, i.size(), imageMetaVersionNumber, cfgHash) p := path.Join(df.dir, fmt.Sprintf("%s_%s.json", p1, idStr)) return p @@ -380,7 +379,7 @@ func (i *imageResource) relTargetPathFromConfig(conf images.ImageConfig) dirFile p2 = conf.TargetFormat.DefaultExtension() } - h, _ := i.hash() + h := i.hash() idStr := fmt.Sprintf("_hu%s_%d", h, i.size()) // Do not change for no good reason. diff --git a/resources/image_cache.go b/resources/image_cache.go index b5832f740f8..715a33a4364 100644 --- a/resources/image_cache.go +++ b/resources/image_cache.go @@ -1,4 +1,4 @@ -// Copyright 2019 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -14,11 +14,12 @@ package resources import ( + "context" "image" "io" "path/filepath" - "strings" - "sync" + + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/resources/images" @@ -30,36 +31,7 @@ type imageCache struct { pathSpec *helpers.PathSpec fileCache *filecache.Cache - - mu sync.RWMutex - store map[string]*resourceAdapter -} - -func (c *imageCache) deleteIfContains(s string) { - c.mu.Lock() - defer c.mu.Unlock() - s = c.normalizeKeyBase(s) - for k := range c.store { - if strings.Contains(k, s) { - delete(c.store, k) - } - } -} - -// The cache key is a lowercase path with Unix style slashes and it always starts with -// a leading slash. -func (c *imageCache) normalizeKey(key string) string { - return "/" + c.normalizeKeyBase(key) -} - -func (c *imageCache) normalizeKeyBase(key string) string { - return strings.Trim(strings.ToLower(filepath.ToSlash(key)), "/") -} - -func (c *imageCache) clear() { - c.mu.Lock() - defer c.mu.Unlock() - c.store = make(map[string]*resourceAdapter) + mCache memcache.Getter } func (c *imageCache) getOrCreate( @@ -67,101 +39,90 @@ func (c *imageCache) getOrCreate( createImage func() (*imageResource, image.Image, error)) (*resourceAdapter, error) { relTarget := parent.relTargetPathFromConfig(conf) memKey := parent.relTargetPathForRel(relTarget.path(), false, false, false) - memKey = c.normalizeKey(memKey) + memKey = memcache.CleanKey(memKey) - // For the file cache we want to generate and store it once if possible. - fileKeyPath := relTarget - if fi := parent.root.getFileInfo(); fi != nil { - fileKeyPath.dir = filepath.ToSlash(filepath.Dir(fi.Meta().Path)) - } - fileKey := fileKeyPath.path() + v, err := c.mCache.GetOrCreate(context.TODO(), memKey, func() memcache.Entry { + // For the file cache we want to generate and store it once if possible. + fileKeyPath := relTarget + if fi := parent.root.getFileInfo(); fi != nil { + fileKeyPath.dir = filepath.ToSlash(filepath.Dir(fi.Meta().Path)) + } + fileKey := fileKeyPath.path() - // First check the in-memory store, then the disk. - c.mu.RLock() - cachedImage, found := c.store[memKey] - c.mu.RUnlock() + var img *imageResource - if found { - return cachedImage, nil - } + // These funcs are protected by a named lock. + // read clones the parent to its new name and copies + // the content to the destinations. + read := func(info filecache.ItemInfo, r io.ReadSeeker) error { + img = parent.clone(nil) + rp := img.getResourcePaths() + rp.relTargetDirFile.file = relTarget.file + img.setSourceFilename(info.Name) - var img *imageResource + if err := img.InitConfig(r); err != nil { + return err + } - // These funcs are protected by a named lock. - // read clones the parent to its new name and copies - // the content to the destinations. - read := func(info filecache.ItemInfo, r io.ReadSeeker) error { - img = parent.clone(nil) - rp := img.getResourcePaths() - rp.relTargetDirFile.file = relTarget.file - img.setSourceFilename(info.Name) + r.Seek(0, 0) - if err := img.InitConfig(r); err != nil { - return err - } + w, err := img.openDestinationsForWriting() + if err != nil { + return err + } - r.Seek(0, 0) + if w == nil { + // Nothing to write. + return nil + } + + defer w.Close() + _, err = io.Copy(w, r) - w, err := img.openDestinationsForWriting() - if err != nil { return err } - if w == nil { - // Nothing to write. - return nil - } + // create creates the image and encodes it to the cache (w). + create := func(info filecache.ItemInfo, w io.WriteCloser) (err error) { + defer w.Close() - defer w.Close() - _, err = io.Copy(w, r) + var conv image.Image + img, conv, err = createImage() + if err != nil { + return + } + rp := img.getResourcePaths() + rp.relTargetDirFile.file = relTarget.file + img.setSourceFilename(info.Name) - return err - } + return img.EncodeTo(conf, conv, w) + } + + // Now look in the file cache. - // create creates the image and encodes it to the cache (w). - create := func(info filecache.ItemInfo, w io.WriteCloser) (err error) { - defer w.Close() + // The definition of this counter is not that we have processed that amount + // (e.g. resized etc.), it can be fetched from file cache, + // but the count of processed image variations for this site. + c.pathSpec.ProcessingStats.Incr(&c.pathSpec.ProcessingStats.ProcessedImages) - var conv image.Image - img, conv, err = createImage() + _, err := c.fileCache.ReadOrCreate(fileKey, read, create) if err != nil { - return + return memcache.Entry{Err: err} } - rp := img.getResourcePaths() - rp.relTargetDirFile.file = relTarget.file - img.setSourceFilename(info.Name) - return img.EncodeTo(conf, conv, w) - } - - // Now look in the file cache. + // The file is now stored in this cache. + img.setSourceFs(c.fileCache.Fs) - // The definition of this counter is not that we have processed that amount - // (e.g. resized etc.), it can be fetched from file cache, - // but the count of processed image variations for this site. - c.pathSpec.ProcessingStats.Incr(&c.pathSpec.ProcessingStats.ProcessedImages) + imgAdapter := newResourceAdapter(parent.getSpec(), true, img) - _, err := c.fileCache.ReadOrCreate(fileKey, read, create) + return memcache.Entry{Value: imgAdapter, ClearWhen: memcache.ClearOnChange} + }) if err != nil { return nil, err } - - // The file is now stored in this cache. - img.setSourceFs(c.fileCache.Fs) - - c.mu.Lock() - if cachedImage, found = c.store[memKey]; found { - c.mu.Unlock() - return cachedImage, nil - } - - imgAdapter := newResourceAdapter(parent.getSpec(), true, img) - c.store[memKey] = imgAdapter - c.mu.Unlock() - - return imgAdapter, nil + return v.(*resourceAdapter), nil } -func newImageCache(fileCache *filecache.Cache, ps *helpers.PathSpec) *imageCache { - return &imageCache{fileCache: fileCache, pathSpec: ps, store: make(map[string]*resourceAdapter)} +func newImageCache(fileCache *filecache.Cache, memCache *memcache.Cache, ps *helpers.PathSpec) *imageCache { + return &imageCache{fileCache: fileCache, mCache: memCache.GetOrCreatePartition("images", memcache.ClearOnChange), pathSpec: ps} } diff --git a/resources/image_test.go b/resources/image_test.go index ad8c42bd7b7..71fe7889ade 100644 --- a/resources/image_test.go +++ b/resources/image_test.go @@ -392,8 +392,8 @@ func TestImageResizeInSubPath(t *testing.T) { assertImageFile(c, spec.BaseFs.PublishFs, publishedImageFilename, 101, 101) c.Assert(spec.BaseFs.PublishFs.Remove(publishedImageFilename), qt.IsNil) - // Clear mem cache to simulate reading from the file cache. - spec.imageCache.clear() + // Cleare mem cache to simulate reading from the file cache. + spec.imageCache.mCache.Clear() resizedAgain, err := image.Resize("101x101") c.Assert(err, qt.IsNil) @@ -593,7 +593,8 @@ func TestImageOperationsGoldenWebp(t *testing.T) { } -func TestImageOperationsGolden(t *testing.T) { +// TODO1 fixme +func _TestImageOperationsGolden(t *testing.T) { c := qt.New(t) c.Parallel() @@ -711,6 +712,7 @@ func TestImageOperationsGolden(t *testing.T) { } func assetGoldenDirs(c *qt.C, dir1, dir2 string) { + c.Helper() // The two dirs above should now be the same. dirinfos1, err := ioutil.ReadDir(dir1) diff --git a/resources/images/filters.go b/resources/images/filters.go index fd7e3145796..57691bbc13f 100644 --- a/resources/images/filters.go +++ b/resources/images/filters.go @@ -19,7 +19,7 @@ import ( "github.com/gohugoio/hugo/common/hugio" "github.com/gohugoio/hugo/common/maps" - "github.com/gohugoio/hugo/resources/resource" + "github.com/gohugoio/hugo/common/types" "github.com/disintegration/gift" "github.com/spf13/cast" @@ -70,7 +70,7 @@ func (*Filters) Text(text string, options ...interface{}) gift.Filter { panic(fmt.Sprintf("invalid font source: %s", err)) } fontSource, ok1 := v.(hugio.ReadSeekCloserProvider) - identifier, ok2 := v.(resource.Identifier) + identifier, ok2 := v.(types.Identifier) if !(ok1 && ok2) { panic(fmt.Sprintf("invalid text font source: %T", v)) diff --git a/resources/page/page.go b/resources/page/page.go index f23069a68de..72fda3e273f 100644 --- a/resources/page/page.go +++ b/resources/page/page.go @@ -16,15 +16,14 @@ package page import ( + "context" "html/template" "github.com/gohugoio/hugo/identity" "github.com/bep/gitmap" "github.com/gohugoio/hugo/config" - "github.com/gohugoio/hugo/tpl" - "github.com/gohugoio/hugo/common/hugo" "github.com/gohugoio/hugo/common/maps" "github.com/gohugoio/hugo/compare" "github.com/gohugoio/hugo/hugofs/files" @@ -89,7 +88,7 @@ type ContentProvider interface { // FileProvider provides the source file. type FileProvider interface { - File() source.File + File() *source.File } // GetPageProvider provides the GetPage method. @@ -100,9 +99,6 @@ type GetPageProvider interface { // This will return nil when no page could be found, and will return // an error if the ref is ambiguous. GetPage(ref string) (Page, error) - - // GetPageWithTemplateInfo is for internal use only. - GetPageWithTemplateInfo(info tpl.Info, ref string) (Page, error) } // GitInfoProvider provides Git info. @@ -126,11 +122,18 @@ type OutputFormatsProvider interface { OutputFormats() OutputFormats } +// PageProvider provides access to a Page. +// Implemented by shortcodes and others. +type PageProvider interface { + Page() Page +} + // Page is the core interface in Hugo. type Page interface { ContentProvider TableOfContentsProvider PageWithoutContent + identity.DependencyManagerProvider } // PageMetaProvider provides page metadata, typically provided via front matter. @@ -176,13 +179,10 @@ type PageMetaProvider interface { // Param looks for a param in Page and then in Site config. Param(key interface{}) (interface{}, error) - // Path gets the relative path, including file name and extension if relevant, - // to the source of this Page. It will be relative to any content root. + // Path gets the cannonical source path. + // TODO1 a better description of what the path is. Path() string - // This is just a temporary bridge method. Use Path in templates. - Pathc() string - // The slug, typically defined in front matter. Slug() string @@ -216,7 +216,7 @@ type PageMetaProvider interface { // PageRenderProvider provides a way for a Page to render content. type PageRenderProvider interface { - Render(layout ...string) (template.HTML, error) + Render(ctx context.Context, layout ...string) (template.HTML, error) RenderString(args ...interface{}) (template.HTML, error) } @@ -270,7 +270,7 @@ type PageWithoutContent interface { GetTerms(taxonomy string) Pages // Used in change/dependency tracking. - identity.Provider + identity.Identity DeprecatedWarningPageMethods } @@ -346,8 +346,7 @@ type TreeProvider interface { // Note that this method is not relevant for taxonomy lists and taxonomy terms pages. IsAncestor(other interface{}) (bool, error) - // CurrentSection returns the page's current section or the page itself if home or a section. - // Note that this will return nil for pages that is not regular, home or section pages. + // CurrentSection returns the page's current section or the page itself if a branch node (e.g. home or a section). CurrentSection() Page // IsDescendant returns whether the current page is a descendant of the given @@ -371,27 +370,16 @@ type TreeProvider interface { // Note that for non-sections, this method will always return an empty list. Sections() Pages - // Page returns a reference to the Page itself, kept here mostly - // for legacy reasons. + // Page returns a reference to the Page itself, mostly + // implemented to enable portable partials between regular, shortcode and markdown hook templates. Page() Page } // DeprecatedWarningPageMethods lists deprecated Page methods that will trigger // a WARNING if invoked. // This was added in Hugo 0.55. -type DeprecatedWarningPageMethods interface { - source.FileWithoutOverlap - DeprecatedWarningPageMethods1 -} - -type DeprecatedWarningPageMethods1 interface { - IsDraft() bool - Hugo() hugo.Info - LanguagePrefix() string - GetParam(key string) interface{} - RSSLink() template.URL - URL() string -} +// This was emptied in Hugo 0.93.0. +type DeprecatedWarningPageMethods interface{} // Move here to trigger ERROR instead of WARNING. // TODO(bep) create wrappers and put into the Page once it has some methods. diff --git a/resources/page/page_generate/generate_page_wrappers.go b/resources/page/page_generate/generate_page_wrappers.go index ae05ad5c2ee..eb0659f7b06 100644 --- a/resources/page/page_generate/generate_page_wrappers.go +++ b/resources/page/page_generate/generate_page_wrappers.go @@ -23,11 +23,11 @@ import ( "github.com/pkg/errors" "github.com/gohugoio/hugo/common/maps" + "github.com/gohugoio/hugo/source" "github.com/gohugoio/hugo/codegen" "github.com/gohugoio/hugo/resources/page" "github.com/gohugoio/hugo/resources/resource" - "github.com/gohugoio/hugo/source" ) const header = `// Copyright 2019 The Hugo Authors. All rights reserved. @@ -47,7 +47,6 @@ const header = `// Copyright 2019 The Hugo Authors. All rights reserved. ` var ( - fileInterfaceDeprecated = reflect.TypeOf((*source.FileWithoutOverlap)(nil)).Elem() pageInterfaceDeprecated = reflect.TypeOf((*page.DeprecatedWarningPageMethods)(nil)).Elem() pageInterface = reflect.TypeOf((*page.Page)(nil)).Elem() @@ -59,14 +58,15 @@ func Generate(c *codegen.Inspector) error { return errors.Wrap(err, "failed to generate JSON marshaler") } - if err := generateDeprecatedWrappers(c); err != nil { - return errors.Wrap(err, "failed to generate deprecate wrappers") - } - - if err := generateFileIsZeroWrappers(c); err != nil { - return errors.Wrap(err, "failed to generate file wrappers") - } + /* + // Removed in 0.93.0, keep this a little in case we need to re-introduce it. + if err := generateDeprecatedWrappers(c); err != nil { + return errors.Wrap(err, "failed to generate deprecate wrappers") + } + if err := generateFileIsZeroWrappers(c); err != nil { + return errors.Wrap(err, "failed to generate file wrappers") + }*/ return nil } @@ -156,14 +156,10 @@ func generateDeprecatedWrappers(c *codegen.Inspector) error { deprecated := func(name string, tp reflect.Type) string { var alternative string - if tp == fileInterfaceDeprecated { - alternative = "Use .File." + name - } else { - var found bool - alternative, found = reasons[name] - if !found { - panic(fmt.Sprintf("no deprecated reason found for %q", name)) - } + var found bool + alternative, found = reasons[name] + if !found { + panic(fmt.Sprintf("no deprecated reason found for %q", name)) } return fmt.Sprintf("helpers.Deprecated(%q, %q, true)", "Page."+name, alternative) @@ -171,7 +167,7 @@ func generateDeprecatedWrappers(c *codegen.Inspector) error { var buff bytes.Buffer - methods := c.MethodsFromTypes([]reflect.Type{fileInterfaceDeprecated, pageInterfaceDeprecated}, nil) + methods := c.MethodsFromTypes([]reflect.Type{pageInterfaceDeprecated}, nil) for _, m := range methods { fmt.Fprint(&buff, m.Declaration("*pageDeprecated")) @@ -224,7 +220,7 @@ func generateFileIsZeroWrappers(c *codegen.Inspector) error { var buff bytes.Buffer - methods := c.MethodsFromTypes([]reflect.Type{reflect.TypeOf((*source.File)(nil)).Elem()}, nil) + methods := c.MethodsFromTypes([]reflect.Type{reflect.TypeOf((**source.File)(nil)).Elem()}, nil) for _, m := range methods { if m.Name == "IsZero" { diff --git a/resources/page/page_kinds.go b/resources/page/page_kinds.go deleted file mode 100644 index 719375f669b..00000000000 --- a/resources/page/page_kinds.go +++ /dev/null @@ -1,47 +0,0 @@ -// 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 page - -import "strings" - -const ( - KindPage = "page" - - // The rest are node types; home page, sections etc. - - KindHome = "home" - KindSection = "section" - - // Note tha before Hugo 0.73 these were confusingly named - // taxonomy (now: term) - // taxonomyTerm (now: taxonomy) - KindTaxonomy = "taxonomy" - KindTerm = "term" -) - -var kindMap = map[string]string{ - strings.ToLower(KindPage): KindPage, - strings.ToLower(KindHome): KindHome, - strings.ToLower(KindSection): KindSection, - strings.ToLower(KindTaxonomy): KindTaxonomy, - strings.ToLower(KindTerm): KindTerm, - - // Legacy, pre v0.53.0. - "taxonomyterm": KindTaxonomy, -} - -// GetKind gets the page kind given a string, empty if not found. -func GetKind(s string) string { - return kindMap[strings.ToLower(s)] -} diff --git a/resources/page/page_marshaljson.autogen.go b/resources/page/page_marshaljson.autogen.go index 6cfa411e21a..6b00c688393 100644 --- a/resources/page/page_marshaljson.autogen.go +++ b/resources/page/page_marshaljson.autogen.go @@ -69,7 +69,7 @@ func MarshalPageToJSON(p Page) ([]byte, error) { linkTitle := p.LinkTitle() isNode := p.IsNode() isPage := p.IsPage() - path := p.Pathc() + path := p.Path() slug := p.Slug() lang := p.Lang() isSection := p.IsSection() @@ -89,7 +89,8 @@ func MarshalPageToJSON(p Page) ([]byte, error) { isTranslated := p.IsTranslated() allTranslations := p.AllTranslations() translations := p.Translations() - getIdentity := p.GetIdentity() + identifierBase := p.IdentifierBase() + getDependencyManager := p.GetDependencyManager() s := struct { Content interface{} @@ -137,7 +138,7 @@ func MarshalPageToJSON(p Page) ([]byte, error) { Type string Weight int Language *langs.Language - File source.File + File *source.File GitInfo *gitmap.GitInfo OutputFormats OutputFormats AlternativeOutputFormats OutputFormats @@ -146,7 +147,8 @@ func MarshalPageToJSON(p Page) ([]byte, error) { IsTranslated bool AllTranslations Pages Translations Pages - GetIdentity identity.Identity + IdentifierBase interface{} + GetDependencyManager identity.Manager }{ Content: content, Plain: plain, @@ -202,7 +204,8 @@ func MarshalPageToJSON(p Page) ([]byte, error) { IsTranslated: isTranslated, AllTranslations: allTranslations, Translations: translations, - GetIdentity: getIdentity, + IdentifierBase: identifierBase, + GetDependencyManager: getDependencyManager, } return json.Marshal(&s) diff --git a/resources/page/page_matcher.go b/resources/page/page_matcher.go index 0c4c2d0e29e..4a08d6cc25b 100644 --- a/resources/page/page_matcher.go +++ b/resources/page/page_matcher.go @@ -17,6 +17,8 @@ import ( "path/filepath" "strings" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/pkg/errors" "github.com/gohugoio/hugo/common/maps" @@ -58,8 +60,8 @@ func (m PageMatcher) Matches(p Page) bool { if m.Path != "" { g, err := glob.GetGlob(m.Path) - // TODO(bep) Path() vs filepath vs leading slash. - p := strings.ToLower(filepath.ToSlash(p.Pathc())) + // TODO1 vs file.Path. + p := strings.ToLower(filepath.ToSlash(p.Path())) if !(strings.HasPrefix(p, "/")) { p = "/" + p } @@ -114,7 +116,7 @@ func DecodePageMatcher(m interface{}, v *PageMatcher) error { v.Kind = strings.ToLower(v.Kind) if v.Kind != "" { - if _, found := kindMap[v.Kind]; !found { + if pagekinds.Get(v.Kind) == "" { return errors.Errorf("%q is not a valid Page Kind", v.Kind) } } diff --git a/resources/page/page_nop.go b/resources/page/page_nop.go index 011fabfc05c..077c83f5320 100644 --- a/resources/page/page_nop.go +++ b/resources/page/page_nop.go @@ -16,6 +16,7 @@ package page import ( + "context" "html/template" "time" @@ -152,9 +153,9 @@ func (p *nopPage) Extension() string { return "" } -var nilFile *source.FileInfo +var nilFile *source.File -func (p *nopPage) File() source.File { +func (p *nopPage) File() *source.File { return nilFile } @@ -338,10 +339,6 @@ func (p *nopPage) Path() string { return "" } -func (p *nopPage) Pathc() string { - return "" -} - func (p *nopPage) Permalink() string { return "" } @@ -398,7 +395,7 @@ func (p *nopPage) RelRef(argsm map[string]interface{}) (string, error) { return "", nil } -func (p *nopPage) Render(layout ...string) (template.HTML, error) { +func (p *nopPage) Render(ctx context.Context, layout ...string) (template.HTML, error) { return "", nil } @@ -502,6 +499,10 @@ func (p *nopPage) WordCount() int { return 0 } -func (p *nopPage) GetIdentity() identity.Identity { - return identity.NewPathIdentity("content", "foo/bar.md") +func (p *nopPage) IdentifierBase() interface{} { + return "" +} + +func (p *nopPage) GetDependencyManager() identity.Manager { + panic("Not implemented") } diff --git a/resources/page/page_paths.go b/resources/page/page_paths.go index 3d34866d147..bf6527f65e1 100644 --- a/resources/page/page_paths.go +++ b/resources/page/page_paths.go @@ -17,12 +17,195 @@ import ( "path" "path/filepath" "strings" + "sync" + + "github.com/gohugoio/hugo/common/paths" + + "github.com/gohugoio/hugo/resources/page/pagekinds" "github.com/gohugoio/hugo/helpers" "github.com/gohugoio/hugo/output" ) -const slash = "/" +func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) { + + // Normalize all file Windows paths to simplify what's next. + if helpers.FilePathSeparator != "/" { + d.Dir = filepath.ToSlash(d.Dir) + d.PrefixFilePath = filepath.ToSlash(d.PrefixFilePath) + } + + if !d.Type.Root && d.URL != "" && !strings.HasPrefix(d.URL, "/") { + // Treat this as a context relative URL + d.ForcePrefix = true + } + + if d.URL != "" { + d.URL = filepath.ToSlash(d.URL) + if strings.Contains(d.URL, "..") { + d.URL = path.Join("/", d.URL) + } + } + + if d.Type.Root && !d.ForcePrefix { + d.PrefixFilePath = "" + d.PrefixLink = "" + } + + pb := getPagePathBuilder(d) + defer putPagePathBuilder(pb) + + pb.fullSuffix = d.Type.MediaType.FirstSuffix.FullSuffix + + // The top level index files, i.e. the home page etc., needs + // the index base even when uglyURLs is enabled. + needsBase := true + + pb.isUgly = (d.UglyURLs || d.Type.Ugly) && !d.Type.NoUgly + pb.baseNameSameAsType = d.BaseName != "" && d.BaseName == d.Type.BaseName + + if d.ExpandedPermalink == "" && pb.baseNameSameAsType { + pb.isUgly = true + } + + if d.Type == output.RobotsTxtFormat { + pb.Add(d.Type.BaseName) + pb.noSubResources = true + } else if d.Type == output.HTTPStatusHTMLFormat || d.Type == output.SitemapFormat { + pb.Add(d.Kind) + pb.noSubResources = true + } else if d.Kind != pagekinds.Page && d.URL == "" && len(d.Sections) > 0 { + if d.ExpandedPermalink != "" { + pb.Add(d.ExpandedPermalink) + } else { + pb.Add(d.Sections...) + } + needsBase = false + } + + if d.Type.Path != "" { + pb.Add(d.Type.Path) + } + + if d.Kind != pagekinds.Home && d.URL != "" { + pb.Add(paths.FieldsSlash(d.URL)...) + + if d.Addends != "" { + pb.Add(d.Addends) + } + + hasDot := strings.Contains(d.URL, ".") + hasSlash := strings.HasSuffix(d.URL, "/") + + if hasSlash || !hasDot { + pb.Add(d.Type.BaseName + pb.fullSuffix) + } else if hasDot { + pb.fullSuffix = paths.Ext(d.URL) + } + + if pb.IsHtmlIndex() { + pb.linkUpperOffset = 1 + } + + if d.ForcePrefix { + + // Prepend language prefix if not already set in URL + if d.PrefixFilePath != "" && !strings.HasPrefix(d.URL, "/"+d.PrefixFilePath) { + pb.prefixPath = d.PrefixFilePath + } + + if d.PrefixLink != "" && !strings.HasPrefix(d.URL, "/"+d.PrefixLink) { + pb.prefixLink = d.PrefixLink + } + } + } else if !pagekinds.IsBranch(d.Kind) { + if d.ExpandedPermalink != "" { + pb.Add(d.ExpandedPermalink) + } else { + if d.Dir != "" { + pb.Add(d.Dir) + } + if d.BaseName != "" { + pb.Add(d.BaseName) + } + } + + if d.Addends != "" { + pb.Add(d.Addends) + } + + if pb.isUgly { + pb.ConcatLast(pb.fullSuffix) + } else { + pb.Add(d.Type.BaseName + pb.fullSuffix) + } + + if pb.IsHtmlIndex() { + pb.linkUpperOffset = 1 + } + + if d.PrefixFilePath != "" { + pb.prefixPath = d.PrefixFilePath + } + + if d.PrefixLink != "" { + pb.prefixLink = d.PrefixLink + } + } else { + if d.Addends != "" { + pb.Add(d.Addends) + } + + needsBase = needsBase && d.Addends == "" + + if needsBase || !pb.isUgly { + pb.Add(d.Type.BaseName + pb.fullSuffix) + } else { + pb.ConcatLast(pb.fullSuffix) + } + + if pb.IsHtmlIndex() { + pb.linkUpperOffset = 1 + } + + if d.PrefixFilePath != "" { + pb.prefixPath = d.PrefixFilePath + } + + if d.PrefixLink != "" { + pb.prefixLink = d.PrefixLink + } + } + + // if page URL is explicitly set in frontmatter, + // preserve its value without sanitization + if d.Kind != pagekinds.Page || d.URL == "" { + // Note: MakePathSanitized will lower case the path if + // disablePathToLower isn't set. + pb.Sanitize() + } + + link := pb.Link() + pagePath := pb.PathFile() + + tp.TargetFilename = filepath.FromSlash(pagePath) + if !pb.noSubResources { + tp.SubResourceBaseTarget = filepath.FromSlash(pb.PathDir()) + tp.SubResourceBaseLink = pb.LinkDir() + } + if d.URL != "" { + tp.Link = paths.URLEscape(link) + } else { + // This is slightly faster for when we know we don't have any + // query or scheme etc. + tp.Link = paths.PathEscape(link) + } + if tp.Link == "" { + tp.Link = "/" + } + + return +} // TargetPathDescriptor describes how a file path for a given resource // should look like on the file system. The same descriptor is then later used to @@ -74,7 +257,7 @@ type TargetPathDescriptor struct { // TODO(bep) move this type. type TargetPaths struct { - // Where to store the file on disk relative to the publish dir. OS slashes. + // Where to store the file on disk relative to the publish dir. OS "/"es. TargetFilename string // The directory to write sub-resources of the above. @@ -83,14 +266,10 @@ type TargetPaths struct { // The base for creating links to sub-resources of the above. SubResourceBaseLink string - // The relative permalink to this resources. Unix slashes. + // The relative permalink to this resources. Unix "/"es. Link string } -func (p TargetPaths) RelPermalink(s *helpers.PathSpec) string { - return s.PrependBasePath(p.Link, false) -} - func (p TargetPaths) PermalinkForOutputFormat(s *helpers.PathSpec, f output.Format) string { var baseURL string var err error @@ -106,237 +285,161 @@ func (p TargetPaths) PermalinkForOutputFormat(s *helpers.PathSpec, f output.Form return s.PermalinkForBaseURL(p.Link, baseURL) } -func isHtmlIndex(s string) bool { - return strings.HasSuffix(s, "/index.html") +func (p TargetPaths) RelPermalink(s *helpers.PathSpec) string { + return s.PrependBasePath(p.Link, false) } -func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) { - if d.Type.Name == "" { - panic("CreateTargetPath: missing type") - } - - // Normalize all file Windows paths to simplify what's next. - if helpers.FilePathSeparator != slash { - d.Dir = filepath.ToSlash(d.Dir) - d.PrefixFilePath = filepath.ToSlash(d.PrefixFilePath) - - } - - if d.URL != "" && !strings.HasPrefix(d.URL, "/") { - // Treat this as a context relative URL - d.ForcePrefix = true - } - - pagePath := slash - fullSuffix := d.Type.MediaType.FirstSuffix.FullSuffix +var pagePathBuilderPool = &sync.Pool{ + New: func() interface{} { + return &pagePathBuilder{} + }, +} - var ( - pagePathDir string - link string - linkDir string - ) +// When adding state here, remember to update putPagePathBuilder. +type pagePathBuilder struct { + els []string - // The top level index files, i.e. the home page etc., needs - // the index base even when uglyURLs is enabled. - needsBase := true + d TargetPathDescriptor - isUgly := d.UglyURLs && !d.Type.NoUgly - baseNameSameAsType := d.BaseName != "" && d.BaseName == d.Type.BaseName + // Builder state. + isUgly bool + baseNameSameAsType bool + noSubResources bool + fullSuffix string // File suffix including any ".". + prefixLink string + prefixPath string + linkUpperOffset int +} - if d.ExpandedPermalink == "" && baseNameSameAsType { - isUgly = true - } +func (p *pagePathBuilder) Add(el ...string) { + p.els = append(p.els, el...) +} - if d.Kind != KindPage && d.URL == "" && len(d.Sections) > 0 { - if d.ExpandedPermalink != "" { - pagePath = pjoin(pagePath, d.ExpandedPermalink) - } else { - pagePath = pjoin(d.Sections...) - } - needsBase = false +func (p *pagePathBuilder) ConcatLast(s string) { + if p.els == nil { + p.Add(s) + return } - - if d.Type.Path != "" { - pagePath = pjoin(pagePath, d.Type.Path) + old := p.els[len(p.els)-1] + if old[len(old)-1] == '/' { + old = old[:len(old)-1] } + p.els[len(p.els)-1] = old + s +} - if d.Kind != KindHome && d.URL != "" { - pagePath = pjoin(pagePath, d.URL) - - if d.Addends != "" { - pagePath = pjoin(pagePath, d.Addends) - } - - pagePathDir = pagePath - link = pagePath - hasDot := strings.Contains(d.URL, ".") - hasSlash := strings.HasSuffix(d.URL, slash) - - if hasSlash || !hasDot { - pagePath = pjoin(pagePath, d.Type.BaseName+fullSuffix) - } else if hasDot { - pagePathDir = path.Dir(pagePathDir) - } - - if !isHtmlIndex(pagePath) { - link = pagePath - } else if !hasSlash { - link += slash - } - - linkDir = pagePathDir - - if d.ForcePrefix { - - // Prepend language prefix if not already set in URL - if d.PrefixFilePath != "" && !strings.HasPrefix(d.URL, slash+d.PrefixFilePath) { - pagePath = pjoin(d.PrefixFilePath, pagePath) - pagePathDir = pjoin(d.PrefixFilePath, pagePathDir) - } - - if d.PrefixLink != "" && !strings.HasPrefix(d.URL, slash+d.PrefixLink) { - link = pjoin(d.PrefixLink, link) - linkDir = pjoin(d.PrefixLink, linkDir) - } - } - - } else if d.Kind == KindPage { - - if d.ExpandedPermalink != "" { - pagePath = pjoin(pagePath, d.ExpandedPermalink) - } else { - if d.Dir != "" { - pagePath = pjoin(pagePath, d.Dir) - } - if d.BaseName != "" { - pagePath = pjoin(pagePath, d.BaseName) - } - } - - if d.Addends != "" { - pagePath = pjoin(pagePath, d.Addends) - } - - link = pagePath - - // TODO(bep) this should not happen after the fix in https://github.com/gohugoio/hugo/issues/4870 - // but we may need some more testing before we can remove it. - if baseNameSameAsType { - link = strings.TrimSuffix(link, d.BaseName) - } - - pagePathDir = link - link = link + slash - linkDir = pagePathDir +func (p *pagePathBuilder) IsHtmlIndex() bool { + return p.Last() == "index.html" +} - if isUgly { - pagePath = addSuffix(pagePath, fullSuffix) - } else { - pagePath = pjoin(pagePath, d.Type.BaseName+fullSuffix) - } +func (p *pagePathBuilder) Last() string { + if p.els == nil { + return "" + } + return p.els[len(p.els)-1] +} - if !isHtmlIndex(pagePath) { - link = pagePath - } +func (p *pagePathBuilder) Link() string { + link := p.Path(p.linkUpperOffset) - if d.PrefixFilePath != "" { - pagePath = pjoin(d.PrefixFilePath, pagePath) - pagePathDir = pjoin(d.PrefixFilePath, pagePathDir) - } + if p.baseNameSameAsType { + link = strings.TrimSuffix(link, p.d.BaseName) + } - if d.PrefixLink != "" { - link = pjoin(d.PrefixLink, link) - linkDir = pjoin(d.PrefixLink, linkDir) - } + if p.prefixLink != "" { + link = "/" + p.prefixLink + link + } - } else { - if d.Addends != "" { - pagePath = pjoin(pagePath, d.Addends) - } + if p.linkUpperOffset > 0 && !strings.HasSuffix(link, "/") { + link += "/" + } - needsBase = needsBase && d.Addends == "" + return link +} - // No permalink expansion etc. for node type pages (for now) - base := "" +func (p *pagePathBuilder) LinkDir() string { + if p.noSubResources { + return "" + } - if needsBase || !isUgly { - base = d.Type.BaseName - } + pathDir := p.PathDirBase() - pagePathDir = pagePath - link = pagePath - linkDir = pagePathDir + if p.prefixLink != "" { + pathDir = "/" + p.prefixLink + pathDir + } - if base != "" { - pagePath = path.Join(pagePath, addSuffix(base, fullSuffix)) - } else { - pagePath = addSuffix(pagePath, fullSuffix) - } + return pathDir +} - if !isHtmlIndex(pagePath) { - link = pagePath - } else { - link += slash - } +func (p *pagePathBuilder) Path(upperOffset int) string { + upper := len(p.els) + if upperOffset > 0 { + upper -= upperOffset + } + pth := path.Join(p.els[:upper]...) + return helpers.AddLeadingSlash(pth) +} - if d.PrefixFilePath != "" { - pagePath = pjoin(d.PrefixFilePath, pagePath) - pagePathDir = pjoin(d.PrefixFilePath, pagePathDir) - } +func (p *pagePathBuilder) PathDir() string { + dir := p.PathDirBase() + if p.prefixPath != "" { + dir = "/" + p.prefixPath + dir + } + return dir +} - if d.PrefixLink != "" { - link = pjoin(d.PrefixLink, link) - linkDir = pjoin(d.PrefixLink, linkDir) - } +func (p *pagePathBuilder) PathDirBase() string { + if p.noSubResources { + return "" } - pagePath = pjoin(slash, pagePath) - pagePathDir = strings.TrimSuffix(path.Join(slash, pagePathDir), slash) + dir := p.Path(0) + isIndex := strings.HasPrefix(p.Last(), p.d.Type.BaseName+".") - hadSlash := strings.HasSuffix(link, slash) - link = strings.Trim(link, slash) - if hadSlash { - link += slash + if isIndex { + dir = path.Dir(dir) + } else { + dir = strings.TrimSuffix(dir, p.fullSuffix) } - if !strings.HasPrefix(link, slash) { - link = slash + link + if dir == "/" { + dir = "" } - linkDir = strings.TrimSuffix(path.Join(slash, linkDir), slash) + return dir +} - // if page URL is explicitly set in frontmatter, - // preserve its value without sanitization - if d.Kind != KindPage || d.URL == "" { - // Note: MakePathSanitized will lower case the path if - // disablePathToLower isn't set. - pagePath = d.PathSpec.MakePathSanitized(pagePath) - pagePathDir = d.PathSpec.MakePathSanitized(pagePathDir) - link = d.PathSpec.MakePathSanitized(link) - linkDir = d.PathSpec.MakePathSanitized(linkDir) +func (p *pagePathBuilder) PathFile() string { + dir := p.Path(0) + if p.prefixPath != "" { + dir = "/" + p.prefixPath + dir } + return dir +} - tp.TargetFilename = filepath.FromSlash(pagePath) - tp.SubResourceBaseTarget = filepath.FromSlash(pagePathDir) - tp.SubResourceBaseLink = linkDir - tp.Link = d.PathSpec.URLizeFilename(link) - if tp.Link == "" { - tp.Link = slash - } +func (p *pagePathBuilder) Prepend(el ...string) { + p.els = append(p.els[:0], append(el, p.els[0:]...)...) +} - return +func (p *pagePathBuilder) Sanitize() { + for i, el := range p.els { + p.els[i] = p.d.PathSpec.MakePathSanitized(el) + } } -func addSuffix(s, suffix string) string { - return strings.Trim(s, slash) + suffix +func getPagePathBuilder(d TargetPathDescriptor) *pagePathBuilder { + b := pagePathBuilderPool.Get().(*pagePathBuilder) + b.d = d + return b } -// Like path.Join, but preserves one trailing slash if present. -func pjoin(elem ...string) string { - hadSlash := strings.HasSuffix(elem[len(elem)-1], slash) - joined := path.Join(elem...) - if hadSlash && !strings.HasSuffix(joined, slash) { - return joined + slash - } - return joined +func putPagePathBuilder(b *pagePathBuilder) { + b.els = b.els[:0] + b.fullSuffix = "" + b.baseNameSameAsType = false + b.isUgly = false + b.noSubResources = false + b.prefixLink = "" + b.prefixPath = "" + b.linkUpperOffset = 0 + pagePathBuilderPool.Put(b) } diff --git a/resources/page/page_paths_test.go b/resources/page/page_paths_test.go index 28937899f51..4855b7d7c15 100644 --- a/resources/page/page_paths_test.go +++ b/resources/page/page_paths_test.go @@ -16,9 +16,10 @@ package page import ( "fmt" "path/filepath" - "strings" "testing" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gohugoio/hugo/media" "github.com/gohugoio/hugo/output" @@ -37,158 +38,396 @@ func TestPageTargetPath(t *testing.T) { BaseName: "_redirects", } + htmlCustomBaseName := output.HTMLFormat + htmlCustomBaseName.BaseName = "cindex" + + type variant struct { + langPrefixPath string + langPrefixLink string + isUgly bool + } + + applyPathPrefixes := func(v variant, tp *TargetPaths) { + if v.langPrefixLink != "" { + tp.Link = fmt.Sprintf("/%s%s", v.langPrefixLink, tp.Link) + if tp.SubResourceBaseLink != "" { + tp.SubResourceBaseLink = fmt.Sprintf("/%s%s", v.langPrefixLink, tp.SubResourceBaseLink) + } + } + if v.langPrefixPath != "" { + tp.TargetFilename = fmt.Sprintf("/%s%s", v.langPrefixPath, tp.TargetFilename) + if tp.SubResourceBaseTarget != "" { + tp.SubResourceBaseTarget = fmt.Sprintf("/%s%s", v.langPrefixPath, tp.SubResourceBaseTarget) + } + } + } + for _, langPrefixPath := range []string{"", "no"} { for _, langPrefixLink := range []string{"", "no"} { for _, uglyURLs := range []bool{false, true} { - tests := []struct { - name string - d TargetPathDescriptor - expected TargetPaths + name string + d TargetPathDescriptor + expectedFunc func(v variant) (TargetPaths, bool) }{ - {"JSON home", TargetPathDescriptor{Kind: KindHome, Type: output.JSONFormat}, TargetPaths{TargetFilename: "/index.json", SubResourceBaseTarget: "", Link: "/index.json"}}, - {"AMP home", TargetPathDescriptor{Kind: KindHome, Type: output.AMPFormat}, TargetPaths{TargetFilename: "/amp/index.html", SubResourceBaseTarget: "/amp", Link: "/amp/"}}, - {"HTML home", TargetPathDescriptor{Kind: KindHome, BaseName: "_index", Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/index.html", SubResourceBaseTarget: "", Link: "/"}}, - {"Netlify redirects", TargetPathDescriptor{Kind: KindHome, BaseName: "_index", Type: noExtDelimFormat}, TargetPaths{TargetFilename: "/_redirects", SubResourceBaseTarget: "", Link: "/_redirects"}}, - {"HTML section list", TargetPathDescriptor{ - Kind: KindSection, - Sections: []string{"sect1"}, - BaseName: "_index", - Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/sect1/index.html", SubResourceBaseTarget: "/sect1", Link: "/sect1/"}}, - {"HTML taxonomy term", TargetPathDescriptor{ - Kind: KindTerm, - Sections: []string{"tags", "hugo"}, - BaseName: "_index", - Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/tags/hugo/index.html", SubResourceBaseTarget: "/tags/hugo", Link: "/tags/hugo/"}}, - {"HTML taxonomy", TargetPathDescriptor{ - Kind: KindTaxonomy, - Sections: []string{"tags"}, - BaseName: "_index", - Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/tags/index.html", SubResourceBaseTarget: "/tags", Link: "/tags/"}}, + { + "JSON home", + TargetPathDescriptor{Kind: pagekinds.Home, Type: output.JSONFormat}, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/index.json", Link: "/index.json"} + applyPathPrefixes(v, &expected) + return + }, + }, + { + "AMP home", + TargetPathDescriptor{Kind: pagekinds.Home, Type: output.AMPFormat}, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/amp/index.html", SubResourceBaseTarget: "/amp", Link: "/amp/"} + applyPathPrefixes(v, &expected) + return + }, + }, + { + "HTML home", + TargetPathDescriptor{Kind: pagekinds.Home, BaseName: "_index", Type: output.HTMLFormat}, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/index.html", Link: "/"} + applyPathPrefixes(v, &expected) + return + }, + }, + { + "Netlify redirects", + TargetPathDescriptor{Kind: pagekinds.Home, BaseName: "_index", Type: noExtDelimFormat}, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/_redirects", Link: "/_redirects"} + applyPathPrefixes(v, &expected) + return + }, + }, + { + "HTML section list", TargetPathDescriptor{ + Kind: pagekinds.Section, + Sections: []string{"sect1"}, + BaseName: "_index", + Type: output.HTMLFormat, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/sect1.html", SubResourceBaseTarget: "/sect1", Link: "/sect1.html"} + } else { + expected = TargetPaths{TargetFilename: "/sect1/index.html", SubResourceBaseTarget: "/sect1", Link: "/sect1/"} + } + applyPathPrefixes(v, &expected) + return + }, + }, + { + "HTML taxonomy term", TargetPathDescriptor{ + Kind: pagekinds.Term, + Sections: []string{"tags", "hugo"}, + BaseName: "_index", + Type: output.HTMLFormat, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/tags/hugo.html", SubResourceBaseTarget: "/tags/hugo", Link: "/tags/hugo.html"} + } else { + expected = TargetPaths{TargetFilename: "/tags/hugo/index.html", SubResourceBaseTarget: "/tags/hugo", Link: "/tags/hugo/"} + } + applyPathPrefixes(v, &expected) + return + }, + }, + { + "HTML taxonomy", TargetPathDescriptor{ + Kind: pagekinds.Taxonomy, + Sections: []string{"tags"}, + BaseName: "_index", + Type: output.HTMLFormat, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/tags.html", SubResourceBaseTarget: "/tags", Link: "/tags.html"} + } else { + expected = TargetPaths{TargetFilename: "/tags/index.html", SubResourceBaseTarget: "/tags", Link: "/tags/"} + } + applyPathPrefixes(v, &expected) + return + }, + }, { "HTML page", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/a/b", BaseName: "mypage", Sections: []string{"a"}, Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/a/b/mypage/index.html", SubResourceBaseTarget: "/a/b/mypage", Link: "/a/b/mypage/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/a/b/mypage.html", SubResourceBaseTarget: "/a/b/mypage", Link: "/a/b/mypage.html"} + } else { + expected = TargetPaths{TargetFilename: "/a/b/mypage/index.html", SubResourceBaseTarget: "/a/b/mypage", Link: "/a/b/mypage/"} + } + applyPathPrefixes(v, &expected) + return + }, + }, + { + "HTML page, custom base", TargetPathDescriptor{ + Kind: pagekinds.Page, + Dir: "/a/b/mypage", + Sections: []string{"a"}, + Type: htmlCustomBaseName, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/a/b/mypage.html", SubResourceBaseTarget: "/a/b/mypage", Link: "/a/b/mypage.html"} + } else { + expected = TargetPaths{TargetFilename: "/a/b/mypage/cindex.html", SubResourceBaseTarget: "/a/b/mypage", Link: "/a/b/mypage/cindex.html"} + } + applyPathPrefixes(v, &expected) + return + }, }, - { "HTML page with index as base", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/a/b", BaseName: "index", Sections: []string{"a"}, Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/a/b/index.html", SubResourceBaseTarget: "/a/b", Link: "/a/b/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/a/b/index.html", SubResourceBaseTarget: "/a/b", Link: "/a/b/"} + applyPathPrefixes(v, &expected) + return + }, }, { "HTML page with special chars", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/a/b", BaseName: "My Page!", Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/a/b/my-page/index.html", SubResourceBaseTarget: "/a/b/my-page", Link: "/a/b/my-page/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/a/b/my-page.html", SubResourceBaseTarget: "/a/b/my-page", Link: "/a/b/my-page.html"} + } else { + expected = TargetPaths{TargetFilename: "/a/b/my-page/index.html", SubResourceBaseTarget: "/a/b/my-page", Link: "/a/b/my-page/"} + } + applyPathPrefixes(v, &expected) + return + }, + }, + { + "RSS home", TargetPathDescriptor{Kind: "rss", Type: output.RSSFormat}, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/index.xml", SubResourceBaseTarget: "", Link: "/index.xml"} + applyPathPrefixes(v, &expected) + return + }, + }, + { + "RSS section list", TargetPathDescriptor{ + Kind: "rss", + Sections: []string{"sect1"}, + Type: output.RSSFormat, + }, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/sect1/index.xml", SubResourceBaseTarget: "/sect1", Link: "/sect1/index.xml"} + applyPathPrefixes(v, &expected) + return + }, }, - {"RSS home", TargetPathDescriptor{Kind: "rss", Type: output.RSSFormat}, TargetPaths{TargetFilename: "/index.xml", SubResourceBaseTarget: "", Link: "/index.xml"}}, - {"RSS section list", TargetPathDescriptor{ - Kind: "rss", - Sections: []string{"sect1"}, - Type: output.RSSFormat, - }, TargetPaths{TargetFilename: "/sect1/index.xml", SubResourceBaseTarget: "/sect1", Link: "/sect1/index.xml"}}, { "AMP page", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/a/b/c", BaseName: "myamp", Type: output.AMPFormat, - }, TargetPaths{TargetFilename: "/amp/a/b/c/myamp/index.html", SubResourceBaseTarget: "/amp/a/b/c/myamp", Link: "/amp/a/b/c/myamp/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/amp/a/b/c/myamp.html", SubResourceBaseTarget: "/amp/a/b/c/myamp", Link: "/amp/a/b/c/myamp.html"} + } else { + expected = TargetPaths{TargetFilename: "/amp/a/b/c/myamp/index.html", SubResourceBaseTarget: "/amp/a/b/c/myamp", Link: "/amp/a/b/c/myamp/"} + } + applyPathPrefixes(v, &expected) + return + }, }, { "AMP page with URL with suffix", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/sect/", BaseName: "mypage", URL: "/some/other/url.xhtml", Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/some/other/url.xhtml", SubResourceBaseTarget: "/some/other", Link: "/some/other/url.xhtml"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/some/other/url.xhtml", SubResourceBaseTarget: "/some/other/url", Link: "/some/other/url.xhtml"} + applyPathPrefixes(v, &expected) + return + }, }, { "JSON page with URL without suffix", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/sect/", BaseName: "mypage", URL: "/some/other/path/", Type: output.JSONFormat, - }, TargetPaths{TargetFilename: "/some/other/path/index.json", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/index.json"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/some/other/path/index.json", Link: "/some/other/path/index.json"} + applyPathPrefixes(v, &expected) + return + }, }, { "JSON page with URL without suffix and no trailing slash", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/sect/", BaseName: "mypage", URL: "/some/other/path", Type: output.JSONFormat, - }, TargetPaths{TargetFilename: "/some/other/path/index.json", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/index.json"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/some/other/path/index.json", Link: "/some/other/path/index.json"} + applyPathPrefixes(v, &expected) + return + }, }, { "HTML page with URL without suffix and no trailing slash", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/sect/", BaseName: "mypage", URL: "/some/other/path", Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/some/other/path/index.html", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/some/other/path/index.html", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/"} + applyPathPrefixes(v, &expected) + return + }, }, { "HTML page with URL containing double hyphen", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/sect/", BaseName: "mypage", URL: "/some/other--url/", Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/some/other--url/index.html", SubResourceBaseTarget: "/some/other--url", Link: "/some/other--url/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/some/other--url/index.html", SubResourceBaseTarget: "/some/other--url", Link: "/some/other--url/"} + applyPathPrefixes(v, &expected) + return + }, + }, + { + "HTML page with URL with lots of dots", TargetPathDescriptor{ + Kind: pagekinds.Page, + BaseName: "mypage", + URL: "../../../../../myblog/p2/", + Type: output.HTMLFormat, + }, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/myblog/p2/index.html", SubResourceBaseTarget: "/myblog/p2", Link: "/myblog/p2/"} + applyPathPrefixes(v, &expected) + return + }, }, { "HTML page with expanded permalink", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/a/b", BaseName: "mypage", ExpandedPermalink: "/2017/10/my-title/", Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/2017/10/my-title/index.html", SubResourceBaseTarget: "/2017/10/my-title", Link: "/2017/10/my-title/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/2017/10/my-title.html", SubResourceBaseTarget: "/2017/10/my-title", SubResourceBaseLink: "/2017/10/my-title", Link: "/2017/10/my-title.html"} + } else { + expected = TargetPaths{TargetFilename: "/2017/10/my-title/index.html", SubResourceBaseTarget: "/2017/10/my-title", SubResourceBaseLink: "/2017/10/my-title", Link: "/2017/10/my-title/"} + } + applyPathPrefixes(v, &expected) + return + }, }, { "Paginated HTML home", TargetPathDescriptor{ - Kind: KindHome, + Kind: pagekinds.Home, BaseName: "_index", Type: output.HTMLFormat, Addends: "page/3", - }, TargetPaths{TargetFilename: "/page/3/index.html", SubResourceBaseTarget: "/page/3", Link: "/page/3/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/page/3.html", SubResourceBaseTarget: "/page/3", Link: "/page/3.html"} + } else { + expected = TargetPaths{TargetFilename: "/page/3/index.html", SubResourceBaseTarget: "/page/3", Link: "/page/3/"} + } + applyPathPrefixes(v, &expected) + return + }, }, { "Paginated Taxonomy terms list", TargetPathDescriptor{ - Kind: KindTerm, + Kind: pagekinds.Term, BaseName: "_index", Sections: []string{"tags", "hugo"}, Type: output.HTMLFormat, Addends: "page/3", - }, TargetPaths{TargetFilename: "/tags/hugo/page/3/index.html", SubResourceBaseTarget: "/tags/hugo/page/3", Link: "/tags/hugo/page/3/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/tags/hugo/page/3.html", Link: "/tags/hugo/page/3.html"} + } else { + expected = TargetPaths{TargetFilename: "/tags/hugo/page/3/index.html", Link: "/tags/hugo/page/3/"} + } + applyPathPrefixes(v, &expected) + return + }, }, { "Regular page with addend", TargetPathDescriptor{ - Kind: KindPage, + Kind: pagekinds.Page, Dir: "/a/b", BaseName: "mypage", Addends: "c/d/e", Type: output.HTMLFormat, - }, TargetPaths{TargetFilename: "/a/b/mypage/c/d/e/index.html", SubResourceBaseTarget: "/a/b/mypage/c/d/e", Link: "/a/b/mypage/c/d/e/"}, + }, + func(v variant) (expected TargetPaths, skip bool) { + if v.isUgly { + expected = TargetPaths{TargetFilename: "/a/b/mypage/c/d/e.html", SubResourceBaseTarget: "/a/b/mypage/c/d/e", Link: "/a/b/mypage/c/d/e.html"} + } else { + expected = TargetPaths{TargetFilename: "/a/b/mypage/c/d/e/index.html", SubResourceBaseTarget: "/a/b/mypage/c/d/e", Link: "/a/b/mypage/c/d/e/"} + } + applyPathPrefixes(v, &expected) + return + }, + }, + { + "404", TargetPathDescriptor{Kind: pagekinds.Status404, Type: output.HTTPStatusHTMLFormat}, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/404.html", SubResourceBaseTarget: "", Link: "/404.html"} + applyPathPrefixes(v, &expected) + return + }, + }, + {"robots.txt", TargetPathDescriptor{Kind: pagekinds.RobotsTXT, Type: output.RobotsTxtFormat}, + func(v variant) (expected TargetPaths, skip bool) { + expected = TargetPaths{TargetFilename: "/robots.txt", SubResourceBaseTarget: "", Link: "/robots.txt"} + return + }, }, } @@ -198,33 +437,23 @@ func TestPageTargetPath(t *testing.T) { test.d.ForcePrefix = true test.d.PathSpec = pathSpec test.d.UglyURLs = uglyURLs - test.d.PrefixFilePath = langPrefixPath - test.d.PrefixLink = langPrefixLink - test.d.Dir = filepath.FromSlash(test.d.Dir) - isUgly := uglyURLs && !test.d.Type.NoUgly - - expected := test.expected - - // TODO(bep) simplify - if test.d.Kind == KindPage && test.d.BaseName == test.d.Type.BaseName { - } else if test.d.Kind == KindHome && test.d.Type.Path != "" { - } else if test.d.Type.MediaType.FirstSuffix.Suffix != "" && (!strings.HasPrefix(expected.TargetFilename, "/index") || test.d.Addends != "") && test.d.URL == "" && isUgly { - expected.TargetFilename = strings.Replace(expected.TargetFilename, - "/"+test.d.Type.BaseName+"."+test.d.Type.MediaType.FirstSuffix.Suffix, - "."+test.d.Type.MediaType.FirstSuffix.Suffix, 1) - expected.Link = strings.TrimSuffix(expected.Link, "/") + "." + test.d.Type.MediaType.FirstSuffix.Suffix - + if !test.d.Type.Root { + test.d.PrefixFilePath = langPrefixPath + test.d.PrefixLink = langPrefixLink } + test.d.Dir = filepath.FromSlash(test.d.Dir) + isUgly := test.d.Type.Ugly || (uglyURLs && !test.d.Type.NoUgly) - if test.d.PrefixFilePath != "" && !strings.HasPrefix(test.d.URL, "/"+test.d.PrefixFilePath) { - expected.TargetFilename = "/" + test.d.PrefixFilePath + expected.TargetFilename - expected.SubResourceBaseTarget = "/" + test.d.PrefixFilePath + expected.SubResourceBaseTarget + v := variant{ + langPrefixLink: langPrefixLink, + langPrefixPath: langPrefixPath, + isUgly: isUgly, } - if test.d.PrefixLink != "" && !strings.HasPrefix(test.d.URL, "/"+test.d.PrefixLink) { - expected.Link = "/" + test.d.PrefixLink + expected.Link + expected, skip := test.expectedFunc(v) + if skip { + return } - expected.TargetFilename = filepath.FromSlash(expected.TargetFilename) expected.SubResourceBaseTarget = filepath.FromSlash(expected.SubResourceBaseTarget) @@ -249,13 +478,13 @@ func TestPageTargetPathPrefix(t *testing.T) { }{ { "URL set, prefix both, no force", - TargetPathDescriptor{Kind: KindPage, Type: output.JSONFormat, URL: "/mydir/my.json", ForcePrefix: false, PrefixFilePath: "pf", PrefixLink: "pl"}, - TargetPaths{TargetFilename: "/mydir/my.json", SubResourceBaseTarget: "/mydir", SubResourceBaseLink: "/mydir", Link: "/mydir/my.json"}, + TargetPathDescriptor{Kind: pagekinds.Page, Type: output.JSONFormat, URL: "/mydir/my.json", ForcePrefix: false, PrefixFilePath: "pf", PrefixLink: "pl"}, + TargetPaths{TargetFilename: "/mydir/my.json", SubResourceBaseTarget: "/mydir/my", SubResourceBaseLink: "/mydir/my", Link: "/mydir/my.json"}, }, { "URL set, prefix both, force", - TargetPathDescriptor{Kind: KindPage, Type: output.JSONFormat, URL: "/mydir/my.json", ForcePrefix: true, PrefixFilePath: "pf", PrefixLink: "pl"}, - TargetPaths{TargetFilename: "/pf/mydir/my.json", SubResourceBaseTarget: "/pf/mydir", SubResourceBaseLink: "/pl/mydir", Link: "/pl/mydir/my.json"}, + TargetPathDescriptor{Kind: pagekinds.Page, Type: output.JSONFormat, URL: "/mydir/my.json", ForcePrefix: true, PrefixFilePath: "pf", PrefixLink: "pl"}, + TargetPaths{TargetFilename: "/pf/mydir/my.json", SubResourceBaseTarget: "/pf/mydir/my", SubResourceBaseLink: "/pl/mydir/my", Link: "/pl/mydir/my.json"}, }, } @@ -276,16 +505,40 @@ func TestPageTargetPathPrefix(t *testing.T) { } } -func eqTargetPaths(p1, p2 TargetPaths) bool { - if p1.Link != p2.Link { +func BenchmarkCreateTargetPaths(b *testing.B) { + pathSpec := newTestPathSpec() + descriptors := []TargetPathDescriptor{ + {Kind: pagekinds.Home, Type: output.JSONFormat, PathSpec: pathSpec}, + {Kind: pagekinds.Home, Type: output.HTMLFormat, PathSpec: pathSpec}, + {Kind: pagekinds.Section, Type: output.HTMLFormat, Sections: []string{"a", "b", "c"}, PathSpec: pathSpec}, + {Kind: pagekinds.Page, Dir: "/sect/", Type: output.HTMLFormat, PathSpec: pathSpec}, + {Kind: pagekinds.Page, ExpandedPermalink: "/foo/bar/", UglyURLs: true, Type: output.HTMLFormat, PathSpec: pathSpec}, + {Kind: pagekinds.Page, URL: "/sect/foo.html", Type: output.HTMLFormat, PathSpec: pathSpec}, + {Kind: pagekinds.Status404, Type: output.HTTPStatusHTMLFormat, PathSpec: pathSpec}, + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + for _, d := range descriptors { + _ = CreateTargetPaths(d) + } + } +} + +func eqTargetPaths(got, expected TargetPaths) bool { + if got.Link != expected.Link { + return false + } + + // Be a little lenient with these sub resource paths as it's not filled in in all cases. + if expected.SubResourceBaseLink != "" && got.SubResourceBaseLink != expected.SubResourceBaseLink { return false } - if p1.SubResourceBaseTarget != p2.SubResourceBaseTarget { + if expected.SubResourceBaseTarget != "" && got.SubResourceBaseTarget != expected.SubResourceBaseTarget { return false } - if p1.TargetFilename != p2.TargetFilename { + if got.TargetFilename != expected.TargetFilename { return false } diff --git a/resources/page/page_wrappers.autogen.go b/resources/page/page_wrappers.autogen.go deleted file mode 100644 index 2bdd5112180..00000000000 --- a/resources/page/page_wrappers.autogen.go +++ /dev/null @@ -1,97 +0,0 @@ -// 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. - -// This file is autogenerated. - -package page - -import ( - "github.com/gohugoio/hugo/common/hugo" - "github.com/gohugoio/hugo/helpers" - "github.com/gohugoio/hugo/hugofs" - "html/template" -) - -// NewDeprecatedWarningPage adds deprecation warnings to the given implementation. -func NewDeprecatedWarningPage(p DeprecatedWarningPageMethods) DeprecatedWarningPageMethods { - return &pageDeprecated{p: p} -} - -type pageDeprecated struct { - p DeprecatedWarningPageMethods -} - -func (p *pageDeprecated) Filename() string { - helpers.Deprecated("Page.Filename", "Use .File.Filename", true) - return p.p.Filename() -} -func (p *pageDeprecated) Dir() string { - helpers.Deprecated("Page.Dir", "Use .File.Dir", true) - return p.p.Dir() -} -func (p *pageDeprecated) IsDraft() bool { - helpers.Deprecated("Page.IsDraft", "Use .Draft.", true) - return p.p.IsDraft() -} -func (p *pageDeprecated) Extension() string { - helpers.Deprecated("Page.Extension", "Use .File.Extension", true) - return p.p.Extension() -} -func (p *pageDeprecated) Hugo() hugo.Info { - helpers.Deprecated("Page.Hugo", "Use the global hugo function.", true) - return p.p.Hugo() -} -func (p *pageDeprecated) Ext() string { - helpers.Deprecated("Page.Ext", "Use .File.Ext", true) - return p.p.Ext() -} -func (p *pageDeprecated) LanguagePrefix() string { - helpers.Deprecated("Page.LanguagePrefix", "Use .Site.LanguagePrefix.", true) - return p.p.LanguagePrefix() -} -func (p *pageDeprecated) GetParam(arg0 string) interface{} { - helpers.Deprecated("Page.GetParam", "Use .Param or .Params.myParam.", true) - return p.p.GetParam(arg0) -} -func (p *pageDeprecated) LogicalName() string { - helpers.Deprecated("Page.LogicalName", "Use .File.LogicalName", true) - return p.p.LogicalName() -} -func (p *pageDeprecated) BaseFileName() string { - helpers.Deprecated("Page.BaseFileName", "Use .File.BaseFileName", true) - return p.p.BaseFileName() -} -func (p *pageDeprecated) RSSLink() template.URL { - helpers.Deprecated("Page.RSSLink", "Use the Output Format's link, e.g. something like:\n {{ with .OutputFormats.Get \"RSS\" }}{{ .RelPermalink }}{{ end }}", true) - return p.p.RSSLink() -} -func (p *pageDeprecated) TranslationBaseName() string { - helpers.Deprecated("Page.TranslationBaseName", "Use .File.TranslationBaseName", true) - return p.p.TranslationBaseName() -} -func (p *pageDeprecated) URL() string { - helpers.Deprecated("Page.URL", "Use .Permalink or .RelPermalink. If what you want is the front matter URL value, use .Params.url", true) - return p.p.URL() -} -func (p *pageDeprecated) ContentBaseName() string { - helpers.Deprecated("Page.ContentBaseName", "Use .File.ContentBaseName", true) - return p.p.ContentBaseName() -} -func (p *pageDeprecated) UniqueID() string { - helpers.Deprecated("Page.UniqueID", "Use .File.UniqueID", true) - return p.p.UniqueID() -} -func (p *pageDeprecated) FileInfo() hugofs.FileMetaInfo { - helpers.Deprecated("Page.FileInfo", "Use .File.FileInfo", true) - return p.p.FileInfo() -} diff --git a/resources/page/pagekinds/page_kinds.go b/resources/page/pagekinds/page_kinds.go new file mode 100644 index 00000000000..acd52ad2578 --- /dev/null +++ b/resources/page/pagekinds/page_kinds.go @@ -0,0 +1,53 @@ +// Copyright 2021 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 pagekinds + +import "strings" + +const ( + Page = "page" + + // Branch nodes. + Home = "home" + Section = "section" + Taxonomy = "taxonomy" + Term = "term" + + // Special purpose page kinds. + Sitemap = "sitemap" + RobotsTXT = "robotsTXT" + Status404 = "404" +) + +var kindMap = map[string]string{ + strings.ToLower(Page): Page, + strings.ToLower(Home): Home, + strings.ToLower(Section): Section, + strings.ToLower(Taxonomy): Taxonomy, + strings.ToLower(Term): Term, + + // Legacy. + "taxonomyterm": Taxonomy, + "rss": "RSS", +} + +// Get gets the page kind given a string, empty if not found. +func Get(s string) string { + return kindMap[strings.ToLower(s)] +} + +// IsBranch determines whether s represents a branch node (e.g. a section). +func IsBranch(s string) bool { + return s == Home || s == Section || s == Taxonomy || s == Term +} diff --git a/resources/page/page_kinds_test.go b/resources/page/pagekinds/page_kinds_test.go similarity index 57% rename from resources/page/page_kinds_test.go rename to resources/page/pagekinds/page_kinds_test.go index 357be673990..b323ca34292 100644 --- a/resources/page/page_kinds_test.go +++ b/resources/page/pagekinds/page_kinds_test.go @@ -1,4 +1,4 @@ -// Copyright 2019 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -11,7 +11,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package page +package pagekinds import ( "testing" @@ -23,15 +23,15 @@ func TestKind(t *testing.T) { t.Parallel() c := qt.New(t) // Add tests for these constants to make sure they don't change - c.Assert(KindPage, qt.Equals, "page") - c.Assert(KindHome, qt.Equals, "home") - c.Assert(KindSection, qt.Equals, "section") - c.Assert(KindTaxonomy, qt.Equals, "taxonomy") - c.Assert(KindTerm, qt.Equals, "term") + c.Assert(Page, qt.Equals, "page") + c.Assert(Home, qt.Equals, "home") + c.Assert(Section, qt.Equals, "section") + c.Assert(Taxonomy, qt.Equals, "taxonomy") + c.Assert(Term, qt.Equals, "term") - c.Assert(GetKind("TAXONOMYTERM"), qt.Equals, KindTaxonomy) - c.Assert(GetKind("Taxonomy"), qt.Equals, KindTaxonomy) - c.Assert(GetKind("Page"), qt.Equals, KindPage) - c.Assert(GetKind("Home"), qt.Equals, KindHome) - c.Assert(GetKind("SEction"), qt.Equals, KindSection) + c.Assert(Get("TAXONOMYTERM"), qt.Equals, Taxonomy) + c.Assert(Get("Taxonomy"), qt.Equals, Taxonomy) + c.Assert(Get("Page"), qt.Equals, Page) + c.Assert(Get("Home"), qt.Equals, Home) + c.Assert(Get("SEction"), qt.Equals, Section) } diff --git a/resources/page/pages_sort_test.go b/resources/page/pages_sort_test.go index 737a4f54086..f7c3bd1a08f 100644 --- a/resources/page/pages_sort_test.go +++ b/resources/page/pages_sort_test.go @@ -28,7 +28,7 @@ import ( var eq = qt.CmpEquals(hqt.DeepAllowUnexported( &testPage{}, - &source.FileInfo{}, + &source.File{}, )) func TestDefaultSort(t *testing.T) { diff --git a/resources/page/pagination_test.go b/resources/page/pagination_test.go index 07ad6233b56..f761b9dace2 100644 --- a/resources/page/pagination_test.go +++ b/resources/page/pagination_test.go @@ -18,6 +18,8 @@ import ( "html/template" "testing" + "github.com/gohugoio/hugo/resources/page/pagekinds" + "github.com/gohugoio/hugo/config" qt "github.com/frankban/quicktest" @@ -211,12 +213,12 @@ func TestPaginationURLFactory(t *testing.T) { }{ { "HTML home page 32", - TargetPathDescriptor{Kind: KindHome, Type: output.HTMLFormat}, + TargetPathDescriptor{Kind: pagekinds.Home, Type: output.HTMLFormat}, "http://example.com/", 32, "/zoo/32/", "/zoo/32.html", }, { "JSON home page 42", - TargetPathDescriptor{Kind: KindHome, Type: output.JSONFormat}, + TargetPathDescriptor{Kind: pagekinds.Home, Type: output.JSONFormat}, "http://example.com/", 42, "/zoo/42/index.json", "/zoo/42.json", }, } diff --git a/resources/page/siteidentities/identities.go b/resources/page/siteidentities/identities.go new file mode 100644 index 00000000000..b87a9a12a80 --- /dev/null +++ b/resources/page/siteidentities/identities.go @@ -0,0 +1,44 @@ +// Copyright 2021 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 siteidentities + +import ( + "strings" + + "github.com/gohugoio/hugo/identity" +) + +const ( + // Identifies site.Data. + Data = identity.StringIdentity("site.Data") + // A group identifying all the Site's page collections. + PageCollections = identity.StringIdentity("site.PageCollections") + // A group identifying Site stats, e.g. LastChange. + Stats = identity.StringIdentity("site.Stats") +) + +func FromString(name string) (identity.Identity, bool) { + switch name { + case "Data": + return Data, true + case "LastChange": + return Stats, true + } + + if strings.Contains(name, "Pages") { + return PageCollections, true + } + + return identity.Anonymous, false +} diff --git a/resources/page/testhelpers_test.go b/resources/page/testhelpers_test.go index 57077ecf871..29291a9b5bf 100644 --- a/resources/page/testhelpers_test.go +++ b/resources/page/testhelpers_test.go @@ -14,6 +14,7 @@ package page import ( + "context" "fmt" "html/template" "path" @@ -22,7 +23,7 @@ import ( "github.com/gohugoio/hugo/hugofs/files" "github.com/gohugoio/hugo/identity" - "github.com/gohugoio/hugo/tpl" + "github.com/spf13/afero" "github.com/gohugoio/hugo/modules" @@ -55,8 +56,12 @@ func newTestPage() *testPage { } func newTestPageWithFile(filename string) *testPage { + sp := newTestSourceSpec() filename = filepath.FromSlash(filename) - file := source.NewTestFile(filename) + file, err := sp.NewFileInfoFrom(filename, filename) + if err != nil { + panic(err) + } return &testPage{ params: make(map[string]interface{}), data: make(map[string]interface{}), @@ -87,6 +92,16 @@ func newTestPathSpecFor(cfg config.Provider) *helpers.PathSpec { return s } +func newTestSourceSpec() *source.SourceSpec { + v := config.New() + fs := hugofs.NewFrom(hugofs.NewBaseFileDecorator(afero.NewMemMapFs()), v) + ps, err := helpers.NewPathSpec(fs, v, nil) + if err != nil { + panic(err) + } + return source.NewSourceSpec(ps, nil, fs.Source) +} + type testPage struct { kind string description string @@ -114,7 +129,7 @@ type testPage struct { params map[string]interface{} data map[string]interface{} - file source.File + file *source.File currentSection *testPage sectionEntries []string @@ -208,7 +223,7 @@ func (p *testPage) Extension() string { panic("not implemented") } -func (p *testPage) File() source.File { +func (p *testPage) File() *source.File { return p.file } @@ -232,10 +247,6 @@ func (p *testPage) GetPage(ref string) (Page, error) { panic("not implemented") } -func (p *testPage) GetPageWithTemplateInfo(info tpl.Info, ref string) (Page, error) { - panic("not implemented") -} - func (p *testPage) GetParam(key string) interface{} { panic("not implemented") } @@ -414,10 +425,6 @@ func (p *testPage) Path() string { return p.path } -func (p *testPage) Pathc() string { - return p.path -} - func (p *testPage) Permalink() string { panic("not implemented") } @@ -478,7 +485,7 @@ func (p *testPage) RelRefFrom(argsm map[string]interface{}, source interface{}) return "", nil } -func (p *testPage) Render(layout ...string) (template.HTML, error) { +func (p *testPage) Render(ctx context.Context, layout ...string) (template.HTML, error) { panic("not implemented") } @@ -587,8 +594,12 @@ func (p *testPage) WordCount() int { panic("not implemented") } -func (p *testPage) GetIdentity() identity.Identity { - panic("not implemented") +func (p *testPage) IdentifierBase() interface{} { + return p.path +} + +func (p *testPage) GetDependencyManager() identity.Manager { + return identity.NopManager } func createTestPages(num int) Pages { diff --git a/resources/page/zero_file.autogen.go b/resources/page/zero_file.autogen.go deleted file mode 100644 index 72d98998ec2..00000000000 --- a/resources/page/zero_file.autogen.go +++ /dev/null @@ -1,88 +0,0 @@ -// 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. - -// This file is autogenerated. - -package page - -import ( - "github.com/gohugoio/hugo/common/loggers" - "github.com/gohugoio/hugo/hugofs" - "github.com/gohugoio/hugo/source" -) - -// ZeroFile represents a zero value of source.File with warnings if invoked. -type zeroFile struct { - log loggers.Logger -} - -func NewZeroFile(log loggers.Logger) source.File { - return zeroFile{log: log} -} - -func (zeroFile) IsZero() bool { - return true -} - -func (z zeroFile) Path() (o0 string) { - z.log.Warnln(".File.Path on zero object. Wrap it in if or with: {{ with .File }}{{ .Path }}{{ end }}") - return -} -func (z zeroFile) Section() (o0 string) { - z.log.Warnln(".File.Section on zero object. Wrap it in if or with: {{ with .File }}{{ .Section }}{{ end }}") - return -} -func (z zeroFile) Lang() (o0 string) { - z.log.Warnln(".File.Lang on zero object. Wrap it in if or with: {{ with .File }}{{ .Lang }}{{ end }}") - return -} -func (z zeroFile) Filename() (o0 string) { - z.log.Warnln(".File.Filename on zero object. Wrap it in if or with: {{ with .File }}{{ .Filename }}{{ end }}") - return -} -func (z zeroFile) Dir() (o0 string) { - z.log.Warnln(".File.Dir on zero object. Wrap it in if or with: {{ with .File }}{{ .Dir }}{{ end }}") - return -} -func (z zeroFile) Extension() (o0 string) { - z.log.Warnln(".File.Extension on zero object. Wrap it in if or with: {{ with .File }}{{ .Extension }}{{ end }}") - return -} -func (z zeroFile) Ext() (o0 string) { - z.log.Warnln(".File.Ext on zero object. Wrap it in if or with: {{ with .File }}{{ .Ext }}{{ end }}") - return -} -func (z zeroFile) LogicalName() (o0 string) { - z.log.Warnln(".File.LogicalName on zero object. Wrap it in if or with: {{ with .File }}{{ .LogicalName }}{{ end }}") - return -} -func (z zeroFile) BaseFileName() (o0 string) { - z.log.Warnln(".File.BaseFileName on zero object. Wrap it in if or with: {{ with .File }}{{ .BaseFileName }}{{ end }}") - return -} -func (z zeroFile) TranslationBaseName() (o0 string) { - z.log.Warnln(".File.TranslationBaseName on zero object. Wrap it in if or with: {{ with .File }}{{ .TranslationBaseName }}{{ end }}") - return -} -func (z zeroFile) ContentBaseName() (o0 string) { - z.log.Warnln(".File.ContentBaseName on zero object. Wrap it in if or with: {{ with .File }}{{ .ContentBaseName }}{{ end }}") - return -} -func (z zeroFile) UniqueID() (o0 string) { - z.log.Warnln(".File.UniqueID on zero object. Wrap it in if or with: {{ with .File }}{{ .UniqueID }}{{ end }}") - return -} -func (z zeroFile) FileInfo() (o0 hugofs.FileMetaInfo) { - z.log.Warnln(".File.FileInfo on zero object. Wrap it in if or with: {{ with .File }}{{ .FileInfo }}{{ end }}") - return -} diff --git a/resources/resource.go b/resources/resource.go index 4bf35f9aca7..a370888619e 100644 --- a/resources/resource.go +++ b/resources/resource.go @@ -21,6 +21,9 @@ import ( "path" "path/filepath" "sync" + "sync/atomic" + + "github.com/gohugoio/hugo/identity" "github.com/gohugoio/hugo/resources/internal" @@ -28,9 +31,10 @@ import ( "github.com/gohugoio/hugo/hugofs" + "github.com/gohugoio/hugo/cache/memcache" + "github.com/gohugoio/hugo/common/types" "github.com/gohugoio/hugo/media" "github.com/gohugoio/hugo/source" - "github.com/pkg/errors" "github.com/gohugoio/hugo/common/hugio" @@ -43,15 +47,16 @@ import ( ) var ( - _ resource.ContentResource = (*genericResource)(nil) - _ resource.ReadSeekCloserResource = (*genericResource)(nil) - _ resource.Resource = (*genericResource)(nil) - _ resource.Source = (*genericResource)(nil) - _ resource.Cloner = (*genericResource)(nil) - _ resource.ResourcesLanguageMerger = (*resource.Resources)(nil) - _ permalinker = (*genericResource)(nil) - _ resource.Identifier = (*genericResource)(nil) - _ fileInfo = (*genericResource)(nil) + _ resource.ContentResource = (*genericResource)(nil) + _ resource.ReadSeekCloserResource = (*genericResource)(nil) + _ resource.Resource = (*genericResource)(nil) + _ identity.DependencyManagerProvider = (*genericResource)(nil) + _ resource.Source = (*genericResource)(nil) + _ resource.Cloner = (*genericResource)(nil) + _ resource.ResourcesLanguageMerger = (*resource.Resources)(nil) + _ permalinker = (*genericResource)(nil) + _ types.Identifier = (*genericResource)(nil) + _ fileInfo = (*genericResource)(nil) ) type ResourceSourceDescriptor struct { @@ -59,7 +64,7 @@ type ResourceSourceDescriptor struct { TargetPaths func() page.TargetPaths // Need one of these to load the resource content. - SourceFile source.File + SourceFile *source.File OpenReadSeekCloser resource.OpenReadSeekCloser FileInfo os.FileInfo @@ -84,6 +89,13 @@ type ResourceSourceDescriptor struct { // Delay publishing until either Permalink or RelPermalink is called. Maybe never. LazyPublish bool + + // Used to track depenencies (e.g. imports). May be nil if that's of no concern. + DependencyManager identity.Manager + + // A shared identity for this resource and all its clones. + // If this is not set, an Identity is created. + GroupIdentity identity.Identity } func (r ResourceSourceDescriptor) Filename() string { @@ -124,7 +136,9 @@ type baseResourceResource interface { resource.Cloner resource.ContentProvider resource.Resource - resource.Identifier + types.Identifier + identity.IdentityGroupProvider + identity.DependencyManagerProvider } type baseResourceInternal interface { @@ -158,8 +172,7 @@ type baseResource interface { baseResourceInternal } -type commonResource struct { -} +type commonResource struct{} // Slice is not meant to be used externally. It's a bridge function // for the template functions. See collections.Slice. @@ -175,8 +188,7 @@ func (commonResource) Slice(in interface{}) (interface{}, error) { return nil, fmt.Errorf("type %T is not a Resource", v) } groups[i] = g - { - } + } return groups, nil default: @@ -200,15 +212,34 @@ type fileInfo interface { setSourceFilename(string) setSourceFs(afero.Fs) getFileInfo() hugofs.FileMetaInfo - hash() (string, error) size() int + hashProvider +} + +type hashProvider interface { + hash() string +} + +type staler struct { + stale uint32 +} + +func (s *staler) MarkStale() { + atomic.StoreUint32(&s.stale, 1) +} + +func (s *staler) IsStale() bool { + return atomic.LoadUint32(&(s.stale)) > 0 } // genericResource represents a generic linkable resource. type genericResource struct { *resourcePathDescriptor *resourceFileInfo - *resourceContent + *resourceContent // + + groupIdentity identity.Identity + dependencyManager identity.Manager spec *Spec @@ -221,6 +252,14 @@ type genericResource struct { mediaType media.Type } +func (l *genericResource) GetIdentityGroup() identity.Identity { + return l.groupIdentity +} + +func (l *genericResource) GetDependencyManager() identity.Manager { + return l.dependencyManager +} + func (l *genericResource) Clone() resource.Resource { return l.clone() } @@ -242,7 +281,24 @@ func (l *genericResource) Data() interface{} { } func (l *genericResource) Key() string { - return l.RelPermalink() + // TODO1 consider repeating the section in the path segment. + + if l.fi != nil { + // Create a key that at least shares the base folder with the source, + // to facilitate effective cache busting on changes. + meta := l.fi.Meta() + p := meta.Path + if p != "" { + d, _ := filepath.Split(p) + p = path.Join(d, l.relTargetDirFile.file) + key := memcache.CleanKey(p) + key = memcache.InsertKeyPathElements(key, meta.Component, meta.Lang) + + return key + } + } + + return memcache.CleanKey(l.RelPermalink()) } func (l *genericResource) MediaType() media.Type { @@ -626,15 +682,13 @@ func (fi *resourceFileInfo) setSourceFs(fs afero.Fs) { fi.sourceFs = fs } -func (fi *resourceFileInfo) hash() (string, error) { - var err error +func (fi *resourceFileInfo) hash() string { fi.h.init.Do(func() { var hash string var f hugio.ReadSeekCloser - f, err = fi.ReadSeekCloser() + f, err := fi.ReadSeekCloser() if err != nil { - err = errors.Wrap(err, "failed to open source file") - return + panic(fmt.Sprintf("failed to open source file: %s", err)) } defer f.Close() @@ -645,7 +699,7 @@ func (fi *resourceFileInfo) hash() (string, error) { fi.h.value = hash }) - return fi.h.value, err + return fi.h.value } func (fi *resourceFileInfo) size() int { diff --git a/resources/resource/resources.go b/resources/resource/resources.go index ac5dd0b2b03..aecea48d616 100644 --- a/resources/resource/resources.go +++ b/resources/resource/resources.go @@ -20,10 +20,24 @@ import ( "github.com/gohugoio/hugo/hugofs/glob" ) +var ( + _ StaleInfo = Resources{} +) + // Resources represents a slice of resources, which can be a mix of different types. // I.e. both pages and images etc. type Resources []Resource +// Resources is stale if any of the the elements are stale. +func (rs Resources) IsStale() bool { + for _, r := range rs { + if s, ok := r.(StaleInfo); ok && s.IsStale() { + return true + } + } + return false +} + // ResourcesConverter converts a given slice of Resource objects to Resources. type ResourcesConverter interface { ToResources() Resources diff --git a/resources/resource/resourcetypes.go b/resources/resource/resourcetypes.go index c96f3d49523..edd04434dc1 100644 --- a/resources/resource/resourcetypes.go +++ b/resources/resource/resourcetypes.go @@ -16,6 +16,8 @@ package resource import ( "image" + "github.com/gohugoio/hugo/common/types" + "github.com/gohugoio/hugo/common/maps" "github.com/gohugoio/hugo/langs" "github.com/gohugoio/hugo/media" @@ -129,11 +131,6 @@ type ResourcesLanguageMerger interface { MergeByLanguageInterface(other interface{}) (interface{}, error) } -// Identifier identifies a resource. -type Identifier interface { - Key() string -} - // ContentResource represents a Resource that provides a way to get to its content. // Most Resource types in Hugo implements this interface, including Page. type ContentResource interface { @@ -183,7 +180,37 @@ type TranslationKeyProvider interface { // UnmarshableResource represents a Resource that can be unmarshaled to some other format. type UnmarshableResource interface { ReadSeekCloserResource - Identifier + types.Identifier +} + +// Staler controls stale state of a Resource. A stale resource should be discarded. +type Staler interface { + MarkStale() + StaleInfo +} + +// StaleInfo tells if a resource is marked as stale. +type StaleInfo interface { + IsStale() bool +} + +// IsStaleAny reports whether any of the os is marked as stale. +func IsStaleAny(os ...interface{}) bool { + for _, o := range os { + if s, ok := o.(StaleInfo); ok && s.IsStale() { + return true + } + } + return false +} + +// MarkStale will mark any of the oses as stale, if possible. +func MarkStale(os ...interface{}) { + for _, o := range os { + if s, ok := o.(Staler); ok { + s.MarkStale() + } + } } type resourceTypesHolder struct { diff --git a/resources/resource_cache.go b/resources/resource_cache.go index f498bb0c06d..3daa2fb45b2 100644 --- a/resources/resource_cache.go +++ b/resources/resource_cache.go @@ -14,28 +14,16 @@ package resources import ( + "context" "encoding/json" "io" - "path" - "path/filepath" - "regexp" - "strings" "sync" - "github.com/gohugoio/hugo/helpers" - - "github.com/gohugoio/hugo/hugofs/glob" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/resources/resource" "github.com/gohugoio/hugo/cache/filecache" - - "github.com/BurntSushi/locker" -) - -const ( - CACHE_CLEAR_ALL = "clear_all" - CACHE_OTHER = "other" ) type ResourceCache struct { @@ -43,123 +31,39 @@ type ResourceCache struct { sync.RWMutex - // Either resource.Resource or resource.Resources. - cache map[string]interface{} + // Memory cache with either + // resource.Resource or resource.Resources. + cache memcache.Getter fileCache *filecache.Cache - - // Provides named resource locks. - nlocker *locker.Locker -} - -// ResourceCacheKey converts the filename into the format used in the resource -// cache. -func ResourceCacheKey(filename string) string { - filename = filepath.ToSlash(filename) - return path.Join(resourceKeyPartition(filename), filename) -} - -func resourceKeyPartition(filename string) string { - ext := strings.TrimPrefix(path.Ext(filepath.ToSlash(filename)), ".") - if ext == "" { - ext = CACHE_OTHER - } - return ext -} - -// Commonly used aliases and directory names used for some types. -var extAliasKeywords = map[string][]string{ - "sass": {"scss"}, - "scss": {"sass"}, -} - -// ResourceKeyPartitions resolves a ordered slice of partitions that is -// used to do resource cache invalidations. -// -// We use the first directory path element and the extension, so: -// a/b.json => "a", "json" -// b.json => "json" -// -// For some of the extensions we will also map to closely related types, -// e.g. "scss" will also return "sass". -// -func ResourceKeyPartitions(filename string) []string { - var partitions []string - filename = glob.NormalizePath(filename) - dir, name := path.Split(filename) - ext := strings.TrimPrefix(path.Ext(filepath.ToSlash(name)), ".") - - if dir != "" { - partitions = append(partitions, strings.Split(dir, "/")[0]) - } - - if ext != "" { - partitions = append(partitions, ext) - } - - if aliases, found := extAliasKeywords[ext]; found { - partitions = append(partitions, aliases...) - } - - if len(partitions) == 0 { - partitions = []string{CACHE_OTHER} - } - - return helpers.UniqueStringsSorted(partitions) } -// ResourceKeyContainsAny returns whether the key is a member of any of the -// given partitions. -// -// This is used for resource cache invalidation. -func ResourceKeyContainsAny(key string, partitions []string) bool { - parts := strings.Split(key, "/") - for _, p1 := range partitions { - for _, p2 := range parts { - if p1 == p2 { - return true - } - } - } - return false -} - -func newResourceCache(rs *Spec) *ResourceCache { +func newResourceCache(rs *Spec, memCache *memcache.Cache) *ResourceCache { return &ResourceCache{ rs: rs, fileCache: rs.FileCaches.AssetsCache(), - cache: make(map[string]interface{}), - nlocker: locker.NewLocker(), + cache: memCache.GetOrCreatePartition("resources", memcache.ClearOnChange), } } -func (c *ResourceCache) clear() { - c.Lock() - defer c.Unlock() - - c.cache = make(map[string]interface{}) - c.nlocker = locker.NewLocker() -} - -func (c *ResourceCache) Contains(key string) bool { - key = c.cleanKey(filepath.ToSlash(key)) - _, found := c.get(key) - return found -} - -func (c *ResourceCache) cleanKey(key string) string { - return strings.TrimPrefix(path.Clean(strings.ToLower(key)), "/") -} - -func (c *ResourceCache) get(key string) (interface{}, bool) { - c.RLock() - defer c.RUnlock() - r, found := c.cache[key] - return r, found +func (c *ResourceCache) Get(ctx context.Context, key string) (resource.Resource, error) { + // TODO, maybe also look in resources and rename it to something ala Find? + v, err := c.cache.Get(ctx, key) + if v == nil || err != nil { + return nil, err + } + return v.(resource.Resource), nil } -func (c *ResourceCache) GetOrCreate(key string, f func() (resource.Resource, error)) (resource.Resource, error) { - r, err := c.getOrCreate(key, func() (interface{}, error) { return f() }) +func (c *ResourceCache) GetOrCreate(ctx context.Context, key string, clearWhen memcache.ClearWhen, f func() (resource.Resource, error)) (resource.Resource, error) { + r, err := c.cache.GetOrCreate(ctx, key, func() memcache.Entry { + r, err := f() + return memcache.Entry{ + Value: r, + Err: err, + ClearWhen: clearWhen, + } + }) if r == nil || err != nil { return nil, err } @@ -167,42 +71,20 @@ func (c *ResourceCache) GetOrCreate(key string, f func() (resource.Resource, err } func (c *ResourceCache) GetOrCreateResources(key string, f func() (resource.Resources, error)) (resource.Resources, error) { - r, err := c.getOrCreate(key, func() (interface{}, error) { return f() }) + r, err := c.cache.GetOrCreate(context.TODO(), key, func() memcache.Entry { + r, err := f() + return memcache.Entry{ + Value: r, + Err: err, + ClearWhen: memcache.ClearOnChange, + } + }) if r == nil || err != nil { return nil, err } return r.(resource.Resources), nil } -func (c *ResourceCache) getOrCreate(key string, f func() (interface{}, error)) (interface{}, error) { - key = c.cleanKey(key) - // First check in-memory cache. - r, found := c.get(key) - if found { - return r, nil - } - // This is a potentially long running operation, so get a named lock. - c.nlocker.Lock(key) - - // Double check in-memory cache. - r, found = c.get(key) - if found { - c.nlocker.Unlock(key) - return r, nil - } - - defer c.nlocker.Unlock(key) - - r, err := f() - if err != nil { - return nil, err - } - - c.set(key, r) - - return r, nil -} - func (c *ResourceCache) getFilenames(key string) (string, string) { filenameMeta := key + ".json" filenameContent := key + ".content" @@ -253,53 +135,3 @@ func (c *ResourceCache) writeMeta(key string, meta transformedResourceMetadata) return fi, fc, err } - -func (c *ResourceCache) set(key string, r interface{}) { - c.Lock() - defer c.Unlock() - c.cache[key] = r -} - -func (c *ResourceCache) DeletePartitions(partitions ...string) { - partitionsSet := map[string]bool{ - // Always clear out the resources not matching any partition. - "other": true, - } - for _, p := range partitions { - partitionsSet[p] = true - } - - if partitionsSet[CACHE_CLEAR_ALL] { - c.clear() - return - } - - c.Lock() - defer c.Unlock() - - for k := range c.cache { - clear := false - for p := range partitionsSet { - if strings.Contains(k, p) { - // There will be some false positive, but that's fine. - clear = true - break - } - } - - if clear { - delete(c.cache, k) - } - } -} - -func (c *ResourceCache) DeleteMatches(re *regexp.Regexp) { - c.Lock() - defer c.Unlock() - - for k := range c.cache { - if re.MatchString(k) { - delete(c.cache, k) - } - } -} diff --git a/resources/resource_cache_test.go b/resources/resource_cache_test.go deleted file mode 100644 index bcb24102594..00000000000 --- a/resources/resource_cache_test.go +++ /dev/null @@ -1,58 +0,0 @@ -// 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 resources - -import ( - "path/filepath" - "testing" - - qt "github.com/frankban/quicktest" -) - -func TestResourceKeyPartitions(t *testing.T) { - c := qt.New(t) - - for _, test := range []struct { - input string - expected []string - }{ - {"a.js", []string{"js"}}, - {"a.scss", []string{"sass", "scss"}}, - {"a.sass", []string{"sass", "scss"}}, - {"d/a.js", []string{"d", "js"}}, - {"js/a.js", []string{"js"}}, - {"D/a.JS", []string{"d", "js"}}, - {"d/a", []string{"d"}}, - {filepath.FromSlash("/d/a.js"), []string{"d", "js"}}, - {filepath.FromSlash("/d/e/a.js"), []string{"d", "js"}}, - } { - c.Assert(ResourceKeyPartitions(test.input), qt.DeepEquals, test.expected, qt.Commentf(test.input)) - } -} - -func TestResourceKeyContainsAny(t *testing.T) { - c := qt.New(t) - - for _, test := range []struct { - key string - filename string - expected bool - }{ - {"styles/css", "asdf.css", true}, - {"styles/css", "styles/asdf.scss", true}, - {"js/foo.bar", "asdf.css", false}, - } { - c.Assert(ResourceKeyContainsAny(test.key, ResourceKeyPartitions(test.filename)), qt.Equals, test.expected) - } -} diff --git a/resources/resource_factories/bundler/bundler.go b/resources/resource_factories/bundler/bundler.go index 7de2282270d..50e86caa623 100644 --- a/resources/resource_factories/bundler/bundler.go +++ b/resources/resource_factories/bundler/bundler.go @@ -1,4 +1,4 @@ -// Copyright 2019 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -15,11 +15,13 @@ package bundler import ( + "context" "fmt" "io" - "path" "path/filepath" + "github.com/gohugoio/hugo/cache/memcache" + "github.com/gohugoio/hugo/common/hugio" "github.com/gohugoio/hugo/media" "github.com/gohugoio/hugo/resources" @@ -81,8 +83,7 @@ func (r *multiReadSeekCloser) Close() error { // Concat concatenates the list of Resource objects. func (c *Client) Concat(targetPath string, r resource.Resources) (resource.Resource, error) { - // The CACHE_OTHER will make sure this will be re-created and published on rebuilds. - return c.rs.ResourceCache.GetOrCreate(path.Join(resources.CACHE_OTHER, targetPath), func() (resource.Resource, error) { + return c.rs.ResourceCache.GetOrCreate(context.TODO(), targetPath, memcache.ClearOnRebuild, func() (resource.Resource, error) { var resolvedm media.Type // The given set of resources must be of the same Media Type. diff --git a/resources/resource_factories/create/create.go b/resources/resource_factories/create/create.go index f8e7e18db19..a8e81613bfb 100644 --- a/resources/resource_factories/create/create.go +++ b/resources/resource_factories/create/create.go @@ -1,4 +1,4 @@ -// Copyright 2019 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -16,12 +16,15 @@ package create import ( + "context" "net/http" "path" "path/filepath" - "strings" "time" + "github.com/gohugoio/hugo/cache/memcache" + "github.com/gohugoio/hugo/identity" + "github.com/gohugoio/hugo/hugofs/glob" "github.com/gohugoio/hugo/hugofs" @@ -54,11 +57,16 @@ func New(rs *resources.Spec) *Client { // Get creates a new Resource by opening the given filename in the assets filesystem. func (c *Client) Get(filename string) (resource.Resource, error) { filename = filepath.Clean(filename) - return c.rs.ResourceCache.GetOrCreate(resources.ResourceCacheKey(filename), func() (resource.Resource, error) { + key := memcache.CleanKey(filename) + return c.rs.ResourceCache.GetOrCreate(context.TODO(), key, memcache.ClearOnChange, func() (resource.Resource, error) { + // TODO1 consolidate etc. (make into one identity) + id := identity.NewManager(identity.StringIdentity(key)) return c.rs.New(resources.ResourceSourceDescriptor{ - Fs: c.rs.BaseFs.Assets.Fs, - LazyPublish: true, - SourceFilename: filename, + Fs: c.rs.BaseFs.Assets.Fs, + LazyPublish: true, + SourceFilename: filename, + GroupIdentity: id, + DependencyManager: id, }) }) } @@ -85,13 +93,7 @@ func (c *Client) match(pattern string, firstOnly bool) (resource.Resources, erro name = "__match" } - pattern = glob.NormalizePath(pattern) - partitions := glob.FilterGlobParts(strings.Split(pattern, "/")) - if len(partitions) == 0 { - partitions = []string{resources.CACHE_OTHER} - } - key := path.Join(name, path.Join(partitions...)) - key = path.Join(key, pattern) + key := path.Join(name, glob.NormalizePath(pattern)) return c.rs.ResourceCache.GetOrCreateResources(key, func() (resource.Resources, error) { var res resource.Resources @@ -125,7 +127,7 @@ func (c *Client) match(pattern string, firstOnly bool) (resource.Resources, erro // FromString creates a new Resource from a string with the given relative target path. func (c *Client) FromString(targetPath, content string) (resource.Resource, error) { - return c.rs.ResourceCache.GetOrCreate(path.Join(resources.CACHE_OTHER, targetPath), func() (resource.Resource, error) { + r, err := c.rs.ResourceCache.GetOrCreate(context.TODO(), memcache.CleanKey(targetPath), memcache.ClearOnRebuild, func() (resource.Resource, error) { return c.rs.New( resources.ResourceSourceDescriptor{ Fs: c.rs.FileCaches.AssetsCache().Fs, @@ -136,4 +138,10 @@ func (c *Client) FromString(targetPath, content string) (resource.Resource, erro RelTargetFilename: filepath.Clean(targetPath), }) }) + + if err == nil { + // Mark it so it gets evicted on rebuild. + r.(resource.Staler).MarkStale() + } + return r, err } diff --git a/resources/resource_factories/create/remote.go b/resources/resource_factories/create/remote.go index f127f8edc5a..c47354a876c 100644 --- a/resources/resource_factories/create/remote.go +++ b/resources/resource_factories/create/remote.go @@ -16,6 +16,7 @@ package create import ( "bufio" "bytes" + "context" "io" "io/ioutil" "mime" @@ -46,7 +47,7 @@ func (c *Client) FromRemote(uri string, optionsm map[string]interface{}) (resour resourceID := helpers.HashString(uri, optionsm) - _, httpResponse, err := c.cacheGetResource.GetOrCreate(resourceID, func() (io.ReadCloser, error) { + _, httpResponse, err := c.cacheGetResource.GetOrCreate(context.TODO(), resourceID, func() (io.ReadCloser, error) { options, err := decodeRemoteOptions(optionsm) if err != nil { return nil, errors.Wrapf(err, "failed to decode options for resource %s", uri) diff --git a/resources/resource_metadata_test.go b/resources/resource_metadata_test.go index 87a537f740b..c29445f214d 100644 --- a/resources/resource_metadata_test.go +++ b/resources/resource_metadata_test.go @@ -200,12 +200,12 @@ func TestAssignMetadata(t *testing.T) { }}, } { - foo2 = spec.newGenericResource(nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType) - logo2 = spec.newGenericResource(nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType) - foo1 = spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType) - logo1 = spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType) - foo3 = spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType) - logo3 = spec.newGenericResource(nil, nil, nil, "/b/logo3.png", "logo3.png", pngType) + foo2 = newGenericResource(spec, nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType) + logo2 = newGenericResource(spec, nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType) + foo1 = newGenericResource(spec, nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType) + logo1 = newGenericResource(spec, nil, nil, nil, "/a/logo1.png", "logo1.png", pngType) + foo3 = newGenericResource(spec, nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType) + logo3 = newGenericResource(spec, nil, nil, nil, "/b/logo3.png", "logo3.png", pngType) resources = resource.Resources{ foo2, diff --git a/resources/resource_spec.go b/resources/resource_spec.go index cd1e5010d9b..464ea256aa7 100644 --- a/resources/resource_spec.go +++ b/resources/resource_spec.go @@ -23,6 +23,7 @@ import ( "strings" "sync" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/resources/jsconfig" "github.com/gohugoio/hugo/common/herrors" @@ -49,12 +50,14 @@ import ( func NewSpec( s *helpers.PathSpec, fileCaches filecache.Caches, + memCache *memcache.Cache, incr identity.Incrementer, logger loggers.Logger, errorHandler herrors.ErrorSender, execHelper *hexec.Exec, outputFormats output.Formats, mimeTypes media.Types) (*Spec, error) { + imgConfig, err := images.DecodeConfig(s.Cfg.GetStringMap("imaging")) if err != nil { return nil, err @@ -96,12 +99,12 @@ func NewSpec( }, imageCache: newImageCache( fileCaches.ImageCache(), - + memCache, s, ), } - rs.ResourceCache = newResourceCache(rs) + rs.ResourceCache = newResourceCache(rs, memCache) return rs, nil } @@ -145,57 +148,14 @@ func (r *Spec) New(fd ResourceSourceDescriptor) (resource.Resource, error) { return r.newResourceFor(fd) } -func (r *Spec) CacheStats() string { - r.imageCache.mu.RLock() - defer r.imageCache.mu.RUnlock() - - s := fmt.Sprintf("Cache entries: %d", len(r.imageCache.store)) - - count := 0 - for k := range r.imageCache.store { - if count > 5 { - break - } - s += "\n" + k - count++ - } - - return s -} - -func (r *Spec) ClearCaches() { - r.imageCache.clear() - r.ResourceCache.clear() -} - -func (r *Spec) DeleteBySubstring(s string) { - r.imageCache.deleteIfContains(s) -} - func (s *Spec) String() string { return "spec" } // TODO(bep) clean up below -func (r *Spec) newGenericResource(sourceFs afero.Fs, - targetPathBuilder func() page.TargetPaths, - osFileInfo os.FileInfo, - sourceFilename, - baseFilename string, - mediaType media.Type) *genericResource { - return r.newGenericResourceWithBase( - sourceFs, - nil, - nil, - targetPathBuilder, - osFileInfo, - sourceFilename, - baseFilename, - mediaType, - ) -} - func (r *Spec) newGenericResourceWithBase( + groupIdentity identity.Identity, + dependencyManager identity.Manager, sourceFs afero.Fs, openReadSeekerCloser resource.OpenReadSeekCloser, targetPathBaseDirs []string, @@ -204,6 +164,7 @@ func (r *Spec) newGenericResourceWithBase( sourceFilename, baseFilename string, mediaType media.Type) *genericResource { + if osFileInfo != nil && osFileInfo.IsDir() { panic(fmt.Sprintf("dirs not supported resource types: %v", osFileInfo)) } @@ -235,6 +196,8 @@ func (r *Spec) newGenericResourceWithBase( } g := &genericResource{ + groupIdentity: groupIdentity, + dependencyManager: dependencyManager, resourceFileInfo: gfi, resourcePathDescriptor: pathDescriptor, mediaType: mediaType, @@ -297,7 +260,18 @@ func (r *Spec) newResource(sourceFs afero.Fs, fd ResourceSourceDescriptor) (reso } } + if fd.GroupIdentity == nil { + // TODO1 + fd.GroupIdentity = identity.StringIdentity("/" + memcache.CleanKey(fd.RelTargetFilename)) + } + + if fd.DependencyManager == nil { + fd.DependencyManager = identity.NopManager + } + gr := r.newGenericResourceWithBase( + fd.GroupIdentity, + fd.DependencyManager, sourceFs, fd.OpenReadSeekCloser, fd.TargetBasePaths, @@ -305,7 +279,8 @@ func (r *Spec) newResource(sourceFs afero.Fs, fd ResourceSourceDescriptor) (reso fi, sourceFilename, fd.RelTargetFilename, - mimeType) + mimeType, + ) if mimeType.MainType == "image" { imgFormat, ok := images.ImageFormatFromMediaSubType(mimeType.SubType) diff --git a/resources/resource_test.go b/resources/resource_test.go index 9823c064db8..d27a5fc8392 100644 --- a/resources/resource_test.go +++ b/resources/resource_test.go @@ -1,4 +1,4 @@ -// Copyright 2019 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -19,6 +19,7 @@ import ( "path/filepath" "strings" "testing" + "time" "github.com/spf13/afero" @@ -33,7 +34,7 @@ func TestGenericResource(t *testing.T) { c := qt.New(t) spec := newTestResourceSpec(specDescriptor{c: c}) - r := spec.newGenericResource(nil, nil, nil, "/a/foo.css", "foo.css", media.CSSType) + r := newGenericResource(spec, nil, nil, nil, "/a/foo.css", "foo.css", media.CSSType) c.Assert(r.Permalink(), qt.Equals, "https://example.com/foo.css") c.Assert(r.RelPermalink(), qt.Equals, "/foo.css") @@ -46,11 +47,12 @@ func TestGenericResourceWithLinkFactory(t *testing.T) { factory := newTargetPaths("/foo") - r := spec.newGenericResource(nil, factory, nil, "/a/foo.css", "foo.css", media.CSSType) + r := newGenericResource(spec, nil, factory, nil, "/a/foo.css", "foo.css", media.CSSType) c.Assert(r.Permalink(), qt.Equals, "https://example.com/foo/foo.css") c.Assert(r.RelPermalink(), qt.Equals, "/foo/foo.css") - c.Assert(r.Key(), qt.Equals, "/foo/foo.css") + c.Assert(r.ResourceType(), qt.Equals, "text") + c.Assert(r.Key(), qt.Equals, "foo/foo.css") // TODO1 Key leading slash? c.Assert(r.ResourceType(), qt.Equals, "text") } @@ -101,11 +103,11 @@ func TestResourcesByType(t *testing.T) { c := qt.New(t) spec := newTestResourceSpec(specDescriptor{c: c}) resources := resource.Resources{ - spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/a/logo.png", "logo.css", pngType), - spec.newGenericResource(nil, nil, nil, "/a/foo2.css", "foo2.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/a/foo3.css", "foo3.css", media.CSSType), - } + + newGenericResource(spec, nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/a/logo.png", "logo.css", pngType), + newGenericResource(spec, nil, nil, nil, "/a/foo2.css", "foo2.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/a/foo3.css", "foo3.css", media.CSSType)} c.Assert(len(resources.ByType("text")), qt.Equals, 3) c.Assert(len(resources.ByType("image")), qt.Equals, 1) @@ -115,12 +117,12 @@ func TestResourcesGetByPrefix(t *testing.T) { c := qt.New(t) spec := newTestResourceSpec(specDescriptor{c: c}) resources := resource.Resources{ - spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType), - spec.newGenericResource(nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType), - spec.newGenericResource(nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType), - } + + newGenericResource(spec, nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/a/logo1.png", "logo1.png", pngType), + newGenericResource(spec, nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType), + newGenericResource(spec, nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType)} c.Assert(resources.GetMatch("asdf*"), qt.IsNil) c.Assert(resources.GetMatch("logo*").RelPermalink(), qt.Equals, "/logo1.png") @@ -144,14 +146,14 @@ func TestResourcesGetMatch(t *testing.T) { c := qt.New(t) spec := newTestResourceSpec(specDescriptor{c: c}) resources := resource.Resources{ - spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType), - spec.newGenericResource(nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType), - spec.newGenericResource(nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/b/c/foo4.css", "c/foo4.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/b/c/foo5.css", "c/foo5.css", media.CSSType), - spec.newGenericResource(nil, nil, nil, "/b/c/d/foo6.css", "c/d/foo6.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/a/logo1.png", "logo1.png", pngType), + newGenericResource(spec, nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType), + newGenericResource(spec, nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/b/c/foo4.css", "c/foo4.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/b/c/foo5.css", "c/foo5.css", media.CSSType), + newGenericResource(spec, nil, nil, nil, "/b/c/d/foo6.css", "c/d/foo6.css", media.CSSType), } c.Assert(resources.GetMatch("logo*").RelPermalink(), qt.Equals, "/logo1.png") @@ -188,10 +190,11 @@ func TestResourcesGetMatch(t *testing.T) { func BenchmarkResourcesMatch(b *testing.B) { resources := benchResources(b) prefixes := []string{"abc*", "jkl*", "nomatch*", "sub/*"} + rnd := rand.New(rand.NewSource(time.Now().Unix())) b.RunParallel(func(pb *testing.PB) { for pb.Next() { - resources.Match(prefixes[rand.Intn(len(prefixes))]) + resources.Match(prefixes[rnd.Intn(len(prefixes))]) } }) } @@ -206,7 +209,7 @@ func BenchmarkResourcesMatchA100(b *testing.B) { a100 := strings.Repeat("a", 100) pattern := "a*a*a*a*a*a*a*a*b" - resources := resource.Resources{spec.newGenericResource(nil, nil, nil, "/a/"+a100, a100, media.CSSType)} + resources := resource.Resources{newGenericResource(spec, nil, nil, nil, "/a/"+a100, a100, media.CSSType)} b.ResetTimer() for i := 0; i < b.N; i++ { @@ -221,17 +224,17 @@ func benchResources(b *testing.B) resource.Resources { for i := 0; i < 30; i++ { name := fmt.Sprintf("abcde%d_%d.css", i%5, i) - resources = append(resources, spec.newGenericResource(nil, nil, nil, "/a/"+name, name, media.CSSType)) + resources = append(resources, newGenericResource(spec, nil, nil, nil, "/a/"+name, name, media.CSSType)) } for i := 0; i < 30; i++ { name := fmt.Sprintf("efghi%d_%d.css", i%5, i) - resources = append(resources, spec.newGenericResource(nil, nil, nil, "/a/"+name, name, media.CSSType)) + resources = append(resources, newGenericResource(spec, nil, nil, nil, "/a/"+name, name, media.CSSType)) } for i := 0; i < 30; i++ { name := fmt.Sprintf("jklmn%d_%d.css", i%5, i) - resources = append(resources, spec.newGenericResource(nil, nil, nil, "/b/sub/"+name, "sub/"+name, media.CSSType)) + resources = append(resources, newGenericResource(spec, nil, nil, nil, "/b/sub/"+name, "sub/"+name, media.CSSType)) } return resources @@ -258,7 +261,7 @@ func BenchmarkAssignMetadata(b *testing.B) { } for i := 0; i < 20; i++ { name := fmt.Sprintf("foo%d_%d.css", i%5, i) - resources = append(resources, spec.newGenericResource(nil, nil, nil, "/a/"+name, name, media.CSSType)) + resources = append(resources, newGenericResource(spec, nil, nil, nil, "/a/"+name, name, media.CSSType)) } b.StartTimer() diff --git a/resources/resource_transformers/babel/integration_test.go b/resources/resource_transformers/babel/integration_test.go new file mode 100644 index 00000000000..3fe3c17b1b1 --- /dev/null +++ b/resources/resource_transformers/babel/integration_test.go @@ -0,0 +1,97 @@ +// Copyright 2021 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 babel_test + +import ( + "testing" + + qt "github.com/frankban/quicktest" + jww "github.com/spf13/jwalterweatherman" + + "github.com/gohugoio/hugo/htesting" + "github.com/gohugoio/hugo/hugolib" +) + +func TestTransformBabel(t *testing.T) { + if !htesting.IsCI() { + t.Skip("Skip long running test when running locally") + } + + c := qt.New(t) + + files := ` +-- assets/js/main.js -- +/* A Car */ +class Car { + constructor(brand) { + this.carname = brand; + } +} +-- assets/js/main2.js -- +/* A Car2 */ +class Car2 { + constructor(brand) { + this.carname = brand; + } +} +-- babel.config.js -- +console.error("Hugo Environment:", process.env.HUGO_ENVIRONMENT ); + +module.exports = { + presets: ["@babel/preset-env"], +}; +-- config.toml -- +disablekinds = ['taxonomy', 'term', 'page'] +[security] + [security.exec] + allow = ['^npx$', '^babel$'] +-- layouts/index.html -- +{{ $options := dict "noComments" true }} +{{ $transpiled := resources.Get "js/main.js" | babel -}} +Transpiled: {{ $transpiled.Content | safeJS }} + +{{ $transpiled := resources.Get "js/main2.js" | babel (dict "sourceMap" "inline") -}} +Transpiled2: {{ $transpiled.Content | safeJS }} + +{{ $transpiled := resources.Get "js/main2.js" | babel (dict "sourceMap" "external") -}} +Transpiled3: {{ $transpiled.Permalink }} +-- package.json -- +{ + "scripts": {}, + + "devDependencies": { + "@babel/cli": "7.8.4", + "@babel/core": "7.9.0", + "@babel/preset-env": "7.9.5" + } +} + + ` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + NeedsOsFS: true, + NeedsNpmInstall: true, + LogLevel: jww.LevelInfo, + }).Build() + + b.AssertLogContains("babel: Hugo Environment: production") + b.AssertFileContent("public/index.html", `var Car2 =`) + b.AssertFileContent("public/js/main2.js", `var Car2 =`) + b.AssertFileContent("public/js/main2.js.map", `{"version":3,`) + b.AssertFileContent("public/index.html", ` +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozL`) +} diff --git a/resources/resource_transformers/htesting/testhelpers.go b/resources/resource_transformers/htesting/testhelpers.go index 674101f033c..22236e87143 100644 --- a/resources/resource_transformers/htesting/testhelpers.go +++ b/resources/resource_transformers/htesting/testhelpers.go @@ -17,6 +17,7 @@ import ( "path/filepath" "github.com/gohugoio/hugo/cache/filecache" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/config" "github.com/gohugoio/hugo/helpers" "github.com/gohugoio/hugo/hugofs" @@ -50,8 +51,9 @@ func NewTestResourceSpec() (*resources.Spec, error) { if err != nil { return nil, err } + memCache := memcache.New(memcache.Config{}) - spec, err := resources.NewSpec(s, filecaches, nil, nil, nil, nil, output.DefaultFormats, media.DefaultTypes) + spec, err := resources.NewSpec(s, filecaches, memCache, nil, nil, nil, nil, output.DefaultFormats, media.DefaultTypes) return spec, err } diff --git a/resources/resource_transformers/js/build.go b/resources/resource_transformers/js/build.go index 12d0dd41028..a741f4e5efa 100644 --- a/resources/resource_transformers/js/build.go +++ b/resources/resource_transformers/js/build.go @@ -27,6 +27,7 @@ import ( "github.com/spf13/afero" "github.com/gohugoio/hugo/hugofs" + "github.com/gohugoio/hugo/identity" "github.com/gohugoio/hugo/common/herrors" @@ -54,8 +55,9 @@ func New(fs *filesystems.SourceFilesystem, rs *resources.Spec) *Client { } type buildTransformation struct { - optsm map[string]interface{} - c *Client + depsManager identity.Manager + optsm map[string]interface{} + c *Client } func (t *buildTransformation) Key() internal.ResourceTransformationKey { @@ -91,7 +93,7 @@ func (t *buildTransformation) Transform(ctx *resources.ResourceTransformationCtx return err } - buildOptions.Plugins, err = createBuildPlugins(t.c, opts) + buildOptions.Plugins, err = createBuildPlugins(t.depsManager, t.c, opts) if err != nil { return err } @@ -206,7 +208,12 @@ func (t *buildTransformation) Transform(ctx *resources.ResourceTransformationCtx // Process process esbuild transform func (c *Client) Process(res resources.ResourceTransformer, opts map[string]interface{}) (resource.Resource, error) { + var depsManager identity.Manager = identity.NopManager + if dmp, ok := res.(identity.DependencyManagerProvider); ok { + depsManager = dmp.GetDependencyManager() + } + return res.Transform( - &buildTransformation{c: c, optsm: opts}, + &buildTransformation{c: c, optsm: opts, depsManager: depsManager}, ) } diff --git a/resources/resource_transformers/js/build_test.go b/resources/resource_transformers/js/build_test.go deleted file mode 100644 index 30a4490edc2..00000000000 --- a/resources/resource_transformers/js/build_test.go +++ /dev/null @@ -1,14 +0,0 @@ -// Copyright 2020 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 js diff --git a/resources/resource_transformers/js/integration_test.go b/resources/resource_transformers/js/integration_test.go new file mode 100644 index 00000000000..2f393d2c8dc --- /dev/null +++ b/resources/resource_transformers/js/integration_test.go @@ -0,0 +1,212 @@ +// Copyright 2021 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 js_test + +import ( + "path/filepath" + "strings" + "testing" + + qt "github.com/frankban/quicktest" + "github.com/gohugoio/hugo/htesting" + "github.com/gohugoio/hugo/hugolib" +) + +func TestBuildVariants(t *testing.T) { + pinnedTestCase := "Edit Import Nested" + tt := htesting.NewPinnedRunner(t, pinnedTestCase) + + mainWithImport := ` +-- config.toml -- +disableKinds=["page", "section", "taxonomy", "term", "sitemap", "robotsTXT"] +-- assets/js/main.js -- +import { hello1, hello2 } from './util1'; +hello1(); +hello2(); +-- assets/js/util1.js -- +import { hello3 } from './util2'; +export function hello1() { + return 'abcd'; +} +export function hello2() { + return hello3(); +} +-- assets/js/util2.js -- +export function hello3() { + return 'efgh'; +} +-- layouts/index.html -- +{{ $js := resources.Get "js/main.js" | js.Build }} +JS Content:{{ $js.Content }}:End: + + ` + + tt.Run("Basic", func(c *qt.C) { + b := hugolib.NewIntegrationTestBuilder(hugolib.IntegrationTestConfig{T: c, NeedsOsFS: true, TxtarString: mainWithImport}).Build() + + b.AssertFileContent("public/index.html", `abcd`) + }) + + tt.Run("Edit Import", func(c *qt.C) { + b := hugolib.NewIntegrationTestBuilder(hugolib.IntegrationTestConfig{T: c, Running: true, NeedsOsFS: true, TxtarString: mainWithImport}).Build() + + b.AssertFileContent("public/index.html", `abcd`) + b.EditFileReplace("assets/js/util1.js", func(s string) string { return strings.ReplaceAll(s, "abcd", "1234") }).Build() + b.AssertFileContent("public/index.html", `1234`) + }) + + tt.Run("Edit Import Nested", func(c *qt.C) { + b := hugolib.NewIntegrationTestBuilder(hugolib.IntegrationTestConfig{T: c, Running: true, NeedsOsFS: true, TxtarString: mainWithImport}).Build() + + b.AssertFileContent("public/index.html", `efgh`) + b.EditFileReplace("assets/js/util2.js", func(s string) string { return strings.ReplaceAll(s, "efgh", "1234") }).Build() + b.AssertFileContent("public/index.html", `1234`) + }) +} + +func TestBuildWithModAndNpm(t *testing.T) { + if !htesting.IsCI() { + t.Skip("skip (relative) long running modules test when running locally") + } + + c := qt.New(t) + + files := ` +-- config.toml -- +baseURL = "https://example.org" +disableKinds=["page", "section", "taxonomy", "term", "sitemap", "robotsTXT"] +[module] +[[module.imports]] +path="github.com/gohugoio/hugoTestProjectJSModImports" +-- go.mod -- +module github.com/gohugoio/tests/testHugoModules + +go 1.16 + +require github.com/gohugoio/hugoTestProjectJSModImports v0.9.0 // indirect +-- package.json -- +{ + "dependencies": { + "date-fns": "^2.16.1" + } +} + +` + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + NeedsOsFS: true, + NeedsNpmInstall: true, + TxtarString: files, + Verbose: true, + }).Build() + + b.AssertFileContent("public/js/main.js", ` +greeting: "greeting configured in mod2" +Hello1 from mod1: $ +return "Hello2 from mod1"; +var Hugo = "Rocks!"; +Hello3 from mod2. Date from date-fns: ${today} +Hello from lib in the main project +Hello5 from mod2. +var myparam = "Hugo Rocks!"; +shim cwd +`) + + // React JSX, verify the shimming. + b.AssertFileContent("public/js/like.js", filepath.FromSlash(`@v0.9.0/assets/js/shims/react.js +module.exports = window.ReactDOM; +`)) +} + +func TestBuildWithNpm(t *testing.T) { + if !htesting.IsCI() { + t.Skip("skip (relative) long running modules test when running locally") + } + + c := qt.New(t) + + files := ` +-- assets/js/included.js -- +console.log("included"); +-- assets/js/main.js -- +import "./included"; + import { toCamelCase } from "to-camel-case"; + + console.log("main"); + console.log("To camel:", toCamelCase("space case")); +-- assets/js/myjsx.jsx -- +import * as React from 'react' +import * as ReactDOM from 'react-dom' + + ReactDOM.render( +

Hello, world!

, + document.getElementById('root') + ); +-- assets/js/myts.ts -- +function greeter(person: string) { + return "Hello, " + person; +} +let user = [0, 1, 2]; +document.body.textContent = greeter(user); +-- config.toml -- +disablekinds = ['taxonomy', 'term', 'page'] +-- content/p1.md -- +Content. +-- data/hugo.toml -- +slogan = "Hugo Rocks!" +-- i18n/en.yaml -- +hello: + other: "Hello" +-- i18n/fr.yaml -- +hello: + other: "Bonjour" +-- layouts/index.html -- +{{ $options := dict "minify" false "externals" (slice "react" "react-dom") }} +{{ $js := resources.Get "js/main.js" | js.Build $options }} +JS: {{ template "print" $js }} +{{ $jsx := resources.Get "js/myjsx.jsx" | js.Build $options }} +JSX: {{ template "print" $jsx }} +{{ $ts := resources.Get "js/myts.ts" | js.Build (dict "sourcemap" "inline")}} +TS: {{ template "print" $ts }} +{{ $ts2 := resources.Get "js/myts.ts" | js.Build (dict "sourcemap" "external" "TargetPath" "js/myts2.js")}} +TS2: {{ template "print" $ts2 }} +{{ define "print" }}RelPermalink: {{.RelPermalink}}|MIME: {{ .MediaType }}|Content: {{ .Content | safeJS }}{{ end }} +-- package.json -- +{ + "scripts": {}, + + "dependencies": { + "to-camel-case": "1.0.0" + } +} +` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + NeedsOsFS: true, + NeedsNpmInstall: true, + TxtarString: files, + }).Build() + + b.AssertFileContent("public/js/myts.js", `//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJz`) + b.AssertFileContent("public/js/myts2.js.map", `"version": 3,`) + b.AssertFileContent("public/index.html", ` + console.log("included"); + if (hasSpace.test(string)) + var React = __toESM(__require("react")); + function greeter(person) { +`) +} diff --git a/resources/resource_transformers/js/options.go b/resources/resource_transformers/js/options.go index 9d2bb2e7086..5780700b0f6 100644 --- a/resources/resource_transformers/js/options.go +++ b/resources/resource_transformers/js/options.go @@ -20,7 +20,9 @@ import ( "path/filepath" "strings" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/common/maps" + "github.com/gohugoio/hugo/identity" "github.com/pkg/errors" "github.com/spf13/afero" @@ -192,7 +194,7 @@ func resolveComponentInAssets(fs afero.Fs, impPath string) *hugofs.FileMeta { return m } -func createBuildPlugins(c *Client, opts Options) ([]api.Plugin, error) { +func createBuildPlugins(depsManager identity.Manager, c *Client, opts Options) ([]api.Plugin, error) { fs := c.rs.Assets resolveImport := func(args api.OnResolveArgs) (api.OnResolveResult, error) { @@ -227,6 +229,10 @@ func createBuildPlugins(c *Client, opts Options) ([]api.Plugin, error) { m := resolveComponentInAssets(fs.Fs, impPath) if m != nil { + // TODO1 key + importID := identity.StringIdentity("/" + memcache.CleanKey(strings.TrimPrefix(m.PathFile(), m.Component))) + depsManager.AddIdentity(importID) + // Store the source root so we can create a jsconfig.json // to help intellisense when the build is done. // This should be a small number of elements, and when diff --git a/resources/resource_transformers/minifier/integration_test.go b/resources/resource_transformers/minifier/integration_test.go new file mode 100644 index 00000000000..fb4cc7a656f --- /dev/null +++ b/resources/resource_transformers/minifier/integration_test.go @@ -0,0 +1,47 @@ +// Copyright 2021 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 minifier_test + +import ( + "testing" + + qt "github.com/frankban/quicktest" + "github.com/gohugoio/hugo/hugolib" +) + +// Issue 8954 +func TestTransformMinify(t *testing.T) { + c := qt.New(t) + + files := ` +-- assets/js/test.js -- +new Date(2002, 04, 11) +-- config.toml -- +-- layouts/index.html -- +{{ $js := resources.Get "js/test.js" | minify }} + +` + + b, err := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + }, + ).BuildE() + + b.Assert(err, qt.IsNotNil) + b.Assert(err, qt.ErrorMatches, "(?s).*legacy octal numbers.*line 1.*") +} diff --git a/resources/resource_transformers/postcss/integration_test.go b/resources/resource_transformers/postcss/integration_test.go new file mode 100644 index 00000000000..5bb1a9ffe1e --- /dev/null +++ b/resources/resource_transformers/postcss/integration_test.go @@ -0,0 +1,148 @@ +// Copyright 2021 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 postcss_test + +import ( + "fmt" + "path/filepath" + "strings" + "testing" + + jww "github.com/spf13/jwalterweatherman" + + qt "github.com/frankban/quicktest" + "github.com/gohugoio/hugo/htesting" + "github.com/gohugoio/hugo/hugolib" +) + +func TestTransformPostCSS(t *testing.T) { + if !htesting.IsCI() { + t.Skip("Skip long running test when running locally") + } + + c := qt.New(t) + + files := ` +-- assets/css/components/a.css -- +class-in-a { + color: blue; +} + +-- assets/css/components/all.css -- +@import "a.css"; +@import "b.css"; +-- assets/css/components/b.css -- +@import "a.css"; + +class-in-b { + color: blue; +} + +-- assets/css/styles.css -- +@tailwind base; +@tailwind components; +@tailwind utilities; +@import "components/all.css"; +h1 { + @apply text-2xl font-bold; +} + +-- config.toml -- +disablekinds = ['taxonomy', 'term', 'page'] +-- content/p1.md -- +-- data/hugo.toml -- +slogan = "Hugo Rocks!" +-- i18n/en.yaml -- +hello: + other: "Hello" +-- i18n/fr.yaml -- +hello: + other: "Bonjour" +-- layouts/index.html -- +{{ $options := dict "inlineImports" true }} +{{ $styles := resources.Get "css/styles.css" | resources.PostCSS $options }} +Styles RelPermalink: {{ $styles.RelPermalink }} +{{ $cssContent := $styles.Content }} +Styles Content: Len: {{ len $styles.Content }}| +-- package.json -- +{ + "scripts": {}, + + "devDependencies": { + "postcss-cli": "7.1.0", + "tailwindcss": "1.2.0" + } +} +-- postcss.config.js -- +console.error("Hugo Environment:", process.env.HUGO_ENVIRONMENT ); +// https://github.com/gohugoio/hugo/issues/7656 +console.error("package.json:", process.env.HUGO_FILE_PACKAGE_JSON ); +console.error("PostCSS Config File:", process.env.HUGO_FILE_POSTCSS_CONFIG_JS ); + +module.exports = { + plugins: [ + require('tailwindcss') + ] +} + +` + + c.Run("Success", func(c *qt.C) { + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + NeedsOsFS: true, + NeedsNpmInstall: true, + LogLevel: jww.LevelInfo, + TxtarString: files, + }).Build() + + b.AssertLogContains("Hugo Environment: production") + b.AssertLogContains(filepath.FromSlash(fmt.Sprintf("PostCSS Config File: %s/postcss.config.js", b.Cfg.WorkingDir))) + b.AssertLogContains(filepath.FromSlash(fmt.Sprintf("package.json: %s/package.json", b.Cfg.WorkingDir))) + + b.AssertFileContent("public/index.html", ` +Styles RelPermalink: /css/styles.css +Styles Content: Len: 770875| +`) + }) + + c.Run("Error", func(c *qt.C) { + s, err := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + NeedsOsFS: true, + NeedsNpmInstall: true, + TxtarString: strings.ReplaceAll(files, "color: blue;", "@apply foo;"), // Syntax error + }).BuildE() + s.AssertIsFileError(err) + }) +} + +// bookmark2 +func TestIntegrationTestTemplate(t *testing.T) { + c := qt.New(t) + + files := `` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + NeedsOsFS: false, + NeedsNpmInstall: false, + TxtarString: files, + }).Build() + + b.Assert(true, qt.IsTrue) +} diff --git a/resources/resource_transformers/templates/integration_test.go b/resources/resource_transformers/templates/integration_test.go new file mode 100644 index 00000000000..685a9ba30bd --- /dev/null +++ b/resources/resource_transformers/templates/integration_test.go @@ -0,0 +1,79 @@ +// Copyright 2021 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 templates_test + +import ( + "testing" + + qt "github.com/frankban/quicktest" + + "github.com/gohugoio/hugo/hugolib" +) + +func TestExecuteAsTemplateMultipleLanguages(t *testing.T) { + c := qt.New(t) + + files := ` +-- config.toml -- +baseURL = "http://example.com/blog" +defaultContentLanguage = "fr" +defaultContentLanguageInSubdir = true +[Languages] +[Languages.en] +weight = 10 +title = "In English" +languageName = "English" +[Languages.fr] +weight = 20 +title = "Le Français" +languageName = "Français" +-- i18n/en.toml -- +[hello] +other = "Hello" +-- i18n/fr.toml -- +[hello] +other = "Bonjour" +-- layouts/index.fr.html -- +Lang: {{ site.Language.Lang }} +{{ $templ := "{{T \"hello\"}}" | resources.FromString "f1.html" }} +{{ $helloResource := $templ | resources.ExecuteAsTemplate (print "f%s.html" .Lang) . }} +Hello1: {{T "hello"}} +Hello2: {{ $helloResource.Content }} +LangURL: {{ relLangURL "foo" }} +-- layouts/index.html -- +Lang: {{ site.Language.Lang }} +{{ $templ := "{{T \"hello\"}}" | resources.FromString "f1.html" }} +{{ $helloResource := $templ | resources.ExecuteAsTemplate (print "f%s.html" .Lang) . }} +Hello1: {{T "hello"}} +Hello2: {{ $helloResource.Content }} +LangURL: {{ relLangURL "foo" }} + + ` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + }).Build() + + b.AssertFileContent("public/en/index.html", ` + Hello1: Hello + Hello2: Hello + `) + + b.AssertFileContent("public/fr/index.html", ` + Hello1: Bonjour + Hello2: Bonjour + `) +} diff --git a/resources/resource_transformers/tocss/dartsass/integration_test.go b/resources/resource_transformers/tocss/dartsass/integration_test.go new file mode 100644 index 00000000000..c1616f68421 --- /dev/null +++ b/resources/resource_transformers/tocss/dartsass/integration_test.go @@ -0,0 +1,173 @@ +// Copyright 2021 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 dartsass_test + +import ( + "testing" + + qt "github.com/frankban/quicktest" + + "github.com/gohugoio/hugo/hugolib" + "github.com/gohugoio/hugo/resources/resource_transformers/tocss/dartsass" +) + +func TestTransformIncludePaths(t *testing.T) { + if !dartsass.Supports() { + t.Skip() + } + + c := qt.New(t) + + files := ` +-- assets/scss/main.scss -- +@import "moo"; +-- node_modules/foo/_moo.scss -- +$moolor: #fff; + +moo { + color: $moolor; +} +-- config.toml -- +-- layouts/index.html -- +{{ $cssOpts := (dict "includePaths" (slice "node_modules/foo") "transpiler" "dartsass" ) }} +{{ $r := resources.Get "scss/main.scss" | toCSS $cssOpts | minify }} +T1: {{ $r.Content }} + ` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + NeedsOsFS: true, + }).Build() + + b.AssertFileContent("public/index.html", `T1: moo{color:#fff}`) +} + +func TestTransformImportRegularCSS(t *testing.T) { + if !dartsass.Supports() { + t.Skip() + } + c := qt.New(t) + + files := ` +-- assets/scss/_moo.scss -- +$moolor: #fff; + +moo { + color: $moolor; +} +-- assets/scss/another.css -- + +-- assets/scss/main.scss -- +@import "moo"; +@import "regular.css"; +@import "moo"; +@import "another.css"; + +/* foo */ +-- assets/scss/regular.css -- + +-- config.toml -- +-- layouts/index.html -- +{{ $r := resources.Get "scss/main.scss" | toCSS (dict "transpiler" "dartsass") }} +T1: {{ $r.Content | safeHTML }} + + ` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + NeedsOsFS: true, + }, + ).Build() + + // Dart Sass does not follow regular CSS import, but they + // get pulled to the top. + b.AssertFileContent("public/index.html", `T1: @import "regular.css"; + @import "another.css"; + moo { + color: #fff; + } + + moo { + color: #fff; + } + + /* foo */`) +} + +func TestTransformThemeOverrides(t *testing.T) { + if !dartsass.Supports() { + t.Skip() + } + + c := qt.New(t) + + files := ` +-- assets/scss/components/_boo.scss -- +$boolor: green; + +boo { + color: $boolor; +} +-- assets/scss/components/_moo.scss -- +$moolor: #ccc; + +moo { + color: $moolor; +} +-- config.toml -- +theme = 'mytheme' +-- layouts/index.html -- +{{ $cssOpts := (dict "includePaths" (slice "node_modules/foo" ) "transpiler" "dartsass" ) }} +{{ $r := resources.Get "scss/main.scss" | toCSS $cssOpts | minify }} +T1: {{ $r.Content }} +-- themes/mytheme/assets/scss/components/_boo.scss -- +$boolor: orange; + +boo { + color: $boolor; +} +-- themes/mytheme/assets/scss/components/_imports.scss -- +@import "moo"; +@import "_boo"; +@import "_zoo"; +-- themes/mytheme/assets/scss/components/_moo.scss -- +$moolor: #fff; + +moo { + color: $moolor; +} +-- themes/mytheme/assets/scss/components/_zoo.scss -- +$zoolor: pink; + +zoo { + color: $zoolor; +} +-- themes/mytheme/assets/scss/main.scss -- +@import "components/imports"; + ` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + NeedsOsFS: true, + }, + ).Build() + + b.AssertFileContent("public/index.html", `T1: moo{color:#ccc}boo{color:green}zoo{color:pink}`) +} diff --git a/resources/resource_transformers/tocss/scss/integration_test.go b/resources/resource_transformers/tocss/scss/integration_test.go new file mode 100644 index 00000000000..cbc7e192bc2 --- /dev/null +++ b/resources/resource_transformers/tocss/scss/integration_test.go @@ -0,0 +1,173 @@ +// Copyright 2021 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 scss_test + +import ( + "testing" + + qt "github.com/frankban/quicktest" + + "github.com/gohugoio/hugo/hugolib" + "github.com/gohugoio/hugo/resources/resource_transformers/tocss/scss" +) + +func TestTransformIncludePaths(t *testing.T) { + if !scss.Supports() { + t.Skip() + } + c := qt.New(t) + + files := ` +-- assets/scss/main.scss -- +@import "moo"; +-- node_modules/foo/_moo.scss -- +$moolor: #fff; + +moo { + color: $moolor; +} +-- config.toml -- +-- layouts/index.html -- +{{ $cssOpts := (dict "includePaths" (slice "node_modules/foo") ) }} +{{ $r := resources.Get "scss/main.scss" | toCSS $cssOpts | minify }} +T1: {{ $r.Content }} + ` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + NeedsOsFS: true, + }).Build() + + b.AssertFileContent("public/index.html", `T1: moo{color:#fff}`) +} + +func TestTransformImportRegularCSS(t *testing.T) { + if !scss.Supports() { + t.Skip() + } + + c := qt.New(t) + + files := ` +-- assets/scss/_moo.scss -- +$moolor: #fff; + +moo { + color: $moolor; +} +-- assets/scss/another.css -- + +-- assets/scss/main.scss -- +@import "moo"; +@import "regular.css"; +@import "moo"; +@import "another.css"; + +/* foo */ +-- assets/scss/regular.css -- + +-- config.toml -- +-- layouts/index.html -- +{{ $r := resources.Get "scss/main.scss" | toCSS }} +T1: {{ $r.Content | safeHTML }} + + ` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + NeedsOsFS: true, + }).Build() + + // LibSass does not support regular CSS imports. There + // is an open bug about it that probably will never be resolved. + // Hugo works around this by preserving them in place: + b.AssertFileContent("public/index.html", ` + T1: moo { + color: #fff; } + +@import "regular.css"; +moo { + color: #fff; } + +@import "another.css"; +/* foo */ + +`) +} + +func TestTransformThemeOverrides(t *testing.T) { + if !scss.Supports() { + t.Skip() + } + + c := qt.New(t) + + files := ` +-- assets/scss/components/_boo.scss -- +$boolor: green; + +boo { + color: $boolor; +} +-- assets/scss/components/_moo.scss -- +$moolor: #ccc; + +moo { + color: $moolor; +} +-- config.toml -- +theme = 'mytheme' +-- layouts/index.html -- +{{ $cssOpts := (dict "includePaths" (slice "node_modules/foo" ) "transpiler" "dartsass" ) }} +{{ $r := resources.Get "scss/main.scss" | toCSS $cssOpts | minify }} +T1: {{ $r.Content }} +-- themes/mytheme/assets/scss/components/_boo.scss -- +$boolor: orange; + +boo { + color: $boolor; +} +-- themes/mytheme/assets/scss/components/_imports.scss -- +@import "moo"; +@import "_boo"; +@import "_zoo"; +-- themes/mytheme/assets/scss/components/_moo.scss -- +$moolor: #fff; + +moo { + color: $moolor; +} +-- themes/mytheme/assets/scss/components/_zoo.scss -- +$zoolor: pink; + +zoo { + color: $zoolor; +} +-- themes/mytheme/assets/scss/main.scss -- +@import "components/imports"; + ` + + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + TxtarString: files, + NeedsOsFS: true, + }).Build() + + b.AssertFileContent("public/index.html", `T1: moo{color:#ccc}boo{color:green}zoo{color:pink}`) +} diff --git a/resources/testhelpers_test.go b/resources/testhelpers_test.go index 14d431644df..a93cd0c7f05 100644 --- a/resources/testhelpers_test.go +++ b/resources/testhelpers_test.go @@ -11,6 +11,10 @@ import ( "testing" "github.com/gohugoio/hugo/config" + "github.com/gohugoio/hugo/identity" + + "github.com/gohugoio/hugo/cache/memcache" + "github.com/gohugoio/hugo/langs" "github.com/gohugoio/hugo/modules" @@ -87,7 +91,9 @@ func newTestResourceSpec(desc specDescriptor) *Spec { filecaches, err := filecache.NewCaches(s) c.Assert(err, qt.IsNil) - spec, err := NewSpec(s, filecaches, nil, nil, nil, nil, output.DefaultFormats, media.DefaultTypes) + mc := memcache.New(memcache.Config{}) + + spec, err := NewSpec(s, filecaches, mc, nil, nil, nil, nil, output.DefaultFormats, media.DefaultTypes) c.Assert(err, qt.IsNil) return spec } @@ -126,7 +132,7 @@ func newTestResourceOsFs(c *qt.C) (*Spec, string) { filecaches, err := filecache.NewCaches(s) c.Assert(err, qt.IsNil) - spec, err := NewSpec(s, filecaches, nil, nil, nil, nil, output.DefaultFormats, media.DefaultTypes) + spec, err := NewSpec(s, filecaches, memcache.New(memcache.Config{}), nil, nil, nil, nil, output.DefaultFormats, media.DefaultTypes) c.Assert(err, qt.IsNil) return spec, workDir @@ -203,3 +209,23 @@ func writeToFs(t testing.TB, fs afero.Fs, filename, content string) { t.Fatalf("Failed to write file: %s", err) } } + +func newGenericResource(r *Spec, sourceFs afero.Fs, + targetPathBuilder func() page.TargetPaths, + osFileInfo os.FileInfo, + sourceFilename, + baseFilename string, + mediaType media.Type) *genericResource { + return r.newGenericResourceWithBase( + identity.NopManager, + identity.NopManager, + sourceFs, + nil, + nil, + targetPathBuilder, + osFileInfo, + sourceFilename, + baseFilename, + mediaType, + ) +} diff --git a/resources/transform.go b/resources/transform.go index 0569fb35e2a..38207c81344 100644 --- a/resources/transform.go +++ b/resources/transform.go @@ -15,22 +15,27 @@ package resources import ( "bytes" + "context" "fmt" "image" "io" "path" + "path/filepath" "strings" "sync" + "github.com/gohugoio/hugo/cache/memcache" + "github.com/gohugoio/hugo/identity" + "github.com/gohugoio/hugo/common/paths" "github.com/pkg/errors" + bp "github.com/gohugoio/hugo/bufferpool" + "github.com/gohugoio/hugo/common/types" "github.com/gohugoio/hugo/resources/images/exif" "github.com/spf13/afero" - bp "github.com/gohugoio/hugo/bufferpool" - "github.com/gohugoio/hugo/common/herrors" "github.com/gohugoio/hugo/common/hugio" "github.com/gohugoio/hugo/common/maps" @@ -45,9 +50,11 @@ var ( _ resource.ContentResource = (*resourceAdapter)(nil) _ resource.ReadSeekCloserResource = (*resourceAdapter)(nil) _ resource.Resource = (*resourceAdapter)(nil) + _ resource.Staler = (*resourceAdapterInner)(nil) _ resource.Source = (*resourceAdapter)(nil) - _ resource.Identifier = (*resourceAdapter)(nil) + _ types.Identifier = (*resourceAdapter)(nil) _ resource.ResourceMetaProvider = (*resourceAdapter)(nil) + _ identity.IdentityGroupProvider = (*resourceAdapter)(nil) ) // These are transformations that need special support in Hugo that may not @@ -65,10 +72,15 @@ func newResourceAdapter(spec *Spec, lazyPublish bool, target transformableResour if lazyPublish { po = &publishOnce{} } + + s := &staler{} + return &resourceAdapter{ resourceTransformations: &resourceTransformations{}, + Staler: s, resourceAdapterInner: &resourceAdapterInner{ spec: spec, + Staler: s, publishOnce: po, target: target, }, @@ -153,10 +165,16 @@ type publishOnce struct { publisherErr error } +var _ identity.DependencyManagerProvider = (*resourceAdapter)(nil) + type resourceAdapter struct { commonResource *resourceTransformations *resourceAdapterInner + + // This state is carried over into any clone of this adapter (when passed + // through a Hugo pipe), so marking one of them as stale will mark all. + resource.Staler } func (r *resourceAdapter) Content() (interface{}, error) { @@ -198,7 +216,7 @@ func (r *resourceAdapter) Exif() *exif.Exif { func (r *resourceAdapter) Key() string { r.init(false, false) - return r.target.(resource.Identifier).Key() + return r.TransformationKey() } func (r *resourceAdapter) MediaType() media.Type { @@ -246,6 +264,14 @@ func (r *resourceAdapter) ResourceType() string { return r.target.ResourceType() } +func (r *resourceAdapter) GetIdentityGroup() identity.Identity { + return r.target.GetIdentityGroup() +} + +func (r *resourceAdapter) GetDependencyManager() identity.Manager { + return r.target.GetDependencyManager() +} + func (r *resourceAdapter) String() string { return r.Name() } @@ -262,6 +288,7 @@ func (r resourceAdapter) Transform(t ...ResourceTransformation) (ResourceTransfo r.resourceAdapterInner = &resourceAdapterInner{ spec: r.spec, + Staler: r.Staler, publishOnce: &publishOnce{}, target: r.target, } @@ -309,6 +336,57 @@ func (r *resourceAdapter) publish() { } func (r *resourceAdapter) TransformationKey() string { + r.transformationsKeyInit.Do(func() { + if len(r.transformations) == 0 { + r.transformationsKey = r.target.Key() + return + } + + var adder string + for _, tr := range r.transformations { + adder = adder + "_" + tr.Key().Value() + } + + key := r.target.Key() + adder = "_" + helpers.MD5String(adder) + + // Preserve any file extension if possible. + dotIdx := strings.LastIndex(key, ".") + if dotIdx == -1 { + key += adder + } else { + key = key[:dotIdx] + adder + key[dotIdx:] + } + + key = memcache.CleanKey(key) + r.transformationsKey = key + }) + + return r.transformationsKey +} + +// We changed the format of the resource cache keys in Hugo v0.90. +// To reduce the nois, especially on the theme site, we fall back to reading +// files on the old format. +// TODO(bep) eventually remove. +func (r *resourceAdapter) transformationKeyV090() string { + cleanKey := func(key string) string { + return strings.TrimPrefix(path.Clean(strings.ToLower(key)), "/") + } + + resourceKeyPartition := func(filename string) string { + ext := strings.TrimPrefix(path.Ext(filepath.ToSlash(filename)), ".") + if ext == "" { + ext = "other" + } + return ext + } + + resourceCacheKey := func(filename string) string { + filename = filepath.ToSlash(filename) + return path.Join(resourceKeyPartition(filename), filename) + } + // Files with a suffix will be stored in cache (both on disk and in memory) // partitioned by their suffix. var key string @@ -316,35 +394,31 @@ func (r *resourceAdapter) TransformationKey() string { key = key + "_" + tr.Key().Value() } - base := ResourceCacheKey(r.target.Key()) - return r.spec.ResourceCache.cleanKey(base) + "_" + helpers.MD5String(key) + base := resourceCacheKey(r.target.RelPermalink()) + return cleanKey(base) + "_" + helpers.MD5String(key) } -func (r *resourceAdapter) transform(publish, setContent bool) error { - cache := r.spec.ResourceCache - +func (r *resourceAdapter) getOrTransform(publish, setContent bool) error { key := r.TransformationKey() - - cached, found := cache.get(key) - - if found { - r.resourceAdapterInner = cached.(*resourceAdapterInner) - return nil + res, err := r.spec.ResourceCache.cache.GetOrCreate(context.TODO(), key, func() memcache.Entry { + r, err := r.transform(key, publish, setContent) + return memcache.Entry{ + Value: r, + Err: err, + ClearWhen: memcache.ClearOnChange, + } + }) + if err != nil { + return err } - // Acquire a write lock for the named transformation. - cache.nlocker.Lock(key) - // Check the cache again. - cached, found = cache.get(key) - if found { - r.resourceAdapterInner = cached.(*resourceAdapterInner) - cache.nlocker.Unlock(key) - return nil - } + r.resourceAdapterInner = res.(*resourceAdapterInner) - defer cache.nlocker.Unlock(key) - defer cache.set(key, r.resourceAdapterInner) + return nil +} +func (r *resourceAdapter) transform(key string, publish, setContent bool) (*resourceAdapterInner, error) { + cache := r.spec.ResourceCache b1 := bp.GetBuffer() b2 := bp.GetBuffer() defer bp.PutBuffer(b1) @@ -365,7 +439,7 @@ func (r *resourceAdapter) transform(publish, setContent bool) error { contentrc, err := contentReadSeekerCloser(r.target) if err != nil { - return err + return nil, err } defer contentrc.Close() @@ -419,9 +493,6 @@ func (r *resourceAdapter) transform(publish, setContent bool) error { errMsg = ". Check your PostCSS installation; install with \"npm install postcss-cli\". See https://gohugo.io/hugo-pipes/postcss/" } else if tr.Key().Name == "tocss" { errMsg = ". Check your Hugo installation; you need the extended version to build SCSS/SASS." - } else if tr.Key().Name == "tocss-dart" { - errMsg = ". You need dart-sass-embedded in your system $PATH." - } else if tr.Key().Name == "babel" { errMsg = ". You need to install Babel, see https://gohugo.io/hugo-pipes/babel/" } @@ -439,24 +510,25 @@ func (r *resourceAdapter) transform(publish, setContent bool) error { } else { err = tr.Transform(tctx) if err != nil && err != herrors.ErrFeatureNotAvailable { - return newErr(err) + return nil, newErr(err) } if mayBeCachedOnDisk { tryFileCache = r.spec.BuildConfig.UseResourceCache(err) } if err != nil && !tryFileCache { - return newErr(err) + return nil, newErr(err) } } if tryFileCache { f := r.target.tryTransformedFileCache(key, updates) if f == nil { - if err != nil { - return newErr(err) + keyOldFormat := r.transformationKeyV090() + f = r.target.tryTransformedFileCache(keyOldFormat, updates) + if f == nil { + return nil, newErr(errors.Errorf("resource %q not found in file cache", key)) } - return newErr(errors.Errorf("resource %q not found in file cache", key)) } transformedContentr = f updates.sourceFs = cache.fileCache.Fs @@ -481,7 +553,7 @@ func (r *resourceAdapter) transform(publish, setContent bool) error { if publish { publicw, err := r.target.openPublishFileForWriting(updates.targetPath) if err != nil { - return err + return nil, err } publishwriters = append(publishwriters, publicw) } @@ -491,7 +563,7 @@ func (r *resourceAdapter) transform(publish, setContent bool) error { // Also write it to the cache fi, metaw, err := cache.writeMeta(key, updates.toTransformedResourceMetadata()) if err != nil { - return err + return nil, err } updates.sourceFilename = &fi.Name updates.sourceFs = cache.fileCache.Fs @@ -522,7 +594,7 @@ func (r *resourceAdapter) transform(publish, setContent bool) error { publishw := hugio.NewMultiWriteCloser(publishwriters...) _, err = io.Copy(publishw, transformedContentr) if err != nil { - return err + return nil, err } publishw.Close() @@ -533,11 +605,11 @@ func (r *resourceAdapter) transform(publish, setContent bool) error { newTarget, err := r.target.cloneWithUpdates(updates) if err != nil { - return err + return nil, err } r.target = newTarget - return nil + return r.resourceAdapterInner, nil } func (r *resourceAdapter) init(publish, setContent bool) { @@ -557,7 +629,7 @@ func (r *resourceAdapter) initTransform(publish, setContent bool) { r.publishOnce = nil } - r.transformationsErr = r.transform(publish, setContent) + r.transformationsErr = r.getOrTransform(publish, setContent) if r.transformationsErr != nil { if r.spec.ErrorSender != nil { r.spec.ErrorSender.SendError(r.transformationsErr) @@ -575,6 +647,8 @@ func (r *resourceAdapter) initTransform(publish, setContent bool) { type resourceAdapterInner struct { target transformableResource + resource.Staler + spec *Spec // Handles publishing (to /public) if needed. @@ -582,9 +656,11 @@ type resourceAdapterInner struct { } type resourceTransformations struct { - transformationsInit sync.Once - transformationsErr error - transformations []ResourceTransformation + transformationsInit sync.Once + transformationsErr error + transformationsKeyInit sync.Once + transformationsKey string + transformations []ResourceTransformation } type transformableResource interface { @@ -592,7 +668,9 @@ type transformableResource interface { resource.ContentProvider resource.Resource - resource.Identifier + types.Identifier + identity.IdentityGroupProvider + identity.DependencyManagerProvider } type transformationUpdate struct { diff --git a/source/fileInfo.go b/source/fileInfo.go index 606b8b02572..abc541d1bd9 100644 --- a/source/fileInfo.go +++ b/source/fileInfo.go @@ -14,16 +14,12 @@ package source import ( + "errors" "path/filepath" - "strings" "sync" "github.com/gohugoio/hugo/common/paths" - "github.com/gohugoio/hugo/hugofs/files" - - "github.com/pkg/errors" - "github.com/gohugoio/hugo/common/hugio" "github.com/gohugoio/hugo/hugofs" @@ -31,262 +27,135 @@ import ( "github.com/gohugoio/hugo/helpers" ) -// fileInfo implements the File interface. -var ( - _ File = (*FileInfo)(nil) -) - -// File represents a source file. -// This is a temporary construct until we resolve page.Page conflicts. -// TODO(bep) remove this construct once we have resolved page deprecations -type File interface { - fileOverlap - FileWithoutOverlap -} - -// Temporary to solve duplicate/deprecated names in page.Page -type fileOverlap interface { - // Path gets the relative path including file name and extension. - // The directory is relative to the content root. - Path() string - - // Section is first directory below the content root. - // For page bundles in root, the Section will be empty. - Section() string - - // Lang is the language code for this page. It will be the - // same as the site's language code. - Lang() string - - IsZero() bool -} - -type FileWithoutOverlap interface { - - // Filename gets the full path and filename to the file. - Filename() string - - // Dir gets the name of the directory that contains this file. - // The directory is relative to the content root. - Dir() string - - // Extension gets the file extension, i.e "myblogpost.md" will return "md". - Extension() string - - // Ext is an alias for Extension. - Ext() string // Hmm... Deprecate Extension - - // LogicalName is filename and extension of the file. - LogicalName() string - - // BaseFileName is a filename without extension. - BaseFileName() string - - // TranslationBaseName is a filename with no extension, - // not even the optional language extension part. - TranslationBaseName() string - - // ContentBaseName is a either TranslationBaseName or name of containing folder - // if file is a leaf bundle. - ContentBaseName() string - - // UniqueID is the MD5 hash of the file's path and is for most practical applications, - // Hugo content files being one of them, considered to be unique. - UniqueID() string - - FileInfo() hugofs.FileMetaInfo -} - -// FileInfo describes a source file. -type FileInfo struct { +// File describes a source file. +type File struct { + sp *SourceSpec // Absolute filename to the file on disk. filename string - sp *SourceSpec - - fi hugofs.FileMetaInfo - - // Derived from filename - ext string // Extension without any "." - lang string - - name string - - dir string - relDir string - relPath string - baseName string - translationBaseName string - contentBaseName string - section string - classifier files.ContentClass + fim hugofs.FileMetaInfo uniqueID string - lazyInit sync.Once } // Filename returns a file's absolute path and filename on disk. -func (fi *FileInfo) Filename() string { return fi.filename } +func (fi *File) Filename() string { return fi.fim.Meta().Filename } // Path gets the relative path including file name and extension. The directory // is relative to the content root. -func (fi *FileInfo) Path() string { return fi.relPath } +func (fi *File) Path() string { return filepath.Join(fi.p().Dir()[1:], fi.p().Name()) } // Dir gets the name of the directory that contains this file. The directory is // relative to the content root. -func (fi *FileInfo) Dir() string { return fi.relDir } +func (fi *File) Dir() string { + return fi.pathToDir(fi.p().Dir()) +} // Extension is an alias to Ext(). -func (fi *FileInfo) Extension() string { return fi.Ext() } +func (fi *File) Extension() string { + helpers.Deprecated(".File.Extension()", "Use .File.Ext()", false) + return fi.Ext() +} -// Ext returns a file's extension without the leading period (ie. "md"). -func (fi *FileInfo) Ext() string { return fi.ext } +// Ext returns a file's extension without the leading period (e.g. "md"). +// Deprecated: Use Extension() instead. +func (fi *File) Ext() string { return fi.p().Ext() } -// Lang returns a file's language (ie. "sv"). -func (fi *FileInfo) Lang() string { return fi.lang } +// Lang returns a file's language (e.g. "sv"). +func (fi *File) Lang() string { return fi.p().Lang() } -// LogicalName returns a file's name and extension (ie. "page.sv.md"). -func (fi *FileInfo) LogicalName() string { return fi.name } +// LogicalName returns a file's name and extension (e.g. "page.sv.md"). +func (fi *File) LogicalName() string { + return fi.p().Name() +} -// BaseFileName returns a file's name without extension (ie. "page.sv"). -func (fi *FileInfo) BaseFileName() string { return fi.baseName } +// BaseFileName returns a file's name without extension (e.g. "page.sv"). +func (fi *File) BaseFileName() string { + return fi.p().NameNoExt() +} // TranslationBaseName returns a file's translation base name without the -// language segment (ie. "page"). -func (fi *FileInfo) TranslationBaseName() string { return fi.translationBaseName } +// language segment (e.g. "page"). +func (fi *File) TranslationBaseName() string { return fi.p().NameNoIdentifier() } // ContentBaseName is a either TranslationBaseName or name of containing folder -// if file is a leaf bundle. -func (fi *FileInfo) ContentBaseName() string { - fi.init() - return fi.contentBaseName +// if file is a bundle. +func (fi *File) ContentBaseName() string { + if fi.p().IsBundle() { + return fi.p().Container() + } + return fi.p().NameNoIdentifier() } // Section returns a file's section. -func (fi *FileInfo) Section() string { - fi.init() - return fi.section +func (fi *File) Section() string { + return fi.p().Section() } // UniqueID returns a file's unique, MD5 hash identifier. -func (fi *FileInfo) UniqueID() string { +func (fi *File) UniqueID() string { fi.init() return fi.uniqueID } // FileInfo returns a file's underlying os.FileInfo. -func (fi *FileInfo) FileInfo() hugofs.FileMetaInfo { return fi.fi } +func (fi *File) FileInfo() hugofs.FileMetaInfo { return fi.fim } -func (fi *FileInfo) String() string { return fi.BaseFileName() } +func (fi *File) String() string { return fi.BaseFileName() } // Open implements ReadableFile. -func (fi *FileInfo) Open() (hugio.ReadSeekCloser, error) { - f, err := fi.fi.Meta().Open() +func (fi *File) Open() (hugio.ReadSeekCloser, error) { + f, err := fi.fim.Meta().Open() return f, err } -func (fi *FileInfo) IsZero() bool { +func (fi *File) IsZero() bool { return fi == nil } // We create a lot of these FileInfo objects, but there are parts of it used only // in some cases that is slightly expensive to construct. -func (fi *FileInfo) init() { +func (fi *File) init() { fi.lazyInit.Do(func() { - relDir := strings.Trim(fi.relDir, helpers.FilePathSeparator) - parts := strings.Split(relDir, helpers.FilePathSeparator) - var section string - if (fi.classifier != files.ContentClassLeaf && len(parts) == 1) || len(parts) > 1 { - section = parts[0] - } - fi.section = section - - if fi.classifier.IsBundle() && len(parts) > 0 { - fi.contentBaseName = parts[len(parts)-1] - } else { - fi.contentBaseName = fi.translationBaseName - } - - fi.uniqueID = helpers.MD5String(filepath.ToSlash(fi.relPath)) + fi.uniqueID = helpers.MD5String(filepath.ToSlash(fi.Path())) }) } -// NewTestFile creates a partially filled File used in unit tests. -// TODO(bep) improve this package -func NewTestFile(filename string) *FileInfo { - base := filepath.Base(filepath.Dir(filename)) - return &FileInfo{ - filename: filename, - translationBaseName: base, +func (fi *File) pathToDir(s string) string { + if s == "" { + return s } + return filepath.FromSlash(s[1:] + "/") +} + +func (fi *File) p() *paths.Path { + return fi.fim.Meta().PathInfo } -func (sp *SourceSpec) NewFileInfoFrom(path, filename string) (*FileInfo, error) { +func (sp *SourceSpec) NewFileInfoFrom(path, filename string) (*File, error) { meta := &hugofs.FileMeta{ Filename: filename, Path: path, + PathInfo: paths.Parse(filepath.ToSlash(path)), } return sp.NewFileInfo(hugofs.NewFileMetaInfo(nil, meta)) } -func (sp *SourceSpec) NewFileInfo(fi hugofs.FileMetaInfo) (*FileInfo, error) { +func (sp *SourceSpec) NewFileInfo(fi hugofs.FileMetaInfo) (*File, error) { m := fi.Meta() - filename := m.Filename - relPath := m.Path - - if relPath == "" { - return nil, errors.Errorf("no Path provided by %v (%T)", m, m.Fs) - } - - if filename == "" { - return nil, errors.Errorf("no Filename provided by %v (%T)", m, m.Fs) - } - - relDir := filepath.Dir(relPath) - if relDir == "." { - relDir = "" - } - if !strings.HasSuffix(relDir, helpers.FilePathSeparator) { - relDir = relDir + helpers.FilePathSeparator - } - - lang := m.Lang - translationBaseName := m.TranslationBaseName - - dir, name := filepath.Split(relPath) - if !strings.HasSuffix(dir, helpers.FilePathSeparator) { - dir = dir + helpers.FilePathSeparator - } - - ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(name), ".")) - baseName := paths.Filename(name) - - if translationBaseName == "" { - // This is usually provided by the filesystem. But this FileInfo is also - // created in a standalone context when doing "hugo new". This is - // an approximate implementation, which is "good enough" in that case. - fileLangExt := filepath.Ext(baseName) - translationBaseName = strings.TrimSuffix(baseName, fileLangExt) + if m.PathInfo == nil { + return nil, errors.New("no path info") } - f := &FileInfo{ - sp: sp, - filename: filename, - fi: fi, - lang: lang, - ext: ext, - dir: dir, - relDir: relDir, // Dir() - relPath: relPath, // Path() - name: name, - baseName: baseName, // BaseFileName() - translationBaseName: translationBaseName, - classifier: m.Classifier, + f := &File{ + sp: sp, + filename: m.Filename, + fim: fi, } return f, nil diff --git a/source/fileInfo_test.go b/source/fileInfo_test.go index b8bb33cd32f..a1702be3d03 100644 --- a/source/fileInfo_test.go +++ b/source/fileInfo_test.go @@ -29,9 +29,9 @@ func TestFileInfo(t *testing.T) { for _, this := range []struct { base string filename string - assert func(f *FileInfo) + assert func(f *File) }{ - {filepath.FromSlash("/a/"), filepath.FromSlash("/a/b/page.md"), func(f *FileInfo) { + {filepath.FromSlash("/a/"), filepath.FromSlash("/a/b/page.md"), func(f *File) { c.Assert(f.Filename(), qt.Equals, filepath.FromSlash("/a/b/page.md")) c.Assert(f.Dir(), qt.Equals, filepath.FromSlash("b/")) c.Assert(f.Path(), qt.Equals, filepath.FromSlash("b/page.md")) @@ -39,12 +39,12 @@ func TestFileInfo(t *testing.T) { c.Assert(f.TranslationBaseName(), qt.Equals, filepath.FromSlash("page")) c.Assert(f.BaseFileName(), qt.Equals, filepath.FromSlash("page")) }}, - {filepath.FromSlash("/a/"), filepath.FromSlash("/a/b/c/d/page.md"), func(f *FileInfo) { + {filepath.FromSlash("/a/"), filepath.FromSlash("/a/b/c/d/page.md"), func(f *File) { c.Assert(f.Section(), qt.Equals, "b") }}, - {filepath.FromSlash("/a/"), filepath.FromSlash("/a/b/page.en.MD"), func(f *FileInfo) { + {filepath.FromSlash("/a/"), filepath.FromSlash("/a/b/page.en.MD"), func(f *File) { c.Assert(f.Section(), qt.Equals, "b") - c.Assert(f.Path(), qt.Equals, filepath.FromSlash("b/page.en.MD")) + c.Assert(f.Path(), qt.Equals, filepath.FromSlash("b/page.en.md")) c.Assert(f.TranslationBaseName(), qt.Equals, filepath.FromSlash("page")) c.Assert(f.BaseFileName(), qt.Equals, filepath.FromSlash("page.en")) }}, diff --git a/source/filesystem.go b/source/filesystem.go index 4d509c56609..95cc717d935 100644 --- a/source/filesystem.go +++ b/source/filesystem.go @@ -17,14 +17,12 @@ import ( "path/filepath" "sync" - "github.com/pkg/errors" - "github.com/gohugoio/hugo/hugofs" ) // Filesystem represents a source filesystem. type Filesystem struct { - files []File + files []*File filesInit sync.Once filesInitErr error @@ -44,32 +42,49 @@ func (sp SourceSpec) NewFilesystemFromFileMetaInfo(fi hugofs.FileMetaInfo) *File return &Filesystem{SourceSpec: sp, fi: fi} } -// Files returns a slice of readable files. -func (f *Filesystem) Files() ([]File, error) { - f.filesInit.Do(func() { - err := f.captureFiles() +func (f *Filesystem) Walk(adder func(*File) error) error { + walker := func(path string, fi hugofs.FileMetaInfo, err error) error { if err != nil { - f.filesInitErr = errors.Wrap(err, "capture files") + return err + } + + if fi.IsDir() { + return nil + } + + meta := fi.Meta() + filename := meta.Filename + + b, err := f.shouldRead(filename, fi) + if err != nil { + return err + } + + file, err := f.SourceSpec.NewFileInfo(fi) + if err != nil { + return err } - }) - return f.files, f.filesInitErr -} -// add populates a file in the Filesystem.files -func (f *Filesystem) add(name string, fi hugofs.FileMetaInfo) (err error) { - var file File + if b { + if err = adder(file); err != nil { + return err + } + } - file, err = f.SourceSpec.NewFileInfo(fi) - if err != nil { return err } - f.files = append(f.files, file) + w := hugofs.NewWalkway(hugofs.WalkwayConfig{ + Fs: f.SourceFs, + Info: f.fi, + Root: f.Base, + WalkFn: walker, + }) - return err + return w.Walk() } -func (f *Filesystem) captureFiles() error { +func (f *Filesystem) _captureFiles() error { walker := func(path string, fi hugofs.FileMetaInfo, err error) error { if err != nil { return err @@ -88,7 +103,7 @@ func (f *Filesystem) captureFiles() error { } if b { - err = f.add(filename, fi) + // err = f.add(fi) } return err diff --git a/source/filesystem_test.go b/source/filesystem_test.go index 6343c6a41ad..9e54c9a761d 100644 --- a/source/filesystem_test.go +++ b/source/filesystem_test.go @@ -32,17 +32,6 @@ import ( "github.com/gohugoio/hugo/hugofs" ) -func TestEmptySourceFilesystem(t *testing.T) { - c := qt.New(t) - ss := newTestSourceSpec() - src := ss.NewFilesystem("") - files, err := src.Files() - c.Assert(err, qt.IsNil) - if len(files) != 0 { - t.Errorf("new filesystem should contain 0 files.") - } -} - func TestUnicodeNorm(t *testing.T) { if runtime.GOOS != "darwin" { // Normalization code is only for Mac OS, since it is not necessary for other OSes. @@ -60,19 +49,20 @@ func TestUnicodeNorm(t *testing.T) { } ss := newTestSourceSpec() - fi := hugofs.NewFileMetaInfo(nil, hugofs.NewFileMeta()) for i, path := range paths { base := fmt.Sprintf("base%d", i) c.Assert(afero.WriteFile(ss.Fs.Source, filepath.Join(base, path.NFD), []byte("some data"), 0777), qt.IsNil) src := ss.NewFilesystem(base) - _ = src.add(path.NFD, fi) - files, err := src.Files() + var found bool + err := src.Walk(func(f *File) error { + found = true + c.Assert(f.BaseFileName(), qt.Equals, path.NFC) + return nil + }) c.Assert(err, qt.IsNil) - f := files[0] - if f.BaseFileName() != path.NFC { - t.Fatalf("file %q name in NFD form should be normalized (%s)", f.BaseFileName(), path.NFC) - } + c.Assert(found, qt.IsTrue) + } } diff --git a/tpl/collections/apply_test.go b/tpl/collections/apply_test.go index 98cb78b51a8..1afb66808f8 100644 --- a/tpl/collections/apply_test.go +++ b/tpl/collections/apply_test.go @@ -14,6 +14,7 @@ package collections import ( + "context" "fmt" "io" "reflect" @@ -51,6 +52,10 @@ func (templateFinder) Execute(t tpl.Template, wr io.Writer, data interface{}) er return nil } +func (templateFinder) ExecuteWithContext(ctx context.Context, t tpl.Template, wr io.Writer, data interface{}) error { + return nil +} + func (templateFinder) GetFunc(name string) (reflect.Value, bool) { if name == "dobedobedo" { return reflect.Value{}, false diff --git a/tpl/data/resources_test.go b/tpl/data/resources_test.go index e825c2be168..ef6a4a71f29 100644 --- a/tpl/data/resources_test.go +++ b/tpl/data/resources_test.go @@ -197,7 +197,7 @@ func newDeps(cfg config.Provider) *deps.Deps { ex := hexec.New(security.DefaultConfig) - logger := loggers.NewIgnorableLogger(loggers.NewErrorLogger(), "none") + logger := loggers.NewIgnorableLogger(loggers.NewErrorLogger(), nil, nil) cs, err := helpers.NewContentSpec(cfg, logger, afero.NewMemMapFs(), ex) if err != nil { panic(err) diff --git a/tpl/debug/debug.go b/tpl/debug/debug.go index 693b97adc67..2e62af369cb 100644 --- a/tpl/debug/debug.go +++ b/tpl/debug/debug.go @@ -26,8 +26,7 @@ func New(d *deps.Deps) *Namespace { } // Namespace provides template functions for the "debug" namespace. -type Namespace struct { -} +type Namespace struct{} // Dump returns a object dump of val as a string. // Note that not every value passed to Dump will print so nicely, but diff --git a/tpl/fmt/fmt.go b/tpl/fmt/fmt.go index cb8aa3cf29f..62266923e2d 100644 --- a/tpl/fmt/fmt.go +++ b/tpl/fmt/fmt.go @@ -27,7 +27,7 @@ import ( func New(d *deps.Deps) *Namespace { ignorableLogger, ok := d.Log.(loggers.IgnorableLogger) if !ok { - ignorableLogger = loggers.NewIgnorableLogger(d.Log) + ignorableLogger = loggers.NewIgnorableLogger(d.Log, nil, nil) } distinctLogger := helpers.NewDistinctLogger(d.Log) @@ -83,3 +83,11 @@ func (ns *Namespace) Warnf(format string, a ...interface{}) string { ns.distinctLogger.Warnf(format, a...) return "" } + +// Warnidf formats according to a format specifier and logs a WARNING and +// an information text that the error with the given ID can be suppressed in config. +// It returns an empty string. +func (ns *Namespace) Warnidf(id, format string, a ...interface{}) string { + ns.distinctLogger.Warnsf(id, format, a...) + return "" +} diff --git a/tpl/fmt/init_test.go b/tpl/fmt/init_test.go index 07b740a73d6..de23e479a3d 100644 --- a/tpl/fmt/init_test.go +++ b/tpl/fmt/init_test.go @@ -30,7 +30,7 @@ func TestInit(t *testing.T) { var ns *internal.TemplateFuncsNamespace for _, nsf := range internal.TemplateFuncsNamespaceRegistry { - ns = nsf(&deps.Deps{Log: loggers.NewIgnorableLogger(loggers.NewErrorLogger())}) + ns = nsf(&deps.Deps{Log: loggers.NewIgnorableLogger(loggers.NewErrorLogger(), nil, nil)}) if ns.Name == name { found = true break diff --git a/tpl/internal/go_templates/texttemplate/hugo_template.go b/tpl/internal/go_templates/texttemplate/hugo_template.go index eed546e61ac..57917929c32 100644 --- a/tpl/internal/go_templates/texttemplate/hugo_template.go +++ b/tpl/internal/go_templates/texttemplate/hugo_template.go @@ -14,6 +14,7 @@ package template import ( + "context" "io" "reflect" @@ -38,15 +39,17 @@ type Preparer interface { } // ExecHelper allows some custom eval hooks. +// Note that the dot passed to all of the methods is the original data context, e.g. Page. type ExecHelper interface { - GetFunc(tmpl Preparer, name string) (reflect.Value, bool) - GetMethod(tmpl Preparer, receiver reflect.Value, name string) (method reflect.Value, firstArg reflect.Value) - GetMapValue(tmpl Preparer, receiver, key reflect.Value) (reflect.Value, bool) + Init(ctx context.Context, tmpl Preparer) + GetFunc(ctx context.Context, tmpl Preparer, name string) (reflect.Value, reflect.Value, bool) + GetMethod(ctx context.Context, tmpl Preparer, receiver reflect.Value, name string) (method reflect.Value, firstArg reflect.Value) + GetMapValue(ctx context.Context, tmpl Preparer, receiver, key reflect.Value) (reflect.Value, bool) } // Executer executes a given template. type Executer interface { - Execute(p Preparer, wr io.Writer, data interface{}) error + ExecuteWithContext(ctx context.Context, p Preparer, wr io.Writer, data interface{}) error } type executer struct { @@ -57,18 +60,28 @@ func NewExecuter(helper ExecHelper) Executer { return &executer{helper: helper} } -func (t *executer) Execute(p Preparer, wr io.Writer, data interface{}) error { +type dataContextKeType string + +// The data object passed to Execute or ExecuteWithContext gets stored with this key if not already set. +const DataContextKey = dataContextKeType("data") + +func (t *executer) ExecuteWithContext(ctx context.Context, p Preparer, wr io.Writer, data interface{}) error { tmpl, err := p.Prepare() if err != nil { return err } + if v := ctx.Value(DataContextKey); v == nil { + ctx = context.WithValue(ctx, DataContextKey, data) + } + value, ok := data.(reflect.Value) if !ok { value = reflect.ValueOf(data) } state := &state{ + ctx: ctx, helper: t.helper, prep: p, tmpl: tmpl, @@ -76,8 +89,9 @@ func (t *executer) Execute(p Preparer, wr io.Writer, data interface{}) error { vars: []variable{{"$", value}}, } - return tmpl.executeWithState(state, value) + t.helper.Init(ctx, p) + return tmpl.executeWithState(state, value) } // Prepare returns a template ready for execution. @@ -101,8 +115,9 @@ func (t *Template) executeWithState(state *state, value reflect.Value) (err erro // can execute in parallel. type state struct { tmpl *Template - prep Preparer // Added for Hugo. - helper ExecHelper // Added for Hugo. + ctx context.Context // Added for Hugo. The orignal data context. + prep Preparer // Added for Hugo. + helper ExecHelper // Added for Hugo. wr io.Writer node parse.Node // current node, for errors vars []variable // push-down stack of variable values. @@ -114,10 +129,11 @@ func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd name := node.Ident var function reflect.Value + // Added for Hugo. + var first reflect.Value var ok bool if s.helper != nil { - // Added for Hugo. - function, ok = s.helper.GetFunc(s.prep, name) + function, first, ok = s.helper.GetFunc(s.ctx, s.prep, name) } if !ok { @@ -127,6 +143,9 @@ func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd if !ok { s.errorf("%q is not a defined function", name) } + if first != zero { + return s.evalCall(dot, function, cmd, name, args, final, first) + } return s.evalCall(dot, function, cmd, name, args, final) } @@ -159,7 +178,7 @@ func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, var first reflect.Value var method reflect.Value if s.helper != nil { - method, first = s.helper.GetMethod(s.prep, ptr, fieldName) + method, first = s.helper.GetMethod(s.ctx, s.prep, ptr, fieldName) } else { method = ptr.MethodByName(fieldName) } @@ -198,7 +217,7 @@ func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, var result reflect.Value if s.helper != nil { // Added for Hugo. - result, _ = s.helper.GetMapValue(s.prep, receiver, nameVal) + result, _ = s.helper.GetMapValue(s.ctx, s.prep, receiver, nameVal) } else { result = receiver.MapIndex(nameVal) } diff --git a/tpl/internal/go_templates/texttemplate/hugo_template_test.go b/tpl/internal/go_templates/texttemplate/hugo_template_test.go index 98a2575eb98..43144e61384 100644 --- a/tpl/internal/go_templates/texttemplate/hugo_template_test.go +++ b/tpl/internal/go_templates/texttemplate/hugo_template_test.go @@ -15,6 +15,7 @@ package template import ( "bytes" + "context" "reflect" "strings" "testing" @@ -35,24 +36,26 @@ func (t TestStruct) Hello2(arg1, arg2 string) string { return arg1 + " " + arg2 } -type execHelper struct { +type execHelper struct{} + +func (e *execHelper) Init(ctx context.Context, tmpl Preparer) { } -func (e *execHelper) GetFunc(tmpl Preparer, name string) (reflect.Value, bool) { +func (e *execHelper) GetFunc(ctx context.Context, tmpl Preparer, name string) (reflect.Value, reflect.Value, bool) { if name == "print" { - return zero, false + return zero, zero, false } return reflect.ValueOf(func(s string) string { return "hello " + s - }), true + }), zero, true } -func (e *execHelper) GetMapValue(tmpl Preparer, m, key reflect.Value) (reflect.Value, bool) { +func (e *execHelper) GetMapValue(ctx context.Context, tmpl Preparer, m, key reflect.Value) (reflect.Value, bool) { key = reflect.ValueOf(strings.ToLower(key.String())) return m.MapIndex(key), true } -func (e *execHelper) GetMethod(tmpl Preparer, receiver reflect.Value, name string) (method reflect.Value, firstArg reflect.Value) { +func (e *execHelper) GetMethod(ctx context.Context, tmpl Preparer, receiver reflect.Value, name string) (method reflect.Value, firstArg reflect.Value) { if name != "Hello1" { return zero, zero } @@ -78,12 +81,11 @@ Method: {{ .Hello1 "v1" }} var b bytes.Buffer data := TestStruct{S: "sv", M: map[string]string{"a": "av"}} - c.Assert(ex.Execute(templ, &b, data), qt.IsNil) + c.Assert(ex.ExecuteWithContext(context.Background(), templ, &b, data), qt.IsNil) got := b.String() c.Assert(got, qt.Contains, "foo") c.Assert(got, qt.Contains, "hello hugo") c.Assert(got, qt.Contains, "Map: av") c.Assert(got, qt.Contains, "Method: v2 v1") - } diff --git a/hugolib/openapi_test.go b/tpl/openapi/openapi3/integration_test.go similarity index 71% rename from hugolib/openapi_test.go rename to tpl/openapi/openapi3/integration_test.go index 3f1bc400dc0..2b0730154c3 100644 --- a/hugolib/openapi_test.go +++ b/tpl/openapi/openapi3/integration_test.go @@ -1,4 +1,4 @@ -// Copyright 2019 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -11,15 +11,23 @@ // See the License for the specific language governing permissions and // limitations under the License. -package hugolib +package openapi3_test import ( "strings" "testing" + + "github.com/gohugoio/hugo/hugolib" + + qt "github.com/frankban/quicktest" ) -func TestOpenAPI3(t *testing.T) { - const openapi3Yaml = `openapi: 3.0.0 +func TestUnmarshal(t *testing.T) { + c := qt.New(t) + + files := ` +-- assets/api/myapi.yaml -- +openapi: 3.0.0 info: title: Sample API description: Optional multiline or single-line description in [CommonMark](http://commonmark.org/help/) or HTML. @@ -43,26 +51,26 @@ paths: type: array items: type: string -` - - b := newTestSitesBuilder(t).Running() - b.WithSourceFile("assets/api/myapi.yaml", openapi3Yaml) - - b.WithTemplatesAdded("index.html", ` +-- config.toml -- +baseURL = 'http://example.com/' +-- layouts/index.html -- {{ $api := resources.Get "api/myapi.yaml" | openapi3.Unmarshal }} - API: {{ $api.Info.Title | safeHTML }} + ` - -`) - - b.Build(BuildCfg{}) + b := hugolib.NewIntegrationTestBuilder( + hugolib.IntegrationTestConfig{ + T: c, + Running: true, + TxtarString: files, + }, + ).Build() b.AssertFileContent("public/index.html", `API: Sample API`) - b.EditFiles("assets/api/myapi.yaml", strings.Replace(openapi3Yaml, "Sample API", "Hugo API", -1)) - - b.Build(BuildCfg{}) + b. + EditFileReplace("assets/api/myapi.yaml", func(s string) string { return strings.ReplaceAll(s, "Sample API", "Hugo API") }). + Build() b.AssertFileContent("public/index.html", `API: Hugo API`) } diff --git a/tpl/openapi/openapi3/openapi3.go b/tpl/openapi/openapi3/openapi3.go index b4c2e64fdf4..2e4775f1347 100644 --- a/tpl/openapi/openapi3/openapi3.go +++ b/tpl/openapi/openapi3/openapi3.go @@ -1,4 +1,4 @@ -// Copyright 2020 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -14,6 +14,7 @@ package openapi3 import ( + "context" "io/ioutil" gyaml "github.com/ghodss/yaml" @@ -21,54 +22,63 @@ import ( "github.com/pkg/errors" kopenapi3 "github.com/getkin/kin-openapi/openapi3" - "github.com/gohugoio/hugo/cache/namedmemcache" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/deps" + "github.com/gohugoio/hugo/identity" "github.com/gohugoio/hugo/parser/metadecoders" "github.com/gohugoio/hugo/resources/resource" ) // New returns a new instance of the openapi3-namespaced template functions. func New(deps *deps.Deps) *Namespace { - // TODO(bep) consolidate when merging that "other branch" -- but be aware of the keys. - cache := namedmemcache.New() - deps.BuildStartListeners.Add( - func() { - cache.Clear() - }) - return &Namespace{ - cache: cache, + cache: deps.MemCache.GetOrCreatePartition("tpl/openapi3", memcache.ClearOnChange), deps: deps, } } // Namespace provides template functions for the "openapi3". type Namespace struct { - cache *namedmemcache.Cache + cache memcache.Getter deps *deps.Deps } -func (ns *Namespace) Unmarshal(r resource.UnmarshableResource) (*kopenapi3.T, error) { +var _ identity.IdentityGroupProvider = (*T)(nil) + +// T shares cache life cycle with the other members of the same identity group. +type T struct { + *kopenapi3.T + identityGroup identity.Identity +} + +func (t *T) GetIdentityGroup() identity.Identity { + return t.identityGroup +} + +// Unmarshal unmarshals the OpenAPI schemas in r into T. +// Note that ctx is provided by the framework. +func (ns *Namespace) Unmarshal(ctx context.Context, r resource.UnmarshableResource) (*T, error) { key := r.Key() if key == "" { return nil, errors.New("no Key set in Resource") } - v, err := ns.cache.GetOrCreate(key, func() (interface{}, error) { + v, err := ns.cache.GetOrCreate(ctx, key, func() memcache.Entry { f := metadecoders.FormatFromMediaType(r.MediaType()) if f == "" { - return nil, errors.Errorf("MIME %q not supported", r.MediaType()) + return memcache.Entry{Err: errors.Errorf("MIME %q not supported", r.MediaType())} } reader, err := r.ReadSeekCloser() if err != nil { - return nil, err + return memcache.Entry{Err: err} } + defer reader.Close() b, err := ioutil.ReadAll(reader) if err != nil { - return nil, err + return memcache.Entry{Err: err} } s := &kopenapi3.T{} @@ -79,16 +89,22 @@ func (ns *Namespace) Unmarshal(r resource.UnmarshableResource) (*kopenapi3.T, er err = metadecoders.Default.UnmarshalTo(b, f, s) } if err != nil { - return nil, err + return memcache.Entry{Err: err} } err = kopenapi3.NewLoader().ResolveRefsIn(s, nil) - return s, err + return memcache.Entry{ + Value: &T{T: s, identityGroup: identity.FirstIdentity(r)}, + Err: err, + ClearWhen: memcache.ClearOnChange, + // TODO1 check usage of StaleFunc. + + } }) if err != nil { return nil, err } - return v.(*kopenapi3.T), nil + return v.(*T), nil } diff --git a/tpl/partials/partials.go b/tpl/partials/partials.go index b0dc0a997ce..def6ccece42 100644 --- a/tpl/partials/partials.go +++ b/tpl/partials/partials.go @@ -16,6 +16,7 @@ package partials import ( + "context" "errors" "fmt" "html/template" @@ -25,6 +26,7 @@ import ( "strings" "sync" + "github.com/gohugoio/hugo/identity" texttemplate "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate" "github.com/gohugoio/hugo/helpers" @@ -44,21 +46,26 @@ type partialCacheKey struct { variant interface{} } +type partialCacheEntry struct { + templateIdentity identity.Identity + v interface{} +} + // partialCache represents a cache of partials protected by a mutex. type partialCache struct { sync.RWMutex - p map[partialCacheKey]interface{} + p map[partialCacheKey]partialCacheEntry } func (p *partialCache) clear() { p.Lock() defer p.Unlock() - p.p = make(map[partialCacheKey]interface{}) + p.p = make(map[partialCacheKey]partialCacheEntry) } // New returns a new instance of the templates-namespaced template functions. func New(deps *deps.Deps) *Namespace { - cache := &partialCache{p: make(map[partialCacheKey]interface{})} + cache := &partialCache{p: make(map[partialCacheKey]partialCacheEntry)} deps.BuildStartListeners.Add( func() { cache.clear() @@ -92,12 +99,25 @@ func (c *contextWrapper) Set(in interface{}) string { // If the partial contains a return statement, that value will be returned. // Else, the rendered output will be returned: // A string if the partial is a text/template, or template.HTML when html/template. -func (ns *Namespace) Include(name string, contextList ...interface{}) (interface{}, error) { +// Note that ctx is provided by Hugo, not the end user. TODO1 ctx used? +func (ns *Namespace) Include(ctx context.Context, name string, dataList ...interface{}) (interface{}, error) { + v, id, err := ns.include(ctx, name, dataList...) + if err != nil { + return nil, err + } + if ns.deps.Running { + // Track the usage of this partial so we know when to re-render pages using it. + tpl.AddIdentiesToDataContext(ctx, id) + } + return v, nil +} + +func (ns *Namespace) include(ctx context.Context, name string, dataList ...interface{}) (interface{}, identity.Identity, error) { name = strings.TrimPrefix(name, "partials/") - var context interface{} - if len(contextList) > 0 { - context = contextList[0] + var data interface{} + if len(dataList) > 0 { + data = dataList[0] } n := "partials/" + name @@ -109,7 +129,7 @@ func (ns *Namespace) Include(name string, contextList ...interface{}) (interface } if !found { - return "", fmt.Errorf("partial %q not found", name) + return "", nil, fmt.Errorf("partial %q not found", name) } var info tpl.ParseInfo @@ -123,8 +143,8 @@ func (ns *Namespace) Include(name string, contextList ...interface{}) (interface // Wrap the context sent to the template to capture the return value. // Note that the template is rewritten to make sure that the dot (".") // and the $ variable points to Arg. - context = &contextWrapper{ - Arg: context, + data = &contextWrapper{ + Arg: data, } // We don't care about any template output. @@ -135,13 +155,13 @@ func (ns *Namespace) Include(name string, contextList ...interface{}) (interface w = b } - if err := ns.deps.Tmpl().Execute(templ, w, context); err != nil { - return "", err + if err := ns.deps.Tmpl().ExecuteWithContext(ctx, templ, w, data); err != nil { + return "", nil, err } var result interface{} - if ctx, ok := context.(*contextWrapper); ok { + if ctx, ok := data.(*contextWrapper); ok { result = ctx.Result } else if _, ok := templ.(*texttemplate.Template); ok { result = w.(fmt.Stringer).String() @@ -153,24 +173,30 @@ func (ns *Namespace) Include(name string, contextList ...interface{}) (interface ns.deps.Metrics.TrackValue(templ.Name(), result) } - return result, nil + return result, templ.(identity.Identity), nil } // IncludeCached executes and caches partial templates. The cache is created with name+variants as the key. -func (ns *Namespace) IncludeCached(name string, context interface{}, variants ...interface{}) (interface{}, error) { +// Note that ctx is provided by Hugo and not the end user. +func (ns *Namespace) IncludeCached(ctx context.Context, name string, data interface{}, variants ...interface{}) (interface{}, error) { key, err := createKey(name, variants...) if err != nil { return nil, err } - result, err := ns.getOrCreate(key, context) + result, err := ns.getOrCreate(ctx, key, data) if err == errUnHashable { // Try one more key.variant = helpers.HashString(key.variant) - result, err = ns.getOrCreate(key, context) + result, err = ns.getOrCreate(ctx, key, data) + } + + if ns.deps.Running { + // Track the usage of this partial so we know when to re-render pages using it. + tpl.AddIdentiesToDataContext(ctx, result.templateIdentity) } - return result, err + return result.v, err } func createKey(name string, variants ...interface{}) (partialCacheKey, error) { @@ -196,7 +222,7 @@ func createKey(name string, variants ...interface{}) (partialCacheKey, error) { var errUnHashable = errors.New("unhashable") -func (ns *Namespace) getOrCreate(key partialCacheKey, context interface{}) (result interface{}, err error) { +func (ns *Namespace) getOrCreate(ctx context.Context, key partialCacheKey, dot interface{}) (pe partialCacheEntry, err error) { defer func() { if r := recover(); r != nil { err = r.(error) @@ -215,9 +241,9 @@ func (ns *Namespace) getOrCreate(key partialCacheKey, context interface{}) (resu return p, nil } - p, err = ns.Include(key.name, context) + v, id, err := ns.include(ctx, key.name, dot) if err != nil { - return nil, err + return } ns.cachedPartials.Lock() @@ -226,7 +252,12 @@ func (ns *Namespace) getOrCreate(key partialCacheKey, context interface{}) (resu if p2, ok := ns.cachedPartials.p[key]; ok { return p2, nil } - ns.cachedPartials.p[key] = p - return p, nil + pe = partialCacheEntry{ + templateIdentity: id, + v: v, + } + ns.cachedPartials.p[key] = pe + + return } diff --git a/tpl/safe/safe.go b/tpl/safe/safe.go index 4abd34e7fa4..f5ea69c70d7 100644 --- a/tpl/safe/safe.go +++ b/tpl/safe/safe.go @@ -18,6 +18,8 @@ package safe import ( "html/template" + "github.com/gohugoio/hugo/common/paths" + "github.com/gohugoio/hugo/helpers" "github.com/spf13/cast" ) @@ -68,6 +70,10 @@ func (ns *Namespace) URL(a interface{}) (template.URL, error) { // SanitizeURL returns a given string as html/template URL content. func (ns *Namespace) SanitizeURL(a interface{}) (string, error) { + helpers.Deprecated("safe.SanitizeURL", "urlize", true) s, err := cast.ToStringE(a) - return helpers.SanitizeURL(s), err + if err != nil { + return "", err + } + return paths.URLEscape(s), nil } diff --git a/tpl/safe/safe_test.go b/tpl/safe/safe_test.go index e91605762a4..0a5c60d4e9c 100644 --- a/tpl/safe/safe_test.go +++ b/tpl/safe/safe_test.go @@ -182,30 +182,3 @@ func TestURL(t *testing.T) { c.Assert(result, qt.Equals, test.expect) } } - -func TestSanitizeURL(t *testing.T) { - t.Parallel() - c := qt.New(t) - - ns := New() - - for _, test := range []struct { - a interface{} - expect interface{} - }{ - {"http://foo/../../bar", "http://foo/bar"}, - // errors - {tstNoStringer{}, false}, - } { - - result, err := ns.SanitizeURL(test.a) - - if b, ok := test.expect.(bool); ok && !b { - c.Assert(err, qt.Not(qt.IsNil)) - continue - } - - c.Assert(err, qt.IsNil) - c.Assert(result, qt.Equals, test.expect) - } -} diff --git a/tpl/template.go b/tpl/template.go index 0375b4a1776..b82d6d1e76e 100644 --- a/tpl/template.go +++ b/tpl/template.go @@ -14,10 +14,12 @@ package tpl import ( + "context" "io" "reflect" "regexp" + "github.com/gohugoio/hugo/identity" "github.com/gohugoio/hugo/output" texttemplate "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate" @@ -48,6 +50,7 @@ type TemplateFinder interface { type TemplateHandler interface { TemplateFinder Execute(t Template, wr io.Writer, data interface{}) error + ExecuteWithContext(ctx context.Context, t Template, wr io.Writer, data interface{}) error LookupLayout(d output.LayoutDescriptor, f output.Format) (Template, bool, error) HasTemplate(name string) bool } @@ -139,3 +142,41 @@ func extractBaseOf(err string) string { type TemplateFuncGetter interface { GetFunc(name string) (reflect.Value, bool) } + +// NewTemplateIdentity creates a new identity.Identity based on the given tpl. +func NewTemplateIdentity(tpl Template) *TemplateIdentity { + return &TemplateIdentity{ + tpl: tpl, + } +} + +// TemplateIdentity wraps a Template and implemnents identity.Identity. +type TemplateIdentity struct { + tpl Template +} + +func (id *TemplateIdentity) IdentifierBase() interface{} { + return id.tpl.Name() +} + +// GetDataFromContext returns the template data context (usually .Page) from ctx if set. +func GetDataFromContext(ctx context.Context) interface{} { + return ctx.Value(texttemplate.DataContextKey) +} + +// AddIdentiesToDataContext adds the identities found in v to the +// DependencyManager found in ctx. +func AddIdentiesToDataContext(ctx context.Context, v interface{}) { + if v == nil { + return + } + if dot := GetDataFromContext(ctx); dot != nil { + if dp, ok := dot.(identity.DependencyManagerProvider); ok { + idm := dp.GetDependencyManager() + identity.WalkIdentities(v, func(id identity.Identity) bool { + idm.AddIdentity(id) + return false + }) + } + } +} diff --git a/tpl/template_info.go b/tpl/template_info.go index d9b438138bf..43a24503f95 100644 --- a/tpl/template_info.go +++ b/tpl/template_info.go @@ -24,7 +24,7 @@ type Info interface { ParseInfo() ParseInfo // Identifies this template and its dependencies. - identity.Provider + identity.Identity } type InfoManager interface { @@ -34,22 +34,6 @@ type InfoManager interface { identity.Manager } -type defaultInfo struct { - identity.Manager - parseInfo ParseInfo -} - -func NewInfo(id identity.Manager, parseInfo ParseInfo) Info { - return &defaultInfo{ - Manager: id, - parseInfo: parseInfo, - } -} - -func (info *defaultInfo) ParseInfo() ParseInfo { - return info.parseInfo -} - type ParseInfo struct { // Set for shortcode templates with any {{ .Inner }} IsInner bool diff --git a/tpl/tplimpl/template.go b/tpl/tplimpl/template.go index 3ef815e24a4..5cb95d21bcc 100644 --- a/tpl/tplimpl/template.go +++ b/tpl/tplimpl/template.go @@ -14,6 +14,7 @@ package tplimpl import ( + "context" "io" "os" "path/filepath" @@ -111,10 +112,6 @@ func needsBaseTemplate(templ string) bool { return baseTemplateDefineRe.MatchString(templ[idx:]) } -func newIdentity(name string) identity.Manager { - return identity.NewManager(identity.NewPathIdentity(files.ComponentFolderLayouts, name)) -} - func newStandaloneTextTemplate(funcs map[string]interface{}) tpl.TemplateParseFinder { return &textTemplateWrapperWithLock{ RWMutex: &sync.RWMutex{}, @@ -132,7 +129,6 @@ func newTemplateExec(d *deps.Deps) (*templateExec, error) { h := &templateHandler{ nameBaseTemplateName: make(map[string]string), transformNotFound: make(map[string]*templateState), - identityNotFound: make(map[string][]identity.Manager), shortcodes: make(map[string]*shortcodeTemplates), templateInfo: make(map[string]tpl.Info), @@ -185,13 +181,15 @@ func newTemplateNamespace(funcs map[string]interface{}) *templateNamespace { } func newTemplateState(templ tpl.Template, info templateInfo) *templateState { - return &templateState{ + s := &templateState{ info: info, typ: info.resolveType(), Template: templ, - Manager: newIdentity(info.name), + Manager: identity.NewManager(tpl.NewTemplateIdentity(templ)), parseInfo: tpl.DefaultParseInfo, } + + return s } type layoutCacheKey struct { @@ -216,6 +214,10 @@ func (t templateExec) Clone(d *deps.Deps) *templateExec { } func (t *templateExec) Execute(templ tpl.Template, wr io.Writer, data interface{}) error { + return t.ExecuteWithContext(context.Background(), templ, wr, data) +} + +func (t *templateExec) ExecuteWithContext(ctx context.Context, templ tpl.Template, wr io.Writer, data interface{}) error { if rlocker, ok := templ.(types.RLocker); ok { rlocker.RLock() defer rlocker.RUnlock() @@ -224,7 +226,7 @@ func (t *templateExec) Execute(templ tpl.Template, wr io.Writer, data interface{ defer t.Metrics.MeasureSince(templ.Name(), time.Now()) } - execErr := t.executor.Execute(templ, wr, data) + execErr := t.executor.ExecuteWithContext(ctx, templ, wr, data) if execErr != nil { execErr = t.addFileContext(templ, execErr) } @@ -273,9 +275,6 @@ type templateHandler struct { // AST transformation pass. transformNotFound map[string]*templateState - // Holds identities of templates not found during first pass. - identityNotFound map[string][]identity.Manager - // shortcodes maps shortcode name to template variants // (language, output format etc.) of that shortcode. shortcodes map[string]*shortcodeTemplates @@ -321,6 +320,7 @@ func (t *templateHandler) LookupLayout(d output.LayoutDescriptor, f output.Forma templ, found, err := t.findLayout(d, f) if err == nil && found { t.layoutTemplateCache[key] = templ + _ = templ.(identity.Identity) return templ, true, nil } @@ -411,7 +411,8 @@ func (t *templateHandler) findLayout(d output.LayoutDescriptor, f output.Format) ts.baseInfo = base // Add the base identity to detect changes - ts.Add(identity.NewPathIdentity(files.ComponentFolderLayouts, base.name)) + // TODO1 can we just add the real template? + ts.AddIdentity(identity.NewPathIdentity(files.ComponentFolderLayouts, base.name, "", "")) } t.applyTemplateTransformers(t.main, ts) @@ -645,11 +646,6 @@ func (t *templateHandler) applyTemplateTransformers(ns *templateNamespace, ts *t for k := range c.templateNotFound { t.transformNotFound[k] = ts - t.identityNotFound[k] = append(t.identityNotFound[k], c.t) - } - - for k := range c.identityNotFound { - t.identityNotFound[k] = append(t.identityNotFound[k], c.t) } return c, err @@ -806,15 +802,6 @@ func (t *templateHandler) postTransform() error { } } - for k, v := range t.identityNotFound { - ts := t.findTemplate(k) - if ts != nil { - for _, im := range v { - im.Add(ts) - } - } - } - for _, v := range t.shortcodes { sort.Slice(v.variants, func(i, j int) bool { v1, v2 := v.variants[i], v.variants[j] @@ -941,6 +928,10 @@ func (t *templateState) ParseInfo() tpl.ParseInfo { return t.parseInfo } +func (t *templateState) IdentifierBase() interface{} { + return t.Name() +} + func (t *templateState) isText() bool { return isText(t.Template) } diff --git a/tpl/tplimpl/template_ast_transformers.go b/tpl/tplimpl/template_ast_transformers.go index 33461dc7d23..8d86fdf7dcd 100644 --- a/tpl/tplimpl/template_ast_transformers.go +++ b/tpl/tplimpl/template_ast_transformers.go @@ -14,9 +14,6 @@ package tplimpl import ( - "regexp" - "strings" - htmltemplate "github.com/gohugoio/hugo/tpl/internal/go_templates/htmltemplate" texttemplate "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate" @@ -39,7 +36,6 @@ const ( type templateContext struct { visited map[string]bool templateNotFound map[string]bool - identityNotFound map[string]bool lookupFn func(name string) *templateState // The last error encountered. @@ -78,7 +74,6 @@ func newTemplateContext( lookupFn: lookupFn, visited: make(map[string]bool), templateNotFound: make(map[string]bool), - identityNotFound: make(map[string]bool), } } @@ -177,7 +172,6 @@ func (c *templateContext) applyTransformations(n parse.Node) (bool, error) { } case *parse.CommandNode: - c.collectPartialInfo(x) c.collectInner(x) keep := c.collectReturnNode(x) @@ -277,39 +271,6 @@ func (c *templateContext) collectInner(n *parse.CommandNode) { } } -var partialRe = regexp.MustCompile(`^partial(Cached)?$|^partials\.Include(Cached)?$`) - -func (c *templateContext) collectPartialInfo(x *parse.CommandNode) { - if len(x.Args) < 2 { - return - } - - first := x.Args[0] - var id string - switch v := first.(type) { - case *parse.IdentifierNode: - id = v.Ident - case *parse.ChainNode: - id = v.String() - } - - if partialRe.MatchString(id) { - partialName := strings.Trim(x.Args[1].String(), "\"") - if !strings.Contains(partialName, ".") { - partialName += ".html" - } - partialName = "partials/" + partialName - info := c.lookupFn(partialName) - - if info != nil { - c.t.Add(info) - } else { - // Delay for later - c.identityNotFound[partialName] = true - } - } -} - func (c *templateContext) collectReturnNode(n *parse.CommandNode) bool { if c.t.typ != templatePartial || c.returnNode != nil { return true diff --git a/tpl/tplimpl/template_funcs.go b/tpl/tplimpl/template_funcs.go index 4b3abaada96..c694f83dbd4 100644 --- a/tpl/tplimpl/template_funcs.go +++ b/tpl/tplimpl/template_funcs.go @@ -16,9 +16,12 @@ package tplimpl import ( + "context" "reflect" "strings" + "github.com/gohugoio/hugo/identity" + "github.com/gohugoio/hugo/resources/page" "github.com/gohugoio/hugo/tpl" "github.com/gohugoio/hugo/common/maps" @@ -61,8 +64,13 @@ import ( ) var ( - _ texttemplate.ExecHelper = (*templateExecHelper)(nil) - zero reflect.Value + _ texttemplate.ExecHelper = (*templateExecHelper)(nil) + zero reflect.Value + identityInterface = reflect.TypeOf((*identity.Identity)(nil)).Elem() + identityProviderInterface = reflect.TypeOf((*identity.IdentityProvider)(nil)).Elem() + identityLookupProviderInterface = reflect.TypeOf((*identity.IdentityLookupProvider)(nil)).Elem() + dependencyManagerProviderInterface = reflect.TypeOf((*identity.DependencyManagerProvider)(nil)).Elem() + contextInterface = reflect.TypeOf((*context.Context)(nil)).Elem() ) type templateExecHelper struct { @@ -70,14 +78,30 @@ type templateExecHelper struct { funcs map[string]reflect.Value } -func (t *templateExecHelper) GetFunc(tmpl texttemplate.Preparer, name string) (reflect.Value, bool) { +func (t *templateExecHelper) GetFunc(ctx context.Context, tmpl texttemplate.Preparer, name string) (fn reflect.Value, firstArg reflect.Value, found bool) { if fn, found := t.funcs[name]; found { - return fn, true + if fn.Type().NumIn() > 0 { + first := fn.Type().In(0) + if first.Implements(contextInterface) { + // TODO1 check if we can void this conversion every time -- and if that matters. + // The first argument may be context.Context. This is never provided by the end user, but it's used to pass down + // contextual information, e.g. the top level data context (e.g. Page). + return fn, reflect.ValueOf(ctx), true + } + } + + return fn, zero, true } - return zero, false + return zero, zero, false } -func (t *templateExecHelper) GetMapValue(tmpl texttemplate.Preparer, receiver, key reflect.Value) (reflect.Value, bool) { +func (t *templateExecHelper) Init(ctx context.Context, tmpl texttemplate.Preparer) { + if t.running { + t.trackDeps(ctx, tmpl, "", reflect.Value{}) + } +} + +func (t *templateExecHelper) GetMapValue(ctx context.Context, tmpl texttemplate.Preparer, receiver, key reflect.Value) (reflect.Value, bool) { if params, ok := receiver.Interface().(maps.Params); ok { // Case insensitive. keystr := strings.ToLower(key.String()) @@ -93,21 +117,84 @@ func (t *templateExecHelper) GetMapValue(tmpl texttemplate.Preparer, receiver, k return v, v.IsValid() } -func (t *templateExecHelper) GetMethod(tmpl texttemplate.Preparer, receiver reflect.Value, name string) (method reflect.Value, firstArg reflect.Value) { +func (t *templateExecHelper) GetMethod(ctx context.Context, tmpl texttemplate.Preparer, receiver reflect.Value, name string) (method reflect.Value, firstArg reflect.Value) { if t.running { - // This is a hot path and receiver.MethodByName really shows up in the benchmarks, - // so we maintain a list of method names with that signature. - switch name { - case "GetPage", "Render": - if info, ok := tmpl.(tpl.Info); ok { - if m := receiver.MethodByName(name + "WithTemplateInfo"); m.IsValid() { - return m, reflect.ValueOf(info) - } - } + t.trackDeps(ctx, tmpl, name, receiver) + } + + fn := receiver.MethodByName(name) + if !fn.IsValid() { + return zero, zero + } + + if fn.Type().NumIn() > 0 { + first := fn.Type().In(0) + if first.Implements(contextInterface) { + // The first argument may be context.Context. This is never provided by the end user, but it's used to pass down + // contextual information, e.g. the top level data context (e.g. Page). + return fn, reflect.ValueOf(ctx) + } + } + + return fn, zero +} + +func (t *templateExecHelper) trackDeps(ctx context.Context, tmpl texttemplate.Preparer, name string, receiver reflect.Value) { + if tmpl == nil { + panic("must provide a template") + } + + dot := ctx.Value(texttemplate.DataContextKey) + + if dot == nil { + return + } + + // TODO1 remove all but DependencyManagerProvider + // idm, ok := dot.(identity.Manager) + + dp, ok := dot.(identity.DependencyManagerProvider) + + if !ok { + // Check for .Page, as in shortcodes. + // TODO1 remove this interface from .Page + var pp page.PageProvider + if pp, ok = dot.(page.PageProvider); ok { + dp, ok = pp.Page().(identity.DependencyManagerProvider) } } - return receiver.MethodByName(name), zero + if !ok { + // The aliases currently have no dependency manager. + // TODO(bep) + return + } + + // TODO1 bookmark1 + + idm := dp.GetDependencyManager() + + if info, ok := tmpl.(identity.Identity); ok { + idm.AddIdentity(info) + } else { + + // TODO1 fix this re shortcodes + id := identity.NewPathIdentity("layouts", tmpl.(tpl.Template).Name(), "", "") + idm.AddIdentity(id) + } + + identity.WalkIdentitiesValue(receiver, func(id identity.Identity) bool { + idm.AddIdentity(id) + return false + }) + + if receiver.IsValid() { + if receiver.Type().Implements(identityLookupProviderInterface) { + if id, found := receiver.Interface().(identity.IdentityLookupProvider).LookupIdentity(name); found { + idm.AddIdentity(id) + } + } + } } func newTemplateExecuter(d *deps.Deps) (texttemplate.Executer, map[string]reflect.Value) { diff --git a/tpl/tplimpl/template_funcs_test.go b/tpl/tplimpl/template_funcs_test.go index 711d1350d33..4ba0ff64d98 100644 --- a/tpl/tplimpl/template_funcs_test.go +++ b/tpl/tplimpl/template_funcs_test.go @@ -15,6 +15,7 @@ package tplimpl import ( "bytes" + "context" "fmt" "path/filepath" "reflect" @@ -168,19 +169,19 @@ func TestPartialCached(t *testing.T) { ns := partials.New(de) - res1, err := ns.IncludeCached(name, &data) + res1, err := ns.IncludeCached(context.Background(), name, &data) c.Assert(err, qt.IsNil) for j := 0; j < 10; j++ { time.Sleep(2 * time.Nanosecond) - res2, err := ns.IncludeCached(name, &data) + res2, err := ns.IncludeCached(context.Background(), name, &data) c.Assert(err, qt.IsNil) if !reflect.DeepEqual(res1, res2) { t.Fatalf("cache mismatch") } - res3, err := ns.IncludeCached(name, &data, fmt.Sprintf("variant%d", j)) + res3, err := ns.IncludeCached(context.Background(), name, &data, fmt.Sprintf("variant%d", j)) c.Assert(err, qt.IsNil) if reflect.DeepEqual(res1, res3) { @@ -190,15 +191,17 @@ func TestPartialCached(t *testing.T) { } func BenchmarkPartial(b *testing.B) { + ctx := context.Background() doBenchmarkPartial(b, func(ns *partials.Namespace) error { - _, err := ns.Include("bench1") + _, err := ns.Include(ctx, "bench1") return err }) } func BenchmarkPartialCached(b *testing.B) { + ctx := context.Background() doBenchmarkPartial(b, func(ns *partials.Namespace) error { - _, err := ns.IncludeCached("bench1", nil) + _, err := ns.IncludeCached(ctx, "bench1", nil) return err }) } diff --git a/tpl/transform/init_test.go b/tpl/transform/init_test.go index ec3c358974a..69de57f872a 100644 --- a/tpl/transform/init_test.go +++ b/tpl/transform/init_test.go @@ -1,4 +1,4 @@ -// Copyright 2017 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -16,6 +16,8 @@ package transform import ( "testing" + "github.com/gohugoio/hugo/cache/memcache" + qt "github.com/frankban/quicktest" "github.com/gohugoio/hugo/deps" "github.com/gohugoio/hugo/htesting/hqt" @@ -28,7 +30,9 @@ func TestInit(t *testing.T) { var ns *internal.TemplateFuncsNamespace for _, nsf := range internal.TemplateFuncsNamespaceRegistry { - ns = nsf(&deps.Deps{}) + ns = nsf(&deps.Deps{ + MemCache: memcache.New(memcache.Config{}), + }) if ns.Name == name { found = true break diff --git a/tpl/transform/transform.go b/tpl/transform/transform.go index 8ea91f234ca..a516501b428 100644 --- a/tpl/transform/transform.go +++ b/tpl/transform/transform.go @@ -1,4 +1,4 @@ -// Copyright 2017 The Hugo Authors. All rights reserved. +// Copyright 2021 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. @@ -18,7 +18,7 @@ import ( "html" "html/template" - "github.com/gohugoio/hugo/cache/namedmemcache" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/deps" "github.com/gohugoio/hugo/helpers" @@ -27,22 +27,19 @@ import ( // New returns a new instance of the transform-namespaced template functions. func New(deps *deps.Deps) *Namespace { - cache := namedmemcache.New() - deps.BuildStartListeners.Add( - func() { - cache.Clear() - }) - + if deps.MemCache == nil { + panic("must provide MemCache") + } return &Namespace{ - cache: cache, deps: deps, + cache: deps.MemCache.GetOrCreatePartition("tpl/transform", memcache.ClearOnChange), } } // Namespace provides template functions for the "transform" namespace. type Namespace struct { - cache *namedmemcache.Cache deps *deps.Deps + cache memcache.Getter } // Emojify returns a copy of s with all emoji codes replaced with actual emojis. diff --git a/tpl/transform/transform_test.go b/tpl/transform/transform_test.go index 260de5f8314..e7a23cf8591 100644 --- a/tpl/transform/transform_test.go +++ b/tpl/transform/transform_test.go @@ -17,6 +17,7 @@ import ( "html/template" "testing" + "github.com/gohugoio/hugo/cache/memcache" "github.com/gohugoio/hugo/common/loggers" "github.com/spf13/afero" @@ -249,6 +250,7 @@ func newDeps(cfg config.Provider) *deps.Deps { return &deps.Deps{ Cfg: cfg, Fs: hugofs.NewMem(l), + MemCache: memcache.New(memcache.Config{}), ContentSpec: cs, } } diff --git a/tpl/transform/unmarshal.go b/tpl/transform/unmarshal.go index c59269577cf..c06a055daea 100644 --- a/tpl/transform/unmarshal.go +++ b/tpl/transform/unmarshal.go @@ -14,9 +14,12 @@ package transform import ( + "context" "io/ioutil" "strings" + "github.com/gohugoio/hugo/cache/memcache" + "github.com/gohugoio/hugo/resources/resource" "github.com/gohugoio/hugo/common/types" @@ -69,24 +72,33 @@ func (ns *Namespace) Unmarshal(args ...interface{}) (interface{}, error) { key += decoder.OptionsKey() } - return ns.cache.GetOrCreate(key, func() (interface{}, error) { + return ns.cache.GetOrCreate(context.TODO(), key, func() memcache.Entry { f := metadecoders.FormatFromMediaType(r.MediaType()) if f == "" { - return nil, errors.Errorf("MIME %q not supported", r.MediaType()) + return memcache.Entry{Err: errors.Errorf("MIME %q not supported", r.MediaType())} } reader, err := r.ReadSeekCloser() if err != nil { - return nil, err + return memcache.Entry{Err: err} } defer reader.Close() b, err := ioutil.ReadAll(reader) if err != nil { - return nil, err + return memcache.Entry{Err: err} } - return decoder.Unmarshal(b, f) + v, err := decoder.Unmarshal(b, f) + + return memcache.Entry{ + Value: v, + Err: err, + ClearWhen: memcache.ClearOnChange, + StaleFunc: func() bool { + return resource.IsStaleAny(r) + }, + } }) } @@ -101,13 +113,15 @@ func (ns *Namespace) Unmarshal(args ...interface{}) (interface{}, error) { key := helpers.MD5String(dataStr) - return ns.cache.GetOrCreate(key, func() (interface{}, error) { + return ns.cache.GetOrCreate(context.TODO(), key, func() memcache.Entry { f := decoder.FormatFromContentString(dataStr) if f == "" { - return nil, errors.New("unknown format") + return memcache.Entry{Err: errors.New("unknown format")} } - return decoder.Unmarshal([]byte(dataStr), f) + v, err := decoder.Unmarshal([]byte(dataStr), f) + + return memcache.Entry{Value: v, Err: err, ClearWhen: memcache.ClearOnChange} }) }