Fix handling of --contentDir etc. flag

We need to revisit the commands package re globals and tests, but this should fix the init order of flags and languages.

Fixes #4589

diff --git a/commands/commandeer.go b/commands/commandeer.go
index f7ac93efa7f6b93155e89c72311de44a35d7793d..5dba5e6b3b737343c313e749f0b84d7656f8d6e0 100644 (file)
--- a/commands/commandeer.go
+++ b/commands/commandeer.go
@@ -19,6 +19,8 @@ import (
        "sync"
        "time"
 
+       "github.com/gohugoio/hugo/config"
+
        "github.com/spf13/cobra"
 
        "github.com/gohugoio/hugo/utils"
@@ -56,8 +58,9 @@ type commandeer struct {
        // Used in cases where we get flooded with events in server mode.
        debounce func(f func())
 
-       serverPorts []int
-       languages   helpers.Languages
+       serverPorts         []int
+       languagesConfigured bool
+       languages           helpers.Languages
 
        configured bool
 }
@@ -135,73 +138,90 @@ func (c *commandeer) loadConfig(running bool) error {
                sourceFs = c.DepsCfg.Fs.Source
        }
 
-       config, configFiles, err := hugolib.LoadConfig(hugolib.ConfigSourceDescriptor{Fs: sourceFs, Path: source, WorkingDir: dir, Filename: cfgFile})
-       if err != nil {
-               return err
-       }
+       doWithConfig := func(cfg config.Provider) error {
+               for _, cmdV := range c.subCmdVs {
+                       initializeFlags(cmdV, cfg)
+               }
 
-       c.Cfg = config
-       c.configFiles = configFiles
+               if baseURL != "" {
+                       cfg.Set("baseURL", baseURL)
+               }
 
-       for _, cmdV := range c.subCmdVs {
-               c.initializeFlags(cmdV)
-       }
+               if len(disableKinds) > 0 {
+                       cfg.Set("disableKinds", disableKinds)
+               }
 
-       if l, ok := c.Cfg.Get("languagesSorted").(helpers.Languages); ok {
-               c.languages = l
-       }
+               cfg.Set("logI18nWarnings", logI18nWarnings)
 
-       if baseURL != "" {
-               config.Set("baseURL", baseURL)
-       }
+               if theme != "" {
+                       cfg.Set("theme", theme)
+               }
 
-       if c.doWithCommandeer != nil {
-               err = c.doWithCommandeer(c)
-       }
+               if themesDir != "" {
+                       cfg.Set("themesDir", themesDir)
+               }
 
-       if err != nil {
-               return err
-       }
+               if destination != "" {
+                       cfg.Set("publishDir", destination)
+               }
 
-       if len(disableKinds) > 0 {
-               c.Set("disableKinds", disableKinds)
-       }
+               cfg.Set("workingDir", dir)
 
-       logger, err := createLogger(cfg.Cfg)
-       if err != nil {
-               return err
-       }
+               if contentDir != "" {
+                       cfg.Set("contentDir", contentDir)
+               }
 
-       cfg.Logger = logger
+               if layoutDir != "" {
+                       cfg.Set("layoutDir", layoutDir)
+               }
 
-       config.Set("logI18nWarnings", logI18nWarnings)
+               if cacheDir != "" {
+                       cfg.Set("cacheDir", cacheDir)
+               }
 
-       if theme != "" {
-               config.Set("theme", theme)
+               return nil
        }
 
-       if themesDir != "" {
-               config.Set("themesDir", themesDir)
+       doWithCommandeer := func(cfg config.Provider) error {
+               c.Cfg = cfg
+               if c.doWithCommandeer == nil {
+                       return nil
+               }
+               err := c.doWithCommandeer(c)
+               return err
        }
 
-       if destination != "" {
-               config.Set("publishDir", destination)
+       config, configFiles, err := hugolib.LoadConfig(
+               hugolib.ConfigSourceDescriptor{Fs: sourceFs, Path: source, WorkingDir: dir, Filename: cfgFile},
+               doWithCommandeer,
+               doWithConfig)
+
+       if err != nil {
+               return err
        }
 
-       config.Set("workingDir", dir)
+       c.configFiles = configFiles
 
-       if contentDir != "" {
-               config.Set("contentDir", contentDir)
+       if l, ok := c.Cfg.Get("languagesSorted").(helpers.Languages); ok {
+               c.languagesConfigured = true
+               c.languages = l
        }
 
-       if layoutDir != "" {
-               config.Set("layoutDir", layoutDir)
+       // This is potentially double work, but we need to do this one more time now
+       // that all the languages have been configured.
+       if c.doWithCommandeer != nil {
+               if err := c.doWithCommandeer(c); err != nil {
+                       return err
+               }
        }
 
-       if cacheDir != "" {
-               config.Set("cacheDir", cacheDir)
+       logger, err := createLogger(config)
+       if err != nil {
+               return err
        }
 
+       cfg.Logger = logger
+
        createMemFs := config.GetBool("renderToMemory")
 
        if createMemFs {

diff --git a/commands/hugo.go b/commands/hugo.go
index d0894a11a6accb5232f5d322cee83a93487d353e..75205456bb17f1e1cb2c8e8c76f798ac5c15ac01 100644 (file)
--- a/commands/hugo.go
+++ b/commands/hugo.go
@@ -348,7 +348,7 @@ func createLogger(cfg config.Provider) (*jww.Notepad, error) {
        return jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime), nil
 }
 
-func (c *commandeer) initializeFlags(cmd *cobra.Command) {
+func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
        persFlagKeys := []string{"debug", "verbose", "logFile"}
        flagKeys := []string{
                "cleanDestinationDir",
@@ -370,10 +370,10 @@ func (c *commandeer) initializeFlags(cmd *cobra.Command) {
        }
 
        for _, key := range persFlagKeys {
-               c.setValueFromFlag(cmd.PersistentFlags(), key)
+               setValueFromFlag(cmd.PersistentFlags(), key, cfg)
        }
        for _, key := range flagKeys {
-               c.setValueFromFlag(cmd.Flags(), key)
+               setValueFromFlag(cmd.Flags(), key, cfg)
        }
 
 }
@@ -385,7 +385,7 @@ var deprecatedFlags = map[string]bool{
        strings.ToLower("canonifyURLs"):          true,
 }
 
-func (c *commandeer) setValueFromFlag(flags *flag.FlagSet, key string) {
+func setValueFromFlag(flags *flag.FlagSet, key string, cfg config.Provider) {
        if flags.Changed(key) {
                if _, deprecated := deprecatedFlags[strings.ToLower(key)]; deprecated {
                        msg := fmt.Sprintf(`Set "%s = true" in your config.toml.
@@ -394,7 +394,7 @@ If you need to set this configuration value from the command line, set it via an
                        helpers.Deprecated("hugo", "--"+key+" flag", msg, true)
                }
                f := flags.Lookup(key)
-               c.Set(key, f.Value.String())
+               cfg.Set(key, f.Value.String())
        }
 }
 

diff --git a/commands/server.go b/commands/server.go
index 278ba7f37bef8a1a28e0c0b54e21a1d3985c2676..e2a9fa021d448e3c7a45a56beb952d2eb757b7d1 100644 (file)
--- a/commands/server.go
+++ b/commands/server.go
@@ -137,6 +137,11 @@ func server(cmd *cobra.Command, args []string) error {
                        c.Set("watch", true)
                }
 
+               // TODO(bep) yes, we should fix.
+               if !c.languagesConfigured {
+                       return nil
+               }
+
                var err error
 
                // We can only do this once.

diff --git a/hugolib/config.go b/hugolib/config.go
index 9f206bc77d07e1565d58d9c51e238910fd5b1404..b166e772986b08f5d5c0adfe8568ebfb768f08cd 100644 (file)
--- a/hugolib/config.go
+++ b/hugolib/config.go
@@ -54,7 +54,7 @@ func LoadConfigDefault(fs afero.Fs) (*viper.Viper, error) {
 
 // LoadConfig loads Hugo configuration into a new Viper and then adds
 // a set of defaults.
-func LoadConfig(d ConfigSourceDescriptor) (*viper.Viper, []string, error) {
+func LoadConfig(d ConfigSourceDescriptor, doWithConfig ...func(cfg config.Provider) error) (*viper.Viper, []string, error) {
        var configFiles []string
 
        fs := d.Fs
@@ -108,6 +108,14 @@ func LoadConfig(d ConfigSourceDescriptor) (*viper.Viper, []string, error) {
                configFiles = append(configFiles, themeConfigFile)
        }
 
+       // We create languages based on the settings, so we need to make sure that
+       // all configuration is loaded/set before doing that.
+       for _, d := range doWithConfig {
+               if err := d(v); err != nil {
+                       return v, configFiles, err
+               }
+       }
+
        if err := loadLanguageSettings(v, nil); err != nil {
                return v, configFiles, err
        }