// Currently only set when in "fast render mode".
changeDetector *fileChangeDetector
- visitedURLs *types.EvictingStringQueue
+ visitedURLs *types.EvictingQueue[string]
fullRebuildSem *semaphore.Weighted
debounce func(f func())
if err != nil {
return
}
- err = h.Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()}, events...)
+ err = h.Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyTouched: c.visitedURLs, ErrRecovery: c.errState.wasErr()}, events...)
return
}
}
whatChanged := &hugolib.WhatChanged{}
whatChanged.Add(ids...)
- err = h.Build(hugolib.BuildCfg{NoBuildLock: true, WhatChanged: whatChanged, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()})
+ err = h.Build(hugolib.BuildCfg{NoBuildLock: true, WhatChanged: whatChanged, RecentlyTouched: c.visitedURLs, ErrRecovery: c.errState.wasErr()})
return
}
)
func newHugoBuilder(r *rootCommand, s *serverCommand, onConfigLoaded ...func(reloaded bool) error) *hugoBuilder {
- var visitedURLs *types.EvictingStringQueue
+ var visitedURLs *types.EvictingQueue[string]
if s != nil && !s.disableFastRender {
- visitedURLs = types.NewEvictingStringQueue(20)
+ visitedURLs = types.NewEvictingQueue[string](20)
}
return &hugoBuilder{
r: r,
}
if f.c.fastRenderMode && f.c.errState.buildErr() == nil {
- if strings.HasSuffix(requestURI, "/") || strings.HasSuffix(requestURI, "html") || strings.HasSuffix(requestURI, "htm") {
+ // Sec-Fetch-Mode should be sent by all recent browser versions, see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-Fetch-Mode#navigate
+ // Fall back to the file extension if not set.
+ // The main take here is that we don't want to have CSS/JS files etc. partake in this logic.
+ if r.Header.Get("Sec-Fetch-Mode") == "navigate" || strings.HasSuffix(requestURI, "/") || strings.HasSuffix(requestURI, "html") || strings.HasSuffix(requestURI, "htm") {
if !f.c.visitedURLs.Contains(requestURI) {
// If not already on stack, re-render that single page.
if err := f.c.partialReRender(requestURI); err != nil {
defer func() {
c.errState.setWasErr(false)
}()
- visited := types.NewEvictingStringQueue(len(urls))
+ visited := types.NewEvictingQueue[string](len(urls))
for _, url := range urls {
visited.Add(url)
}
}
// Note: We do not set NoBuildLock as the file lock is not acquired at this stage.
- err = h.Build(hugolib.BuildCfg{NoBuildLock: false, RecentlyVisited: visited, PartialReRender: true, ErrRecovery: c.errState.wasErr()})
+ err = h.Build(hugolib.BuildCfg{NoBuildLock: false, RecentlyTouched: visited, PartialReRender: true, ErrRecovery: c.errState.wasErr()})
return
}
"sync"
)
-// EvictingStringQueue is a queue which automatically evicts elements from the head of
+// EvictingQueue is a queue which automatically evicts elements from the head of
// the queue when attempting to add new elements onto the queue and it is full.
// This queue orders elements LIFO (last-in-first-out). It throws away duplicates.
-// Note: This queue currently does not contain any remove (poll etc.) methods.
-type EvictingStringQueue struct {
+type EvictingQueue[T comparable] struct {
size int
- vals []string
- set map[string]bool
+ vals []T
+ set map[T]bool
mu sync.Mutex
+ zero T
}
-// NewEvictingStringQueue creates a new queue with the given size.
-func NewEvictingStringQueue(size int) *EvictingStringQueue {
- return &EvictingStringQueue{size: size, set: make(map[string]bool)}
+// NewEvictingQueue creates a new queue with the given size.
+func NewEvictingQueue[T comparable](size int) *EvictingQueue[T] {
+ return &EvictingQueue[T]{size: size, set: make(map[T]bool)}
}
// Add adds a new string to the tail of the queue if it's not already there.
-func (q *EvictingStringQueue) Add(v string) *EvictingStringQueue {
+func (q *EvictingQueue[T]) Add(v T) *EvictingQueue[T] {
q.mu.Lock()
if q.set[v] {
q.mu.Unlock()
return q
}
-func (q *EvictingStringQueue) Len() int {
+func (q *EvictingQueue[T]) Len() int {
if q == nil {
return 0
}
}
// Contains returns whether the queue contains v.
-func (q *EvictingStringQueue) Contains(v string) bool {
+func (q *EvictingQueue[T]) Contains(v T) bool {
if q == nil {
return false
}
}
// Peek looks at the last element added to the queue.
-func (q *EvictingStringQueue) Peek() string {
+func (q *EvictingQueue[T]) Peek() T {
q.mu.Lock()
l := len(q.vals)
if l == 0 {
q.mu.Unlock()
- return ""
+ return q.zero
}
elem := q.vals[l-1]
q.mu.Unlock()
}
// PeekAll looks at all the elements in the queue, with the newest first.
-func (q *EvictingStringQueue) PeekAll() []string {
+func (q *EvictingQueue[T]) PeekAll() []T {
+ if q == nil {
+ return nil
+ }
q.mu.Lock()
- vals := make([]string, len(q.vals))
+ vals := make([]T, len(q.vals))
copy(vals, q.vals)
q.mu.Unlock()
for i, j := 0, len(vals)-1; i < j; i, j = i+1, j-1 {
}
// PeekAllSet returns PeekAll as a set.
-func (q *EvictingStringQueue) PeekAllSet() map[string]bool {
+func (q *EvictingQueue[T]) PeekAllSet() map[T]bool {
all := q.PeekAll()
- set := make(map[string]bool)
+ set := make(map[T]bool)
for _, v := range all {
set[v] = true
}
func TestEvictingStringQueue(t *testing.T) {
c := qt.New(t)
- queue := NewEvictingStringQueue(3)
+ queue := NewEvictingQueue[string](3)
c.Assert(queue.Peek(), qt.Equals, "")
queue.Add("a")
var wg sync.WaitGroup
val := "someval"
- queue := NewEvictingStringQueue(3)
+ queue := NewEvictingQueue[string](3)
for j := 0; j < 100; j++ {
wg.Add(1)
// Set in server mode when the last build failed for some reason.
ErrRecovery bool
- // Recently visited URLs. This is used for partial re-rendering.
- RecentlyVisited *types.EvictingStringQueue
+ // Recently visited or touched URLs. This is used for partial re-rendering.
+ RecentlyTouched *types.EvictingQueue[string]
// Can be set to build only with a sub set of the content source.
ContentInclusionFilter *glob.FilenameFilter
}
// shouldRender returns whether this output format should be rendered or not.
-func (cfg *BuildCfg) shouldRender(p *pageState) bool {
+func (cfg *BuildCfg) shouldRender(infol logg.LevelLogger, p *pageState) bool {
if p.skipRender() {
return false
}
return false
}
- if p.outputFormat().IsHTML {
- // This is fast render mode and the output format is HTML,
- // rerender if this page is one of the recently visited.
- return cfg.RecentlyVisited.Contains(p.RelPermalink())
+ if relURL := p.getRelURL(); relURL != "" {
+ if cfg.RecentlyTouched.Contains(relURL) {
+ infol.Logf("render recently touched URL %q (%s)", relURL, p.outputFormat().Name)
+ return true
+ }
}
// In fast render mode, we want to avoid re-rendering the sitemaps etc. and
// other big listings whenever we e.g. change a content file,
- // but we want partial renders of the recently visited pages to also include
+ // but we want partial renders of the recently touched pages to also include
// alternative formats of the same HTML page (e.g. RSS, JSON).
for _, po := range p.pageOutputs {
- if po.render && po.f.IsHTML && cfg.RecentlyVisited.Contains(po.RelPermalink()) {
+ if po.render && po.f.IsHTML && cfg.RecentlyTouched.Contains(po.getRelURL()) {
+ infol.Logf("render recently touched URL %q, %s version of %s", po.getRelURL(), po.f.Name, p.outputFormat().Name)
return true
}
}
loggers.TimeTrackf(l, start, h.buildCounters.loggFields(), "")
}()
- siteRenderContext := &siteRenderContext{cfg: config, multihost: h.Configs.IsMultihost}
+ siteRenderContext := &siteRenderContext{cfg: config, infol: l, multihost: h.Configs.IsMultihost}
renderErr := func(err error) error {
if err == nil {
needsPagesAssemble = true
- if config.RecentlyVisited != nil {
+ if config.RecentlyTouched != nil {
// Fast render mode. Adding them to the visited queue
// avoids rerendering them on navigation.
for _, id := range changes {
if p, ok := id.(page.Page); ok {
- config.RecentlyVisited.Add(p.RelPermalink())
+ config.RecentlyTouched.Add(p.RelPermalink())
}
}
}
if !s.Cfg.Running {
panic("BuildPartial can only be used in server mode")
}
- visited := types.NewEvictingStringQueue(len(urls))
+ visited := types.NewEvictingQueue[string](len(urls))
for _, url := range urls {
visited.Add(url)
}
- buildCfg := BuildCfg{RecentlyVisited: visited, PartialReRender: true}
+ buildCfg := BuildCfg{RecentlyTouched: visited, PartialReRender: true}
return s, s.build(buildCfg)
}
// Use the main format for permalinks, usually HTML.
permalinksIndex := 0
if f.Permalinkable {
- // Unless it's permalinkable
+ // Unless it's permalinkable.
permalinksIndex = i
}
targets[f.Name] = targetPathsHolder{
+ relURL: relPermalink,
paths: paths,
OutputFormat: pageOutputFormats[permalinksIndex],
}
type targetPather interface {
targetPaths() page.TargetPaths
+ getRelURL() string
}
type targetPathsHolder struct {
- paths page.TargetPaths
+ // relURL is usually the same as OutputFormat.RelPermalink, but can be different
+ // for non-permalinkable output formats. These shares RelPermalink with the main (first) output format.
+ relURL string
+ paths page.TargetPaths
page.OutputFormat
}
+func (t targetPathsHolder) getRelURL() string {
+ return t.relURL
+}
+
func (t targetPathsHolder) targetPaths() page.TargetPaths {
return t.paths
}
}
func TestRebuildRenameDirectoryWithBranchBundleFastRender(t *testing.T) {
- recentlyVisited := types.NewEvictingStringQueue(10).Add("/a/b/c/")
- b := TestRunning(t, rebuildFilesSimple, func(cfg *IntegrationTestConfig) { cfg.BuildCfg = BuildCfg{RecentlyVisited: recentlyVisited} })
+ recentlyVisited := types.NewEvictingQueue[string](10).Add("/a/b/c/")
+ b := TestRunning(t, rebuildFilesSimple, func(cfg *IntegrationTestConfig) { cfg.BuildCfg = BuildCfg{RecentlyTouched: recentlyVisited} })
b.RenameDir("content/mysection", "content/mysectionrenamed").Build()
b.AssertFileContent("public/mysectionrenamed/index.html", "My Section")
b.AssertFileContent("public/mysectionrenamed/mysectionbundle/index.html", "My Section Bundle")
b.AssertFileContent("public/index.html", "Content: <p>Home</p>")
}
+// Issue #13014.
+func TestRebuildEditNotPermalinkableCustomOutputFormatTemplateInFastRenderMode(t *testing.T) {
+ t.Parallel()
+
+ files := `
+-- hugo.toml --
+baseURL = "https://example.com/docs/"
+disableLiveReload = true
+[internal]
+fastRenderMode = true
+disableKinds = ["taxonomy", "term", "sitemap", "robotsTXT", "404"]
+[outputFormats]
+ [outputFormats.SearchIndex]
+ baseName = 'Search'
+ isPlainText = true
+ mediaType = 'text/plain'
+ noAlternative = true
+ permalinkable = false
+
+[outputs]
+ home = ['HTML', 'SearchIndex']
+-- content/_index.md --
+---
+title: "Home"
+---
+Home.
+-- layouts/index.html --
+Home.
+-- layouts/_default/index.searchindex.txt --
+Text. {{ .Title }}|{{ .RelPermalink }}|
+
+`
+ b := TestRunning(t, files, TestOptInfo())
+
+ b.AssertFileContent("public/search.txt", "Text.")
+
+ b.EditFileReplaceAll("layouts/_default/index.searchindex.txt", "Text.", "Text Edited.").Build()
+
+ b.BuildPartial("/docs/search.txt")
+
+ b.AssertFileContent("public/search.txt", "Text Edited.")
+}
+
func TestRebuildVariationsAssetsJSImport(t *testing.T) {
t.Parallel()
files := `
"strings"
"sync"
+ "github.com/bep/logg"
"github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/hugolib/doctree"
type siteRenderContext struct {
cfg *BuildCfg
+ infol logg.LevelLogger
+
// languageIdx is the zero based index of the site.
languageIdx int
Tree: s.pageMap.treePages,
Handle: func(key string, n contentNodeI, match doctree.DimensionFlag) (bool, error) {
if p, ok := n.(*pageState); ok {
- if cfg.shouldRender(p) {
+ if cfg.shouldRender(ctx.infol, p) {
select {
case <-s.h.Done():
return true, nil
projects / brevno-suite / hugo / commitdiff