Only print the path warnings once

We could reset and rerun it on server rebuilds, but that report needs a full build to make sense.

Also clean up the config vs flags in this area: Make all config settings match the flags e.g. `printPathWarnings`, but set up aliases for the
old.

Fixes #11187

diff --git a/commands/commandeer.go b/commands/commandeer.go
index 26bd25c0170e413d0258d1b929c5d0423b168833..1a4ecf64f4ffb99153db32f716497884af240783 100644 (file)
--- a/commands/commandeer.go
+++ b/commands/commandeer.go
@@ -110,12 +110,10 @@ type rootCommand struct {
        environment string
 
        // Common build flags.
-       baseURL              string
-       gc                   bool
-       poll                 string
-       forceSyncStatic      bool
-       printPathWarnings    bool
-       printUnusedTemplates bool
+       baseURL         string
+       gc              bool
+       poll            string
+       forceSyncStatic bool
 
        // Profile flags (for debugging of performance problems)
        cpuprofile   string
@@ -288,7 +286,7 @@ func (r *rootCommand) ConfigFromProvider(key int32, cfg config.Provider) (*commo
                        htime.Clock = clock.Start(configs.Base.C.Clock)
                }
 
-               if base.LogPathWarnings {
+               if base.PrintPathWarnings {
                        // Note that we only care about the "dynamic creates" here,
                        // so skip the static fs.
                        fs.PublishDir = hugofs.NewCreateCountingFs(fs.PublishDir)
@@ -544,8 +542,8 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
        cmd.Flags().BoolP("noChmod", "", false, "don't sync permission mode of files")
        cmd.Flags().BoolP("noBuildLock", "", false, "don't create .hugo_build.lock file")
        cmd.Flags().BoolP("printI18nWarnings", "", false, "print missing translations")
-       cmd.Flags().BoolVarP(&r.printPathWarnings, "printPathWarnings", "", false, "print warnings on duplicate target paths etc.")
-       cmd.Flags().BoolVarP(&r.printUnusedTemplates, "printUnusedTemplates", "", false, "print warnings on unused templates.")
+       cmd.Flags().BoolP("printPathWarnings", "", false, "print warnings on duplicate target paths etc.")
+       cmd.Flags().BoolP("printUnusedTemplates", "", false, "print warnings on unused templates.")
        cmd.Flags().StringVarP(&r.cpuprofile, "profile-cpu", "", "", "write cpu profile to `file`")
        cmd.Flags().StringVarP(&r.memprofile, "profile-mem", "", "", "write memory profile to `file`")
        cmd.Flags().BoolVarP(&r.printm, "printMemoryUsage", "", false, "print memory usage to screen at intervals")

diff --git a/commands/helpers.go b/commands/helpers.go
index c342ce2c793666ce231af86b43bdfac71cdb65c4..5021221fb0009c76cf4f1aa50d540065b9a4695a 100644 (file)
--- a/commands/helpers.go
+++ b/commands/helpers.go
@@ -79,11 +79,9 @@ func flagsToCfgWithAdditionalConfigBase(cd *simplecobra.Commandeer, cfg config.P
 
        // Flags with a different name in the config.
        keyMap := map[string]string{
-               "minify":            "minifyOutput",
-               "destination":       "publishDir",
-               "printI18nWarnings": "logI18nWarnings",
-               "printPathWarnings": "logPathWarnings",
-               "editor":            "newContentEditor",
+               "minify":      "minifyOutput",
+               "destination": "publishDir",
+               "editor":      "newContentEditor",
        }
 
        // Flags that we for some reason don't want to expose in the site config.

diff --git a/commands/hugobuilder.go b/commands/hugobuilder.go
index 3e96bfc73d668c643d4eac28562994efd9021c16..b5cd0c2bbedcb5d4b30f9020161c44640d17e9c0 100644 (file)
--- a/commands/hugobuilder.go
+++ b/commands/hugobuilder.go
@@ -43,7 +43,6 @@ import (
        "github.com/gohugoio/hugo/hugolib/filesystems"
        "github.com/gohugoio/hugo/livereload"
        "github.com/gohugoio/hugo/resources/page"
-       "github.com/gohugoio/hugo/tpl"
        "github.com/gohugoio/hugo/watcher"
        "github.com/spf13/fsync"
        "golang.org/x/sync/errgroup"
@@ -418,13 +417,6 @@ func (c *hugoBuilder) build() error {
                        return err
                }
 
-               if c.r.printUnusedTemplates {
-                       unusedTemplates := h.Tmpl().(tpl.UnusedTemplatesProvider).UnusedTemplates()
-                       for _, unusedTemplate := range unusedTemplates {
-                               c.r.logger.Warnf("Template %s is unused, source file %s", unusedTemplate.Name(), unusedTemplate.Filename())
-                       }
-               }
-
                h.PrintProcessingStats(os.Stdout)
                c.r.Println()
        }

diff --git a/config/allconfig/allconfig.go b/config/allconfig/allconfig.go
index 2dc409be77d6a46eaf4f62cc4f1a6517bfc9be93..bab15501b7e70bb864ba8aaa5c3049673a9c0982 100644 (file)
--- a/config/allconfig/allconfig.go
+++ b/config/allconfig/allconfig.go
@@ -484,12 +484,6 @@ type RootConfig struct {
        // Enable to print greppable placeholders (on the form "[i18n] TRANSLATIONID") for missing translation strings.
        EnableMissingTranslationPlaceholders bool
 
-       // Enable to print warnings for missing translation strings.
-       LogI18nWarnings bool
-
-       // ENable to print warnings for multiple files published to the same destination.
-       LogPathWarnings bool
-
        // Enable to panic on warning log entries. This may make it easier to detect the source.
        PanicOnWarning bool
 
@@ -525,6 +519,12 @@ type RootConfig struct {
        // Whether to track and print unused templates during the build.
        PrintUnusedTemplates bool
 
+       // Enable to print warnings for missing translation strings.
+       PrintI18nWarnings bool
+
+       // ENable to print warnings for multiple files published to the same destination.
+       PrintPathWarnings bool
+
        // URL to be used as a placeholder when a page reference cannot be found in ref or relref. Is used as-is.
        RefLinksNotFoundURL string
 

diff --git a/config/allconfig/configlanguage.go b/config/allconfig/configlanguage.go
index 95c5c7edfbc47e2be3cf4d6cd8f9ae1d4d0bd935..be549126bd20dc8d9a11f645079c92c2ab64a70a 100644 (file)
--- a/config/allconfig/configlanguage.go
+++ b/config/allconfig/configlanguage.go
@@ -199,8 +199,8 @@ func (c ConfigLanguage) EnableMissingTranslationPlaceholders() bool {
        return c.config.EnableMissingTranslationPlaceholders
 }
 
-func (c ConfigLanguage) LogI18nWarnings() bool {
-       return c.config.LogI18nWarnings
+func (c ConfigLanguage) PrintI18nWarnings() bool {
+       return c.config.PrintI18nWarnings
 }
 
 func (c ConfigLanguage) CreateTitle(s string) string {

diff --git a/config/allconfig/integration_test.go b/config/allconfig/integration_test.go
index 2de83eaa4cc33f80fdcabcee18693f9f6bb2ae14..fcb92e71df31e207ca8df33eebbe07fc6fba3064 100644 (file)
--- a/config/allconfig/integration_test.go
+++ b/config/allconfig/integration_test.go
@@ -69,3 +69,21 @@ Title: {{ .Title }}
        b.Assert(modConf.Mounts[1].Lang, qt.Equals, "sv")
 
 }
+
+func TestConfigAliases(t *testing.T) {
+
+       files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+logI18nWarnings = true
+logPathWarnings = true
+`
+       b := hugolib.NewIntegrationTestBuilder(
+               hugolib.IntegrationTestConfig{T: t, TxtarString: files},
+       ).Build()
+
+       conf := b.H.Configs.Base
+
+       b.Assert(conf.PrintI18nWarnings, qt.Equals, true)
+       b.Assert(conf.PrintPathWarnings, qt.Equals, true)
+}

diff --git a/config/allconfig/load.go b/config/allconfig/load.go
index 4e5478c408d1ea6af4cfec39c606f452c610f2e0..b9bb38aaf40da917978256ca3550c3394bbf26b5 100644 (file)
--- a/config/allconfig/load.go
+++ b/config/allconfig/load.go
@@ -139,7 +139,11 @@ type configLoader struct {
 
 // Handle some legacy values.
 func (l configLoader) applyConfigAliases() error {
-       aliases := []types.KeyValueStr{{Key: "taxonomies", Value: "indexes"}}
+       aliases := []types.KeyValueStr{
+               {Key: "indexes", Value: "taxonomies"},
+               {Key: "logI18nWarnings", Value: "printI18nWarnings"},
+               {Key: "logPathWarnings", Value: "printPathWarnings"},
+       }
 
        for _, alias := range aliases {
                if l.cfg.IsSet(alias.Key) {

diff --git a/config/configProvider.go b/config/configProvider.go
index 8ed0728bd8af60097e14bdea9668afccf8540b41..5d6acce9f3bca430cae8383fbfe72233c7eec12b 100644 (file)
--- a/config/configProvider.go
+++ b/config/configProvider.go
@@ -57,7 +57,7 @@ type AllProvider interface {
        EnableMissingTranslationPlaceholders() bool
        TemplateMetrics() bool
        TemplateMetricsHints() bool
-       LogI18nWarnings() bool
+       PrintI18nWarnings() bool
        CreateTitle(s string) string
        IgnoreFile(s string) bool
        NewContentEditor() string

diff --git a/hugolib/hugo_sites.go b/hugolib/hugo_sites.go
index 6ffef6fa88021faa222abfb323436e22f1f13845..9c121f7ac1191ed4b8efe471a203c4145ae7ea39 100644 (file)
--- a/hugolib/hugo_sites.go
+++ b/hugolib/hugo_sites.go
@@ -77,6 +77,8 @@ type HugoSites struct {
        contentInit sync.Once
        content     *pageMaps
 
+       postRenderInit sync.Once
+
        // Keeps track of bundle directories and symlinks to enable partial rebuilding.
        ContentChanges *contentChangeMap
 

diff --git a/hugolib/hugo_sites_build.go b/hugolib/hugo_sites_build.go
index ea73c493fc5db185ab12ff1334c3e03ef5eeb367..9a645f3a56f8a9d4057e4c2b445334e4faf38322 100644 (file)
--- a/hugolib/hugo_sites_build.go
+++ b/hugolib/hugo_sites_build.go
@@ -25,6 +25,7 @@ import (
        "github.com/bep/logg"
        "github.com/gohugoio/hugo/langs"
        "github.com/gohugoio/hugo/publisher"
+       "github.com/gohugoio/hugo/tpl"
 
        "github.com/gohugoio/hugo/hugofs"
 
@@ -144,18 +145,8 @@ func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error {
                        h.SendError(fmt.Errorf("render: %w", err))
                }
 
-               if h.Configs.Base.LogPathWarnings {
-                       // We need to do this before any post processing, as that may write to the same files twice
-                       // and create false positives.
-                       hugofs.WalkFilesystems(h.Fs.PublishDir, func(fs afero.Fs) bool {
-                               if dfs, ok := fs.(hugofs.DuplicatesReporter); ok {
-                                       dupes := dfs.ReportDuplicates()
-                                       if dupes != "" {
-                                               h.Log.Warnln("Duplicate target paths:", dupes)
-                                       }
-                               }
-                               return false
-                       })
+               if err := h.postRenderOnce(); err != nil {
+                       h.SendError(fmt.Errorf("postRenderOnce: %w", err))
                }
 
                if err := h.postProcess(infol); err != nil {
@@ -329,6 +320,34 @@ func (h *HugoSites) render(l logg.LevelLogger, config *BuildCfg) error {
        return nil
 }
 
+func (h *HugoSites) postRenderOnce() error {
+       h.postRenderInit.Do(func() {
+               conf := h.Configs.Base
+               if conf.PrintPathWarnings {
+                       // We need to do this before any post processing, as that may write to the same files twice
+                       // and create false positives.
+                       hugofs.WalkFilesystems(h.Fs.PublishDir, func(fs afero.Fs) bool {
+                               if dfs, ok := fs.(hugofs.DuplicatesReporter); ok {
+                                       dupes := dfs.ReportDuplicates()
+                                       if dupes != "" {
+                                               h.Log.Warnln("Duplicate target paths:", dupes)
+                                       }
+                               }
+                               return false
+                       })
+               }
+
+               if conf.PrintUnusedTemplates {
+                       unusedTemplates := h.Tmpl().(tpl.UnusedTemplatesProvider).UnusedTemplates()
+                       for _, unusedTemplate := range unusedTemplates {
+                               h.Log.Warnf("Template %s is unused, source file %s", unusedTemplate.Name(), unusedTemplate.Filename())
+                       }
+               }
+
+       })
+       return nil
+}
+
 func (h *HugoSites) postProcess(l logg.LevelLogger) error {
        defer h.timeTrack(l, time.Now(), "postProcess")
 

diff --git a/langs/i18n/i18n.go b/langs/i18n/i18n.go
index 1ebd039cd8830246cdba7f9b789f39a0f19e4cf9..74af0775405ca49498963275c35abd4dea840dfc 100644 (file)
--- a/langs/i18n/i18n.go
+++ b/langs/i18n/i18n.go
@@ -119,7 +119,7 @@ func (t Translator) initFuncs(bndl *i18n.Bundle) {
                                t.logger.Warnf("Failed to get translated string for language %q and ID %q: %s", currentLangStr, translationID, err)
                        }
 
-                       if t.cfg.LogI18nWarnings() {
+                       if t.cfg.PrintI18nWarnings() {
                                t.logger.Warnf("i18n|MISSING_TRANSLATION|%s|%s", currentLangStr, translationID)
                        }