✨ Implement Page bundling and image handling

This commit is not the smallest in Hugo's history.

Some hightlights include:

* Page bundles (for complete articles, keeping images and content together etc.).
* Bundled images can be processed in as many versions/sizes as you need with the three methods `Resize`, `Fill` and `Fit`.
* Processed images are cached inside `resources/_gen/images` (default) in your project.
* Symbolic links (both files and dirs) are now allowed anywhere inside /content
* A new table based build summary
* The "Total in nn ms" now reports the total including the handling of the files inside /static. So if it now reports more than you're used to, it is just **more real** and probably faster than before (see below).

A site building  benchmark run compared to `v0.31.1` shows that this should be slightly faster and use less memory:

```bash
▶ ./benchSite.sh "TOML,num_langs=.*,num_root_sections=5,num_pages=(500|1000),tags_per_page=5,shortcodes,render"

benchmark                                                                                                         old ns/op     new ns/op     delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4      101785785     78067944      -23.30%
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4     185481057     149159919     -19.58%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4      103149918     85679409      -16.94%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4     203515478     169208775     -16.86%

benchmark                                                                                                         old allocs     new allocs     delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4      532464         391539         -26.47%
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4     1056549        772702         -26.87%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4      555974         406630         -26.86%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4     1086545        789922         -27.30%

benchmark                                                                                                         old bytes     new bytes     delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4      53243246      43598155      -18.12%
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4     105811617     86087116      -18.64%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4      54558852      44545097      -18.35%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4     106903858     86978413      -18.64%
```

Fixes #3651
Closes #3158
Fixes #1014
Closes #2021
Fixes #1240
Updates #3757

commands/benchmark.go

@@ -48,12 +48,7 @@ func init() {
 }
 
 func benchmark(cmd *cobra.Command, args []string) error {
-	cfg, err := InitializeConfig(benchmarkCmd)
-	if err != nil {
-		return err
-	}
-
-	c, err := newCommandeer(cfg)
+	c, err := InitializeConfig(false, nil, benchmarkCmd)
 	if err != nil {
 		return err
 	}
@@ -84,7 +79,7 @@ func benchmark(cmd *cobra.Command, args []string) error {
 
 	t := time.Now()
 	for i := 0; i < benchmarkTimes; i++ {
-		if err = c.resetAndBuildSites(false); err != nil {
+		if err = c.resetAndBuildSites(); err != nil {
 			return err
 		}
 	}

commands/commandeer.go

@@ -18,6 +18,7 @@ import (
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
+	src "github.com/gohugoio/hugo/source"
 )
 
 type commandeer struct {
@@ -25,7 +26,10 @@ type commandeer struct {
 	pathSpec    *helpers.PathSpec
 	visitedURLs *types.EvictingStringQueue
 
+	staticDirsConfig []*src.Dirs
+
 	serverPorts []int
+	languages   helpers.Languages
 
 	configured bool
 }
@@ -44,10 +48,6 @@ func (c *commandeer) PathSpec() *helpers.PathSpec {
 	return c.pathSpec
 }
 
-func (c *commandeer) languages() helpers.Languages {
-	return c.Cfg.Get("languagesSorted").(helpers.Languages)
-}
-
 func (c *commandeer) initFs(fs *hugofs.Fs) error {
 	c.DepsCfg.Fs = fs
 	ps, err := helpers.NewPathSpec(fs, c.Cfg)
@@ -55,18 +55,26 @@ func (c *commandeer) initFs(fs *hugofs.Fs) error {
 		return err
 	}
 	c.pathSpec = ps
+
+	dirsConfig, err := c.createStaticDirsConfig()
+	if err != nil {
+		return err
+	}
+	c.staticDirsConfig = dirsConfig
+
 	return nil
 }
 
-func newCommandeer(cfg *deps.DepsCfg) (*commandeer, error) {
-	l := cfg.Language
-	if l == nil {
-		l = helpers.NewDefaultLanguage(cfg.Cfg)
-	}
-	ps, err := helpers.NewPathSpec(cfg.Fs, l)
-	if err != nil {
-		return nil, err
+func newCommandeer(cfg *deps.DepsCfg, running bool) (*commandeer, error) {
+	cfg.Running = running
+
+	var languages helpers.Languages
+
+	if l, ok := cfg.Cfg.Get("languagesSorted").(helpers.Languages); ok {
+		languages = l
 	}
 
-	return &commandeer{DepsCfg: cfg, pathSpec: ps, visitedURLs: types.NewEvictingStringQueue(10)}, nil
+	c := &commandeer{DepsCfg: cfg, languages: languages, visitedURLs: types.NewEvictingStringQueue(10)}
+
+	return c, nil
 }

commands/convert.go

@@ -14,12 +14,15 @@
 package commands
 
 import (
-	"errors"
 	"fmt"
-	"path/filepath"
 	"time"
 
+	src "github.com/gohugoio/hugo/source"
+
 	"github.com/gohugoio/hugo/hugolib"
+
+	"path/filepath"
+
 	"github.com/gohugoio/hugo/parser"
 	"github.com/spf13/cast"
 	"github.com/spf13/cobra"
@@ -78,81 +81,103 @@ func init() {
 }
 
 func convertContents(mark rune) error {
-	cfg, err := InitializeConfig()
+	if outputDir == "" && !unsafe {
+		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
+	}
+
+	c, err := InitializeConfig(false, nil)
 	if err != nil {
 		return err
 	}
 
-	h, err := hugolib.NewHugoSites(*cfg)
+	h, err := hugolib.NewHugoSites(*c.DepsCfg)
 	if err != nil {
 		return err
 	}
 
+	if err := h.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+		return err
+	}
+
 	site := h.Sites[0]
 
-	if err = site.Initialise(); err != nil {
-		return err
-	}
-
-	if site.Source == nil {
-		panic("site.Source not set")
-	}
-	if len(site.Source.Files()) < 1 {
-		return errors.New("No source files found")
-	}
-
-	contentDir := site.PathSpec.AbsPathify(site.Cfg.GetString("contentDir"))
-	site.Log.FEEDBACK.Println("processing", len(site.Source.Files()), "content files")
-	for _, file := range site.Source.Files() {
-		site.Log.INFO.Println("Attempting to convert", file.LogicalName())
-		page, err := site.NewPage(file.LogicalName())
-		if err != nil {
+	site.Log.FEEDBACK.Println("processing", len(site.AllPages), "content files")
+	for _, p := range site.AllPages {
+		if err := convertAndSavePage(p, site, mark); err != nil {
 			return err
 		}
-
-		psr, err := parser.ReadFrom(file.Contents)
-		if err != nil {
-			site.Log.ERROR.Println("Error processing file:", file.Path())
-			return err
-		}
-		metadata, err := psr.Metadata()
-		if err != nil {
-			site.Log.ERROR.Println("Error processing file:", file.Path())
-			return err
-		}
-
-		// better handling of dates in formats that don't have support for them
-		if mark == parser.FormatToLeadRune("json") || mark == parser.FormatToLeadRune("yaml") || mark == parser.FormatToLeadRune("toml") {
-			newMetadata := cast.ToStringMap(metadata)
-			for k, v := range newMetadata {
-				switch vv := v.(type) {
-				case time.Time:
-					newMetadata[k] = vv.Format(time.RFC3339)
-				}
-			}
-			metadata = newMetadata
-		}
-
-		page.SetDir(filepath.Join(contentDir, file.Dir()))
-		page.SetSourceContent(psr.Content())
-		if err = page.SetSourceMetaData(metadata, mark); err != nil {
-			site.Log.ERROR.Printf("Failed to set source metadata for file %q: %s. For more info see For more info see https://github.com/gohugoio/hugo/issues/2458", page.FullFilePath(), err)
-			continue
-		}
-
-		if outputDir != "" {
-			if err = page.SaveSourceAs(filepath.Join(outputDir, page.FullFilePath())); err != nil {
-				return fmt.Errorf("Failed to save file %q: %s", page.FullFilePath(), err)
-			}
-		} else {
-			if unsafe {
-				if err = page.SaveSource(); err != nil {
-					return fmt.Errorf("Failed to save file %q: %s", page.FullFilePath(), err)
-				}
-			} else {
-				site.Log.FEEDBACK.Println("Unsafe operation not allowed, use --unsafe or set a different output path")
-			}
-		}
 	}
 	return nil
 }
+
+func convertAndSavePage(p *hugolib.Page, site *hugolib.Site, mark rune) error {
+	// The resources are not in .Site.AllPages.
+	for _, r := range p.Resources.ByType("page") {
+		if err := convertAndSavePage(r.(*hugolib.Page), site, mark); err != nil {
+			return err
+		}
+	}
+
+	if p.Filename() == "" {
+		// No content file.
+		return nil
+	}
+
+	site.Log.INFO.Println("Attempting to convert", p.LogicalName())
+	newPage, err := site.NewPage(p.LogicalName())
+	if err != nil {
+		return err
+	}
+
+	f, _ := p.File.(src.ReadableFile)
+	file, err := f.Open()
+	if err != nil {
+		site.Log.ERROR.Println("Error reading file:", p.Path())
+		file.Close()
+		return nil
+	}
+
+	psr, err := parser.ReadFrom(file)
+	if err != nil {
+		site.Log.ERROR.Println("Error processing file:", p.Path())
+		file.Close()
+		return err
+	}
+
+	file.Close()
+
+	metadata, err := psr.Metadata()
+	if err != nil {
+		site.Log.ERROR.Println("Error processing file:", p.Path())
+		return err
+	}
+
+	// better handling of dates in formats that don't have support for them
+	if mark == parser.FormatToLeadRune("json") || mark == parser.FormatToLeadRune("yaml") || mark == parser.FormatToLeadRune("toml") {
+		newMetadata := cast.ToStringMap(metadata)
+		for k, v := range newMetadata {
+			switch vv := v.(type) {
+			case time.Time:
+				newMetadata[k] = vv.Format(time.RFC3339)
+			}
+		}
+		metadata = newMetadata
+	}
+
+	newPage.SetSourceContent(psr.Content())
+	if err = newPage.SetSourceMetaData(metadata, mark); err != nil {
+		site.Log.ERROR.Printf("Failed to set source metadata for file %q: %s. For more info see For more info see https://github.com/gohugoio/hugo/issues/2458", newPage.FullFilePath(), err)
+		return nil
+	}
+
+	newFilename := p.Filename()
+	if outputDir != "" {
+		newFilename = filepath.Join(outputDir, p.Dir(), newPage.LogicalName())
+	}
+
+	if err = newPage.SaveSourceAs(newFilename); err != nil {
+		return fmt.Errorf("Failed to save file %q: %s", newFilename, err)
+	}
+
+	return nil
+}

commands/hugo.go

@@ -18,6 +18,10 @@ package commands
 import (
 	"fmt"
 	"io/ioutil"
+	"sort"
+	"sync/atomic"
+
+	"golang.org/x/sync/errgroup"
 
 	"github.com/gohugoio/hugo/hugofs"
 
@@ -58,6 +62,13 @@ import (
 // provide a cleaner external API, but until then, this is it.
 var Hugo *hugolib.HugoSites
 
+const (
+	ansiEsc    = "\u001B"
+	clearLine  = "\r\033[K"
+	hideCursor = ansiEsc + "[?25l"
+	showCursor = ansiEsc + "[?25h"
+)
+
 // Reset resets Hugo ready for a new full build. This is mainly only useful
 // for benchmark testing etc. via the CLI commands.
 func Reset() error {
@@ -116,18 +127,20 @@ built with love by spf13 and friends in Go.
 
 Complete documentation is available at http://gohugo.io/.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		cfg, err := InitializeConfig()
-		if err != nil {
-			return err
+
+		cfgInit := func(c *commandeer) error {
+			if buildWatch {
+				c.Set("disableLiveReload", true)
+			}
+			return nil
 		}
 
-		c, err := newCommandeer(cfg)
+		c, err := InitializeConfig(buildWatch, cfgInit)
 		if err != nil {
 			return err
 		}
 
 		if buildWatch {
-			cfg.Cfg.Set("disableLiveReload", true)
 			c.watchConfig()
 		}
 
@@ -149,6 +162,7 @@ var (
 )
 
 var (
+	gc              bool
 	baseURL         string
 	cacheDir        string
 	contentDir      string
@@ -201,6 +215,7 @@ func AddCommands() {
 	genCmd.AddCommand(genmanCmd)
 	genCmd.AddCommand(createGenDocsHelper().cmd)
 	genCmd.AddCommand(createGenChromaStyles().cmd)
+
 }
 
 // initHugoBuilderFlags initializes all common flags, typically used by the
@@ -240,6 +255,7 @@ func initHugoBuildCommonFlags(cmd *cobra.Command) {
 	cmd.Flags().Bool("canonifyURLs", false, "if true, all relative URLs will be canonicalized using baseURL")
 	cmd.Flags().StringVarP(&baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. http://spf13.com/")
 	cmd.Flags().Bool("enableGitInfo", false, "add Git revision, date and author info to the pages")
+	cmd.Flags().BoolVar(&gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
 
 	cmd.Flags().BoolVar(&nitro.AnalysisOn, "stepAnalysis", false, "display memory and timing of different steps of the program")
 	cmd.Flags().Bool("templateMetrics", false, "display metrics about template executions")
@@ -285,7 +301,7 @@ func init() {
 }
 
 // InitializeConfig initializes a config file with sensible default configuration flags.
-func InitializeConfig(subCmdVs ...*cobra.Command) (*deps.DepsCfg, error) {
+func InitializeConfig(running bool, doWithCommandeer func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) {
 
 	var cfg *deps.DepsCfg = &deps.DepsCfg{}
 
@@ -294,13 +310,13 @@ func InitializeConfig(subCmdVs ...*cobra.Command) (*deps.DepsCfg, error) {
 
 	config, err := hugolib.LoadConfig(osFs, source, cfgFile)
 	if err != nil {
-		return cfg, err
+		return nil, err
 	}
 
 	// Init file systems. This may be changed at a later point.
 	cfg.Cfg = config
 
-	c, err := newCommandeer(cfg)
+	c, err := newCommandeer(cfg, running)
 	if err != nil {
 		return nil, err
 	}
@@ -309,23 +325,29 @@ func InitializeConfig(subCmdVs ...*cobra.Command) (*deps.DepsCfg, error) {
 		c.initializeFlags(cmdV)
 	}
 
+	if baseURL != "" {
+		config.Set("baseURL", baseURL)
+	}
+
+	if doWithCommandeer != nil {
+		if err := doWithCommandeer(c); err != nil {
+			return nil, err
+		}
+	}
+
 	if len(disableKinds) > 0 {
 		c.Set("disableKinds", disableKinds)
 	}
 
 	logger, err := createLogger(cfg.Cfg)
 	if err != nil {
-		return cfg, err
+		return nil, err
 	}
 
 	cfg.Logger = logger
 
 	config.Set("logI18nWarnings", logI18nWarnings)
 
-	if baseURL != "" {
-		config.Set("baseURL", baseURL)
-	}
-
 	if !config.GetBool("relativeURLs") && config.GetString("baseURL") == "" {
 		cfg.Logger.ERROR.Println("No 'baseURL' set in configuration or as a flag. Features like page menus will not work without one.")
 	}
@@ -350,17 +372,6 @@ func InitializeConfig(subCmdVs ...*cobra.Command) (*deps.DepsCfg, error) {
 	}
 	config.Set("workingDir", dir)
 
-	fs := hugofs.NewFrom(osFs, config)
-
-	// Hugo writes the output to memory instead of the disk.
-	// This is only used for benchmark testing. Cause the content is only visible
-	// in memory.
-	if renderToMemory {
-		fs.Destination = new(afero.MemMapFs)
-		// Rendering to memoryFS, publish to Root regardless of publishDir.
-		c.Set("publishDir", "/")
-	}
-
 	if contentDir != "" {
 		config.Set("contentDir", contentDir)
 	}
@@ -373,6 +384,17 @@ func InitializeConfig(subCmdVs ...*cobra.Command) (*deps.DepsCfg, error) {
 		config.Set("cacheDir", cacheDir)
 	}
 
+	fs := hugofs.NewFrom(osFs, config)
+
+	// Hugo writes the output to memory instead of the disk.
+	// This is only used for benchmark testing. Cause the content is only visible
+	// in memory.
+	if config.GetBool("renderToMemory") {
+		fs.Destination = new(afero.MemMapFs)
+		// Rendering to memoryFS, publish to Root regardless of publishDir.
+		config.Set("publishDir", "/")
+	}
+
 	cacheDir = config.GetString("cacheDir")
 	if cacheDir != "" {
 		if helpers.FilePathSeparator != cacheDir[len(cacheDir)-1:] {
@@ -397,7 +419,7 @@ func InitializeConfig(subCmdVs ...*cobra.Command) (*deps.DepsCfg, error) {
 	themeDir := c.PathSpec().GetThemeDir()
 	if themeDir != "" {
 		if _, err := cfg.Fs.Source.Stat(themeDir); os.IsNotExist(err) {
-			return cfg, newSystemError("Unable to find theme Directory:", themeDir)
+			return nil, newSystemError("Unable to find theme Directory:", themeDir)
 		}
 	}
 
@@ -408,7 +430,7 @@ func InitializeConfig(subCmdVs ...*cobra.Command) (*deps.DepsCfg, error) {
 			helpers.CurrentHugoVersion.ReleaseVersion(), minVersion)
 	}
 
-	return cfg, nil
+	return c, nil
 
 }
 
@@ -482,17 +504,17 @@ func (c *commandeer) initializeFlags(cmd *cobra.Command) {
 		"templateMetricsHints",
 	}
 
-	// Remove these in Hugo 0.23.
+	// Remove these in Hugo 0.33.
 	if cmd.Flags().Changed("disable404") {
-		helpers.Deprecated("command line", "--disable404", "Use --disableKinds=404", false)
+		helpers.Deprecated("command line", "--disable404", "Use --disableKinds=404", true)
 	}
 
 	if cmd.Flags().Changed("disableRSS") {
-		helpers.Deprecated("command line", "--disableRSS", "Use --disableKinds=RSS", false)
+		helpers.Deprecated("command line", "--disableRSS", "Use --disableKinds=RSS", true)
 	}
 
 	if cmd.Flags().Changed("disableSitemap") {
-		helpers.Deprecated("command line", "--disableSitemap", "Use --disableKinds=sitemap", false)
+		helpers.Deprecated("command line", "--disableSitemap", "Use --disableKinds=sitemap", true)
 	}
 
 	for _, key := range persFlagKeys {
@@ -525,16 +547,71 @@ func (c *commandeer) watchConfig() {
 	})
 }
 
+func (c *commandeer) fullBuild(watches ...bool) error {
+	var (
+		g         errgroup.Group
+		langCount map[string]uint64
+	)
+
+	if !quiet {
+		fmt.Print(hideCursor + "Building sites … ")
+		defer func() {
+			fmt.Print(showCursor + clearLine)
+		}()
+	}
+
+	g.Go(func() error {
+		cnt, err := c.copyStatic()
+		if err != nil {
+			return fmt.Errorf("Error copying static files: %s", err)
+		}
+		langCount = cnt
+		return nil
+	})
+
+	g.Go(func() error {
+		if err := c.buildSites(); err != nil {
+			return fmt.Errorf("Error building site: %s", err)
+		}
+
+		return nil
+	})
+
+	if err := g.Wait(); err != nil {
+		return err
+	}
+
+	for _, s := range Hugo.Sites {
+		s.ProcessingStats.Static = langCount[s.Language.Lang]
+	}
+
+	if gc {
+		count, err := Hugo.GC()
+		if err != nil {
+			return err
+		}
+		for _, s := range Hugo.Sites {
+			// We have no way of knowing what site the garbage belonged to.
+			s.ProcessingStats.Cleaned = uint64(count)
+		}
+	}
+
+	return nil
+
+}
+
 func (c *commandeer) build(watches ...bool) error {
-	if err := c.copyStatic(); err != nil {
-		return fmt.Errorf("Error copying static files: %s", err)
+	defer c.timeTrack(time.Now(), "Total")
+
+	if err := c.fullBuild(watches...); err != nil {
+		return err
 	}
-	watch := false
-	if len(watches) > 0 && watches[0] {
-		watch = true
-	}
-	if err := c.buildSites(buildWatch || watch); err != nil {
-		return fmt.Errorf("Error building site: %s", err)
+
+	// TODO(bep) Feedback?
+	if !quiet {
+		fmt.Println()
+		Hugo.PrintProcessingStats(os.Stdout)
+		fmt.Println()
 	}
 
 	if buildWatch {
@@ -550,62 +627,101 @@ func (c *commandeer) build(watches ...bool) error {
 	return nil
 }
 
-func (c *commandeer) copyStatic() error {
+func (c *commandeer) copyStatic() (map[string]uint64, error) {
 	return c.doWithPublishDirs(c.copyStaticTo)
 }
 
-func (c *commandeer) doWithPublishDirs(f func(dirs *src.Dirs, publishDir string) error) error {
-	publishDir := c.PathSpec().AbsPathify(c.Cfg.GetString("publishDir")) + helpers.FilePathSeparator
-	// If root, remove the second '/'
-	if publishDir == "//" {
-		publishDir = helpers.FilePathSeparator
-	}
+func (c *commandeer) createStaticDirsConfig() ([]*src.Dirs, error) {
+	var dirsConfig []*src.Dirs
 
-	languages := c.languages()
-
-	if !languages.IsMultihost() {
+	if !c.languages.IsMultihost() {
 		dirs, err := src.NewDirs(c.Fs, c.Cfg, c.DepsCfg.Logger)
 		if err != nil {
-			return err
+			return nil, err
 		}
-		return f(dirs, publishDir)
-	}
-
-	for _, l := range languages {
-		dir := filepath.Join(publishDir, l.Lang)
-		dirs, err := src.NewDirs(c.Fs, l, c.DepsCfg.Logger)
-		if err != nil {
-			return err
-		}
-		if err := f(dirs, dir); err != nil {
-			return err
+		dirsConfig = append(dirsConfig, dirs)
+	} else {
+		for _, l := range c.languages {
+			dirs, err := src.NewDirs(c.Fs, l, c.DepsCfg.Logger)
+			if err != nil {
+				return nil, err
+			}
+			dirsConfig = append(dirsConfig, dirs)
 		}
 	}
 
-	return nil
+	return dirsConfig, nil
+
 }
 
-func (c *commandeer) copyStaticTo(dirs *src.Dirs, publishDir string) error {
+func (c *commandeer) doWithPublishDirs(f func(dirs *src.Dirs, publishDir string) (uint64, error)) (map[string]uint64, error) {
+
+	langCount := make(map[string]uint64)
+
+	for _, dirs := range c.staticDirsConfig {
+
+		cnt, err := f(dirs, c.pathSpec.PublishDir)
+		if err != nil {
+			return langCount, err
+		}
+
+		if dirs.Language == nil {
+			// Not multihost
+			for _, l := range c.languages {
+				langCount[l.Lang] = cnt
+			}
+		} else {
+			langCount[dirs.Language.Lang] = cnt
+		}
+
+	}
+
+	return langCount, nil
+}
+
+type countingStatFs struct {
+	afero.Fs
+	statCounter uint64
+}
+
+func (fs *countingStatFs) Stat(name string) (os.FileInfo, error) {
+	f, err := fs.Fs.Stat(name)
+	if err == nil {
+		if !f.IsDir() {
+			atomic.AddUint64(&fs.statCounter, 1)
+		}
+	}
+	return f, err
+}
+
+func (c *commandeer) copyStaticTo(dirs *src.Dirs, publishDir string) (uint64, error) {
 
 	// If root, remove the second '/'
 	if publishDir == "//" {
 		publishDir = helpers.FilePathSeparator
 	}
 
+	if dirs.Language != nil {
+		// Multihost setup.
+		publishDir = filepath.Join(publishDir, dirs.Language.Lang)
+	}
+
 	staticSourceFs, err := dirs.CreateStaticFs()
 	if err != nil {
-		return err
+		return 0, err
 	}
 
 	if staticSourceFs == nil {
 		c.Logger.WARN.Println("No static directories found to sync")
-		return nil
+		return 0, nil
 	}
 
+	fs := &countingStatFs{Fs: staticSourceFs}
+
 	syncer := fsync.NewSyncer()
 	syncer.NoTimes = c.Cfg.GetBool("noTimes")
 	syncer.NoChmod = c.Cfg.GetBool("noChmod")
-	syncer.SrcFs = staticSourceFs
+	syncer.SrcFs = fs
 	syncer.DestFs = c.Fs.Destination
 	// Now that we are using a unionFs for the static directories
 	// We can effectively clean the publishDir on initial sync
@@ -622,12 +738,30 @@ func (c *commandeer) copyStaticTo(dirs *src.Dirs, publishDir string) error {
 
 	// because we are using a baseFs (to get the union right).
 	// set sync src to root
-	return syncer.Sync(publishDir, helpers.FilePathSeparator)
+	err = syncer.Sync(publishDir, helpers.FilePathSeparator)
+	if err != nil {
+		return 0, err
+	}
+
+	// Sync runs Stat 3 times for every source file (which sounds much)
+	numFiles := fs.statCounter / 3
+
+	return numFiles, err
+}
+
+func (c *commandeer) timeTrack(start time.Time, name string) {
+	elapsed := time.Since(start)
+	c.Logger.FEEDBACK.Printf("%s in %v ms", name, int(1000*elapsed.Seconds()))
 }
 
 // getDirList provides NewWatcher() with a list of directories to watch for changes.
 func (c *commandeer) getDirList() ([]string, error) {
 	var a []string
+
+	// To handle nested symlinked content dirs
+	var seen = make(map[string]bool)
+	var nested []string
+
 	dataDir := c.PathSpec().AbsPathify(c.Cfg.GetString("dataDir"))
 	i18nDir := c.PathSpec().AbsPathify(c.Cfg.GetString("i18nDir"))
 	staticSyncer, err := newStaticSyncer(c)
@@ -638,86 +772,121 @@ func (c *commandeer) getDirList() ([]string, error) {
 	layoutDir := c.PathSpec().GetLayoutDirPath()
 	staticDirs := staticSyncer.d.AbsStaticDirs
 
-	walker := func(path string, fi os.FileInfo, err error) error {
-		if err != nil {
-			if path == dataDir && os.IsNotExist(err) {
-				c.Logger.WARN.Println("Skip dataDir:", err)
-				return nil
-			}
-
-			if path == i18nDir && os.IsNotExist(err) {
-				c.Logger.WARN.Println("Skip i18nDir:", err)
-				return nil
-			}
-
-			if path == layoutDir && os.IsNotExist(err) {
-				c.Logger.WARN.Println("Skip layoutDir:", err)
-				return nil
-			}
-
-			if os.IsNotExist(err) {
-				for _, staticDir := range staticDirs {
-					if path == staticDir && os.IsNotExist(err) {
-						c.Logger.WARN.Println("Skip staticDir:", err)
-					}
+	newWalker := func(allowSymbolicDirs bool) func(path string, fi os.FileInfo, err error) error {
+		return func(path string, fi os.FileInfo, err error) error {
+			if err != nil {
+				if path == dataDir && os.IsNotExist(err) {
+					c.Logger.WARN.Println("Skip dataDir:", err)
+					return nil
 				}
-				// Ignore.
+
+				if path == i18nDir && os.IsNotExist(err) {
+					c.Logger.WARN.Println("Skip i18nDir:", err)
+					return nil
+				}
+
+				if path == layoutDir && os.IsNotExist(err) {
+					c.Logger.WARN.Println("Skip layoutDir:", err)
+					return nil
+				}
+
+				if os.IsNotExist(err) {
+					for _, staticDir := range staticDirs {
+						if path == staticDir && os.IsNotExist(err) {
+							c.Logger.WARN.Println("Skip staticDir:", err)
+						}
+					}
+					// Ignore.
+					return nil
+				}
+
+				c.Logger.ERROR.Println("Walker: ", err)
 				return nil
 			}
 
-			c.Logger.ERROR.Println("Walker: ", err)
-			return nil
-		}
-
-		// Skip .git directories.
-		// Related to https://github.com/gohugoio/hugo/issues/3468.
-		if fi.Name() == ".git" {
-			return nil
-		}
-
-		if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
-			link, err := filepath.EvalSymlinks(path)
-			if err != nil {
-				c.Logger.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", path, err)
+			// Skip .git directories.
+			// Related to https://github.com/gohugoio/hugo/issues/3468.
+			if fi.Name() == ".git" {
 				return nil
 			}
-			linkfi, err := c.Fs.Source.Stat(link)
-			if err != nil {
-				c.Logger.ERROR.Printf("Cannot stat '%s', error was: %s", link, err)
-				return nil
+
+			if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
+				link, err := filepath.EvalSymlinks(path)
+				if err != nil {
+					c.Logger.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", path, err)
+					return nil
+				}
+				linkfi, err := helpers.LstatIfOs(c.Fs.Source, link)
+				if err != nil {
+					c.Logger.ERROR.Printf("Cannot stat %q: %s", link, err)
+					return nil
+				}
+				if !allowSymbolicDirs && !linkfi.Mode().IsRegular() {
+					c.Logger.ERROR.Printf("Symbolic links for directories not supported, skipping %q", path)
+					return nil
+				}
+
+				if allowSymbolicDirs && linkfi.IsDir() {
+					// afero.Walk will not walk symbolic links, so wee need to do it.
+					if !seen[path] {
+						seen[path] = true
+						nested = append(nested, path)
+					}
+					return nil
+				}
+
+				fi = linkfi
 			}
-			if !linkfi.Mode().IsRegular() {
-				c.Logger.ERROR.Printf("Symbolic links for directories not supported, skipping '%s'", path)
+
+			if fi.IsDir() {
+				if fi.Name() == ".git" ||
+					fi.Name() == "node_modules" || fi.Name() == "bower_components" {
+					return filepath.SkipDir
+				}
+				a = append(a, path)
 			}
 			return nil
 		}
-
-		if fi.IsDir() {
-			if fi.Name() == ".git" ||
-				fi.Name() == "node_modules" || fi.Name() == "bower_components" {
-				return filepath.SkipDir
-			}
-			a = append(a, path)
-		}
-		return nil
 	}
 
+	symLinkWalker := newWalker(true)
+	regularWalker := newWalker(false)
+
 	// SymbolicWalk will log anny ERRORs
-	_ = helpers.SymbolicWalk(c.Fs.Source, dataDir, walker)
-	_ = helpers.SymbolicWalk(c.Fs.Source, c.PathSpec().AbsPathify(c.Cfg.GetString("contentDir")), walker)
-	_ = helpers.SymbolicWalk(c.Fs.Source, i18nDir, walker)
-	_ = helpers.SymbolicWalk(c.Fs.Source, layoutDir, walker)
+	_ = helpers.SymbolicWalk(c.Fs.Source, dataDir, regularWalker)
+	_ = helpers.SymbolicWalk(c.Fs.Source, c.PathSpec().AbsPathify(c.Cfg.GetString("contentDir")), symLinkWalker)
+	_ = helpers.SymbolicWalk(c.Fs.Source, i18nDir, regularWalker)
+	_ = helpers.SymbolicWalk(c.Fs.Source, layoutDir, regularWalker)
 	for _, staticDir := range staticDirs {
-		_ = helpers.SymbolicWalk(c.Fs.Source, staticDir, walker)
+		_ = helpers.SymbolicWalk(c.Fs.Source, staticDir, regularWalker)
 	}
 
 	if c.PathSpec().ThemeSet() {
 		themesDir := c.PathSpec().GetThemeDir()
-		_ = helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "layouts"), walker)
-		_ = helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "i18n"), walker)
-		_ = helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "data"), walker)
+		_ = helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "layouts"), regularWalker)
+		_ = helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "i18n"), regularWalker)
+		_ = helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "data"), regularWalker)
 	}
 
+	if len(nested) > 0 {
+		for {
+
+			toWalk := nested
+			nested = nested[:0]
+
+			for _, d := range toWalk {
+				_ = helpers.SymbolicWalk(c.Fs.Source, d, symLinkWalker)
+			}
+
+			if len(nested) == 0 {
+				break
+			}
+		}
+	}
+
+	a = helpers.UniqueStrings(a)
+	sort.Strings(a)
+
 	return a, nil
 }
 
@@ -728,17 +897,17 @@ func (c *commandeer) recreateAndBuildSites(watching bool) (err error) {
 	if !quiet {
 		c.Logger.FEEDBACK.Println("Started building sites ...")
 	}
-	return Hugo.Build(hugolib.BuildCfg{CreateSitesFromConfig: true, Watching: watching, PrintStats: !quiet})
+	return Hugo.Build(hugolib.BuildCfg{CreateSitesFromConfig: true})
 }
 
-func (c *commandeer) resetAndBuildSites(watching bool) (err error) {
+func (c *commandeer) resetAndBuildSites() (err error) {
 	if err = c.initSites(); err != nil {
 		return
 	}
 	if !quiet {
 		c.Logger.FEEDBACK.Println("Started building sites ...")
 	}
-	return Hugo.Build(hugolib.BuildCfg{ResetState: true, Watching: watching, PrintStats: !quiet})
+	return Hugo.Build(hugolib.BuildCfg{ResetState: true})
 }
 
 func (c *commandeer) initSites() error {
@@ -755,17 +924,16 @@ func (c *commandeer) initSites() error {
 	return nil
 }
 
-func (c *commandeer) buildSites(watching bool) (err error) {
+func (c *commandeer) buildSites() (err error) {
 	if err := c.initSites(); err != nil {
 		return err
 	}
-	if !quiet {
-		c.Logger.FEEDBACK.Println("Started building sites ...")
-	}
-	return Hugo.Build(hugolib.BuildCfg{Watching: watching, PrintStats: !quiet})
+	return Hugo.Build(hugolib.BuildCfg{})
 }
 
 func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
+	defer c.timeTrack(time.Now(), "Total")
+
 	if err := c.initSites(); err != nil {
 		return err
 	}
@@ -776,7 +944,7 @@ func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
 		// Make sure we always render the home page
 		visited[home] = true
 	}
-	return Hugo.Build(hugolib.BuildCfg{PrintStats: !quiet, Watching: true, RecentlyVisited: visited}, events...)
+	return Hugo.Build(hugolib.BuildCfg{RecentlyVisited: visited}, events...)
 }
 
 // newWatcher creates a new watcher to watch filesystem events.
@@ -818,6 +986,37 @@ func (c *commandeer) newWatcher(serve bool, dirList ...string) error {
 				staticEvents := []fsnotify.Event{}
 				dynamicEvents := []fsnotify.Event{}
 
+				// Special handling for symbolic links inside /content.
+				filtered := []fsnotify.Event{}
+				for _, ev := range evs {
+					// Check the most specific first, i.e. files.
+					contentMapped := Hugo.ContentChanges.GetSymbolicLinkMappings(ev.Name)
+					if len(contentMapped) > 0 {
+						for _, mapped := range contentMapped {
+							filtered = append(filtered, fsnotify.Event{Name: mapped, Op: ev.Op})
+						}
+						continue
+					}
+
+					// Check for any symbolic directory mapping.
+
+					dir, name := filepath.Split(ev.Name)
+
+					contentMapped = Hugo.ContentChanges.GetSymbolicLinkMappings(dir)
+
+					if len(contentMapped) == 0 {
+						filtered = append(filtered, ev)
+						continue
+					}
+
+					for _, mapped := range contentMapped {
+						mappedFilename := filepath.Join(mapped, name)
+						filtered = append(filtered, fsnotify.Event{Name: mappedFilename, Op: ev.Op})
+					}
+				}
+
+				evs = filtered
+
 				for _, ev := range evs {
 					ext := filepath.Ext(ev.Name)
 					baseName := filepath.Base(ev.Name)
@@ -894,7 +1093,7 @@ func (c *commandeer) newWatcher(serve bool, dirList ...string) error {
 
 					if c.Cfg.GetBool("forceSyncStatic") {
 						c.Logger.FEEDBACK.Printf("Syncing all static files\n")
-						err := c.copyStatic()
+						_, err := c.copyStatic()
 						if err != nil {
 							utils.StopOnErr(c.Logger, err, "Error copying static files to publish dir")
 						}
@@ -932,8 +1131,9 @@ func (c *commandeer) newWatcher(serve bool, dirList ...string) error {
 						}
 
 					}
+
 					c.Logger.FEEDBACK.Println("\nChange detected, rebuilding site")
-					const layout = "2006-01-02 15:04 -0700"
+					const layout = "2006-01-02 15:04:05.000 -0700"
 					c.Logger.FEEDBACK.Println(time.Now().Format(layout))
 
 					if err := c.rebuildSites(dynamicEvents); err != nil {
@@ -950,6 +1150,7 @@ func (c *commandeer) newWatcher(serve bool, dirList ...string) error {
 							if onePageName != "" {
 								p = Hugo.GetContentPage(onePageName)
 							}
+
 						}
 
 						if p != nil {
@@ -978,6 +1179,9 @@ func (c *commandeer) newWatcher(serve bool, dirList ...string) error {
 func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
 	name := ""
 
+	// Some editors (for example notepad.exe on Windows) triggers a change
+	// both for directory and file. So we pick the longest path, which should
+	// be the file itself.
 	for _, ev := range events {
 		if (ev.Op&fsnotify.Write == fsnotify.Write || ev.Op&fsnotify.Create == fsnotify.Create) && len(ev.Name) > len(name) {
 			name = ev.Name

commands/import_jekyll.go

@@ -468,7 +468,6 @@ func convertJekyllPost(s *hugolib.Site, path, relPath, targetDir string, draft b
 		return err
 	}
 
-	page.SetDir(targetParentDir)
 	page.SetSourceContent([]byte(content))
 	page.SetSourceMetaData(newmetadata, parser.FormatToLeadRune("yaml"))
 	page.SaveSourceAs(targetFile)

commands/list.go

@@ -43,20 +43,16 @@ var listDraftsCmd = &cobra.Command{
 	Short: "List all drafts",
 	Long:  `List all of the drafts in your content directory.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-
-		cfg, err := InitializeConfig()
+		cfgInit := func(c *commandeer) error {
+			c.Set("buildDrafts", true)
+			return nil
+		}
+		c, err := InitializeConfig(false, cfgInit)
 		if err != nil {
 			return err
 		}
 
-		c, err := newCommandeer(cfg)
-		if err != nil {
-			return err
-		}
-
-		c.Set("buildDrafts", true)
-
-		sites, err := hugolib.NewHugoSites(*cfg)
+		sites, err := hugolib.NewHugoSites(*c.DepsCfg)
 
 		if err != nil {
 			return newSystemError("Error creating sites", err)
@@ -84,20 +80,16 @@ var listFutureCmd = &cobra.Command{
 	Long: `List all of the posts in your content directory which will be
 posted in the future.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-
-		cfg, err := InitializeConfig()
+		cfgInit := func(c *commandeer) error {
+			c.Set("buildFuture", true)
+			return nil
+		}
+		c, err := InitializeConfig(false, cfgInit)
 		if err != nil {
 			return err
 		}
 
-		c, err := newCommandeer(cfg)
-		if err != nil {
-			return err
-		}
-
-		c.Set("buildFuture", true)
-
-		sites, err := hugolib.NewHugoSites(*cfg)
+		sites, err := hugolib.NewHugoSites(*c.DepsCfg)
 
 		if err != nil {
 			return newSystemError("Error creating sites", err)
@@ -125,20 +117,16 @@ var listExpiredCmd = &cobra.Command{
 	Long: `List all of the posts in your content directory which has already
 expired.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-
-		cfg, err := InitializeConfig()
+		cfgInit := func(c *commandeer) error {
+			c.Set("buildExpired", true)
+			return nil
+		}
+		c, err := InitializeConfig(false, cfgInit)
 		if err != nil {
 			return err
 		}
 
-		c, err := newCommandeer(cfg)
-		if err != nil {
-			return err
-		}
-
-		c.Set("buildExpired", true)
-
-		sites, err := hugolib.NewHugoSites(*cfg)
+		sites, err := hugolib.NewHugoSites(*c.DepsCfg)
 
 		if err != nil {
 			return newSystemError("Error creating sites", err)

commands/list_config.go

@@ -33,7 +33,7 @@ func init() {
 }
 
 func printConfig(cmd *cobra.Command, args []string) error {
-	cfg, err := InitializeConfig(configCmd)
+	cfg, err := InitializeConfig(false, nil, configCmd)
 
 	if err != nil {
 		return err

commands/new.go

@@ -86,21 +86,19 @@ as you see fit.`,
 
 // NewContent adds new content to a Hugo site.
 func NewContent(cmd *cobra.Command, args []string) error {
-	cfg, err := InitializeConfig()
+	cfgInit := func(c *commandeer) error {
+		if cmd.Flags().Changed("editor") {
+			c.Set("newContentEditor", contentEditor)
+		}
+		return nil
+	}
+
+	c, err := InitializeConfig(false, cfgInit)
 
 	if err != nil {
 		return err
 	}
 
-	c, err := newCommandeer(cfg)
-	if err != nil {
-		return err
-	}
-
-	if cmd.Flags().Changed("editor") {
-		c.Set("newContentEditor", contentEditor)
-	}
-
 	if len(args) < 1 {
 		return newUserError("path needs to be provided")
 	}
@@ -115,6 +113,8 @@ func NewContent(cmd *cobra.Command, args []string) error {
 		kind = contentType
 	}
 
+	cfg := c.DepsCfg
+
 	ps, err := helpers.NewPathSpec(cfg.Fs, cfg.Cfg)
 	if err != nil {
 		return err
@@ -130,7 +130,7 @@ func NewContent(cmd *cobra.Command, args []string) error {
 			return nil, err
 		}
 
-		if err := Hugo.Build(hugolib.BuildCfg{SkipRender: true, PrintStats: false}); err != nil {
+		if err := Hugo.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
 			return nil, err
 		}
 
@@ -240,7 +240,7 @@ func NewSite(cmd *cobra.Command, args []string) error {
 
 // NewTheme creates a new Hugo theme.
 func NewTheme(cmd *cobra.Command, args []string) error {
-	cfg, err := InitializeConfig()
+	c, err := InitializeConfig(false, nil)
 
 	if err != nil {
 		return err
@@ -250,14 +250,11 @@ func NewTheme(cmd *cobra.Command, args []string) error {
 		return newUserError("theme name needs to be provided")
 	}
 
-	c, err := newCommandeer(cfg)
-	if err != nil {
-		return err
-	}
-
 	createpath := c.PathSpec().AbsPathify(filepath.Join(c.Cfg.GetString("themesDir"), args[0]))
 	jww.INFO.Println("creating theme at", createpath)
 
+	cfg := c.DepsCfg
+
 	if x, _ := helpers.Exists(createpath, cfg.Fs.Source); x {
 		return newUserError(createpath, "already exists")
 	}
@@ -375,7 +372,11 @@ func newContentPathSection(path string) (string, string) {
 	var section string
 	// assume the first directory is the section (kind)
 	if strings.Contains(createpath[1:], helpers.FilePathSeparator) {
-		section = helpers.GuessSection(createpath)
+		parts := strings.Split(strings.TrimPrefix(createpath, helpers.FilePathSeparator), helpers.FilePathSeparator)
+		if len(parts) > 0 {
+			section = parts[0]
+		}
+
 	}
 
 	return createpath, section

commands/server.go

@@ -110,109 +110,94 @@ func init() {
 }
 
 func server(cmd *cobra.Command, args []string) error {
-	cfg, err := InitializeConfig(serverCmd)
-	if err != nil {
-		return err
+	// If a Destination is provided via flag write to disk
+	if destination != "" {
+		renderToDisk = true
 	}
 
-	c, err := newCommandeer(cfg)
-	if err != nil {
-		return err
-	}
-
-	if cmd.Flags().Changed("disableLiveReload") {
-		c.Set("disableLiveReload", disableLiveReload)
-	}
-
-	if cmd.Flags().Changed("navigateToChanged") {
-		c.Set("navigateToChanged", navigateToChanged)
-	}
-
-	if cmd.Flags().Changed("disableFastRender") {
-		c.Set("disableFastRender", disableFastRender)
-	}
-
-	if serverWatch {
-		c.Set("watch", true)
-	}
-
-	if c.Cfg.GetBool("watch") {
-		serverWatch = true
-		c.watchConfig()
-	}
-
-	languages := c.languages()
-	serverPorts := make([]int, 1)
-
-	if languages.IsMultihost() {
-		if !serverAppend {
-			return newSystemError("--appendPort=false not supported when in multihost mode")
+	cfgInit := func(c *commandeer) error {
+		c.Set("renderToMemory", !renderToDisk)
+		if cmd.Flags().Changed("navigateToChanged") {
+			c.Set("navigateToChanged", navigateToChanged)
+		}
+		if cmd.Flags().Changed("disableLiveReload") {
+			c.Set("disableLiveReload", disableLiveReload)
+		}
+		if cmd.Flags().Changed("disableFastRender") {
+			c.Set("disableFastRender", disableFastRender)
+		}
+		if serverWatch {
+			c.Set("watch", true)
 		}
-		serverPorts = make([]int, len(languages))
-	}
 
-	currentServerPort := serverPort
+		serverPorts := make([]int, 1)
 
-	for i := 0; i < len(serverPorts); i++ {
-		l, err := net.Listen("tcp", net.JoinHostPort(serverInterface, strconv.Itoa(currentServerPort)))
-		if err == nil {
-			l.Close()
-			serverPorts[i] = currentServerPort
+		if c.languages.IsMultihost() {
+			if !serverAppend {
+				return newSystemError("--appendPort=false not supported when in multihost mode")
+			}
+			serverPorts = make([]int, len(c.languages))
+		}
+
+		currentServerPort := serverPort
+
+		for i := 0; i < len(serverPorts); i++ {
+			l, err := net.Listen("tcp", net.JoinHostPort(serverInterface, strconv.Itoa(currentServerPort)))
+			if err == nil {
+				l.Close()
+				serverPorts[i] = currentServerPort
+			} else {
+				if i == 0 && serverCmd.Flags().Changed("port") {
+					// port set explicitly by user -- he/she probably meant it!
+					return newSystemErrorF("Server startup failed: %s", err)
+				}
+				jww.ERROR.Println("port", serverPort, "already in use, attempting to use an available port")
+				sp, err := helpers.FindAvailablePort()
+				if err != nil {
+					return newSystemError("Unable to find alternative port to use:", err)
+				}
+				serverPorts[i] = sp.Port
+			}
+
+			currentServerPort = serverPorts[i] + 1
+		}
+
+		c.serverPorts = serverPorts
+
+		c.Set("port", serverPort)
+		if liveReloadPort != -1 {
+			c.Set("liveReloadPort", liveReloadPort)
 		} else {
-			if i == 0 && serverCmd.Flags().Changed("port") {
-				// port set explicitly by user -- he/she probably meant it!
-				return newSystemErrorF("Server startup failed: %s", err)
-			}
-			jww.ERROR.Println("port", serverPort, "already in use, attempting to use an available port")
-			sp, err := helpers.FindAvailablePort()
-			if err != nil {
-				return newSystemError("Unable to find alternative port to use:", err)
-			}
-			serverPorts[i] = sp.Port
+			c.Set("liveReloadPort", serverPorts[0])
 		}
 
-		currentServerPort = serverPorts[i] + 1
-	}
-
-	c.serverPorts = serverPorts
-
-	c.Set("port", serverPort)
-	if liveReloadPort != -1 {
-		c.Set("liveReloadPort", liveReloadPort)
-	} else {
-		c.Set("liveReloadPort", serverPorts[0])
-	}
-
-	if languages.IsMultihost() {
-		for i, language := range languages {
-			baseURL, err = fixURL(language, baseURL, serverPorts[i])
+		if c.languages.IsMultihost() {
+			for i, language := range c.languages {
+				baseURL, err := fixURL(language, baseURL, serverPorts[i])
+				if err != nil {
+					return err
+				}
+				language.Set("baseURL", baseURL)
+			}
+		} else {
+			baseURL, err := fixURL(c.Cfg, baseURL, serverPorts[0])
 			if err != nil {
 				return err
 			}
-			language.Set("baseURL", baseURL)
+			c.Set("baseURL", baseURL)
 		}
-	} else {
-		baseURL, err = fixURL(c.Cfg, baseURL, serverPorts[0])
-		if err != nil {
-			return err
-		}
-		c.Set("baseURL", baseURL)
+
+		return nil
+
 	}
 
 	if err := memStats(); err != nil {
 		jww.ERROR.Println("memstats error:", err)
 	}
 
-	// If a Destination is provided via flag write to disk
-	if destination != "" {
-		renderToDisk = true
-	}
-
-	// Hugo writes the output to memory instead of the disk
-	if !renderToDisk {
-		cfg.Fs.Destination = new(afero.MemMapFs)
-		// Rendering to memoryFS, publish to Root regardless of publishDir.
-		c.Set("publishDir", "/")
+	c, err := InitializeConfig(true, cfgInit, serverCmd)
+	if err != nil {
+		return err
 	}
 
 	if err := c.build(serverWatch); err != nil {
@@ -223,6 +208,10 @@ func server(cmd *cobra.Command, args []string) error {
 		s.RegisterMediaTypes()
 	}
 
+	if serverWatch {
+		c.watchConfig()
+	}
+
 	// Watch runs its own server as part of the routine
 	if serverWatch {
 

commands/static_syncer.go

@@ -44,15 +44,20 @@ func (s *staticSyncer) isStatic(path string) bool {
 func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 	c := s.c
 
-	syncFn := func(dirs *src.Dirs, publishDir string) error {
+	syncFn := func(dirs *src.Dirs, publishDir string) (uint64, error) {
 		staticSourceFs, err := dirs.CreateStaticFs()
 		if err != nil {
-			return err
+			return 0, err
+		}
+
+		if dirs.Language != nil {
+			// Multihost setup
+			publishDir = filepath.Join(publishDir, dirs.Language.Lang)
 		}
 
 		if staticSourceFs == nil {
 			c.Logger.WARN.Println("No static directories found to sync")
-			return nil
+			return 0, nil
 		}
 
 		syncer := fsync.NewSyncer()
@@ -127,9 +132,10 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 			}
 		}
 
-		return nil
+		return 0, nil
 	}
 
-	return c.doWithPublishDirs(syncFn)
+	_, err := c.doWithPublishDirs(syncFn)
+	return err
 
 }

commands/undraft.go

@@ -36,7 +36,7 @@ If the content's draft status is 'False', nothing is done.`,
 // to false and setting its publish date to now. If the specified content is
 // not a draft, it will log an error.
 func Undraft(cmd *cobra.Command, args []string) error {
-	cfg, err := InitializeConfig()
+	c, err := InitializeConfig(false, nil)
 
 	if err != nil {
 		return err
@@ -46,6 +46,8 @@ func Undraft(cmd *cobra.Command, args []string) error {
 		return newUserError("a piece of content needs to be specified")
 	}
 
+	cfg := c.DepsCfg
+
 	location := args[0]
 	// open the file
 	f, err := cfg.Fs.Source.Open(location)