releaser: Bump versions for release of 0.91.2

[ci skip]
releaser: Add release notes for 0.91.2
2026-09-01 11:12:37 +00:00 · 2021-12-23 15:33:33 +00:00 · 2021-12-23 15:33:33 +00:00 · 2021-12-23 16:23:15 +01:00 · 2021-12-23 15:09:27 +01:00 · 2021-12-23 15:09:27 +01:00
1247 changed files with 41450 additions and 12637 deletions
@@ -1,6 +1,6 @@
 defaults: &defaults
  docker:
-      - image: bepsays/ci-goreleaser:1.15.1
+      - image: bepsays/ci-goreleaser:1.17.5
  environment:
    CGO_ENABLED: "0"

@@ -18,7 +18,6 @@ jobs:
                go mod download
                sleep 5
                go mod verify
-                go test -p 1 ./...
      - persist_to_workspace:
          root: .
          paths: .
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+    - name: SUPPORT, ISSUES and TROUBLESHOOTING
+      url: https://discourse.gohugo.io/
+      about: Please DO NOT use Github for support requests. Please visit https://discourse.gohugo.io for support! You will be helped much faster there. If you ignore this request your issue might be closed with a discourse label.
@@ -1,10 +0,0 @@
---
-name: Support (Do not use)
-about: Please do not use Github for support requests. Visit https://discourse.gohugo.io for support
-title: ''
-labels: support
-assignees: ''
-
---
-
-Issues created with this template will be automatically closed. Please visit https://discourse.gohugo.io for the support you really, really, want!
@@ -1,7 +1,7 @@
 # See https://docs.github.com/en/github/administering-a-repository/configuration-options-for-dependency-updates#package-ecosystem
 version: 2
 updates:
-  - package-ecosystem: "gomod" 
+  - package-ecosystem: "gomod"
    directory: "/"
    schedule:
      interval: "daily"
@@ -1,14 +0,0 @@
-on:
-  schedule:
-  - cron: 0 5 * * 3 
-name: Weekly Issue Closure
-jobs:
-  cycle-weekly-close:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@master
-    - name: weekly-issue-closure
-      uses: bdougie/close-issues-based-on-label@master
-      env:
-        LABEL: support
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,82 @@
+on: [push, pull_request]
+name: Test
+jobs:
+  test:
+    env:
+      GOPROXY: https://proxy.golang.org
+      GO111MODULE: on
+    strategy:
+      matrix:
+        go-version: [1.16.x, 1.17.x]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@37335c7bb261b353407cff977110895fa0b4f7d8
+      with:
+        go-version: ${{ matrix.go-version }}
+    - name: Install Ruby
+      uses: actions/setup-ruby@5f29a1cd8dfebf420691c4c9a0e832e2fae5a526
+      with:
+        ruby-version: '2.7'
+    - name: Install Python
+      uses: actions/setup-python@3105fb18c05ddd93efea5f9e0bef7a03a6e9e7df
+      with:
+        python-version: '3.x'
+    - name: Install Mage
+      run: go get github.com/magefile/mage@07afc7d24f4d6d6442305d49552f04fbda5ccb3e
+    - name: Install asciidoctor
+      uses: reitzig/actions-asciidoctor@7570212ae20b63653481675fb1ff62d1073632b0
+    - name: Checkout code
+      uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f
+    - name: Install docutils
+      run: |
+        pip install docutils
+        rst2html.py --version
+    - if: matrix.os == 'ubuntu-latest'
+      name: Install pandoc on Linux
+      run: |
+          sudo apt-get update -y
+          sudo apt-get install -y pandoc
+    - if: matrix.os == 'macos-latest'
+      run: |
+        brew install pandoc
+    - if: matrix.os == 'windows-latest'
+      run: |
+        choco install pandoc
+    - run: pandoc -v
+    - if: matrix.os == 'ubuntu-latest'
+      name: Install dart-sass-embedded Linux
+      run: |
+        curl -LJO https://github.com/sass/dart-sass-embedded/releases/download/1.0.0-beta.6/sass_embedded-1.0.0-beta.6-linux-x64.tar.gz;
+        echo "04fc1e5e28d29a4585a701941b6dace56771d94bfbe7f9e4db28d24417ceeec3  sass_embedded-1.0.0-beta.6-linux-x64.tar.gz" | sha256sum -c;
+        tar -xvf sass_embedded-1.0.0-beta.6-linux-x64.tar.gz;
+        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
+    - if: matrix.os == 'macos-latest'
+      name: Install dart-sass-embedded MacOS
+      run: |
+        curl -LJO https://github.com/sass/dart-sass-embedded/releases/download/1.0.0-beta.6/sass_embedded-1.0.0-beta.6-macos-x64.tar.gz;
+        echo "b3b984675a9b04aa22f6f2302dda4191b507ac2ca124467db2dfe7e58e72fbad  sass_embedded-1.0.0-beta.6-macos-x64.tar.gz" | shasum -a 256 -c;
+        tar -xvf sass_embedded-1.0.0-beta.6-macos-x64.tar.gz;
+        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
+    - if: matrix.os == 'windows-latest'
+      name: Install dart-sass-embedded Windows
+      run: |
+        curl -LJO https://github.com/sass/dart-sass-embedded/releases/download/1.0.0-beta.6/sass_embedded-1.0.0-beta.6-windows-x64.zip;
+        echo "6ae442129dbb3334bc21ef851261da6c0c1b560da790ca2e1350871d00ab816d  sass_embedded-1.0.0-beta.6-windows-x64.zip" | sha256sum -c;
+        unzip sass_embedded-1.0.0-beta.6-windows-x64.zip;
+        echo  "$env:GITHUB_WORKSPACE/sass_embedded/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
+    - name: Test
+      run: |
+        mage -v test
+        mage -v check;
+    - name: Build Docs
+      env:
+        HUGO_BUILD_TAGS: extended
+        HUGO_TIMEOUT: 31000
+        HUGO_IGNOREERRORS: error-remote-getjson
+        HUGO_SERVICES_INSTAGRAM_ACCESSTOKEN: dummytoken
+      run: |
+        mage -v hugo
+        ./hugo -s docs/
+        ./hugo --renderToMemory -s docs/
@@ -1,6 +1,7 @@
 /hugo
 docs/public*
 /.idea
+.vscode/*
 hugo.exe
 *.test
 *.prof
@@ -1,77 +0,0 @@
-language: go
-
-dist: bionic
-
-env:
-  global:
-    - CACHE_NAME=${TRAVIS_ARCH}
-    - GO111MODULE=on
-    - GOPROXY=https://proxy.golang.org
-    - HUGO_BUILD_TAGS=extended
-
-git:
-  depth: false
-go:
-  - "1.14.8"
-  - "1.15.1"
-  - master
-
-arch:
-  - amd64
-  - arm64
-
-os:
-  - linux
-  - osx
-  - windows
-
-jobs:
-  allow_failures:
-    - go: master
-    - arch: arm64
-  fast_finish: true
-  exclude:
-    - os: windows
-      go: master
-    - arch: arm64
-      os: osx
-    - arch: arm64
-      os: windows
-
-cache:
-  directories:
-    - $HOME/gopath/pkg/mod
-    - $HOME/.cache/go-build
-    - $HOME/Library/Caches/go-build
-    - $HOME/AppData/Local/go-build
-
-before_install:
-  - df -h
-    # https://travis-ci.community/t/go-cant-find-gcc-with-go1-11-1-on-windows/293/5
-  - if [ "$TRAVIS_OS_NAME" = "windows" ]; then
-        choco install mingw -y;
-        export PATH=/c/tools/mingw64/bin:"$PATH";
-    fi
-  - gem install asciidoctor
-  - type asciidoctor
-
-install:
-  - mkdir -p $HOME/src
-  - mv $TRAVIS_BUILD_DIR $HOME/src
-  - export TRAVIS_BUILD_DIR=$HOME/src/hugo
-  - cd $HOME/src/hugo
-  - go get github.com/magefile/mage
-
-script:
-  - go mod download
-  - go mod verify
-  - mage -v test
-  - if [ "$TRAVIS_ARCH" = "amd64" ]; then
-        mage -v check;
-    else
-        HUGO_TIMEOUT=30000 mage -v check;
-    fi
-  - mage -v hugo
-  - ./hugo -s docs/
-  - ./hugo --renderToMemory -s docs/
-  - df -h
@@ -50,7 +50,9 @@ Hugo has become a fully featured static site generator, so any new functionality

 If it is of some complexity, the contributor is expected to maintain and support the new feature in the future (answer questions on the forum, fix any bugs etc.).

-It is recommended to open up a discussion on the [Hugo Forum](https://discourse.gohugo.io/) to get feedback on your idea before you begin. If you are submitting a complex feature, create a small design proposal on the [Hugo issue tracker](https://github.com/gohugoio/hugo/issues) before you start.
+It is recommended to open up a discussion on the [Hugo Forum](https://discourse.gohugo.io/) to get feedback on your idea before you begin. 
+
+Any non-trivial code change needs to update an open [issue](https://github.com/gohugoio/hugo/issues). A non-trivial code change without an issue reference with one of the labels `bug` or `enhancement` will not be merged.

 Note that we do not accept new features that require [CGO](https://github.com/golang/go/wiki/cgo).
 We have one exception to this rule which is LibSASS.
@@ -2,9 +2,9 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/

-FROM golang:1.13-alpine AS build
+FROM golang:1.16-alpine AS build

-# Optionally set HUGO_BUILD_TAGS to "extended" when building like so:
+# Optionally set HUGO_BUILD_TAGS to "extended" or "nodeploy" when building like so:
 #   docker build --build-arg HUGO_BUILD_TAGS=extended .
 ARG HUGO_BUILD_TAGS

@@ -19,14 +19,14 @@ COPY . /go/src/github.com/gohugoio/hugo/

 # gcc/g++ are required to build SASS libraries for extended version
 RUN apk update && \
-    apk add --no-cache gcc g++ musl-dev && \
+    apk add --no-cache gcc g++ musl-dev git && \
    go get github.com/magefile/mage

 RUN mage hugo && mage install

 # ---

-FROM alpine:3.11
+FROM alpine:3.12

 COPY --from=build /go/bin/hugo /usr/bin/hugo

@@ -1,4 +1,4 @@
-<img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/static/images/hugo-logo-wide.svg?sanitize=true" alt="Hugo" width="565">
+<a href="https://gohugo.io/"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/static/images/hugo-logo-wide.svg?sanitize=true" alt="Hugo" width="565"></a>

 A Fast and Flexible Static Site Generator built with love by [bep](https://github.com/bep), [spf13](http://spf13.com/) and [friends](https://github.com/gohugoio/hugo/graphs/contributors) in [Go][].

@@ -10,7 +10,7 @@ A Fast and Flexible Static Site Generator built with love by [bep](https://githu
 [Twitter](https://twitter.com/gohugoio)

 [![GoDoc](https://godoc.org/github.com/gohugoio/hugo?status.svg)](https://godoc.org/github.com/gohugoio/hugo)
-[![Linux and macOS Build Status](https://api.travis-ci.org/gohugoio/hugo.svg?branch=master&label=Windows+and+Linux+and+macOS+build "Windows, Linux and macOS Build Status")](https://travis-ci.org/gohugoio/hugo)
+[![Tests on Linux, MacOS and Windows](https://github.com/gohugoio/hugo/workflows/Test/badge.svg)](https://github.com/gohugoio/hugo/actions?query=workflow%3ATest)
 [![Go Report Card](https://goreportcard.com/badge/github.com/gohugoio/hugo)](https://goreportcard.com/report/github.com/gohugoio/hugo)

 ## Overview
@@ -29,7 +29,7 @@ Hugo is designed to work well for any kind of website including blogs, tumbles,

 #### Supported Architectures

-Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBSD, DragonFly BSD, Open BSD, macOS (Darwin), and [Android](https://gist.github.com/bep/a0d8a26cf6b4f8bc992729b8e50b480b) for x64, i386 and ARM architectures.
+Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBSD, DragonFly BSD, OpenBSD, macOS (Darwin), and [Android](https://gist.github.com/bep/a0d8a26cf6b4f8bc992729b8e50b480b) for x64, i386 and ARM architectures.

 Hugo may also be compiled from source wherever the Go compiler tool chain can run, e.g. for other operating systems including Plan 9 and Solaris.

@@ -54,7 +54,7 @@ Use the [installation instructions in the Hugo documentation](https://gohugo.io/
 #### Prerequisite Tools

 * [Git](https://git-scm.com/)
-* [Go (we test it with the last 2 major versions)](https://golang.org/dl/)
+* [Go (we test it with the last 2 major versions; but note that Hugo 0.81.0 only builds with >= Go 1.16.)](https://golang.org/dl/)

 #### Fetch from GitHub

@@ -119,78 +119,106 @@ If you are unfamiliar with the contribution process, the Hugo team will help you

 For a complete guide to contributing code to Hugo, see the [Contribution Guide](CONTRIBUTING.md).

-[![Analytics](https://ga-beacon.appspot.com/UA-7131036-6/hugo/readme)](https://github.com/igrigorik/ga-beacon)
-
 [Go]: https://golang.org/
 [Hugo Documentation]: https://gohugo.io/overview/introduction/

 ## Dependencies

-Hugo stands on the shoulder of many great open source libraries, in lexical order:
+Hugo stands on the shoulder of many great open source libraries.
+
+If you run `hugo env -v` you will get a complete and up to date list.
+
+In Hugo 0.89.0 that list is, in lexical order:
+
+```
+cloud.google.com/go/storage="v1.10.0"
+cloud.google.com/go="v0.87.0"
+github.com/Azure/azure-pipeline-go="v0.2.2"
+github.com/Azure/azure-storage-blob-go="v0.9.0"
+github.com/BurntSushi/locker="v0.0.0-20171006230638-a6e239ea1c69"
+github.com/BurntSushi/toml="v0.3.1"
+github.com/PuerkitoBio/purell="v1.1.1"
+github.com/PuerkitoBio/urlesc="v0.0.0-20170810143723-de5bf2ad4578"
+github.com/alecthomas/chroma="v0.9.4"
+github.com/armon/go-radix="v1.0.0"
+github.com/aws/aws-sdk-go="v1.41.14"
+github.com/bep/debounce="v1.2.0"
+github.com/bep/gitmap="v1.1.2"
+github.com/bep/godartsass="v0.12.0"
+github.com/bep/golibsass="v1.0.0"
+github.com/bep/gowebp="v0.1.0"
+github.com/bep/tmc="v0.5.1"
+github.com/cli/safeexec="v1.0.0"
+github.com/cpuguy83/go-md2man/v2="v2.0.0"
+github.com/disintegration/gift="v1.2.1"
+github.com/dlclark/regexp2="v1.4.0"
+github.com/dustin/go-humanize="v1.0.0"
+github.com/evanw/esbuild="v0.13.12"
+github.com/fsnotify/fsnotify="v1.5.1"
+github.com/getkin/kin-openapi="v0.80.0"
+github.com/ghodss/yaml="v1.0.0"
+github.com/go-openapi/jsonpointer="v0.19.5"
+github.com/go-openapi/swag="v0.19.5"
+github.com/gobuffalo/flect="v0.2.3"
+github.com/gobwas/glob="v0.2.3"
+github.com/gohugoio/go-i18n/v2="v2.1.3-0.20210430103248-4c28c89f8013"
+github.com/gohugoio/locales="v0.14.0"
+github.com/gohugoio/localescompressed="v0.14.0"
+github.com/golang/groupcache="v0.0.0-20200121045136-8c9f03a8e57e"
+github.com/golang/protobuf="v1.5.2"
+github.com/google/go-cmp="v0.5.6"
+github.com/google/uuid="v1.1.2"
+github.com/google/wire="v0.4.0"
+github.com/googleapis/gax-go/v2="v2.0.5"
+github.com/googleapis/gax-go="v2.0.2+incompatible"
+github.com/gorilla/websocket="v1.4.2"
+github.com/inconshreveable/mousetrap="v1.0.0"
+github.com/jdkato/prose="v1.2.1"
+github.com/jmespath/go-jmespath="v0.4.0"
+github.com/kyokomi/emoji/v2="v2.2.8"
+github.com/mailru/easyjson="v0.0.0-20190626092158-b2ccc519800e"
+github.com/mattn/go-ieproxy="v0.0.1"
+github.com/mattn/go-isatty="v0.0.14"
+github.com/mattn/go-runewidth="v0.0.9"
+github.com/miekg/mmark="v1.3.6"
+github.com/mitchellh/hashstructure="v1.1.0"
+github.com/mitchellh/mapstructure="v1.4.2"
+github.com/muesli/smartcrop="v0.3.0"
+github.com/niklasfasching/go-org="v1.5.0"
+github.com/olekukonko/tablewriter="v0.0.5"
+github.com/pelletier/go-toml/v2="v2.0.0-beta.3.0.20210727221244-fa0796069526"
+github.com/pkg/errors="v0.9.1"
+github.com/rogpeppe/go-internal="v1.8.0"
+github.com/russross/blackfriday/v2="v2.0.1"
+github.com/russross/blackfriday="v1.5.3-0.20200218234912-41c5fccfd6f6"
+github.com/rwcarlsen/goexif="v0.0.0-20190401172101-9e8deecbddbd"
+github.com/sanity-io/litter="v1.5.1"
+github.com/sass/libsass="3.6.5"
+github.com/shurcooL/sanitized_anchor_name="v1.0.0"
+github.com/spf13/afero="v1.6.0"
+github.com/spf13/cast="v1.4.1"
+github.com/spf13/cobra="v1.2.1"
+github.com/spf13/fsync="v0.9.0"
+github.com/spf13/jwalterweatherman="v1.1.0"
+github.com/spf13/pflag="v1.0.5"
+github.com/tdewolff/minify/v2="v2.9.22"
+github.com/tdewolff/parse/v2="v2.5.21"
+github.com/webmproject/libwebp="v1.2.0"
+github.com/yuin/goldmark-highlighting="v0.0.0-20200307114337-60d527fdb691"
+github.com/yuin/goldmark="v1.4.2"
+go.opencensus.io="v0.23.0"
+gocloud.dev="v0.20.0"
+golang.org/x/image="v0.0.0-20210220032944-ac19c3e999fb"
+golang.org/x/net="v0.0.0-20210614182718-04defd469f4e"
+golang.org/x/oauth2="v0.0.0-20210628180205-a41e5a781914"
+golang.org/x/sync="v0.0.0-20210220032951-036812b2e83c"
+golang.org/x/sys="v0.0.0-20210908233432-aa78b53d3365"
+golang.org/x/text="v0.3.7"
+golang.org/x/xerrors="v0.0.0-20200804184101-5ec99f83aff1"
+google.golang.org/api="v0.51.0"
+google.golang.org/genproto="v0.0.0-20210716133855-ce7ef5c701ea"
+google.golang.org/grpc="v1.39.0"
+google.golang.org/protobuf="v1.27.1"
+gopkg.in/yaml.v2="v2.4.0"
+```

- | Dependency  | License |
- | :------------- | :------------- |
- | [github.com/alecthomas/chroma](https://github.com/alecthomas/chroma) | MIT License |
- | [github.com/armon/go-radix](https://github.com/armon/go-radix) | MIT License |
- | [github.com/aws/aws-sdk-go](https://github.com/aws/aws-sdk-go) | Apache License 2.0 |
- | [github.com/bep/debounce](https://github.com/bep/debounce) | MIT License |
- | [github.com/bep/gitmap](https://github.com/bep/gitmap) | MIT License |
- | [github.com/bep/golibsass](https://github.com/bep/golibsass) | MIT License |
- | [github.com/bep/tmc](https://github.com/bep/tmc) | MIT License |
- | [github.com/BurntSushi/locker](https://github.com/BurntSushi/locker) | The Unlicense |
- | [github.com/BurntSushi/toml](https://github.com/BurntSushi/toml) | MIT License |
- | [github.com/cpuguy83/go-md2man](https://github.com/cpuguy83/go-md2man) | MIT License |
- | [github.com/danwakefield/fnmatch](https://github.com/danwakefield/fnmatch) | BSD 2-Clause "Simplified" License |
- | [github.com/disintegration/gift](https://github.com/disintegration/gift) | MIT License |
- | [github.com/dustin/go-humanize](https://github.com/dustin/go-humanize) | MIT License |
- | [github.com/fsnotify/fsnotify](https://github.com/fsnotify/fsnotify) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/gobwas/glob](https://github.com/gobwas/glob) | MIT License |
- | [github.com/gorilla/websocket](https://github.com/gorilla/websocket) | BSD 2-Clause "Simplified" License |
- | [github.com/hashicorp/golang-lru](https://github.com/hashicorp/golang-lru) | Mozilla Public License 2.0 |
- | [github.com/hashicorp/hcl](https://github.com/hashicorp/hcl) | Mozilla Public License 2.0 |
- | [github.com/jdkato/prose](https://github.com/jdkato/prose) | MIT License |
- | [github.com/kr/pretty](https://github.com/kr/pretty) | MIT License |
- | [github.com/kyokomi/emoji](https://github.com/kyokomi/emoji) | MIT License |
- | [github.com/magiconair/properties](https://github.com/magiconair/properties) | BSD 2-Clause "Simplified" License |
- | [github.com/markbates/inflect](https://github.com/markbates/inflect) | MIT License |
- | [github.com/mattn/go-isatty](https://github.com/mattn/go-isatty) | MIT License |
- | [github.com/mattn/go-runewidth](https://github.com/mattn/go-runewidth) | MIT License |
- | [github.com/miekg/mmark](https://github.com/miekg/mmark) | Simplified BSD License |
- | [github.com/mitchellh/hashstructure](https://github.com/mitchellh/hashstructure) | MIT License |
- | [github.com/mitchellh/mapstructure](https://github.com/mitchellh/mapstructure) | MIT License |
- | [github.com/muesli/smartcrop](https://github.com/muesli/smartcrop) | MIT License |
- | [github.com/nicksnyder/go-i18n](https://github.com/nicksnyder/go-i18n) | MIT License |
- | [github.com/niklasfasching/go-org](https://github.com/niklasfasching/go-org) | MIT License |
- | [github.com/olekukonko/tablewriter](https://github.com/olekukonko/tablewriter) | MIT License |
- | [github.com/pelletier/go-toml](https://github.com/pelletier/go-toml) | MIT License |
- | [github.com/pkg/errors](https://github.com/pkg/errors) | BSD 2-Clause "Simplified" License |
- | [github.com/PuerkitoBio/purell](https://github.com/PuerkitoBio/purell) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/PuerkitoBio/urlesc](https://github.com/PuerkitoBio/urlesc) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/rogpeppe/go-internal](https://github.com/rogpeppe/go-internal) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/russross/blackfriday](https://github.com/russross/blackfriday)  | Simplified BSD License |
- | [github.com/rwcarlsen/goexif](https://github.com/rwcarlsen/goexif) | BSD 2-Clause "Simplified" License |
- | [github.com/spf13/afero](https://github.com/spf13/afero) | Apache License 2.0 |
- | [github.com/spf13/cast](https://github.com/spf13/cast) | MIT License |
- | [github.com/spf13/cobra](https://github.com/spf13/cobra) | Apache License 2.0 |
- | [github.com/spf13/fsync](https://github.com/spf13/fsync) | MIT License |
- | [github.com/spf13/jwalterweatherman](https://github.com/spf13/jwalterweatherman) | MIT License |
- | [github.com/spf13/pflag](https://github.com/spf13/pflag) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/spf13/viper](https://github.com/spf13/viper) | MIT License |
- | [github.com/tdewolff/minify](https://github.com/tdewolff/minify) | MIT License |
- | [github.com/tdewolff/parse](https://github.com/tdewolff/parse) | MIT License |
- | [github.com/yuin/goldmark](https://github.com/yuin/goldmark) | MIT License |
- | [github.com/yuin/goldmark-highlighting](https://github.com/yuin/goldmark-highlighting) | MIT License |
- | [go.opencensus.io](https://go.opencensus.io) | Apache License 2.0 |
- | [go.uber.org/atomic](https://go.uber.org/atomic) | MIT License |
- | [gocloud.dev](https://gocloud.dev) | Apache License 2.0 |
- | [golang.org/x/image](https://golang.org/x/image) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/net](https://golang.org/x/net) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/oauth2](https://golang.org/x/oauth2) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/sync](https://golang.org/x/sync) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/sys](https://golang.org/x/sys) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/text](https://golang.org/x/text) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/xerrors](https://golang.org/x/xerrors) | BSD 3-Clause "New" or "Revised" License |
- | [google.golang.org/api](https://google.golang.org/api) | BSD 3-Clause "New" or "Revised" License |
- | [google.golang.org/genproto](https://google.golang.org/genproto) | Apache License 2.0 |
- | [gopkg.in/ini.v1](https://gopkg.in/ini.v1) | Apache License 2.0 |
- | [gopkg.in/yaml.v2](https://gopkg.in/yaml.v2) | Apache License 2.0 |
@@ -0,0 +1,7 @@
+## Security Policy
+
+### Reporting a Vulnerability
+
+Please report (suspected) security vulnerabilities to **[bjorn.erik.pedersen@gmail.com](mailto:bjorn.erik.pedersen@gmail.com)**. You will receive a response from us within 48 hours. If we can confirm the issue, we will release a patch as soon as possible depending on the complexity of the issue but historically within days.
+
+Also see [Hugo's Security Model](https://gohugo.io/about/security-model/).
@@ -3,7 +3,7 @@
 # allow user to override go executable by running as GOEXE=xxx make ...
 GOEXE="${GOEXE-go}"

-# Send in a regexp mathing the benchmarks you want to run, i.e. './benchSite.sh "YAML"'. 
+# Send in a regexp matching the benchmarks you want to run, i.e. './benchSite.sh "YAML"'.
 # Note the quotes, which will be needed for more complex expressions.
 # The above will run all variations, but only for front matter YAML.

@@ -158,7 +158,6 @@ func (c *Cache) ReadOrCreate(id string,
 	err = create(info, f)

 	return
-
 }

 // GetOrCreate tries to get the file with the given id from cache. If not found or expired, create will
@@ -176,7 +175,12 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It
 		return info, r, nil
 	}

-	r, err := create()
+	var (
+		r   io.ReadCloser
+		err error
+	)
+
+	r, err = create()
 	if err != nil {
 		return info, nil, err
 	}
@@ -207,7 +211,12 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 		return info, b, err
 	}

-	b, err := create()
+	var (
+		b   []byte
+		err error
+	)
+
+	b, err = create()
 	if err != nil {
 		return info, nil, err
 	}
@@ -220,10 +229,9 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 		return info, nil, err
 	}
 	return info, b, nil
-
 }

-// GetBytes gets the file content with the given id from the cahce, nil if none found.
+// GetBytes gets the file content with the given id from the cache, nil if none found.
 func (c *Cache) GetBytes(id string) (ItemInfo, []byte, error) {
 	id = cleanID(id)

@@ -276,7 +284,6 @@ func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
 	}

 	f, err := c.Fs.Open(id)
-
 	if err != nil {
 		return nil
 	}
@@ -299,7 +306,6 @@ func (c *Cache) getString(id string) string {
 	defer c.nlocker.Unlock(id)

 	f, err := c.Fs.Open(id)
-
 	if err != nil {
 		return ""
 	}
@@ -307,7 +313,6 @@ func (c *Cache) getString(id string) string {

 	b, _ := ioutil.ReadAll(f)
 	return string(b)
-
 }

 // Caches is a named set of caches.
@@ -19,6 +19,8 @@ import (
 	"strings"
 	"time"

+	"github.com/gohugoio/hugo/common/maps"
+
 	"github.com/gohugoio/hugo/config"

 	"github.com/gohugoio/hugo/helpers"
@@ -32,19 +34,21 @@ const (
 	cachesConfigKey = "caches"

 	resourcesGenDir = ":resourceDir/_gen"
+	cacheDirProject = ":cacheDir/:project"
 )

 var defaultCacheConfig = Config{
 	MaxAge: -1, // Never expire
-	Dir:    ":cacheDir/:project",
+	Dir:    cacheDirProject,
 }

 const (
-	cacheKeyGetJSON = "getjson"
-	cacheKeyGetCSV  = "getcsv"
-	cacheKeyImages  = "images"
-	cacheKeyAssets  = "assets"
-	cacheKeyModules = "modules"
+	cacheKeyGetJSON     = "getjson"
+	cacheKeyGetCSV      = "getcsv"
+	cacheKeyImages      = "images"
+	cacheKeyAssets      = "assets"
+	cacheKeyModules     = "modules"
+	cacheKeyGetResource = "getresource"
 )

 type Configs map[string]Config
@@ -68,6 +72,10 @@ var defaultCacheConfigs = Configs{
 		MaxAge: -1,
 		Dir:    resourcesGenDir,
 	},
+	cacheKeyGetResource: Config{
+		MaxAge: -1, // Never expire
+		Dir:    cacheDirProject,
+	},
 }

 type Config struct {
@@ -109,6 +117,11 @@ func (f Caches) AssetsCache() *Cache {
 	return f[cacheKeyAssets]
 }

+// GetResourceCache gets the file cache for remote resources.
+func (f Caches) GetResourceCache() *Cache {
+	return f[cacheKeyGetResource]
+}
+
 func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 	c := make(Configs)
 	valid := make(map[string]bool)
@@ -123,6 +136,9 @@ func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 	_, isOsFs := fs.(*afero.OsFs)

 	for k, v := range m {
+		if _, ok := v.(maps.Params); !ok {
+			continue
+		}
 		cc := defaultCacheConfig

 		dc := &mapstructure.DecoderConfig{
@@ -137,7 +153,7 @@ func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 		}

 		if err := decoder.Decode(v); err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "failed to decode filecache config")
 		}

 		if cc.Dir == "" {
@@ -25,7 +25,6 @@ import (
 	"github.com/gohugoio/hugo/config"

 	qt "github.com/frankban/quicktest"
-	"github.com/spf13/viper"
 )

 func TestDecodeConfig(t *testing.T) {
@@ -51,7 +50,8 @@ maxAge = "11h"
 dir = "/path/to/c2"
 [caches.images]
 dir = "/path/to/c3"
-
+[caches.getResource]
+dir = "/path/to/c4"
 `

 	cfg, err := config.FromConfigString(configStr, "toml")
@@ -60,7 +60,7 @@ dir = "/path/to/c3"
 	decoded, err := DecodeConfig(fs, cfg)
 	c.Assert(err, qt.IsNil)

-	c.Assert(len(decoded), qt.Equals, 5)
+	c.Assert(len(decoded), qt.Equals, 6)

 	c2 := decoded["getcsv"]
 	c.Assert(c2.MaxAge.String(), qt.Equals, "11h0m0s")
@@ -70,6 +70,9 @@ dir = "/path/to/c3"
 	c.Assert(c3.MaxAge, qt.Equals, time.Duration(-1))
 	c.Assert(c3.Dir, qt.Equals, filepath.FromSlash("/path/to/c3/filecache/images"))

+	c4 := decoded["getresource"]
+	c.Assert(c4.MaxAge, qt.Equals, time.Duration(-1))
+	c.Assert(c4.Dir, qt.Equals, filepath.FromSlash("/path/to/c4/filecache/getresource"))
 }

 func TestDecodeConfigIgnoreCache(t *testing.T) {
@@ -96,7 +99,8 @@ maxAge = 3456
 dir = "/path/to/c2"
 [caches.images]
 dir = "/path/to/c3"
-
+[caches.getResource]
+dir = "/path/to/c4"
 `

 	cfg, err := config.FromConfigString(configStr, "toml")
@@ -105,12 +109,11 @@ dir = "/path/to/c3"
 	decoded, err := DecodeConfig(fs, cfg)
 	c.Assert(err, qt.IsNil)

-	c.Assert(len(decoded), qt.Equals, 5)
+	c.Assert(len(decoded), qt.Equals, 6)

 	for _, v := range decoded {
 		c.Assert(v.MaxAge, qt.Equals, time.Duration(0))
 	}
-
 }

 func TestDecodeConfigDefault(t *testing.T) {
@@ -132,7 +135,7 @@ func TestDecodeConfigDefault(t *testing.T) {

 	c.Assert(err, qt.IsNil)

-	c.Assert(len(decoded), qt.Equals, 5)
+	c.Assert(len(decoded), qt.Equals, 6)

 	imgConfig := decoded[cacheKeyImages]
 	jsonConfig := decoded[cacheKeyGetJSON]
@@ -178,11 +181,10 @@ dir = "/"

 	_, err = DecodeConfig(fs, cfg)
 	c.Assert(err, qt.Not(qt.IsNil))
-
 }

-func newTestConfig() *viper.Viper {
-	cfg := viper.New()
+func newTestConfig() config.Provider {
+	cfg := config.New()
 	cfg.Set("workingDir", filepath.FromSlash("/my/cool/hugoproject"))
 	cfg.Set("contentDir", "content")
 	cfg.Set("dataDir", "data")
@@ -110,7 +110,6 @@ func (c *Cache) Prune(force bool) (int, error) {
 }

 func (c *Cache) pruneRootDir(force bool) (int, error) {
-
 	info, err := c.Fs.Stat(c.pruneAllRootDir)
 	if err != nil {
 		if os.IsNotExist(err) {
@@ -124,5 +123,4 @@ func (c *Cache) pruneRootDir(force bool) (int, error) {
 	}

 	return hugofs.MakeReadableAndRemoveAllModulePkgDir(c.Fs, c.pruneAllRootDir)
-
 }
@@ -107,5 +107,4 @@ dir = ":resourceDir/_gen"
 		}

 	}
-
 }
@@ -183,7 +183,6 @@ dir = ":cacheDir/c"
 		c.Assert(string(b), qt.Equals, "Hugo is great!")

 	}
-
 }

 func TestFileCacheConcurrent(t *testing.T) {
@@ -253,7 +252,6 @@ func TestFileCacheReadOrCreateErrorInRead(t *testing.T) {
 	var result string

 	rf := func(failLevel int) func(info ItemInfo, r io.ReadSeeker) error {
-
 		return func(info ItemInfo, r io.ReadSeeker) error {
 			if failLevel > 0 {
 				if failLevel > 1 {
@@ -347,5 +345,4 @@ func newPathsSpec(t *testing.T, fs afero.Fs, configStr string) *helpers.PathSpec
 	p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, cfg), cfg, nil)
 	c.Assert(err, qt.IsNil)
 	return p
-
 }
@@ -49,13 +49,12 @@ func (c *Cache) Clear() {

 	c.cache = make(map[string]cacheEntry)
 	c.nlocker = locker.NewLocker()
-
 }

 // GetOrCreate tries to get the value with the given cache key, if not found
 // create will be called and cached.
 // This method is thread safe. It also guarantees that the create func for a given
-// key is invoced only once for this cache.
+// key is invoked only once for this cache.
 func (c *Cache) GetOrCreate(key string, create func() (interface{}, error)) (interface{}, error) {
 	c.mu.RLock()
 	entry, found := c.cache[key]
@@ -58,7 +58,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T

 	var methods Methods

-	var excludes = make(map[string]bool)
+	excludes := make(map[string]bool)

 	if len(exclude) > 0 {
 		for _, m := range c.MethodsFromTypes(exclude, nil) {
@@ -99,11 +99,9 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 		name = pkgPrefix + name

 		return name, pkg
-
 	}

 	for _, t := range include {
-
 		for i := 0; i < t.NumMethod(); i++ {

 			m := t.Method(i)
@@ -153,7 +151,6 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T

 			methods = append(methods, method)
 		}
-
 	}

 	sort.SliceStable(methods, func(i, j int) bool {
@@ -167,16 +164,13 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 		}

 		return wi < wj
-
 	})

 	return methods
-
 }

 func (c *Inspector) parseSource() {
 	c.init.Do(func() {
-
 		if !strings.Contains(c.ProjectRootDir, "hugo") {
 			panic("dir must be set to the Hugo root")
 		}
@@ -200,7 +194,6 @@ func (c *Inspector) parseSource() {
 			filenames = append(filenames, path)

 			return nil
-
 		})

 		for _, filename := range filenames {
@@ -230,7 +223,6 @@ func (c *Inspector) parseSource() {
 							c.methodWeight[iface] = weights
 						}
 					}
-
 				}
 				return true
 			})
@@ -247,7 +239,6 @@ func (c *Inspector) parseSource() {
 				}
 			}
 		}
-
 	})
 }

@@ -374,7 +365,7 @@ func (m Methods) Imports() []string {
 }

 // ToMarshalJSON creates a MarshalJSON method for these methods. Any method name
-// matchin any of the regexps in excludes will be ignored.
+// matching any of the regexps in excludes will be ignored.
 func (m Methods) ToMarshalJSON(receiver, pkgPath string, excludes ...string) (string, []string) {
 	var sb strings.Builder

@@ -385,7 +376,7 @@ func (m Methods) ToMarshalJSON(receiver, pkgPath string, excludes ...string) (st
 	fmt.Fprintf(&sb, "func Marshal%sToJSON(%s %s) ([]byte, error) {\n", what, r, receiver)

 	var methods Methods
-	var excludeRes = make([]*regexp.Regexp, len(excludes))
+	excludeRes := make([]*regexp.Regexp, len(excludes))

 	for i, exclude := range excludes {
 		excludeRes[i] = regexp.MustCompile(exclude)
@@ -450,7 +441,6 @@ func (m Methods) ToMarshalJSON(receiver, pkgPath string, excludes ...string) (st
 	}

 	return sb.String(), pkgImports
-
 }

 func collectMethodsRecursive(pkg string, f []*ast.Field) []string {
@@ -481,7 +471,6 @@ func collectMethodsRecursive(pkg string, f []*ast.Field) []string {
 	}

 	return methodNames
-
 }

 func firstToLower(name string) string {
@@ -544,5 +533,4 @@ func varName(name string) string {
 	}

 	return name
-
 }
@@ -25,7 +25,6 @@ import (
 )

 func TestMethods(t *testing.T) {
-
 	var (
 		zeroIE     = reflect.TypeOf((*IEmbed)(nil)).Elem()
 		zeroIEOnly = reflect.TypeOf((*IEOnly)(nil)).Elem()
@@ -58,7 +57,6 @@ func TestMethods(t *testing.T) {
 		methodsStr := fmt.Sprint(methods)

 		c.Assert(methodsStr, qt.Contains, "MethodEmbed3(arg0 string) string")
-
 	})

 	t.Run("ToMarshalJSON", func(t *testing.T) {
@@ -76,9 +74,7 @@ func TestMethods(t *testing.T) {
 		c.Assert(pkg, qt.Contains, "encoding/json")

 		fmt.Println(pkg)
-
 	})
-
 }

 type I interface {
@@ -26,9 +26,10 @@ type checkCmd struct {
 }

 func newCheckCmd() *checkCmd {
-	return &checkCmd{baseCmd: &baseCmd{cmd: &cobra.Command{
-		Use:   "check",
-		Short: "Contains some verification checks",
-	},
+	return &checkCmd{baseCmd: &baseCmd{
+		cmd: &cobra.Command{
+			Use:   "check",
+			Short: "Contains some verification checks",
+		},
 	}}
 }
@@ -24,10 +24,11 @@ type checkCmd struct {
 }

 func newCheckCmd() *checkCmd {
-	cc := &checkCmd{baseCmd: &baseCmd{cmd: &cobra.Command{
-		Use:   "check",
-		Short: "Contains some verification checks",
-	},
+	cc := &checkCmd{baseCmd: &baseCmd{
+		cmd: &cobra.Command{
+			Use:   "check",
+			Short: "Contains some verification checks",
+		},
 	}}

 	cc.cmd.AddCommand(newLimitCmd().getCommand())
@@ -16,24 +16,22 @@ package commands
 import (
 	"bytes"
 	"errors"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
 	"sync"
+	"time"

 	hconfig "github.com/gohugoio/hugo/config"

 	"golang.org/x/sync/semaphore"

-	"io/ioutil"
-
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/hugo"

 	jww "github.com/spf13/jwalterweatherman"

-	"os"
-	"path/filepath"
-	"regexp"
-	"time"
-
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/config"

@@ -60,9 +58,14 @@ type commandeerHugoState struct {
 type commandeer struct {
 	*commandeerHugoState

-	logger       *loggers.Logger
+	logger       loggers.Logger
 	serverConfig *config.Server

+	// Loading state
+	mustHaveConfigFile bool
+	failOnInitErr      bool
+	running            bool
+
 	// Currently only set when in "fast render mode". But it seems to
 	// be fast enough that we could maybe just add it for all server modes.
 	changeDetector *fileChangeDetector
@@ -112,7 +115,7 @@ func (c *commandeerHugoState) hugo() *hugolib.HugoSites {
 }

 func (c *commandeer) errCount() int {
-	return int(c.logger.ErrorCounter.Count())
+	return int(c.logger.LogCounters().ErrorCounter.Count())
 }

 func (c *commandeer) getErrorWithContext() interface{} {
@@ -155,8 +158,7 @@ func (c *commandeer) initFs(fs *hugofs.Fs) error {
 	return nil
 }

-func newCommandeer(mustHaveConfigFile, running bool, h *hugoBuilderCommon, f flagsToConfigHandler, cfgInit func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) {
-
+func newCommandeer(mustHaveConfigFile, failOnInitErr, running bool, h *hugoBuilderCommon, f flagsToConfigHandler, cfgInit func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) {
 	var rebuildDebouncer func(f func())
 	if running {
 		// The time value used is tested with mass content replacements in a fairly big Hugo site.
@@ -178,11 +180,17 @@ func newCommandeer(mustHaveConfigFile, running bool, h *hugoBuilderCommon, f fla
 		visitedURLs:         types.NewEvictingStringQueue(10),
 		debounce:            rebuildDebouncer,
 		fullRebuildSem:      semaphore.NewWeighted(1),
+
+		// Init state
+		mustHaveConfigFile: mustHaveConfigFile,
+		failOnInitErr:      failOnInitErr,
+		running:            running,
+
 		// This will be replaced later, but we need something to log to before the configuration is read.
 		logger: loggers.NewLogger(jww.LevelWarn, jww.LevelError, out, ioutil.Discard, running),
 	}

-	return c, c.loadConfig(mustHaveConfigFile, running)
+	return c, c.loadConfig()
 }

 type fileChangeDetector struct {
@@ -247,8 +255,7 @@ func (f *fileChangeDetector) PrepareNew() {
 	f.current = make(map[string]string)
 }

-func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
-
+func (c *commandeer) loadConfig() error {
 	if c.DepsCfg == nil {
 		c.DepsCfg = &deps.DepsCfg{}
 	}
@@ -260,7 +267,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {

 	cfg := c.DepsCfg
 	c.configured = false
-	cfg.Running = running
+	cfg.Running = c.running

 	var dir string
 	if c.h.source != "" {
@@ -274,10 +281,9 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		sourceFs = c.DepsCfg.Fs.Source
 	}

-	environment := c.h.getEnvironment(running)
+	environment := c.h.getEnvironment(c.running)

 	doWithConfig := func(cfg config.Provider) error {
-
 		if c.ftch != nil {
 			c.ftch.flagsToConfig(cfg)
 		}
@@ -308,14 +314,22 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 			WorkingDir:   dir,
 			Filename:     c.h.cfgFile,
 			AbsConfigDir: c.h.getConfigDir(dir),
-			Environ:      os.Environ(),
-			Environment:  environment},
+			Environment:  environment,
+		},
 		cfgSetAndInit,
 		doWithConfig)

-	if err != nil && mustHaveConfigFile {
-		return err
-	} else if mustHaveConfigFile && len(configFiles) == 0 {
+	if err != nil {
+		// We should improve the error handling here,
+		// but with hugo mod init and similar there is a chicken and egg situation
+		// with modules already configured in config.toml, so ignore those errors.
+		if c.mustHaveConfigFile || (c.failOnInitErr && !moduleNotFoundRe.MatchString(err.Error())) {
+			return err
+		} else {
+			// Just make it a warning.
+			c.logger.Warnln(err)
+		}
+	} else if c.mustHaveConfigFile && len(configFiles) == 0 {
 		return hugolib.ErrNoConfigFile
 	}

@@ -327,7 +341,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 	}

 	// Set some commonly used flags
-	c.doLiveReload = running && !c.Cfg.GetBool("disableLiveReload")
+	c.doLiveReload = c.running && !c.Cfg.GetBool("disableLiveReload")
 	c.fastRenderMode = c.doLiveReload && !c.Cfg.GetBool("disableFastRender")
 	c.showErrorInBrowser = c.doLiveReload && !c.Cfg.GetBool("disableBrowserError")

@@ -339,7 +353,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		}
 	}

-	logger, err := c.createLogger(config, running)
+	logger, err := c.createLogger(config)
 	if err != nil {
 		return err
 	}
@@ -389,7 +403,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		}

 		// To debug hard-to-find path issues.
-		//fs.Destination = hugofs.NewStacktracerFs(fs.Destination, `fr/fr`)
+		// fs.Destination = hugofs.NewStacktracerFs(fs.Destination, `fr/fr`)

 		err = c.initFs(fs)
 		if err != nil {
@@ -399,10 +413,13 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {

 		var h *hugolib.HugoSites

-		h, err = hugolib.NewHugoSites(*c.DepsCfg)
+		var createErr error
+		h, createErr = hugolib.NewHugoSites(*c.DepsCfg)
+		if h == nil || c.failOnInitErr {
+			err = createErr
+		}
 		c.hugoSites = h
 		close(c.created)
-
 	})

 	if err != nil {
@@ -415,8 +432,5 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 	}
 	config.Set("cacheDir", cacheDir)

-	cfg.Logger.INFO.Println("Using config file:", config.ConfigFileUsed())
-
 	return nil
-
 }
@@ -88,6 +88,7 @@ var _ commandsBuilderGetter = (*baseBuilderCmd)(nil)
 type commandsBuilderGetter interface {
 	getCommandsBuilder() *commandsBuilder
 }
+
 type baseBuilderCmd struct {
 	*baseCmd
 	*commandsBuilder
@@ -138,7 +139,6 @@ func (c *nilCommand) getCommand() *cobra.Command {
 }

 func (c *nilCommand) flagsToConfig(cfg config.Provider) {
-
 }

 func (b *commandsBuilder) newHugoCmd() *hugoCmd {
@@ -162,13 +162,21 @@ Complete documentation is available at http://gohugo.io/.`,
 				return nil
 			}

-			c, err := initializeConfig(true, cc.buildWatch, &cc.hugoBuilderCommon, cc, cfgInit)
+			// prevent cobra printing error so it can be handled here (before the timeTrack prints)
+			cmd.SilenceErrors = true
+
+			c, err := initializeConfig(true, true, cc.buildWatch, &cc.hugoBuilderCommon, cc, cfgInit)
 			if err != nil {
+				cmd.PrintErrln("Error:", err.Error())
 				return err
 			}
 			cc.c = c

-			return c.build()
+			err = c.build()
+			if err != nil {
+				cmd.PrintErrln("Error:", err.Error())
+			}
+			return err
 		},
 	})

@@ -204,6 +212,7 @@ type hugoBuilderCommon struct {
 	environment string

 	buildWatch bool
+	poll       string

 	gc bool

@@ -291,6 +300,7 @@ func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 	cmd.Flags().StringVarP(&cc.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(&cc.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
+	cmd.Flags().StringVar(&cc.poll, "poll", "", "set this to a poll interval, e.g --poll 700ms, to use a poll based approach to watch for file system changes")

 	cmd.Flags().Bool("templateMetrics", false, "display metrics about template executions")
 	cmd.Flags().Bool("templateMetricsHints", false, "calculate some improvement hints when combined with --templateMetrics")
@@ -322,16 +332,12 @@ func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 	_ = cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
 }

-func checkErr(logger *loggers.Logger, err error, s ...string) {
+func checkErr(logger loggers.Logger, err error, s ...string) {
 	if err == nil {
 		return
 	}
-	if len(s) == 0 {
-		logger.CRITICAL.Println(err)
-		return
-	}
 	for _, message := range s {
-		logger.ERROR.Println(message)
+		logger.Errorln(message)
 	}
-	logger.ERROR.Println(err)
+	logger.Errorln(err)
 }
@@ -20,6 +20,8 @@ import (
 	"path/filepath"
 	"testing"

+	"github.com/gohugoio/hugo/config"
+
 	"github.com/gohugoio/hugo/htesting"

 	"github.com/spf13/afero"
@@ -29,13 +31,11 @@ import (
 	"github.com/gohugoio/hugo/common/types"

 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"

 	qt "github.com/frankban/quicktest"
 )

 func TestExecute(t *testing.T) {
-
 	c := qt.New(t)

 	createSite := func(c *qt.C) (string, func()) {
@@ -90,7 +90,7 @@ func TestExecute(t *testing.T) {
 		defer clean()
 		resp := Execute([]string{"deploy", "-s=" + dir, "-e=staging", "--target=mydeployment", "--dryRun"})
 		c.Assert(resp.Err, qt.Not(qt.IsNil))
-		c.Assert(resp.Err.Error(), qt.Contains, `no provider registered for "hugocloud"`)
+		c.Assert(resp.Err.Error(), qt.Contains, `no driver registered for "hugocloud"`)
 	})

 	c.Run("list", func(c *qt.C) {
@@ -121,10 +121,9 @@ func TestExecute(t *testing.T) {
 		resp := Execute([]string{"new", "site", siteDir, "-e=staging"})
 		c.Assert(resp.Err, qt.IsNil)
 		config := readFileFrom(c, filepath.Join(siteDir, "config.toml"))
-		c.Assert(config, qt.Contains, "baseURL = \"http://example.org/\"")
+		c.Assert(config, qt.Contains, "baseURL = 'http://example.org/'")
 		checkNewSiteInited(c, siteDir)
 	})
-
 }

 func checkNewSiteInited(c *qt.C, basepath string) {
@@ -168,7 +167,7 @@ func TestFlags(t *testing.T) {
 			name: "ignoreVendor as bool",
 			args: []string{"server", "--ignoreVendor"},
 			check: func(c *qt.C, cmd *serverCmd) {
-				cfg := viper.New()
+				cfg := config.New()
 				cmd.flagsToConfig(cfg)
 				c.Assert(cfg.Get("ignoreVendor"), qt.Equals, true)
 			},
@@ -178,14 +177,15 @@ func TestFlags(t *testing.T) {
 			name: "ignoreVendorPaths",
 			args: []string{"server", "--ignoreVendorPaths=github.com/**"},
 			check: func(c *qt.C, cmd *serverCmd) {
-				cfg := viper.New()
+				cfg := config.New()
 				cmd.flagsToConfig(cfg)
 				c.Assert(cfg.Get("ignoreVendorPaths"), qt.Equals, "github.com/**")
 			},
 		},
 		{
 			name: "Persistent flags",
-			args: []string{"server",
+			args: []string{
+				"server",
 				"--config=myconfig.toml",
 				"--configDir=myconfigdir",
 				"--contentDir=mycontent",
@@ -217,7 +217,7 @@ func TestFlags(t *testing.T) {
 				c.Assert(sc.serverPort, qt.Equals, 1366)
 				c.Assert(sc.environment, qt.Equals, "testing")

-				cfg := viper.New()
+				cfg := config.New()
 				sc.flagsToConfig(cfg)
 				c.Assert(cfg.GetString("publishDir"), qt.Equals, "/tmp/mydestination")
 				c.Assert(cfg.GetString("contentDir"), qt.Equals, "mycontent")
@@ -235,12 +235,12 @@ func TestFlags(t *testing.T) {

 				// The flag is named i18n-warnings
 				c.Assert(cfg.GetBool("logI18nWarnings"), qt.Equals, true)
-
-			}}}
+			},
+		},
+	}

 	for _, test := range tests {
 		c.Run(test.name, func(c *qt.C) {
-
 			b := newCommandsBuilder()
 			root := b.addAll().build()

@@ -257,11 +257,9 @@ func TestFlags(t *testing.T) {
 			test.check(c, b.commands[0].(*serverCmd))
 		})
 	}
-
 }

 func TestCommandsExecute(t *testing.T) {
-
 	c := qt.New(t)

 	dir, clean, err := createSimpleTestSite(t, testSiteConfig{})
@@ -330,7 +328,6 @@ func TestCommandsExecute(t *testing.T) {
 		}

 	}
-
 }

 type testSiteConfig struct {
@@ -399,7 +396,6 @@ Environment: {{ hugo.Environment }}
 `)

 	return d, clean, nil
-
 }

 func writeFile(t *testing.T, filename, content string) {
@@ -21,6 +21,9 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/common/maps"

 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
@@ -28,7 +31,6 @@ import (
 	"github.com/gohugoio/hugo/modules"

 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )

 var _ cmder = (*configCmd)(nil)
@@ -60,7 +62,7 @@ func (b *commandsBuilder) newConfigCmd() *configCmd {
 }

 func (c *configCmd) printMounts(cmd *cobra.Command, args []string) error {
-	cfg, err := initializeConfig(true, false, &c.hugoBuilderCommon, c, nil)
+	cfg, err := initializeConfig(true, false, false, &c.hugoBuilderCommon, c, nil)
 	if err != nil {
 		return err
 	}
@@ -68,7 +70,7 @@ func (c *configCmd) printMounts(cmd *cobra.Command, args []string) error {
 	allModules := cfg.Cfg.Get("allmodules").(modules.Modules)

 	for _, m := range allModules {
-		if err := parser.InterfaceToConfig(&modMounts{m: m}, metadecoders.JSON, os.Stdout); err != nil {
+		if err := parser.InterfaceToConfig(&modMounts{m: m, verbose: c.verbose}, metadecoders.JSON, os.Stdout); err != nil {
 			return err
 		}
 	}
@@ -76,12 +78,12 @@ func (c *configCmd) printMounts(cmd *cobra.Command, args []string) error {
 }

 func (c *configCmd) printConfig(cmd *cobra.Command, args []string) error {
-	cfg, err := initializeConfig(true, false, &c.hugoBuilderCommon, c, nil)
+	cfg, err := initializeConfig(true, false, false, &c.hugoBuilderCommon, c, nil)
 	if err != nil {
 		return err
 	}

-	allSettings := cfg.Cfg.(*viper.Viper).AllSettings()
+	allSettings := cfg.Cfg.Get("").(maps.Params)

 	// We need to clean up this, but we store objects in the config that
 	// isn't really interesting to the end user, so filter these.
@@ -114,7 +116,8 @@ func (c *configCmd) printConfig(cmd *cobra.Command, args []string) error {
 }

 type modMounts struct {
-	m modules.Module
+	verbose bool
+	m       modules.Module
 }

 type modMount struct {
@@ -134,13 +137,49 @@ func (m *modMounts) MarshalJSON() ([]byte, error) {
 		})
 	}

+	var ownerPath string
+	if m.m.Owner() != nil {
+		ownerPath = m.m.Owner().Path()
+	}
+
+	if m.verbose {
+		config := m.m.Config()
+		return json.Marshal(&struct {
+			Path        string                 `json:"path"`
+			Version     string                 `json:"version"`
+			Time        time.Time              `json:"time"`
+			Owner       string                 `json:"owner"`
+			Dir         string                 `json:"dir"`
+			Meta        map[string]interface{} `json:"meta"`
+			HugoVersion modules.HugoVersion    `json:"hugoVersion"`
+
+			Mounts []modMount `json:"mounts"`
+		}{
+			Path:        m.m.Path(),
+			Version:     m.m.Version(),
+			Time:        m.m.Time(),
+			Owner:       ownerPath,
+			Dir:         m.m.Dir(),
+			Meta:        config.Params,
+			HugoVersion: config.HugoVersion,
+			Mounts:      mounts,
+		})
+	}
+
 	return json.Marshal(&struct {
-		Path   string     `json:"path"`
-		Dir    string     `json:"dir"`
-		Mounts []modMount `json:"mounts"`
+		Path    string     `json:"path"`
+		Version string     `json:"version"`
+		Time    time.Time  `json:"time"`
+		Owner   string     `json:"owner"`
+		Dir     string     `json:"dir"`
+		Mounts  []modMount `json:"mounts"`
 	}{
-		Path:   m.m.Path(),
-		Dir:    m.m.Dir(),
-		Mounts: mounts,
+		Path:    m.m.Path(),
+		Version: m.m.Version(),
+		Time:    m.m.Time(),
+		Owner:   ownerPath,
+		Dir:     m.m.Dir(),
+		Mounts:  mounts,
 	})
+
 }
@@ -16,6 +16,7 @@ package commands
 import (
 	"bytes"
 	"fmt"
+	"path/filepath"
 	"strings"
 	"time"

@@ -34,14 +35,10 @@ import (

 	"github.com/gohugoio/hugo/hugolib"

-	"path/filepath"
-
 	"github.com/spf13/cobra"
 )

-var (
-	_ cmder = (*convertCmd)(nil)
-)
+var _ cmder = (*convertCmd)(nil)

 type convertCmd struct {
 	outputDir string
@@ -105,7 +102,7 @@ func (cc *convertCmd) convertContents(format metadecoders.Format) error {
 		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
 	}

-	c, err := initializeConfig(true, false, &cc.hugoBuilderCommon, cc, nil)
+	c, err := initializeConfig(true, false, false, &cc.hugoBuilderCommon, cc, nil)
 	if err != nil {
 		return err
 	}
@@ -123,7 +120,7 @@ func (cc *convertCmd) convertContents(format metadecoders.Format) error {

 	site := h.Sites[0]

-	site.Log.FEEDBACK.Println("processing", len(site.AllPages()), "content files")
+	site.Log.Println("processing", len(site.AllPages()), "content files")
 	for _, p := range site.AllPages() {
 		if err := cc.convertAndSavePage(p, site, format); err != nil {
 			return err
@@ -147,19 +144,19 @@ func (cc *convertCmd) convertAndSavePage(p page.Page, site *hugolib.Site, target

 	errMsg := fmt.Errorf("Error processing file %q", p.Path())

-	site.Log.INFO.Println("Attempting to convert", p.File().Filename())
+	site.Log.Infoln("Attempting to convert", p.File().Filename())

 	f := p.File()
 	file, err := f.FileInfo().Meta().Open()
 	if err != nil {
-		site.Log.ERROR.Println(errMsg)
+		site.Log.Errorln(errMsg)
 		file.Close()
 		return nil
 	}

 	pf, err := pageparser.ParseFrontMatterAndContent(file)
 	if err != nil {
-		site.Log.ERROR.Println(errMsg)
+		site.Log.Errorln(errMsg)
 		file.Close()
 		return err
 	}
@@ -179,7 +176,7 @@ func (cc *convertCmd) convertAndSavePage(p page.Page, site *hugolib.Site, target
 	var newContent bytes.Buffer
 	err = parser.InterfaceToFrontMatter(pf.FrontMatter, targetFormat, &newContent)
 	if err != nil {
-		site.Log.ERROR.Println(errMsg)
+		site.Log.Errorln(errMsg)
 		return err
 	}

@@ -11,6 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

+// +build !nodeploy
+
 package commands

 import (
@@ -58,7 +60,7 @@ documentation.
 				c.Set("maxDeletes", cc.maxDeletes)
 				return nil
 			}
-			comm, err := initializeConfig(true, false, &cc.hugoBuilderCommon, cc, cfgInit)
+			comm, err := initializeConfig(true, true, false, &cc.hugoBuilderCommon, cc, cfgInit)
 			if err != nil {
 				return err
 			}
@@ -16,6 +16,8 @@ package commands
 import (
 	"runtime"

+	"github.com/gohugoio/hugo/common/hugo"
+
 	"github.com/spf13/cobra"
 	jww "github.com/spf13/jwalterweatherman"
 )
@@ -27,18 +29,32 @@ type envCmd struct {
 }

 func newEnvCmd() *envCmd {
-	return &envCmd{baseCmd: newBaseCmd(&cobra.Command{
-		Use:   "env",
-		Short: "Print Hugo version and environment info",
-		Long:  `Print Hugo version and environment info. This is useful in Hugo bug reports.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			printHugoVersion()
-			jww.FEEDBACK.Printf("GOOS=%q\n", runtime.GOOS)
-			jww.FEEDBACK.Printf("GOARCH=%q\n", runtime.GOARCH)
-			jww.FEEDBACK.Printf("GOVERSION=%q\n", runtime.Version())
+	return &envCmd{
+		baseCmd: newBaseCmd(&cobra.Command{
+			Use:   "env",
+			Short: "Print Hugo version and environment info",
+			Long: `Print Hugo version and environment info. This is useful in Hugo bug reports.

-			return nil
-		},
-	}),
+If you add the -v flag, you will get a full dependency list.
+`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				printHugoVersion()
+				jww.FEEDBACK.Printf("GOOS=%q\n", runtime.GOOS)
+				jww.FEEDBACK.Printf("GOARCH=%q\n", runtime.GOARCH)
+				jww.FEEDBACK.Printf("GOVERSION=%q\n", runtime.Version())
+
+				isVerbose, _ := cmd.Flags().GetBool("verbose")
+
+				if isVerbose {
+					deps := hugo.GetDependencyList()
+					for _, dep := range deps {
+						jww.FEEDBACK.Printf("%s\n", dep)
+					}
+				}
+
+				return nil
+			},
+		}),
 	}
+
 }
@@ -14,6 +14,9 @@
 package commands

 import (
+	"io"
+	"os"
+
 	"github.com/spf13/cobra"
 	jww "github.com/spf13/jwalterweatherman"
 )
@@ -23,7 +26,7 @@ var _ cmder = (*genautocompleteCmd)(nil)
 type genautocompleteCmd struct {
 	autocompleteTarget string

-	// bash for now (zsh and others will come)
+	// bash, zsh, fish or powershell
 	autocompleteType string

 	*baseCmd
@@ -37,44 +40,54 @@ func newGenautocompleteCmd() *genautocompleteCmd {
 		Short: "Generate shell autocompletion script for Hugo",
 		Long: `Generates a shell autocompletion script for Hugo.

-NOTE: The current version supports Bash only.
-      This should work for *nix systems with Bash installed.
+The script is written to the console (stdout).

-By default, the file is written directly to /etc/bash_completion.d
-for convenience, and the command may need superuser rights, e.g.:
+To write to file, add the ` + "`--completionfile=/path/to/file`" + ` flag.

-	$ sudo hugo gen autocomplete
-
-Add ` + "`--completionfile=/path/to/file`" + ` flag to set alternative
-file-path and name.
+Add ` + "`--type={bash, zsh, fish or powershell}`" + ` flag to set alternative
+shell type.

 Logout and in again to reload the completion scripts,
 or just source them in directly:

-	$ . /etc/bash_completion`,
+	$ . /etc/bash_completion or /path/to/file`,

 		RunE: func(cmd *cobra.Command, args []string) error {
-			if cc.autocompleteType != "bash" {
-				return newUserError("Only Bash is supported for now")
+			var err error
+			var target io.Writer
+
+			if cc.autocompleteTarget == "" {
+				target = os.Stdout
+			} else {
+				target, _ = os.OpenFile(cc.autocompleteTarget, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 			}

-			err := cmd.Root().GenBashCompletionFile(cc.autocompleteTarget)
+			switch cc.autocompleteType {
+			case "bash":
+				err = cmd.Root().GenBashCompletion(target)
+			case "zsh":
+				err = cmd.Root().GenZshCompletion(target)
+			case "fish":
+				err = cmd.Root().GenFishCompletion(target, true)
+			case "powershell":
+				err = cmd.Root().GenPowerShellCompletion(target)
+			default:
+				return newUserError("Unsupported completion type")
+			}

 			if err != nil {
 				return err
 			}

-			jww.FEEDBACK.Println("Bash completion file for Hugo saved to", cc.autocompleteTarget)
-
+			if cc.autocompleteTarget != "" {
+				jww.FEEDBACK.Println(cc.autocompleteType+" completion file for Hugo saved to", cc.autocompleteTarget)
+			}
 			return nil
 		},
 	})

-	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteTarget, "completionfile", "", "/etc/bash_completion.d/hugo.sh", "autocompletion file")
-	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteType, "type", "", "bash", "autocompletion type (currently only bash supported)")
-
-	// For bash-completion
-	cc.cmd.PersistentFlags().SetAnnotation("completionfile", cobra.BashCompFilenameExt, []string{})
+	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteTarget, "completionfile", "f", "", "autocompletion file, defaults to stdout")
+	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteType, "type", "t", "bash", "autocompletion type (bash, zsh, fish, or powershell)")

 	return cc
 }
@@ -22,9 +22,7 @@ import (
 	"github.com/spf13/cobra"
 )

-var (
-	_ cmder = (*genChromaStyles)(nil)
-)
+var _ cmder = (*genChromaStyles)(nil)

 type genChromaStyles struct {
 	style          string
@@ -39,9 +37,9 @@ func createGenChromaStyles() *genChromaStyles {
 		baseCmd: newBaseCmd(&cobra.Command{
 			Use:   "chromastyles",
 			Short: "Generate CSS stylesheet for the Chroma code highlighter",
-			Long: `Generate CSS stylesheet for the Chroma code highlighter for a given style. This stylesheet is needed if pygmentsUseClasses is enabled in config.
+			Long: `Generate CSS stylesheet for the Chroma code highlighter for a given style. This stylesheet is needed if markup.highlight.noClasses is disabled in config.

-See https://help.farbox.com/pygments.html for preview of available styles`,
+See https://xyproto.github.io/splash/docs/all.html for a preview of the available styles`,
 		}),
 	}

@@ -49,7 +47,7 @@ See https://help.farbox.com/pygments.html for preview of available styles`,
 		return g.generate()
 	}

-	g.cmd.PersistentFlags().StringVar(&g.style, "style", "friendly", "highlighter style (see https://help.farbox.com/pygments.html)")
+	g.cmd.PersistentFlags().StringVar(&g.style, "style", "friendly", "highlighter style (see https://xyproto.github.io/splash/docs/)")
 	g.cmd.PersistentFlags().StringVar(&g.highlightStyle, "highlightStyle", "bg:#ffffcc", "style used for highlighting lines (see https://github.com/alecthomas/chroma)")
 	g.cmd.PersistentFlags().StringVar(&g.linesStyle, "linesStyle", "", "style used for line numbers (see https://github.com/alecthomas/chroma)")

@@ -18,7 +18,6 @@ import (
 	"path"
 	"path/filepath"
 	"strings"
-	"time"

 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
@@ -36,7 +35,6 @@ type genDocCmd struct {

 func newGenDocCmd() *genDocCmd {
 	const gendocFrontmatterTemplate = `---
-date: %s
 title: "%s"
 slug: %s
 url: %s
@@ -57,6 +55,12 @@ It creates one Markdown file per command with front matter suitable
 for rendering in Hugo.`,

 		RunE: func(cmd *cobra.Command, args []string) error {
+			cmd.VisitParents(func(c *cobra.Command) {
+				// Disable the "Auto generated by spf13/cobra on DATE"
+				// as it creates a lot of diffs.
+				c.DisableAutoGenTag = true
+			})
+
 			if !strings.HasSuffix(cc.gendocdir, helpers.FilePathSeparator) {
 				cc.gendocdir += helpers.FilePathSeparator
 			}
@@ -66,19 +70,17 @@ for rendering in Hugo.`,
 					return err
 				}
 			}
-			now := time.Now().Format("2006-01-02")
 			prepender := func(filename string) string {
 				name := filepath.Base(filename)
 				base := strings.TrimSuffix(name, path.Ext(name))
 				url := "/commands/" + strings.ToLower(base) + "/"
-				return fmt.Sprintf(gendocFrontmatterTemplate, now, strings.Replace(base, "_", " ", -1), base, url)
+				return fmt.Sprintf(gendocFrontmatterTemplate, strings.Replace(base, "_", " ", -1), base, url)
 			}

 			linkHandler := func(name string) string {
 				base := strings.TrimSuffix(name, path.Ext(name))
 				return "/commands/" + strings.ToLower(base) + "/"
 			}
-
 			jww.FEEDBACK.Println("Generating Hugo command-line documentation in", cc.gendocdir, "...")
 			doc.GenMarkdownTreeCustom(cmd.Root(), cc.gendocdir, prepender, linkHandler)
 			jww.FEEDBACK.Println("Done.")
@@ -23,9 +23,7 @@ import (
 	"github.com/spf13/cobra"
 )

-var (
-	_ cmder = (*genDocsHelper)(nil)
-)
+var _ cmder = (*genDocsHelper)(nil)

 type genDocsHelper struct {
 	target string
@@ -70,5 +68,4 @@ func (g *genDocsHelper) generate() error {

 	fmt.Println("Done!")
 	return nil
-
 }
@@ -19,10 +19,20 @@ import (
 	"context"
 	"fmt"
 	"io/ioutil"
+	"os"
 	"os/signal"
+	"path/filepath"
+	"runtime"
 	"runtime/pprof"
 	"runtime/trace"
+	"strings"
 	"sync/atomic"
+	"syscall"
+	"time"
+
+	"github.com/gohugoio/hugo/hugofs/files"
+
+	"github.com/gohugoio/hugo/common/types"

 	"github.com/gohugoio/hugo/hugofs"

@@ -31,21 +41,14 @@ import (
 	"github.com/pkg/errors"

 	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/terminal"

-	"syscall"
-
 	"github.com/gohugoio/hugo/hugolib/filesystems"

 	"golang.org/x/sync/errgroup"

-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
 	"github.com/gohugoio/hugo/config"

 	flag "github.com/spf13/pflag"
@@ -82,7 +85,6 @@ func (r Response) IsUserError() bool {
 // Execute adds all child commands to the root command HugoCmd and sets flags appropriately.
 // The args are usually filled with os.Args[1:].
 func Execute(args []string) Response {
-
 	hugoCmd := newCommandsBuilder().addAll().build()
 	cmd := hugoCmd.getCommand()
 	cmd.SetArgs(args)
@@ -116,21 +118,19 @@ func Execute(args []string) Response {
 }

 // InitializeConfig initializes a config file with sensible default configuration flags.
-func initializeConfig(mustHaveConfigFile, running bool,
+func initializeConfig(mustHaveConfigFile, failOnInitErr, running bool,
 	h *hugoBuilderCommon,
 	f flagsToConfigHandler,
 	cfgInit func(c *commandeer) error) (*commandeer, error) {
-
-	c, err := newCommandeer(mustHaveConfigFile, running, h, f, cfgInit)
+	c, err := newCommandeer(mustHaveConfigFile, failOnInitErr, running, h, f, cfgInit)
 	if err != nil {
 		return nil, err
 	}

 	return c, nil
-
 }

-func (c *commandeer) createLogger(cfg config.Provider, running bool) (*loggers.Logger, error) {
+func (c *commandeer) createLogger(cfg config.Provider) (loggers.Logger, error) {
 	var (
 		logHandle       = ioutil.Discard
 		logThreshold    = jww.LevelWarn
@@ -174,7 +174,7 @@ func (c *commandeer) createLogger(cfg config.Provider, running bool) (*loggers.L
 	loggers.InitGlobalLogger(stdoutThreshold, logThreshold, outHandle, logHandle)
 	helpers.InitLoggers()

-	return loggers.NewLogger(stdoutThreshold, logThreshold, outHandle, logHandle, running), nil
+	return loggers.NewLogger(stdoutThreshold, logThreshold, outHandle, logHandle, c.running), nil
 }

 func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
@@ -246,7 +246,6 @@ func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
 	setValueFromFlag(cmd.Flags(), "destination", cfg, "publishDir", false)
 	setValueFromFlag(cmd.Flags(), "i18n-warnings", cfg, "logI18nWarnings", false)
 	setValueFromFlag(cmd.Flags(), "path-warnings", cfg, "logPathWarnings", false)
-
 }

 func setValueFromFlag(flags *flag.FlagSet, key string, cfg config.Provider, targetKey string, force bool) {
@@ -281,7 +280,7 @@ func isTerminal() bool {
 	return terminal.IsTerminal(os.Stdout)
 }

-func (c *commandeer) fullBuild() error {
+func (c *commandeer) fullBuild(noBuildLock bool) error {

 	var (
 		g         errgroup.Group
@@ -290,6 +289,7 @@ func (c *commandeer) fullBuild() error {

 	if !c.h.quiet {
 		fmt.Println("Start building sites … ")
+		fmt.Println(hugo.BuildVersionString())
 		if isTerminal() {
 			defer func() {
 				fmt.Print(showCursor + clearLine)
@@ -298,7 +298,6 @@ func (c *commandeer) fullBuild() error {
 	}

 	copyStaticFunc := func() error {
-
 		cnt, err := c.copyStatic()
 		if err != nil {
 			return errors.Wrap(err, "Error copying static files")
@@ -307,7 +306,7 @@ func (c *commandeer) fullBuild() error {
 		return nil
 	}
 	buildSitesFunc := func() error {
-		if err := c.buildSites(); err != nil {
+		if err := c.buildSites(noBuildLock); err != nil {
 			return errors.Wrap(err, "Error building site")
 		}
 		return nil
@@ -346,7 +345,6 @@ func (c *commandeer) fullBuild() error {
 	}

 	return nil
-
 }

 func (c *commandeer) initCPUProfile() (func(), error) {
@@ -374,12 +372,12 @@ func (c *commandeer) initMemProfile() {

 	f, err := os.Create(c.h.memprofile)
 	if err != nil {
-		c.logger.ERROR.Println("could not create memory profile: ", err)
+		c.logger.Errorf("could not create memory profile: ", err)
 	}
 	defer f.Close()
 	runtime.GC() // get up-to-date statistics
 	if err := pprof.WriteHeapProfile(f); err != nil {
-		c.logger.ERROR.Println("could not write memory profile: ", err)
+		c.logger.Errorf("could not write memory profile: ", err)
 	}
 }

@@ -419,7 +417,6 @@ func (c *commandeer) initMutexProfile() (func(), error) {
 		pprof.Lookup("mutex").WriteTo(f, 0)
 		f.Close()
 	}, nil
-
 }

 func (c *commandeer) initMemTicker() func() {
@@ -429,7 +426,6 @@ func (c *commandeer) initMemTicker() func() {
 		var m runtime.MemStats
 		runtime.ReadMemStats(&m)
 		fmt.Printf("\n\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", formatByteCount(m.Alloc), formatByteCount(m.TotalAlloc), formatByteCount(m.Sys), m.NumGC)
-
 	}

 	go func() {
@@ -442,7 +438,6 @@ func (c *commandeer) initMemTicker() func() {
 				printMem()
 				return
 			}
-
 		}
 	}()

@@ -452,7 +447,6 @@ func (c *commandeer) initMemTicker() func() {
 }

 func (c *commandeer) initProfiling() (func(), error) {
-
 	stopCPUProf, err := c.initCPUProfile()
 	if err != nil {
 		return nil, err
@@ -505,7 +499,7 @@ func (c *commandeer) build() error {
 		}
 	}()

-	if err := c.fullBuild(); err != nil {
+	if err := c.fullBuild(false); err != nil {
 		return err
 	}

@@ -518,7 +512,7 @@ func (c *commandeer) build() error {
 		if createCounter, ok := c.destinationFs.(hugofs.DuplicatesReporter); ok {
 			dupes := createCounter.ReportDuplicates()
 			if dupes != "" {
-				c.logger.WARN.Println("Duplicate target paths:", dupes)
+				c.logger.Warnln("Duplicate target paths:", dupes)
 			}
 		}
 	}
@@ -532,13 +526,13 @@ func (c *commandeer) build() error {
 		baseWatchDir := c.Cfg.GetString("workingDir")
 		rootWatchDirs := getRootWatchDirsStr(baseWatchDir, watchDirs)

-		c.logger.FEEDBACK.Printf("Watching for changes in %s%s{%s}\n", baseWatchDir, helpers.FilePathSeparator, rootWatchDirs)
-		c.logger.FEEDBACK.Println("Press Ctrl+C to stop")
-		watcher, err := c.newWatcher(watchDirs...)
+		c.logger.Printf("Watching for changes in %s%s{%s}\n", baseWatchDir, helpers.FilePathSeparator, rootWatchDirs)
+		c.logger.Println("Press Ctrl+C to stop")
+		watcher, err := c.newWatcher(c.h.poll, watchDirs...)
 		checkErr(c.Logger, err)
 		defer watcher.Close()

-		var sigs = make(chan os.Signal, 1)
+		sigs := make(chan os.Signal, 1)
 		signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

 		<-sigs
@@ -548,7 +542,6 @@ func (c *commandeer) build() error {
 }

 func (c *commandeer) serverBuild() error {
-	defer c.timeTrack(time.Now(), "Built")

 	stopProfiling, err := c.initProfiling()
 	if err != nil {
@@ -561,7 +554,7 @@ func (c *commandeer) serverBuild() error {
 		}
 	}()

-	if err := c.fullBuild(); err != nil {
+	if err := c.fullBuild(false); err != nil {
 		return err
 	}

@@ -584,13 +577,12 @@ func (c *commandeer) copyStatic() (map[string]uint64, error) {
 }

 func (c *commandeer) doWithPublishDirs(f func(sourceFs *filesystems.SourceFilesystem) (uint64, error)) (map[string]uint64, error) {
-
 	langCount := make(map[string]uint64)

 	staticFilesystems := c.hugo().BaseFs.SourceFilesystems.Static

 	if len(staticFilesystems) == 0 {
-		c.logger.INFO.Println("No static directories found to sync")
+		c.logger.Infoln("No static directories found to sync")
 		return langCount, nil
 	}

@@ -662,13 +654,13 @@ func (c *commandeer) copyStaticTo(sourceFs *filesystems.SourceFilesystem) (uint6
 	syncer.Delete = c.Cfg.GetBool("cleanDestinationDir")

 	if syncer.Delete {
-		c.logger.INFO.Println("removing all files from destination that don't exist in static dirs")
+		c.logger.Infoln("removing all files from destination that don't exist in static dirs")

 		syncer.DeleteFilter = func(f os.FileInfo) bool {
 			return f.IsDir() && strings.HasPrefix(f.Name(), ".")
 		}
 	}
-	c.logger.INFO.Println("syncing static files to", publishDir)
+	c.logger.Infoln("syncing static files to", publishDir)

 	// because we are using a baseFs (to get the union right).
 	// set sync src to root
@@ -689,7 +681,7 @@ func (c *commandeer) firstPathSpec() *helpers.PathSpec {

 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()))
+	c.logger.Printf("%s in %v ms", name, int(1000*elapsed.Seconds()))
 }

 // getDirList provides NewWatcher() with a list of directories to watch for changes.
@@ -698,7 +690,7 @@ func (c *commandeer) getDirList() ([]string, error) {

 	walkFn := func(path string, fi hugofs.FileMetaInfo, err error) error {
 		if err != nil {
-			c.logger.ERROR.Println("walker: ", err)
+			c.logger.Errorln("walker: ", err)
 			return nil
 		}

@@ -708,23 +700,22 @@ func (c *commandeer) getDirList() ([]string, error) {
 				return filepath.SkipDir
 			}

-			filenames = append(filenames, fi.Meta().Filename())
+			filenames = append(filenames, fi.Meta().Filename)
 		}

 		return nil
-
 	}

 	watchFiles := c.hugo().PathSpec.BaseFs.WatchDirs()
 	for _, fi := range watchFiles {
 		if !fi.IsDir() {
-			filenames = append(filenames, fi.Meta().Filename())
+			filenames = append(filenames, fi.Meta().Filename)
 			continue
 		}

 		w := hugofs.NewWalkway(hugofs.WalkwayConfig{Logger: c.logger, Info: fi, WalkFn: walkFn})
 		if err := w.Walk(); err != nil {
-			c.logger.ERROR.Println("walker: ", err)
+			c.logger.Errorln("walker: ", err)
 		}
 	}

@@ -733,27 +724,25 @@ func (c *commandeer) getDirList() ([]string, error) {
 	return filenames, nil
 }

-func (c *commandeer) buildSites() (err error) {
-	return c.hugo().Build(hugolib.BuildCfg{})
+func (c *commandeer) buildSites(noBuildLock bool) (err error) {
+	return c.hugo().Build(hugolib.BuildCfg{NoBuildLock: noBuildLock})
 }

 func (c *commandeer) handleBuildErr(err error, msg string) {
 	c.buildErr = err

-	c.logger.ERROR.Print(msg + ":\n\n")
-	c.logger.ERROR.Println(helpers.FirstUpper(err.Error()))
+	c.logger.Errorln(msg + ":\n")
+	c.logger.Errorln(helpers.FirstUpper(err.Error()))
 	if !c.h.quiet && c.h.verbose {
 		herrors.PrintStackTraceFromErr(err)
 	}
 }

 func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
-	defer c.timeTrack(time.Now(), "Total")

 	c.buildErr = nil
 	visited := c.visitedURLs.PeekAllSet()
 	if c.fastRenderMode {
-
 		// Make sure we always render the home pages
 		for _, l := range c.languages {
 			langPath := c.hugo().PathSpec.GetLangSubDir(l.Lang)
@@ -763,9 +752,8 @@ func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
 			home := c.hugo().PathSpec.PrependBasePath("/"+langPath, false)
 			visited[home] = true
 		}
-
 	}
-	return c.hugo().Build(hugolib.BuildCfg{RecentlyVisited: visited, ErrRecovery: c.wasError}, events...)
+	return c.hugo().Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: visited, ErrRecovery: c.wasError}, events...)
 }

 func (c *commandeer) partialReRender(urls ...string) error {
@@ -777,7 +765,9 @@ func (c *commandeer) partialReRender(urls ...string) error {
 	for _, url := range urls {
 		visited[url] = true
 	}
-	return c.hugo().Build(hugolib.BuildCfg{RecentlyVisited: visited, PartialReRender: true, ErrRecovery: c.wasError})
+
+	// Note: We do not set NoBuildLock as the file lock is not acquired at this stage.
+	return c.hugo().Build(hugolib.BuildCfg{NoBuildLock: false, RecentlyVisited: visited, PartialReRender: true, ErrRecovery: c.wasError})
 }

 func (c *commandeer) fullRebuild(changeType string) {
@@ -793,13 +783,11 @@ func (c *commandeer) fullRebuild(changeType string) {
 	c.fullRebuildSem.Acquire(context.Background(), 1)

 	go func() {
-
 		defer c.fullRebuildSem.Release(1)

 		c.printChangeDetected(changeType)

 		defer func() {
-
 			// Allow any file system events to arrive back.
 			// This will block any rebuild on config changes for the
 			// duration of the sleep.
@@ -809,7 +797,7 @@ func (c *commandeer) fullRebuild(changeType string) {
 		defer c.timeTrack(time.Now(), "Rebuilt")

 		c.commandeerHugoState = newCommandeerHugoState()
-		err := c.loadConfig(true, true)
+		err := c.loadConfig()
 		if err != nil {
 			// Set the processing on pause until the state is recovered.
 			c.paused = true
@@ -822,13 +810,13 @@ func (c *commandeer) fullRebuild(changeType string) {
 		if !c.paused {
 			_, err := c.copyStatic()
 			if err != nil {
-				c.logger.ERROR.Println(err)
+				c.logger.Errorln(err)
 				return
 			}

-			err = c.buildSites()
+			err = c.buildSites(true)
 			if err != nil {
-				c.logger.ERROR.Println(err)
+				c.logger.Errorln(err)
 			} else if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
 				livereload.ForceRefresh()
 			}
@@ -837,7 +825,7 @@ func (c *commandeer) fullRebuild(changeType string) {
 }

 // newWatcher creates a new watcher to watch filesystem events.
-func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
+func (c *commandeer) newWatcher(pollIntervalStr string, dirList ...string) (*watcher.Batcher, error) {
 	if runtime.GOOS == "darwin" {
 		tweakLimit()
 	}
@@ -847,8 +835,21 @@ func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
 		return nil, err
 	}

-	watcher, err := watcher.New(1 * time.Second)
+	var pollInterval time.Duration
+	poll := pollIntervalStr != ""
+	if poll {
+		pollInterval, err = types.ToDurationE(pollIntervalStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid value for flag poll: %s", err)
+		}
+		c.logger.Printf("Use watcher with poll interval %v", pollInterval)
+	}

+	if pollInterval == 0 {
+		pollInterval = 500 * time.Millisecond
+	}
+
+	watcher, err := watcher.New(500*time.Millisecond, pollInterval, poll)
 	if err != nil {
 		return nil, err
 	}
@@ -862,7 +863,7 @@ func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
 	// Identifies changes to config (config.toml) files.
 	configSet := make(map[string]bool)

-	c.logger.FEEDBACK.Println("Watching for config changes in", strings.Join(c.configFiles, ", "))
+	c.logger.Println("Watching for config changes in", strings.Join(c.configFiles, ", "))
 	for _, configFile := range c.configFiles {
 		watcher.Add(configFile)
 		configSet[configFile] = true
@@ -872,14 +873,20 @@ func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
 		for {
 			select {
 			case evs := <-watcher.Events:
+				unlock, err := c.hugo().BaseFs.LockBuild()
+				if err != nil {
+					c.logger.Errorln("Failed to acquire a build lock: %s", err)
+					return
+				}
 				c.handleEvents(watcher, staticSyncer, evs, configSet)
 				if c.showErrorInBrowser && c.errCount() > 0 {
 					// Need to reload browser to show the error
 					livereload.ForceRefresh()
 				}
-			case err := <-watcher.Errors:
-				if err != nil {
-					c.logger.ERROR.Println("Error while watching:", err)
+				unlock()
+			case err := <-watcher.Errors():
+				if err != nil && !os.IsNotExist(err) {
+					c.logger.Errorln("Error while watching:", err)
 				}
 			}
 		}
@@ -895,9 +902,9 @@ func (c *commandeer) printChangeDetected(typ string) {
 	}
 	msg += " detected, rebuilding site."

-	c.logger.FEEDBACK.Println(msg)
+	c.logger.Println(msg)
 	const layout = "2006-01-02 15:04:05.000 -0700"
-	c.logger.FEEDBACK.Println(time.Now().Format(layout))
+	c.logger.Println(time.Now().Format(layout))
 }

 const (
@@ -909,7 +916,6 @@ func (c *commandeer) handleEvents(watcher *watcher.Batcher,
 	staticSyncer *staticSyncer,
 	evs []fsnotify.Event,
 	configSet map[string]bool) {
-
 	defer func() {
 		c.wasError = false
 	}()
@@ -950,7 +956,6 @@ func (c *commandeer) handleEvents(watcher *watcher.Batcher,
 						time.Sleep(100 * time.Millisecond)
 					}
 				}
-
 			}

 			// Config file(s) changed. Need full rebuild.
@@ -979,14 +984,16 @@ func (c *commandeer) handleEvents(watcher *watcher.Batcher,
 		return
 	}

-	c.logger.INFO.Println("Received System Events:", evs)
+	c.logger.Infoln("Received System Events:", evs)

 	staticEvents := []fsnotify.Event{}
 	dynamicEvents := []fsnotify.Event{}

-	// Special handling for symbolic links inside /content.
 	filtered := []fsnotify.Event{}
 	for _, ev := range evs {
+		if c.hugo().ShouldSkipFileChangeEvent(ev) {
+			continue
+		}
 		// Check the most specific first, i.e. files.
 		contentMapped := c.hugo().ContentChanges.GetSymbolicLinkMappings(ev.Name)
 		if len(contentMapped) > 0 {
@@ -1059,7 +1066,7 @@ func (c *commandeer) handleEvents(watcher *watcher.Batcher,

 		walkAdder := func(path string, f hugofs.FileMetaInfo, err error) error {
 			if f.IsDir() {
-				c.logger.FEEDBACK.Println("adding created directory to watchlist", path)
+				c.logger.Println("adding created directory to watchlist", path)
 				if err := watcher.Add(path); err != nil {
 					return err
 				}
@@ -1091,15 +1098,15 @@ func (c *commandeer) handleEvents(watcher *watcher.Batcher,
 		c.printChangeDetected("Static files")

 		if c.Cfg.GetBool("forceSyncStatic") {
-			c.logger.FEEDBACK.Printf("Syncing all static files\n")
+			c.logger.Printf("Syncing all static files\n")
 			_, err := c.copyStatic()
 			if err != nil {
-				c.logger.ERROR.Println("Error copying static files to publish dir:", err)
+				c.logger.Errorln("Error copying static files to publish dir:", err)
 				return
 			}
 		} else {
 			if err := staticSyncer.syncsStaticEvents(staticEvents); err != nil {
-				c.logger.ERROR.Println("Error syncing static files to publish dir:", err)
+				c.logger.Errorln("Error syncing static files to publish dir:", err)
 				return
 			}
 		}
@@ -1130,9 +1137,13 @@ func (c *commandeer) handleEvents(watcher *watcher.Batcher,

 		c.printChangeDetected("")
 		c.changeDetector.PrepareNew()
-		if err := c.rebuildSites(dynamicEvents); err != nil {
-			c.handleBuildErr(err, "Rebuild failed")
-		}
+
+		func() {
+			defer c.timeTrack(time.Now(), "Total")
+			if err := c.rebuildSites(dynamicEvents); err != nil {
+				c.handleBuildErr(err, "Rebuild failed")
+			}
+		}()

 		if doLiveReload {
 			if len(partitionedEvents.ContentEvents) == 0 && len(partitionedEvents.AssetEvents) > 0 {
@@ -1192,18 +1203,21 @@ func partitionDynamicEvents(sourceFs *filesystems.SourceFilesystems, events []fs
 		}
 	}
 	return
-
 }

 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
+		if ev.Op&fsnotify.Write == fsnotify.Write || ev.Op&fsnotify.Create == fsnotify.Create {
+			if files.IsIndexContentFile(ev.Name) {
+				return ev.Name
+			}
+
+			if files.IsContentFile(ev.Name) {
+				name = ev.Name
+			}
+
 		}
 	}

@@ -44,5 +44,4 @@ contentDir = "thisdoesnotexist"

 	_, err = cmd.ExecuteC()
 	c.Assert(err, qt.IsNil)
-
 }
@@ -13,7 +13,13 @@

 package commands

-import "github.com/spf13/cobra"
+import (
+	// For time zone lookups on Windows without Go installed.
+	// See #8892
+	_ "time/tzdata"
+
+	"github.com/spf13/cobra"
+)

 func init() {
 	// This message to show to Windows users if Hugo is opened from explorer.exe
@@ -74,11 +74,9 @@ Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root
 	cc.cmd.AddCommand(importJekyllCmd)

 	return cc
-
 }

 func (i *importCmd) importFromJekyll(cmd *cobra.Command, args []string) error {
-
 	if len(args) < 2 {
 		return newUserError(`import from jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.")
 	}
@@ -255,13 +253,11 @@ func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]
 	defer f.Close()

 	b, err := ioutil.ReadAll(f)
-
 	if err != nil {
 		return nil
 	}

 	c, err := metadecoders.Default.UnmarshalToMap(b, metadecoders.YAML)
-
 	if err != nil {
 		return nil
 	}
@@ -338,8 +334,10 @@ func (i *importCmd) copyJekyllFilesAndFolders(jekyllRoot, dest string, jekyllPos
 			}
 		} else {
 			lowerEntryName := strings.ToLower(entry.Name())
-			exceptSuffix := []string{".md", ".markdown", ".html", ".htm",
-				".xml", ".textile", "rakefile", "gemfile", ".lock"}
+			exceptSuffix := []string{
+				".md", ".markdown", ".html", ".htm",
+				".xml", ".textile", "rakefile", "gemfile", ".lock",
+			}
 			isExcept := false
 			for _, suffix := range exceptSuffix {
 				if strings.HasSuffix(lowerEntryName, suffix) {
@@ -602,8 +600,8 @@ func replaceImageTag(match string) string {
 	}
 	result.WriteString(">}}")
 	return result.String()
-
 }
+
 func replaceOptionalPart(buffer *bytes.Buffer, partName string, part string) {
 	if len(part) > 0 {
 		buffer.WriteString(partName + "=\"" + part + "\" ")
@@ -53,25 +53,41 @@ func TestConvertJekyllMetadata(t *testing.T) {
 		draft    bool
 		expect   string
 	}{
-		{map[interface{}]interface{}{}, "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
-			`{"date":"2015-10-01T00:00:00Z"}`},
-		{map[interface{}]interface{}{}, "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
-			`{"date":"2015-10-01T00:00:00Z","draft":true}`},
-		{map[interface{}]interface{}{"Permalink": "/permalink.html", "layout": "post"},
+		{
+			map[interface{}]interface{}{},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
-			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`},
-		{map[interface{}]interface{}{"permalink": "/permalink.html"},
+			`{"date":"2015-10-01T00:00:00Z"}`,
+		},
+		{
+			map[interface{}]interface{}{},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
+			`{"date":"2015-10-01T00:00:00Z","draft":true}`,
+		},
+		{
+			map[interface{}]interface{}{"Permalink": "/permalink.html", "layout": "post"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
-			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`},
-		{map[interface{}]interface{}{"category": nil, "permalink": 123},
+			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
+		},
+		{
+			map[interface{}]interface{}{"permalink": "/permalink.html"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
-			`{"date":"2015-10-01T00:00:00Z"}`},
-		{map[interface{}]interface{}{"Excerpt_Separator": "sep"},
+			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
+		},
+		{
+			map[interface{}]interface{}{"category": nil, "permalink": 123},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
-			`{"date":"2015-10-01T00:00:00Z","excerpt_separator":"sep"}`},
-		{map[interface{}]interface{}{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
+			`{"date":"2015-10-01T00:00:00Z"}`,
+		},
+		{
+			map[interface{}]interface{}{"Excerpt_Separator": "sep"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
-			`{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z"}`},
+			`{"date":"2015-10-01T00:00:00Z","excerpt_separator":"sep"}`,
+		},
+		{
+			map[interface{}]interface{}{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z"}`,
+		},
 	}

 	for _, data := range testDataList {
@@ -90,44 +106,68 @@ func TestConvertJekyllContent(t *testing.T) {
 		content  string
 		expect   string
 	}{
-		{map[interface{}]interface{}{},
-			"Test content\r\n<!-- more -->\npart2 content", "Test content\n<!--more-->\npart2 content"},
-		{map[interface{}]interface{}{},
-			"Test content\n<!-- More -->\npart2 content", "Test content\n<!--more-->\npart2 content"},
-		{map[interface{}]interface{}{"excerpt_separator": "<!--sep-->"},
+		{
+			map[interface{}]interface{}{},
+			"Test content\r\n<!-- more -->\npart2 content", "Test content\n<!--more-->\npart2 content",
+		},
+		{
+			map[interface{}]interface{}{},
+			"Test content\n<!-- More -->\npart2 content", "Test content\n<!--more-->\npart2 content",
+		},
+		{
+			map[interface{}]interface{}{"excerpt_separator": "<!--sep-->"},
 			"Test content\n<!--sep-->\npart2 content",
-			"---\nexcerpt_separator: <!--sep-->\n---\nTest content\n<!--more-->\npart2 content"},
+			"---\nexcerpt_separator: <!--sep-->\n---\nTest content\n<!--more-->\npart2 content",
+		},
 		{map[interface{}]interface{}{}, "{% raw %}text{% endraw %}", "text"},
 		{map[interface{}]interface{}{}, "{%raw%} text2 {%endraw %}", "text2"},
-		{map[interface{}]interface{}{},
+		{
+			map[interface{}]interface{}{},
 			"{% highlight go %}\nvar s int\n{% endhighlight %}",
-			"{{< highlight go >}}\nvar s int\n{{< / highlight >}}"},
-		{map[interface{}]interface{}{},
+			"{{< highlight go >}}\nvar s int\n{{< / highlight >}}",
+		},
+		{
+			map[interface{}]interface{}{},
 			"{% highlight go linenos hl_lines=\"1 2\" %}\nvar s string\nvar i int\n{% endhighlight %}",
-			"{{< highlight go \"linenos=table,hl_lines=1 2\" >}}\nvar s string\nvar i int\n{{< / highlight >}}"},
+			"{{< highlight go \"linenos=table,hl_lines=1 2\" >}}\nvar s string\nvar i int\n{{< / highlight >}}",
+		},

 		// Octopress image tag
-		{map[interface{}]interface{}{},
+		{
+			map[interface{}]interface{}{},
 			"{% img http://placekitten.com/890/280 %}",
-			"{{< figure src=\"http://placekitten.com/890/280\" >}}"},
-		{map[interface{}]interface{}{},
+			"{{< figure src=\"http://placekitten.com/890/280\" >}}",
+		},
+		{
+			map[interface{}]interface{}{},
 			"{% img left http://placekitten.com/320/250 Place Kitten #2 %}",
-			"{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}"},
-		{map[interface{}]interface{}{},
+			"{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}",
+		},
+		{
+			map[interface{}]interface{}{},
 			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #3' %}",
-			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #3\" >}}"},
-		{map[interface{}]interface{}{},
+			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #3\" >}}",
+		},
+		{
+			map[interface{}]interface{}{},
 			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
-			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
-		{map[interface{}]interface{}{},
+			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+		},
+		{
+			map[interface{}]interface{}{},
 			"{% img http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
-			"{{< figure src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
-		{map[interface{}]interface{}{},
+			"{{< figure src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+		},
+		{
+			map[interface{}]interface{}{},
 			"{% img right /placekitten/300/500 'Place Kitten #4' 'An image of a very cute kitten' %}",
-			"{{< figure class=\"right\" src=\"/placekitten/300/500\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
-		{map[interface{}]interface{}{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
+			"{{< figure class=\"right\" src=\"/placekitten/300/500\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+		},
+		{
+			map[interface{}]interface{}{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
 			"somecontent",
-			"---\nDate: \"2015-10-01 12:13:11\"\ncategory: book\nlayout: post\n---\nsomecontent"},
+			"---\nDate: \"2015-10-01 12:13:11\"\ncategory: book\nlayout: post\n---\nsomecontent",
+		},
 	}
 	for _, data := range testDataList {
 		result, err := convertJekyllContent(data.metadata, data.content)
@@ -40,13 +40,12 @@ func (lc *listCmd) buildSites(config map[string]interface{}) (*hugolib.HugoSites
 		return nil
 	}

-	c, err := initializeConfig(true, false, &lc.hugoBuilderCommon, lc, cfgInit)
+	c, err := initializeConfig(true, true, false, &lc.hugoBuilderCommon, lc, cfgInit)
 	if err != nil {
 		return nil, err
 	}

 	sites, err := hugolib.NewHugoSites(*c.DepsCfg)
-
 	if err != nil {
 		return nil, newSystemError("Error creating sites", err)
 	}
@@ -77,7 +76,6 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Long:  `List all of the drafts in your content directory.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
 				sites, err := cc.buildSites(map[string]interface{}{"buildDrafts": true})
-
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -97,7 +95,6 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			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 {
 				sites, err := cc.buildSites(map[string]interface{}{"buildFuture": true})
-
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -126,7 +123,6 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Long:  `List all of the posts in your content directory which has already expired.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
 				sites, err := cc.buildSites(map[string]interface{}{"buildExpired": true})
-
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -159,7 +155,6 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 					"buildDrafts":  true,
 					"buildFuture":  true,
 				})
-
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -71,11 +71,12 @@ Also note that if you configure a positive maxAge for the "modules" file cache,
 			if all {
 				com, err := c.initConfig(false)

-				if err != nil && !moduleNotFoundRe.MatchString(err.Error()) {
+				if err != nil && com == nil {
 					return err
 				}

-				_, err = com.hugo().FileCaches.ModulesCache().Prune(true)
+				count, err := com.hugo().FileCaches.ModulesCache().Prune(true)
+				com.logger.Printf("Deleted %d files from module cache.", count)
 				return err
 			}
 			return c.withModsClient(true, func(c *modules.Client) error {
@@ -91,7 +92,6 @@ Also note that if you configure a positive maxAge for the "modules" file cache,
 }

 func (b *commandsBuilder) newModCmd() *modCmd {
-
 	c := &modCmd{}

 	const commonUsage = `
@@ -264,7 +264,6 @@ If a module is vendored, that is where Hugo will look for it's dependencies.
 	c.baseBuilderCmd = b.newBuilderCmd(cmd)

 	return c
-
 }

 func (c *modCmd) withModsClient(failOnMissingConfig bool, f func(*modules.Client) error) error {
@@ -286,7 +285,7 @@ func (c *modCmd) withHugo(f func(*hugolib.HugoSites) error) error {
 }

 func (c *modCmd) initConfig(failOnNoConfig bool) (*commandeer, error) {
-	com, err := initializeConfig(failOnNoConfig, false, &c.hugoBuilderCommon, c, nil)
+	com, err := initializeConfig(failOnNoConfig, false, false, &c.hugoBuilderCommon, c, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -20,7 +20,6 @@ import (
 )

 func newModNPMCmd(c *modCmd) *cobra.Command {
-
 	cmd := &cobra.Command{
 		Use:   "npm",
 		Short: "Various npm helpers.",
@@ -47,7 +46,6 @@ removed from Hugo, but we need to test this out in "real life" to get a feel of
 so this may/will change in future versions of Hugo.
 `,
 		RunE: func(cmd *cobra.Command, args []string) error {
-
 			return c.withHugo(func(h *hugolib.HugoSites) error {
 				return npm.Pack(h.BaseFs.SourceFs, h.BaseFs.Assets.Dirs)
 			})
@@ -71,8 +71,7 @@ func (n *newCmd) newContent(cmd *cobra.Command, args []string) error {
 		return nil
 	}

-	c, err := initializeConfig(true, false, &n.hugoBuilderCommon, n, cfgInit)
-
+	c, err := initializeConfig(true, true, false, &n.hugoBuilderCommon, n, cfgInit)
 	if err != nil {
 		return err
 	}
@@ -81,17 +80,7 @@ func (n *newCmd) newContent(cmd *cobra.Command, args []string) error {
 		return newUserError("path needs to be provided")
 	}

-	createPath := args[0]
-
-	var kind string
-
-	createPath, kind = newContentPathSection(c.hugo(), createPath)
-
-	if n.contentType != "" {
-		kind = n.contentType
-	}
-
-	return create.NewContent(c.hugo(), kind, createPath)
+	return create.NewContent(c.hugo(), n.contentType, args[0])
 }

 func mkdir(x ...string) {
@@ -119,7 +108,7 @@ func newContentPathSection(h *hugolib.HugoSites, path string) (string, string) {

 	if h != nil {
 		for _, dir := range h.BaseFs.Content.Dirs {
-			createpath = strings.TrimPrefix(createpath, dir.Meta().Filename())
+			createpath = strings.TrimPrefix(createpath, dir.Meta().Filename)
 		}
 	}

@@ -19,6 +19,7 @@ import (
 	"path/filepath"
 	"strings"

+	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/parser/metadecoders"

 	_errors "github.com/pkg/errors"
@@ -29,7 +30,6 @@ import (
 	"github.com/gohugoio/hugo/parser"
 	"github.com/spf13/cobra"
 	jww "github.com/spf13/jwalterweatherman"
-	"github.com/spf13/viper"
 )

 var _ cmder = (*newSiteCmd)(nil)
@@ -58,7 +58,6 @@ Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)

 	return cc
-
 }

 func (n *newSiteCmd) doNewSite(fs *hugofs.Fs, basepath string, force bool) error {
@@ -103,7 +102,7 @@ func (n *newSiteCmd) doNewSite(fs *hugofs.Fs, basepath string, force bool) error

 	// Create a default archetype file.
 	helpers.SafeWriteToDisk(filepath.Join(archeTypePath, "default.md"),
-		strings.NewReader(create.ArchetypeTemplateTemplate), fs.Source)
+		strings.NewReader(create.DefaultArchetypeTemplateTemplate), fs.Source)

 	jww.FEEDBACK.Printf("Congratulations! Your new Hugo site is created in %s.\n\n", basepath)
 	jww.FEEDBACK.Println(nextStepsText())
@@ -124,7 +123,7 @@ func (n *newSiteCmd) newSite(cmd *cobra.Command, args []string) error {

 	forceNew, _ := cmd.Flags().GetBool("force")

-	return n.doNewSite(hugofs.NewDefault(viper.New()), createpath, forceNew)
+	return n.doNewSite(hugofs.NewDefault(config.New()), createpath, forceNew)
 }

 func createConfig(fs *hugofs.Fs, inpath string, kind string) (err error) {
@@ -38,7 +38,7 @@ func (b *commandsBuilder) newNewThemeCmd() *newThemeCmd {
 	cmd := &cobra.Command{
 		Use:   "theme [name]",
 		Short: "Create a new theme",
-		Long: `Create a new theme (skeleton) called [name] in the current directory.
+		Long: `Create a new theme (skeleton) called [name] in ./themes.
 New theme is a skeleton. Please add content to the touched files. Add your
 name to the copyright line in the license and adjust the theme.toml file
 as you see fit.`,
@@ -52,8 +52,7 @@ as you see fit.`,

 // newTheme creates a new Hugo theme template
 func (n *newThemeCmd) newTheme(cmd *cobra.Command, args []string) error {
-	c, err := initializeConfig(false, false, &n.hugoBuilderCommon, n, nil)
-
+	c, err := initializeConfig(false, false, false, &n.hugoBuilderCommon, n, nil)
 	if err != nil {
 		return err
 	}
@@ -145,7 +144,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 }

 func (n *newThemeCmd) createThemeMD(fs *hugofs.Fs, inpath string) (err error) {
-
 	by := []byte(`# theme.toml template for a Hugo theme
 # See https://github.com/gohugoio/hugoThemes#themetoml for an example

@@ -0,0 +1,50 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build nodeploy
+
+package commands
+
+import (
+	"errors"
+
+	"github.com/spf13/cobra"
+)
+
+var _ cmder = (*deployCmd)(nil)
+
+// deployCmd supports deploying sites to Cloud providers.
+type deployCmd struct {
+	*baseBuilderCmd
+}
+
+func (b *commandsBuilder) newDeployCmd() *deployCmd {
+	cc := &deployCmd{}
+
+	cmd := &cobra.Command{
+		Use:   "deploy",
+		Short: "Deploy your site to a Cloud provider.",
+		Long: `Deploy your site to a Cloud provider.
+
+See https://gohugo.io/hosting-and-deployment/hugo-deploy/ for detailed
+documentation.
+`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return errors.New("build without HUGO_BUILD_TAGS=nodeploy to use this command")
+		},
+	}
+
+	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
+
+	return cc
+}
@@ -61,7 +61,6 @@ func (c *releaseCommandeer) getCommand() *cobra.Command {
 }

 func (c *releaseCommandeer) flagsToConfig(cfg config.Provider) {
-
 }

 func (r *releaseCommandeer) release() error {
@@ -31,6 +31,8 @@ import (
 	"syscall"
 	"time"

+	"github.com/gohugoio/hugo/common/paths"
+
 	"github.com/pkg/errors"

 	"github.com/gohugoio/hugo/livereload"
@@ -185,7 +187,7 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 						// port set explicitly by user -- he/she probably meant it!
 						err = newSystemErrorF("Server startup failed: %s", err)
 					}
-					c.logger.FEEDBACK.Println("port", sc.serverPort, "already in use, attempting to use an available port")
+					c.logger.Println("port", sc.serverPort, "already in use, attempting to use an available port")
 					sp, err := helpers.FindAvailablePort()
 					if err != nil {
 						err = newSystemError("Unable to find alternative port to use:", err)
@@ -228,19 +230,30 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 		}

 		return err
-
 	}

 	if err := memStats(); err != nil {
 		jww.WARN.Println("memstats error:", err)
 	}

-	c, err := initializeConfig(true, true, &sc.hugoBuilderCommon, sc, cfgInit)
+	// silence errors in cobra so we can handle them here
+	cmd.SilenceErrors = true
+
+	c, err := initializeConfig(true, true, true, &sc.hugoBuilderCommon, sc, cfgInit)
 	if err != nil {
+		cmd.PrintErrln("Error:", err.Error())
 		return err
 	}

-	if err := c.serverBuild(); err != nil {
+	err = func() error {
+		defer c.timeTrack(time.Now(), "Built")
+		err := c.serverBuild()
+		if err != nil {
+			cmd.PrintErrln("Error:", err.Error())
+		}
+		return err
+	}()
+	if err != nil {
 		return err
 	}

@@ -261,8 +274,7 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 		for _, group := range watchGroups {
 			jww.FEEDBACK.Printf("Watching for changes in %s\n", group)
 		}
-		watcher, err := c.newWatcher(watchDirs...)
-
+		watcher, err := c.newWatcher(sc.poll, watchDirs...)
 		if err != nil {
 			return err
 		}
@@ -272,13 +284,12 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 	}

 	return c.serve(sc)
-
 }

 func getRootWatchDirsStr(baseDir string, watchDirs []string) string {
 	relWatchDirs := make([]string, len(watchDirs))
 	for i, dir := range watchDirs {
-		relWatchDirs[i], _ = helpers.GetRelativePath(dir, baseDir)
+		relWatchDirs[i], _ = paths.GetRelativePath(dir, baseDir)
 	}

 	return strings.Join(helpers.UniqueStringsSorted(helpers.ExtractRootPaths(relWatchDirs)), ",")
@@ -301,7 +312,6 @@ func (f *fileServer) rewriteRequest(r *http.Request, toPath string) *http.Reques
 	r2.Header.Set("X-Rewrite-Original-URI", r.URL.RequestURI())

 	return r2
-
 }

 func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, error) {
@@ -350,14 +360,16 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, erro
 					w.WriteHeader(500)
 					r, err := f.errorTemplate(err)
 					if err != nil {
-						f.c.logger.ERROR.Println(err)
+						f.c.logger.Errorln(err)
 					}

 					port = 1313
 					if !f.c.paused {
 						port = f.c.Cfg.GetInt("liveReloadPort")
 					}
-					fmt.Fprint(w, injectLiveReloadScript(r, port))
+					lr := *u
+					lr.Host = fmt.Sprintf("%s:%d", lr.Hostname(), port)
+					fmt.Fprint(w, injectLiveReloadScript(r, lr))

 					return
 				}
@@ -391,7 +403,6 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, erro
 						} else {
 							doRedirect = false
 						}
-
 					}
 				}

@@ -411,7 +422,6 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, erro
 			}

 			if f.c.fastRenderMode && f.c.buildErr == nil {
-
 				if 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.
@@ -451,8 +461,8 @@ var logErrorRe = regexp.MustCompile(`(?s)ERROR \d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{
 func removeErrorPrefixFromLog(content string) string {
 	return logErrorRe.ReplaceAllLiteralString(content, "")
 }
-func (c *commandeer) serve(s *serverCmd) error {

+func (c *commandeer) serve(s *serverCmd) error {
 	isMultiHost := c.hugo().IsMultihost()

 	var (
@@ -494,21 +504,26 @@ func (c *commandeer) serve(s *serverCmd) error {
 		livereload.Initialize()
 	}

-	var sigs = make(chan os.Signal, 1)
+	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

 	for i := range baseURLs {
 		mu, serverURL, endpoint, err := srv.createEndpoint(i)

 		if doLiveReload {
-			mu.HandleFunc("/livereload.js", livereload.ServeJS)
-			mu.HandleFunc("/livereload", livereload.Handler)
+			u, err := url.Parse(helpers.SanitizeURL(baseURLs[i]))
+			if err != nil {
+				return err
+			}
+
+			mu.HandleFunc(u.Path+"/livereload.js", livereload.ServeJS)
+			mu.HandleFunc(u.Path+"/livereload", livereload.Handler)
 		}
 		jww.FEEDBACK.Printf("Web Server is available at %s (bind address %s)\n", serverURL, s.serverInterface)
 		go func() {
 			err = http.ListenAndServe(endpoint, mu)
 			if err != nil {
-				c.logger.ERROR.Printf("Error: %s\n", err.Error())
+				c.logger.Errorf("Error: %s\n", err.Error())
 				os.Exit(1)
 			}
 		}()
@@ -525,6 +540,8 @@ func (c *commandeer) serve(s *serverCmd) error {
 		<-sigs
 	}

+	c.hugo().Close()
+
 	return nil
 }

@@ -16,6 +16,7 @@ package commands
 import (
 	"bytes"
 	"io"
+	"net/url"

 	"github.com/gohugoio/hugo/transform"
 	"github.com/gohugoio/hugo/transform/livereloadinject"
@@ -82,9 +83,9 @@ var buildErrorTemplate = `<!doctype html>
 </html>
 `

-func injectLiveReloadScript(src io.Reader, port int) string {
+func injectLiveReloadScript(src io.Reader, baseURL url.URL) string {
 	var b bytes.Buffer
-	chain := transform.Chain{livereloadinject.New(port)}
+	chain := transform.Chain{livereloadinject.New(baseURL)}
 	chain.Apply(&b, src)

 	return b.String()
@@ -22,10 +22,10 @@ import (
 	"testing"
 	"time"

+	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/helpers"

 	qt "github.com/frankban/quicktest"
-	"github.com/spf13/viper"
 )

 func TestServer(t *testing.T) {
@@ -73,7 +73,6 @@ func TestServer(t *testing.T) {

 	// Stop the server.
 	stop <- true
-
 }

 func TestFixURL(t *testing.T) {
@@ -102,7 +101,7 @@ func TestFixURL(t *testing.T) {
 		t.Run(test.TestName, func(t *testing.T) {
 			b := newCommandsBuilder()
 			s := b.newServerCmd()
-			v := viper.New()
+			v := config.New()
 			baseURL := test.CLIBaseURL
 			v.Set("baseURL", test.CfgBaseURL)
 			s.serverAppend = test.AppendPort
@@ -127,7 +126,6 @@ ERROR 2018/10/07 13:11:12 Rebuild failed: logged 1 error(s)
 	withoutError := removeErrorPrefixFromLog(content)

 	c.Assert(strings.Contains(withoutError, "ERROR"), qt.Equals, false)
-
 }

 func isWindowsCI() bool {
@@ -58,7 +58,7 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 		syncer.DestFs = c.Fs.Destination

 		// prevent spamming the log on changes
-		logger := helpers.NewDistinctFeedbackLogger()
+		logger := helpers.NewDistinctErrorLogger()

 		for _, ev := range staticEvents {
 			// Due to our approach of layering both directories and the content's rendered output
@@ -79,9 +79,9 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {

 			fromPath := ev.Name

-			relPath := sourceFs.MakePathRelative(fromPath)
+			relPath, found := sourceFs.MakePathRelative(fromPath)

-			if relPath == "" {
+			if !found {
 				// Not member of this virtual host.
 				continue
 			}
@@ -107,10 +107,10 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 					logger.Println("Syncing", relPath, "to", publishDir)

 					if err := syncer.Sync(filepath.Join(publishDir, relPath), relPath); err != nil {
-						c.logger.ERROR.Println(err)
+						c.logger.Errorln(err)
 					}
 				} else {
-					c.logger.ERROR.Println(err)
+					c.logger.Errorln(err)
 				}

 				continue
@@ -119,7 +119,7 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 			// For all other event operations Hugo will sync static.
 			logger.Println("Syncing", relPath, "to", publishDir)
 			if err := syncer.Sync(filepath.Join(publishDir, relPath), relPath); err != nil {
-				c.logger.ERROR.Println(err)
+				c.logger.Errorln(err)
 			}
 		}

@@ -128,5 +128,4 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {

 	_, err := c.doWithPublishDirs(syncFn)
 	return err
-
 }
@@ -51,7 +51,6 @@ func Append(to interface{}, from ...interface{}) (interface{}, error) {
 				} else if !fromt.AssignableTo(tot) {
 					// Fall back to a []interface{} slice.
 					return appendToInterfaceSliceFromValues(tov, fromv)
-
 				}
 			}
 		}
@@ -36,28 +36,44 @@ func TestAppend(t *testing.T) {
 		{nil, []interface{}{"a", "b"}, []string{"a", "b"}},
 		{nil, []interface{}{nil}, []interface{}{nil}},
 		{[]interface{}{}, []interface{}{[]string{"c", "d", "e"}}, []string{"c", "d", "e"}},
-		{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
+		{
+			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
 			[]interface{}{&tstSlicer{"c"}},
-			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}}},
-		{&tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
+			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}},
+		},
+		{
+			&tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
 			[]interface{}{&tstSlicer{"c"}},
-			tstSlicers{&tstSlicer{"a"},
+			tstSlicers{
+				&tstSlicer{"a"},
 				&tstSlicer{"b"},
-				&tstSlicer{"c"}}},
-		{testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}},
+				&tstSlicer{"c"},
+			},
+		},
+		{
+			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}},
 			[]interface{}{&tstSlicerIn1{"c"}},
-			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}, &tstSlicerIn1{"c"}}},
+			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}, &tstSlicerIn1{"c"}},
+		},
 		//https://github.com/gohugoio/hugo/issues/5361
-		{[]string{"a", "b"}, []interface{}{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
-			[]interface{}{"a", "b", &tstSlicer{"a"}, &tstSlicer{"b"}}},
-		{[]string{"a", "b"}, []interface{}{&tstSlicer{"a"}},
-			[]interface{}{"a", "b", &tstSlicer{"a"}}},
+		{
+			[]string{"a", "b"},
+			[]interface{}{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
+			[]interface{}{"a", "b", &tstSlicer{"a"}, &tstSlicer{"b"}},
+		},
+		{
+			[]string{"a", "b"},
+			[]interface{}{&tstSlicer{"a"}},
+			[]interface{}{"a", "b", &tstSlicer{"a"}},
+		},
 		// Errors
 		{"", []interface{}{[]string{"a", "b"}}, false},
 		// No string concatenation.
-		{"ab",
+		{
+			"ab",
 			[]interface{}{"c"},
-			false},
+			false,
+		},
 	} {

 		result, err := Append(test.start, test.addend...)
@@ -71,5 +87,4 @@ func TestAppend(t *testing.T) {
 		c.Assert(err, qt.IsNil)
 		c.Assert(result, qt.DeepEquals, test.expected)
 	}
-
 }
@@ -64,3 +64,13 @@ func Slice(args ...interface{}) interface{} {
 	}
 	return slice.Interface()
 }
+
+// StringSliceToInterfaceSlice converts ss to []interface{}.
+func StringSliceToInterfaceSlice(ss []string) []interface{} {
+	result := make([]interface{}, len(ss))
+	for i, s := range ss {
+		result[i] = s
+	}
+	return result
+
+}
@@ -20,11 +20,13 @@ import (
 	qt "github.com/frankban/quicktest"
 )

-var _ Slicer = (*tstSlicer)(nil)
-var _ Slicer = (*tstSlicerIn1)(nil)
-var _ Slicer = (*tstSlicerIn2)(nil)
-var _ testSlicerInterface = (*tstSlicerIn1)(nil)
-var _ testSlicerInterface = (*tstSlicerIn1)(nil)
+var (
+	_ Slicer              = (*tstSlicer)(nil)
+	_ Slicer              = (*tstSlicerIn1)(nil)
+	_ Slicer              = (*tstSlicerIn2)(nil)
+	_ testSlicerInterface = (*tstSlicerIn1)(nil)
+	_ testSlicerInterface = (*tstSlicerIn1)(nil)
+)

 type testSlicerInterface interface {
 	Name() string
@@ -54,7 +56,6 @@ func (p *tstSlicerIn1) Slice(in interface{}) (interface{}, error) {
 		default:
 			return nil, errors.New("invalid type")
 		}
-
 	}
 	return result, nil
 }
@@ -120,5 +121,4 @@ func TestSlice(t *testing.T) {

 		c.Assert(test.expected, qt.DeepEquals, result, errMsg)
 	}
-
 }
@@ -18,4 +18,8 @@ package constants
 const (
 	ErrIDAmbigousDisableKindTaxonomy = "error-disable-taxonomy"
 	ErrIDAmbigousOutputKindTaxonomy  = "error-output-taxonomy"
+
+	// IDs for remote errors in tpl/data.
+	ErrRemoteGetJSON = "error-remote-getjson"
+	ErrRemoteGetCSV  = "error-remote-getcsv"
 )
@@ -100,6 +100,17 @@ func WithFileContextForFile(e error, realFilename, filename string, fs afero.Fs,
 	return WithFileContext(e, realFilename, f, matcher)
 }

+// WithFileContextForFileDefault tries to add file context using the default line matcher.
+func WithFileContextForFileDefault(err error, filename string, fs afero.Fs) error {
+	err, _ = WithFileContextForFile(
+		err,
+		filename,
+		filename,
+		fs,
+		SimpleLineMatcher)
+	return err
+}
+
 // WithFileContextForFile will try to add a file context with lines matching the given matcher.
 // If no match could be found, the original error is returned with false as the second return value.
 func WithFileContext(e error, realFilename string, r io.Reader, matcher LineMatcherFn) (error, bool) {
@@ -125,5 +125,4 @@ E`, offsetMatcher)
 	c.Assert(location.Lines, qt.DeepEquals, []string{"A", "B", "C", "D"})
 	c.Assert(location.Position().LineNumber, qt.Equals, 2)
 	c.Assert(location.LinesPos, qt.Equals, 1)
-
 }
@@ -88,3 +88,10 @@ func GetGID() uint64 {
 // We will, at least to begin with, make some Hugo features (SCSS with libsass) optional,
 // and this error is used to signal those situations.
 var ErrFeatureNotAvailable = errors.New("this feature is not available in your current Hugo version, see https://goo.gl/YMrWcn for more information")
+
+// Must panics if err != nil.
+func Must(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
@@ -21,9 +21,7 @@ import (
 	"github.com/pkg/errors"
 )

-var (
-	_ causer = (*fileError)(nil)
-)
+var _ causer = (*fileError)(nil)

 // FileError represents an error when handling a file: Parsing a config file,
 // execute a template etc.
@@ -36,7 +36,6 @@ func TestToLineNumberError(t *testing.T) {
 		{errors.New(`template: _default/single.html:4:15: executing "_default/single.html" at <.Titles>: can't evaluate field Titles in type *hugolib.PageOutput`), 0, 4, 15},
 		{errors.New("parse failed: template: _default/bundle-resource-meta.html:11: unexpected in operand"), 0, 11, 1},
 		{errors.New(`failed:: template: _default/bundle-resource-meta.html:2:7: executing "main" at <.Titles>`), 0, 2, 7},
-		{errors.New("error in front matter: Near line 32 (last key parsed 'title')"), 0, 32, 1},
 		{errors.New(`failed to load translations: (6, 7): was expecting token =, but got "g" instead`), 0, 6, 7},
 	} {

@@ -52,5 +51,4 @@ func TestToLineNumberError(t *testing.T) {
 		c.Assert(pos.ColumnNumber, qt.Equals, test.columnNumber, errMsg)
 		c.Assert(errors.Cause(got), qt.Not(qt.IsNil))
 	}
-
 }
@@ -16,6 +16,10 @@ package herrors
 import (
 	"regexp"
 	"strconv"
+
+	"github.com/pkg/errors"
+
+	"github.com/pelletier/go-toml/v2"
 )

 var lineNumberExtractors = []lineNumberExtractor{
@@ -24,8 +28,7 @@ var lineNumberExtractors = []lineNumberExtractor{
 	newLineNumberErrHandlerFromRegexp(".*:(\\d+):"),

 	// TOML parse errors
-	newLineNumberErrHandlerFromRegexp(".*Near line (\\d+)(\\s.*)"),
-
+	tomlLineNumberExtractor,
 	// YAML parse errors
 	newLineNumberErrHandlerFromRegexp("line (\\d+):"),

@@ -35,6 +38,14 @@ var lineNumberExtractors = []lineNumberExtractor{

 type lineNumberExtractor func(e error) (int, int)

+var tomlLineNumberExtractor = func(e error) (int, int) {
+	e = errors.Cause(e)
+	if terr, ok := e.(*toml.DecodeError); ok {
+		return terr.Position()
+	}
+	return -1, -1
+}
+
 func newLineNumberErrHandlerFromRegexp(expression string) lineNumberExtractor {
 	re := regexp.MustCompile(expression)
 	return extractLineNo(re)
@@ -0,0 +1,276 @@
+// Copyright 2020 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package hexec
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"regexp"
+	"strings"
+
+	"os"
+	"os/exec"
+
+	"github.com/cli/safeexec"
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/config/security"
+)
+
+var WithDir = func(dir string) func(c *commandeer) {
+	return func(c *commandeer) {
+		c.dir = dir
+	}
+}
+
+var WithContext = func(ctx context.Context) func(c *commandeer) {
+	return func(c *commandeer) {
+		c.ctx = ctx
+	}
+}
+
+var WithStdout = func(w io.Writer) func(c *commandeer) {
+	return func(c *commandeer) {
+		c.stdout = w
+	}
+}
+
+var WithStderr = func(w io.Writer) func(c *commandeer) {
+	return func(c *commandeer) {
+		c.stderr = w
+	}
+}
+
+var WithStdin = func(r io.Reader) func(c *commandeer) {
+	return func(c *commandeer) {
+		c.stdin = r
+	}
+}
+
+var WithEnviron = func(env []string) func(c *commandeer) {
+	return func(c *commandeer) {
+		setOrAppend := func(s string) {
+			k1, _ := config.SplitEnvVar(s)
+			var found bool
+			for i, v := range c.env {
+				k2, _ := config.SplitEnvVar(v)
+				if k1 == k2 {
+					found = true
+					c.env[i] = s
+				}
+			}
+
+			if !found {
+				c.env = append(c.env, s)
+			}
+		}
+
+		for _, s := range env {
+			setOrAppend(s)
+		}
+	}
+}
+
+// New creates a new Exec using the provided security config.
+func New(cfg security.Config) *Exec {
+	var baseEnviron []string
+	for _, v := range os.Environ() {
+		k, _ := config.SplitEnvVar(v)
+		if cfg.Exec.OsEnv.Accept(k) {
+			baseEnviron = append(baseEnviron, v)
+		}
+	}
+
+	return &Exec{
+		sc:          cfg,
+		baseEnviron: baseEnviron,
+	}
+}
+
+// IsNotFound reports whether this is an error about a binary not found.
+func IsNotFound(err error) bool {
+	var notFoundErr *NotFoundError
+	return errors.As(err, &notFoundErr)
+}
+
+// SafeCommand is a wrapper around os/exec Command which uses a LookPath
+// implementation that does not search in current directory before looking in PATH.
+// See https://github.com/cli/safeexec and the linked issues.
+func SafeCommand(name string, arg ...string) (*exec.Cmd, error) {
+	bin, err := safeexec.LookPath(name)
+	if err != nil {
+		return nil, err
+	}
+
+	return exec.Command(bin, arg...), nil
+}
+
+// Exec encorces a security policy for commands run via os/exec.
+type Exec struct {
+	sc security.Config
+
+	// os.Environ filtered by the Exec.OsEnviron whitelist filter.
+	baseEnviron []string
+}
+
+// New will fail if name is not allowed according to the configured security policy.
+// Else a configured Runner will be returned ready to be Run.
+func (e *Exec) New(name string, arg ...interface{}) (Runner, error) {
+	if err := e.sc.CheckAllowedExec(name); err != nil {
+		return nil, err
+	}
+
+	env := make([]string, len(e.baseEnviron))
+	copy(env, e.baseEnviron)
+
+	cm := &commandeer{
+		name: name,
+		env:  env,
+	}
+
+	return cm.command(arg...)
+
+}
+
+// Npx is a convenience method to create a Runner running npx --no-install <name> <args.
+func (e *Exec) Npx(name string, arg ...interface{}) (Runner, error) {
+	arg = append(arg[:0], append([]interface{}{"--no-install", name}, arg[0:]...)...)
+	return e.New("npx", arg...)
+}
+
+// Sec returns the security policies this Exec is configured with.
+func (e *Exec) Sec() security.Config {
+	return e.sc
+}
+
+type NotFoundError struct {
+	name string
+}
+
+func (e *NotFoundError) Error() string {
+	return fmt.Sprintf("binary with name %q not found", e.name)
+}
+
+// Runner wraps a *os.Cmd.
+type Runner interface {
+	Run() error
+	StdinPipe() (io.WriteCloser, error)
+}
+
+type cmdWrapper struct {
+	name string
+	c    *exec.Cmd
+
+	outerr *bytes.Buffer
+}
+
+var notFoundRe = regexp.MustCompile(`(?s)not found:|could not determine executable`)
+
+func (c *cmdWrapper) Run() error {
+	err := c.c.Run()
+	if err == nil {
+		return nil
+	}
+	if notFoundRe.MatchString(c.outerr.String()) {
+		return &NotFoundError{name: c.name}
+	}
+	return fmt.Errorf("failed to execute binary %q with args %v: %s", c.name, c.c.Args[1:], c.outerr.String())
+}
+
+func (c *cmdWrapper) StdinPipe() (io.WriteCloser, error) {
+	return c.c.StdinPipe()
+}
+
+type commandeer struct {
+	stdout io.Writer
+	stderr io.Writer
+	stdin  io.Reader
+	dir    string
+	ctx    context.Context
+
+	name string
+	env  []string
+}
+
+func (c *commandeer) command(arg ...interface{}) (*cmdWrapper, error) {
+	if c == nil {
+		return nil, nil
+	}
+
+	var args []string
+	for _, a := range arg {
+		switch v := a.(type) {
+		case string:
+			args = append(args, v)
+		case func(*commandeer):
+			v(c)
+		default:
+			return nil, fmt.Errorf("invalid argument to command: %T", a)
+		}
+	}
+
+	bin, err := safeexec.LookPath(c.name)
+	if err != nil {
+		return nil, &NotFoundError{
+			name: c.name,
+		}
+	}
+
+	outerr := &bytes.Buffer{}
+	if c.stderr == nil {
+		c.stderr = outerr
+	} else {
+		c.stderr = io.MultiWriter(c.stderr, outerr)
+	}
+
+	var cmd *exec.Cmd
+
+	if c.ctx != nil {
+		cmd = exec.CommandContext(c.ctx, bin, args...)
+	} else {
+		cmd = exec.Command(bin, args...)
+	}
+
+	cmd.Stdin = c.stdin
+	cmd.Stderr = c.stderr
+	cmd.Stdout = c.stdout
+	cmd.Env = c.env
+	cmd.Dir = c.dir
+
+	return &cmdWrapper{outerr: outerr, c: cmd, name: c.name}, nil
+}
+
+// InPath reports whether binaryName is in $PATH.
+func InPath(binaryName string) bool {
+	if strings.Contains(binaryName, "/") {
+		panic("binary name should not contain any slash")
+	}
+	_, err := safeexec.LookPath(binaryName)
+	return err == nil
+}
+
+// LookPath finds the path to binaryName in $PATH.
+// Returns "" if not found.
+func LookPath(binaryName string) string {
+	if strings.Contains(binaryName, "/") {
+		panic("binary name should not contain any slash")
+	}
+	s, err := safeexec.LookPath(binaryName)
+	if err != nil {
+		return ""
+	}
+	return s
+}
@@ -23,7 +23,7 @@ import (
 )

 // TODO(bep) replace the private versions in /tpl with these.
-// IsInt returns whether the given kind is a number.
+// IsNumber returns whether the given kind is a number.
 func IsNumber(kind reflect.Kind) bool {
 	return IsInt(kind) || IsUint(kind) || IsFloat(kind)
 }
@@ -67,7 +67,6 @@ func IsTruthful(in interface{}) bool {
 	default:
 		return IsTruthfulValue(reflect.ValueOf(in))
 	}
-
 }

 var zeroType = reflect.TypeOf((*types.Zeroer)(nil)).Elem()
@@ -0,0 +1,150 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package htime
+
+import (
+	"strings"
+	"time"
+
+	"github.com/spf13/cast"
+
+	toml "github.com/pelletier/go-toml/v2"
+
+	"github.com/gohugoio/locales"
+)
+
+var (
+	longDayNames = []string{
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday",
+	}
+
+	shortDayNames = []string{
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat",
+	}
+
+	shortMonthNames = []string{
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec",
+	}
+
+	longMonthNames = []string{
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December",
+	}
+)
+
+func NewTimeFormatter(ltr locales.Translator) TimeFormatter {
+	if ltr == nil {
+		panic("must provide a locales.Translator")
+	}
+	return TimeFormatter{
+		ltr: ltr,
+	}
+}
+
+// TimeFormatter is locale aware.
+type TimeFormatter struct {
+	ltr locales.Translator
+}
+
+func (f TimeFormatter) Format(t time.Time, layout string) string {
+	if layout == "" {
+		return ""
+	}
+
+	if layout[0] == ':' {
+		// It may be one of Hugo's custom layouts.
+		switch strings.ToLower(layout[1:]) {
+		case "date_full":
+			return f.ltr.FmtDateFull(t)
+		case "date_long":
+			return f.ltr.FmtDateLong(t)
+		case "date_medium":
+			return f.ltr.FmtDateMedium(t)
+		case "date_short":
+			return f.ltr.FmtDateShort(t)
+		case "time_full":
+			return f.ltr.FmtTimeFull(t)
+		case "time_long":
+			return f.ltr.FmtTimeLong(t)
+		case "time_medium":
+			return f.ltr.FmtTimeMedium(t)
+		case "time_short":
+			return f.ltr.FmtTimeShort(t)
+		}
+	}
+
+	s := t.Format(layout)
+
+	monthIdx := t.Month() - 1 // Month() starts at 1.
+	dayIdx := t.Weekday()
+
+	s = strings.ReplaceAll(s, longMonthNames[monthIdx], f.ltr.MonthWide(t.Month()))
+	if !strings.Contains(s, f.ltr.MonthWide(t.Month())) {
+		s = strings.ReplaceAll(s, shortMonthNames[monthIdx], f.ltr.MonthAbbreviated(t.Month()))
+	}
+	s = strings.ReplaceAll(s, longDayNames[dayIdx], f.ltr.WeekdayWide(t.Weekday()))
+	if !strings.Contains(s, f.ltr.WeekdayWide(t.Weekday())) {
+		s = strings.ReplaceAll(s, shortDayNames[dayIdx], f.ltr.WeekdayAbbreviated(t.Weekday()))
+	}
+
+	return s
+}
+
+func ToTimeInDefaultLocationE(i interface{}, location *time.Location) (tim time.Time, err error) {
+	switch vv := i.(type) {
+	case toml.LocalDate:
+		return vv.AsTime(location), nil
+	case toml.LocalDateTime:
+		return vv.AsTime(location), nil
+	// issue #8895
+	// datetimes parsed by `go-toml` have empty zone name
+	// convert back them into string and use `cast`
+	case time.Time:
+		i = vv.Format(time.RFC3339)
+	}
+	return cast.ToTimeInDefaultLocationE(i, location)
+}
@@ -0,0 +1,148 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package htime
+
+import (
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+	translators "github.com/gohugoio/localescompressed"
+)
+
+func TestTimeFormatter(t *testing.T) {
+	c := qt.New(t)
+
+	june06, _ := time.Parse("2006-Jan-02", "2018-Jun-06")
+	june06 = june06.Add(7777 * time.Second)
+
+	jan06, _ := time.Parse("2006-Jan-02", "2018-Jan-06")
+	jan06 = jan06.Add(32 * time.Second)
+
+	mondayNovemberFirst, _ := time.Parse("2006-Jan-02", "2021-11-01")
+	mondayNovemberFirst = mondayNovemberFirst.Add(33 * time.Second)
+
+	c.Run("Norsk nynorsk", func(c *qt.C) {
+		f := NewTimeFormatter(translators.GetTranslator("nn"))
+
+		c.Assert(f.Format(june06, "Monday Jan 2 2006"), qt.Equals, "onsdag juni 6 2018")
+		c.Assert(f.Format(june06, "Mon January 2 2006"), qt.Equals, "on. juni 6 2018")
+		c.Assert(f.Format(june06, "Mon Mon"), qt.Equals, "on. on.")
+	})
+
+	c.Run("Custom layouts Norsk nynorsk", func(c *qt.C) {
+		f := NewTimeFormatter(translators.GetTranslator("nn"))
+
+		c.Assert(f.Format(june06, ":date_full"), qt.Equals, "onsdag 6. juni 2018")
+		c.Assert(f.Format(june06, ":date_long"), qt.Equals, "6. juni 2018")
+		c.Assert(f.Format(june06, ":date_medium"), qt.Equals, "6. juni 2018")
+		c.Assert(f.Format(june06, ":date_short"), qt.Equals, "06.06.2018")
+
+		c.Assert(f.Format(june06, ":time_full"), qt.Equals, "kl. 02:09:37 UTC")
+		c.Assert(f.Format(june06, ":time_long"), qt.Equals, "02:09:37 UTC")
+		c.Assert(f.Format(june06, ":time_medium"), qt.Equals, "02:09:37")
+		c.Assert(f.Format(june06, ":time_short"), qt.Equals, "02:09")
+
+	})
+
+	c.Run("Custom layouts English", func(c *qt.C) {
+		f := NewTimeFormatter(translators.GetTranslator("en"))
+
+		c.Assert(f.Format(june06, ":date_full"), qt.Equals, "Wednesday, June 6, 2018")
+		c.Assert(f.Format(june06, ":date_long"), qt.Equals, "June 6, 2018")
+		c.Assert(f.Format(june06, ":date_medium"), qt.Equals, "Jun 6, 2018")
+		c.Assert(f.Format(june06, ":date_short"), qt.Equals, "6/6/18")
+
+		c.Assert(f.Format(june06, ":time_full"), qt.Equals, "2:09:37 am UTC")
+		c.Assert(f.Format(june06, ":time_long"), qt.Equals, "2:09:37 am UTC")
+		c.Assert(f.Format(june06, ":time_medium"), qt.Equals, "2:09:37 am")
+		c.Assert(f.Format(june06, ":time_short"), qt.Equals, "2:09 am")
+
+	})
+
+	c.Run("English", func(c *qt.C) {
+		f := NewTimeFormatter(translators.GetTranslator("en"))
+
+		c.Assert(f.Format(june06, "Monday Jan 2 2006"), qt.Equals, "Wednesday Jun 6 2018")
+		c.Assert(f.Format(june06, "Mon January 2 2006"), qt.Equals, "Wed June 6 2018")
+		c.Assert(f.Format(june06, "Mon Mon"), qt.Equals, "Wed Wed")
+	})
+
+	c.Run("Weekdays German", func(c *qt.C) {
+		tr := translators.GetTranslator("de")
+		f := NewTimeFormatter(tr)
+
+		// Issue #9107
+		for i, weekDayWideGerman := range []string{"Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"} {
+			date := mondayNovemberFirst.Add(time.Duration(i*24) * time.Hour)
+			c.Assert(tr.WeekdayWide(date.Weekday()), qt.Equals, weekDayWideGerman)
+			c.Assert(f.Format(date, "Monday"), qt.Equals, weekDayWideGerman)
+		}
+
+		for i, weekDayAbbreviatedGerman := range []string{"Mo.", "Di.", "Mi.", "Do.", "Fr.", "Sa.", "So."} {
+			date := mondayNovemberFirst.Add(time.Duration(i*24) * time.Hour)
+			c.Assert(tr.WeekdayAbbreviated(date.Weekday()), qt.Equals, weekDayAbbreviatedGerman)
+			c.Assert(f.Format(date, "Mon"), qt.Equals, weekDayAbbreviatedGerman)
+		}
+	})
+
+	c.Run("Months German", func(c *qt.C) {
+		tr := translators.GetTranslator("de")
+		f := NewTimeFormatter(tr)
+
+		// Issue #9107
+		for i, monthWideNorway := range []string{"Januar", "Februar", "März", "April", "Mai", "Juni", "Juli"} {
+			date := jan06.Add(time.Duration(i*24*31) * time.Hour)
+			c.Assert(tr.MonthWide(date.Month()), qt.Equals, monthWideNorway)
+			c.Assert(f.Format(date, "January"), qt.Equals, monthWideNorway)
+		}
+
+	})
+
+}
+
+func BenchmarkTimeFormatter(b *testing.B) {
+	june06, _ := time.Parse("2006-Jan-02", "2018-Jun-06")
+
+	b.Run("Native", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			got := june06.Format("Monday Jan 2 2006")
+			if got != "Wednesday Jun 6 2018" {
+				b.Fatalf("invalid format, got %q", got)
+			}
+		}
+	})
+
+	b.Run("Localized", func(b *testing.B) {
+		f := NewTimeFormatter(translators.GetTranslator("nn"))
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			got := f.Format(june06, "Monday Jan 2 2006")
+			if got != "onsdag juni 6 2018" {
+				b.Fatalf("invalid format, got %q", got)
+			}
+		}
+	})
+
+	b.Run("Localized Custom", func(b *testing.B) {
+		f := NewTimeFormatter(translators.GetTranslator("nn"))
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			got := f.Format(june06, ":date_medium")
+			if got != "6. juni 2018" {
+				b.Fatalf("invalid format, got %q", got)
+			}
+		}
+	})
+}
@@ -31,8 +31,13 @@ type ReadSeekCloser interface {
 	io.Closer
 }

+// ReadSeekCloserProvider provides a ReadSeekCloser.
+type ReadSeekCloserProvider interface {
+	ReadSeekCloser() (ReadSeekCloser, error)
+}
+
 // ReadSeekerNoOpCloser implements ReadSeekCloser by doing nothing in Close.
-// TODO(bep) rename this and simila to ReadSeekerNopCloser, naming used in stdlib, which kind of makes sense.
+// TODO(bep) rename this and similar to ReadSeekerNopCloser, naming used in stdlib, which kind of makes sense.
 type ReadSeekerNoOpCloser struct {
 	ReadSeeker
 }
@@ -18,6 +18,8 @@ import (
 	"html/template"
 	"os"
 	"path/filepath"
+	"runtime/debug"
+	"sort"
 	"strings"

 	"github.com/gohugoio/hugo/hugofs/files"
@@ -34,12 +36,15 @@ const (
 )

 var (
-	// commitHash contains the current Git revision. Use make to build to make
-	// sure this gets set.
+	// commitHash contains the current Git revision.
+	// Use mage to build to make sure this gets set.
 	commitHash string

 	// buildDate contains the date of the current build.
 	buildDate string
+
+	// vendorInfo contains vendor notes about the current build.
+	vendorInfo string
 )

 // Info contains information about the current Hugo environment
@@ -68,6 +73,10 @@ func (i Info) IsProduction() bool {
 	return i.Environment == EnvironmentProduction
 }

+func (i Info) IsExtended() bool {
+	return IsExtended
+}
+
 // NewInfo creates a new Hugo Info object.
 func NewInfo(environment string) Info {
 	if environment == "" {
@@ -80,8 +89,10 @@ func NewInfo(environment string) Info {
 	}
 }

+// GetExecEnviron creates and gets the common os/exec environment used in the
+// external programs we interact with via os/exec, e.g. postcss.
 func GetExecEnviron(workDir string, cfg config.Provider, fs afero.Fs) []string {
-	env := os.Environ()
+	var env []string
 	nodepath := filepath.Join(workDir, "node_modules")
 	if np := os.Getenv("NODE_PATH"); np != "" {
 		nodepath = workDir + string(os.PathListSeparator) + np
@@ -89,14 +100,59 @@ func GetExecEnviron(workDir string, cfg config.Provider, fs afero.Fs) []string {
 	config.SetEnvVars(&env, "NODE_PATH", nodepath)
 	config.SetEnvVars(&env, "PWD", workDir)
 	config.SetEnvVars(&env, "HUGO_ENVIRONMENT", cfg.GetString("environment"))
-	fis, err := afero.ReadDir(fs, files.FolderJSConfig)
-	if err == nil {
-		for _, fi := range fis {
-			key := fmt.Sprintf("HUGO_FILE_%s", strings.ReplaceAll(strings.ToUpper(fi.Name()), ".", "_"))
-			value := fi.(hugofs.FileMetaInfo).Meta().Filename()
-			config.SetEnvVars(&env, key, value)
+
+	if fs != nil {
+		fis, err := afero.ReadDir(fs, files.FolderJSConfig)
+		if err == nil {
+			for _, fi := range fis {
+				key := fmt.Sprintf("HUGO_FILE_%s", strings.ReplaceAll(strings.ToUpper(fi.Name()), ".", "_"))
+				value := fi.(hugofs.FileMetaInfo).Meta().Filename
+				config.SetEnvVars(&env, key, value)
+			}
 		}
 	}

 	return env
 }
+
+// GetDependencyList returns a sorted dependency list on the format package="version".
+// It includes both Go dependencies and (a manually maintained) list of C(++) dependencies.
+func GetDependencyList() []string {
+	var deps []string
+
+	formatDep := func(path, version string) string {
+		return fmt.Sprintf("%s=%q", path, version)
+	}
+
+	if IsExtended {
+		deps = append(
+			deps,
+			// TODO(bep) consider adding a DepsNonGo() method to these upstream projects.
+			formatDep("github.com/sass/libsass", "3.6.5"),
+			formatDep("github.com/webmproject/libwebp", "v1.2.0"),
+		)
+	}
+
+	bi, ok := debug.ReadBuildInfo()
+	if !ok {
+		return deps
+	}
+
+	for _, dep := range bi.Deps {
+		deps = append(deps, formatDep(dep.Path, dep.Version))
+	}
+
+	sort.Strings(deps)
+
+	return deps
+}
+
+// IsRunningAsTest reports whether we are running as a test.
+func IsRunningAsTest() bool {
+	for _, arg := range os.Args {
+		if strings.HasPrefix(arg, "-test") {
+			return true
+		}
+	}
+	return false
+}
@@ -32,8 +32,8 @@ func TestHugoInfo(t *testing.T) {
 	c.Assert(hugoInfo.Environment, qt.Equals, "production")
 	c.Assert(string(hugoInfo.Generator()), qt.Contains, fmt.Sprintf("Hugo %s", hugoInfo.Version()))
 	c.Assert(hugoInfo.IsProduction(), qt.Equals, true)
+	c.Assert(hugoInfo.IsExtended(), qt.Equals, IsExtended)

 	devHugoInfo := NewInfo("development")
 	c.Assert(devHugoInfo.IsProduction(), qt.Equals, false)
-
 }
@@ -16,7 +16,6 @@ package hugo
 import (
 	"fmt"
 	"io"
-
 	"runtime"
 	"strings"

@@ -128,14 +127,15 @@ func (v Version) NextPatchLevel(level int) Version {
 // BuildVersionString creates a version string. This is what you see when
 // running "hugo version".
 func BuildVersionString() string {
-	program := "Hugo Static Site Generator"
+	// program := "Hugo Static Site Generator"
+	program := "hugo"

 	version := "v" + CurrentVersion.String()
 	if commitHash != "" {
 		version += "-" + strings.ToUpper(commitHash)
 	}
 	if IsExtended {
-		version += "/extended"
+		version += "+extended"
 	}

 	osArch := runtime.GOOS + "/" + runtime.GOARCH
@@ -145,8 +145,14 @@ func BuildVersionString() string {
 		date = "unknown"
 	}

-	return fmt.Sprintf("%s %s %s BuildDate: %s", program, version, osArch, date)
+	versionString := fmt.Sprintf("%s %s %s BuildDate=%s",
+		program, version, osArch, date)

+	if vendorInfo != "" {
+		versionString += " VendorInfo=" + vendorInfo
+	}
+
+	return versionString
 }

 func version(version float32, patchVersion int, suffix string) string {
@@ -16,7 +16,7 @@ package hugo
 // CurrentVersion represents the current build version.
 // This should be the only one.
 var CurrentVersion = Version{
-	Number:     0.76,
+	Number:     0.91,
 	PatchLevel: 2,
 	Suffix:     "",
 }
@@ -19,25 +19,31 @@ import (
 )

 // IgnorableLogger is a logger that ignores certain log statements.
-type IgnorableLogger struct {
-	logger     *Logger
+type IgnorableLogger interface {
+	Logger
+	Errorsf(statementID, format string, v ...interface{})
+	Apply(logger Logger) IgnorableLogger
+}
+
+type ignorableLogger struct {
+	Logger
 	statements map[string]bool
 }

 // NewIgnorableLogger wraps the given logger and ignores the log statement IDs given.
-func NewIgnorableLogger(logger *Logger, statements ...string) IgnorableLogger {
+func NewIgnorableLogger(logger Logger, statements ...string) IgnorableLogger {
 	statementsSet := make(map[string]bool)
 	for _, s := range statements {
 		statementsSet[strings.ToLower(s)] = true
-
 	}
-	return IgnorableLogger{
-		logger:     logger,
+	return ignorableLogger{
+		Logger:     logger,
 		statements: statementsSet,
 	}
 }

-func (l IgnorableLogger) Errorf(statementID, format string, v ...interface{}) {
+// Errorsf logs statementID as an ERROR if not configured as ignoreable.
+func (l ignorableLogger) Errorsf(statementID, format string, v ...interface{}) {
 	if l.statements[statementID] {
 		// Ignore.
 		return
@@ -48,5 +54,12 @@ ignoreErrors = [%q]`, statementID)

 	format += ignoreMsg

-	l.logger.ERROR.Printf(format, v...)
+	l.Errorf(format, v...)
+}
+
+func (l ignorableLogger) Apply(logger Logger) IgnorableLogger {
+	return ignorableLogger{
+		Logger:     logger,
+		statements: l.statements,
+	}
 }
@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2020 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -29,10 +29,8 @@ import (
 	jww "github.com/spf13/jwalterweatherman"
 )

-var (
-	// Counts ERROR logs to the global jww logger.
-	GlobalErrorCounter *jww.Counter
-)
+// Counts ERROR logs to the global jww logger.
+var GlobalErrorCounter *jww.Counter

 func init() {
 	GlobalErrorCounter = &jww.Counter{}
@@ -56,39 +54,132 @@ func (w prefixWriter) Write(p []byte) (n int, err error) {
 	return len(p), nil
 }

-// Logger wraps a *loggers.Logger and some other related logging state.
-type Logger struct {
+type Logger interface {
+	Printf(format string, v ...interface{})
+	Println(v ...interface{})
+	PrintTimerIfDelayed(start time.Time, name string)
+	Debug() *log.Logger
+	Debugf(format string, v ...interface{})
+	Debugln(v ...interface{})
+	Info() *log.Logger
+	Infof(format string, v ...interface{})
+	Infoln(v ...interface{})
+	Warn() *log.Logger
+	Warnf(format string, v ...interface{})
+	Warnln(v ...interface{})
+	Error() *log.Logger
+	Errorf(format string, v ...interface{})
+	Errorln(v ...interface{})
+	Errors() string
+
+	Out() io.Writer
+
+	Reset()
+
+	// Used in tests.
+	LogCounters() *LogCounters
+}
+
+type LogCounters struct {
+	ErrorCounter *jww.Counter
+	WarnCounter  *jww.Counter
+}
+
+type logger struct {
 	*jww.Notepad

 	// The writer that represents stdout.
 	// Will be ioutil.Discard when in quiet mode.
-	Out io.Writer
+	out io.Writer

-	ErrorCounter *jww.Counter
-	WarnCounter  *jww.Counter
+	logCounters *LogCounters

 	// This is only set in server mode.
 	errors *bytes.Buffer
 }

+func (l *logger) Printf(format string, v ...interface{}) {
+	l.FEEDBACK.Printf(format, v...)
+}
+
+func (l *logger) Println(v ...interface{}) {
+	l.FEEDBACK.Println(v...)
+}
+
+func (l *logger) Debug() *log.Logger {
+	return l.DEBUG
+}
+
+func (l *logger) Debugf(format string, v ...interface{}) {
+	l.DEBUG.Printf(format, v...)
+}
+
+func (l *logger) Debugln(v ...interface{}) {
+	l.DEBUG.Println(v...)
+}
+
+func (l *logger) Infof(format string, v ...interface{}) {
+	l.INFO.Printf(format, v...)
+}
+
+func (l *logger) Infoln(v ...interface{}) {
+	l.INFO.Println(v...)
+}
+
+func (l *logger) Info() *log.Logger {
+	return l.INFO
+}
+
+func (l *logger) Warnf(format string, v ...interface{}) {
+	l.WARN.Printf(format, v...)
+}
+
+func (l *logger) Warnln(v ...interface{}) {
+	l.WARN.Println(v...)
+}
+
+func (l *logger) Warn() *log.Logger {
+	return l.WARN
+}
+
+func (l *logger) Errorf(format string, v ...interface{}) {
+	l.ERROR.Printf(format, v...)
+}
+
+func (l *logger) Errorln(v ...interface{}) {
+	l.ERROR.Println(v...)
+}
+
+func (l *logger) Error() *log.Logger {
+	return l.ERROR
+}
+
+func (l *logger) LogCounters() *LogCounters {
+	return l.logCounters
+}
+
+func (l *logger) Out() io.Writer {
+	return l.out
+}
+
 // PrintTimerIfDelayed prints a time statement to the FEEDBACK logger
 // if considerable time is spent.
-func (l *Logger) PrintTimerIfDelayed(start time.Time, name string) {
+func (l *logger) PrintTimerIfDelayed(start time.Time, name string) {
 	elapsed := time.Since(start)
 	milli := int(1000 * elapsed.Seconds())
 	if milli < 500 {
 		return
 	}
-	l.FEEDBACK.Printf("%s in %v ms", name, milli)
+	l.Printf("%s in %v ms", name, milli)
 }

-func (l *Logger) PrintTimer(start time.Time, name string) {
+func (l *logger) PrintTimer(start time.Time, name string) {
 	elapsed := time.Since(start)
 	milli := int(1000 * elapsed.Seconds())
-	l.FEEDBACK.Printf("%s in %v ms", name, milli)
+	l.Printf("%s in %v ms", name, milli)
 }

-func (l *Logger) Errors() string {
+func (l *logger) Errors() string {
 	if l.errors == nil {
 		return ""
 	}
@@ -96,45 +187,45 @@ func (l *Logger) Errors() string {
 }

 // Reset resets the logger's internal state.
-func (l *Logger) Reset() {
-	l.ErrorCounter.Reset()
+func (l *logger) Reset() {
+	l.logCounters.ErrorCounter.Reset()
 	if l.errors != nil {
 		l.errors.Reset()
 	}
 }

 //  NewLogger creates a new Logger for the given thresholds
-func NewLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) *Logger {
+func NewLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) Logger {
 	return newLogger(stdoutThreshold, logThreshold, outHandle, logHandle, saveErrors)
 }

 // NewDebugLogger is a convenience function to create a debug logger.
-func NewDebugLogger() *Logger {
+func NewDebugLogger() Logger {
 	return NewBasicLogger(jww.LevelDebug)
 }

 // NewWarningLogger is a convenience function to create a warning logger.
-func NewWarningLogger() *Logger {
+func NewWarningLogger() Logger {
 	return NewBasicLogger(jww.LevelWarn)
 }

 // NewInfoLogger is a convenience function to create a info logger.
-func NewInfoLogger() *Logger {
+func NewInfoLogger() Logger {
 	return NewBasicLogger(jww.LevelInfo)
 }

 // NewErrorLogger is a convenience function to create an error logger.
-func NewErrorLogger() *Logger {
+func NewErrorLogger() Logger {
 	return NewBasicLogger(jww.LevelError)
 }

 // NewBasicLogger creates a new basic logger writing to Stdout.
-func NewBasicLogger(t jww.Threshold) *Logger {
+func NewBasicLogger(t jww.Threshold) Logger {
 	return newLogger(t, jww.LevelError, os.Stdout, ioutil.Discard, false)
 }

 // NewBasicLoggerForWriter creates a new basic logger writing to w.
-func NewBasicLoggerForWriter(t jww.Threshold, w io.Writer) *Logger {
+func NewBasicLoggerForWriter(t jww.Threshold, w io.Writer) Logger {
 	return newLogger(t, jww.LevelError, w, ioutil.Discard, false)
 }

@@ -170,7 +261,6 @@ func (a labelColorizer) Write(p []byte) (n int, err error) {
 	// bytes, so we lie a little.
 	_, err = a.w.Write([]byte(replaced))
 	return len(p), err
-
 }

 // InitGlobalLogger initializes the global logger, used in some rare cases.
@@ -181,7 +271,6 @@ func InitGlobalLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, lo
 	jww.SetLogOutput(logHandle)
 	jww.SetLogThreshold(logThreshold)
 	jww.SetStdoutThreshold(stdoutThreshold)
-
 }

 func getLogWriters(outHandle, logHandle io.Writer) (io.Writer, io.Writer) {
@@ -196,7 +285,6 @@ func getLogWriters(outHandle, logHandle io.Writer) (io.Writer, io.Writer) {
 	}

 	return outHandle, logHandle
-
 }

 type fatalLogWriter int
@@ -219,7 +307,7 @@ var fatalLogListener = func(t jww.Threshold) io.Writer {
 	return new(fatalLogWriter)
 }

-func newLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) *Logger {
+func newLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) *logger {
 	errorCounter := &jww.Counter{}
 	warnCounter := &jww.Counter{}
 	outHandle, logHandle = getLogWriters(outHandle, logHandle)
@@ -239,11 +327,13 @@ func newLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle
 		listeners = append(listeners, errorCapture)
 	}

-	return &Logger{
-		Notepad:      jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime, listeners...),
-		Out:          outHandle,
-		ErrorCounter: errorCounter,
-		WarnCounter:  warnCounter,
-		errors:       errorBuff,
+	return &logger{
+		Notepad: jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime, listeners...),
+		out:     outHandle,
+		logCounters: &LogCounters{
+			ErrorCounter: errorCounter,
+			WarnCounter:  warnCounter,
+		},
+		errors: errorBuff,
 	}
 }
@@ -26,12 +26,11 @@ func TestLogger(t *testing.T) {
 	c := qt.New(t)
 	l := NewWarningLogger()

-	l.ERROR.Println("One error")
-	l.ERROR.Println("Two error")
-	l.WARN.Println("A warning")
-
-	c.Assert(l.ErrorCounter.Count(), qt.Equals, uint64(2))
+	l.Errorln("One error")
+	l.Errorln("Two error")
+	l.Warnln("A warning")

+	c.Assert(l.LogCounters().ErrorCounter.Count(), qt.Equals, uint64(2))
 }

 func TestLoggerToWriterWithPrefix(t *testing.T) {
@@ -14,56 +14,101 @@
 package maps

 import (
+	"fmt"
 	"strings"

-	"github.com/gobwas/glob"
+	"github.com/gohugoio/hugo/common/types"

+	"github.com/gobwas/glob"
 	"github.com/spf13/cast"
 )

-// ToLower makes all the keys in the given map lower cased and will do so
-// recursively.
-// Notes:
-// * This will modify the map given.
-// * Any nested map[interface{}]interface{} will be converted to Params.
-func ToLower(m Params) {
-	for k, v := range m {
-		var retyped bool
-		switch v.(type) {
-		case map[interface{}]interface{}:
-			var p Params = cast.ToStringMap(v)
-			v = p
-			ToLower(p)
-			retyped = true
-		case map[string]interface{}:
-			var p Params = v.(map[string]interface{})
-			v = p
-			ToLower(p)
-			retyped = true
-		}
-
-		lKey := strings.ToLower(k)
-		if retyped || k != lKey {
-			delete(m, k)
-			m[lKey] = v
-		}
-	}
-}
-
+// ToStringMapE converts in to map[string]interface{}.
 func ToStringMapE(in interface{}) (map[string]interface{}, error) {
-	switch in.(type) {
+	switch vv := in.(type) {
 	case Params:
-		return in.(Params), nil
+		return vv, nil
+	case map[string]string:
+		var m = map[string]interface{}{}
+		for k, v := range vv {
+			m[k] = v
+		}
+		return m, nil
+
 	default:
 		return cast.ToStringMapE(in)
 	}
 }

+// ToParamsAndPrepare converts in to Params and prepares it for use.
+// If in is nil, an empty map is returned.
+// See PrepareParams.
+func ToParamsAndPrepare(in interface{}) (Params, bool) {
+	if types.IsNil(in) {
+		return Params{}, true
+	}
+	m, err := ToStringMapE(in)
+	if err != nil {
+		return nil, false
+	}
+	PrepareParams(m)
+	return m, true
+}
+
+// MustToParamsAndPrepare calls ToParamsAndPrepare and panics if it fails.
+func MustToParamsAndPrepare(in interface{}) Params {
+	if p, ok := ToParamsAndPrepare(in); ok {
+		return p
+	} else {
+		panic(fmt.Sprintf("cannot convert %T to maps.Params", in))
+	}
+}
+
+// ToStringMap converts in to map[string]interface{}.
 func ToStringMap(in interface{}) map[string]interface{} {
 	m, _ := ToStringMapE(in)
 	return m
 }

+// ToStringMapStringE converts in to map[string]string.
+func ToStringMapStringE(in interface{}) (map[string]string, error) {
+	m, err := ToStringMapE(in)
+	if err != nil {
+		return nil, err
+	}
+	return cast.ToStringMapStringE(m)
+}
+
+// ToStringMapString converts in to map[string]string.
+func ToStringMapString(in interface{}) map[string]string {
+	m, _ := ToStringMapStringE(in)
+	return m
+}
+
+// ToStringMapBool converts in to bool.
+func ToStringMapBool(in interface{}) map[string]bool {
+	m, _ := ToStringMapE(in)
+	return cast.ToStringMapBool(m)
+}
+
+// ToSliceStringMap converts in to []map[string]interface{}.
+func ToSliceStringMap(in interface{}) ([]map[string]interface{}, error) {
+	switch v := in.(type) {
+	case []map[string]interface{}:
+		return v, nil
+	case []interface{}:
+		var s []map[string]interface{}
+		for _, entry := range v {
+			if vv, ok := entry.(map[string]interface{}); ok {
+				s = append(s, vv)
+			}
+		}
+		return s, nil
+	default:
+		return nil, fmt.Errorf("unable to cast %#v of type %T to []map[string]interface{}", in, in)
+	}
+}
+
 type keyRename struct {
 	pattern glob.Glob
 	newKey  string
@@ -109,9 +154,8 @@ func (KeyRenamer) keyPath(k1, k2 string) string {
 	k1, k2 = strings.ToLower(k1), strings.ToLower(k2)
 	if k1 == "" {
 		return k2
-	} else {
-		return k1 + "/" + k2
 	}
+	return k1 + "/" + k2
 }

 func (r KeyRenamer) renamePath(parentKeyPath string, m map[string]interface{}) {
@@ -21,10 +21,10 @@ import (
 	qt "github.com/frankban/quicktest"
 )

-func TestToLower(t *testing.T) {
+func TestPrepareParams(t *testing.T) {
 	tests := []struct {
-		input    map[string]interface{}
-		expected map[string]interface{}
+		input    Params
+		expected Params
 	}{
 		{
 			map[string]interface{}{
@@ -47,6 +47,9 @@ func TestToLower(t *testing.T) {
 				"gHi": map[string]interface{}{
 					"J": 25,
 				},
+				"jKl": map[string]string{
+					"M": "26",
+				},
 			},
 			Params{
 				"abc": 32,
@@ -60,14 +63,17 @@ func TestToLower(t *testing.T) {
 				"ghi": Params{
 					"j": 25,
 				},
+				"jkl": Params{
+					"m": "26",
+				},
 			},
 		},
 	}

 	for i, test := range tests {
 		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			// ToLower modifies input.
-			ToLower(test.input)
+			// PrepareParams modifies input.
+			PrepareParams(test.input)
 			if !reflect.DeepEqual(test.expected, test.input) {
 				t.Errorf("[%d] Expected\n%#v, got\n%#v\n", i, test.expected, test.input)
 			}
@@ -75,6 +81,49 @@ func TestToLower(t *testing.T) {
 	}
 }

+func TestToSliceStringMap(t *testing.T) {
+	c := qt.New(t)
+
+	tests := []struct {
+		input    interface{}
+		expected []map[string]interface{}
+	}{
+		{
+			input: []map[string]interface{}{
+				{"abc": 123},
+			},
+			expected: []map[string]interface{}{
+				{"abc": 123},
+			},
+		}, {
+			input: []interface{}{
+				map[string]interface{}{
+					"def": 456,
+				},
+			},
+			expected: []map[string]interface{}{
+				{"def": 456},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		v, err := ToSliceStringMap(test.input)
+		c.Assert(err, qt.IsNil)
+		c.Assert(v, qt.DeepEquals, test.expected)
+	}
+}
+
+func TestToParamsAndPrepare(t *testing.T) {
+	c := qt.New(t)
+	_, ok := ToParamsAndPrepare(map[string]interface{}{"A": "av"})
+	c.Assert(ok, qt.IsTrue)
+
+	params, ok := ToParamsAndPrepare(nil)
+	c.Assert(ok, qt.IsTrue)
+	c.Assert(params, qt.DeepEquals, Params{})
+}
+
 func TestRenameKeys(t *testing.T) {
 	c := qt.New(t)

@@ -121,5 +170,4 @@ func TestRenameKeys(t *testing.T) {
 	if !reflect.DeepEqual(expected, m) {
 		t.Errorf("Expected\n%#v, got\n%#v\n", expected, m)
 	}
-
 }
@@ -14,6 +14,7 @@
 package maps

 import (
+	"fmt"
 	"strings"

 	"github.com/spf13/cast"
@@ -29,6 +30,118 @@ func (p Params) Get(indices ...string) interface{} {
 	return v
 }

+// Set overwrites values in p with values in pp for common or new keys.
+// This is done recursively.
+func (p Params) Set(pp Params) {
+	for k, v := range pp {
+		vv, found := p[k]
+		if !found {
+			p[k] = v
+		} else {
+			switch vvv := vv.(type) {
+			case Params:
+				if pv, ok := v.(Params); ok {
+					vvv.Set(pv)
+				} else {
+					p[k] = v
+				}
+			default:
+				p[k] = v
+			}
+		}
+	}
+}
+
+// IsZero returns true if p is considered empty.
+func (p Params) IsZero() bool {
+	if p == nil || len(p) == 0 {
+		return true
+	}
+
+	if len(p) > 1 {
+		return false
+	}
+
+	for k, _ := range p {
+		return k == mergeStrategyKey
+	}
+
+	return false
+
+}
+
+// Merge transfers values from pp to p for new keys.
+// This is done recursively.
+func (p Params) Merge(pp Params) {
+	p.merge("", pp)
+}
+
+// MergeRoot transfers values from pp to p for new keys where p is the
+// root of the tree.
+// This is done recursively.
+func (p Params) MergeRoot(pp Params) {
+	ms, _ := p.GetMergeStrategy()
+	p.merge(ms, pp)
+}
+
+func (p Params) merge(ps ParamsMergeStrategy, pp Params) {
+	ns, found := p.GetMergeStrategy()
+
+	var ms = ns
+	if !found && ps != "" {
+		ms = ps
+	}
+
+	noUpdate := ms == ParamsMergeStrategyNone
+	noUpdate = noUpdate || (ps != "" && ps == ParamsMergeStrategyShallow)
+
+	for k, v := range pp {
+
+		if k == mergeStrategyKey {
+			continue
+		}
+		vv, found := p[k]
+
+		if found {
+			// Key matches, if both sides are Params, we try to merge.
+			if vvv, ok := vv.(Params); ok {
+				if pv, ok := v.(Params); ok {
+					vvv.merge(ms, pv)
+				}
+			}
+		} else if !noUpdate {
+			p[k] = v
+		}
+
+	}
+}
+
+func (p Params) GetMergeStrategy() (ParamsMergeStrategy, bool) {
+	if v, found := p[mergeStrategyKey]; found {
+		if s, ok := v.(ParamsMergeStrategy); ok {
+			return s, true
+		}
+	}
+	return ParamsMergeStrategyShallow, false
+}
+
+func (p Params) DeleteMergeStrategy() bool {
+	if _, found := p[mergeStrategyKey]; found {
+		delete(p, mergeStrategyKey)
+		return true
+	}
+	return false
+}
+
+func (p Params) SetDefaultMergeStrategy(s ParamsMergeStrategy) {
+	switch s {
+	case ParamsMergeStrategyDeep, ParamsMergeStrategyNone, ParamsMergeStrategyShallow:
+	default:
+		panic(fmt.Sprintf("invalid merge strategy %q", s))
+	}
+	p[mergeStrategyKey] = s
+}
+
 func getNested(m map[string]interface{}, indices []string) (interface{}, string, map[string]interface{}) {
 	if len(indices) == 0 {
 		return nil, "", nil
@@ -37,7 +150,11 @@ func getNested(m map[string]interface{}, indices []string) (interface{}, string,
 	first := indices[0]
 	v, found := m[strings.ToLower(cast.ToString(first))]
 	if !found {
+		if len(indices) == 1 {
+			return nil, first, m
+		}
 		return nil, "", nil
+
 	}

 	if len(indices) == 1 {
@@ -76,11 +193,10 @@ func GetNestedParam(keyStr, separator string, candidates ...Params) (interface{}
 	}

 	return nil, nil
-
 }

 func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) interface{}) (interface{}, string, map[string]interface{}, error) {
-	keySegments := strings.Split(strings.ToLower(keyStr), separator)
+	keySegments := strings.Split(keyStr, separator)
 	if len(keySegments) == 0 {
 		return nil, "", nil, nil
 	}
@@ -105,3 +221,69 @@ func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) interf

 	return nil, "", nil, nil
 }
+
+// ParamsMergeStrategy tells what strategy to use in Params.Merge.
+type ParamsMergeStrategy string
+
+const (
+	// Do not merge.
+	ParamsMergeStrategyNone ParamsMergeStrategy = "none"
+	// Only add new keys.
+	ParamsMergeStrategyShallow ParamsMergeStrategy = "shallow"
+	// Add new keys, merge existing.
+	ParamsMergeStrategyDeep ParamsMergeStrategy = "deep"
+
+	mergeStrategyKey = "_merge"
+)
+
+func toMergeStrategy(v interface{}) ParamsMergeStrategy {
+	s := ParamsMergeStrategy(cast.ToString(v))
+	switch s {
+	case ParamsMergeStrategyDeep, ParamsMergeStrategyNone, ParamsMergeStrategyShallow:
+		return s
+	default:
+		return ParamsMergeStrategyDeep
+	}
+}
+
+// PrepareParams
+// * makes all the keys in the given map lower cased and will do so
+// * This will modify the map given.
+// * Any nested map[interface{}]interface{}, map[string]interface{},map[string]string  will be converted to Params.
+// * Any _merge value will be converted to proper type and value.
+func PrepareParams(m Params) {
+	for k, v := range m {
+		var retyped bool
+		lKey := strings.ToLower(k)
+		if lKey == mergeStrategyKey {
+			v = toMergeStrategy(v)
+			retyped = true
+		} else {
+			switch vv := v.(type) {
+			case map[interface{}]interface{}:
+				var p Params = cast.ToStringMap(v)
+				v = p
+				PrepareParams(p)
+				retyped = true
+			case map[string]interface{}:
+				var p Params = v.(map[string]interface{})
+				v = p
+				PrepareParams(p)
+				retyped = true
+			case map[string]string:
+				p := make(Params)
+				for k, v := range vv {
+					p[k] = v
+				}
+				v = p
+				PrepareParams(p)
+				retyped = true
+			}
+		}
+
+		if retyped || k != lKey {
+			delete(m, k)
+			m[lKey] = v
+		}
+	}
+}
@@ -20,7 +20,6 @@ import (
 )

 func TestGetNestedParam(t *testing.T) {
-
 	m := map[string]interface{}{
 		"string":          "value",
 		"first":           1,
@@ -47,5 +46,125 @@ func TestGetNestedParam(t *testing.T) {
 	c.Assert(must("nested_color", "_", m), qt.Equals, "blue")
 	c.Assert(must("nested.nestednested.color", ".", m), qt.Equals, "green")
 	c.Assert(must("string.name", ".", m), qt.IsNil)
+	c.Assert(must("nested.foo", ".", m), qt.IsNil)
+}
+
+// https://github.com/gohugoio/hugo/issues/7903
+func TestGetNestedParamFnNestedNewKey(t *testing.T) {
+	c := qt.New(t)
+
+	nested := map[string]interface{}{
+		"color": "blue",
+	}
+	m := map[string]interface{}{
+		"nested": nested,
+	}
+
+	existing, nestedKey, owner, err := GetNestedParamFn("nested.new", ".", func(key string) interface{} {
+		return m[key]
+	})
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(existing, qt.IsNil)
+	c.Assert(nestedKey, qt.Equals, "new")
+	c.Assert(owner, qt.DeepEquals, nested)
+}
+
+func TestParamsSetAndMerge(t *testing.T) {
+	c := qt.New(t)
+
+	createParamsPair := func() (Params, Params) {
+		p1 := Params{"a": "av", "c": "cv", "nested": Params{"al2": "al2v", "cl2": "cl2v"}}
+		p2 := Params{"b": "bv", "a": "abv", "nested": Params{"bl2": "bl2v", "al2": "al2bv"}, mergeStrategyKey: ParamsMergeStrategyDeep}
+		return p1, p2
+	}
+
+	p1, p2 := createParamsPair()
+
+	p1.Set(p2)
+
+	c.Assert(p1, qt.DeepEquals, Params{
+		"a": "abv",
+		"c": "cv",
+		"nested": Params{
+			"al2": "al2bv",
+			"cl2": "cl2v",
+			"bl2": "bl2v",
+		},
+		"b":              "bv",
+		mergeStrategyKey: ParamsMergeStrategyDeep,
+	})
+
+	p1, p2 = createParamsPair()
+
+	p1.Merge(p2)
+
+	// Default is to do a shallow merge.
+	c.Assert(p1, qt.DeepEquals, Params{
+		"c": "cv",
+		"nested": Params{
+			"al2": "al2v",
+			"cl2": "cl2v",
+		},
+		"b": "bv",
+		"a": "av",
+	})
+
+	p1, p2 = createParamsPair()
+	p1.SetDefaultMergeStrategy(ParamsMergeStrategyNone)
+	p1.Merge(p2)
+	p1.DeleteMergeStrategy()
+
+	c.Assert(p1, qt.DeepEquals, Params{
+		"a": "av",
+		"c": "cv",
+		"nested": Params{
+			"al2": "al2v",
+			"cl2": "cl2v",
+		},
+	})
+
+	p1, p2 = createParamsPair()
+	p1.SetDefaultMergeStrategy(ParamsMergeStrategyShallow)
+	p1.Merge(p2)
+	p1.DeleteMergeStrategy()
+
+	c.Assert(p1, qt.DeepEquals, Params{
+		"a": "av",
+		"c": "cv",
+		"nested": Params{
+			"al2": "al2v",
+			"cl2": "cl2v",
+		},
+		"b": "bv",
+	})
+
+	p1, p2 = createParamsPair()
+	p1.SetDefaultMergeStrategy(ParamsMergeStrategyDeep)
+	p1.Merge(p2)
+	p1.DeleteMergeStrategy()
+
+	c.Assert(p1, qt.DeepEquals, Params{
+		"nested": Params{
+			"al2": "al2v",
+			"cl2": "cl2v",
+			"bl2": "bl2v",
+		},
+		"b": "bv",
+		"a": "av",
+		"c": "cv",
+	})

 }
+
+func TestParamsIsZero(t *testing.T) {
+	c := qt.New(t)
+
+	var nilParams Params
+
+	c.Assert(Params{}.IsZero(), qt.IsTrue)
+	c.Assert(nilParams.IsZero(), qt.IsTrue)
+	c.Assert(Params{"foo": "bar"}.IsZero(), qt.IsFalse)
+	c.Assert(Params{"_merge": "foo", "foo": "bar"}.IsZero(), qt.IsFalse)
+	c.Assert(Params{"_merge": "foo"}.IsZero(), qt.IsTrue)
+}
@@ -51,7 +51,6 @@ func NewScratcher() Scratcher {
 //
 // If the first add for a key is an array or slice, then the next value(s) will be appended.
 func (c *Scratch) Add(key string, newAddend interface{}) (string, error) {
-
 	var newVal interface{}
 	c.mu.RLock()
 	existingAddend, found := c.values[key]
@@ -130,6 +129,17 @@ func (c *Scratch) SetInMap(key string, mapKey string, value interface{}) string
 	return ""
 }

+// DeleteInMap deletes a value to a map with the given key in the Node context.
+func (c *Scratch) DeleteInMap(key string, mapKey string) string {
+	c.mu.Lock()
+	_, found := c.values[key]
+	if found {
+		delete(c.values[key].(map[string]interface{}), mapKey)
+	}
+	c.mu.Unlock()
+	return ""
+}
+
 // GetSortedMapValues returns a sorted map previously filled with SetInMap.
 func (c *Scratch) GetSortedMapValues(key string) interface{} {
 	c.mu.RLock()
@@ -53,7 +53,6 @@ func TestScratchAdd(t *testing.T) {
 	if err == nil {
 		t.Errorf("Expected error from invalid arithmetic")
 	}
-
 }

 func TestScratchAddSlice(t *testing.T) {
@@ -96,7 +95,6 @@ func TestScratchAddTypedSliceToInterfaceSlice(t *testing.T) {
 	_, err := scratch.Add("slice", []int{1, 2})
 	c.Assert(err, qt.IsNil)
 	c.Assert(scratch.Get("slice"), qt.DeepEquals, []int{1, 2})
-
 }

 // https://github.com/gohugoio/hugo/issues/5361
@@ -110,7 +108,6 @@ func TestScratchAddDifferentTypedSliceToInterfaceSlice(t *testing.T) {
 	_, err := scratch.Add("slice", []int{1, 2})
 	c.Assert(err, qt.IsNil)
 	c.Assert(scratch.Get("slice"), qt.DeepEquals, []interface{}{"foo", 1, 2})
-
 }

 func TestScratchSet(t *testing.T) {
@@ -191,6 +188,20 @@ func TestScratchSetInMap(t *testing.T) {
 	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []interface{}{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"})
 }

+func TestScratchDeleteInMap(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	scratch := NewScratch()
+	scratch.SetInMap("key", "lux", "Lux")
+	scratch.SetInMap("key", "abc", "Abc")
+	scratch.SetInMap("key", "zyx", "Zyx")
+	scratch.DeleteInMap("key", "abc")
+	scratch.SetInMap("key", "def", "Def")
+	scratch.DeleteInMap("key", "lmn") // Do nothing
+	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []interface{}{0: "Def", 1: "Lux", 2: "Zyx"})
+}
+
 func TestScratchGetSortedMapValues(t *testing.T) {
 	t.Parallel()
 	scratch := NewScratch()
@@ -16,13 +16,14 @@ package para
 import (
 	"context"
 	"runtime"
-
 	"sort"
 	"sync"
 	"sync/atomic"
 	"testing"
 	"time"

+	"github.com/gohugoio/hugo/htesting"
+
 	qt "github.com/frankban/quicktest"
 )

@@ -31,6 +32,10 @@ func TestPara(t *testing.T) {
 		t.Skipf("skip para test, CPU count is %d", runtime.NumCPU())
 	}

+	if !htesting.IsCI() {
+		t.Skip("skip para test when not running on CI")
+	}
+
 	c := qt.New(t)

 	c.Run("Order", func(c *qt.C) {
@@ -60,7 +65,6 @@ func TestPara(t *testing.T) {
 		c.Assert(sort.IntsAreSorted(result), qt.Equals, false, qt.Commentf("Para does not seem to be parallel"))
 		sort.Ints(result)
 		c.Assert(result, qt.DeepEquals, ints)
-
 	})

 	c.Run("Time", func(c *qt.C) {
@@ -83,8 +87,9 @@ func TestPara(t *testing.T) {

 		c.Assert(r.Wait(), qt.IsNil)
 		c.Assert(counter, qt.Equals, int64(n))
-		c.Assert(time.Since(start) < n/2*time.Millisecond, qt.Equals, true)

+		since := time.Since(start)
+		limit := n / 2 * time.Millisecond
+		c.Assert(since < limit, qt.Equals, true, qt.Commentf("%s >= %s", since, limit))
 	})
-
 }
@@ -0,0 +1,312 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package paths
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// FilePathSeparator as defined by os.Separator.
+const FilePathSeparator = string(filepath.Separator)
+
+// filepathPathBridge is a bridge for common functionality in filepath vs path
+type filepathPathBridge interface {
+	Base(in string) string
+	Clean(in string) string
+	Dir(in string) string
+	Ext(in string) string
+	Join(elem ...string) string
+	Separator() string
+}
+
+type filepathBridge struct {
+}
+
+func (filepathBridge) Base(in string) string {
+	return filepath.Base(in)
+}
+
+func (filepathBridge) Clean(in string) string {
+	return filepath.Clean(in)
+}
+
+func (filepathBridge) Dir(in string) string {
+	return filepath.Dir(in)
+}
+
+func (filepathBridge) Ext(in string) string {
+	return filepath.Ext(in)
+}
+
+func (filepathBridge) Join(elem ...string) string {
+	return filepath.Join(elem...)
+}
+
+func (filepathBridge) Separator() string {
+	return FilePathSeparator
+}
+
+var fpb filepathBridge
+
+// ToSlashTrimLeading is just a filepath.ToSlash with an added / prefix trimmer.
+func ToSlashTrimLeading(s string) string {
+	return strings.TrimPrefix(filepath.ToSlash(s), "/")
+}
+
+// MakeTitle converts the path given to a suitable title, trimming whitespace
+// and replacing hyphens with whitespace.
+func MakeTitle(inpath string) string {
+	return strings.Replace(strings.TrimSpace(inpath), "-", " ", -1)
+}
+
+// ReplaceExtension takes a path and an extension, strips the old extension
+// and returns the path with the new extension.
+func ReplaceExtension(path string, newExt string) string {
+	f, _ := fileAndExt(path, fpb)
+	return f + "." + newExt
+}
+
+func makePathRelative(inPath string, possibleDirectories ...string) (string, error) {
+	for _, currentPath := range possibleDirectories {
+		if strings.HasPrefix(inPath, currentPath) {
+			return strings.TrimPrefix(inPath, currentPath), nil
+		}
+	}
+	return inPath, errors.New("can't extract relative path, unknown prefix")
+}
+
+// Should be good enough for Hugo.
+var isFileRe = regexp.MustCompile(`.*\..{1,6}$`)
+
+// GetDottedRelativePath expects a relative path starting after the content directory.
+// It returns a relative path with dots ("..") navigating up the path structure.
+func GetDottedRelativePath(inPath string) string {
+	inPath = filepath.Clean(filepath.FromSlash(inPath))
+
+	if inPath == "." {
+		return "./"
+	}
+
+	if !isFileRe.MatchString(inPath) && !strings.HasSuffix(inPath, FilePathSeparator) {
+		inPath += FilePathSeparator
+	}
+
+	if !strings.HasPrefix(inPath, FilePathSeparator) {
+		inPath = FilePathSeparator + inPath
+	}
+
+	dir, _ := filepath.Split(inPath)
+
+	sectionCount := strings.Count(dir, FilePathSeparator)
+
+	if sectionCount == 0 || dir == FilePathSeparator {
+		return "./"
+	}
+
+	var dottedPath string
+
+	for i := 1; i < sectionCount; i++ {
+		dottedPath += "../"
+	}
+
+	return dottedPath
+}
+
+// ExtNoDelimiter takes a path and returns the extension, excluding the delimiter, i.e. "md".
+func ExtNoDelimiter(in string) string {
+	return strings.TrimPrefix(Ext(in), ".")
+}
+
+// Ext takes a path and returns the extension, including the delimiter, i.e. ".md".
+func Ext(in string) string {
+	_, ext := fileAndExt(in, fpb)
+	return ext
+}
+
+// PathAndExt is the same as FileAndExt, but it uses the path package.
+func PathAndExt(in string) (string, string) {
+	return fileAndExt(in, pb)
+}
+
+// FileAndExt takes a path and returns the file and extension separated,
+// the extension including the delimiter, i.e. ".md".
+func FileAndExt(in string) (string, string) {
+	return fileAndExt(in, fpb)
+}
+
+// FileAndExtNoDelimiter takes a path and returns the file and extension separated,
+// the extension excluding the delimiter, e.g "md".
+func FileAndExtNoDelimiter(in string) (string, string) {
+	file, ext := fileAndExt(in, fpb)
+	return file, strings.TrimPrefix(ext, ".")
+}
+
+// Filename takes a file path, strips out the extension,
+// and returns the name of the file.
+func Filename(in string) (name string) {
+	name, _ = fileAndExt(in, fpb)
+	return
+}
+
+// PathNoExt takes a path, strips out the extension,
+// and returns the name of the file.
+func PathNoExt(in string) string {
+	return strings.TrimSuffix(in, path.Ext(in))
+}
+
+// FileAndExt returns the filename and any extension of a file path as
+// two separate strings.
+//
+// If the path, in, contains a directory name ending in a slash,
+// then both name and ext will be empty strings.
+//
+// If the path, in, is either the current directory, the parent
+// directory or the root directory, or an empty string,
+// then both name and ext will be empty strings.
+//
+// If the path, in, represents the path of a file without an extension,
+// then name will be the name of the file and ext will be an empty string.
+//
+// If the path, in, represents a filename with an extension,
+// then name will be the filename minus any extension - including the dot
+// and ext will contain the extension - minus the dot.
+func fileAndExt(in string, b filepathPathBridge) (name string, ext string) {
+	ext = b.Ext(in)
+	base := b.Base(in)
+
+	return extractFilename(in, ext, base, b.Separator()), ext
+}
+
+func extractFilename(in, ext, base, pathSeparator string) (name string) {
+	// No file name cases. These are defined as:
+	// 1. any "in" path that ends in a pathSeparator
+	// 2. any "base" consisting of just an pathSeparator
+	// 3. any "base" consisting of just an empty string
+	// 4. any "base" consisting of just the current directory i.e. "."
+	// 5. any "base" consisting of just the parent directory i.e. ".."
+	if (strings.LastIndex(in, pathSeparator) == len(in)-1) || base == "" || base == "." || base == ".." || base == pathSeparator {
+		name = "" // there is NO filename
+	} else if ext != "" { // there was an Extension
+		// return the filename minus the extension (and the ".")
+		name = base[:strings.LastIndex(base, ".")]
+	} else {
+		// no extension case so just return base, which willi
+		// be the filename
+		name = base
+	}
+	return
+}
+
+// GetRelativePath returns the relative path of a given path.
+func GetRelativePath(path, base string) (final string, err error) {
+	if filepath.IsAbs(path) && base == "" {
+		return "", errors.New("source: missing base directory")
+	}
+	name := filepath.Clean(path)
+	base = filepath.Clean(base)
+
+	name, err = filepath.Rel(base, name)
+	if err != nil {
+		return "", err
+	}
+
+	if strings.HasSuffix(filepath.FromSlash(path), FilePathSeparator) && !strings.HasSuffix(name, FilePathSeparator) {
+		name += FilePathSeparator
+	}
+	return name, nil
+}
+
+// PathPrep prepares the path using the uglify setting to create paths on
+// either the form /section/name/index.html or /section/name.html.
+func PathPrep(ugly bool, in string) string {
+	if ugly {
+		return Uglify(in)
+	}
+	return PrettifyPath(in)
+}
+
+// PrettifyPath is the same as PrettifyURLPath but for file paths.
+//     /section/name.html       becomes /section/name/index.html
+//     /section/name/           becomes /section/name/index.html
+//     /section/name/index.html becomes /section/name/index.html
+func PrettifyPath(in string) string {
+	return prettifyPath(in, fpb)
+}
+
+func prettifyPath(in string, b filepathPathBridge) string {
+	if filepath.Ext(in) == "" {
+		// /section/name/  -> /section/name/index.html
+		if len(in) < 2 {
+			return b.Separator()
+		}
+		return b.Join(in, "index.html")
+	}
+	name, ext := fileAndExt(in, b)
+	if name == "index" {
+		// /section/name/index.html -> /section/name/index.html
+		return b.Clean(in)
+	}
+	// /section/name.html -> /section/name/index.html
+	return b.Join(b.Dir(in), name, "index"+ext)
+}
+
+type NamedSlice struct {
+	Name  string
+	Slice []string
+}
+
+func (n NamedSlice) String() string {
+	if len(n.Slice) == 0 {
+		return n.Name
+	}
+	return fmt.Sprintf("%s%s{%s}", n.Name, FilePathSeparator, strings.Join(n.Slice, ","))
+}
+
+// FindCWD returns the current working directory from where the Hugo
+// executable is run.
+func FindCWD() (string, error) {
+	serverFile, err := filepath.Abs(os.Args[0])
+	if err != nil {
+		return "", fmt.Errorf("can't get absolute path for executable: %v", err)
+	}
+
+	path := filepath.Dir(serverFile)
+	realFile, err := filepath.EvalSymlinks(serverFile)
+	if err != nil {
+		if _, err = os.Stat(serverFile + ".exe"); err == nil {
+			realFile = filepath.Clean(serverFile + ".exe")
+		}
+	}
+
+	if err == nil && realFile != serverFile {
+		path = filepath.Dir(realFile)
+	}
+
+	return path, nil
+}
+
+// AddTrailingSlash adds a trailing Unix styled slash (/) if not already
+// there.
+func AddTrailingSlash(path string) string {
+	if !strings.HasSuffix(path, "/") {
+		path += "/"
+	}
+	return path
+}
@@ -0,0 +1,252 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package paths
+
+import (
+	"path/filepath"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestGetRelativePath(t *testing.T) {
+	tests := []struct {
+		path   string
+		base   string
+		expect interface{}
+	}{
+		{filepath.FromSlash("/a/b"), filepath.FromSlash("/a"), filepath.FromSlash("b")},
+		{filepath.FromSlash("/a/b/c/"), filepath.FromSlash("/a"), filepath.FromSlash("b/c/")},
+		{filepath.FromSlash("/c"), filepath.FromSlash("/a/b"), filepath.FromSlash("../../c")},
+		{filepath.FromSlash("/c"), "", false},
+	}
+	for i, this := range tests {
+		// ultimately a fancy wrapper around filepath.Rel
+		result, err := GetRelativePath(this.path, this.base)
+
+		if b, ok := this.expect.(bool); ok && !b {
+			if err == nil {
+				t.Errorf("[%d] GetRelativePath didn't return an expected error", i)
+			}
+		} else {
+			if err != nil {
+				t.Errorf("[%d] GetRelativePath failed: %s", i, err)
+				continue
+			}
+			if result != this.expect {
+				t.Errorf("[%d] GetRelativePath got %v but expected %v", i, result, this.expect)
+			}
+		}
+
+	}
+}
+
+func TestMakePathRelative(t *testing.T) {
+	type test struct {
+		inPath, path1, path2, output string
+	}
+
+	data := []test{
+		{"/abc/bcd/ab.css", "/abc/bcd", "/bbc/bcd", "/ab.css"},
+		{"/abc/bcd/ab.css", "/abcd/bcd", "/abc/bcd", "/ab.css"},
+	}
+
+	for i, d := range data {
+		output, _ := makePathRelative(d.inPath, d.path1, d.path2)
+		if d.output != output {
+			t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output)
+		}
+	}
+	_, error := makePathRelative("a/b/c.ss", "/a/c", "/d/c", "/e/f")
+
+	if error == nil {
+		t.Errorf("Test failed, expected error")
+	}
+}
+
+func TestGetDottedRelativePath(t *testing.T) {
+	// on Windows this will receive both kinds, both country and western ...
+	for _, f := range []func(string) string{filepath.FromSlash, func(s string) string { return s }} {
+		doTestGetDottedRelativePath(f, t)
+	}
+}
+
+func doTestGetDottedRelativePath(urlFixer func(string) string, t *testing.T) {
+	type test struct {
+		input, expected string
+	}
+	data := []test{
+		{"", "./"},
+		{urlFixer("/"), "./"},
+		{urlFixer("post"), "../"},
+		{urlFixer("/post"), "../"},
+		{urlFixer("post/"), "../"},
+		{urlFixer("tags/foo.html"), "../"},
+		{urlFixer("/tags/foo.html"), "../"},
+		{urlFixer("/post/"), "../"},
+		{urlFixer("////post/////"), "../"},
+		{urlFixer("/foo/bar/index.html"), "../../"},
+		{urlFixer("/foo/bar/foo/"), "../../../"},
+		{urlFixer("/foo/bar/foo"), "../../../"},
+		{urlFixer("foo/bar/foo/"), "../../../"},
+		{urlFixer("foo/bar/foo/bar"), "../../../../"},
+		{"404.html", "./"},
+		{"404.xml", "./"},
+		{"/404.html", "./"},
+	}
+	for i, d := range data {
+		output := GetDottedRelativePath(d.input)
+		if d.expected != output {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
+		}
+	}
+}
+
+func TestMakeTitle(t *testing.T) {
+	type test struct {
+		input, expected string
+	}
+	data := []test{
+		{"Make-Title", "Make Title"},
+		{"MakeTitle", "MakeTitle"},
+		{"make_title", "make_title"},
+	}
+	for i, d := range data {
+		output := MakeTitle(d.input)
+		if d.expected != output {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
+		}
+	}
+}
+
+// Replace Extension is probably poorly named, but the intent of the
+// function is to accept a path and return only the file name with a
+// new extension. It's intentionally designed to strip out the path
+// and only provide the name. We should probably rename the function to
+// be more explicit at some point.
+func TestReplaceExtension(t *testing.T) {
+	type test struct {
+		input, newext, expected string
+	}
+	data := []test{
+		// These work according to the above definition
+		{"/some/random/path/file.xml", "html", "file.html"},
+		{"/banana.html", "xml", "banana.xml"},
+		{"./banana.html", "xml", "banana.xml"},
+		{"banana/pie/index.html", "xml", "index.xml"},
+		{"../pies/fish/index.html", "xml", "index.xml"},
+		// but these all fail
+		{"filename-without-an-ext", "ext", "filename-without-an-ext.ext"},
+		{"/filename-without-an-ext", "ext", "filename-without-an-ext.ext"},
+		{"/directory/mydir/", "ext", ".ext"},
+		{"mydir/", "ext", ".ext"},
+	}
+
+	for i, d := range data {
+		output := ReplaceExtension(filepath.FromSlash(d.input), d.newext)
+		if d.expected != output {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
+		}
+	}
+}
+
+func TestExtNoDelimiter(t *testing.T) {
+	c := qt.New(t)
+	c.Assert(ExtNoDelimiter(filepath.FromSlash("/my/data.json")), qt.Equals, "json")
+}
+
+func TestFilename(t *testing.T) {
+	type test struct {
+		input, expected string
+	}
+	data := []test{
+		{"index.html", "index"},
+		{"./index.html", "index"},
+		{"/index.html", "index"},
+		{"index", "index"},
+		{"/tmp/index.html", "index"},
+		{"./filename-no-ext", "filename-no-ext"},
+		{"/filename-no-ext", "filename-no-ext"},
+		{"filename-no-ext", "filename-no-ext"},
+		{"directory/", ""}, // no filename case??
+		{"directory/.hidden.ext", ".hidden"},
+		{"./directory/../~/banana/gold.fish", "gold"},
+		{"../directory/banana.man", "banana"},
+		{"~/mydir/filename.ext", "filename"},
+		{"./directory//tmp/filename.ext", "filename"},
+	}
+
+	for i, d := range data {
+		output := Filename(filepath.FromSlash(d.input))
+		if d.expected != output {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
+		}
+	}
+}
+
+func TestFileAndExt(t *testing.T) {
+	type test struct {
+		input, expectedFile, expectedExt string
+	}
+	data := []test{
+		{"index.html", "index", ".html"},
+		{"./index.html", "index", ".html"},
+		{"/index.html", "index", ".html"},
+		{"index", "index", ""},
+		{"/tmp/index.html", "index", ".html"},
+		{"./filename-no-ext", "filename-no-ext", ""},
+		{"/filename-no-ext", "filename-no-ext", ""},
+		{"filename-no-ext", "filename-no-ext", ""},
+		{"directory/", "", ""}, // no filename case??
+		{"directory/.hidden.ext", ".hidden", ".ext"},
+		{"./directory/../~/banana/gold.fish", "gold", ".fish"},
+		{"../directory/banana.man", "banana", ".man"},
+		{"~/mydir/filename.ext", "filename", ".ext"},
+		{"./directory//tmp/filename.ext", "filename", ".ext"},
+	}
+
+	for i, d := range data {
+		file, ext := fileAndExt(filepath.FromSlash(d.input), fpb)
+		if d.expectedFile != file {
+			t.Errorf("Test %d failed. Expected filename %q got %q.", i, d.expectedFile, file)
+		}
+		if d.expectedExt != ext {
+			t.Errorf("Test %d failed. Expected extension %q got %q.", i, d.expectedExt, ext)
+		}
+	}
+}
+
+func TestFindCWD(t *testing.T) {
+	type test struct {
+		expectedDir string
+		expectedErr error
+	}
+
+	// cwd, _ := os.Getwd()
+	data := []test{
+		//{cwd, nil},
+		// Commenting this out. It doesn't work properly.
+		// There's a good reason why we don't use os.Getwd(), it doesn't actually work the way we want it to.
+		// I really don't know a better way to test this function. - SPF 2014.11.04
+	}
+	for i, d := range data {
+		dir, err := FindCWD()
+		if d.expectedDir != dir {
+			t.Errorf("Test %d failed. Expected %q but got %q", i, d.expectedDir, dir)
+		}
+		if d.expectedErr != err {
+			t.Errorf("Test %d failed. Expected %q but got %q", i, d.expectedErr, err)
+		}
+	}
+}
@@ -0,0 +1,212 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package paths
+
+import (
+	"fmt"
+	"net/url"
+	"path"
+	"strings"
+
+	"github.com/PuerkitoBio/purell"
+)
+
+type pathBridge struct {
+}
+
+func (pathBridge) Base(in string) string {
+	return path.Base(in)
+}
+
+func (pathBridge) Clean(in string) string {
+	return path.Clean(in)
+}
+
+func (pathBridge) Dir(in string) string {
+	return path.Dir(in)
+}
+
+func (pathBridge) Ext(in string) string {
+	return path.Ext(in)
+}
+
+func (pathBridge) Join(elem ...string) string {
+	return path.Join(elem...)
+}
+
+func (pathBridge) Separator() string {
+	return "/"
+}
+
+var pb pathBridge
+
+func sanitizeURLWithFlags(in string, f purell.NormalizationFlags) string {
+	s, err := purell.NormalizeURLString(in, f)
+	if err != nil {
+		return in
+	}
+
+	// Temporary workaround for the bug fix and resulting
+	// behavioral change in purell.NormalizeURLString():
+	// a leading '/' was inadvertently added to relative links,
+	// but no longer, see #878.
+	//
+	// I think the real solution is to allow Hugo to
+	// make relative URL with relative path,
+	// e.g. "../../post/hello-again/", as wished by users
+	// in issues #157, #622, etc., without forcing
+	// relative URLs to begin with '/'.
+	// Once the fixes are in, let's remove this kludge
+	// and restore SanitizeURL() to the way it was.
+	//                         -- @anthonyfok, 2015-02-16
+	//
+	// Begin temporary kludge
+	u, err := url.Parse(s)
+	if err != nil {
+		panic(err)
+	}
+	if len(u.Path) > 0 && !strings.HasPrefix(u.Path, "/") {
+		u.Path = "/" + u.Path
+	}
+	return u.String()
+	// End temporary kludge
+
+	// return s
+
+}
+
+// SanitizeURL sanitizes the input URL string.
+func SanitizeURL(in string) string {
+	return sanitizeURLWithFlags(in, purell.FlagsSafe|purell.FlagRemoveTrailingSlash|purell.FlagRemoveDotSegments|purell.FlagRemoveDuplicateSlashes|purell.FlagRemoveUnnecessaryHostDots|purell.FlagRemoveEmptyPortSeparator)
+}
+
+// SanitizeURLKeepTrailingSlash is the same as SanitizeURL, but will keep any trailing slash.
+func SanitizeURLKeepTrailingSlash(in string) string {
+	return sanitizeURLWithFlags(in, purell.FlagsSafe|purell.FlagRemoveDotSegments|purell.FlagRemoveDuplicateSlashes|purell.FlagRemoveUnnecessaryHostDots|purell.FlagRemoveEmptyPortSeparator)
+}
+
+// MakePermalink combines base URL with content path to create full URL paths.
+// Example
+//    base:   http://spf13.com/
+//    path:   post/how-i-blog
+//    result: http://spf13.com/post/how-i-blog
+func MakePermalink(host, plink string) *url.URL {
+	base, err := url.Parse(host)
+	if err != nil {
+		panic(err)
+	}
+
+	p, err := url.Parse(plink)
+	if err != nil {
+		panic(err)
+	}
+
+	if p.Host != "" {
+		panic(fmt.Errorf("can't make permalink from absolute link %q", plink))
+	}
+
+	base.Path = path.Join(base.Path, p.Path)
+
+	// path.Join will strip off the last /, so put it back if it was there.
+	hadTrailingSlash := (plink == "" && strings.HasSuffix(host, "/")) || strings.HasSuffix(p.Path, "/")
+	if hadTrailingSlash && !strings.HasSuffix(base.Path, "/") {
+		base.Path = base.Path + "/"
+	}
+
+	return base
+}
+
+// IsAbsURL determines whether the given path points to an absolute URL.
+func IsAbsURL(path string) bool {
+	url, err := url.Parse(path)
+	if err != nil {
+		return false
+	}
+
+	return url.IsAbs() || strings.HasPrefix(path, "//")
+}
+
+// AddContextRoot adds the context root to an URL if it's not already set.
+// For relative URL entries on sites with a base url with a context root set (i.e. http://example.com/mysite),
+// relative URLs must not include the context root if canonifyURLs is enabled. But if it's disabled, it must be set.
+func AddContextRoot(baseURL, relativePath string) string {
+	url, err := url.Parse(baseURL)
+	if err != nil {
+		panic(err)
+	}
+
+	newPath := path.Join(url.Path, relativePath)
+
+	// path strips trailing slash, ignore root path.
+	if newPath != "/" && strings.HasSuffix(relativePath, "/") {
+		newPath += "/"
+	}
+	return newPath
+}
+
+// URLizeAn
+
+// PrettifyURL takes a URL string and returns a semantic, clean URL.
+func PrettifyURL(in string) string {
+	x := PrettifyURLPath(in)
+
+	if path.Base(x) == "index.html" {
+		return path.Dir(x)
+	}
+
+	if in == "" {
+		return "/"
+	}
+
+	return x
+}
+
+// PrettifyURLPath takes a URL path to a content and converts it
+// to enable pretty URLs.
+//     /section/name.html       becomes /section/name/index.html
+//     /section/name/           becomes /section/name/index.html
+//     /section/name/index.html becomes /section/name/index.html
+func PrettifyURLPath(in string) string {
+	return prettifyPath(in, pb)
+}
+
+// Uglify does the opposite of PrettifyURLPath().
+//     /section/name/index.html becomes /section/name.html
+//     /section/name/           becomes /section/name.html
+//     /section/name.html       becomes /section/name.html
+func Uglify(in string) string {
+	if path.Ext(in) == "" {
+		if len(in) < 2 {
+			return "/"
+		}
+		// /section/name/  -> /section/name.html
+		return path.Clean(in) + ".html"
+	}
+
+	name, ext := fileAndExt(in, pb)
+	if name == "index" {
+		// /section/name/index.html -> /section/name.html
+		d := path.Dir(in)
+		if len(d) > 1 {
+			return d + ext
+		}
+		return in
+	}
+	// /.xml -> /index.xml
+	if name == "" {
+		return path.Dir(in) + "index" + ext
+	}
+	// /section/name.html -> /section/name.html
+	return path.Clean(in)
+}
@@ -0,0 +1,129 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package paths
+
+import (
+	"strings"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestSanitizeURL(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"http://foo.bar/", "http://foo.bar"},
+		{"http://foo.bar", "http://foo.bar"},          // issue #1105
+		{"http://foo.bar/zoo/", "http://foo.bar/zoo"}, // issue #931
+	}
+
+	for i, test := range tests {
+		o1 := SanitizeURL(test.input)
+		o2 := SanitizeURLKeepTrailingSlash(test.input)
+
+		expected2 := test.expected
+
+		if strings.HasSuffix(test.input, "/") && !strings.HasSuffix(expected2, "/") {
+			expected2 += "/"
+		}
+
+		if o1 != test.expected {
+			t.Errorf("[%d] 1: Expected %#v, got %#v\n", i, test.expected, o1)
+		}
+		if o2 != expected2 {
+			t.Errorf("[%d] 2: Expected %#v, got %#v\n", i, expected2, o2)
+		}
+	}
+}
+
+func TestMakePermalink(t *testing.T) {
+	type test struct {
+		host, link, output string
+	}
+
+	data := []test{
+		{"http://abc.com/foo", "post/bar", "http://abc.com/foo/post/bar"},
+		{"http://abc.com/foo/", "post/bar", "http://abc.com/foo/post/bar"},
+		{"http://abc.com", "post/bar", "http://abc.com/post/bar"},
+		{"http://abc.com", "bar", "http://abc.com/bar"},
+		{"http://abc.com/foo/bar", "post/bar", "http://abc.com/foo/bar/post/bar"},
+		{"http://abc.com/foo/bar", "post/bar/", "http://abc.com/foo/bar/post/bar/"},
+	}
+
+	for i, d := range data {
+		output := MakePermalink(d.host, d.link).String()
+		if d.output != output {
+			t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output)
+		}
+	}
+}
+
+func TestAddContextRoot(t *testing.T) {
+	tests := []struct {
+		baseURL  string
+		url      string
+		expected string
+	}{
+		{"http://example.com/sub/", "/foo", "/sub/foo"},
+		{"http://example.com/sub/", "/foo/index.html", "/sub/foo/index.html"},
+		{"http://example.com/sub1/sub2", "/foo", "/sub1/sub2/foo"},
+		{"http://example.com", "/foo", "/foo"},
+		// cannot guess that the context root is already added int the example below
+		{"http://example.com/sub/", "/sub/foo", "/sub/sub/foo"},
+		{"http://example.com/тря", "/трям/", "/тря/трям/"},
+		{"http://example.com", "/", "/"},
+		{"http://example.com/bar", "//", "/bar/"},
+	}
+
+	for _, test := range tests {
+		output := AddContextRoot(test.baseURL, test.url)
+		if output != test.expected {
+			t.Errorf("Expected %#v, got %#v\n", test.expected, output)
+		}
+	}
+}
+
+func TestPretty(t *testing.T) {
+	c := qt.New(t)
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name.html"))
+	c.Assert("/section/sub/name/index.html", qt.Equals, PrettifyURLPath("/section/sub/name.html"))
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name/"))
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name/index.html"))
+	c.Assert("/index.html", qt.Equals, PrettifyURLPath("/index.html"))
+	c.Assert("/name/index.xml", qt.Equals, PrettifyURLPath("/name.xml"))
+	c.Assert("/", qt.Equals, PrettifyURLPath("/"))
+	c.Assert("/", qt.Equals, PrettifyURLPath(""))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name.html"))
+	c.Assert("/section/sub/name", qt.Equals, PrettifyURL("/section/sub/name.html"))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name/"))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name/index.html"))
+	c.Assert("/", qt.Equals, PrettifyURL("/index.html"))
+	c.Assert("/name/index.xml", qt.Equals, PrettifyURL("/name.xml"))
+	c.Assert("/", qt.Equals, PrettifyURL("/"))
+	c.Assert("/", qt.Equals, PrettifyURL(""))
+}
+
+func TestUgly(t *testing.T) {
+	c := qt.New(t)
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name.html"))
+	c.Assert("/section/sub/name.html", qt.Equals, Uglify("/section/sub/name.html"))
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name/"))
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name/index.html"))
+	c.Assert("/index.html", qt.Equals, Uglify("/index.html"))
+	c.Assert("/name.xml", qt.Equals, Uglify("/name.xml"))
+	c.Assert("/", qt.Equals, Uglify("/"))
+	c.Assert("/", qt.Equals, Uglify(""))
+}
@@ -50,12 +50,11 @@ func (pos Position) IsValid() bool {
 var positionStringFormatfunc func(p Position) string

 func createPositionStringFormatter(formatStr string) func(p Position) string {
-
 	if formatStr == "" {
 		formatStr = "\":file::line::col\""
 	}

-	var identifiers = []string{":file", ":line", ":col"}
+	identifiers := []string{":file", ":line", ":col"}
 	var identifiersFound []string

 	for i := range formatStr {
@@ -29,5 +29,4 @@ func TestPositionStringFormatter(t *testing.T) {
 	c.Assert(createPositionStringFormatter("好::col")(pos), qt.Equals, "好:13")
 	c.Assert(createPositionStringFormatter("")(pos), qt.Equals, "\"/my/file.txt:12:13\"")
 	c.Assert(pos.String(), qt.Equals, "\"/my/file.txt:12:13\"")
-
 }
@@ -25,5 +25,4 @@ func TestRemoveAccents(t *testing.T) {
 	c.Assert(string(RemoveAccents([]byte("Resumé"))), qt.Equals, "Resume")
 	c.Assert(string(RemoveAccents([]byte("Hugo Rocks!"))), qt.Equals, "Hugo Rocks!")
 	c.Assert(string(RemoveAccentsString("Resumé")), qt.Equals, "Resume")
-
 }
@@ -15,21 +15,72 @@ package types

 import (
 	"encoding/json"
+	"fmt"
 	"html/template"
+	"reflect"
+	"time"

 	"github.com/spf13/cast"
 )

-// ToStringSlicePreserveString converts v to a string slice.
-// If v is a string, it will be wrapped in a string slice.
+// ToDuration converts v to time.Duration.
+// See ToDurationE if you need to handle errors.
+func ToDuration(v interface{}) time.Duration {
+	d, _ := ToDurationE(v)
+	return d
+}
+
+// ToDurationE converts v to time.Duration.
+func ToDurationE(v interface{}) (time.Duration, error) {
+	if n := cast.ToInt(v); n > 0 {
+		return time.Duration(n) * time.Millisecond, nil
+	}
+	d, err := time.ParseDuration(cast.ToString(v))
+	if err != nil {
+		return 0, fmt.Errorf("cannot convert %v to time.Duration", v)
+	}
+	return d, nil
+}
+
+// ToStringSlicePreserveString is the same as ToStringSlicePreserveStringE,
+// but it never fails.
 func ToStringSlicePreserveString(v interface{}) []string {
+	vv, _ := ToStringSlicePreserveStringE(v)
+	return vv
+}
+
+// ToStringSlicePreserveStringE converts v to a string slice.
+// If v is a string, it will be wrapped in a string slice.
+func ToStringSlicePreserveStringE(v interface{}) ([]string, error) {
 	if v == nil {
-		return nil
+		return nil, nil
 	}
 	if sds, ok := v.(string); ok {
-		return []string{sds}
+		return []string{sds}, nil
 	}
-	return cast.ToStringSlice(v)
+	result, err := cast.ToStringSliceE(v)
+	if err == nil {
+		return result, nil
+	}
+
+	// Probably []int or similar. Fall back to reflect.
+	vv := reflect.ValueOf(v)
+
+	switch vv.Kind() {
+	case reflect.Slice, reflect.Array:
+		result = make([]string, vv.Len())
+		for i := 0; i < vv.Len(); i++ {
+			s, err := cast.ToStringE(vv.Index(i).Interface())
+			if err != nil {
+				return nil, err
+			}
+			result[i] = s
+		}
+		return result, nil
+	default:
+		return nil, fmt.Errorf("failed to convert %T to a string slice", v)
+	}
+
 }

 // TypeToString converts v to a string if it's a valid string type.
@@ -16,6 +16,7 @@ package types
 import (
 	"encoding/json"
 	"testing"
+	"time"

 	qt "github.com/frankban/quicktest"
 )
@@ -24,9 +25,10 @@ func TestToStringSlicePreserveString(t *testing.T) {
 	c := qt.New(t)

 	c.Assert(ToStringSlicePreserveString("Hugo"), qt.DeepEquals, []string{"Hugo"})
+	c.Assert(ToStringSlicePreserveString(qt.Commentf("Hugo")), qt.DeepEquals, []string{"Hugo"})
 	c.Assert(ToStringSlicePreserveString([]interface{}{"A", "B"}), qt.DeepEquals, []string{"A", "B"})
+	c.Assert(ToStringSlicePreserveString([]int{1, 3}), qt.DeepEquals, []string{"1", "3"})
 	c.Assert(ToStringSlicePreserveString(nil), qt.IsNil)
-
 }

 func TestToString(t *testing.T) {
@@ -34,5 +36,14 @@ func TestToString(t *testing.T) {

 	c.Assert(ToString([]byte("Hugo")), qt.Equals, "Hugo")
 	c.Assert(ToString(json.RawMessage("Hugo")), qt.Equals, "Hugo")
+}
+
+func TestToDuration(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(ToDuration("200ms"), qt.Equals, 200*time.Millisecond)
+	c.Assert(ToDuration("200"), qt.Equals, 200*time.Millisecond)
+	c.Assert(ToDuration("4m"), qt.Equals, 4*time.Minute)
+	c.Assert(ToDuration("asdfadf"), qt.Equals, time.Duration(0))

 }
@@ -27,6 +27,12 @@ type RLocker interface {
 	RUnlock()
 }

+// KeyValue is a interface{} tuple.
+type KeyValue struct {
+	Key   interface{}
+	Value interface{}
+}
+
 // KeyValueStr is a string tuple.
 type KeyValueStr struct {
 	Key   string
@@ -61,5 +61,4 @@ func TestLexicographicSort(t *testing.T) {
 	})

 	c.Assert(s, qt.DeepEquals, []string{"A", "b", "Ba", "ba", "ba", "Bz"})
-
 }
@@ -14,12 +14,12 @@
 package config

 import (
-	"github.com/pkg/errors"
-
 	"sort"
 	"strings"
 	"sync"

+	"github.com/pkg/errors"
+
 	"github.com/gohugoio/hugo/common/types"

 	"github.com/gobwas/glob"
@@ -34,13 +34,17 @@ var DefaultBuild = Build{
 	WriteStats:           false,
 }

-// Build holds some build related condfiguration.
+// Build holds some build related configuration.
 type Build struct {
 	UseResourceCacheWhen string // never, fallback, always. Default is fallback

 	// When enabled, will collect and write a hugo_stats.json with some build
 	// related aggregated data (e.g. CSS class names).
 	WriteStats bool
+
+	// Can be used to toggle off writing of the intellinsense /assets/jsconfig.js
+	// file.
+	NoJSConfigInAssets bool
 }

 func (b Build) UseResourceCache(err error) bool {
@@ -84,7 +88,6 @@ type Sitemap struct {
 }

 func DecodeSitemap(prototype Sitemap, input map[string]interface{}) Sitemap {
-
 	for key, value := range input {
 		switch key {
 		case "changefreq":
@@ -112,7 +115,6 @@ type Server struct {
 }

 func (s *Server) init() {
-
 	s.compiledInit.Do(func() {
 		for _, h := range s.Headers {
 			s.compiledHeaders = append(s.compiledHeaders, glob.MustCompile(h.For))
@@ -146,7 +148,6 @@ func (s *Server) MatchHeaders(pattern string) []types.KeyValueStr {
 	})

 	return matches
-
 }

 func (s *Server) MatchRedirect(pattern string) Redirect {
@@ -172,7 +173,6 @@ func (s *Server) MatchRedirect(pattern string) Redirect {
 	}

 	return Redirect{}
-
 }

 type Headers struct {
@@ -21,14 +21,12 @@ import (
 	"github.com/gohugoio/hugo/common/types"

 	qt "github.com/frankban/quicktest"
-
-	"github.com/spf13/viper"
 )

 func TestBuild(t *testing.T) {
 	c := qt.New(t)

-	v := viper.New()
+	v := New()
 	v.Set("build", map[string]interface{}{
 		"useResourceCacheWhen": "always",
 	})
@@ -57,7 +55,6 @@ func TestBuild(t *testing.T) {
 	c.Assert(b.UseResourceCache(herrors.ErrFeatureNotAvailable), qt.Equals, false)
 	c.Assert(b.UseResourceCache(errors.New("err")), qt.Equals, false)
 	c.Assert(b.UseResourceCache(nil), qt.Equals, false)
-
 }

 func TestServer(t *testing.T) {
@@ -98,7 +95,8 @@ status = 301
 	c.Assert(s.MatchHeaders("/foo.jpg"), qt.DeepEquals, []types.KeyValueStr{
 		{Key: "X-Content-Type-Options", Value: "nosniff"},
 		{Key: "X-Frame-Options", Value: "DENY"},
-		{Key: "X-XSS-Protection", Value: "1; mode=block"}})
+		{Key: "X-XSS-Protection", Value: "1; mode=block"},
+	})

 	c.Assert(s.MatchRedirect("/foo/bar/baz"), qt.DeepEquals, Redirect{
 		From:   "/foo/**",
@@ -122,7 +120,8 @@ status = 301
 	c.Assert(s.MatchRedirect("/default/index.html"), qt.DeepEquals, Redirect{})
 	c.Assert(s.MatchRedirect("/default/"), qt.DeepEquals, Redirect{})

-	for _, errorCase := range []string{`[[server.redirects]]
+	for _, errorCase := range []string{
+		`[[server.redirects]]
 from = "/**"
 to = "/file"
 status = 301`,
@@ -138,5 +137,4 @@ status = 301`,
 		c.Assert(err, qt.Not(qt.IsNil))

 	}
-
 }
@@ -0,0 +1,117 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package config
+
+import (
+	"github.com/gohugoio/hugo/common/maps"
+)
+
+// NewCompositeConfig creates a new composite Provider with a read-only base
+// and a writeable layer.
+func NewCompositeConfig(base, layer Provider) Provider {
+	return &compositeConfig{
+		base:  base,
+		layer: layer,
+	}
+}
+
+// compositeConfig contains a read only config base with
+// a possibly writeable config layer on top.
+type compositeConfig struct {
+	base  Provider
+	layer Provider
+}
+
+func (c *compositeConfig) GetBool(key string) bool {
+	if c.layer.IsSet(key) {
+		return c.layer.GetBool(key)
+	}
+	return c.base.GetBool(key)
+}
+
+func (c *compositeConfig) GetInt(key string) int {
+	if c.layer.IsSet(key) {
+		return c.layer.GetInt(key)
+	}
+	return c.base.GetInt(key)
+}
+
+func (c *compositeConfig) Merge(key string, value interface{}) {
+	c.layer.Merge(key, value)
+}
+
+func (c *compositeConfig) GetParams(key string) maps.Params {
+	if c.layer.IsSet(key) {
+		return c.layer.GetParams(key)
+	}
+	return c.base.GetParams(key)
+}
+
+func (c *compositeConfig) GetStringMap(key string) map[string]interface{} {
+	if c.layer.IsSet(key) {
+		return c.layer.GetStringMap(key)
+	}
+	return c.base.GetStringMap(key)
+}
+
+func (c *compositeConfig) GetStringMapString(key string) map[string]string {
+	if c.layer.IsSet(key) {
+		return c.layer.GetStringMapString(key)
+	}
+	return c.base.GetStringMapString(key)
+}
+
+func (c *compositeConfig) GetStringSlice(key string) []string {
+	if c.layer.IsSet(key) {
+		return c.layer.GetStringSlice(key)
+	}
+	return c.base.GetStringSlice(key)
+}
+
+func (c *compositeConfig) Get(key string) interface{} {
+	if c.layer.IsSet(key) {
+		return c.layer.Get(key)
+	}
+	return c.base.Get(key)
+}
+
+func (c *compositeConfig) IsSet(key string) bool {
+	if c.layer.IsSet(key) {
+		return true
+	}
+	return c.base.IsSet(key)
+}
+
+func (c *compositeConfig) GetString(key string) string {
+	if c.layer.IsSet(key) {
+		return c.layer.GetString(key)
+	}
+	return c.base.GetString(key)
+}
+
+func (c *compositeConfig) Set(key string, value interface{}) {
+	c.layer.Set(key, value)
+}
+
+func (c *compositeConfig) SetDefaults(params maps.Params) {
+	c.layer.SetDefaults(params)
+}
+
+func (c *compositeConfig) WalkParams(walkFn func(params ...KeyParams) bool) {
+	panic("not supported")
+}
+
+func (c *compositeConfig) SetDefaultMergeStrategy() {
+	panic("not supported")
+}
@@ -0,0 +1,40 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package config
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestCompositeConfig(t *testing.T) {
+	c := qt.New(t)
+
+	c.Run("Set and get", func(c *qt.C) {
+		base, layer := New(), New()
+		cfg := NewCompositeConfig(base, layer)
+
+		layer.Set("a1", "av")
+		base.Set("b1", "bv")
+		cfg.Set("c1", "cv")
+
+		c.Assert(cfg.Get("a1"), qt.Equals, "av")
+		c.Assert(cfg.Get("b1"), qt.Equals, "bv")
+		c.Assert(cfg.Get("c1"), qt.Equals, "cv")
+		c.Assert(cfg.IsSet("c1"), qt.IsTrue)
+		c.Assert(layer.IsSet("c1"), qt.IsTrue)
+		c.Assert(base.IsSet("c1"), qt.IsFalse)
+	})
+}
@@ -14,13 +14,19 @@
 package config

 import (
+	"os"
 	"path/filepath"
 	"strings"

+	"github.com/gohugoio/hugo/common/herrors"
+
+	"github.com/pkg/errors"
+
+	"github.com/gohugoio/hugo/common/paths"
+
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/parser/metadecoders"
 	"github.com/spf13/afero"
-	"github.com/spf13/viper"
 )

 var (
@@ -43,32 +49,20 @@ func IsValidConfigFilename(filename string) bool {

 // FromConfigString creates a config from the given YAML, JSON or TOML config. This is useful in tests.
 func FromConfigString(config, configType string) (Provider, error) {
-	v := newViper()
 	m, err := readConfig(metadecoders.FormatFromString(configType), []byte(config))
 	if err != nil {
 		return nil, err
 	}
-
-	v.MergeConfigMap(m)
-
-	return v, nil
+	return NewFrom(m), nil
 }

 // FromFile loads the configuration from the given filename.
 func FromFile(fs afero.Fs, filename string) (Provider, error) {
 	m, err := loadConfigFromFile(fs, filename)
 	if err != nil {
-		return nil, err
+		return nil, herrors.WithFileContextForFileDefault(err, filename, fs)
 	}
-
-	v := newViper()
-
-	err = v.MergeConfigMap(m)
-	if err != nil {
-		return nil, err
-	}
-
-	return v, nil
+	return NewFrom(m), nil
 }

 // FromFileToMap is the same as FromFile, but it returns the config values
@@ -86,7 +80,6 @@ func readConfig(format metadecoders.Format, data []byte) (map[string]interface{}
 	RenameKeys(m)

 	return m, nil
-
 }

 func loadConfigFromFile(fs afero.Fs, filename string) (map[string]interface{}, error) {
@@ -98,6 +91,102 @@ func loadConfigFromFile(fs afero.Fs, filename string) (map[string]interface{}, e
 	return m, nil
 }

+func LoadConfigFromDir(sourceFs afero.Fs, configDir, environment string) (Provider, []string, error) {
+	defaultConfigDir := filepath.Join(configDir, "_default")
+	environmentConfigDir := filepath.Join(configDir, environment)
+	cfg := New()
+
+	var configDirs []string
+	// Merge from least to most specific.
+	for _, dir := range []string{defaultConfigDir, environmentConfigDir} {
+		if _, err := sourceFs.Stat(dir); err == nil {
+			configDirs = append(configDirs, dir)
+		}
+	}
+
+	if len(configDirs) == 0 {
+		return nil, nil, nil
+	}
+
+	// Keep track of these so we can watch them for changes.
+	var dirnames []string
+
+	for _, configDir := range configDirs {
+		err := afero.Walk(sourceFs, configDir, func(path string, fi os.FileInfo, err error) error {
+			if fi == nil || err != nil {
+				return nil
+			}
+
+			if fi.IsDir() {
+				dirnames = append(dirnames, path)
+				return nil
+			}
+
+			if !IsValidConfigFilename(path) {
+				return nil
+			}
+
+			name := paths.Filename(filepath.Base(path))
+
+			item, err := metadecoders.Default.UnmarshalFileToMap(sourceFs, path)
+			if err != nil {
+				// This will be used in error reporting, use the most specific value.
+				dirnames = []string{path}
+				return errors.Wrapf(err, "failed to unmarshl config for path %q", path)
+			}
+
+			var keyPath []string
+
+			if name != "config" {
+				// Can be params.jp, menus.en etc.
+				name, lang := paths.FileAndExtNoDelimiter(name)
+
+				keyPath = []string{name}
+
+				if lang != "" {
+					keyPath = []string{"languages", lang}
+					switch name {
+					case "menu", "menus":
+						keyPath = append(keyPath, "menus")
+					case "params":
+						keyPath = append(keyPath, "params")
+					}
+				}
+			}
+
+			root := item
+			if len(keyPath) > 0 {
+				root = make(map[string]interface{})
+				m := root
+				for i, key := range keyPath {
+					if i >= len(keyPath)-1 {
+						m[key] = item
+					} else {
+						nm := make(map[string]interface{})
+						m[key] = nm
+						m = nm
+					}
+				}
+			}
+
+			// Migrate menu => menus etc.
+			RenameKeys(root)
+
+			// Set will overwrite keys with the same name, recursively.
+			cfg.Set("", root)
+
+			return nil
+		})
+		if err != nil {
+			return nil, dirnames, err
+		}
+
+	}
+
+	return cfg, dirnames, nil
+
+}
+
 var keyAliases maps.KeyRenamer

 func init() {
@@ -117,9 +206,3 @@ func init() {
 func RenameKeys(m map[string]interface{}) {
 	keyAliases.Rename(m)
 }
-
-func newViper() *viper.Viper {
-	v := viper.New()
-
-	return v
-}
@@ -14,6 +14,7 @@
 package config

 import (
+	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/types"
 )

@@ -22,11 +23,16 @@ type Provider interface {
 	GetString(key string) string
 	GetInt(key string) int
 	GetBool(key string) bool
+	GetParams(key string) maps.Params
 	GetStringMap(key string) map[string]interface{}
 	GetStringMapString(key string) map[string]string
 	GetStringSlice(key string) []string
 	Get(key string) interface{}
 	Set(key string, value interface{})
+	Merge(key string, value interface{})
+	SetDefaults(params maps.Params)
+	SetDefaultMergeStrategy()
+	WalkParams(walkFn func(params ...KeyParams) bool)
 	IsSet(key string) bool
 }

@@ -17,12 +17,11 @@ import (
 	"testing"

 	qt "github.com/frankban/quicktest"
-	"github.com/spf13/viper"
 )

 func TestGetStringSlicePreserveString(t *testing.T) {
 	c := qt.New(t)
-	cfg := viper.New()
+	cfg := New()

 	s := "This is a string"
 	sSlice := []string{"This", "is", "a", "slice"}
--- a/Show More
+++ b/Show More