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

commands/commandeer.go

@@ -19,6 +19,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/gohugoio/hugo/config"
+
 	"github.com/spf13/cobra"
 
 	"github.com/gohugoio/hugo/utils"
@@ -57,6 +59,7 @@ type commandeer struct {
 	debounce func(f func())
 
 	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
-	}
-
-	c.Cfg = config
-	c.configFiles = configFiles
-
+	doWithConfig := func(cfg config.Provider) error {
 		for _, cmdV := range c.subCmdVs {
-		c.initializeFlags(cmdV)
-	}
-
-	if l, ok := c.Cfg.Get("languagesSorted").(helpers.Languages); ok {
-		c.languages = l
+			initializeFlags(cmdV, cfg)
 		}
 
 		if baseURL != "" {
-		config.Set("baseURL", baseURL)
+			cfg.Set("baseURL", baseURL)
 		}
 
-	if c.doWithCommandeer != nil {
-		err = c.doWithCommandeer(c)
+		if len(disableKinds) > 0 {
+			cfg.Set("disableKinds", disableKinds)
 		}
 
+		cfg.Set("logI18nWarnings", logI18nWarnings)
+
+		if theme != "" {
+			cfg.Set("theme", theme)
+		}
+
+		if themesDir != "" {
+			cfg.Set("themesDir", themesDir)
+		}
+
+		if destination != "" {
+			cfg.Set("publishDir", destination)
+		}
+
+		cfg.Set("workingDir", dir)
+
+		if contentDir != "" {
+			cfg.Set("contentDir", contentDir)
+		}
+
+		if layoutDir != "" {
+			cfg.Set("layoutDir", layoutDir)
+		}
+
+		if cacheDir != "" {
+			cfg.Set("cacheDir", cacheDir)
+		}
+
+		return nil
+	}
+
+	doWithCommandeer := func(cfg config.Provider) error {
+		c.Cfg = cfg
+		if c.doWithCommandeer == nil {
+			return nil
+		}
+		err := c.doWithCommandeer(c)
+		return err
+	}
+
+	config, configFiles, err := hugolib.LoadConfig(
+		hugolib.ConfigSourceDescriptor{Fs: sourceFs, Path: source, WorkingDir: dir, Filename: cfgFile},
+		doWithCommandeer,
+		doWithConfig)
+
 	if err != nil {
 		return err
 	}
 
-	if len(disableKinds) > 0 {
-		c.Set("disableKinds", disableKinds)
+	c.configFiles = configFiles
+
+	if l, ok := c.Cfg.Get("languagesSorted").(helpers.Languages); ok {
+		c.languagesConfigured = true
+		c.languages = l
 	}
 
-	logger, err := createLogger(cfg.Cfg)
+	// 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
+		}
+	}
+
+	logger, err := createLogger(config)
 	if err != nil {
 		return err
 	}
 
 	cfg.Logger = logger
 
-	config.Set("logI18nWarnings", logI18nWarnings)
-
-	if theme != "" {
-		config.Set("theme", theme)
-	}
-
-	if themesDir != "" {
-		config.Set("themesDir", themesDir)
-	}
-
-	if destination != "" {
-		config.Set("publishDir", destination)
-	}
-
-	config.Set("workingDir", dir)
-
-	if contentDir != "" {
-		config.Set("contentDir", contentDir)
-	}
-
-	if layoutDir != "" {
-		config.Set("layoutDir", layoutDir)
-	}
-
-	if cacheDir != "" {
-		config.Set("cacheDir", cacheDir)
-	}
-
 	createMemFs := config.GetBool("renderToMemory")
 
 	if createMemFs {

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())
 	}
 }
 

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.

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
 	}