releaser: Add release notes to /docs for release of 0.53

[ci skip]

.circleci/config.yml

@@ -1,8 +1,9 @@
 defaults: &defaults
-  working_directory: /go/src/github.com/gohugoio
   docker:
-      - image: bepsays/ci-goreleaser:0.34.2-11
-    
+      - image: bepsays/ci-goreleaser:1.11-3
+  environment:
+    CGO_ENABLED: "0"
+
 version: 2
 jobs:
   build:
@@ -12,11 +13,11 @@ jobs:
           path: hugo
       - run:
             command: |
-                go get -d github.com/magefile/mage/...
                 git clone git@github.com:gohugoio/hugoDocs.git
                 cd hugo
-                mage vendor
-                mage check
+                go mod download
+                sleep 5
+                go test -p 1 ./...
       - persist_to_workspace:
           root: .
           paths: .
@@ -24,7 +25,7 @@ jobs:
     <<: *defaults
     steps:
       - attach_workspace:
-          at: /go/src/github.com/gohugoio
+          at: /root/project
       - run:
             command: |
                     cd hugo

.gitattributes

@@ -3,3 +3,6 @@
 
 # Go source files always have LF line endings
 *.go text eol=lf
+
+# SVG files should not be modified
+*.svg -text

.gitignore

@@ -1,4 +1,4 @@
-hugo
+/hugo
 docs/public*
 /.idea
 hugo.exe
@@ -19,3 +19,6 @@ dock.sh
 
 GoBuilds
 dist
+
+
+vendor

.travis.yml

@@ -2,29 +2,43 @@ language: go
 sudo: false
 dist: trusty
 env:
-  HUGO_BUILD_TAGS="extended"
+  global:
+  - HUGO_BUILD_TAGS="extended"
 git:
   depth: false
 go:
-  - 1.9.7
-  - "1.10.3"
+  - "1.11.4"
   - tip
 os:
   - linux
   - osx
+  - windows
 matrix:
   allow_failures:
     - go: tip
   fast_finish: true
+  exclude:
+  - os: windows
+    go: tip
+
 install:
+  - mkdir -p $HOME/src
+  - mv $HOME/gopath/src/github.com/gohugoio/hugo $HOME/src
+  - export TRAVIS_BUILD_DIR=$HOME/src/hugo
+  - cd $HOME/src/hugo
   - go get github.com/magefile/mage
-  - mage -v vendor
 script:
+  - go mod download
   - mage -v test
   - mage -v check
   - mage -v hugo
   - ./hugo -s docs/
   - ./hugo --renderToMemory -s docs/
+  - df -h
+
 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

CONTRIBUTING.md

@@ -18,11 +18,8 @@ The Hugo community and maintainers are [very active](https://github.com/gohugoio
 * [Submitting Patches](#submitting-patches)
   * [Code Contribution Guidelines](#code-contribution-guidelines)
   * [Git Commit Message Guidelines](#git-commit-message-guidelines)
-  * [Vendored Dependencies](#vendored-dependencies)
   * [Fetching the Sources From GitHub](#fetching-the-sources-from-github)
-  * [Using Git Remotes](#using-git-remotes)
-  * [Build Hugo with Your Changes](#build-hugo-with-your-changes)
-  * [Updating the Hugo Sources](#updating-the-hugo-sources)
+  * [Building Hugo with Your Changes](#building-hugo-with-your-changes)
 
 ## Asking Support Questions
 
@@ -73,7 +70,7 @@ To make the contribution process as seamless as possible, we ask for the followi
     * Run `go fmt`.
     * Add documentation if you are adding new features or changing functionality.  The docs site lives in `/docs`.
     * Squash your commits into a single commit. `git rebase -i`. It’s okay to force update your pull request with `git push -f`.
-    * Ensure that `mage check` succeeds. [Travis CI](https://travis-ci.org/gohugoio/hugo) (Linux and macOS) and [AppVeyor](https://ci.appveyor.com/project/gohugoio/hugo/branch/master) (Windows) will fail the build if `mage check` fails.
+    * Ensure that `mage check` succeeds. [Travis CI](https://travis-ci.org/gohugoio/hugo) (Windows, Linux and macOS) will fail the build if `mage check` fails.
     * Follow the **Git Commit Message Guidelines** below.
 
 ### Git Commit Message Guidelines
@@ -106,30 +103,25 @@ Fixes #1949
 
 ###  Fetching the Sources From GitHub
 
-Due to the way Go handles package imports, the best approach for working on a
-Hugo fork is to use Git Remotes.  Here's a simple walk-through for getting
-started:
+Since Hugo 0.48, Hugo uses the Go Modules support built into Go 1.11 to build. The easiest is to clone Hugo in a directory outside of `GOPATH`, as in the following example:
 
-1. Get the Hugo source:
+```bash
+mkdir $HOME/src
+cd $HOME/src
+git clone https://github.com/gohugoio/hugo.git
+cd hugo
+go install
+```
 
-    ```bash
-    go get -u -v -d github.com/gohugoio/hugo
-    ```
+>Note: Some Go tools may not be fully updated to support Go Modules yet. One example would be LiteIDE. Follow [this workaround](https://github.com/visualfc/liteide/issues/986#issuecomment-428117702) for how to continue to work with Hugo below `GOPATH`.
 
-1. Install Mage:
+For some convenient build and test targets, you also will want to install Mage:
 
-    ```bash
-    go get github.com/magefile/mage
-    ```
+```bash
+go get github.com/magefile/mage
+```
 
-1. Change to the Hugo source directory and fetch the dependencies:
-
-    ```bash
-    cd $HOME/go/src/github.com/gohugoio/hugo
-    mage vendor
-    ```
-
-    Note that Hugo uses [Go Dep](https://github.com/golang/dep) to vendor dependencies, rather than a simple `go get`. We don't commit the vendored packages themselves to the Hugo git repository. The call to `mage vendor` takes care of all this for you.
+Now, to make a change to Hugo's source:
 
 1. Create a new branch for your changes (the branch name is arbitrary):
 
@@ -167,7 +159,7 @@ Hugo uses [mage](https://github.com/magefile/mage) to sync vendor dependencies,
 cd $HOME/go/src/github.com/gohugoio/hugo
 ```
 
-To build Hugo: 
+To build Hugo:
 
 ```bash
 mage hugo
@@ -197,15 +189,3 @@ mage -l
 ```bash
 HUGO_BUILD_TAGS=extended mage install
 ````
-
-### Updating the Hugo Sources
-
-If you want to stay in sync with the Hugo repository, you can easily pull down
-the source changes, but you'll need to keep the vendored packages up-to-date as
-well.
-
-```bash
-git pull
-mage vendor
-```
-

Dockerfile

@@ -2,19 +2,18 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/
 
-FROM golang:1.10.3-alpine3.7 AS build
+FROM golang:1.11-alpine3.7 AS build
 
 ENV CGO_ENABLED=0
 ENV GOOS=linux
+ENV GO111MODULE=on
 
 WORKDIR /go/src/github.com/gohugoio/hugo
 RUN apk add --no-cache \
     git \
-    musl-dev && \
-  go get github.com/golang/dep/cmd/dep
+    musl-dev
 COPY . /go/src/github.com/gohugoio/hugo/
-RUN dep ensure -vendor-only && \
-  go install -ldflags '-s -w'
+RUN go install -ldflags '-s -w'
 
 # ---
 

Gopkg.lock

@@ -1,530 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  branch = "master"
-  name = "github.com/BurntSushi/locker"
-  packages = ["."]
-  revision = "a6e239ea1c69bff1cfdb20c4b73dadf52f784b6a"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/BurntSushi/toml"
-  packages = ["."]
-  revision = "a368813c5e648fee92e5f6c30e3944ff9d5e8895"
-
-[[projects]]
-  name = "github.com/PuerkitoBio/purell"
-  packages = ["."]
-  revision = "0bcb03f4b4d0a9428594752bd2a3b9aa0a9d4bd4"
-  version = "v1.1.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/PuerkitoBio/urlesc"
-  packages = ["."]
-  revision = "de5bf2ad457846296e2031421a34e2568e304e35"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/alecthomas/assert"
-  packages = ["."]
-  revision = "405dbfeb8e38effee6e723317226e93fff912d06"
-
-[[projects]]
-  name = "github.com/alecthomas/chroma"
-  packages = [
-    ".",
-    "formatters",
-    "formatters/html",
-    "lexers",
-    "lexers/a",
-    "lexers/b",
-    "lexers/c",
-    "lexers/circular",
-    "lexers/d",
-    "lexers/e",
-    "lexers/f",
-    "lexers/g",
-    "lexers/h",
-    "lexers/i",
-    "lexers/internal",
-    "lexers/j",
-    "lexers/k",
-    "lexers/l",
-    "lexers/m",
-    "lexers/n",
-    "lexers/o",
-    "lexers/p",
-    "lexers/q",
-    "lexers/r",
-    "lexers/s",
-    "lexers/t",
-    "lexers/v",
-    "lexers/w",
-    "lexers/x",
-    "lexers/y",
-    "styles"
-  ]
-  revision = "1b755a90bd109f170385cb3964f0abdfd3451145"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/alecthomas/colour"
-  packages = ["."]
-  revision = "60882d9e27213e8552dcff6328914fe4c2b44bc9"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/alecthomas/repr"
-  packages = ["."]
-  revision = "f49988b46e025398b9f834f7c726afe001ec481f"
-
-[[projects]]
-  name = "github.com/bep/debounce"
-  packages = ["."]
-  revision = "844797fa1dd9ba969d71b62797ff19d1e49d4eac"
-  version = "v1.1.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/bep/gitmap"
-  packages = ["."]
-  revision = "012701e8669671499fc43e9792335a1dcbfe2afb"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/bep/go-tocss"
-  packages = [
-    "scss",
-    "scss/libsass",
-    "tocss"
-  ]
-  revision = "2abb118dc8688b6c7df44e12f4152c2bded9b19c"
-
-[[projects]]
-  name = "github.com/chaseadamsio/goorgeous"
-  packages = ["."]
-  revision = "dcf1ef873b8987bf12596fe6951c48347986eb2f"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "github.com/cpuguy83/go-md2man"
-  packages = ["md2man"]
-  revision = "a65d4d2de4d5f7c74868dfa9b202a3c8be315aaa"
-  version = "v1.0.6"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/danwakefield/fnmatch"
-  packages = ["."]
-  revision = "cbb64ac3d964b81592e64f957ad53df015803288"
-
-[[projects]]
-  name = "github.com/davecgh/go-spew"
-  packages = ["spew"]
-  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "github.com/disintegration/imaging"
-  packages = ["."]
-  revision = "dd50a3ee9985ccd313a2f03c398fcaedc96dc707"
-  version = "v1.2.4"
-
-[[projects]]
-  name = "github.com/dlclark/regexp2"
-  packages = [
-    ".",
-    "syntax"
-  ]
-  revision = "487489b64fb796de2e55f4e8a4ad1e145f80e957"
-  version = "v1.1.6"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/dsnet/golib"
-  packages = ["memfile"]
-  revision = "1ea1667757804fdcccc5a1810e09aba618885ac2"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/eknkc/amber"
-  packages = [
-    ".",
-    "parser"
-  ]
-  revision = "cdade1c073850f4ffc70a829e31235ea6892853b"
-
-[[projects]]
-  name = "github.com/fortytw2/leaktest"
-  packages = ["."]
-  revision = "a5ef70473c97b71626b9abeda80ee92ba2a7de9e"
-  version = "v1.2.0"
-
-[[projects]]
-  name = "github.com/fsnotify/fsnotify"
-  packages = ["."]
-  revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
-  version = "v1.4.7"
-
-[[projects]]
-  name = "github.com/gobwas/glob"
-  packages = [
-    ".",
-    "compiler",
-    "match",
-    "syntax",
-    "syntax/ast",
-    "syntax/lexer",
-    "util/runes",
-    "util/strings"
-  ]
-  revision = "5ccd90ef52e1e632236f7326478d4faa74f99438"
-  version = "v0.2.3"
-
-[[projects]]
-  name = "github.com/gorilla/websocket"
-  packages = ["."]
-  revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b"
-  version = "v1.2.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/hashicorp/go-immutable-radix"
-  packages = ["."]
-  revision = "7f3cd4390caab3250a57f30efdb2a65dd7649ecf"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/hashicorp/golang-lru"
-  packages = ["simplelru"]
-  revision = "0fb14efe8c47ae851c0034ed7a448854d3d34cf3"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/hashicorp/hcl"
-  packages = [
-    ".",
-    "hcl/ast",
-    "hcl/parser",
-    "hcl/printer",
-    "hcl/scanner",
-    "hcl/strconv",
-    "hcl/token",
-    "json/parser",
-    "json/scanner",
-    "json/token"
-  ]
-  revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168"
-
-[[projects]]
-  name = "github.com/inconshreveable/mousetrap"
-  packages = ["."]
-  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
-  version = "v1.0"
-
-[[projects]]
-  name = "github.com/jdkato/prose"
-  packages = [
-    "internal/util",
-    "transform"
-  ]
-  revision = "20d3663d4bc9dd10d75abcde9d92e04b4861c674"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "github.com/kyokomi/emoji"
-  packages = ["."]
-  revision = "7e06b236c489543f53868841f188a294e3383eab"
-  version = "v1.5"
-
-[[projects]]
-  name = "github.com/magefile/mage"
-  packages = [
-    "mg",
-    "sh"
-  ]
-  revision = "2f974307b636f59c13b88704cf350a4772fef271"
-  version = "v1.0.2"
-
-[[projects]]
-  name = "github.com/magiconair/properties"
-  packages = ["."]
-  revision = "c3beff4c2358b44d0493c7dda585e7db7ff28ae6"
-  version = "v1.7.6"
-
-[[projects]]
-  name = "github.com/markbates/inflect"
-  packages = ["."]
-  revision = "a12c3aec81a6a938bf584a4bac567afed9256586"
-
-[[projects]]
-  name = "github.com/mattn/go-isatty"
-  packages = ["."]
-  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
-  version = "v0.0.3"
-
-[[projects]]
-  name = "github.com/mattn/go-runewidth"
-  packages = ["."]
-  revision = "9e777a8366cce605130a531d2cd6363d07ad7317"
-  version = "v0.0.2"
-
-[[projects]]
-  name = "github.com/miekg/mmark"
-  packages = ["."]
-  revision = "fd2f6c1403b37925bd7fe13af05853b8ae58ee5f"
-  version = "v1.3.6"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/mitchellh/hashstructure"
-  packages = ["."]
-  revision = "2bca23e0e452137f789efbc8610126fd8b94f73b"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/mitchellh/mapstructure"
-  packages = ["."]
-  revision = "00c29f56e2386353d58c599509e8dc3801b0d716"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/muesli/smartcrop"
-  packages = [
-    ".",
-    "options"
-  ]
-  revision = "f6ebaa786a12a0fdb2d7c6dee72808e68c296464"
-
-[[projects]]
-  name = "github.com/nicksnyder/go-i18n"
-  packages = [
-    "i18n/bundle",
-    "i18n/language",
-    "i18n/translation"
-  ]
-  revision = "0dc1626d56435e9d605a29875701721c54bc9bbd"
-  version = "v1.10.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/olekukonko/tablewriter"
-  packages = ["."]
-  revision = "b8a9be070da40449e501c3c4730a889e42d87a9e"
-
-[[projects]]
-  name = "github.com/pelletier/go-toml"
-  packages = ["."]
-  revision = "acdc4509485b587f5e675510c4f2c63e90ff68a8"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "github.com/pmezard/go-difflib"
-  packages = ["difflib"]
-  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
-  version = "v1.0.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/russross/blackfriday"
-  packages = ["."]
-  revision = "11635eb403ff09dbc3a6b5a007ab5ab09151c229"
-
-[[projects]]
-  name = "github.com/sanity-io/litter"
-  packages = ["."]
-  revision = "ae543b7ba8fd6af63e4976198f146e1348ae53c1"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "github.com/sergi/go-diff"
-  packages = ["diffmatchpatch"]
-  revision = "1744e2970ca51c86172c8190fadad617561ed6e7"
-  version = "v1.0.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/shurcooL/sanitized_anchor_name"
-  packages = ["."]
-  revision = "86672fcb3f950f35f2e675df2240550f2a50762f"
-
-[[projects]]
-  name = "github.com/spf13/afero"
-  packages = [
-    ".",
-    "mem"
-  ]
-  revision = "787d034dfe70e44075ccc060d346146ef53270ad"
-  version = "v1.1.1"
-
-[[projects]]
-  name = "github.com/spf13/cast"
-  packages = ["."]
-  revision = "8965335b8c7107321228e3e3702cab9832751bac"
-  version = "v1.2.0"
-
-[[projects]]
-  name = "github.com/spf13/cobra"
-  packages = [
-    ".",
-    "doc"
-  ]
-  revision = "a1f051bc3eba734da4772d60e2d677f47cf93ef4"
-  version = "v0.0.2"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/spf13/fsync"
-  packages = ["."]
-  revision = "12a01e648f05a938100a26858d2d59a120307a18"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/spf13/jwalterweatherman"
-  packages = ["."]
-  revision = "7c0cea34c8ece3fbeb2b27ab9b59511d360fb394"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/spf13/nitro"
-  packages = ["."]
-  revision = "24d7ef30a12da0bdc5e2eb370a79c659ddccf0e8"
-
-[[projects]]
-  name = "github.com/spf13/pflag"
-  packages = ["."]
-  revision = "e57e3eeb33f795204c1ca35f56c44f83227c6e66"
-  version = "v1.0.0"
-
-[[projects]]
-  name = "github.com/spf13/viper"
-  packages = ["."]
-  revision = "b5e8006cbee93ec955a89ab31e0e3ce3204f3736"
-  version = "v1.0.2"
-
-[[projects]]
-  name = "github.com/stretchr/testify"
-  packages = [
-    "assert",
-    "require"
-  ]
-  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
-  version = "v1.2.1"
-
-[[projects]]
-  name = "github.com/tdewolff/minify"
-  packages = [
-    ".",
-    "css",
-    "html",
-    "js",
-    "json",
-    "svg",
-    "xml"
-  ]
-  revision = "8d72a4127ae33b755e95bffede9b92e396267ce2"
-  version = "v2.3.5"
-
-[[projects]]
-  name = "github.com/tdewolff/parse"
-  packages = [
-    ".",
-    "buffer",
-    "css",
-    "html",
-    "js",
-    "json",
-    "strconv",
-    "svg",
-    "xml"
-  ]
-  revision = "d739d6fccb0971177e06352fea02d3552625efb1"
-  version = "v2.3.3"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/wellington/go-libsass"
-  packages = ["libs"]
-  revision = "615eaa47ef794d037c1906a0eb7bf85375a5decf"
-
-[[projects]]
-  name = "github.com/yosssi/ace"
-  packages = ["."]
-  revision = "ea038f4770b6746c3f8f84f14fa60d9fe1205b56"
-  version = "v0.0.5"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/image"
-  packages = [
-    "bmp",
-    "draw",
-    "math/f64",
-    "riff",
-    "tiff",
-    "tiff/lzw",
-    "vp8",
-    "vp8l",
-    "webp"
-  ]
-  revision = "f315e440302883054d0c2bd85486878cb4f8572c"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/net"
-  packages = [
-    "context",
-    "idna"
-  ]
-  revision = "61147c48b25b599e5b561d2e9c4f3e1ef489ca41"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/sync"
-  packages = ["errgroup"]
-  revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/sys"
-  packages = ["unix"]
-  revision = "3b87a42e500a6dc65dae1a55d0b641295971163e"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/text"
-  packages = [
-    "collate",
-    "collate/build",
-    "internal/colltab",
-    "internal/gen",
-    "internal/language",
-    "internal/language/compact",
-    "internal/tag",
-    "internal/triegen",
-    "internal/ucd",
-    "language",
-    "secure/bidirule",
-    "transform",
-    "unicode/bidi",
-    "unicode/cldr",
-    "unicode/norm",
-    "unicode/rangetable",
-    "width"
-  ]
-  revision = "2cb43934f0eece38629746959acc633cba083fe4"
-
-[[projects]]
-  branch = "v2"
-  name = "gopkg.in/yaml.v2"
-  packages = ["."]
-  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  inputs-digest = "993acf46c3937e5cebef4f39a2733150aad7cbf96913a017e56cd03c8241a56e"
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,171 +0,0 @@
-
-
-[[constraint]]
-  name = "github.com/BurntSushi/toml"
-  branch = "master"
-
-[[constraint]]
-  name = "github.com/PuerkitoBio/purell"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "github.com/alecthomas/chroma"
-  revision = "1b755a90bd109f170385cb3964f0abdfd3451145"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/bep/gitmap"
-  
-[[constraint]]
-   branch = "master"
-   name = "github.com/bep/go-tocss"
-
-[[override]]
-   branch = "master"
-   name = "github.com/wellington/go-libsass"
- 
-[[constraint]]
- name = "github.com/chaseadamsio/goorgeous"
- version = "^1.1.0"
-
-[[constraint]]
- name = "github.com/disintegration/imaging"
- version = "~v1.2.4"
-
-[[constraint]]
-  name = "github.com/magefile/mage"
-  version = "v1"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/eknkc/amber"
-
-[[constraint]]
-  name = "github.com/fortytw2/leaktest"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "github.com/fsnotify/fsnotify"
-  version = "^1.4.0"
-
-[[constraint]]
-  name = "github.com/gorilla/websocket"
-  version = "1.2.0"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/hashicorp/go-immutable-radix"
-
-[[constraint]]
-  name = "github.com/jdkato/prose"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "github.com/kyokomi/emoji"
-  version = "1.5.0"
-
-[[constraint]]
-  name = "github.com/markbates/inflect"
-  revision = "a12c3aec81a6a938bf584a4bac567afed9256586"
-
-[[constraint]]
-  name = "github.com/miekg/mmark"
-  version = "^1.3.6"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/mitchellh/mapstructure"
-
-[[constraint]]
-  name = "github.com/nicksnyder/go-i18n"
-  version = "^1.10.0"
-
-[[constraint]]
-  name = "github.com/russross/blackfriday"
-  branch = "master"
-
-[[constraint]]
-  name = "github.com/spf13/afero"
-  version = "^1.1.0"
-
-[[constraint]]
-  name = "github.com/spf13/cast"
-  version = "^1.1.0"
-
-[[constraint]]
-  version = "^0.0.1"
-  name = "github.com/spf13/cobra"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/spf13/fsync"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/spf13/jwalterweatherman"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/spf13/nitro"
-
-[[constraint]]
-  name = "github.com/spf13/pflag"
-  version = "1.0.0"
-
-[[constraint]]
-  name = "github.com/spf13/viper"
-  version = "1.0.0"
-
-[[constraint]]
-  name = "github.com/stretchr/testify"
-  version = "1.1.4"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/olekukonko/tablewriter"
-
-[[constraint]]
-  name = "github.com/yosssi/ace"
-  version = "^0.0.5"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/image"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/text"
-
-[[constraint]]
-  branch = "v2"
-  name = "gopkg.in/yaml.v2"
-
-[[constraint]]
-  name = "github.com/gobwas/glob"
-  version = "0.2.2"
-
-
-[[constraint]]
-  name = "github.com/muesli/smartcrop"
-  branch = "master"
-
-
-[[constraint]]
-  name = "github.com/sanity-io/litter"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "github.com/bep/debounce"
-  version = "^1.1.0"
-
-[[constraint]]
-  name = "github.com/tdewolff/minify"
-  version = "^2.3.5"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/BurntSushi/locker"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/mitchellh/hashstructure"

README.md

@@ -4,16 +4,15 @@ A Fast and Flexible Static Site Generator built with love by [bep](https://githu
 
 [Website](https://gohugo.io) |
 [Forum](https://discourse.gohugo.io) |
-[Developer Chat (no support)](https://gitter.im/gohugoio/hugo) |
-[Documentation](https://gohugo.io/overview/introduction/) |
-[Installation Guide](https://gohugo.io/overview/installing/) |
+[Developer Chat (no support)](https://gitter.im/spf13/hugo) |
+[Documentation](https://gohugo.io/getting-started/) |
+[Installation Guide](https://gohugo.io/getting-started/installing/) |
 [Contribution Guide](CONTRIBUTING.md) |
-[Twitter](http://twitter.com/gohugoio)
+[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=Linux+and+macOS+build "Linux and macOS Build Status")](https://travis-ci.org/gohugoio/hugo)
-[![Windows Build Status](https://ci.appveyor.com/api/projects/status/a5mr220vsd091kua?svg=true&label=Windows+build "Windows Build Status")](https://ci.appveyor.com/project/bep/hugo/branch/master)
-[![Dev chat at https://gitter.im/gohugoio/hugo](https://img.shields.io/badge/gitter-developer_chat-46bc99.svg)](https://gitter.im/spf13/hugo?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![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)
+[![Dev chat at https://gitter.im/spf13/hugo](https://img.shields.io/badge/gitter-developer_chat-46bc99.svg)](https://gitter.im/spf13/hugo?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Go Report Card](https://goreportcard.com/badge/github.com/gohugoio/hugo)](https://goreportcard.com/report/github.com/gohugoio/hugo)
 
 ## Overview
@@ -36,7 +35,7 @@ Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBS
 
 Hugo may also be compiled from source wherever the Go compiler tool chain can run, e.g. for other operating systems including DragonFly BSD, OpenBSD, Plan 9, and Solaris.
 
-**Complete documentation is available at [Hugo Documentation][].**
+**Complete documentation is available at [Hugo Documentation](https://gohugo.io/getting-started/).**
 
 ## Choose How to Install
 
@@ -50,29 +49,25 @@ Building the binaries is an easy task for an experienced `go` getter.
 
 ### Install Hugo as Your Site Generator (Binary Install)
 
-Use the [installation instructions in the Hugo documentation](https://gohugo.io/overview/installing/).
+Use the [installation instructions in the Hugo documentation](https://gohugo.io/getting-started/installing/).
 
 ### Build and Install the Binaries from Source (Advanced Install)
 
 #### Prerequisite Tools
 
-* [Git](http://git-scm.com/)
-* [Go (latest or previous version)](https://golang.org/dl/)
-
-#### Vendored Dependencies
-
-Hugo uses [dep](https://github.com/golang/dep) to vendor dependencies, but we don't commit the vendored packages themselves to the Hugo git repository. Therefore, a simple `go get` is _not_ supported because the command is not vendor aware.
-
-The simplest way is to use [mage](https://github.com/magefile/mage) (a Make alternative for Go projects.)
+* [Git](https://git-scm.com/)
+* [Go (at least Go 1.11)](https://golang.org/dl/)
 
 #### Fetch from GitHub
 
+Since Hugo 0.48, Hugo uses the Go Modules support built into Go 1.11 to build. The easiest is to clone Hugo in a directory outside of `GOPATH`, as in the following example:
+
 ```bash
-go get github.com/magefile/mage
-go get -d github.com/gohugoio/hugo
-cd ${GOPATH:-$HOME/go}/src/github.com/gohugoio/hugo
-mage vendor
-mage install
+mkdir $HOME/src
+cd $HOME/src
+git clone https://github.com/gohugoio/hugo.git
+cd hugo
+go install
 ```
 
 **If you are a Windows user, substitute the `$HOME` environment variable above with `%USERPROFILE%`.**
@@ -124,3 +119,71 @@ For a complete guide to contributing code to Hugo, see the [Contribution Guide](
 
 [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:
+
+ | Dependency  | 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/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/alecthomas/chroma](https://github.com/alecthomas/chroma) |  MIT License |
+ | [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/go-tocss](https://github.com/bep/go-tocss) | MIT License |
+ | [github.com/chaseadamsio/goorgeous](https://github.com/chaseadamsio/goorgeous) | 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/imaging](https://github.com/disintegration/imaging) |  MIT License |
+ | [github.com/dlclark/regexp2](https://github.com/dlclark/regexp2) | MIT License |
+ | [github.com/eknkc/amber](https://github.com/eknkc/amber) | 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/go-immutable-radix](https://github.com/hashicorp/go-immutable-radix) | Mozilla Public License 2.0 |
+ | [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/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/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/russross/blackfriday](https://github.com/russross/blackfriday)  | Simplified BSD License |
+ | [github.com/shurcooL/sanitized_anchor_name](https://github.com/shurcooL/sanitized_anchor_name) | MIT 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/nitro](https://github.com/spf13/nitro) | Apache License 2.0 |
+ | [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/wellington/go-libsass](https://github.com/wellington/go-libsass) | Apache License 2.0 |
+ | [github.com/yosssi/ace](https://github.com/yosssi/ace) |  MIT License |
+ | [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/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
+ | [gopkg.in/yaml.v2](https://gopkg.in/yaml.v2) |    Apache License 2.0 |
+
+  
+ 
+  
+ 
+ 
+ 

appveyor.yml

@@ -1,24 +0,0 @@
-image: Visual Studio 2015
-
-init:
-  - set PATH=%PATH%;C:\mingw-w64\x86_64-7.3.0-posix-seh-rt_v5-rev0\mingw64\bin;%GOPATH%\bin
-  - go version
-  - go env
-
-environment:
-  GOPATH: C:\GOPATH\
-  HUGO_BUILD_TAGS: extended
-
-# clones and cd's to path
-clone_folder: C:\GOPATH\src\github.com\gohugoio\hugo
-
-install:
-#  - gem install asciidoctor
-  - pip install docutils
-  - go get github.com/magefile/mage
-
-build_script:
-  - mage vendor hugoRace
-  - mage -v check
-  - hugo -s docs/
-  - hugo --renderToMemory -s docs/

bepdock.sh

@@ -1,2 +1 @@
-# Temp script used to test new builds.
- docker run --rm --mount type=bind,source="$(pwd)",target=/go/src/github.com/gohugoio/hugo -w /go/src/github.com/gohugoio/hugo  -i -t bepsays/ci-goreleaser:latest /bin/bash
+docker run --rm --mount type=bind,source="$(pwd)",target=/hugo -w /hugo  -i -t bepsays/ci-goreleaser:1.11-2 /bin/bash

cache/filecache/filecache.go

@@ -0,0 +1,353 @@
+// Copyright 2018 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 filecache
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gohugoio/hugo/common/hugio"
+
+	"github.com/gohugoio/hugo/helpers"
+
+	"github.com/BurntSushi/locker"
+	"github.com/spf13/afero"
+)
+
+const (
+	filecacheRootDirname = "filecache"
+)
+
+// Cache caches a set of files in a directory. This is usually a file on
+// disk, but since this is backed by an Afero file system, it can be anything.
+type Cache struct {
+	Fs afero.Fs
+
+	// Max age for items in this cache. Negative duration means forever,
+	// 0 is effectively turning this cache off.
+	maxAge time.Duration
+
+	nlocker *lockTracker
+}
+
+type lockTracker struct {
+	seenMu sync.RWMutex
+	seen   map[string]struct{}
+
+	*locker.Locker
+}
+
+// Lock tracks the ids in use. We use this information to do garbage collection
+// after a Hugo build.
+func (l *lockTracker) Lock(id string) {
+	l.seenMu.RLock()
+	if _, seen := l.seen[id]; !seen {
+		l.seenMu.RUnlock()
+		l.seenMu.Lock()
+		l.seen[id] = struct{}{}
+		l.seenMu.Unlock()
+	} else {
+		l.seenMu.RUnlock()
+	}
+
+	l.Locker.Lock(id)
+}
+
+// ItemInfo contains info about a cached file.
+type ItemInfo struct {
+	// This is the file's name relative to the cache's filesystem.
+	Name string
+}
+
+// NewCache creates a new file cache with the given filesystem and max age.
+func NewCache(fs afero.Fs, maxAge time.Duration) *Cache {
+	return &Cache{
+		Fs:      fs,
+		nlocker: &lockTracker{Locker: locker.NewLocker(), seen: make(map[string]struct{})},
+		maxAge:  maxAge,
+	}
+}
+
+// lockedFile is a file with a lock that is released on Close.
+type lockedFile struct {
+	afero.File
+	unlock func()
+}
+
+func (l *lockedFile) Close() error {
+	defer l.unlock()
+	return l.File.Close()
+}
+
+// WriteCloser returns a transactional writer into the cache.
+// It's important that it's closed when done.
+func (c *Cache) WriteCloser(id string) (ItemInfo, io.WriteCloser, error) {
+	id = cleanID(id)
+	c.nlocker.Lock(id)
+
+	info := ItemInfo{Name: id}
+
+	f, err := helpers.OpenFileForWriting(c.Fs, id)
+	if err != nil {
+		c.nlocker.Unlock(id)
+		return info, nil, err
+	}
+
+	return info, &lockedFile{
+		File:   f,
+		unlock: func() { c.nlocker.Unlock(id) },
+	}, nil
+}
+
+// ReadOrCreate tries to lookup the file in cache.
+// If found, it is passed to read and then closed.
+// If not found a new file is created and passed to create, which should close
+// it when done.
+func (c *Cache) ReadOrCreate(id string,
+	read func(info ItemInfo, r io.Reader) error,
+	create func(info ItemInfo, w io.WriteCloser) error) (info ItemInfo, err error) {
+	id = cleanID(id)
+
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)
+
+	info = ItemInfo{Name: id}
+
+	if r := c.getOrRemove(id); r != nil {
+		err = read(info, r)
+		defer r.Close()
+		return
+	}
+
+	f, err := helpers.OpenFileForWriting(c.Fs, id)
+	if err != nil {
+		return
+	}
+
+	err = create(info, f)
+
+	return
+
+}
+
+// GetOrCreate tries to get the file with the given id from cache. If not found or expired, create will
+// be invoked and the result cached.
+// This method is protected by a named lock using the given id as identifier.
+func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (ItemInfo, io.ReadCloser, error) {
+	id = cleanID(id)
+
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)
+
+	info := ItemInfo{Name: id}
+
+	if r := c.getOrRemove(id); r != nil {
+		return info, r, nil
+	}
+
+	r, err := create()
+	if err != nil {
+		return info, nil, err
+	}
+
+	if c.maxAge == 0 {
+		// No caching.
+		return info, hugio.ToReadCloser(r), nil
+	}
+
+	var buff bytes.Buffer
+	return info,
+		hugio.ToReadCloser(&buff),
+		afero.WriteReader(c.Fs, id, io.TeeReader(r, &buff))
+}
+
+// GetOrCreateBytes is the same as GetOrCreate, but produces a byte slice.
+func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (ItemInfo, []byte, error) {
+	id = cleanID(id)
+
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)
+
+	info := ItemInfo{Name: id}
+
+	if r := c.getOrRemove(id); r != nil {
+		defer r.Close()
+		b, err := ioutil.ReadAll(r)
+		return info, b, err
+	}
+
+	b, err := create()
+	if err != nil {
+		return info, nil, err
+	}
+
+	if c.maxAge == 0 {
+		return info, b, nil
+	}
+
+	if err := afero.WriteReader(c.Fs, id, bytes.NewReader(b)); err != nil {
+		return info, nil, err
+	}
+	return info, b, nil
+
+}
+
+// GetBytes gets the file content with the given id from the cahce, nil if none found.
+func (c *Cache) GetBytes(id string) (ItemInfo, []byte, error) {
+	id = cleanID(id)
+
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)
+
+	info := ItemInfo{Name: id}
+
+	if r := c.getOrRemove(id); r != nil {
+		defer r.Close()
+		b, err := ioutil.ReadAll(r)
+		return info, b, err
+	}
+
+	return info, nil, nil
+}
+
+// Get gets the file with the given id from the cahce, nil if none found.
+func (c *Cache) Get(id string) (ItemInfo, io.ReadCloser, error) {
+	id = cleanID(id)
+
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)
+
+	info := ItemInfo{Name: id}
+
+	r := c.getOrRemove(id)
+
+	return info, r, nil
+}
+
+// getOrRemove gets the file with the given id. If it's expired, it will
+// be removed.
+func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
+	if c.maxAge == 0 {
+		// No caching.
+		return nil
+	}
+
+	if c.maxAge > 0 {
+		fi, err := c.Fs.Stat(id)
+		if err != nil {
+			return nil
+		}
+
+		if c.isExpired(fi.ModTime()) {
+			c.Fs.Remove(id)
+			return nil
+		}
+	}
+
+	f, err := c.Fs.Open(id)
+
+	if err != nil {
+		return nil
+	}
+
+	return f
+}
+
+func (c *Cache) isExpired(modTime time.Time) bool {
+	if c.maxAge < 0 {
+		return false
+	}
+	return c.maxAge == 0 || time.Now().Sub(modTime) > c.maxAge
+}
+
+// For testing
+func (c *Cache) getString(id string) string {
+	id = cleanID(id)
+
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)
+
+	f, err := c.Fs.Open(id)
+
+	if err != nil {
+		return ""
+	}
+	defer f.Close()
+
+	b, _ := ioutil.ReadAll(f)
+	return string(b)
+
+}
+
+// Caches is a named set of caches.
+type Caches map[string]*Cache
+
+// Get gets a named cache, nil if none found.
+func (f Caches) Get(name string) *Cache {
+	return f[strings.ToLower(name)]
+}
+
+// NewCaches creates a new set of file caches from the given
+// configuration.
+func NewCaches(p *helpers.PathSpec) (Caches, error) {
+	dcfg, err := decodeConfig(p)
+	if err != nil {
+		return nil, err
+	}
+
+	fs := p.Fs.Source
+
+	m := make(Caches)
+	for k, v := range dcfg {
+		var cfs afero.Fs
+
+		if v.isResourceDir {
+			cfs = p.BaseFs.Resources.Fs
+		} else {
+			cfs = fs
+		}
+
+		var baseDir string
+		if !strings.HasPrefix(v.Dir, "_gen") {
+			// We do cache eviction (file removes) and since the user can set
+			// his/hers own cache directory, we really want to make sure
+			// we do not delete any files that do not belong to this cache.
+			// We do add the cache name as the root, but this is an extra safe
+			// guard. We skip the files inside /resources/_gen/ because
+			// that would be breaking.
+			baseDir = filepath.Join(v.Dir, filecacheRootDirname, k)
+		} else {
+			baseDir = filepath.Join(v.Dir, k)
+		}
+		if err = cfs.MkdirAll(baseDir, 0777); err != nil && !os.IsExist(err) {
+			return nil, err
+		}
+
+		bfs := afero.NewBasePathFs(cfs, baseDir)
+
+		m[k] = NewCache(bfs, v.MaxAge)
+	}
+
+	return m, nil
+}
+
+func cleanID(name string) string {
+	return strings.TrimPrefix(filepath.Clean(name), helpers.FilePathSeparator)
+}

cache/filecache/filecache_config.go

@@ -0,0 +1,202 @@
+// Copyright 2018 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 filecache
+
+import (
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/pkg/errors"
+	"github.com/spf13/afero"
+)
+
+const (
+	cachesConfigKey = "caches"
+
+	resourcesGenDir = ":resourceDir/_gen"
+)
+
+var defaultCacheConfig = cacheConfig{
+	MaxAge: -1, // Never expire
+	Dir:    ":cacheDir/:project",
+}
+
+const (
+	cacheKeyGetJSON = "getjson"
+	cacheKeyGetCSV  = "getcsv"
+	cacheKeyImages  = "images"
+	cacheKeyAssets  = "assets"
+)
+
+var defaultCacheConfigs = map[string]cacheConfig{
+	cacheKeyGetJSON: defaultCacheConfig,
+	cacheKeyGetCSV:  defaultCacheConfig,
+	cacheKeyImages: cacheConfig{
+		MaxAge: -1,
+		Dir:    resourcesGenDir,
+	},
+	cacheKeyAssets: cacheConfig{
+		MaxAge: -1,
+		Dir:    resourcesGenDir,
+	},
+}
+
+type cachesConfig map[string]cacheConfig
+
+type cacheConfig struct {
+	// Max age of cache entries in this cache. Any items older than this will
+	// be removed and not returned from the cache.
+	// a negative value means forever, 0 means cache is disabled.
+	MaxAge time.Duration
+
+	// The directory where files are stored.
+	Dir string
+
+	// Will resources/_gen will get its own composite filesystem that
+	// also checks any theme.
+	isResourceDir bool
+}
+
+// GetJSONCache gets the file cache for getJSON.
+func (f Caches) GetJSONCache() *Cache {
+	return f[cacheKeyGetJSON]
+}
+
+// GetCSVCache gets the file cache for getCSV.
+func (f Caches) GetCSVCache() *Cache {
+	return f[cacheKeyGetCSV]
+}
+
+// ImageCache gets the file cache for processed images.
+func (f Caches) ImageCache() *Cache {
+	return f[cacheKeyImages]
+}
+
+// AssetsCache gets the file cache for assets (processed resources, SCSS etc.).
+func (f Caches) AssetsCache() *Cache {
+	return f[cacheKeyAssets]
+}
+
+func decodeConfig(p *helpers.PathSpec) (cachesConfig, error) {
+	c := make(cachesConfig)
+	valid := make(map[string]bool)
+	// Add defaults
+	for k, v := range defaultCacheConfigs {
+		c[k] = v
+		valid[k] = true
+	}
+
+	cfg := p.Cfg
+
+	m := cfg.GetStringMap(cachesConfigKey)
+
+	_, isOsFs := p.Fs.Source.(*afero.OsFs)
+
+	for k, v := range m {
+		cc := defaultCacheConfig
+
+		dc := &mapstructure.DecoderConfig{
+			Result:           &cc,
+			DecodeHook:       mapstructure.StringToTimeDurationHookFunc(),
+			WeaklyTypedInput: true,
+		}
+
+		decoder, err := mapstructure.NewDecoder(dc)
+		if err != nil {
+			return c, err
+		}
+
+		if err := decoder.Decode(v); err != nil {
+			return nil, err
+		}
+
+		if cc.Dir == "" {
+			return c, errors.New("must provide cache Dir")
+		}
+
+		name := strings.ToLower(k)
+		if !valid[name] {
+			return nil, errors.Errorf("%q is not a valid cache name", name)
+		}
+
+		c[name] = cc
+	}
+
+	// This is a very old flag in Hugo, but we need to respect it.
+	disabled := cfg.GetBool("ignoreCache")
+
+	for k, v := range c {
+		dir := filepath.ToSlash(filepath.Clean(v.Dir))
+		hadSlash := strings.HasPrefix(dir, "/")
+		parts := strings.Split(dir, "/")
+
+		for i, part := range parts {
+			if strings.HasPrefix(part, ":") {
+				resolved, isResource, err := resolveDirPlaceholder(p, part)
+				if err != nil {
+					return c, err
+				}
+				if isResource {
+					v.isResourceDir = true
+				}
+				parts[i] = resolved
+			}
+		}
+
+		dir = path.Join(parts...)
+		if hadSlash {
+			dir = "/" + dir
+		}
+		v.Dir = filepath.Clean(filepath.FromSlash(dir))
+
+		if !v.isResourceDir {
+			if isOsFs && !filepath.IsAbs(v.Dir) {
+				return c, errors.Errorf("%q must resolve to an absolute directory", v.Dir)
+			}
+
+			// Avoid cache in root, e.g. / (Unix) or c:\ (Windows)
+			if len(strings.TrimPrefix(v.Dir, filepath.VolumeName(v.Dir))) == 1 {
+				return c, errors.Errorf("%q is a root folder and not allowed as cache dir", v.Dir)
+			}
+		}
+
+		if disabled {
+			v.MaxAge = 0
+		}
+
+		c[k] = v
+	}
+
+	return c, nil
+}
+
+// Resolves :resourceDir => /myproject/resources etc., :cacheDir => ...
+func resolveDirPlaceholder(p *helpers.PathSpec, placeholder string) (cacheDir string, isResource bool, err error) {
+	switch strings.ToLower(placeholder) {
+	case ":resourcedir":
+		return "", true, nil
+	case ":cachedir":
+		d, err := helpers.GetCacheDir(p.Fs.Source, p.Cfg)
+		return d, false, err
+	case ":project":
+		return filepath.Base(p.WorkingDir), false, nil
+	}
+
+	return "", false, errors.Errorf("%q is not a valid placeholder (valid values are :cacheDir or :resourceDir)", placeholder)
+}

cache/filecache/filecache_config_test.go

@@ -0,0 +1,207 @@
+// Copyright 2018 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 filecache
+
+import (
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/hugofs"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDecodeConfig(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	configStr := `
+resourceDir = "myresources"
+contentDir = "content"
+dataDir = "data"
+i18nDir = "i18n"
+layoutDir = "layouts"
+assetDir = "assets"
+archetypeDir = "archetypes"
+
+[caches]
+[caches.getJSON]
+maxAge = "10m"
+dir = "/path/to/c1"
+[caches.getCSV]
+maxAge = "11h"
+dir = "/path/to/c2"
+[caches.images]
+dir = "/path/to/c3"
+
+`
+
+	cfg, err := config.FromConfigString(configStr, "toml")
+	assert.NoError(err)
+	fs := hugofs.NewMem(cfg)
+	p, err := helpers.NewPathSpec(fs, cfg)
+	assert.NoError(err)
+
+	decoded, err := decodeConfig(p)
+	assert.NoError(err)
+
+	assert.Equal(4, len(decoded))
+
+	c2 := decoded["getcsv"]
+	assert.Equal("11h0m0s", c2.MaxAge.String())
+	assert.Equal(filepath.FromSlash("/path/to/c2"), c2.Dir)
+
+	c3 := decoded["images"]
+	assert.Equal(time.Duration(-1), c3.MaxAge)
+	assert.Equal(filepath.FromSlash("/path/to/c3"), c3.Dir)
+
+}
+
+func TestDecodeConfigIgnoreCache(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	configStr := `
+resourceDir = "myresources"
+contentDir = "content"
+dataDir = "data"
+i18nDir = "i18n"
+layoutDir = "layouts"
+assetDir = "assets"
+archeTypedir = "archetypes"
+
+ignoreCache = true
+[caches]
+[caches.getJSON]
+maxAge = 1234
+dir = "/path/to/c1"
+[caches.getCSV]
+maxAge = 3456
+dir = "/path/to/c2"
+[caches.images]
+dir = "/path/to/c3"
+
+`
+
+	cfg, err := config.FromConfigString(configStr, "toml")
+	assert.NoError(err)
+	fs := hugofs.NewMem(cfg)
+	p, err := helpers.NewPathSpec(fs, cfg)
+	assert.NoError(err)
+
+	decoded, err := decodeConfig(p)
+	assert.NoError(err)
+
+	assert.Equal(4, len(decoded))
+
+	for _, v := range decoded {
+		assert.Equal(time.Duration(0), v.MaxAge)
+	}
+
+}
+
+func TestDecodeConfigDefault(t *testing.T) {
+	assert := require.New(t)
+	cfg := newTestConfig()
+
+	if runtime.GOOS == "windows" {
+		cfg.Set("resourceDir", "c:\\cache\\resources")
+		cfg.Set("cacheDir", "c:\\cache\\thecache")
+
+	} else {
+		cfg.Set("resourceDir", "/cache/resources")
+		cfg.Set("cacheDir", "/cache/thecache")
+	}
+
+	fs := hugofs.NewMem(cfg)
+	p, err := helpers.NewPathSpec(fs, cfg)
+	assert.NoError(err)
+
+	decoded, err := decodeConfig(p)
+
+	assert.NoError(err)
+
+	assert.Equal(4, len(decoded))
+
+	imgConfig := decoded[cacheKeyImages]
+	jsonConfig := decoded[cacheKeyGetJSON]
+
+	if runtime.GOOS == "windows" {
+		assert.Equal("_gen", imgConfig.Dir)
+	} else {
+		assert.Equal("_gen", imgConfig.Dir)
+		assert.Equal("/cache/thecache/hugoproject", jsonConfig.Dir)
+	}
+
+	assert.True(imgConfig.isResourceDir)
+	assert.False(jsonConfig.isResourceDir)
+}
+
+func TestDecodeConfigInvalidDir(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	configStr := `
+resourceDir = "myresources"
+contentDir = "content"
+dataDir = "data"
+i18nDir = "i18n"
+layoutDir = "layouts"
+assetDir = "assets"
+archeTypedir = "archetypes"
+
+[caches]
+[caches.getJSON]
+maxAge = "10m"
+dir = "/"
+
+`
+	if runtime.GOOS == "windows" {
+		configStr = strings.Replace(configStr, "/", "c:\\\\", 1)
+	}
+
+	cfg, err := config.FromConfigString(configStr, "toml")
+	assert.NoError(err)
+	fs := hugofs.NewMem(cfg)
+	p, err := helpers.NewPathSpec(fs, cfg)
+	assert.NoError(err)
+
+	_, err = decodeConfig(p)
+	assert.Error(err)
+
+}
+
+func newTestConfig() *viper.Viper {
+	cfg := viper.New()
+	cfg.Set("workingDir", filepath.FromSlash("/my/cool/hugoproject"))
+	cfg.Set("contentDir", "content")
+	cfg.Set("dataDir", "data")
+	cfg.Set("resourceDir", "resources")
+	cfg.Set("i18nDir", "i18n")
+	cfg.Set("layoutDir", "layouts")
+	cfg.Set("archetypeDir", "archetypes")
+	cfg.Set("assetDir", "assets")
+
+	return cfg
+}

cache/filecache/filecache_pruner.go

@@ -0,0 +1,80 @@
+// Copyright 2018 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 filecache
+
+import (
+	"io"
+	"os"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/afero"
+)
+
+// Prune removes expired and unused items from this cache.
+// The last one requires a full build so the cache usage can be tracked.
+// Note that we operate directly on the filesystem here, so this is not
+// thread safe.
+func (c Caches) Prune() (int, error) {
+	counter := 0
+	for k, cache := range c {
+		err := afero.Walk(cache.Fs, "", func(name string, info os.FileInfo, err error) error {
+			if info == nil {
+				return nil
+			}
+
+			name = cleanID(name)
+
+			if info.IsDir() {
+				f, err := cache.Fs.Open(name)
+				if err != nil {
+					// This cache dir may not exist.
+					return nil
+				}
+				defer f.Close()
+				_, err = f.Readdirnames(1)
+				if err == io.EOF {
+					// Empty dir.
+					return cache.Fs.Remove(name)
+				}
+
+				return nil
+			}
+
+			shouldRemove := cache.isExpired(info.ModTime())
+
+			if !shouldRemove && len(cache.nlocker.seen) > 0 {
+				// Remove it if it's not been touched/used in the last build.
+				_, seen := cache.nlocker.seen[name]
+				shouldRemove = !seen
+			}
+
+			if shouldRemove {
+				err := cache.Fs.Remove(name)
+				if err == nil {
+					counter++
+				}
+				return err
+			}
+
+			return nil
+		})
+
+		if err != nil {
+			return counter, errors.Wrapf(err, "failed to prune cache %q", k)
+		}
+
+	}
+
+	return counter, nil
+}

cache/filecache/filecache_pruner_test.go

@@ -0,0 +1,118 @@
+// Copyright 2018 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 filecache
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPrune(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	configStr := `
+resourceDir = "myresources"
+contentDir = "content"
+dataDir = "data"
+i18nDir = "i18n"
+layoutDir = "layouts"
+assetDir = "assets"
+archeTypedir = "archetypes"
+
+[caches]
+[caches.getjson]
+maxAge = "200ms"
+dir = "/cache/c"
+[caches.getcsv]
+maxAge = "200ms"
+dir = "/cache/d"
+[caches.assets]
+maxAge = "200ms"
+dir = ":resourceDir/_gen"
+[caches.images]
+maxAge = "200ms"
+dir = ":resourceDir/_gen"
+`
+
+	cfg, err := config.FromConfigString(configStr, "toml")
+	assert.NoError(err)
+
+	for _, name := range []string{cacheKeyGetCSV, cacheKeyGetJSON, cacheKeyAssets, cacheKeyImages} {
+		msg := fmt.Sprintf("cache: %s", name)
+		fs := hugofs.NewMem(cfg)
+		p, err := helpers.NewPathSpec(fs, cfg)
+		assert.NoError(err)
+		caches, err := NewCaches(p)
+		assert.NoError(err)
+		cache := caches[name]
+		for i := 0; i < 10; i++ {
+			id := fmt.Sprintf("i%d", i)
+			cache.GetOrCreateBytes(id, func() ([]byte, error) {
+				return []byte("abc"), nil
+			})
+			if i == 4 {
+				// This will expire the first 5
+				time.Sleep(201 * time.Millisecond)
+			}
+		}
+
+		count, err := caches.Prune()
+		assert.NoError(err)
+		assert.Equal(5, count, msg)
+
+		for i := 0; i < 10; i++ {
+			id := fmt.Sprintf("i%d", i)
+			v := cache.getString(id)
+			if i < 5 {
+				assert.Equal("", v, id)
+			} else {
+				assert.Equal("abc", v, id)
+			}
+		}
+
+		caches, err = NewCaches(p)
+		assert.NoError(err)
+		cache = caches[name]
+		// Touch one and then prune.
+		cache.GetOrCreateBytes("i5", func() ([]byte, error) {
+			return []byte("abc"), nil
+		})
+
+		count, err = caches.Prune()
+		assert.NoError(err)
+		assert.Equal(4, count)
+
+		// Now only the i5 should be left.
+		for i := 0; i < 10; i++ {
+			id := fmt.Sprintf("i%d", i)
+			v := cache.getString(id)
+			if i != 5 {
+				assert.Equal("", v, id)
+			} else {
+				assert.Equal("abc", v, id)
+			}
+		}
+
+	}
+
+}

cache/filecache/filecache_test.go

@@ -0,0 +1,257 @@
+// Copyright 2018 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 filecache
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/gohugoio/hugo/common/hugio"
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/helpers"
+
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/afero"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestFileCache(t *testing.T) {
+	t.Parallel()
+	assert := require.New(t)
+
+	tempWorkingDir, err := ioutil.TempDir("", "hugo_filecache_test_work")
+	assert.NoError(err)
+	defer os.Remove(tempWorkingDir)
+
+	tempCacheDir, err := ioutil.TempDir("", "hugo_filecache_test_cache")
+	assert.NoError(err)
+	defer os.Remove(tempCacheDir)
+
+	osfs := afero.NewOsFs()
+
+	for _, test := range []struct {
+		cacheDir   string
+		workingDir string
+	}{
+		// Run with same dirs twice to make sure that works.
+		{tempCacheDir, tempWorkingDir},
+		{tempCacheDir, tempWorkingDir},
+	} {
+
+		configStr := `
+workingDir = "WORKING_DIR"
+resourceDir = "resources"
+cacheDir = "CACHEDIR"
+contentDir = "content"
+dataDir = "data"
+i18nDir = "i18n"
+layoutDir = "layouts"
+assetDir = "assets"
+archeTypedir = "archetypes"
+
+[caches]
+[caches.getJSON]
+maxAge = "10h"
+dir = ":cacheDir/c"
+
+`
+
+		winPathSep := "\\\\"
+
+		replacer := strings.NewReplacer("CACHEDIR", test.cacheDir, "WORKING_DIR", test.workingDir)
+
+		configStr = replacer.Replace(configStr)
+		configStr = strings.Replace(configStr, "\\", winPathSep, -1)
+
+		cfg, err := config.FromConfigString(configStr, "toml")
+		assert.NoError(err)
+
+		fs := hugofs.NewFrom(osfs, cfg)
+		p, err := helpers.NewPathSpec(fs, cfg)
+		assert.NoError(err)
+
+		caches, err := NewCaches(p)
+		assert.NoError(err)
+
+		cache := caches.Get("GetJSON")
+		assert.NotNil(cache)
+		assert.Equal("10h0m0s", cache.maxAge.String())
+
+		bfs, ok := cache.Fs.(*afero.BasePathFs)
+		assert.True(ok)
+		filename, err := bfs.RealPath("key")
+		assert.NoError(err)
+		if test.cacheDir != "" {
+			assert.Equal(filepath.Join(test.cacheDir, "c/"+filecacheRootDirname+"/getjson/key"), filename)
+		} else {
+			// Temp dir.
+			assert.Regexp(regexp.MustCompile(".*hugo_cache.*"+filecacheRootDirname+".*key"), filename)
+		}
+
+		cache = caches.Get("Images")
+		assert.NotNil(cache)
+		assert.Equal(time.Duration(-1), cache.maxAge)
+		bfs, ok = cache.Fs.(*afero.BasePathFs)
+		assert.True(ok)
+		filename, _ = bfs.RealPath("key")
+		assert.Equal(filepath.FromSlash("_gen/images/key"), filename)
+
+		rf := func(s string) func() (io.ReadCloser, error) {
+			return func() (io.ReadCloser, error) {
+				return struct {
+					io.ReadSeeker
+					io.Closer
+				}{
+					strings.NewReader(s),
+					ioutil.NopCloser(nil),
+				}, nil
+			}
+		}
+
+		bf := func() ([]byte, error) {
+			return []byte("bcd"), nil
+		}
+
+		for _, c := range []*Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
+			for i := 0; i < 2; i++ {
+				info, r, err := c.GetOrCreate("a", rf("abc"))
+				assert.NoError(err)
+				assert.NotNil(r)
+				assert.Equal("a", info.Name)
+				b, _ := ioutil.ReadAll(r)
+				r.Close()
+				assert.Equal("abc", string(b))
+
+				info, b, err = c.GetOrCreateBytes("b", bf)
+				assert.NoError(err)
+				assert.NotNil(r)
+				assert.Equal("b", info.Name)
+				assert.Equal("bcd", string(b))
+
+				_, b, err = c.GetOrCreateBytes("a", bf)
+				assert.NoError(err)
+				assert.Equal("abc", string(b))
+
+				_, r, err = c.GetOrCreate("a", rf("bcd"))
+				assert.NoError(err)
+				b, _ = ioutil.ReadAll(r)
+				r.Close()
+				assert.Equal("abc", string(b))
+			}
+		}
+
+		assert.NotNil(caches.Get("getJSON"))
+
+		info, w, err := caches.ImageCache().WriteCloser("mykey")
+		assert.NoError(err)
+		assert.Equal("mykey", info.Name)
+		io.WriteString(w, "Hugo is great!")
+		w.Close()
+		assert.Equal("Hugo is great!", caches.ImageCache().getString("mykey"))
+
+		info, r, err := caches.ImageCache().Get("mykey")
+		assert.NoError(err)
+		assert.NotNil(r)
+		assert.Equal("mykey", info.Name)
+		b, _ := ioutil.ReadAll(r)
+		r.Close()
+		assert.Equal("Hugo is great!", string(b))
+
+		info, b, err = caches.ImageCache().GetBytes("mykey")
+		assert.NoError(err)
+		assert.Equal("mykey", info.Name)
+		assert.Equal("Hugo is great!", string(b))
+
+	}
+
+}
+
+func TestFileCacheConcurrent(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	configStr := `
+resourceDir = "myresources"
+contentDir = "content"
+dataDir = "data"
+i18nDir = "i18n"
+layoutDir = "layouts"
+assetDir = "assets"
+archeTypedir = "archetypes"
+
+[caches]
+[caches.getjson]
+maxAge = "1s"
+dir = "/cache/c"
+
+`
+
+	cfg, err := config.FromConfigString(configStr, "toml")
+	assert.NoError(err)
+	fs := hugofs.NewMem(cfg)
+	p, err := helpers.NewPathSpec(fs, cfg)
+	assert.NoError(err)
+
+	caches, err := NewCaches(p)
+	assert.NoError(err)
+
+	const cacheName = "getjson"
+
+	filenameData := func(i int) (string, string) {
+		data := fmt.Sprintf("data: %d", i)
+		filename := fmt.Sprintf("file%d", i)
+		return filename, data
+	}
+
+	var wg sync.WaitGroup
+
+	for i := 0; i < 50; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			for j := 0; j < 20; j++ {
+				c := caches.Get(cacheName)
+				assert.NotNil(c)
+				filename, data := filenameData(i)
+				_, r, err := c.GetOrCreate(filename, func() (io.ReadCloser, error) {
+					return hugio.ToReadCloser(strings.NewReader(data)), nil
+				})
+				assert.NoError(err)
+				b, _ := ioutil.ReadAll(r)
+				r.Close()
+				assert.Equal(data, string(b))
+				// Trigger some expiration.
+				time.Sleep(50 * time.Millisecond)
+			}
+		}(i)
+
+	}
+	wg.Wait()
+}
+
+func TestCleanID(t *testing.T) {
+	assert := require.New(t)
+	assert.Equal(filepath.FromSlash("a/b/c.txt"), cleanID(filepath.FromSlash("/a/b//c.txt")))
+	assert.Equal(filepath.FromSlash("a/b/c.txt"), cleanID(filepath.FromSlash("a/b//c.txt")))
+}

cache/namedmemcache/named_cache.go

@@ -0,0 +1,84 @@
+// Copyright 2018 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 namedmemcache provides a memory cache with a named lock. This is suitable
+// for situations where creating the cached resource can be time consuming or otherwise
+// resource hungry, or in situations where a "once only per key" is a requirement.
+package namedmemcache
+
+import (
+	"sync"
+
+	"github.com/BurntSushi/locker"
+)
+
+// Cache holds the cached values.
+type Cache struct {
+	nlocker *locker.Locker
+	cache   map[string]cacheEntry
+	mu      sync.RWMutex
+}
+
+type cacheEntry struct {
+	value interface{}
+	err   error
+}
+
+// New creates a new cache.
+func New() *Cache {
+	return &Cache{
+		nlocker: locker.NewLocker(),
+		cache:   make(map[string]cacheEntry),
+	}
+}
+
+// Clear clears the cache state.
+func (c *Cache) Clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	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.
+func (c *Cache) GetOrCreate(key string, create func() (interface{}, error)) (interface{}, error) {
+	c.mu.RLock()
+	entry, found := c.cache[key]
+	c.mu.RUnlock()
+
+	if found {
+		return entry.value, entry.err
+	}
+
+	c.nlocker.Lock(key)
+	defer c.nlocker.Unlock(key)
+
+	// Double check
+	if entry, found := c.cache[key]; found {
+		return entry.value, entry.err
+	}
+
+	// Create it.
+	value, err := create()
+
+	c.mu.Lock()
+	c.cache[key] = cacheEntry{value: value, err: err}
+	c.mu.Unlock()
+
+	return value, err
+}

cache/namedmemcache/named_cache_test.go

@@ -0,0 +1,80 @@
+// Copyright 2018 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 namedmemcache
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNamedCache(t *testing.T) {
+	t.Parallel()
+	assert := require.New(t)
+
+	cache := New()
+
+	counter := 0
+	create := func() (interface{}, error) {
+		counter++
+		return counter, nil
+	}
+
+	for i := 0; i < 5; i++ {
+		v1, err := cache.GetOrCreate("a1", create)
+		assert.NoError(err)
+		assert.Equal(1, v1)
+		v2, err := cache.GetOrCreate("a2", create)
+		assert.NoError(err)
+		assert.Equal(2, v2)
+	}
+
+	cache.Clear()
+
+	v3, err := cache.GetOrCreate("a2", create)
+	assert.NoError(err)
+	assert.Equal(3, v3)
+}
+
+func TestNamedCacheConcurrent(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	var wg sync.WaitGroup
+
+	cache := New()
+
+	create := func(i int) func() (interface{}, error) {
+		return func() (interface{}, error) {
+			return i, nil
+		}
+	}
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 100; j++ {
+				id := fmt.Sprintf("id%d", j)
+				v, err := cache.GetOrCreate(id, create(j))
+				assert.NoError(err)
+				assert.Equal(j, v)
+			}
+		}()
+	}
+	wg.Wait()
+}

cache/partitioned_lazy_cache.go

@@ -24,34 +24,52 @@ type Partition struct {
 	Load func() (map[string]interface{}, error)
 }
 
-type lazyPartition struct {
+// Lazy represents a lazily loaded cache.
+type Lazy struct {
 	initSync sync.Once
+	initErr  error
 	cache    map[string]interface{}
 	load     func() (map[string]interface{}, error)
 }
 
-func (l *lazyPartition) init() error {
-	var err error
+// NewLazy creates a lazy cache with the given load func.
+func NewLazy(load func() (map[string]interface{}, error)) *Lazy {
+	return &Lazy{load: load}
+}
+
+func (l *Lazy) init() error {
 	l.initSync.Do(func() {
-		var c map[string]interface{}
-		c, err = l.load()
+		c, err := l.load()
 		l.cache = c
+		l.initErr = err
+
 	})
 
-	return err
+	return l.initErr
+}
+
+// Get initializes the cache if not already initialized, then looks up the
+// given key.
+func (l *Lazy) Get(key string) (interface{}, bool, error) {
+	l.init()
+	if l.initErr != nil {
+		return nil, false, l.initErr
+	}
+	v, found := l.cache[key]
+	return v, found, nil
 }
 
 // PartitionedLazyCache is a lazily loaded cache paritioned by a supplied string key.
 type PartitionedLazyCache struct {
-	partitions map[string]*lazyPartition
+	partitions map[string]*Lazy
 }
 
 // NewPartitionedLazyCache creates a new NewPartitionedLazyCache with the supplied
 // partitions.
 func NewPartitionedLazyCache(partitions ...Partition) *PartitionedLazyCache {
-	lazyPartitions := make(map[string]*lazyPartition, len(partitions))
+	lazyPartitions := make(map[string]*Lazy, len(partitions))
 	for _, partition := range partitions {
-		lazyPartitions[partition.Key] = &lazyPartition{load: partition.Load}
+		lazyPartitions[partition.Key] = NewLazy(partition.Load)
 	}
 	cache := &PartitionedLazyCache{partitions: lazyPartitions}
 
@@ -67,11 +85,12 @@ func (c *PartitionedLazyCache) Get(partition, key string) (interface{}, error) {
 		return nil, nil
 	}
 
-	if err := p.init(); err != nil {
+	v, found, err := p.Get(key)
+	if err != nil {
 		return nil, err
 	}
 
-	if v, found := p.cache[key]; found {
+	if found {
 		return v, nil
 	}
 

commands/benchmark.go

@@ -1,115 +0,0 @@
-// Copyright 2015 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 commands
-
-import (
-	"os"
-	"runtime"
-	"runtime/pprof"
-	"time"
-
-	"github.com/spf13/cobra"
-	jww "github.com/spf13/jwalterweatherman"
-)
-
-type benchmarkCmd struct {
-	benchmarkTimes int
-	cpuProfileFile string
-	memProfileFile string
-
-	*baseBuilderCmd
-}
-
-func (b *commandsBuilder) newBenchmarkCmd() *benchmarkCmd {
-	cmd := &cobra.Command{
-		Use:   "benchmark",
-		Short: "Benchmark Hugo by building a site a number of times.",
-		Long: `Hugo can build a site many times over and analyze the running process
-creating a benchmark.`,
-	}
-
-	c := &benchmarkCmd{baseBuilderCmd: b.newBuilderCmd(cmd)}
-
-	cmd.Flags().StringVar(&c.cpuProfileFile, "cpuprofile", "", "path/filename for the CPU profile file")
-	cmd.Flags().StringVar(&c.memProfileFile, "memprofile", "", "path/filename for the memory profile file")
-	cmd.Flags().IntVarP(&c.benchmarkTimes, "count", "n", 13, "number of times to build the site")
-	cmd.Flags().Bool("renderToMemory", false, "render to memory (only useful for benchmark testing)")
-
-	cmd.RunE = c.benchmark
-
-	return c
-}
-
-func (c *benchmarkCmd) benchmark(cmd *cobra.Command, args []string) error {
-	cfgInit := func(c *commandeer) error {
-		return nil
-	}
-
-	comm, err := initializeConfig(true, false, &c.hugoBuilderCommon, c, cfgInit)
-	if err != nil {
-		return err
-	}
-
-	var memProf *os.File
-	if c.memProfileFile != "" {
-		memProf, err = os.Create(c.memProfileFile)
-		if err != nil {
-			return err
-		}
-	}
-
-	var cpuProf *os.File
-	if c.cpuProfileFile != "" {
-		cpuProf, err = os.Create(c.cpuProfileFile)
-		if err != nil {
-			return err
-		}
-	}
-
-	var memStats runtime.MemStats
-	runtime.ReadMemStats(&memStats)
-	memAllocated := memStats.TotalAlloc
-	mallocs := memStats.Mallocs
-	if cpuProf != nil {
-		pprof.StartCPUProfile(cpuProf)
-	}
-
-	t := time.Now()
-	for i := 0; i < c.benchmarkTimes; i++ {
-		if err = comm.resetAndBuildSites(); err != nil {
-			return err
-		}
-	}
-	totalTime := time.Since(t)
-
-	if memProf != nil {
-		pprof.WriteHeapProfile(memProf)
-		memProf.Close()
-	}
-	if cpuProf != nil {
-		pprof.StopCPUProfile()
-		cpuProf.Close()
-	}
-
-	runtime.ReadMemStats(&memStats)
-	totalMemAllocated := memStats.TotalAlloc - memAllocated
-	totalMallocs := memStats.Mallocs - mallocs
-
-	jww.FEEDBACK.Println()
-	jww.FEEDBACK.Printf("Average time per operation: %vms\n", int(1000*totalTime.Seconds()/float64(c.benchmarkTimes)))
-	jww.FEEDBACK.Printf("Average memory allocated per operation: %vkB\n", totalMemAllocated/uint64(c.benchmarkTimes)/1024)
-	jww.FEEDBACK.Printf("Average allocations per operation: %v\n", totalMallocs/uint64(c.benchmarkTimes))
-
-	return nil
-}

commands/commandeer.go

@@ -14,21 +14,30 @@
 package commands
 
 import (
+	"bytes"
+	"errors"
+
+	"io/ioutil"
+
+	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/hugo"
+
+	jww "github.com/spf13/jwalterweatherman"
+
 	"os"
 	"path/filepath"
 	"regexp"
+	"strings"
 	"sync"
 	"time"
 
+	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/config"
 
 	"github.com/spf13/cobra"
 
-	"github.com/gohugoio/hugo/utils"
-
-	"github.com/spf13/afero"
-
 	"github.com/gohugoio/hugo/hugolib"
+	"github.com/spf13/afero"
 
 	"github.com/bep/debounce"
 	"github.com/gohugoio/hugo/common/types"
@@ -47,6 +56,8 @@ type commandeerHugoState struct {
 type commandeer struct {
 	*commandeerHugoState
 
+	logger *loggers.Logger
+
 	// 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
@@ -70,8 +81,45 @@ type commandeer struct {
 	serverPorts         []int
 	languagesConfigured bool
 	languages           langs.Languages
+	doLiveReload        bool
+	fastRenderMode      bool
+	showErrorInBrowser  bool
 
 	configured bool
+	paused     bool
+
+	// Any error from the last build.
+	buildErr error
+}
+
+func (c *commandeer) errCount() int {
+	return int(c.logger.ErrorCounter.Count())
+}
+
+func (c *commandeer) getErrorWithContext() interface{} {
+	errCount := c.errCount()
+
+	if errCount == 0 {
+		return nil
+	}
+
+	m := make(map[string]interface{})
+
+	m["Error"] = errors.New(removeErrorPrefixFromLog(c.logger.Errors()))
+	m["Version"] = hugo.BuildVersionString()
+
+	fe := herrors.UnwrapErrorWithFileContext(c.buildErr)
+	if fe != nil {
+		m["File"] = fe
+	}
+
+	if c.h.verbose {
+		var b bytes.Buffer
+		herrors.FprintStackTrace(&b, c.buildErr)
+		m["StackTrace"] = b.String()
+	}
+
+	return m
 }
 
 func (c *commandeer) Set(key string, value interface{}) {
@@ -105,6 +153,8 @@ func newCommandeer(mustHaveConfigFile, running bool, h *hugoBuilderCommon, f fla
 		doWithCommandeer:    doWithCommandeer,
 		visitedURLs:         types.NewEvictingStringQueue(10),
 		debounce:            rebuildDebouncer,
+		// This will be replaced later, but we need something to log to before the configuration is read.
+		logger: loggers.NewLogger(jww.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, running),
 	}
 
 	return c, c.loadConfig(mustHaveConfigFile, running)
@@ -178,6 +228,11 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		c.DepsCfg = &deps.DepsCfg{}
 	}
 
+	if c.logger != nil {
+		// Truncate the error log if this is a reload.
+		c.logger.Reset()
+	}
+
 	cfg := c.DepsCfg
 	c.configured = false
 	cfg.Running = running
@@ -194,6 +249,8 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		sourceFs = c.DepsCfg.Fs.Source
 	}
 
+	environment := c.h.getEnvironment(running)
+
 	doWithConfig := func(cfg config.Provider) error {
 
 		if c.ftch != nil {
@@ -201,7 +258,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		}
 
 		cfg.Set("workingDir", dir)
-
+		cfg.Set("environment", environment)
 		return nil
 	}
 
@@ -214,8 +271,18 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		return err
 	}
 
+	configPath := c.h.source
+	if configPath == "" {
+		configPath = dir
+	}
 	config, configFiles, err := hugolib.LoadConfig(
-		hugolib.ConfigSourceDescriptor{Fs: sourceFs, Path: c.h.source, WorkingDir: dir, Filename: c.h.cfgFile},
+		hugolib.ConfigSourceDescriptor{
+			Fs:           sourceFs,
+			Path:         configPath,
+			WorkingDir:   dir,
+			Filename:     c.h.cfgFile,
+			AbsConfigDir: c.h.getConfigDir(dir),
+			Environment:  environment},
 		doWithCommandeer,
 		doWithConfig)
 
@@ -236,6 +303,11 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		c.languages = l
 	}
 
+	// Set some commonly used flags
+	c.doLiveReload = !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
+	c.fastRenderMode = c.doLiveReload && !c.Cfg.GetBool("disableFastRender")
+	c.showErrorInBrowser = c.doLiveReload && !c.Cfg.GetBool("disableBrowserError")
+
 	// This is potentially double work, but we need to do this one more time now
 	// that all the languages have been configured.
 	if c.doWithCommandeer != nil {
@@ -244,12 +316,13 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		}
 	}
 
-	logger, err := c.createLogger(config)
+	logger, err := c.createLogger(config, running)
 	if err != nil {
 		return err
 	}
 
 	cfg.Logger = logger
+	c.logger = logger
 
 	createMemFs := config.GetBool("renderToMemory")
 
@@ -269,10 +342,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 			fs.Destination = new(afero.MemMapFs)
 		}
 
-		doLiveReload := !c.h.buildWatch && !config.GetBool("disableLiveReload")
-		fastRenderMode := doLiveReload && !config.GetBool("disableFastRender")
-
-		if fastRenderMode {
+		if c.fastRenderMode {
 			// For now, fast render mode only. It should, however, be fast enough
 			// for the full variant, too.
 			changeDetector := &fileChangeDetector{
@@ -302,20 +372,11 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		return err
 	}
 
-	cacheDir := config.GetString("cacheDir")
-	if cacheDir != "" {
-		if helpers.FilePathSeparator != cacheDir[len(cacheDir)-1:] {
-			cacheDir = cacheDir + helpers.FilePathSeparator
-		}
-		isDir, err := helpers.DirExists(cacheDir, sourceFs)
-		utils.CheckErr(cfg.Logger, err)
-		if !isDir {
-			mkdir(cacheDir)
-		}
-		config.Set("cacheDir", cacheDir)
-	} else {
-		config.Set("cacheDir", helpers.GetTempDir("hugo_cache", sourceFs))
+	cacheDir, err := helpers.GetCacheDir(sourceFs, config)
+	if err != nil {
+		return err
 	}
+	config.Set("cacheDir", cacheDir)
 
 	cfg.Logger.INFO.Println("Using config file:", config.ConfigFileUsed())
 
@@ -326,11 +387,12 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		}
 	}
 
-	themeVersionMismatch, minVersion := c.isThemeVsHugoVersionMismatch(sourceFs)
+	dir, themeVersionMismatch, minVersion := c.isThemeVsHugoVersionMismatch(sourceFs)
 
 	if themeVersionMismatch {
-		cfg.Logger.ERROR.Printf("Current theme does not support Hugo version %s. Minimum version required is %s\n",
-			helpers.CurrentHugoVersion.ReleaseVersion(), minVersion)
+		name := filepath.Base(dir)
+		cfg.Logger.ERROR.Printf("%s theme does not support Hugo version %s. Minimum version required is %s\n",
+			strings.ToUpper(name), hugo.CurrentVersion.ReleaseVersion(), minVersion)
 	}
 
 	return nil

commands/commands.go

@@ -14,10 +14,15 @@
 package commands
 
 import (
+	"os"
+
+	"github.com/gohugoio/hugo/hugolib/paths"
+
+	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/spf13/cobra"
-
 	"github.com/spf13/nitro"
 )
 
@@ -43,9 +48,8 @@ func (b *commandsBuilder) addAll() *commandsBuilder {
 		newEnvCmd(),
 		newConfigCmd(),
 		newCheckCmd(),
-		b.newBenchmarkCmd(),
 		newConvertCmd(),
-		newNewCmd(),
+		b.newNewCmd(),
 		newListCmd(),
 		newImportCmd(),
 		newGenCmd(),
@@ -79,14 +83,14 @@ var _ commandsBuilderGetter = (*baseBuilderCmd)(nil)
 
 // Used in tests.
 type commandsBuilderGetter interface {
-	getCmmandsBuilder() *commandsBuilder
+	getCommandsBuilder() *commandsBuilder
 }
 type baseBuilderCmd struct {
 	*baseCmd
 	*commandsBuilder
 }
 
-func (b *baseBuilderCmd) getCmmandsBuilder() *commandsBuilder {
+func (b *baseBuilderCmd) getCommandsBuilder() *commandsBuilder {
 	return b.commandsBuilder
 }
 
@@ -159,6 +163,7 @@ Complete documentation is available at http://gohugo.io/.`,
 	})
 
 	cc.cmd.PersistentFlags().StringVar(&cc.cfgFile, "config", "", "config file (default is path/config.yaml|json|toml)")
+	cc.cmd.PersistentFlags().StringVar(&cc.cfgDir, "configDir", "config", "config dir")
 	cc.cmd.PersistentFlags().BoolVar(&cc.quiet, "quiet", false, "build in quiet mode")
 
 	// Set bash-completion
@@ -185,8 +190,9 @@ Complete documentation is available at http://gohugo.io/.`,
 }
 
 type hugoBuilderCommon struct {
-	source  string
-	baseURL string
+	source      string
+	baseURL     string
+	environment string
 
 	buildWatch bool
 
@@ -200,15 +206,45 @@ type hugoBuilderCommon struct {
 	quiet      bool
 
 	cfgFile string
+	cfgDir  string
 	logFile string
 }
 
+func (cc *hugoBuilderCommon) getConfigDir(baseDir string) string {
+	if cc.cfgDir != "" {
+		return paths.AbsPathify(baseDir, cc.cfgDir)
+	}
+
+	if v, found := os.LookupEnv("HUGO_CONFIGDIR"); found {
+		return paths.AbsPathify(baseDir, v)
+	}
+
+	return paths.AbsPathify(baseDir, "config")
+}
+
+func (cc *hugoBuilderCommon) getEnvironment(isServer bool) string {
+	if cc.environment != "" {
+		return cc.environment
+	}
+
+	if v, found := os.LookupEnv("HUGO_ENVIRONMENT"); found {
+		return v
+	}
+
+	if isServer {
+		return hugo.EnvironmentDevelopment
+	}
+
+	return hugo.EnvironmentProduction
+}
+
 func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 	cmd.Flags().Bool("cleanDestinationDir", false, "remove files from destination not found in static directories")
 	cmd.Flags().BoolP("buildDrafts", "D", false, "include content marked as draft")
 	cmd.Flags().BoolP("buildFuture", "F", false, "include content with publishdate in the future")
 	cmd.Flags().BoolP("buildExpired", "E", false, "include expired content")
 	cmd.Flags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
+	cmd.Flags().StringVarP(&cc.environment, "environment", "e", "", "build environment")
 	cmd.Flags().StringP("contentDir", "c", "", "filesystem path to content directory")
 	cmd.Flags().StringP("layoutDir", "l", "", "filesystem path to layout directory")
 	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/")
@@ -216,8 +252,6 @@ func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("destination", "d", "", "filesystem path to write files to")
 	cmd.Flags().StringP("theme", "t", "", "theme to use (located in /themes/THEMENAME/)")
 	cmd.Flags().StringP("themesDir", "", "", "filesystem path to themes directory")
-	cmd.Flags().Bool("uglyURLs", false, "(deprecated) if true, use /filename.html instead of /filename/")
-	cmd.Flags().Bool("canonifyURLs", false, "(deprecated) if true, all relative URLs will be canonicalized using baseURL")
 	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")
@@ -225,8 +259,6 @@ func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 	cmd.Flags().BoolVar(&nitro.AnalysisOn, "stepAnalysis", false, "display memory and timing of different steps of the program")
 	cmd.Flags().Bool("templateMetrics", false, "display metrics about template executions")
 	cmd.Flags().Bool("templateMetricsHints", false, "calculate some improvement hints when combined with --templateMetrics")
-	cmd.Flags().Bool("pluralizeListTitles", true, "(deprecated) pluralize titles in lists using inflect")
-	cmd.Flags().Bool("preserveTaxonomyNames", false, `(deprecated) preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")`)
 	cmd.Flags().BoolP("forceSyncStatic", "", false, "copy all files when static is changed.")
 	cmd.Flags().BoolP("noTimes", "", false, "don't sync modification time of files")
 	cmd.Flags().BoolP("noChmod", "", false, "don't sync permission mode of files")
@@ -234,6 +266,8 @@ func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringSlice("disableKinds", []string{}, "disable different kind of pages (home, RSS etc.)")
 
+	cmd.Flags().Bool("minify", false, "minify any supported output format (HTML, XML etc.)")
+
 	// Set bash-completion.
 	// Each flag must first be defined before using the SetAnnotation() call.
 	_ = cmd.Flags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
@@ -241,3 +275,17 @@ func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 	_ = cmd.Flags().SetAnnotation("destination", cobra.BashCompSubdirsInDir, []string{})
 	_ = cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
 }
+
+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.ERROR.Println(err)
+}

commands/commands_test.go

@@ -56,8 +56,11 @@ func TestCommandsPersistentFlags(t *testing.T) {
 		check func(command []cmder)
 	}{{[]string{"server",
 		"--config=myconfig.toml",
+		"--configDir=myconfigdir",
 		"--contentDir=mycontent",
 		"--disableKinds=page,home",
+		"--environment=testing",
+		"--configDir=myconfigdir",
 		"--layoutDir=mylayouts",
 		"--theme=mytheme",
 		"--gc",
@@ -72,12 +75,13 @@ func TestCommandsPersistentFlags(t *testing.T) {
 		"--port=1366",
 		"--renderToDisk",
 		"--source=mysource",
-		"--uglyURLs"}, func(commands []cmder) {
+	}, func(commands []cmder) {
 		var sc *serverCmd
 		for _, command := range commands {
 			if b, ok := command.(commandsBuilderGetter); ok {
-				v := b.getCmmandsBuilder().hugoBuilderCommon
+				v := b.getCommandsBuilder().hugoBuilderCommon
 				assert.Equal("myconfig.toml", v.cfgFile)
+				assert.Equal("myconfigdir", v.cfgDir)
 				assert.Equal("mysource", v.source)
 				assert.Equal("https://example.com/b/", v.baseURL)
 			}
@@ -93,6 +97,7 @@ func TestCommandsPersistentFlags(t *testing.T) {
 		assert.True(sc.noHTTPCache)
 		assert.True(sc.renderToDisk)
 		assert.Equal(1366, sc.serverPort)
+		assert.Equal("testing", sc.environment)
 
 		cfg := viper.New()
 		sc.flagsToConfig(cfg)
@@ -105,7 +110,6 @@ func TestCommandsPersistentFlags(t *testing.T) {
 
 		assert.Equal([]string{"page", "home"}, cfg.Get("disableKinds"))
 
-		assert.True(cfg.GetBool("uglyURLs"))
 		assert.True(cfg.GetBool("gc"))
 
 		// The flag is named i18n-warnings
@@ -161,7 +165,6 @@ func TestCommandsExecute(t *testing.T) {
 		{nil, []string{sourceFlag}, ""},
 		{nil, []string{sourceFlag, "--renderToMemory"}, ""},
 		{[]string{"config"}, []string{sourceFlag}, ""},
-		{[]string{"benchmark"}, []string{sourceFlag, "-n=1"}, ""},
 		{[]string{"convert", "toTOML"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "toml")}, ""},
 		{[]string{"convert", "toYAML"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "yaml")}, ""},
 		{[]string{"convert", "toJSON"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "json")}, ""},
@@ -234,6 +237,7 @@ Single: {{ .Title }}
 	writeFile(t, filepath.Join(d, "layouts", "_default", "list.html"), `
 
 List: {{ .Title }}
+Environment: {{ hugo.Environment }}
 
 `)
 

commands/convert.go

@@ -14,17 +14,27 @@
 package commands
 
 import (
+	"bytes"
 	"fmt"
+	"io"
+	"strings"
 	"time"
 
+	"github.com/gohugoio/hugo/hugofs"
+
+	"github.com/gohugoio/hugo/helpers"
+
+	"github.com/gohugoio/hugo/parser"
+	"github.com/gohugoio/hugo/parser/metadecoders"
+	"github.com/gohugoio/hugo/parser/pageparser"
+
 	src "github.com/gohugoio/hugo/source"
+	"github.com/pkg/errors"
 
 	"github.com/gohugoio/hugo/hugolib"
 
 	"path/filepath"
 
-	"github.com/gohugoio/hugo/parser"
-	"github.com/spf13/cast"
 	"github.com/spf13/cobra"
 )
 
@@ -60,7 +70,7 @@ See convert's subcommands toJSON, toTOML and toYAML for more information.`,
 			Long: `toJSON converts all front matter in the content directory
 to use JSON for the front matter.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				return cc.convertContents(rune([]byte(parser.JSONLead)[0]))
+				return cc.convertContents(metadecoders.JSON)
 			},
 		},
 		&cobra.Command{
@@ -69,7 +79,7 @@ to use JSON for the front matter.`,
 			Long: `toTOML converts all front matter in the content directory
 to use TOML for the front matter.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				return cc.convertContents(rune([]byte(parser.TOMLLead)[0]))
+				return cc.convertContents(metadecoders.TOML)
 			},
 		},
 		&cobra.Command{
@@ -78,7 +88,7 @@ to use TOML for the front matter.`,
 			Long: `toYAML converts all front matter in the content directory
 to use YAML for the front matter.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				return cc.convertContents(rune([]byte(parser.YAMLLead)[0]))
+				return cc.convertContents(metadecoders.YAML)
 			},
 		},
 	)
@@ -91,7 +101,7 @@ to use YAML for the front matter.`,
 	return cc
 }
 
-func (cc *convertCmd) convertContents(mark rune) error {
+func (cc *convertCmd) convertContents(format metadecoders.Format) error {
 	if cc.outputDir == "" && !cc.unsafe {
 		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
 	}
@@ -101,6 +111,8 @@ func (cc *convertCmd) convertContents(mark rune) error {
 		return err
 	}
 
+	c.Cfg.Set("buildDrafts", true)
+
 	h, err := hugolib.NewHugoSites(*c.DepsCfg)
 	if err != nil {
 		return err
@@ -114,17 +126,17 @@ func (cc *convertCmd) convertContents(mark rune) error {
 
 	site.Log.FEEDBACK.Println("processing", len(site.AllPages), "content files")
 	for _, p := range site.AllPages {
-		if err := cc.convertAndSavePage(p, site, mark); err != nil {
+		if err := cc.convertAndSavePage(p, site, format); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (cc *convertCmd) convertAndSavePage(p *hugolib.Page, site *hugolib.Site, mark rune) error {
+func (cc *convertCmd) convertAndSavePage(p *hugolib.Page, site *hugolib.Site, targetFormat metadecoders.Format) error {
 	// The resources are not in .Site.AllPages.
 	for _, r := range p.Resources.ByType("page") {
-		if err := cc.convertAndSavePage(r.(*hugolib.Page), site, mark); err != nil {
+		if err := cc.convertAndSavePage(r.(*hugolib.Page), site, targetFormat); err != nil {
 			return err
 		}
 	}
@@ -134,61 +146,104 @@ func (cc *convertCmd) convertAndSavePage(p *hugolib.Page, site *hugolib.Site, ma
 		return nil
 	}
 
+	errMsg := fmt.Errorf("Error processing file %q", p.Path())
+
 	site.Log.INFO.Println("Attempting to convert", p.LogicalName())
-	newPage, err := site.NewPage(p.LogicalName())
-	if err != nil {
-		return err
-	}
 
 	f, _ := p.File.(src.ReadableFile)
 	file, err := f.Open()
 	if err != nil {
-		site.Log.ERROR.Println("Error reading file:", p.Path())
+		site.Log.ERROR.Println(errMsg)
 		file.Close()
 		return nil
 	}
 
-	psr, err := parser.ReadFrom(file)
+	pf, err := parseContentFile(file)
 	if err != nil {
-		site.Log.ERROR.Println("Error processing file:", p.Path())
+		site.Log.ERROR.Println(errMsg)
 		file.Close()
 		return err
 	}
 
 	file.Close()
 
-	metadata, err := psr.Metadata()
+	// better handling of dates in formats that don't have support for them
+	if pf.frontMatterFormat == metadecoders.JSON || pf.frontMatterFormat == metadecoders.YAML || pf.frontMatterFormat == metadecoders.TOML {
+		for k, v := range pf.frontMatter {
+			switch vv := v.(type) {
+			case time.Time:
+				pf.frontMatter[k] = vv.Format(time.RFC3339)
+			}
+		}
+	}
+
+	var newContent bytes.Buffer
+	err = parser.InterfaceToFrontMatter(pf.frontMatter, targetFormat, &newContent)
 	if err != nil {
-		site.Log.ERROR.Println("Error processing file:", p.Path())
+		site.Log.ERROR.Println(errMsg)
 		return err
 	}
 
-	// better handling of dates in formats that don't have support for them
-	if mark == parser.FormatToLeadRune("json") || mark == parser.FormatToLeadRune("yaml") || mark == parser.FormatToLeadRune("toml") {
-		newMetadata := cast.ToStringMap(metadata)
-		for k, v := range newMetadata {
-			switch vv := v.(type) {
-			case time.Time:
-				newMetadata[k] = vv.Format(time.RFC3339)
-			}
-		}
-		metadata = newMetadata
-	}
-
-	newPage.SetSourceContent(psr.Content())
-	if err = newPage.SetSourceMetaData(metadata, mark); err != nil {
-		site.Log.ERROR.Printf("Failed to set source metadata for file %q: %s. For more info see For more info see https://github.com/gohugoio/hugo/issues/2458", newPage.FullFilePath(), err)
-		return nil
-	}
+	newContent.Write(pf.content)
 
 	newFilename := p.Filename()
+
 	if cc.outputDir != "" {
-		newFilename = filepath.Join(cc.outputDir, p.Dir(), newPage.LogicalName())
+		contentDir := strings.TrimSuffix(newFilename, p.Path())
+		contentDir = filepath.Base(contentDir)
+
+		newFilename = filepath.Join(cc.outputDir, contentDir, p.Path())
 	}
 
-	if err = newPage.SaveSourceAs(newFilename); err != nil {
-		return fmt.Errorf("Failed to save file %q: %s", newFilename, err)
+	fs := hugofs.Os
+	if err := helpers.WriteToDisk(newFilename, &newContent, fs); err != nil {
+		return errors.Wrapf(err, "Failed to save file %q:", newFilename)
 	}
 
 	return nil
 }
+
+type parsedFile struct {
+	frontMatterFormat metadecoders.Format
+	frontMatterSource []byte
+	frontMatter       map[string]interface{}
+
+	// Everything after Front Matter
+	content []byte
+}
+
+func parseContentFile(r io.Reader) (parsedFile, error) {
+	var pf parsedFile
+
+	psr, err := pageparser.Parse(r, pageparser.Config{})
+	if err != nil {
+		return pf, err
+	}
+
+	iter := psr.Iterator()
+
+	walkFn := func(item pageparser.Item) bool {
+		if pf.frontMatterSource != nil {
+			// The rest is content.
+			pf.content = psr.Input()[item.Pos:]
+			// Done
+			return false
+		} else if item.IsFrontMatter() {
+			pf.frontMatterFormat = metadecoders.FormatFromFrontMatterType(item.Type)
+			pf.frontMatterSource = item.Val
+		}
+		return true
+
+	}
+
+	iter.PeekWalk(walkFn)
+
+	metadata, err := metadecoders.Default.UnmarshalToMap(pf.frontMatterSource, pf.frontMatterFormat)
+	if err != nil {
+		return pf, err
+	}
+	pf.frontMatter = metadata
+
+	return pf, nil
+
+}

commands/genman.go

@@ -17,6 +17,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/spf13/cobra"
@@ -45,7 +46,7 @@ in the "man" directory under the current directory.`,
 			header := &doc.GenManHeader{
 				Section: "1",
 				Manual:  "Hugo Manual",
-				Source:  fmt.Sprintf("Hugo %s", helpers.CurrentHugoVersion),
+				Source:  fmt.Sprintf("Hugo %s", hugo.CurrentVersion),
 			}
 			if !strings.HasSuffix(cc.genmandir, helpers.FilePathSeparator) {
 				cc.genmandir += helpers.FilePathSeparator

commands/helpers.go

@@ -23,6 +23,13 @@ import (
 	"github.com/spf13/cobra"
 )
 
+const (
+	ansiEsc    = "\u001B"
+	clearLine  = "\r\033[K"
+	hideCursor = ansiEsc + "[?25l"
+	showCursor = ansiEsc + "[?25h"
+)
+
 type flagsToConfigHandler interface {
 	flagsToConfig(cfg config.Provider)
 }

commands/hugo.go

@@ -18,16 +18,24 @@ package commands
 import (
 	"fmt"
 	"io/ioutil"
+
 	"os/signal"
 	"sort"
 	"sync/atomic"
+
+	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/pkg/errors"
+
+	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/loggers"
+	"github.com/gohugoio/hugo/common/terminal"
+
 	"syscall"
 
 	"github.com/gohugoio/hugo/hugolib/filesystems"
 
 	"golang.org/x/sync/errgroup"
 
-	"log"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -36,14 +44,13 @@ import (
 
 	"github.com/gohugoio/hugo/config"
 
-	"github.com/gohugoio/hugo/parser"
+	"github.com/gohugoio/hugo/parser/metadecoders"
 	flag "github.com/spf13/pflag"
 
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/livereload"
-	"github.com/gohugoio/hugo/utils"
 	"github.com/gohugoio/hugo/watcher"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
@@ -63,6 +70,8 @@ type Response struct {
 	Cmd *cobra.Command
 }
 
+// IsUserError returns true is the Response error is a user error rather than a
+// system error.
 func (r Response) IsUserError() bool {
 	return r.Err != nil && isUserError(r.Err)
 }
@@ -84,7 +93,7 @@ func Execute(args []string) Response {
 	}
 
 	if err == nil {
-		errCount := int(jww.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError))
+		errCount := int(loggers.GlobalErrorCounter.Count())
 		if errCount > 0 {
 			err = fmt.Errorf("logged %d errors", errCount)
 		} else if resp.Result != nil {
@@ -117,13 +126,13 @@ func initializeConfig(mustHaveConfigFile, running bool,
 
 }
 
-func (c *commandeer) createLogger(cfg config.Provider) (*jww.Notepad, error) {
+func (c *commandeer) createLogger(cfg config.Provider, running bool) (*loggers.Logger, error) {
 	var (
 		logHandle       = ioutil.Discard
 		logThreshold    = jww.LevelWarn
 		logFile         = cfg.GetString("logFile")
 		outHandle       = os.Stdout
-		stdoutThreshold = jww.LevelError
+		stdoutThreshold = jww.LevelWarn
 	)
 
 	if c.h.verboseLog || c.h.logging || (c.h.logFile != "") {
@@ -154,13 +163,10 @@ func (c *commandeer) createLogger(cfg config.Provider) (*jww.Notepad, error) {
 		}
 	}
 
-	// The global logger is used in some few cases.
-	jww.SetLogOutput(logHandle)
-	jww.SetLogThreshold(logThreshold)
-	jww.SetStdoutThreshold(stdoutThreshold)
+	loggers.InitGlobalLogger(stdoutThreshold, logThreshold, outHandle, logHandle)
 	helpers.InitLoggers()
 
-	return jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime), nil
+	return loggers.NewLogger(stdoutThreshold, logThreshold, outHandle, logHandle, running), nil
 }
 
 func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
@@ -210,35 +216,31 @@ func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
 		"verboseLog",
 	}
 
+	// Will set a value even if it is the default.
+	flagKeysForced := []string{
+		"minify",
+	}
+
 	for _, key := range persFlagKeys {
-		setValueFromFlag(cmd.PersistentFlags(), key, cfg, "")
+		setValueFromFlag(cmd.PersistentFlags(), key, cfg, "", false)
 	}
 	for _, key := range flagKeys {
-		setValueFromFlag(cmd.Flags(), key, cfg, "")
+		setValueFromFlag(cmd.Flags(), key, cfg, "", false)
+	}
+
+	for _, key := range flagKeysForced {
+		setValueFromFlag(cmd.Flags(), key, cfg, "", true)
 	}
 
 	// Set some "config aliases"
-	setValueFromFlag(cmd.Flags(), "destination", cfg, "publishDir")
-	setValueFromFlag(cmd.Flags(), "i18n-warnings", cfg, "logI18nWarnings")
+	setValueFromFlag(cmd.Flags(), "destination", cfg, "publishDir", false)
+	setValueFromFlag(cmd.Flags(), "i18n-warnings", cfg, "logI18nWarnings", false)
 
 }
 
-var deprecatedFlags = map[string]bool{
-	strings.ToLower("uglyURLs"):              true,
-	strings.ToLower("pluralizeListTitles"):   true,
-	strings.ToLower("preserveTaxonomyNames"): true,
-	strings.ToLower("canonifyURLs"):          true,
-}
-
-func setValueFromFlag(flags *flag.FlagSet, key string, cfg config.Provider, targetKey string) {
+func setValueFromFlag(flags *flag.FlagSet, key string, cfg config.Provider, targetKey string, force bool) {
 	key = strings.TrimSpace(key)
-	if flags.Changed(key) {
-		if _, deprecated := deprecatedFlags[strings.ToLower(key)]; deprecated {
-			msg := fmt.Sprintf(`Set "%s = true" in your config.toml.
-If you need to set this configuration value from the command line, set it via an OS environment variable: "HUGO_%s=true hugo"`, key, strings.ToUpper(key))
-			// Remove in Hugo 0.38
-			helpers.Deprecated("hugo", "--"+key+" flag", msg, true)
-		}
+	if (force && flags.Lookup(key) != nil) || flags.Changed(key) {
 		f := flags.Lookup(key)
 		configKey := key
 		if targetKey != "" {
@@ -261,6 +263,17 @@ If you need to set this configuration value from the command line, set it via an
 	}
 }
 
+func isTerminal() bool {
+	return terminal.IsTerminal(os.Stdout)
+
+}
+func ifTerminal(s string) string {
+	if !isTerminal() {
+		return ""
+	}
+	return s
+}
+
 func (c *commandeer) fullBuild() error {
 	var (
 		g         errgroup.Group
@@ -268,19 +281,21 @@ func (c *commandeer) fullBuild() error {
 	)
 
 	if !c.h.quiet {
-		fmt.Print(hideCursor + "Building sites … ")
-		defer func() {
-			fmt.Print(showCursor + clearLine)
-		}()
+		fmt.Print(ifTerminal(hideCursor) + "Building sites … ")
+		if isTerminal() {
+			defer func() {
+				fmt.Print(showCursor + clearLine)
+			}()
+		}
 	}
 
 	copyStaticFunc := func() error {
 		cnt, err := c.copyStatic()
 		if err != nil {
 			if !os.IsNotExist(err) {
-				return fmt.Errorf("Error copying static files: %s", err)
+				return errors.Wrap(err, "Error copying static files")
 			}
-			c.Logger.WARN.Println("No Static directory found")
+			c.logger.INFO.Println("No Static directory found")
 		}
 		langCount = cnt
 		langCount = cnt
@@ -288,7 +303,7 @@ func (c *commandeer) fullBuild() error {
 	}
 	buildSitesFunc := func() error {
 		if err := c.buildSites(); err != nil {
-			return fmt.Errorf("Error building site: %s", err)
+			return errors.Wrap(err, "Error building site")
 		}
 		return nil
 	}
@@ -348,10 +363,10 @@ func (c *commandeer) build() error {
 		if err != nil {
 			return err
 		}
-		c.Logger.FEEDBACK.Println("Watching for changes in", c.hugo.PathSpec.AbsPathify(c.Cfg.GetString("contentDir")))
-		c.Logger.FEEDBACK.Println("Press Ctrl+C to stop")
+		c.logger.FEEDBACK.Println("Watching for changes in", c.hugo.PathSpec.AbsPathify(c.Cfg.GetString("contentDir")))
+		c.logger.FEEDBACK.Println("Press Ctrl+C to stop")
 		watcher, err := c.newWatcher(watchDirs...)
-		utils.CheckErr(c.Logger, err)
+		checkErr(c.Logger, err)
 		defer watcher.Close()
 
 		var sigs = make(chan os.Signal)
@@ -391,7 +406,7 @@ func (c *commandeer) doWithPublishDirs(f func(sourceFs *filesystems.SourceFilesy
 	staticFilesystems := c.hugo.BaseFs.SourceFilesystems.Static
 
 	if len(staticFilesystems) == 0 {
-		c.Logger.WARN.Println("No static directories found to sync")
+		c.logger.INFO.Println("No static directories found to sync")
 		return langCount, nil
 	}
 
@@ -451,13 +466,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.INFO.Println("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.INFO.Println("syncing static files to", publishDir)
 
 	var err error
 
@@ -483,7 +498,7 @@ func (c *commandeer) timeTrack(start time.Time, name string) {
 		return
 	}
 	elapsed := time.Since(start)
-	c.Logger.FEEDBACK.Printf("%s in %v ms", name, int(1000*elapsed.Seconds()))
+	c.logger.FEEDBACK.Printf("%s in %v ms", name, int(1000*elapsed.Seconds()))
 }
 
 // getDirList provides NewWatcher() with a list of directories to watch for changes.
@@ -501,7 +516,7 @@ func (c *commandeer) getDirList() ([]string, error) {
 					return nil
 				}
 
-				c.Logger.ERROR.Println("Walker: ", err)
+				c.logger.ERROR.Println("Walker: ", err)
 				return nil
 			}
 
@@ -514,16 +529,16 @@ func (c *commandeer) getDirList() ([]string, error) {
 			if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
 				link, err := filepath.EvalSymlinks(path)
 				if err != nil {
-					c.Logger.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", path, err)
+					c.logger.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", path, err)
 					return nil
 				}
 				linkfi, err := helpers.LstatIfPossible(c.Fs.Source, link)
 				if err != nil {
-					c.Logger.ERROR.Printf("Cannot stat %q: %s", link, err)
+					c.logger.ERROR.Printf("Cannot stat %q: %s", link, err)
 					return nil
 				}
 				if !allowSymbolicDirs && !linkfi.Mode().IsRegular() {
-					c.Logger.ERROR.Printf("Symbolic links for directories not supported, skipping %q", path)
+					c.logger.ERROR.Printf("Symbolic links for directories not supported, skipping %q", path)
 					return nil
 				}
 
@@ -606,7 +621,7 @@ func (c *commandeer) getDirList() ([]string, error) {
 
 func (c *commandeer) resetAndBuildSites() (err error) {
 	if !c.h.quiet {
-		c.Logger.FEEDBACK.Println("Started building sites ...")
+		c.logger.FEEDBACK.Println("Started building sites ...")
 	}
 	return c.hugo.Build(hugolib.BuildCfg{ResetState: true})
 }
@@ -615,12 +630,22 @@ func (c *commandeer) buildSites() (err error) {
 	return c.hugo.Build(hugolib.BuildCfg{})
 }
 
+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()))
+	if !c.h.quiet && c.h.verbose {
+		herrors.PrintStackTrace(err)
+	}
+}
+
 func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
 	defer c.timeTrack(time.Now(), "Total")
 
+	c.buildErr = nil
 	visited := c.visitedURLs.PeekAllSet()
-	doLiveReload := !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
-	if doLiveReload && !c.Cfg.GetBool("disableFastRender") {
+	if c.fastRenderMode {
 
 		// Make sure we always render the home pages
 		for _, l := range c.languages {
@@ -628,7 +653,7 @@ func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
 			if langPath != "" {
 				langPath = langPath + "/"
 			}
-			home := c.hugo.PathSpec.PrependBasePath("/" + langPath)
+			home := c.hugo.PathSpec.PrependBasePath("/"+langPath, false)
 			visited[home] = true
 		}
 
@@ -636,14 +661,34 @@ func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
 	return c.hugo.Build(hugolib.BuildCfg{RecentlyVisited: visited}, events...)
 }
 
+func (c *commandeer) partialReRender(urls ...string) error {
+	c.buildErr = nil
+	visited := make(map[string]bool)
+	for _, url := range urls {
+		visited[url] = true
+	}
+	return c.hugo.Build(hugolib.BuildCfg{RecentlyVisited: visited, PartialReRender: true})
+}
+
 func (c *commandeer) fullRebuild() {
 	c.commandeerHugoState = &commandeerHugoState{}
-	if err := c.loadConfig(true, true); err != nil {
-		jww.ERROR.Println("Failed to reload config:", err)
-	} else if err := c.buildSites(); err != nil {
-		jww.ERROR.Println(err)
-	} else if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
-		livereload.ForceRefresh()
+	err := c.loadConfig(true, true)
+	if err != nil {
+		// Set the processing on pause until the state is recovered.
+		c.paused = true
+		c.handleBuildErr(err, "Failed to reload config")
+
+	} else {
+		c.paused = false
+	}
+
+	if !c.paused {
+		err := c.buildSites()
+		if err != nil {
+			c.logger.ERROR.Println(err)
+		} else if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
+			livereload.ForceRefresh()
+		}
 	}
 }
 
@@ -673,8 +718,8 @@ 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, ", "))
 	for _, configFile := range c.configFiles {
-		c.Logger.FEEDBACK.Println("Watching for config changes in", configFile)
 		watcher.Add(configFile)
 		configSet[configFile] = true
 	}
@@ -683,215 +728,14 @@ func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
 		for {
 			select {
 			case evs := <-watcher.Events:
-				if len(evs) > 50 {
-					// This is probably a mass edit of the content dir.
-					// Schedule a full rebuild for when it slows down.
-					c.debounce(c.fullRebuild)
-					continue
-				}
-
-				c.Logger.INFO.Println("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 configSet[ev.Name] {
-						if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
-							continue
-						}
-						// Config file changed. Need full rebuild.
-						c.fullRebuild()
-						break
-					}
-
-					// Check the most specific first, i.e. files.
-					contentMapped := c.hugo.ContentChanges.GetSymbolicLinkMappings(ev.Name)
-					if len(contentMapped) > 0 {
-						for _, mapped := range contentMapped {
-							filtered = append(filtered, fsnotify.Event{Name: mapped, Op: ev.Op})
-						}
-						continue
-					}
-
-					// Check for any symbolic directory mapping.
-
-					dir, name := filepath.Split(ev.Name)
-
-					contentMapped = c.hugo.ContentChanges.GetSymbolicLinkMappings(dir)
-
-					if len(contentMapped) == 0 {
-						filtered = append(filtered, ev)
-						continue
-					}
-
-					for _, mapped := range contentMapped {
-						mappedFilename := filepath.Join(mapped, name)
-						filtered = append(filtered, fsnotify.Event{Name: mappedFilename, Op: ev.Op})
-					}
-				}
-
-				evs = filtered
-
-				for _, ev := range evs {
-					ext := filepath.Ext(ev.Name)
-					baseName := filepath.Base(ev.Name)
-					istemp := strings.HasSuffix(ext, "~") ||
-						(ext == ".swp") || // vim
-						(ext == ".swx") || // vim
-						(ext == ".tmp") || // generic temp file
-						(ext == ".DS_Store") || // OSX Thumbnail
-						baseName == "4913" || // vim
-						strings.HasPrefix(ext, ".goutputstream") || // gnome
-						strings.HasSuffix(ext, "jb_old___") || // intelliJ
-						strings.HasSuffix(ext, "jb_tmp___") || // intelliJ
-						strings.HasSuffix(ext, "jb_bak___") || // intelliJ
-						strings.HasPrefix(ext, ".sb-") || // byword
-						strings.HasPrefix(baseName, ".#") || // emacs
-						strings.HasPrefix(baseName, "#") // emacs
-					if istemp {
-						continue
-					}
-					// Sometimes during rm -rf operations a '"": REMOVE' is triggered. Just ignore these
-					if ev.Name == "" {
-						continue
-					}
-
-					// Write and rename operations are often followed by CHMOD.
-					// There may be valid use cases for rebuilding the site on CHMOD,
-					// but that will require more complex logic than this simple conditional.
-					// On OS X this seems to be related to Spotlight, see:
-					// https://github.com/go-fsnotify/fsnotify/issues/15
-					// A workaround is to put your site(s) on the Spotlight exception list,
-					// but that may be a little mysterious for most end users.
-					// So, for now, we skip reload on CHMOD.
-					// We do have to check for WRITE though. On slower laptops a Chmod
-					// could be aggregated with other important events, and we still want
-					// to rebuild on those
-					if ev.Op&(fsnotify.Chmod|fsnotify.Write|fsnotify.Create) == fsnotify.Chmod {
-						continue
-					}
-
-					walkAdder := func(path string, f os.FileInfo, err error) error {
-						if f.IsDir() {
-							c.Logger.FEEDBACK.Println("adding created directory to watchlist", path)
-							if err := watcher.Add(path); err != nil {
-								return err
-							}
-						} else if !staticSyncer.isStatic(path) {
-							// Hugo's rebuilding logic is entirely file based. When you drop a new folder into
-							// /content on OSX, the above logic will handle future watching of those files,
-							// but the initial CREATE is lost.
-							dynamicEvents = append(dynamicEvents, fsnotify.Event{Name: path, Op: fsnotify.Create})
-						}
-						return nil
-					}
-
-					// recursively add new directories to watch list
-					// When mkdir -p is used, only the top directory triggers an event (at least on OSX)
-					if ev.Op&fsnotify.Create == fsnotify.Create {
-						if s, err := c.Fs.Source.Stat(ev.Name); err == nil && s.Mode().IsDir() {
-							_ = helpers.SymbolicWalk(c.Fs.Source, ev.Name, walkAdder)
-						}
-					}
-
-					if staticSyncer.isStatic(ev.Name) {
-						staticEvents = append(staticEvents, ev)
-					} else {
-						dynamicEvents = append(dynamicEvents, ev)
-					}
-				}
-
-				if len(staticEvents) > 0 {
-					c.Logger.FEEDBACK.Println("\nStatic file changes detected")
-					const layout = "2006-01-02 15:04:05.000 -0700"
-					c.Logger.FEEDBACK.Println(time.Now().Format(layout))
-
-					if c.Cfg.GetBool("forceSyncStatic") {
-						c.Logger.FEEDBACK.Printf("Syncing all static files\n")
-						_, err := c.copyStatic()
-						if err != nil {
-							utils.StopOnErr(c.Logger, err, "Error copying static files to publish dir")
-						}
-					} else {
-						if err := staticSyncer.syncsStaticEvents(staticEvents); err != nil {
-							c.Logger.ERROR.Println(err)
-							continue
-						}
-					}
-
-					if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
-						// Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
-
-						// force refresh when more than one file
-						if len(staticEvents) == 1 {
-							ev := staticEvents[0]
-							path := c.hugo.BaseFs.SourceFilesystems.MakeStaticPathRelative(ev.Name)
-							path = c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(path), false)
-							livereload.RefreshPath(path)
-						} else {
-							livereload.ForceRefresh()
-						}
-					}
-				}
-
-				if len(dynamicEvents) > 0 {
-					partitionedEvents := partitionDynamicEvents(
-						c.firstPathSpec().BaseFs.SourceFilesystems,
-						dynamicEvents)
-
-					doLiveReload := !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
-					onePageName := pickOneWriteOrCreatePath(partitionedEvents.ContentEvents)
-
-					c.Logger.FEEDBACK.Println("\nChange detected, rebuilding site")
-					const layout = "2006-01-02 15:04:05.000 -0700"
-					c.Logger.FEEDBACK.Println(time.Now().Format(layout))
-
-					c.changeDetector.PrepareNew()
-					if err := c.rebuildSites(dynamicEvents); err != nil {
-						c.Logger.ERROR.Println("Failed to rebuild site:", err)
-					}
-
-					if doLiveReload {
-						if len(partitionedEvents.ContentEvents) == 0 && len(partitionedEvents.AssetEvents) > 0 {
-							changed := c.changeDetector.changed()
-							if c.changeDetector != nil && len(changed) == 0 {
-								// Nothing has changed.
-								continue
-							} else if len(changed) == 1 {
-								pathToRefresh := c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(changed[0]), false)
-								livereload.RefreshPath(pathToRefresh)
-							} else {
-								livereload.ForceRefresh()
-							}
-						}
-
-						if len(partitionedEvents.ContentEvents) > 0 {
-
-							navigate := c.Cfg.GetBool("navigateToChanged")
-							// We have fetched the same page above, but it may have
-							// changed.
-							var p *hugolib.Page
-
-							if navigate {
-								if onePageName != "" {
-									p = c.hugo.GetContentPage(onePageName)
-								}
-							}
-
-							if p != nil {
-								livereload.NavigateToPathForPort(p.RelPermalink(), p.Site.ServerPort())
-							} else {
-								livereload.ForceRefresh()
-							}
-						}
-					}
+				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(err)
+					c.logger.ERROR.Println("Error while watching:", err)
 				}
 			}
 		}
@@ -900,6 +744,253 @@ func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
 	return watcher, nil
 }
 
+func (c *commandeer) handleEvents(watcher *watcher.Batcher,
+	staticSyncer *staticSyncer,
+	evs []fsnotify.Event,
+	configSet map[string]bool) {
+
+	for _, ev := range evs {
+		isConfig := configSet[ev.Name]
+		if !isConfig {
+			// It may be one of the /config folders
+			dirname := filepath.Dir(ev.Name)
+			if dirname != "." && configSet[dirname] {
+				isConfig = true
+			}
+
+		}
+
+		if isConfig {
+			if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
+				continue
+			}
+			if ev.Op&fsnotify.Remove == fsnotify.Remove {
+				for _, configFile := range c.configFiles {
+					counter := 0
+					for watcher.Add(configFile) != nil {
+						counter++
+						if counter >= 100 {
+							break
+						}
+						time.Sleep(100 * time.Millisecond)
+					}
+				}
+			}
+			// Config file(s) changed. Need full rebuild.
+			c.fullRebuild()
+			break
+		}
+	}
+
+	if c.paused {
+		// Wait for the server to get into a consistent state before
+		// we continue with processing.
+		return
+	}
+
+	if len(evs) > 50 {
+		// This is probably a mass edit of the content dir.
+		// Schedule a full rebuild for when it slows down.
+		c.debounce(c.fullRebuild)
+		return
+	}
+
+	c.logger.INFO.Println("Received System Events:", evs)
+
+	staticEvents := []fsnotify.Event{}
+	dynamicEvents := []fsnotify.Event{}
+
+	// Special handling for symbolic links inside /content.
+	filtered := []fsnotify.Event{}
+	for _, ev := range evs {
+		// Check the most specific first, i.e. files.
+		contentMapped := c.hugo.ContentChanges.GetSymbolicLinkMappings(ev.Name)
+		if len(contentMapped) > 0 {
+			for _, mapped := range contentMapped {
+				filtered = append(filtered, fsnotify.Event{Name: mapped, Op: ev.Op})
+			}
+			continue
+		}
+
+		// Check for any symbolic directory mapping.
+
+		dir, name := filepath.Split(ev.Name)
+
+		contentMapped = c.hugo.ContentChanges.GetSymbolicLinkMappings(dir)
+
+		if len(contentMapped) == 0 {
+			filtered = append(filtered, ev)
+			continue
+		}
+
+		for _, mapped := range contentMapped {
+			mappedFilename := filepath.Join(mapped, name)
+			filtered = append(filtered, fsnotify.Event{Name: mappedFilename, Op: ev.Op})
+		}
+	}
+
+	evs = filtered
+
+	for _, ev := range evs {
+		ext := filepath.Ext(ev.Name)
+		baseName := filepath.Base(ev.Name)
+		istemp := strings.HasSuffix(ext, "~") ||
+			(ext == ".swp") || // vim
+			(ext == ".swx") || // vim
+			(ext == ".tmp") || // generic temp file
+			(ext == ".DS_Store") || // OSX Thumbnail
+			baseName == "4913" || // vim
+			strings.HasPrefix(ext, ".goutputstream") || // gnome
+			strings.HasSuffix(ext, "jb_old___") || // intelliJ
+			strings.HasSuffix(ext, "jb_tmp___") || // intelliJ
+			strings.HasSuffix(ext, "jb_bak___") || // intelliJ
+			strings.HasPrefix(ext, ".sb-") || // byword
+			strings.HasPrefix(baseName, ".#") || // emacs
+			strings.HasPrefix(baseName, "#") // emacs
+		if istemp {
+			continue
+		}
+		if c.hugo.Deps.SourceSpec.IgnoreFile(ev.Name) {
+			continue
+		}
+		// Sometimes during rm -rf operations a '"": REMOVE' is triggered. Just ignore these
+		if ev.Name == "" {
+			continue
+		}
+
+		// Write and rename operations are often followed by CHMOD.
+		// There may be valid use cases for rebuilding the site on CHMOD,
+		// but that will require more complex logic than this simple conditional.
+		// On OS X this seems to be related to Spotlight, see:
+		// https://github.com/go-fsnotify/fsnotify/issues/15
+		// A workaround is to put your site(s) on the Spotlight exception list,
+		// but that may be a little mysterious for most end users.
+		// So, for now, we skip reload on CHMOD.
+		// We do have to check for WRITE though. On slower laptops a Chmod
+		// could be aggregated with other important events, and we still want
+		// to rebuild on those
+		if ev.Op&(fsnotify.Chmod|fsnotify.Write|fsnotify.Create) == fsnotify.Chmod {
+			continue
+		}
+
+		walkAdder := func(path string, f os.FileInfo, err error) error {
+			if f.IsDir() {
+				c.logger.FEEDBACK.Println("adding created directory to watchlist", path)
+				if err := watcher.Add(path); err != nil {
+					return err
+				}
+			} else if !staticSyncer.isStatic(path) {
+				// Hugo's rebuilding logic is entirely file based. When you drop a new folder into
+				// /content on OSX, the above logic will handle future watching of those files,
+				// but the initial CREATE is lost.
+				dynamicEvents = append(dynamicEvents, fsnotify.Event{Name: path, Op: fsnotify.Create})
+			}
+			return nil
+		}
+
+		// recursively add new directories to watch list
+		// When mkdir -p is used, only the top directory triggers an event (at least on OSX)
+		if ev.Op&fsnotify.Create == fsnotify.Create {
+			if s, err := c.Fs.Source.Stat(ev.Name); err == nil && s.Mode().IsDir() {
+				_ = helpers.SymbolicWalk(c.Fs.Source, ev.Name, walkAdder)
+			}
+		}
+
+		if staticSyncer.isStatic(ev.Name) {
+			staticEvents = append(staticEvents, ev)
+		} else {
+			dynamicEvents = append(dynamicEvents, ev)
+		}
+	}
+
+	if len(staticEvents) > 0 {
+		c.logger.FEEDBACK.Println("\nStatic file changes detected")
+		const layout = "2006-01-02 15:04:05.000 -0700"
+		c.logger.FEEDBACK.Println(time.Now().Format(layout))
+
+		if c.Cfg.GetBool("forceSyncStatic") {
+			c.logger.FEEDBACK.Printf("Syncing all static files\n")
+			_, err := c.copyStatic()
+			if err != nil {
+				c.logger.ERROR.Println("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)
+				return
+			}
+		}
+
+		if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
+			// Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
+
+			// force refresh when more than one file
+			if len(staticEvents) == 1 {
+				ev := staticEvents[0]
+				path := c.hugo.BaseFs.SourceFilesystems.MakeStaticPathRelative(ev.Name)
+				path = c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(path), false)
+				livereload.RefreshPath(path)
+			} else {
+				livereload.ForceRefresh()
+			}
+		}
+	}
+
+	if len(dynamicEvents) > 0 {
+		partitionedEvents := partitionDynamicEvents(
+			c.firstPathSpec().BaseFs.SourceFilesystems,
+			dynamicEvents)
+
+		doLiveReload := !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
+		onePageName := pickOneWriteOrCreatePath(partitionedEvents.ContentEvents)
+
+		c.logger.FEEDBACK.Println("\nChange detected, rebuilding site")
+		const layout = "2006-01-02 15:04:05.000 -0700"
+		c.logger.FEEDBACK.Println(time.Now().Format(layout))
+
+		c.changeDetector.PrepareNew()
+		if err := c.rebuildSites(dynamicEvents); err != nil {
+			c.handleBuildErr(err, "Rebuild failed")
+		}
+
+		if doLiveReload {
+			if len(partitionedEvents.ContentEvents) == 0 && len(partitionedEvents.AssetEvents) > 0 {
+				changed := c.changeDetector.changed()
+				if c.changeDetector != nil && len(changed) == 0 {
+					// Nothing has changed.
+					return
+				} else if len(changed) == 1 {
+					pathToRefresh := c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(changed[0]), false)
+					livereload.RefreshPath(pathToRefresh)
+				} else {
+					livereload.ForceRefresh()
+				}
+			}
+
+			if len(partitionedEvents.ContentEvents) > 0 {
+
+				navigate := c.Cfg.GetBool("navigateToChanged")
+				// We have fetched the same page above, but it may have
+				// changed.
+				var p *hugolib.Page
+
+				if navigate {
+					if onePageName != "" {
+						p = c.hugo.GetContentPage(onePageName)
+					}
+				}
+
+				if p != nil {
+					livereload.NavigateToPathForPort(p.RelPermalink(), p.Site.ServerPort())
+				} else {
+					livereload.ForceRefresh()
+				}
+			}
+		}
+	}
+}
+
 // dynamicEvents contains events that is considered dynamic, as in "not static".
 // Both of these categories will trigger a new build, but the asset events
 // does not fit into the "navigate to changed" logic.
@@ -937,7 +1028,7 @@ func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
 
 // isThemeVsHugoVersionMismatch returns whether the current Hugo version is
 // less than any of the themes' min_version.
-func (c *commandeer) isThemeVsHugoVersionMismatch(fs afero.Fs) (mismatch bool, requiredMinVersion string) {
+func (c *commandeer) isThemeVsHugoVersionMismatch(fs afero.Fs) (dir string, mismatch bool, requiredMinVersion string) {
 	if !c.hugo.PathSpec.ThemeSet() {
 		return
 	}
@@ -954,15 +1045,15 @@ func (c *commandeer) isThemeVsHugoVersionMismatch(fs afero.Fs) (mismatch bool, r
 
 		b, err := afero.ReadFile(fs, path)
 
-		tomlMeta, err := parser.HandleTOMLMetaData(b)
+		tomlMeta, err := metadecoders.Default.UnmarshalToMap(b, metadecoders.TOML)
 
 		if err != nil {
 			continue
 		}
 
 		if minVersion, ok := tomlMeta["min_version"]; ok {
-			if helpers.CompareVersion(minVersion) > 0 {
-				return true, fmt.Sprint(minVersion)
+			if hugo.CompareVersion(minVersion) > 0 {
+				return absThemeDir, true, fmt.Sprint(minVersion)
 			}
 		}
 

commands/hugo_windows.go

@@ -23,5 +23,5 @@ func init() {
 
   You need to open cmd.exe and run Hugo from there.
   
-  Visit http://gohugo.io/ for more information.`
+  Visit https://gohugo.io/ for more information.`
 }

commands/import_jekyll.go

@@ -16,6 +16,7 @@ package commands
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -24,6 +25,9 @@ import (
 	"strconv"
 	"strings"
 	"time"
+	"unicode"
+
+	"github.com/gohugoio/hugo/parser/metadecoders"
 
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
@@ -73,23 +77,23 @@ Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root
 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`.")
+		return newUserError(`import from jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.")
 	}
 
 	jekyllRoot, err := filepath.Abs(filepath.Clean(args[0]))
 	if err != nil {
-		return newUserError("Path error:", args[0])
+		return newUserError("path error:", args[0])
 	}
 
 	targetDir, err := filepath.Abs(filepath.Clean(args[1]))
 	if err != nil {
-		return newUserError("Path error:", args[1])
+		return newUserError("path error:", args[1])
 	}
 
 	jww.INFO.Println("Import Jekyll from:", jekyllRoot, "to:", targetDir)
 
 	if strings.HasPrefix(filepath.Dir(targetDir), jekyllRoot) {
-		return newUserError("Target path should not be inside the Jekyll root, aborting.")
+		return newUserError("abort: target path should not be inside the Jekyll root")
 	}
 
 	forceImport, _ := cmd.Flags().GetBool("force")
@@ -97,7 +101,7 @@ func (i *importCmd) importFromJekyll(cmd *cobra.Command, args []string) error {
 	fs := afero.NewOsFs()
 	jekyllPostDirs, hasAnyPost := i.getJekyllDirInfo(fs, jekyllRoot)
 	if !hasAnyPost {
-		return errors.New("Your Jekyll root contains neither posts nor drafts, aborting.")
+		return errors.New("abort: jekyll root contains neither posts nor drafts")
 	}
 
 	site, err := i.createSiteFromJekyll(jekyllRoot, targetDir, jekyllPostDirs, forceImport)
@@ -120,7 +124,7 @@ func (i *importCmd) importFromJekyll(cmd *cobra.Command, args []string) error {
 
 		relPath, err := filepath.Rel(jekyllRoot, path)
 		if err != nil {
-			return newUserError("Get rel path error:", path)
+			return newUserError("get rel path error:", path)
 		}
 
 		relPath = filepath.ToSlash(relPath)
@@ -204,13 +208,13 @@ func (i *importCmd) createSiteFromJekyll(jekyllRoot, targetDir string, jekyllPos
 	fs := s.Fs.Source
 	if exists, _ := helpers.Exists(targetDir, fs); exists {
 		if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
-			return nil, errors.New("Target path \"" + targetDir + "\" already exists but not a directory")
+			return nil, errors.New("target path \"" + targetDir + "\" exists but is not a directory")
 		}
 
 		isEmpty, _ := helpers.IsEmpty(targetDir, fs)
 
 		if !isEmpty && !force {
-			return nil, errors.New("Target path \"" + targetDir + "\" already exists and is not empty")
+			return nil, errors.New("target path \"" + targetDir + "\" exists and is not empty")
 		}
 	}
 
@@ -253,7 +257,7 @@ func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]
 		return nil
 	}
 
-	c, err := parser.HandleYAMLMetaData(b)
+	c, err := metadecoders.Default.UnmarshalToMap(b, metadecoders.YAML)
 
 	if err != nil {
 		return nil
@@ -262,7 +266,7 @@ func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]
 	return c
 }
 
-func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind string, jekyllConfig map[string]interface{}) (err error) {
+func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]interface{}) (err error) {
 	title := "My New Hugo Site"
 	baseURL := "http://example.org/"
 
@@ -288,15 +292,14 @@ func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind stri
 		"languageCode":       "en-us",
 		"disablePathToLower": true,
 	}
-	kind = parser.FormatSanitize(kind)
 
 	var buf bytes.Buffer
-	err = parser.InterfaceToConfig(in, parser.FormatToLeadRune(kind), &buf)
+	err = parser.InterfaceToConfig(in, kind, &buf)
 	if err != nil {
 		return err
 	}
 
-	return helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), &buf, fs)
+	return helpers.WriteToDisk(filepath.Join(inpath, "config."+string(kind)), &buf, fs)
 }
 
 func copyFile(source string, dest string) error {
@@ -445,39 +448,25 @@ func convertJekyllPost(s *hugolib.Site, path, relPath, targetDir string, draft b
 		return err
 	}
 
-	psr, err := parser.ReadFrom(bytes.NewReader(contentBytes))
+	pf, err := parseContentFile(bytes.NewReader(contentBytes))
 	if err != nil {
 		jww.ERROR.Println("Parse file error:", path)
 		return err
 	}
 
-	metadata, err := psr.Metadata()
-	if err != nil {
-		jww.ERROR.Println("Processing file error:", path)
-		return err
-	}
-
-	newmetadata, err := convertJekyllMetaData(metadata, postName, postDate, draft)
+	newmetadata, err := convertJekyllMetaData(pf.frontMatter, postName, postDate, draft)
 	if err != nil {
 		jww.ERROR.Println("Convert metadata error:", path)
 		return err
 	}
 
-	jww.TRACE.Println(newmetadata)
-	content := convertJekyllContent(newmetadata, string(psr.Content()))
+	content := convertJekyllContent(newmetadata, string(pf.content))
 
-	page, err := s.NewPage(filename)
-	if err != nil {
-		jww.ERROR.Println("New page error", filename)
-		return err
+	fs := hugofs.Os
+	if err := helpers.WriteToDisk(targetFile, strings.NewReader(content), fs); err != nil {
+		return fmt.Errorf("Failed to save file %q:", filename)
 	}
 
-	page.SetSourceContent([]byte(content))
-	page.SetSourceMetaData(newmetadata, parser.FormatToLeadRune("yaml"))
-	page.SaveSourceAs(targetFile)
-
-	jww.TRACE.Println("Target file:", targetFile)
-
 	return nil
 }
 
@@ -557,7 +546,6 @@ func convertJekyllContent(m interface{}, content string) string {
 	}{
 		{regexp.MustCompile("(?i)<!-- more -->"), "<!--more-->"},
 		{regexp.MustCompile(`\{%\s*raw\s*%\}\s*(.*?)\s*\{%\s*endraw\s*%\}`), "$1"},
-		{regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`), "{{< highlight $1 >}}"},
 		{regexp.MustCompile(`{%\s*endhighlight\s*%}`), "{{< / highlight >}}"},
 	}
 
@@ -571,6 +559,7 @@ func convertJekyllContent(m interface{}, content string) string {
 	}{
 		// Octopress image tag: http://octopress.org/docs/plugins/image-tag/
 		{regexp.MustCompile(`{%\s+img\s*(.*?)\s*%}`), replaceImageTag},
+		{regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`), replaceHighlightTag},
 	}
 
 	for _, replace := range replaceListFunc {
@@ -580,6 +569,50 @@ func convertJekyllContent(m interface{}, content string) string {
 	return content
 }
 
+func replaceHighlightTag(match string) string {
+	r := regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`)
+	parts := r.FindStringSubmatch(match)
+	lastQuote := rune(0)
+	f := func(c rune) bool {
+		switch {
+		case c == lastQuote:
+			lastQuote = rune(0)
+			return false
+		case lastQuote != rune(0):
+			return false
+		case unicode.In(c, unicode.Quotation_Mark):
+			lastQuote = c
+			return false
+		default:
+			return unicode.IsSpace(c)
+		}
+	}
+	// splitting string by space but considering quoted section
+	items := strings.FieldsFunc(parts[1], f)
+
+	result := bytes.NewBufferString("{{< highlight ")
+	result.WriteString(items[0]) // language
+	options := items[1:]
+	for i, opt := range options {
+		opt = strings.Replace(opt, "\"", "", -1)
+		if opt == "linenos" {
+			opt = "linenos=table"
+		}
+		if i == 0 {
+			opt = " \"" + opt
+		}
+		if i < len(options)-1 {
+			opt += ","
+		} else if i == len(options)-1 {
+			opt += "\""
+		}
+		result.WriteString(opt)
+	}
+
+	result.WriteString(" >}}")
+	return result.String()
+}
+
 func replaceImageTag(match string) string {
 	r := regexp.MustCompile(`{%\s+img\s*(\p{L}*)\s+([\S]*/[\S]+)\s+(\d*)\s*(\d*)\s*(.*?)\s*%}`)
 	result := bytes.NewBufferString("{{< figure ")

commands/import_jekyll_test.go

@@ -97,6 +97,9 @@ func TestConvertJekyllContent(t *testing.T) {
 		{map[interface{}]interface{}{},
 			"{% highlight go %}\nvar s int\n{% endhighlight %}",
 			"{{< 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 >}}"},
 
 		// Octopress image tag
 		{map[interface{}]interface{}{},

commands/new.go

@@ -30,16 +30,14 @@ import (
 var _ cmder = (*newCmd)(nil)
 
 type newCmd struct {
-	hugoBuilderCommon
 	contentEditor string
 	contentType   string
 
-	*baseCmd
+	*baseBuilderCmd
 }
 
-func newNewCmd() *newCmd {
-	cc := &newCmd{}
-	cc.baseCmd = newBaseCmd(&cobra.Command{
+func (b *commandsBuilder) newNewCmd() *newCmd {
+	cmd := &cobra.Command{
 		Use:   "new [path]",
 		Short: "Create new content for your site",
 		Long: `Create a new content file and automatically set the date and title.
@@ -47,18 +45,22 @@ It will guess which kind of file to create based on the path provided.
 
 You can also specify the kind with ` + "`-k KIND`" + `.
 
-If archetypes are provided in your theme or site, they will be used.`,
+If archetypes are provided in your theme or site, they will be used.
 
-		RunE: cc.newContent,
-	})
+Ensure you run this within the root directory of your site.`,
+	}
 
-	cc.cmd.Flags().StringVarP(&cc.contentType, "kind", "k", "", "content type to create")
-	cc.cmd.PersistentFlags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
-	cc.cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
-	cc.cmd.Flags().StringVar(&cc.contentEditor, "editor", "", "edit new content with this editor, if provided")
+	cc := &newCmd{baseBuilderCmd: b.newBuilderCmd(cmd)}
 
-	cc.cmd.AddCommand(newNewSiteCmd().getCommand())
-	cc.cmd.AddCommand(newNewThemeCmd().getCommand())
+	cmd.Flags().StringVarP(&cc.contentType, "kind", "k", "", "content type to create")
+	cmd.PersistentFlags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
+	cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+	cmd.Flags().StringVar(&cc.contentEditor, "editor", "", "edit new content with this editor, if provided")
+
+	cmd.AddCommand(newNewSiteCmd().getCommand())
+	cmd.AddCommand(newNewThemeCmd().getCommand())
+
+	cmd.RunE = cc.newContent
 
 	return cc
 }
@@ -85,45 +87,13 @@ func (n *newCmd) newContent(cmd *cobra.Command, args []string) error {
 
 	var kind string
 
-	createPath, kind = newContentPathSection(createPath)
+	createPath, kind = newContentPathSection(c.hugo, createPath)
 
 	if n.contentType != "" {
 		kind = n.contentType
 	}
 
-	cfg := c.DepsCfg
-
-	ps, err := helpers.NewPathSpec(cfg.Fs, cfg.Cfg)
-	if err != nil {
-		return err
-	}
-
-	// If a site isn't in use in the archetype template, we can skip the build.
-	siteFactory := func(filename string, siteUsed bool) (*hugolib.Site, error) {
-		if !siteUsed {
-			return hugolib.NewSite(*cfg)
-		}
-		var s *hugolib.Site
-
-		if err := c.hugo.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
-			return nil, err
-		}
-
-		s = c.hugo.Sites[0]
-
-		if len(c.hugo.Sites) > 1 {
-			// Find the best match.
-			for _, ss := range c.hugo.Sites {
-				if strings.Contains(createPath, "."+ss.Language.Lang) {
-					s = ss
-					break
-				}
-			}
-		}
-		return s, nil
-	}
-
-	return create.NewContent(ps, siteFactory, kind, createPath)
+	return create.NewContent(c.hugo, kind, createPath)
 }
 
 func mkdir(x ...string) {
@@ -144,10 +114,17 @@ func touchFile(fs afero.Fs, x ...string) {
 	}
 }
 
-func newContentPathSection(path string) (string, string) {
+func newContentPathSection(h *hugolib.HugoSites, path string) (string, string) {
 	// Forward slashes is used in all examples. Convert if needed.
 	// Issue #1133
 	createpath := filepath.FromSlash(path)
+
+	if h != nil {
+		for _, s := range h.Sites {
+			createpath = strings.TrimPrefix(createpath, s.PathSpec.ContentDir)
+		}
+	}
+
 	var section string
 	// assume the first directory is the section (kind)
 	if strings.Contains(createpath[1:], helpers.FilePathSeparator) {

commands/new_content_test.go

@@ -25,7 +25,7 @@ import (
 
 // Issue #1133
 func TestNewContentPathSectionWithForwardSlashes(t *testing.T) {
-	p, s := newContentPathSection("/post/new.md")
+	p, s := newContentPathSection(nil, "/post/new.md")
 	assert.Equal(t, filepath.FromSlash("/post/new.md"), p)
 	assert.Equal(t, "post", s)
 }

commands/new_site.go

@@ -16,10 +16,13 @@ package commands
 import (
 	"bytes"
 	"errors"
-	"fmt"
 	"path/filepath"
 	"strings"
 
+	"github.com/gohugoio/hugo/parser/metadecoders"
+
+	_errors "github.com/pkg/errors"
+
 	"github.com/gohugoio/hugo/create"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
@@ -92,7 +95,7 @@ func (n *newSiteCmd) doNewSite(fs *hugofs.Fs, basepath string, force bool) error
 
 	for _, dir := range dirs {
 		if err := fs.Source.MkdirAll(dir, 0777); err != nil {
-			return fmt.Errorf("Failed to create dir: %s", err)
+			return _errors.Wrap(err, "Failed to create dir")
 		}
 	}
 
@@ -130,10 +133,9 @@ func createConfig(fs *hugofs.Fs, inpath string, kind string) (err error) {
 		"title":        "My New Hugo Site",
 		"languageCode": "en-us",
 	}
-	kind = parser.FormatSanitize(kind)
 
 	var buf bytes.Buffer
-	err = parser.InterfaceToConfig(in, parser.FormatToLeadRune(kind), &buf)
+	err = parser.InterfaceToConfig(in, metadecoders.FormatFromString(kind), &buf)
 	if err != nil {
 		return err
 	}

commands/server.go

@@ -14,6 +14,7 @@
 package commands
 
 import (
+	"bytes"
 	"fmt"
 	"net"
 	"net/http"
@@ -21,6 +22,7 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strconv"
 	"strings"
@@ -28,10 +30,12 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/gohugoio/hugo/livereload"
+	"github.com/gohugoio/hugo/tpl"
 
 	"github.com/gohugoio/hugo/config"
-
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
@@ -52,7 +56,8 @@ type serverCmd struct {
 	serverWatch       bool
 	noHTTPCache       bool
 
-	disableFastRender bool
+	disableFastRender   bool
+	disableBrowserError bool
 
 	*baseBuilderCmd
 }
@@ -93,6 +98,7 @@ of a second, you will be able to save and see your changes nearly instantly.`,
 	cc.cmd.Flags().BoolVar(&cc.navigateToChanged, "navigateToChanged", false, "navigate to changed content file on live browser reload")
 	cc.cmd.Flags().BoolVar(&cc.renderToDisk, "renderToDisk", false, "render to Destination path (default is render to memory & serve from there)")
 	cc.cmd.Flags().BoolVar(&cc.disableFastRender, "disableFastRender", false, "enables full re-renders on changes")
+	cc.cmd.Flags().BoolVar(&cc.disableBrowserError, "disableBrowserError", false, "do not show build errors in the browser")
 
 	cc.cmd.Flags().String("memstats", "", "log memory usage to this file")
 	cc.cmd.Flags().String("meminterval", "100ms", "interval to poll memory usage (requires --memstats), valid time units are \"ns\", \"us\" (or \"µs\"), \"ms\", \"s\", \"m\", \"h\".")
@@ -122,27 +128,30 @@ func (f noDirFile) Readdir(count int) ([]os.FileInfo, error) {
 
 var serverPorts []int
 
-func (s *serverCmd) server(cmd *cobra.Command, args []string) error {
+func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 	// If a Destination is provided via flag write to disk
 	destination, _ := cmd.Flags().GetString("destination")
 	if destination != "" {
-		s.renderToDisk = true
+		sc.renderToDisk = true
 	}
 
 	var serverCfgInit sync.Once
 
 	cfgInit := func(c *commandeer) error {
-		c.Set("renderToMemory", !s.renderToDisk)
+		c.Set("renderToMemory", !sc.renderToDisk)
 		if cmd.Flags().Changed("navigateToChanged") {
-			c.Set("navigateToChanged", s.navigateToChanged)
+			c.Set("navigateToChanged", sc.navigateToChanged)
 		}
 		if cmd.Flags().Changed("disableLiveReload") {
-			c.Set("disableLiveReload", s.disableLiveReload)
+			c.Set("disableLiveReload", sc.disableLiveReload)
 		}
 		if cmd.Flags().Changed("disableFastRender") {
-			c.Set("disableFastRender", s.disableFastRender)
+			c.Set("disableFastRender", sc.disableFastRender)
 		}
-		if s.serverWatch {
+		if cmd.Flags().Changed("disableBrowserError") {
+			c.Set("disableBrowserError", sc.disableBrowserError)
+		}
+		if sc.serverWatch {
 			c.Set("watch", true)
 		}
 
@@ -158,25 +167,25 @@ func (s *serverCmd) server(cmd *cobra.Command, args []string) error {
 			serverPorts = make([]int, 1)
 
 			if c.languages.IsMultihost() {
-				if !s.serverAppend {
+				if !sc.serverAppend {
 					err = newSystemError("--appendPort=false not supported when in multihost mode")
 				}
 				serverPorts = make([]int, len(c.languages))
 			}
 
-			currentServerPort := s.serverPort
+			currentServerPort := sc.serverPort
 
 			for i := 0; i < len(serverPorts); i++ {
-				l, err := net.Listen("tcp", net.JoinHostPort(s.serverInterface, strconv.Itoa(currentServerPort)))
+				l, err := net.Listen("tcp", net.JoinHostPort(sc.serverInterface, strconv.Itoa(currentServerPort)))
 				if err == nil {
 					l.Close()
 					serverPorts[i] = currentServerPort
 				} else {
-					if i == 0 && s.cmd.Flags().Changed("port") {
+					if i == 0 && sc.cmd.Flags().Changed("port") {
 						// port set explicitly by user -- he/she probably meant it!
 						err = newSystemErrorF("Server startup failed: %s", err)
 					}
-					jww.ERROR.Println("port", s.serverPort, "already in use, attempting to use an available port")
+					c.logger.FEEDBACK.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)
@@ -190,9 +199,9 @@ func (s *serverCmd) server(cmd *cobra.Command, args []string) error {
 
 		c.serverPorts = serverPorts
 
-		c.Set("port", s.serverPort)
-		if s.liveReloadPort != -1 {
-			c.Set("liveReloadPort", s.liveReloadPort)
+		c.Set("port", sc.serverPort)
+		if sc.liveReloadPort != -1 {
+			c.Set("liveReloadPort", sc.liveReloadPort)
 		} else {
 			c.Set("liveReloadPort", serverPorts[0])
 		}
@@ -206,7 +215,7 @@ func (s *serverCmd) server(cmd *cobra.Command, args []string) error {
 				serverPort = serverPorts[0]
 			}
 
-			baseURL, err := s.fixURL(language, s.baseURL, serverPort)
+			baseURL, err := sc.fixURL(language, sc.baseURL, serverPort)
 			if err != nil {
 				return nil
 			}
@@ -223,10 +232,10 @@ func (s *serverCmd) server(cmd *cobra.Command, args []string) error {
 	}
 
 	if err := memStats(); err != nil {
-		jww.ERROR.Println("memstats error:", err)
+		jww.WARN.Println("memstats error:", err)
 	}
 
-	c, err := initializeConfig(true, true, &s.hugoBuilderCommon, s, cfgInit)
+	c, err := initializeConfig(true, true, &sc.hugoBuilderCommon, sc, cfgInit)
 	if err != nil {
 		return err
 	}
@@ -240,7 +249,7 @@ func (s *serverCmd) server(cmd *cobra.Command, args []string) error {
 	}
 
 	// Watch runs its own server as part of the routine
-	if s.serverWatch {
+	if sc.serverWatch {
 
 		watchDirs, err := c.getDirList()
 		if err != nil {
@@ -266,15 +275,16 @@ func (s *serverCmd) server(cmd *cobra.Command, args []string) error {
 
 	}
 
-	return c.serve(s)
+	return c.serve(sc)
 
 }
 
 type fileServer struct {
-	baseURLs []string
-	roots    []string
-	c        *commandeer
-	s        *serverCmd
+	baseURLs      []string
+	roots         []string
+	errorTemplate tpl.Template
+	c             *commandeer
+	s             *serverCmd
 }
 
 func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, error) {
@@ -290,6 +300,8 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, erro
 
 	absPublishDir := f.c.hugo.PathSpec.AbsPathify(publishDir)
 
+	jww.FEEDBACK.Printf("Environment: %q", f.c.hugo.Deps.Site.Hugo().Environment)
+
 	if i == 0 {
 		if f.s.renderToDisk {
 			jww.FEEDBACK.Println("Serving pages from " + absPublishDir)
@@ -301,30 +313,59 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, erro
 	httpFs := afero.NewHttpFs(f.c.destinationFs)
 	fs := filesOnlyFs{httpFs.Dir(absPublishDir)}
 
-	doLiveReload := !f.s.buildWatch && !f.c.Cfg.GetBool("disableLiveReload")
-	fastRenderMode := doLiveReload && !f.c.Cfg.GetBool("disableFastRender")
-
-	if i == 0 && fastRenderMode {
+	if i == 0 && f.c.fastRenderMode {
 		jww.FEEDBACK.Println("Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender")
 	}
 
 	// We're only interested in the path
 	u, err := url.Parse(baseURL)
 	if err != nil {
-		return nil, "", "", fmt.Errorf("Invalid baseURL: %s", err)
+		return nil, "", "", errors.Wrap(err, "Invalid baseURL")
 	}
 
 	decorate := func(h http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if f.c.showErrorInBrowser {
+				// First check the error state
+				err := f.c.getErrorWithContext()
+				if err != nil {
+					w.WriteHeader(500)
+					var b bytes.Buffer
+					err := f.errorTemplate.Execute(&b, err)
+					if err != nil {
+						f.c.logger.ERROR.Println(err)
+					}
+					port = 1313
+					if !f.c.paused {
+						port = f.c.Cfg.GetInt("liveReloadPort")
+					}
+					fmt.Fprint(w, injectLiveReloadScript(&b, port))
+
+					return
+				}
+			}
+
 			if f.s.noHTTPCache {
 				w.Header().Set("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0")
 				w.Header().Set("Pragma", "no-cache")
 			}
 
-			if fastRenderMode {
+			if f.c.fastRenderMode && f.c.buildErr == nil {
 				p := r.RequestURI
 				if strings.HasSuffix(p, "/") || strings.HasSuffix(p, "html") || strings.HasSuffix(p, "htm") {
+					if !f.c.visitedURLs.Contains(p) {
+						// If not already on stack, re-render that single page.
+						if err := f.c.partialReRender(p); err != nil {
+							f.c.handleBuildErr(err, fmt.Sprintf("Failed to render %q", p))
+							if f.c.showErrorInBrowser {
+								http.Redirect(w, r, p, 301)
+								return
+							}
+						}
+					}
+
 					f.c.visitedURLs.Add(p)
+
 				}
 			}
 			h.ServeHTTP(w, r)
@@ -345,6 +386,11 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, erro
 	return mu, u.String(), endpoint, nil
 }
 
+var logErrorRe = regexp.MustCompile("(?s)ERROR \\d{4}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2} ")
+
+func removeErrorPrefixFromLog(content string) string {
+	return logErrorRe.ReplaceAllLiteralString(content, "")
+}
 func (c *commandeer) serve(s *serverCmd) error {
 
 	isMultiHost := c.hugo.IsMultihost()
@@ -365,11 +411,17 @@ func (c *commandeer) serve(s *serverCmd) error {
 		roots = []string{""}
 	}
 
+	templ, err := c.hugo.TextTmpl.Parse("__default_server_error", buildErrorTemplate)
+	if err != nil {
+		return err
+	}
+
 	srv := &fileServer{
-		baseURLs: baseURLs,
-		roots:    roots,
-		c:        c,
-		s:        s,
+		baseURLs:      baseURLs,
+		roots:         roots,
+		c:             c,
+		s:             s,
+		errorTemplate: templ,
 	}
 
 	doLiveReload := !c.Cfg.GetBool("disableLiveReload")
@@ -392,7 +444,7 @@ func (c *commandeer) serve(s *serverCmd) error {
 		go func() {
 			err = http.ListenAndServe(endpoint, mu)
 			if err != nil {
-				jww.ERROR.Printf("Error: %s\n", err.Error())
+				c.logger.ERROR.Printf("Error: %s\n", err.Error())
 				os.Exit(1)
 			}
 		}()
@@ -453,7 +505,7 @@ func (sc *serverCmd) fixURL(cfg config.Provider, s string, port int) (string, er
 		if strings.Contains(u.Host, ":") {
 			u.Host, _, err = net.SplitHostPort(u.Host)
 			if err != nil {
-				return "", fmt.Errorf("Failed to split baseURL hostpost: %s", err)
+				return "", errors.Wrap(err, "Failed to split baseURL hostpost")
 			}
 		}
 		u.Host += fmt.Sprintf(":%d", port)

commands/server_errors.go

@@ -0,0 +1,95 @@
+// Copyright 2018 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 commands
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/gohugoio/hugo/transform"
+	"github.com/gohugoio/hugo/transform/livereloadinject"
+)
+
+var buildErrorTemplate = `<!doctype html>
+<html class="no-js" lang="">
+	<head>
+		<meta charset="utf-8">
+		<title>Hugo Server: Error</title>
+		<style type="text/css">
+		body {
+			font-family: "Muli",avenir, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+			font-size: 16px;
+			background-color: black;
+			color: rgba(255, 255, 255, 0.9);
+		}
+		main {
+			margin: auto;
+			width: 95%;
+			padding: 1rem;
+		}		
+		.version {
+			color: #ccc;
+			padding: 1rem 0;
+		}
+		.stack {
+			margin-top: 6rem;
+		}
+		pre {
+			white-space: pre-wrap;      
+			white-space: -moz-pre-wrap;  
+			white-space: -pre-wrap;     
+			white-space: -o-pre-wrap;    
+			word-wrap: break-word;     
+		}
+		.highlight {
+			overflow-x: auto;
+			padding: 0.75rem;
+			margin-bottom: 1rem;
+			background-color: #272822;
+			border: 1px solid black;
+		}
+		a {
+			color: #0594cb;
+			text-decoration: none;
+		}
+		a:hover {
+			color: #ccc;
+		}
+		</style>
+	</head>
+	<body>
+		<main>
+			{{ highlight .Error "apl" "noclasses=true,style=monokai" }}
+			{{ with .File }}
+			{{ $params := printf "noclasses=true,style=monokai,linenos=table,hl_lines=%d,linenostart=%d" (add .LinesPos 1) (sub .Position.LineNumber .LinesPos) }}
+			{{ $lexer := .ChromaLexer | default "go-html-template" }}
+			{{  highlight (delimit .Lines "\n") $lexer $params }}
+			{{ end }}
+			{{ with .StackTrace }}
+			{{ highlight . "apl" "noclasses=true,style=monokai" }}
+			{{ end }}
+			<p class="version">{{ .Version }}</p>
+			<a href="">Reload Page</a>
+		</main>
+</body>
+</html>
+`
+
+func injectLiveReloadScript(src io.Reader, port int) string {
+	var b bytes.Buffer
+	chain := transform.Chain{livereloadinject.New(port)}
+	chain.Apply(&b, src)
+
+	return b.String()
+}

commands/server_test.go

@@ -17,6 +17,8 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"runtime"
+	"strings"
 	"testing"
 	"time"
 
@@ -27,6 +29,10 @@ import (
 )
 
 func TestServer(t *testing.T) {
+	if isWindowsCI() {
+		// TODO(bep) not sure why server tests have started to fail on the Windows CI server.
+		t.Skip("Skip server test on appveyor")
+	}
 	assert := require.New(t)
 	dir, err := createSimpleTestSite(t)
 	assert.NoError(err)
@@ -62,6 +68,7 @@ func TestServer(t *testing.T) {
 	homeContent := helpers.ReaderToString(resp.Body)
 
 	assert.Contains(homeContent, "List: Hugo Commands")
+	assert.Contains(homeContent, "Environment: development")
 
 	// Stop the server.
 	stop <- true
@@ -107,3 +114,19 @@ func TestFixURL(t *testing.T) {
 		}
 	}
 }
+
+func TestRemoveErrorPrefixFromLog(t *testing.T) {
+	assert := require.New(t)
+	content := `ERROR 2018/10/07 13:11:12 Error while rendering "home": template: _default/baseof.html:4:3: executing "main" at <partial "logo" .>: error calling partial: template: partials/logo.html:5:84: executing "partials/logo.html" at <$resized.AHeight>: can't evaluate field AHeight in type *resource.Image
+ERROR 2018/10/07 13:11:12 Rebuild failed: logged 1 error(s)
+`
+
+	withoutError := removeErrorPrefixFromLog(content)
+
+	assert.False(strings.Contains(withoutError, "ERROR"), withoutError)
+
+}
+
+func isWindowsCI() bool {
+	return runtime.GOOS == "windows" && os.Getenv("CI") != ""
+}

commands/static_syncer.go

@@ -105,10 +105,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.ERROR.Println(err)
 					}
 				} else {
-					c.Logger.ERROR.Println(err)
+					c.logger.ERROR.Println(err)
 				}
 
 				continue
@@ -117,7 +117,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.ERROR.Println(err)
 			}
 		}
 

commands/version.go

@@ -14,12 +14,7 @@
 package commands
 
 import (
-	"runtime"
-	"strings"
-
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/hugolib"
-	"github.com/gohugoio/hugo/resource/tocss/scss"
+	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/spf13/cobra"
 	jww "github.com/spf13/jwalterweatherman"
 )
@@ -45,24 +40,5 @@ func newVersionCmd() *versionCmd {
 }
 
 func printHugoVersion() {
-	program := "Hugo Static Site Generator"
-
-	version := "v" + helpers.CurrentHugoVersion.String()
-	if hugolib.CommitHash != "" {
-		version += "-" + strings.ToUpper(hugolib.CommitHash)
-	}
-	if scss.Supports() {
-		version += "/extended"
-	}
-
-	osArch := runtime.GOOS + "/" + runtime.GOARCH
-
-	var buildDate string
-	if hugolib.BuildDate != "" {
-		buildDate = hugolib.BuildDate
-	} else {
-		buildDate = "unknown"
-	}
-
-	jww.FEEDBACK.Println(program, version, osArch, "BuildDate:", buildDate)
+	jww.FEEDBACK.Println(hugo.BuildVersionString())
 }

common/collections/append.go

@@ -0,0 +1,114 @@
+// Copyright 2018 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 collections
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Append appends from to a slice to and returns the resulting slice.
+// If length of from is one and the only element is a slice of same type as to,
+// it will be appended.
+func Append(to interface{}, from ...interface{}) (interface{}, error) {
+	tov, toIsNil := indirect(reflect.ValueOf(to))
+
+	toIsNil = toIsNil || to == nil
+	var tot reflect.Type
+
+	if !toIsNil {
+		if tov.Kind() != reflect.Slice {
+			return nil, fmt.Errorf("expected a slice, got %T", to)
+		}
+
+		tot = tov.Type().Elem()
+		toIsNil = tov.Len() == 0
+
+		if len(from) == 1 {
+			fromv := reflect.ValueOf(from[0])
+			if fromv.Kind() == reflect.Slice {
+				if toIsNil {
+					// If we get nil []string, we just return the []string
+					return from[0], nil
+				}
+
+				fromt := reflect.TypeOf(from[0]).Elem()
+
+				// If we get []string []string, we append the from slice to to
+				if tot == fromt {
+					return reflect.AppendSlice(tov, fromv).Interface(), nil
+				} else if !fromt.AssignableTo(tot) {
+					// Fall back to a []interface{} slice.
+					return appendToInterfaceSliceFromValues(tov, fromv)
+
+				}
+			}
+		}
+	}
+
+	if toIsNil {
+		return Slice(from...), nil
+	}
+
+	for _, f := range from {
+		fv := reflect.ValueOf(f)
+		if !fv.Type().AssignableTo(tot) {
+			// Fall back to a []interface{} slice.
+			return appendToInterfaceSlice(tov, from...)
+		}
+		tov = reflect.Append(tov, fv)
+	}
+
+	return tov.Interface(), nil
+}
+
+func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]interface{}, error) {
+	var tos []interface{}
+
+	for _, slice := range []reflect.Value{slice1, slice2} {
+		for i := 0; i < slice.Len(); i++ {
+			tos = append(tos, slice.Index(i).Interface())
+		}
+	}
+
+	return tos, nil
+}
+
+func appendToInterfaceSlice(tov reflect.Value, from ...interface{}) ([]interface{}, error) {
+	var tos []interface{}
+
+	for i := 0; i < tov.Len(); i++ {
+		tos = append(tos, tov.Index(i).Interface())
+	}
+
+	for _, v := range from {
+		tos = append(tos, v)
+	}
+
+	return tos, nil
+}
+
+// indirect is borrowed from the Go stdlib: 'text/template/exec.go'
+// TODO(bep) consolidate
+func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
+	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
+		if v.IsNil() {
+			return v, true
+		}
+		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
+			break
+		}
+	}
+	return v, false
+}

common/collections/append_test.go

@@ -0,0 +1,78 @@
+// Copyright 2018 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 collections
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestAppend(t *testing.T) {
+	t.Parallel()
+
+	for i, test := range []struct {
+		start    interface{}
+		addend   []interface{}
+		expected interface{}
+	}{
+		{[]string{"a", "b"}, []interface{}{"c"}, []string{"a", "b", "c"}},
+		{[]string{"a", "b"}, []interface{}{"c", "d", "e"}, []string{"a", "b", "c", "d", "e"}},
+		{[]string{"a", "b"}, []interface{}{[]string{"c", "d", "e"}}, []string{"a", "b", "c", "d", "e"}},
+		{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"}},
+			[]interface{}{&tstSlicer{"c"}},
+			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}}},
+		{&tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
+			[]interface{}{&tstSlicer{"c"}},
+			tstSlicers{&tstSlicer{"a"},
+				&tstSlicer{"b"},
+				&tstSlicer{"c"}}},
+		{testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}},
+			[]interface{}{&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"}}},
+		// Errors
+		{"", []interface{}{[]string{"a", "b"}}, false},
+		// No string concatenation.
+		{"ab",
+			[]interface{}{"c"},
+			false},
+	} {
+
+		errMsg := fmt.Sprintf("[%d]", i)
+
+		result, err := Append(test.start, test.addend...)
+
+		if b, ok := test.expected.(bool); ok && !b {
+			require.Error(t, err, errMsg)
+			continue
+		}
+
+		require.NoError(t, err, errMsg)
+
+		if !reflect.DeepEqual(test.expected, result) {
+			t.Fatalf("%s got\n%T: %v\nexpected\n%T: %v", errMsg, result, result, test.expected, test.expected)
+		}
+	}
+
+}

common/collections/collections.go

@@ -0,0 +1,21 @@
+// Copyright 2018 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 collections contains common Hugo functionality related to collection
+// handling.
+package collections
+
+// Grouper defines a very generic way to group items by a given key.
+type Grouper interface {
+	Group(key interface{}, items interface{}) (interface{}, error)
+}

common/collections/slice.go

@@ -0,0 +1,66 @@
+// Copyright 2018 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 collections
+
+import (
+	"reflect"
+)
+
+// Slicer defines a very generic way to create a typed slice. This is used
+// in collections.Slice template func to get types such as Pages, PageGroups etc.
+// instead of the less useful []interface{}.
+type Slicer interface {
+	Slice(items interface{}) (interface{}, error)
+}
+
+// Slice returns a slice of all passed arguments.
+func Slice(args ...interface{}) interface{} {
+	if len(args) == 0 {
+		return args
+	}
+
+	first := args[0]
+	firstType := reflect.TypeOf(first)
+
+	if firstType == nil {
+		return args
+	}
+
+	if g, ok := first.(Slicer); ok {
+		v, err := g.Slice(args)
+		if err == nil {
+			return v
+		}
+
+		// If Slice fails, the items are not of the same type and
+		// []interface{} is the best we can do.
+		return args
+	}
+
+	if len(args) > 1 {
+		// This can be a mix of types.
+		for i := 1; i < len(args); i++ {
+			if firstType != reflect.TypeOf(args[i]) {
+				// []interface{} is the best we can do
+				return args
+			}
+		}
+	}
+
+	slice := reflect.MakeSlice(reflect.SliceOf(firstType), len(args), len(args))
+	for i, arg := range args {
+		slice.Index(i).Set(reflect.ValueOf(arg))
+	}
+	return slice.Interface()
+}

common/collections/slice_test.go

@@ -0,0 +1,125 @@
+// Copyright 2018 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 collections
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/alecthomas/assert"
+)
+
+var _ Slicer = (*tstSlicer)(nil)
+var _ Slicer = (*tstSlicerIn1)(nil)
+var _ Slicer = (*tstSlicerIn2)(nil)
+var _ testSlicerInterface = (*tstSlicerIn1)(nil)
+var _ testSlicerInterface = (*tstSlicerIn1)(nil)
+
+type testSlicerInterface interface {
+	Name() string
+}
+
+type testSlicerInterfaces []testSlicerInterface
+
+type tstSlicerIn1 struct {
+	name string
+}
+
+type tstSlicerIn2 struct {
+	name string
+}
+
+type tstSlicer struct {
+	name string
+}
+
+func (p *tstSlicerIn1) Slice(in interface{}) (interface{}, error) {
+	items := in.([]interface{})
+	result := make(testSlicerInterfaces, len(items))
+	for i, v := range items {
+		switch vv := v.(type) {
+		case testSlicerInterface:
+			result[i] = vv
+		default:
+			return nil, errors.New("invalid type")
+		}
+
+	}
+	return result, nil
+}
+
+func (p *tstSlicerIn2) Slice(in interface{}) (interface{}, error) {
+	items := in.([]interface{})
+	result := make(testSlicerInterfaces, len(items))
+	for i, v := range items {
+		switch vv := v.(type) {
+		case testSlicerInterface:
+			result[i] = vv
+		default:
+			return nil, errors.New("invalid type")
+		}
+	}
+	return result, nil
+}
+
+func (p *tstSlicerIn1) Name() string {
+	return p.Name()
+}
+
+func (p *tstSlicerIn2) Name() string {
+	return p.Name()
+}
+
+func (p *tstSlicer) Slice(in interface{}) (interface{}, error) {
+	items := in.([]interface{})
+	result := make(tstSlicers, len(items))
+	for i, v := range items {
+		switch vv := v.(type) {
+		case *tstSlicer:
+			result[i] = vv
+		default:
+			return nil, errors.New("invalid type")
+		}
+	}
+	return result, nil
+}
+
+type tstSlicers []*tstSlicer
+
+func TestSlice(t *testing.T) {
+	t.Parallel()
+
+	for i, test := range []struct {
+		args     []interface{}
+		expected interface{}
+	}{
+		{[]interface{}{"a", "b"}, []string{"a", "b"}},
+		{[]interface{}{&tstSlicer{"a"}, &tstSlicer{"b"}}, tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
+		{[]interface{}{&tstSlicer{"a"}, "b"}, []interface{}{&tstSlicer{"a"}, "b"}},
+		{[]interface{}{}, []interface{}{}},
+		{[]interface{}{nil}, []interface{}{nil}},
+		{[]interface{}{5, "b"}, []interface{}{5, "b"}},
+		{[]interface{}{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}, testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}},
+		{[]interface{}{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}, []interface{}{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}},
+	} {
+		errMsg := fmt.Sprintf("[%d] %v", i, test.args)
+
+		result := Slice(test.args...)
+
+		assert.Equal(t, test.expected, result, errMsg)
+	}
+
+	assert.Len(t, Slice(), 0)
+}

common/herrors/error_locator.go

@@ -0,0 +1,255 @@
+// Copyright 2018 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 errors contains common Hugo errors and error related utilities.
+package herrors
+
+import (
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+
+	"github.com/gohugoio/hugo/common/text"
+
+	"github.com/spf13/afero"
+)
+
+// LineMatcher contains the elements used to match an error to a line
+type LineMatcher struct {
+	Position text.Position
+	Error    error
+
+	LineNumber int
+	Offset     int
+	Line       string
+}
+
+// LineMatcherFn is used to match a line with an error.
+type LineMatcherFn func(m LineMatcher) bool
+
+// SimpleLineMatcher simply matches by line number.
+var SimpleLineMatcher = func(m LineMatcher) bool {
+	return m.Position.LineNumber == m.LineNumber
+}
+
+var _ text.Positioner = ErrorContext{}
+
+// ErrorContext contains contextual information about an error. This will
+// typically be the lines surrounding some problem in a file.
+type ErrorContext struct {
+
+	// If a match will contain the matched line and up to 2 lines before and after.
+	// Will be empty if no match.
+	Lines []string
+
+	// The position of the error in the Lines above. 0 based.
+	LinesPos int
+
+	position text.Position
+
+	// The lexer to use for syntax highlighting.
+	// https://gohugo.io/content-management/syntax-highlighting/#list-of-chroma-highlighting-languages
+	ChromaLexer string
+}
+
+// Position returns the text position of this error.
+func (e ErrorContext) Position() text.Position {
+	return e.position
+}
+
+var _ causer = (*ErrorWithFileContext)(nil)
+
+// ErrorWithFileContext is an error with some additional file context related
+// to that error.
+type ErrorWithFileContext struct {
+	cause error
+	ErrorContext
+}
+
+func (e *ErrorWithFileContext) Error() string {
+	pos := e.Position()
+	if pos.IsValid() {
+		return pos.String() + ": " + e.cause.Error()
+	}
+	return e.cause.Error()
+}
+
+func (e *ErrorWithFileContext) Cause() error {
+	return e.cause
+}
+
+// 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 WithFileContextForFile(e error, realFilename, filename string, fs afero.Fs, matcher LineMatcherFn) (error, bool) {
+	f, err := fs.Open(filename)
+	if err != nil {
+		return e, false
+	}
+	defer f.Close()
+	return WithFileContext(e, realFilename, f, matcher)
+}
+
+// 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) {
+	if e == nil {
+		panic("error missing")
+	}
+	le := UnwrapFileError(e)
+
+	if le == nil {
+		var ok bool
+		if le, ok = ToFileError("", e).(FileError); !ok {
+			return e, false
+		}
+	}
+
+	var errCtx ErrorContext
+
+	posle := le.Position()
+
+	if posle.Offset != -1 {
+		errCtx = locateError(r, le, func(m LineMatcher) bool {
+			if posle.Offset >= m.Offset && posle.Offset < m.Offset+len(m.Line) {
+				lno := posle.LineNumber - m.Position.LineNumber + m.LineNumber
+				m.Position = text.Position{LineNumber: lno}
+			}
+			return matcher(m)
+		})
+	} else {
+		errCtx = locateError(r, le, matcher)
+	}
+
+	pos := &errCtx.position
+
+	if pos.LineNumber == -1 {
+		return e, false
+	}
+
+	pos.Filename = realFilename
+
+	if le.Type() != "" {
+		errCtx.ChromaLexer = chromaLexerFromType(le.Type())
+	} else {
+		errCtx.ChromaLexer = chromaLexerFromFilename(realFilename)
+	}
+
+	return &ErrorWithFileContext{cause: e, ErrorContext: errCtx}, true
+}
+
+// UnwrapErrorWithFileContext tries to unwrap an ErrorWithFileContext from err.
+// It returns nil if this is not possible.
+func UnwrapErrorWithFileContext(err error) *ErrorWithFileContext {
+	for err != nil {
+		switch v := err.(type) {
+		case *ErrorWithFileContext:
+			return v
+		case causer:
+			err = v.Cause()
+		default:
+			return nil
+		}
+	}
+	return nil
+}
+
+func chromaLexerFromType(fileType string) string {
+	switch fileType {
+	case "html", "htm":
+		return "go-html-template"
+	}
+	return fileType
+}
+
+func extNoDelimiter(filename string) string {
+	return strings.TrimPrefix(".", filepath.Ext(filename))
+}
+
+func chromaLexerFromFilename(filename string) string {
+	if strings.Contains(filename, "layouts") {
+		return "go-html-template"
+	}
+
+	ext := extNoDelimiter(filename)
+	return chromaLexerFromType(ext)
+}
+
+func locateErrorInString(src string, matcher LineMatcherFn) ErrorContext {
+	return locateError(strings.NewReader(src), &fileError{}, matcher)
+}
+
+func locateError(r io.Reader, le FileError, matches LineMatcherFn) ErrorContext {
+	if le == nil {
+		panic("must provide an error")
+	}
+
+	errCtx := ErrorContext{position: text.Position{LineNumber: -1, ColumnNumber: 1, Offset: -1}, LinesPos: -1}
+
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		return errCtx
+	}
+
+	pos := &errCtx.position
+	lepos := le.Position()
+
+	lines := strings.Split(string(b), "\n")
+
+	if le != nil && lepos.ColumnNumber >= 0 {
+		pos.ColumnNumber = lepos.ColumnNumber
+	}
+
+	lineNo := 0
+	posBytes := 0
+
+	for li, line := range lines {
+		lineNo = li + 1
+		m := LineMatcher{
+			Position:   le.Position(),
+			Error:      le,
+			LineNumber: lineNo,
+			Offset:     posBytes,
+			Line:       line,
+		}
+		if errCtx.LinesPos == -1 && matches(m) {
+			pos.LineNumber = lineNo
+			break
+		}
+
+		posBytes += len(line)
+	}
+
+	if pos.LineNumber != -1 {
+		low := pos.LineNumber - 3
+		if low < 0 {
+			low = 0
+		}
+
+		if pos.LineNumber > 2 {
+			errCtx.LinesPos = 2
+		} else {
+			errCtx.LinesPos = pos.LineNumber - 1
+		}
+
+		high := pos.LineNumber + 2
+		if high > len(lines) {
+			high = len(lines)
+		}
+
+		errCtx.Lines = lines[low:high]
+
+	}
+
+	return errCtx
+}

common/herrors/error_locator_test.go

@@ -0,0 +1,129 @@
+// Copyright 2018 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 errors contains common Hugo errors and error related utilities.
+package herrors
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestErrorLocator(t *testing.T) {
+	assert := require.New(t)
+
+	lineMatcher := func(m LineMatcher) bool {
+		return strings.Contains(m.Line, "THEONE")
+	}
+
+	lines := `LINE 1
+LINE 2
+LINE 3
+LINE 4
+This is THEONE
+LINE 6
+LINE 7
+LINE 8
+`
+
+	location := locateErrorInString(lines, lineMatcher)
+	assert.Equal([]string{"LINE 3", "LINE 4", "This is THEONE", "LINE 6", "LINE 7"}, location.Lines)
+
+	pos := location.Position()
+	assert.Equal(5, pos.LineNumber)
+	assert.Equal(2, location.LinesPos)
+
+	assert.Equal([]string{"This is THEONE"}, locateErrorInString(`This is THEONE`, lineMatcher).Lines)
+
+	location = locateErrorInString(`L1
+This is THEONE
+L2
+`, lineMatcher)
+	assert.Equal(2, location.Position().LineNumber)
+	assert.Equal(1, location.LinesPos)
+	assert.Equal([]string{"L1", "This is THEONE", "L2", ""}, location.Lines)
+
+	location = locateErrorInString(`This is THEONE
+L2
+`, lineMatcher)
+	assert.Equal(0, location.LinesPos)
+	assert.Equal([]string{"This is THEONE", "L2", ""}, location.Lines)
+
+	location = locateErrorInString(`L1
+This THEONE
+`, lineMatcher)
+	assert.Equal([]string{"L1", "This THEONE", ""}, location.Lines)
+	assert.Equal(1, location.LinesPos)
+
+	location = locateErrorInString(`L1
+L2
+This THEONE
+`, lineMatcher)
+	assert.Equal([]string{"L1", "L2", "This THEONE", ""}, location.Lines)
+	assert.Equal(2, location.LinesPos)
+
+	location = locateErrorInString("NO MATCH", lineMatcher)
+	assert.Equal(-1, location.Position().LineNumber)
+	assert.Equal(-1, location.LinesPos)
+	assert.Equal(0, len(location.Lines))
+
+	lineMatcher = func(m LineMatcher) bool {
+		return m.LineNumber == 6
+	}
+
+	location = locateErrorInString(`A
+B
+C
+D
+E
+F
+G
+H
+I
+J`, lineMatcher)
+
+	assert.Equal([]string{"D", "E", "F", "G", "H"}, location.Lines)
+	assert.Equal(6, location.Position().LineNumber)
+	assert.Equal(2, location.LinesPos)
+
+	// Test match EOF
+	lineMatcher = func(m LineMatcher) bool {
+		return m.LineNumber == 4
+	}
+
+	location = locateErrorInString(`A
+B
+C
+`, lineMatcher)
+
+	assert.Equal([]string{"B", "C", ""}, location.Lines)
+	assert.Equal(4, location.Position().LineNumber)
+	assert.Equal(2, location.LinesPos)
+
+	offsetMatcher := func(m LineMatcher) bool {
+		return m.Offset == 1
+	}
+
+	location = locateErrorInString(`A
+B
+C
+D
+E`, offsetMatcher)
+
+	assert.Equal([]string{"A", "B", "C", "D"}, location.Lines)
+	assert.Equal(2, location.Position().LineNumber)
+	assert.Equal(1, location.LinesPos)
+
+}

common/herrors/errors.go

@@ -0,0 +1,53 @@
+// Copyright 2018 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 herrors contains common Hugo errors and error related utilities.
+package herrors
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+
+	_errors "github.com/pkg/errors"
+)
+
+// As defined in https://godoc.org/github.com/pkg/errors
+type causer interface {
+	Cause() error
+}
+
+type stackTracer interface {
+	StackTrace() _errors.StackTrace
+}
+
+// PrintStackTrace prints the error's stack trace to stdoud.
+func PrintStackTrace(err error) {
+	FprintStackTrace(os.Stdout, err)
+}
+
+// FprintStackTrace prints the error's stack trace to w.
+func FprintStackTrace(w io.Writer, err error) {
+	if err, ok := err.(stackTracer); ok {
+		for _, f := range err.StackTrace() {
+			fmt.Fprintf(w, "%+s:%d\n", f, f)
+		}
+	}
+}
+
+// ErrFeatureNotAvailable denotes that a feature is unavailable.
+//
+// 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")

common/herrors/file_error.go

@@ -0,0 +1,133 @@
+// Copyright 2018 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
+// limitatio	ns under the License.
+
+package herrors
+
+import (
+	"encoding/json"
+
+	"github.com/gohugoio/hugo/common/text"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	_ causer = (*fileError)(nil)
+)
+
+// FileError represents an error when handling a file: Parsing a config file,
+// execute a template etc.
+type FileError interface {
+	error
+
+	text.Positioner
+
+	// A string identifying the type of file, e.g. JSON, TOML, markdown etc.
+	Type() string
+}
+
+var _ FileError = (*fileError)(nil)
+
+type fileError struct {
+	position text.Position
+
+	fileType string
+
+	cause error
+}
+
+// Position returns the text position of this error.
+func (e fileError) Position() text.Position {
+	return e.position
+}
+
+func (e *fileError) Type() string {
+	return e.fileType
+}
+
+func (e *fileError) Error() string {
+	if e.cause == nil {
+		return ""
+	}
+	return e.cause.Error()
+}
+
+func (f *fileError) Cause() error {
+	return f.cause
+}
+
+// NewFileError creates a new FileError.
+func NewFileError(fileType string, offset, lineNumber, columnNumber int, err error) FileError {
+	pos := text.Position{Offset: offset, LineNumber: lineNumber, ColumnNumber: columnNumber}
+	return &fileError{cause: err, fileType: fileType, position: pos}
+}
+
+// UnwrapFileError tries to unwrap a FileError from err.
+// It returns nil if this is not possible.
+func UnwrapFileError(err error) FileError {
+	for err != nil {
+		switch v := err.(type) {
+		case FileError:
+			return v
+		case causer:
+			err = v.Cause()
+		default:
+			return nil
+		}
+	}
+	return nil
+}
+
+// ToFileErrorWithOffset will return a new FileError with a line number
+// with the given offset from the original.
+func ToFileErrorWithOffset(fe FileError, offset int) FileError {
+	pos := fe.Position()
+	return ToFileErrorWithLineNumber(fe, pos.LineNumber+offset)
+}
+
+// ToFileErrorWithOffset will return a new FileError with the given line number.
+func ToFileErrorWithLineNumber(fe FileError, lineNumber int) FileError {
+	pos := fe.Position()
+	pos.LineNumber = lineNumber
+	return &fileError{cause: fe, fileType: fe.Type(), position: pos}
+}
+
+// ToFileError will convert the given error to an error supporting
+// the FileError interface.
+func ToFileError(fileType string, err error) FileError {
+	for _, handle := range lineNumberExtractors {
+		lno, col := handle(err)
+		offset, typ := extractOffsetAndType(err)
+		if fileType == "" {
+			fileType = typ
+		}
+
+		if lno > 0 || offset != -1 {
+			return NewFileError(fileType, offset, lno, col, err)
+		}
+	}
+	// Fall back to the pointing to line number 1.
+	return NewFileError(fileType, -1, 1, 1, err)
+}
+
+func extractOffsetAndType(e error) (int, string) {
+	e = errors.Cause(e)
+	switch v := e.(type) {
+	case *json.UnmarshalTypeError:
+		return int(v.Offset), "json"
+	case *json.SyntaxError:
+		return int(v.Offset), "json"
+	default:
+		return -1, ""
+	}
+}

common/herrors/file_error_test.go

@@ -0,0 +1,57 @@
+// Copyright 2018 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 herrors
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/pkg/errors"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestToLineNumberError(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	for i, test := range []struct {
+		in           error
+		offset       int
+		lineNumber   int
+		columnNumber int
+	}{
+		{errors.New("no line number for you"), 0, 1, 1},
+		{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},
+	} {
+
+		got := ToFileError("template", test.in)
+
+		errMsg := fmt.Sprintf("[%d][%T]", i, got)
+		le, ok := got.(FileError)
+		assert.True(ok)
+
+		assert.True(ok, errMsg)
+		pos := le.Position()
+		assert.Equal(test.lineNumber, pos.LineNumber, errMsg)
+		assert.Equal(test.columnNumber, pos.ColumnNumber, errMsg)
+		assert.Error(errors.Cause(got))
+	}
+
+}

common/herrors/line_number_extractors.go

@@ -0,0 +1,66 @@
+// Copyright 2018 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
+// limitatio	ns under the License.
+
+package herrors
+
+import (
+	"regexp"
+	"strconv"
+)
+
+var lineNumberExtractors = []lineNumberExtractor{
+	// Template/shortcode parse errors
+	newLineNumberErrHandlerFromRegexp(".*:(\\d+):(\\d*):"),
+	newLineNumberErrHandlerFromRegexp(".*:(\\d+):"),
+
+	// TOML parse errors
+	newLineNumberErrHandlerFromRegexp(".*Near line (\\d+)(\\s.*)"),
+
+	// YAML parse errors
+	newLineNumberErrHandlerFromRegexp("line (\\d+):"),
+
+	// i18n bundle errors
+	newLineNumberErrHandlerFromRegexp("\\((\\d+),\\s(\\d*)"),
+}
+
+type lineNumberExtractor func(e error) (int, int)
+
+func newLineNumberErrHandlerFromRegexp(expression string) lineNumberExtractor {
+	re := regexp.MustCompile(expression)
+	return extractLineNo(re)
+}
+
+func extractLineNo(re *regexp.Regexp) lineNumberExtractor {
+	return func(e error) (int, int) {
+		if e == nil {
+			panic("no error")
+		}
+		col := 1
+		s := e.Error()
+		m := re.FindStringSubmatch(s)
+		if len(m) >= 2 {
+			lno, _ := strconv.Atoi(m[1])
+			if len(m) > 2 {
+				col, _ = strconv.Atoi(m[2])
+			}
+
+			if col <= 0 {
+				col = 1
+			}
+
+			return lno, col
+		}
+
+		return -1, col
+	}
+}

common/hugio/readers.go

@@ -0,0 +1,53 @@
+// Copyright 2018 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 hugio
+
+import (
+	"io"
+	"strings"
+)
+
+// ReadSeeker wraps io.Reader and io.Seeker.
+type ReadSeeker interface {
+	io.Reader
+	io.Seeker
+}
+
+// ReadSeekCloser is implemented by afero.File. We use this as the common type for
+// content in Resource objects, even for strings.
+type ReadSeekCloser interface {
+	ReadSeeker
+	io.Closer
+}
+
+// ReadSeekerNoOpCloser implements ReadSeekCloser by doing nothing in Close.
+type ReadSeekerNoOpCloser struct {
+	ReadSeeker
+}
+
+// Close does nothing.
+func (r ReadSeekerNoOpCloser) Close() error {
+	return nil
+}
+
+// NewReadSeekerNoOpCloser creates a new ReadSeekerNoOpCloser with the given ReadSeeker.
+func NewReadSeekerNoOpCloser(r ReadSeeker) ReadSeekerNoOpCloser {
+	return ReadSeekerNoOpCloser{r}
+}
+
+// NewReadSeekerNoOpCloserFromString uses strings.NewReader to create a new ReadSeekerNoOpCloser
+// from the given string.
+func NewReadSeekerNoOpCloserFromString(content string) ReadSeekerNoOpCloser {
+	return ReadSeekerNoOpCloser{strings.NewReader(content)}
+}

common/hugio/writers.go

@@ -0,0 +1,76 @@
+// Copyright 2018 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 hugio
+
+import (
+	"io"
+	"io/ioutil"
+)
+
+type multiWriteCloser struct {
+	io.Writer
+	closers []io.WriteCloser
+}
+
+func (m multiWriteCloser) Close() error {
+	var err error
+	for _, c := range m.closers {
+		if closeErr := c.Close(); err != nil {
+			err = closeErr
+		}
+	}
+	return err
+}
+
+// NewMultiWriteCloser creates a new io.WriteCloser that duplicates its writes to all the
+// provided writers.
+func NewMultiWriteCloser(writeClosers ...io.WriteCloser) io.WriteCloser {
+	writers := make([]io.Writer, len(writeClosers))
+	for i, w := range writeClosers {
+		writers[i] = w
+	}
+	return multiWriteCloser{Writer: io.MultiWriter(writers...), closers: writeClosers}
+}
+
+// ToWriteCloser creates an io.WriteCloser from the given io.Writer.
+// If it's not already, one will be created with a Close method that does nothing.
+func ToWriteCloser(w io.Writer) io.WriteCloser {
+	if rw, ok := w.(io.WriteCloser); ok {
+		return rw
+	}
+
+	return struct {
+		io.Writer
+		io.Closer
+	}{
+		w,
+		ioutil.NopCloser(nil),
+	}
+}
+
+// ToReadCloser creates an io.ReadCloser from the given io.Reader.
+// If it's not already, one will be created with a Close method that does nothing.
+func ToReadCloser(r io.Reader) io.ReadCloser {
+	if rc, ok := r.(io.ReadCloser); ok {
+		return rc
+	}
+
+	return struct {
+		io.Reader
+		io.Closer
+	}{
+		r,
+		ioutil.NopCloser(nil),
+	}
+}

common/hugo/hugo.go

@@ -0,0 +1,67 @@
+// Copyright 2018 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 hugo
+
+import (
+	"fmt"
+	"html/template"
+)
+
+const (
+	EnvironmentDevelopment = "development"
+	EnvironmentProduction  = "production"
+)
+
+var (
+	// commitHash contains the current Git revision. Use make to build to make
+	// sure this gets set.
+	commitHash string
+
+	// buildDate contains the date of the current build.
+	buildDate string
+)
+
+// Info contains information about the current Hugo environment
+type Info struct {
+	CommitHash string
+	BuildDate  string
+
+	// The build environment.
+	// Defaults are "production" (hugo) and "development" (hugo server).
+	// This can also be set by the user.
+	// It can be any string, but it will be all lower case.
+	Environment string
+}
+
+// Version returns the current version as a comparable version string.
+func (i Info) Version() VersionString {
+	return CurrentVersion.Version()
+}
+
+// Generator a Hugo meta generator HTML tag.
+func (i Info) Generator() template.HTML {
+	return template.HTML(fmt.Sprintf(`<meta name="generator" content="Hugo %s" />`, CurrentVersion.String()))
+}
+
+// NewInfo creates a new Hugo Info object.
+func NewInfo(environment string) Info {
+	if environment == "" {
+		environment = EnvironmentProduction
+	}
+	return Info{
+		CommitHash:  commitHash,
+		BuildDate:   buildDate,
+		Environment: environment,
+	}
+}

common/hugo/hugo_test.go

@@ -11,23 +11,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package hugolib
+package hugo
 
 import (
 	"fmt"
 	"testing"
 
-	"github.com/gohugoio/hugo/helpers"
 	"github.com/stretchr/testify/require"
 )
 
 func TestHugoInfo(t *testing.T) {
 	assert := require.New(t)
 
-	assert.Equal(helpers.CurrentHugoVersion.Version(), hugoInfo.Version)
-	assert.IsType(helpers.HugoVersionString(""), hugoInfo.Version)
-	assert.Equal(CommitHash, hugoInfo.CommitHash)
-	assert.Equal(BuildDate, hugoInfo.BuildDate)
-	assert.Contains(hugoInfo.Generator, fmt.Sprintf("Hugo %s", hugoInfo.Version))
+	hugoInfo := NewInfo("")
+
+	assert.Equal(CurrentVersion.Version(), hugoInfo.Version())
+	assert.IsType(VersionString(""), hugoInfo.Version())
+	assert.Equal(commitHash, hugoInfo.CommitHash)
+	assert.Equal(buildDate, hugoInfo.BuildDate)
+	assert.Equal("production", hugoInfo.Environment)
+	assert.Contains(hugoInfo.Generator(), fmt.Sprintf("Hugo %s", hugoInfo.Version()))
 
 }

common/hugo/site.go

@@ -1,4 +1,4 @@
-// Copyright 2015 The Hugo Authors. All rights reserved.
+// Copyright 2018 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.
@@ -11,18 +11,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package transform
+package hugo
 
-var ar = newAbsURLReplacer()
+import "github.com/gohugoio/hugo/langs"
 
-// AbsURL replaces relative URLs with absolute ones
-// in HTML files, using the baseURL setting.
-var AbsURL = func(ct contentTransformer) {
-	ar.replaceInHTML(ct)
-}
-
-// AbsURLInXML replaces relative URLs with absolute ones
-// in XML files, using the baseURL setting.
-var AbsURLInXML = func(ct contentTransformer) {
-	ar.replaceInXML(ct)
+// Site represents a site in the build. This is currently a very narrow interface,
+// but the actual implementation will be richer, see hugolib.SiteInfo.
+type Site interface {
+	Language() *langs.Language
+	IsServer() bool
+	Hugo() Info
 }

common/hugo/vars_extended.go

@@ -11,13 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// +build windows
+// +build extended
 
-package commands
+package hugo
 
-const (
-	ansiEsc    = ""
-	clearLine  = ""
-	hideCursor = ""
-	showCursor = ""
-)
+var isExtended = true

common/hugo/vars_regular.go

@@ -11,13 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// +build !windows
+// +build !extended
 
-package commands
+package hugo
 
-const (
-	ansiEsc    = "\u001B"
-	clearLine  = "\r\033[K"
-	hideCursor = ansiEsc + "[?25l"
-	showCursor = ansiEsc + "[?25h"
-)
+var isExtended = false

common/hugo/version.go

@@ -1,4 +1,4 @@
-// Copyright 2015 The Hugo Authors. All rights reserved.
+// Copyright 2018 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.
@@ -11,18 +11,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package helpers
+package hugo
 
 import (
 	"fmt"
+
+	"runtime"
 	"strings"
 
 	"github.com/gohugoio/hugo/compare"
 	"github.com/spf13/cast"
 )
 
-// HugoVersion represents the Hugo build version.
-type HugoVersion struct {
+// Version represents the Hugo build version.
+type Version struct {
 	// Major and minor version.
 	Number float32
 
@@ -35,32 +37,34 @@ type HugoVersion struct {
 }
 
 var (
-	_ compare.Eqer     = (*HugoVersionString)(nil)
-	_ compare.Comparer = (*HugoVersionString)(nil)
+	_ compare.Eqer     = (*VersionString)(nil)
+	_ compare.Comparer = (*VersionString)(nil)
 )
 
-type HugoVersionString string
-
-func (v HugoVersion) String() string {
-	return hugoVersion(v.Number, v.PatchLevel, v.Suffix)
+func (v Version) String() string {
+	return version(v.Number, v.PatchLevel, v.Suffix)
 }
 
-func (v HugoVersion) Version() HugoVersionString {
-	return HugoVersionString(v.String())
+// Version returns the Hugo version.
+func (v Version) Version() VersionString {
+	return VersionString(v.String())
 }
 
-func (h HugoVersionString) String() string {
+// VersionString represents a Hugo version string.
+type VersionString string
+
+func (h VersionString) String() string {
 	return string(h)
 }
 
-// Implements compare.Comparer
-func (h HugoVersionString) Compare(other interface{}) int {
-	v := MustParseHugoVersion(h.String())
+// Compare implements the compare.Comparer interface.
+func (h VersionString) Compare(other interface{}) int {
+	v := MustParseVersion(h.String())
 	return compareVersionsWithSuffix(v.Number, v.PatchLevel, v.Suffix, other)
 }
 
-// Implements compare.Eqer
-func (h HugoVersionString) Eq(other interface{}) bool {
+// Eq implements the compare.Eqer interface.
+func (h VersionString) Eq(other interface{}) bool {
 	s, err := cast.ToStringE(other)
 	if err != nil {
 		return false
@@ -70,9 +74,9 @@ func (h HugoVersionString) Eq(other interface{}) bool {
 
 var versionSuffixes = []string{"-test", "-DEV"}
 
-// ParseHugoVersion parses a version string.
-func ParseHugoVersion(s string) (HugoVersion, error) {
-	var vv HugoVersion
+// ParseVersion parses a version string.
+func ParseVersion(s string) (Version, error) {
+	var vv Version
 	for _, suffix := range versionSuffixes {
 		if strings.HasSuffix(s, suffix) {
 			vv.Suffix = suffix
@@ -88,10 +92,10 @@ func ParseHugoVersion(s string) (HugoVersion, error) {
 	return vv, nil
 }
 
-// MustParseHugoVersion parses a version string
+// MustParseVersion parses a version string
 // and panics if any error occurs.
-func MustParseHugoVersion(s string) HugoVersion {
-	vv, err := ParseHugoVersion(s)
+func MustParseVersion(s string) Version {
+	vv, err := ParseVersion(s)
 	if err != nil {
 		panic(err)
 	}
@@ -99,36 +103,52 @@ func MustParseHugoVersion(s string) HugoVersion {
 }
 
 // ReleaseVersion represents the release version.
-func (v HugoVersion) ReleaseVersion() HugoVersion {
+func (v Version) ReleaseVersion() Version {
 	v.Suffix = ""
 	return v
 }
 
 // Next returns the next Hugo release version.
-func (v HugoVersion) Next() HugoVersion {
-	return HugoVersion{Number: v.Number + 0.01}
+func (v Version) Next() Version {
+	return Version{Number: v.Number + 0.01}
 }
 
 // Prev returns the previous Hugo release version.
-func (v HugoVersion) Prev() HugoVersion {
-	return HugoVersion{Number: v.Number - 0.01}
+func (v Version) Prev() Version {
+	return Version{Number: v.Number - 0.01}
 }
 
 // NextPatchLevel returns the next patch/bugfix Hugo version.
 // This will be a patch increment on the previous Hugo version.
-func (v HugoVersion) NextPatchLevel(level int) HugoVersion {
-	return HugoVersion{Number: v.Number - 0.01, PatchLevel: level}
+func (v Version) NextPatchLevel(level int) Version {
+	return Version{Number: v.Number - 0.01, PatchLevel: level}
 }
 
-// CurrentHugoVersion represents the current build version.
-// This should be the only one.
-var CurrentHugoVersion = HugoVersion{
-	Number:     0.43,
-	PatchLevel: 0,
-	Suffix:     "",
+// BuildVersionString creates a version string. This is what you see when
+// running "hugo version".
+func BuildVersionString() string {
+	program := "Hugo Static Site Generator"
+
+	version := "v" + CurrentVersion.String()
+	if commitHash != "" {
+		version += "-" + strings.ToUpper(commitHash)
+	}
+	if isExtended {
+		version += "/extended"
+	}
+
+	osArch := runtime.GOOS + "/" + runtime.GOARCH
+
+	date := buildDate
+	if date == "" {
+		date = "unknown"
+	}
+
+	return fmt.Sprintf("%s %s %s BuildDate: %s", program, version, osArch, date)
+
 }
 
-func hugoVersion(version float32, patchVersion int, suffix string) string {
+func version(version float32, patchVersion int, suffix string) string {
 	if patchVersion > 0 {
 		return fmt.Sprintf("%.2f.%d%s", version, patchVersion, suffix)
 	}
@@ -140,7 +160,7 @@ func hugoVersion(version float32, patchVersion int, suffix string) string {
 // It returns -1 if the given version is less than, 0 if equal and 1 if greater than
 // the running version.
 func CompareVersion(version interface{}) int {
-	return compareVersionsWithSuffix(CurrentHugoVersion.Number, CurrentHugoVersion.PatchLevel, CurrentHugoVersion.Suffix, version)
+	return compareVersionsWithSuffix(CurrentVersion.Number, CurrentVersion.PatchLevel, CurrentVersion.Suffix, version)
 }
 
 func compareVersions(inVersion float32, inPatchVersion int, in interface{}) int {
@@ -166,7 +186,7 @@ func compareVersionsWithSuffix(inVersion float32, inPatchVersion int, suffix str
 			return -1
 		}
 
-		v, err := ParseHugoVersion(s)
+		v, err := ParseVersion(s)
 		if err != nil {
 			return -1
 		}

common/hugo/version_current.go

@@ -0,0 +1,22 @@
+// Copyright 2018 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 hugo
+
+// CurrentVersion represents the current build version.
+// This should be the only one.
+var CurrentVersion = Version{
+	Number:     0.53,
+	PatchLevel: 0,
+	Suffix:     "",
+}

common/hugo/version_test.go

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package helpers
+package hugo
 
 import (
 	"testing"
@@ -21,10 +21,10 @@ import (
 )
 
 func TestHugoVersion(t *testing.T) {
-	assert.Equal(t, "0.15-DEV", hugoVersion(0.15, 0, "-DEV"))
-	assert.Equal(t, "0.15.2-DEV", hugoVersion(0.15, 2, "-DEV"))
+	assert.Equal(t, "0.15-DEV", version(0.15, 0, "-DEV"))
+	assert.Equal(t, "0.15.2-DEV", version(0.15, 2, "-DEV"))
 
-	v := HugoVersion{Number: 0.21, PatchLevel: 0, Suffix: "-DEV"}
+	v := Version{Number: 0.21, PatchLevel: 0, Suffix: "-DEV"}
 
 	require.Equal(t, v.ReleaseVersion().String(), "0.21")
 	require.Equal(t, "0.21-DEV", v.String())
@@ -62,9 +62,9 @@ func TestCompareVersions(t *testing.T) {
 }
 
 func TestParseHugoVersion(t *testing.T) {
-	require.Equal(t, "0.25", MustParseHugoVersion("0.25").String())
-	require.Equal(t, "0.25.2", MustParseHugoVersion("0.25.2").String())
-	require.Equal(t, "0.25-test", MustParseHugoVersion("0.25-test").String())
-	require.Equal(t, "0.25-DEV", MustParseHugoVersion("0.25-DEV").String())
+	require.Equal(t, "0.25", MustParseVersion("0.25").String())
+	require.Equal(t, "0.25.2", MustParseVersion("0.25.2").String())
+	require.Equal(t, "0.25-test", MustParseVersion("0.25-test").String())
+	require.Equal(t, "0.25-DEV", MustParseVersion("0.25-DEV").String())
 
 }

common/loggers/loggers.go

@@ -14,24 +14,160 @@
 package loggers
 
 import (
+	"bytes"
+	"io"
 	"io/ioutil"
 	"log"
 	"os"
+	"regexp"
+
+	"github.com/gohugoio/hugo/common/terminal"
 
 	jww "github.com/spf13/jwalterweatherman"
 )
 
+var (
+	// Counts ERROR logs to the global jww logger.
+	GlobalErrorCounter *jww.Counter
+)
+
+func init() {
+	GlobalErrorCounter = &jww.Counter{}
+	jww.SetLogListeners(jww.LogCounter(GlobalErrorCounter, jww.LevelError))
+}
+
+// Logger wraps a *loggers.Logger and some other related logging state.
+type Logger struct {
+	*jww.Notepad
+	ErrorCounter *jww.Counter
+
+	// This is only set in server mode.
+	errors *bytes.Buffer
+}
+
+func (l *Logger) Errors() string {
+	if l.errors == nil {
+		return ""
+	}
+	return ansiColorRe.ReplaceAllString(l.errors.String(), "")
+}
+
+// Reset resets the logger's internal state.
+func (l *Logger) Reset() {
+	l.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 {
+	return newLogger(stdoutThreshold, logThreshold, outHandle, logHandle, saveErrors)
+}
+
 // NewDebugLogger is a convenience function to create a debug logger.
-func NewDebugLogger() *jww.Notepad {
-	return jww.NewNotepad(jww.LevelDebug, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+func NewDebugLogger() *Logger {
+	return newBasicLogger(jww.LevelDebug)
 }
 
 // NewWarningLogger is a convenience function to create a warning logger.
-func NewWarningLogger() *jww.Notepad {
-	return jww.NewNotepad(jww.LevelWarn, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+func NewWarningLogger() *Logger {
+	return newBasicLogger(jww.LevelWarn)
 }
 
 // NewErrorLogger is a convenience function to create an error logger.
-func NewErrorLogger() *jww.Notepad {
-	return jww.NewNotepad(jww.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+func NewErrorLogger() *Logger {
+	return newBasicLogger(jww.LevelError)
+}
+
+var (
+	ansiColorRe = regexp.MustCompile("(?s)\\033\\[\\d*(;\\d*)*m")
+	errorRe     = regexp.MustCompile("^(ERROR|FATAL|WARN)")
+)
+
+type ansiCleaner struct {
+	w io.Writer
+}
+
+func (a ansiCleaner) Write(p []byte) (n int, err error) {
+	return a.w.Write(ansiColorRe.ReplaceAll(p, []byte("")))
+}
+
+type labelColorizer struct {
+	w io.Writer
+}
+
+func (a labelColorizer) Write(p []byte) (n int, err error) {
+	replaced := errorRe.ReplaceAllStringFunc(string(p), func(m string) string {
+		switch m {
+		case "ERROR", "FATAL":
+			return terminal.Error(m)
+		case "WARN":
+			return terminal.Warning(m)
+		default:
+			return m
+		}
+	})
+	// io.MultiWriter will abort if we return a bigger write count than input
+	// 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.
+func InitGlobalLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer) {
+	outHandle, logHandle = getLogWriters(outHandle, logHandle)
+
+	jww.SetStdoutOutput(outHandle)
+	jww.SetLogOutput(logHandle)
+	jww.SetLogThreshold(logThreshold)
+	jww.SetStdoutThreshold(stdoutThreshold)
+
+}
+
+func getLogWriters(outHandle, logHandle io.Writer) (io.Writer, io.Writer) {
+	isTerm := terminal.IsTerminal(os.Stdout)
+	if logHandle != ioutil.Discard && isTerm {
+		// Remove any Ansi coloring from log output
+		logHandle = ansiCleaner{w: logHandle}
+	}
+
+	if isTerm {
+		outHandle = labelColorizer{w: outHandle}
+	}
+
+	return outHandle, logHandle
+
+}
+
+func newLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) *Logger {
+	errorCounter := &jww.Counter{}
+	outHandle, logHandle = getLogWriters(outHandle, logHandle)
+
+	listeners := []jww.LogListener{jww.LogCounter(errorCounter, jww.LevelError)}
+	var errorBuff *bytes.Buffer
+	if saveErrors {
+		errorBuff = new(bytes.Buffer)
+		errorCapture := func(t jww.Threshold) io.Writer {
+			if t != jww.LevelError {
+				// Only interested in ERROR
+				return nil
+			}
+
+			return errorBuff
+		}
+
+		listeners = append(listeners, errorCapture)
+	}
+
+	return &Logger{
+		Notepad:      jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime, listeners...),
+		ErrorCounter: errorCounter,
+		errors:       errorBuff,
+	}
+}
+
+func newBasicLogger(t jww.Threshold) *Logger {
+	return newLogger(t, jww.LevelError, os.Stdout, ioutil.Discard, false)
 }

common/loggers/loggers_test.go

@@ -11,13 +11,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package errors contains common Hugo errors and error related utilities.
-package errors
+package loggers
 
 import (
-	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
-// 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 FeatureNotAvailableErr = errors.New("this feature is not available in your current Hugo version")
+func TestLogger(t *testing.T) {
+	assert := require.New(t)
+	l := NewWarningLogger()
+
+	l.ERROR.Println("One error")
+	l.ERROR.Println("Two error")
+	l.WARN.Println("A warning")
+
+	assert.Equal(uint64(2), l.ErrorCounter.Count())
+
+}

common/maps/maps.go

@@ -16,6 +16,8 @@ package maps
 import (
 	"strings"
 
+	"github.com/gobwas/glob"
+
 	"github.com/spf13/cast"
 )
 
@@ -42,3 +44,73 @@ func ToLower(m map[string]interface{}) {
 
 	}
 }
+
+type keyRename struct {
+	pattern glob.Glob
+	newKey  string
+}
+
+// KeyRenamer supports renaming of keys in a map.
+type KeyRenamer struct {
+	renames []keyRename
+}
+
+// NewKeyRenamer creates a new KeyRenamer given a list of pattern and new key
+// value pairs.
+func NewKeyRenamer(patternKeys ...string) (KeyRenamer, error) {
+	var renames []keyRename
+	for i := 0; i < len(patternKeys); i += 2 {
+		g, err := glob.Compile(strings.ToLower(patternKeys[i]), '/')
+		if err != nil {
+			return KeyRenamer{}, err
+		}
+		renames = append(renames, keyRename{pattern: g, newKey: patternKeys[i+1]})
+	}
+
+	return KeyRenamer{renames: renames}, nil
+}
+
+func (r KeyRenamer) getNewKey(keyPath string) string {
+	for _, matcher := range r.renames {
+		if matcher.pattern.Match(keyPath) {
+			return matcher.newKey
+		}
+	}
+
+	return ""
+}
+
+// Rename renames the keys in the given map according
+// to the patterns in the current KeyRenamer.
+func (r KeyRenamer) Rename(m map[string]interface{}) {
+	r.renamePath("", m)
+}
+
+func (KeyRenamer) keyPath(k1, k2 string) string {
+	k1, k2 = strings.ToLower(k1), strings.ToLower(k2)
+	if k1 == "" {
+		return k2
+	} else {
+		return k1 + "/" + k2
+	}
+}
+
+func (r KeyRenamer) renamePath(parentKeyPath string, m map[string]interface{}) {
+	for key, val := range m {
+		keyPath := r.keyPath(parentKeyPath, key)
+		switch val.(type) {
+		case map[interface{}]interface{}:
+			val = cast.ToStringMap(val)
+			r.renamePath(keyPath, val.(map[string]interface{}))
+		case map[string]interface{}:
+			r.renamePath(keyPath, val.(map[string]interface{}))
+		}
+
+		newKey := r.getNewKey(keyPath)
+
+		if newKey != "" {
+			delete(m, key)
+			m[newKey] = val
+		}
+	}
+}

common/maps/maps_test.go

@@ -16,6 +16,8 @@ package maps
 import (
 	"reflect"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestToLower(t *testing.T) {
@@ -70,3 +72,52 @@ func TestToLower(t *testing.T) {
 		}
 	}
 }
+
+func TestRenameKeys(t *testing.T) {
+	assert := require.New(t)
+
+	m := map[string]interface{}{
+		"a":    32,
+		"ren1": "m1",
+		"ren2": "m1_2",
+		"sub": map[string]interface{}{
+			"subsub": map[string]interface{}{
+				"REN1": "m2",
+				"ren2": "m2_2",
+			},
+		},
+		"no": map[string]interface{}{
+			"ren1": "m2",
+			"ren2": "m2_2",
+		},
+	}
+
+	expected := map[string]interface{}{
+		"a":    32,
+		"new1": "m1",
+		"new2": "m1_2",
+		"sub": map[string]interface{}{
+			"subsub": map[string]interface{}{
+				"new1": "m2",
+				"ren2": "m2_2",
+			},
+		},
+		"no": map[string]interface{}{
+			"ren1": "m2",
+			"ren2": "m2_2",
+		},
+	}
+
+	renamer, err := NewKeyRenamer(
+		"{ren1,sub/*/ren1}", "new1",
+		"{Ren2,sub/ren2}", "new2",
+	)
+	assert.NoError(err)
+
+	renamer.Rename(m)
+
+	if !reflect.DeepEqual(expected, m) {
+		t.Errorf("Expected\n%#v, got\n%#v\n", expected, m)
+	}
+
+}

common/maps/scratch.go

@@ -18,6 +18,7 @@ import (
 	"sort"
 	"sync"
 
+	"github.com/gohugoio/hugo/common/collections"
 	"github.com/gohugoio/hugo/common/math"
 )
 
@@ -40,14 +41,12 @@ func (c *Scratch) Add(key string, newAddend interface{}) (string, error) {
 	if found {
 		var err error
 
-		addendV := reflect.ValueOf(existingAddend)
+		addendV := reflect.TypeOf(existingAddend)
 
 		if addendV.Kind() == reflect.Slice || addendV.Kind() == reflect.Array {
-			nav := reflect.ValueOf(newAddend)
-			if nav.Kind() == reflect.Slice || nav.Kind() == reflect.Array {
-				newVal = reflect.AppendSlice(addendV, nav).Interface()
-			} else {
-				newVal = reflect.Append(addendV, nav).Interface()
+			newVal, err = collections.Append(existingAddend, newAddend)
+			if err != nil {
+				return "", err
 			}
 		} else {
 			newVal, err = math.DoArithmetic(existingAddend, newAddend, '+')
@@ -73,7 +72,7 @@ func (c *Scratch) Set(key string, value interface{}) string {
 	return ""
 }
 
-// Reset deletes the given key
+// Delete deletes the given key.
 func (c *Scratch) Delete(key string) string {
 	c.mu.Lock()
 	delete(c.values, key)
@@ -81,7 +80,7 @@ func (c *Scratch) Delete(key string) string {
 	return ""
 }
 
-// Get returns a value previously set by Add or Set
+// Get returns a value previously set by Add or Set.
 func (c *Scratch) Get(key string) interface{} {
 	c.mu.RLock()
 	val := c.values[key]
@@ -104,7 +103,7 @@ func (c *Scratch) SetInMap(key string, mapKey string, value interface{}) string
 	return ""
 }
 
-// GetSortedMapValues returns a sorted map previously filled with SetInMap
+// GetSortedMapValues returns a sorted map previously filled with SetInMap.
 func (c *Scratch) GetSortedMapValues(key string) interface{} {
 	c.mu.RLock()
 
@@ -130,6 +129,7 @@ func (c *Scratch) GetSortedMapValues(key string) interface{} {
 	return sortedArray
 }
 
+// NewScratch returns a new instance Scratch.
 func NewScratch() *Scratch {
 	return &Scratch{values: make(map[string]interface{})}
 }

common/maps/scratch_test.go

@@ -18,29 +18,31 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestScratchAdd(t *testing.T) {
 	t.Parallel()
+	assert := require.New(t)
+
 	scratch := NewScratch()
 	scratch.Add("int1", 10)
 	scratch.Add("int1", 20)
 	scratch.Add("int2", 20)
 
-	assert.Equal(t, int64(30), scratch.Get("int1"))
-	assert.Equal(t, 20, scratch.Get("int2"))
+	assert.Equal(int64(30), scratch.Get("int1"))
+	assert.Equal(20, scratch.Get("int2"))
 
 	scratch.Add("float1", float64(10.5))
 	scratch.Add("float1", float64(20.1))
 
-	assert.Equal(t, float64(30.6), scratch.Get("float1"))
+	assert.Equal(float64(30.6), scratch.Get("float1"))
 
 	scratch.Add("string1", "Hello ")
 	scratch.Add("string1", "big ")
 	scratch.Add("string1", "World!")
 
-	assert.Equal(t, "Hello big World!", scratch.Get("string1"))
+	assert.Equal("Hello big World!", scratch.Get("string1"))
 
 	scratch.Add("scratch", scratch)
 	_, err := scratch.Add("scratch", scratch)
@@ -53,12 +55,14 @@ func TestScratchAdd(t *testing.T) {
 
 func TestScratchAddSlice(t *testing.T) {
 	t.Parallel()
+	assert := require.New(t)
+
 	scratch := NewScratch()
 
 	_, err := scratch.Add("intSlice", []int{1, 2})
-	assert.Nil(t, err)
+	assert.NoError(err)
 	_, err = scratch.Add("intSlice", 3)
-	assert.Nil(t, err)
+	assert.NoError(err)
 
 	sl := scratch.Get("intSlice")
 	expected := []int{1, 2, 3}
@@ -66,10 +70,9 @@ func TestScratchAddSlice(t *testing.T) {
 	if !reflect.DeepEqual(expected, sl) {
 		t.Errorf("Slice difference, go %q expected %q", sl, expected)
 	}
-
 	_, err = scratch.Add("intSlice", []int{4, 5})
 
-	assert.Nil(t, err)
+	assert.NoError(err)
 
 	sl = scratch.Get("intSlice")
 	expected = []int{1, 2, 3, 4, 5}
@@ -77,29 +80,61 @@ func TestScratchAddSlice(t *testing.T) {
 	if !reflect.DeepEqual(expected, sl) {
 		t.Errorf("Slice difference, go %q expected %q", sl, expected)
 	}
+}
+
+// https://github.com/gohugoio/hugo/issues/5275
+func TestScratchAddTypedSliceToInterfaceSlice(t *testing.T) {
+	t.Parallel()
+	assert := require.New(t)
+
+	scratch := NewScratch()
+	scratch.Set("slice", []interface{}{})
+
+	_, err := scratch.Add("slice", []int{1, 2})
+	assert.NoError(err)
+	assert.Equal([]int{1, 2}, scratch.Get("slice"))
+
+}
+
+// https://github.com/gohugoio/hugo/issues/5361
+func TestScratchAddDifferentTypedSliceToInterfaceSlice(t *testing.T) {
+	t.Parallel()
+	assert := require.New(t)
+
+	scratch := NewScratch()
+	scratch.Set("slice", []string{"foo"})
+
+	_, err := scratch.Add("slice", []int{1, 2})
+	assert.NoError(err)
+	assert.Equal([]interface{}{"foo", 1, 2}, scratch.Get("slice"))
 
 }
 
 func TestScratchSet(t *testing.T) {
 	t.Parallel()
+	assert := require.New(t)
+
 	scratch := NewScratch()
 	scratch.Set("key", "val")
-	assert.Equal(t, "val", scratch.Get("key"))
+	assert.Equal("val", scratch.Get("key"))
 }
 
 func TestScratchDelete(t *testing.T) {
 	t.Parallel()
+	assert := require.New(t)
+
 	scratch := NewScratch()
 	scratch.Set("key", "val")
 	scratch.Delete("key")
 	scratch.Add("key", "Lucy Parsons")
-	assert.Equal(t, "Lucy Parsons", scratch.Get("key"))
+	assert.Equal("Lucy Parsons", scratch.Get("key"))
 }
 
 // Issue #2005
 func TestScratchInParallel(t *testing.T) {
 	var wg sync.WaitGroup
 	scratch := NewScratch()
+
 	key := "counter"
 	scratch.Set(key, int64(1))
 	for i := 1; i <= 10; i++ {
@@ -142,13 +177,15 @@ func TestScratchGet(t *testing.T) {
 
 func TestScratchSetInMap(t *testing.T) {
 	t.Parallel()
+	assert := require.New(t)
+
 	scratch := NewScratch()
 	scratch.SetInMap("key", "lux", "Lux")
 	scratch.SetInMap("key", "abc", "Abc")
 	scratch.SetInMap("key", "zyx", "Zyx")
 	scratch.SetInMap("key", "abc", "Abc (updated)")
 	scratch.SetInMap("key", "def", "Def")
-	assert.Equal(t, []interface{}{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"}, scratch.GetSortedMapValues("key"))
+	assert.Equal([]interface{}{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"}, scratch.GetSortedMapValues("key"))
 }
 
 func TestScratchGetSortedMapValues(t *testing.T) {

common/terminal/colors.go

@@ -0,0 +1,70 @@
+// Copyright 2018 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 terminal contains helper for the terminal, such as coloring output.
+package terminal
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+
+	isatty "github.com/mattn/go-isatty"
+)
+
+const (
+	errorColor   = "\033[1;31m%s\033[0m"
+	warningColor = "\033[0;33m%s\033[0m"
+	noticeColor  = "\033[1;36m%s\033[0m"
+)
+
+// IsTerminal return true if the file descriptor is terminal and the TERM
+// environment variable isn't a dumb one.
+func IsTerminal(f *os.File) bool {
+	if runtime.GOOS == "windows" {
+		return false
+	}
+
+	fd := f.Fd()
+	return os.Getenv("TERM") != "dumb" && (isatty.IsTerminal(fd) || isatty.IsCygwinTerminal(fd))
+}
+
+// Notice colorizes the string in a noticeable color.
+func Notice(s string) string {
+	return colorize(s, noticeColor)
+}
+
+// Error colorizes the string in a colour that grabs attention.
+func Error(s string) string {
+	return colorize(s, errorColor)
+}
+
+// Warning colorizes the string in a colour that warns.
+func Warning(s string) string {
+	return colorize(s, warningColor)
+}
+
+// colorize s in color.
+func colorize(s, color string) string {
+	s = fmt.Sprintf(color, doublePercent(s))
+	return singlePercent(s)
+}
+
+func doublePercent(str string) string {
+	return strings.Replace(str, "%", "%%", -1)
+}
+
+func singlePercent(str string) string {
+	return strings.Replace(str, "%%", "%", -1)
+}

common/text/position.go

@@ -0,0 +1,99 @@
+// Copyright 2018 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 text
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/gohugoio/hugo/common/terminal"
+)
+
+// Positioner represents a thing that knows its position in a text file or stream,
+// typically an error.
+type Positioner interface {
+	Position() Position
+}
+
+// Position holds a source position in a text file or stream.
+type Position struct {
+	Filename     string // filename, if any
+	Offset       int    // byte offset, starting at 0. It's set to -1 if not provided.
+	LineNumber   int    // line number, starting at 1
+	ColumnNumber int    // column number, starting at 1 (character count per line)
+}
+
+func (pos Position) String() string {
+	if pos.Filename == "" {
+		pos.Filename = "<stream>"
+	}
+	return positionStringFormatfunc(pos)
+}
+
+// IsValid returns true if line number is > 0.
+func (pos Position) IsValid() bool {
+	return pos.LineNumber > 0
+}
+
+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"}
+	var identifiersFound []string
+
+	for i := range formatStr {
+		for _, id := range identifiers {
+			if strings.HasPrefix(formatStr[i:], id) {
+				identifiersFound = append(identifiersFound, id)
+			}
+		}
+	}
+
+	replacer := strings.NewReplacer(":file", "%s", ":line", "%d", ":col", "%d")
+	format := replacer.Replace(formatStr)
+
+	f := func(pos Position) string {
+		args := make([]interface{}, len(identifiersFound))
+		for i, id := range identifiersFound {
+			switch id {
+			case ":file":
+				args[i] = pos.Filename
+			case ":line":
+				args[i] = pos.LineNumber
+			case ":col":
+				args[i] = pos.ColumnNumber
+			}
+		}
+
+		msg := fmt.Sprintf(format, args...)
+
+		if terminal.IsTerminal(os.Stdout) {
+			return terminal.Notice(msg)
+		}
+
+		return msg
+	}
+
+	return f
+}
+
+func init() {
+	positionStringFormatfunc = createPositionStringFormatter(os.Getenv("HUGO_FILE_LOG_FORMAT"))
+}

common/text/position_test.go

@@ -0,0 +1,33 @@
+// Copyright 2018 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 text
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPositionStringFormatter(t *testing.T) {
+	assert := require.New(t)
+
+	pos := Position{Filename: "/my/file.txt", LineNumber: 12, ColumnNumber: 13, Offset: 14}
+
+	assert.Equal("/my/file.txt|13|12", createPositionStringFormatter(":file|:col|:line")(pos))
+	assert.Equal("13|/my/file.txt|12", createPositionStringFormatter(":col|:file|:line")(pos))
+	assert.Equal("好:13", createPositionStringFormatter("好::col")(pos))
+	assert.Equal("\"/my/file.txt:12:13\"", createPositionStringFormatter("")(pos))
+	assert.Equal("\"/my/file.txt:12:13\"", pos.String())
+
+}

common/types/evictingqueue.go

@@ -52,6 +52,13 @@ func (q *EvictingStringQueue) Add(v string) {
 	q.mu.Unlock()
 }
 
+// Contains returns whether the queue contains v.
+func (q *EvictingStringQueue) Contains(v string) bool {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	return q.set[v]
+}
+
 // Peek looks at the last element added to the queue.
 func (q *EvictingStringQueue) Peek() string {
 	q.mu.Lock()

common/types/evictingqueue_test.go

@@ -36,6 +36,9 @@ func TestEvictingStringQueue(t *testing.T) {
 	queue.Add("a")
 	queue.Add("b")
 
+	assert.True(queue.Contains("a"))
+	assert.False(queue.Contains("foo"))
+
 	assert.Equal([]string{"b", "a"}, queue.PeekAll())
 	assert.Equal("b", queue.Peek())
 	queue.Add("c")

common/types/types.go

@@ -1,4 +1,4 @@
-// Copyright 2017-present The Hugo Authors. All rights reserved.
+// Copyright 2018 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.
@@ -41,6 +41,8 @@ func (k KeyValues) String() string {
 	return fmt.Sprintf("%v: %v", k.Key, k.Values)
 }
 
+// NewKeyValuesStrings takes a given key and slice of values and returns a new
+// KeyValues struct.
 func NewKeyValuesStrings(key string, values ...string) KeyValues {
 	iv := make([]interface{}, len(values))
 	for i := 0; i < len(values); i++ {

common/urls/ref.go

@@ -0,0 +1,22 @@
+// Copyright 2018 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 urls
+
+// RefLinker is implemented by those who support reference linking.
+// args must contain a path, but can also point to the target
+// language or output format.
+type RefLinker interface {
+	Ref(args map[string]interface{}) (string, error)
+	RelRef(args map[string]interface{}) (string, error)
+}

config/configLoader.go

@@ -0,0 +1,106 @@
+// Copyright 2018 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"
+	"github.com/gohugoio/hugo/parser/metadecoders"
+	"github.com/spf13/afero"
+	"github.com/spf13/viper"
+)
+
+// 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
+}
+
+// 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
+	}
+
+	v := newViper()
+
+	err = v.MergeConfigMap(m)
+	if err != nil {
+		return nil, err
+	}
+
+	return v, nil
+}
+
+// FromFileToMap is the same as FromFile, but it returns the config values
+// as a simple map.
+func FromFileToMap(fs afero.Fs, filename string) (map[string]interface{}, error) {
+	return loadConfigFromFile(fs, filename)
+}
+
+func readConfig(format metadecoders.Format, data []byte) (map[string]interface{}, error) {
+	m, err := metadecoders.Default.UnmarshalToMap(data, format)
+	if err != nil {
+		return nil, err
+	}
+
+	RenameKeys(m)
+
+	return m, nil
+
+}
+
+func loadConfigFromFile(fs afero.Fs, filename string) (map[string]interface{}, error) {
+	m, err := metadecoders.Default.UnmarshalFileToMap(fs, filename)
+	if err != nil {
+		return nil, err
+	}
+	RenameKeys(m)
+	return m, nil
+}
+
+var keyAliases maps.KeyRenamer
+
+func init() {
+	var err error
+	keyAliases, err = maps.NewKeyRenamer(
+		// Before 0.53 we used singular for "menu".
+		"{menu,languages/*/menu}", "menus",
+	)
+
+	if err != nil {
+		panic(err)
+	}
+}
+
+// RenameKeys renames config keys in m recursively according to a global Hugo
+// alias definition.
+func RenameKeys(m map[string]interface{}) {
+	keyAliases.Rename(m)
+}
+
+func newViper() *viper.Viper {
+	v := viper.New()
+	v.AutomaticEnv()
+	v.SetEnvPrefix("hugo")
+
+	return v
+}

config/configProvider.go

@@ -14,11 +14,7 @@
 package config
 
 import (
-	"strings"
-
 	"github.com/spf13/cast"
-
-	"github.com/spf13/viper"
 )
 
 // Provider provides the configuration settings for Hugo.
@@ -34,16 +30,6 @@ type Provider interface {
 	IsSet(key 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 := viper.New()
-	v.SetConfigType(configType)
-	if err := v.ReadConfig(strings.NewReader(config)); err != nil {
-		return nil, err
-	}
-	return v, nil
-}
-
 // GetStringSlicePreserveString returns a string slice from the given config and key.
 // It differs from the GetStringSlice method in that if the config value is a string,
 // we do not attempt to split it into fields.
@@ -51,7 +37,6 @@ func GetStringSlicePreserveString(cfg Provider, key string) []string {
 	sd := cfg.Get(key)
 	if sds, ok := sd.(string); ok {
 		return []string{sds}
-	} else {
-		return cast.ToStringSlice(sd)
 	}
+	return cast.ToStringSlice(sd)
 }

config/privacy/privacyConfig.go

@@ -96,6 +96,7 @@ type YouTube struct {
 	PrivacyEnhanced bool
 }
 
+// DecodeConfig creates a privacy Config from a given Hugo configuration.
 func DecodeConfig(cfg config.Provider) (pc Config, err error) {
 	if !cfg.IsSet(privacyConfigKey) {
 		return

config/services/servicesConfig.go

@@ -61,6 +61,7 @@ type Twitter struct {
 	DisableInlineCSS bool
 }
 
+// DecodeConfig creates a services Config from a given Hugo configuration.
 func DecodeConfig(cfg config.Provider) (c Config, err error) {
 	m := cfg.GetStringMap(servicesConfigKey)
 

create/content.go

@@ -16,72 +16,80 @@ package create
 
 import (
 	"bytes"
-	"fmt"
+
+	"github.com/pkg/errors"
+
+	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
+
+	"github.com/gohugoio/hugo/hugofs"
 
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugolib"
+	"github.com/spf13/afero"
 	jww "github.com/spf13/jwalterweatherman"
 )
 
 // NewContent creates a new content file in the content directory based upon the
 // given kind, which is used to lookup an archetype.
 func NewContent(
-	ps *helpers.PathSpec,
-	siteFactory func(filename string, siteUsed bool) (*hugolib.Site, error), kind, targetPath string) error {
+	sites *hugolib.HugoSites, kind, targetPath string) error {
+	targetPath = filepath.Clean(targetPath)
 	ext := helpers.Ext(targetPath)
-	fs := ps.BaseFs.SourceFilesystems.Archetypes.Fs
+	ps := sites.PathSpec
+	archetypeFs := ps.BaseFs.SourceFilesystems.Archetypes.Fs
+	sourceFs := ps.Fs.Source
 
 	jww.INFO.Printf("attempting to create %q of %q of ext %q", targetPath, kind, ext)
 
-	archetypeFilename := findArchetype(ps, kind, ext)
+	archetypeFilename, isDir := findArchetype(ps, kind, ext)
+	contentPath, s := resolveContentPath(sites, sourceFs, targetPath)
+
+	if isDir {
+
+		langFs := hugofs.NewLanguageFs(s.Language.Lang, sites.LanguageSet(), archetypeFs)
+
+		cm, err := mapArcheTypeDir(ps, langFs, archetypeFilename)
+		if err != nil {
+			return err
+		}
+
+		if cm.siteUsed {
+			if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+				return err
+			}
+		}
+
+		name := filepath.Base(targetPath)
+		return newContentFromDir(archetypeFilename, sites, archetypeFs, sourceFs, cm, name, contentPath)
+	}
 
 	// Building the sites can be expensive, so only do it if really needed.
 	siteUsed := false
 
 	if archetypeFilename != "" {
-		f, err := fs.Open(archetypeFilename)
+
+		var err error
+		siteUsed, err = usesSiteVar(archetypeFs, archetypeFilename)
 		if err != nil {
-			return fmt.Errorf("failed to open archetype file: %s", err)
-		}
-		defer f.Close()
-
-		if helpers.ReaderContains(f, []byte(".Site")) {
-			siteUsed = true
+			return err
 		}
 	}
 
-	s, err := siteFactory(targetPath, siteUsed)
+	if siteUsed {
+		if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+			return err
+		}
+	}
+
+	content, err := executeArcheTypeAsTemplate(s, "", kind, targetPath, archetypeFilename)
 	if err != nil {
 		return err
 	}
 
-	var content []byte
-
-	content, err = executeArcheTypeAsTemplate(s, kind, targetPath, archetypeFilename)
-	if err != nil {
-		return err
-	}
-
-	// The site may have multiple content dirs, and we currently do not know which contentDir the
-	// user wants to create this content in. We should improve on this, but we start by testing if the
-	// provided path points to an existing dir. If so, use it as is.
-	var contentPath string
-	var exists bool
-	targetDir := filepath.Dir(targetPath)
-
-	if targetDir != "" && targetDir != "." {
-		exists, _ = helpers.Exists(targetDir, fs)
-	}
-
-	if exists {
-		contentPath = targetPath
-	} else {
-		contentPath = s.PathSpec.AbsPathify(filepath.Join(s.Cfg.GetString("contentDir"), targetPath))
-	}
-
 	if err := helpers.SafeWriteToDisk(contentPath, bytes.NewReader(content), s.Fs.Source); err != nil {
 		return err
 	}
@@ -103,29 +111,200 @@ func NewContent(
 	return nil
 }
 
+func targetSite(sites *hugolib.HugoSites, fi *hugofs.LanguageFileInfo) *hugolib.Site {
+	for _, s := range sites.Sites {
+		if fi.Lang() == s.Language.Lang {
+			return s
+		}
+	}
+	return sites.Sites[0]
+}
+
+func newContentFromDir(
+	archetypeDir string,
+	sites *hugolib.HugoSites,
+	sourceFs, targetFs afero.Fs,
+	cm archetypeMap, name, targetPath string) error {
+
+	for _, f := range cm.otherFiles {
+		filename := f.Filename()
+		// Just copy the file to destination.
+		in, err := sourceFs.Open(filename)
+		if err != nil {
+			return errors.Wrap(err, "failed to open non-content file")
+		}
+
+		targetFilename := filepath.Join(targetPath, strings.TrimPrefix(filename, archetypeDir))
+
+		targetDir := filepath.Dir(targetFilename)
+		if err := targetFs.MkdirAll(targetDir, 0777); err != nil && !os.IsExist(err) {
+			return errors.Wrapf(err, "failed to create target directory for %s:", targetDir)
+		}
+
+		out, err := targetFs.Create(targetFilename)
+
+		_, err = io.Copy(out, in)
+		if err != nil {
+			return err
+		}
+
+		in.Close()
+		out.Close()
+	}
+
+	for _, f := range cm.contentFiles {
+		filename := f.Filename()
+		s := targetSite(sites, f)
+		targetFilename := filepath.Join(targetPath, strings.TrimPrefix(filename, archetypeDir))
+
+		content, err := executeArcheTypeAsTemplate(s, name, archetypeDir, targetFilename, filename)
+		if err != nil {
+			return errors.Wrap(err, "failed to execute archetype template")
+		}
+
+		if err := helpers.SafeWriteToDisk(targetFilename, bytes.NewReader(content), targetFs); err != nil {
+			return errors.Wrap(err, "failed to save results")
+		}
+	}
+
+	jww.FEEDBACK.Println(targetPath, "created")
+
+	return nil
+}
+
+type archetypeMap struct {
+	// These needs to be parsed and executed as Go templates.
+	contentFiles []*hugofs.LanguageFileInfo
+	// These are just copied to destination.
+	otherFiles []*hugofs.LanguageFileInfo
+	// If the templates needs a fully built site. This can potentially be
+	// expensive, so only do when needed.
+	siteUsed bool
+}
+
+func mapArcheTypeDir(
+	ps *helpers.PathSpec,
+	fs afero.Fs,
+	archetypeDir string) (archetypeMap, error) {
+
+	var m archetypeMap
+
+	walkFn := func(filename string, fi os.FileInfo, err error) error {
+
+		if err != nil {
+			return err
+		}
+
+		if fi.IsDir() {
+			return nil
+		}
+
+		fil := fi.(*hugofs.LanguageFileInfo)
+
+		if hugolib.IsContentFile(filename) {
+			m.contentFiles = append(m.contentFiles, fil)
+			if !m.siteUsed {
+				m.siteUsed, err = usesSiteVar(fs, filename)
+				if err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+
+		m.otherFiles = append(m.otherFiles, fil)
+
+		return nil
+	}
+
+	if err := helpers.SymbolicWalk(fs, archetypeDir, walkFn); err != nil {
+		return m, errors.Wrapf(err, "failed to walk archetype dir %q", archetypeDir)
+	}
+
+	return m, nil
+}
+
+func usesSiteVar(fs afero.Fs, filename string) (bool, error) {
+	f, err := fs.Open(filename)
+	if err != nil {
+		return false, errors.Wrap(err, "failed to open archetype file")
+	}
+	defer f.Close()
+	return helpers.ReaderContains(f, []byte(".Site")), nil
+}
+
+// Resolve the target content path.
+func resolveContentPath(sites *hugolib.HugoSites, fs afero.Fs, targetPath string) (string, *hugolib.Site) {
+	targetDir := filepath.Dir(targetPath)
+	first := sites.Sites[0]
+
+	var (
+		s              *hugolib.Site
+		siteContentDir string
+	)
+
+	// Try the filename: my-post.en.md
+	for _, ss := range sites.Sites {
+		if strings.Contains(targetPath, "."+ss.Language.Lang+".") {
+			s = ss
+			break
+		}
+	}
+
+	for _, ss := range sites.Sites {
+		contentDir := ss.PathSpec.ContentDir
+		if !strings.HasSuffix(contentDir, helpers.FilePathSeparator) {
+			contentDir += helpers.FilePathSeparator
+		}
+		if strings.HasPrefix(targetPath, contentDir) {
+			siteContentDir = ss.PathSpec.ContentDir
+			if s == nil {
+				s = ss
+			}
+			break
+		}
+	}
+
+	if s == nil {
+		s = first
+	}
+
+	if targetDir != "" && targetDir != "." {
+		exists, _ := helpers.Exists(targetDir, fs)
+
+		if exists {
+			return targetPath, s
+		}
+	}
+
+	if siteContentDir != "" {
+		pp := filepath.Join(siteContentDir, strings.TrimPrefix(targetPath, siteContentDir))
+		return s.PathSpec.AbsPathify(pp), s
+
+	} else {
+		return s.PathSpec.AbsPathify(filepath.Join(first.PathSpec.ContentDir, targetPath)), s
+	}
+
+}
+
 // FindArchetype takes a given kind/archetype of content and returns the path
 // to the archetype in the archetype filesystem, blank if none found.
-func findArchetype(ps *helpers.PathSpec, kind, ext string) (outpath string) {
+func findArchetype(ps *helpers.PathSpec, kind, ext string) (outpath string, isDir bool) {
 	fs := ps.BaseFs.Archetypes.Fs
 
-	// If the new content isn't in a subdirectory, kind == "".
-	// Therefore it should be excluded otherwise `is a directory`
-	// error will occur. github.com/gohugoio/hugo/issues/411
-	var pathsToCheck = []string{"default"}
+	var pathsToCheck []string
 
-	if ext != "" {
-		if kind != "" {
-			pathsToCheck = append([]string{kind + ext, "default" + ext}, pathsToCheck...)
-		} else {
-			pathsToCheck = append([]string{"default" + ext}, pathsToCheck...)
-		}
+	if kind != "" {
+		pathsToCheck = append(pathsToCheck, kind+ext)
 	}
+	pathsToCheck = append(pathsToCheck, "default"+ext, "default")
 
 	for _, p := range pathsToCheck {
-		if exists, _ := helpers.Exists(p, fs); exists {
-			return p
+		fi, err := fs.Stat(p)
+		if err == nil {
+			return p, fi.IsDir()
 		}
 	}
 
-	return ""
+	return "", false
 }

create/content_template_handler.go

@@ -20,6 +20,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/source"
 
@@ -80,7 +82,7 @@ var (
 		"%}x}", "%}}")
 )
 
-func executeArcheTypeAsTemplate(s *hugolib.Site, kind, targetPath, archetypeFilename string) ([]byte, error) {
+func executeArcheTypeAsTemplate(s *hugolib.Site, name, kind, targetPath, archetypeFilename string) ([]byte, error) {
 
 	var (
 		archetypeContent  []byte
@@ -88,20 +90,16 @@ func executeArcheTypeAsTemplate(s *hugolib.Site, kind, targetPath, archetypeFile
 		err               error
 	)
 
-	ps, err := helpers.NewPathSpec(s.Deps.Fs, s.Deps.Cfg)
-	if err != nil {
-		return nil, err
-	}
-	sp := source.NewSourceSpec(ps, ps.Fs.Source)
+	f := s.SourceSpec.NewFileInfo("", targetPath, false, nil)
 
-	f := sp.NewFileInfo("", targetPath, false, nil)
+	if name == "" {
+		name = f.TranslationBaseName()
 
-	name := f.TranslationBaseName()
-
-	if name == "index" || name == "_index" {
-		// Page bundles; the directory name will hopefully have a better name.
-		dir := strings.TrimSuffix(f.Dir(), helpers.FilePathSeparator)
-		_, name = filepath.Split(dir)
+		if name == "index" || name == "_index" {
+			// Page bundles; the directory name will hopefully have a better name.
+			dir := strings.TrimSuffix(f.Dir(), helpers.FilePathSeparator)
+			_, name = filepath.Split(dir)
+		}
 	}
 
 	data := ArchetypeFileData{
@@ -131,14 +129,14 @@ func executeArcheTypeAsTemplate(s *hugolib.Site, kind, targetPath, archetypeFile
 	templateHandler := s.Deps.Tmpl.(tpl.TemplateHandler)
 	templateName := "_text/" + helpers.Filename(archetypeFilename)
 	if err := templateHandler.AddTemplate(templateName, string(archetypeTemplate)); err != nil {
-		return nil, fmt.Errorf("Failed to parse archetype file %q: %s", archetypeFilename, err)
+		return nil, errors.Wrapf(err, "Failed to parse archetype file %q:", archetypeFilename)
 	}
 
 	templ, _ := templateHandler.Lookup(templateName)
 
 	var buff bytes.Buffer
 	if err := templ.Execute(&buff, data); err != nil {
-		return nil, fmt.Errorf("Failed to process archetype file %q: %s", archetypeFilename, err)
+		return nil, errors.Wrapf(err, "Failed to process archetype file %q:", archetypeFilename)
 	}
 
 	archetypeContent = []byte(archetypeShortcodeReplacementsPost.Replace(buff.String()))

create/content_test.go

@@ -35,8 +35,7 @@ import (
 )
 
 func TestNewContent(t *testing.T) {
-	v := viper.New()
-	initViper(v)
+	assert := require.New(t)
 
 	cases := []struct {
 		kind     string
@@ -49,6 +48,14 @@ func TestNewContent(t *testing.T) {
 		{"stump", "stump/sample-2.md", []string{`title: "Sample 2"`}},      // no archetype file
 		{"", "sample-3.md", []string{`title: "Sample 3"`}},                 // no archetype
 		{"product", "product/sample-4.md", []string{`title = "SAMPLE-4"`}}, // empty archetype front matter
+		{"lang", "post/lang-1.md", []string{`Site Lang: en|Name: Lang 1|i18n: Hugo Rocks!`}},
+		{"lang", "post/lang-2.en.md", []string{`Site Lang: en|Name: Lang 2|i18n: Hugo Rocks!`}},
+		{"lang", "post/lang-3.nn.md", []string{`Site Lang: nn|Name: Lang 3|i18n: Hugo Rokkar!`}},
+		{"lang", "content_nn/post/lang-4.md", []string{`Site Lang: nn|Name: Lang 4|i18n: Hugo Rokkar!`}},
+		{"lang", "content_nn/post/lang-5.en.md", []string{`Site Lang: en|Name: Lang 5|i18n: Hugo Rocks!`}},
+		{"lang", "post/my-bundle/index.md", []string{`Site Lang: en|Name: My Bundle|i18n: Hugo Rocks!`}},
+		{"lang", "post/my-bundle/index.en.md", []string{`Site Lang: en|Name: My Bundle|i18n: Hugo Rocks!`}},
+		{"lang", "post/my-bundle/index.nn.md", []string{`Site Lang: nn|Name: My Bundle|i18n: Hugo Rokkar!`}},
 		{"shortcodes", "shortcodes/go.md", []string{
 			`title = "GO"`,
 			"{{< myshortcode >}}",
@@ -56,21 +63,20 @@ func TestNewContent(t *testing.T) {
 			"{{</* comment */>}}\n{{%/* comment */%}}"}}, // shortcodes
 	}
 
-	for _, c := range cases {
-		cfg, fs := newTestCfg()
-		require.NoError(t, initFs(fs))
+	for i, c := range cases {
+		cfg, fs := newTestCfg(assert)
+		assert.NoError(initFs(fs))
 		h, err := hugolib.NewHugoSites(deps.DepsCfg{Cfg: cfg, Fs: fs})
-		require.NoError(t, err)
+		assert.NoError(err)
 
-		siteFactory := func(filename string, siteUsed bool) (*hugolib.Site, error) {
-			return h.Sites[0], nil
+		assert.NoError(create.NewContent(h, c.kind, c.path))
+
+		fname := filepath.FromSlash(c.path)
+		if !strings.HasPrefix(fname, "content") {
+			fname = filepath.Join("content", fname)
 		}
-
-		require.NoError(t, create.NewContent(h.PathSpec, siteFactory, c.kind, c.path))
-
-		fname := filepath.Join("content", filepath.FromSlash(c.path))
 		content := readFileFromFs(t, fs.Source, fname)
-		for i, v := range c.expected {
+		for _, v := range c.expected {
 			found := strings.Contains(content, v)
 			if !found {
 				t.Fatalf("[%d] %q missing from output:\n%q", i, v, content)
@@ -79,17 +85,54 @@ func TestNewContent(t *testing.T) {
 	}
 }
 
-func initViper(v *viper.Viper) {
-	v.Set("metaDataFormat", "toml")
-	v.Set("archetypeDir", "archetypes")
-	v.Set("contentDir", "content")
-	v.Set("themesDir", "themes")
-	v.Set("layoutDir", "layouts")
-	v.Set("i18nDir", "i18n")
-	v.Set("theme", "sample")
-	v.Set("archetypeDir", "archetypes")
-	v.Set("resourceDir", "resources")
-	v.Set("publishDir", "public")
+func TestNewContentFromDir(t *testing.T) {
+	assert := require.New(t)
+	cfg, fs := newTestCfg(assert)
+	assert.NoError(initFs(fs))
+
+	archetypeDir := filepath.Join("archetypes", "my-bundle")
+	assert.NoError(fs.Source.Mkdir(archetypeDir, 0755))
+
+	archetypeThemeDir := filepath.Join("themes", "mytheme", "archetypes", "my-theme-bundle")
+	assert.NoError(fs.Source.Mkdir(archetypeThemeDir, 0755))
+
+	contentFile := `
+File: %s
+Site Lang: {{ .Site.Language.Lang  }} 	
+Name: {{ replace .Name "-" " " | title }}
+i18n: {{ T "hugo" }}
+`
+
+	assert.NoError(afero.WriteFile(fs.Source, filepath.Join(archetypeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0755))
+	assert.NoError(afero.WriteFile(fs.Source, filepath.Join(archetypeDir, "index.nn.md"), []byte(fmt.Sprintf(contentFile, "index.nn.md")), 0755))
+
+	assert.NoError(afero.WriteFile(fs.Source, filepath.Join(archetypeDir, "pages", "bio.md"), []byte(fmt.Sprintf(contentFile, "bio.md")), 0755))
+	assert.NoError(afero.WriteFile(fs.Source, filepath.Join(archetypeDir, "resources", "hugo1.json"), []byte(`hugo1: {{ printf "no template handling in here" }}`), 0755))
+	assert.NoError(afero.WriteFile(fs.Source, filepath.Join(archetypeDir, "resources", "hugo2.xml"), []byte(`hugo2: {{ printf "no template handling in here" }}`), 0755))
+
+	assert.NoError(afero.WriteFile(fs.Source, filepath.Join(archetypeThemeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0755))
+	assert.NoError(afero.WriteFile(fs.Source, filepath.Join(archetypeThemeDir, "resources", "hugo1.json"), []byte(`hugo1: {{ printf "no template handling in here" }}`), 0755))
+
+	h, err := hugolib.NewHugoSites(deps.DepsCfg{Cfg: cfg, Fs: fs})
+	assert.NoError(err)
+	assert.Equal(2, len(h.Sites))
+
+	assert.NoError(create.NewContent(h, "my-bundle", "post/my-post"))
+
+	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/resources/hugo1.json")), `hugo1: {{ printf "no template handling in here" }}`)
+	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/resources/hugo2.xml")), `hugo2: {{ printf "no template handling in here" }}`)
+
+	// Content files should get the correct site context.
+	// TODO(bep) archetype check i18n
+	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/index.md")), `File: index.md`, `Site Lang: en`, `Name: My Post`, `i18n: Hugo Rocks!`)
+	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/index.nn.md")), `File: index.nn.md`, `Site Lang: nn`, `Name: My Post`, `i18n: Hugo Rokkar!`)
+
+	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/pages/bio.md")), `File: bio.md`, `Site Lang: en`, `Name: My Post`)
+
+	assert.NoError(create.NewContent(h, "my-theme-bundle", "post/my-theme-post"))
+	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-theme-post/index.md")), `File: index.md`, `Site Lang: en`, `Name: My Theme Post`, `i18n: Hugo Rocks!`)
+	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-theme-post/resources/hugo1.json")), `hugo1: {{ printf "no template handling in here" }}`)
+
 }
 
 func initFs(fs *hugofs.Fs) error {
@@ -132,6 +175,10 @@ title = "{{ .BaseFileName  | upper }}"
 			path:    filepath.Join("archetypes", "emptydate.md"),
 			content: "+++\ndate =\"\"\ntitle = \"Empty Date Arch title\"\ntest = \"test1\"\n+++\n",
 		},
+		{
+			path:    filepath.Join("archetypes", "lang.md"),
+			content: `Site Lang: {{ .Site.Language.Lang  }}|Name: {{ replace .Name "-" " " | title }}|i18n: {{ T "hugo" }}`,
+		},
 		// #3623x
 		{
 			path: filepath.Join("archetypes", "shortcodes.md"),
@@ -166,6 +213,12 @@ Some text.
 	return nil
 }
 
+func assertContains(assert *require.Assertions, v interface{}, matches ...string) {
+	for _, m := range matches {
+		assert.Contains(v, m)
+	}
+}
+
 // TODO(bep) extract common testing package with this and some others
 func readFileFromFs(t *testing.T, fs afero.Fs, filename string) string {
 	filename = filepath.FromSlash(filename)
@@ -185,22 +238,35 @@ func readFileFromFs(t *testing.T, fs afero.Fs, filename string) string {
 	return string(b)
 }
 
-func newTestCfg() (*viper.Viper, *hugofs.Fs) {
+func newTestCfg(assert *require.Assertions) (*viper.Viper, *hugofs.Fs) {
 
-	v := viper.New()
-	v.Set("contentDir", "content")
-	v.Set("dataDir", "data")
-	v.Set("i18nDir", "i18n")
-	v.Set("layoutDir", "layouts")
-	v.Set("archetypeDir", "archetypes")
-	v.Set("assetDir", "assets")
+	cfg := `
 
-	fs := hugofs.NewMem(v)
+theme = "mytheme"
+	
+[languages]
+[languages.en]
+weight = 1
+languageName = "English"
+[languages.nn]
+weight = 2
+languageName = "Nynorsk"
+contentDir = "content_nn"
 
-	v.SetFs(fs.Source)
+`
 
-	initViper(v)
+	mm := afero.NewMemMapFs()
 
-	return v, fs
+	assert.NoError(afero.WriteFile(mm, filepath.Join("i18n", "en.toml"), []byte(`[hugo]
+other = "Hugo Rocks!"`), 0755))
+	assert.NoError(afero.WriteFile(mm, filepath.Join("i18n", "nn.toml"), []byte(`[hugo]
+other = "Hugo Rokkar!"`), 0755))
+
+	assert.NoError(afero.WriteFile(mm, "config.toml", []byte(cfg), 0755))
+
+	v, _, err := hugolib.LoadConfig(hugolib.ConfigSourceDescriptor{Fs: mm, Filename: "config.toml"})
+	assert.NoError(err)
+
+	return v, hugofs.NewFrom(mm, v)
 
 }

deps/deps.go

@@ -1,10 +1,14 @@
 package deps
 
 import (
+	"sync"
 	"time"
 
-	"github.com/gohugoio/hugo/common/loggers"
+	"github.com/pkg/errors"
 
+	"github.com/gohugoio/hugo/cache/filecache"
+	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
@@ -22,8 +26,9 @@ import (
 // There will be normally only one instance of deps in play
 // at a given time, i.e. one per Site built.
 type Deps struct {
+
 	// The logger to use.
-	Log *jww.Notepad `json:"-"`
+	Log *loggers.Logger `json:"-"`
 
 	// Used to log errors that may repeat itself many times.
 	DistinctErrorLog *helpers.DistinctLogger
@@ -52,11 +57,18 @@ type Deps struct {
 	// The configuration to use
 	Cfg config.Provider `json:"-"`
 
+	// The file cache to use.
+	FileCaches filecache.Caches
+
 	// The translation func to use
 	Translate func(translationID string, args ...interface{}) string `json:"-"`
 
+	// The language in use. TODO(bep) consolidate with site
 	Language *langs.Language
 
+	// The site building.
+	Site hugo.Site
+
 	// All the output formats available for the current site.
 	OutputFormatsConfig output.Formats
 
@@ -69,6 +81,63 @@ type Deps struct {
 
 	// Timeout is configurable in site config.
 	Timeout time.Duration
+
+	// BuildStartListeners will be notified before a build starts.
+	BuildStartListeners *Listeners
+
+	*globalErrHandler
+}
+
+type globalErrHandler struct {
+	// Channel for some "hard to get to" build errors
+	buildErrors chan error
+}
+
+// SendErr sends the error on a channel to be handled later.
+// This can be used in situations where returning and aborting the current
+// operation isn't practical.
+func (e *globalErrHandler) SendError(err error) {
+	if e.buildErrors != nil {
+		select {
+		case e.buildErrors <- err:
+		default:
+		}
+		return
+	}
+
+	jww.ERROR.Println(err)
+}
+
+func (e *globalErrHandler) StartErrorCollector() chan error {
+	e.buildErrors = make(chan error, 10)
+	return e.buildErrors
+}
+
+// Listeners represents an event listener.
+type Listeners struct {
+	sync.Mutex
+
+	// A list of funcs to be notified about an event.
+	listeners []func()
+}
+
+// Add adds a function to a Listeners instance.
+func (b *Listeners) Add(f func()) {
+	if b == nil {
+		return
+	}
+	b.Lock()
+	defer b.Unlock()
+	b.listeners = append(b.listeners, f)
+}
+
+// Notify executes all listener functions.
+func (b *Listeners) Notify() {
+	b.Lock()
+	defer b.Unlock()
+	for _, notify := range b.listeners {
+		notify()
+	}
 }
 
 // ResourceProvider is used to create and refresh, and clone resources needed.
@@ -93,10 +162,6 @@ func (d *Deps) LoadResources() error {
 		return err
 	}
 
-	if th, ok := d.Tmpl.(tpl.TemplateHandler); ok {
-		th.PrintErrors()
-	}
-
 	return nil
 }
 
@@ -130,13 +195,26 @@ func New(cfg DepsCfg) (*Deps, error) {
 		fs = hugofs.NewDefault(cfg.Language)
 	}
 
+	if cfg.MediaTypes == nil {
+		cfg.MediaTypes = media.DefaultTypes
+	}
+
+	if cfg.OutputFormats == nil {
+		cfg.OutputFormats = output.DefaultFormats
+	}
+
 	ps, err := helpers.NewPathSpec(fs, cfg.Language)
 
 	if err != nil {
 		return nil, err
 	}
 
-	resourceSpec, err := resource.NewSpec(ps, logger, cfg.MediaTypes)
+	fileCaches, err := filecache.NewCaches(ps)
+	if err != nil {
+		return nil, errors.WithMessage(err, "failed to create file caches from configuration")
+	}
+
+	resourceSpec, err := resource.NewSpec(ps, fileCaches, logger, cfg.OutputFormats, cfg.MediaTypes)
 	if err != nil {
 		return nil, err
 	}
@@ -168,7 +246,11 @@ func New(cfg DepsCfg) (*Deps, error) {
 		ResourceSpec:        resourceSpec,
 		Cfg:                 cfg.Language,
 		Language:            cfg.Language,
+		Site:                cfg.Site,
+		FileCaches:          fileCaches,
+		BuildStartListeners: &Listeners{},
 		Timeout:             time.Duration(timeoutms) * time.Millisecond,
+		globalErrHandler:    &globalErrHandler{},
 	}
 
 	if cfg.Cfg.GetBool("templateMetrics") {
@@ -180,7 +262,7 @@ func New(cfg DepsCfg) (*Deps, error) {
 
 // ForLanguage creates a copy of the Deps with the language dependent
 // parts switched out.
-func (d Deps) ForLanguage(cfg DepsCfg) (*Deps, error) {
+func (d Deps) ForLanguage(cfg DepsCfg, onCreated func(d *Deps) error) (*Deps, error) {
 	l := cfg.Language
 	var err error
 
@@ -194,14 +276,26 @@ func (d Deps) ForLanguage(cfg DepsCfg) (*Deps, error) {
 		return nil, err
 	}
 
-	d.ResourceSpec, err = resource.NewSpec(d.PathSpec, d.Log, cfg.MediaTypes)
+	d.Site = cfg.Site
+
+	// The resource cache is global so reuse.
+	// TODO(bep) clean up these inits.
+	resourceCache := d.ResourceSpec.ResourceCache
+	d.ResourceSpec, err = resource.NewSpec(d.PathSpec, d.ResourceSpec.FileCaches, d.Log, cfg.OutputFormats, cfg.MediaTypes)
 	if err != nil {
 		return nil, err
 	}
+	d.ResourceSpec.ResourceCache = resourceCache
 
 	d.Cfg = l
 	d.Language = l
 
+	if onCreated != nil {
+		if err = onCreated(&d); err != nil {
+			return nil, err
+		}
+	}
+
 	if err := d.translationProvider.Clone(&d); err != nil {
 		return nil, err
 	}
@@ -210,6 +304,8 @@ func (d Deps) ForLanguage(cfg DepsCfg) (*Deps, error) {
 		return nil, err
 	}
 
+	d.BuildStartListeners = &Listeners{}
+
 	return &d, nil
 
 }
@@ -220,7 +316,7 @@ func (d Deps) ForLanguage(cfg DepsCfg) (*Deps, error) {
 type DepsCfg struct {
 
 	// The Logger to use.
-	Logger *jww.Notepad
+	Logger *loggers.Logger
 
 	// The file systems to use
 	Fs *hugofs.Fs
@@ -228,12 +324,18 @@ type DepsCfg struct {
 	// The language to use.
 	Language *langs.Language
 
+	// The Site in use
+	Site hugo.Site
+
 	// The configuration to use.
 	Cfg config.Provider
 
 	// The media types configured.
 	MediaTypes media.Types
 
+	// The output formats configured.
+	OutputFormats output.Formats
+
 	// Template handling.
 	TemplateProvider ResourceProvider
 	WithTemplate     func(templ tpl.TemplateHandler) error

docs/.github/stale.yml

@@ -0,0 +1,21 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 120
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 30
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - Keep
+  - Security
+# Label to use when marking an issue as stale
+staleLabel: Stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. The resources of the Hugo team are limited, and so we are asking for your help.
+
+  If you still think this is important, please tell us why.
+
+  This issue will automatically be closed in the near future if no further activity occurs. Thank you for all your contributions.
+  
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

docs/archetypes/showcase/bio.md

@@ -0,0 +1,8 @@
+
+Add some **general info** about {{ replace .Name "-" " " | title }} here.
+
+The site is built by:
+
+* [Person 1](https://example.com)
+* [Person 1](https://example.com)
+

docs/archetypes/showcase/index.md

@@ -0,0 +1,37 @@
+---
+
+title: {{ replace .Name "-" " " | title }}
+date: {{ now.Format "2006-01-02" }}
+
+description: "A short description of this page."
+
+# The URL to the site on the internet.
+siteURL: https://gohugo.io/
+
+# Link to the site's Hugo source code if public and you can/want to share.
+# Remove or leave blank if not needed/wanted.
+siteSource: https://github.com/gohugoio/hugoDocs
+
+# Add credit to the article author. Leave blank or remove if not needed/wanted.
+byline: "[bep](https://github.com/bep), Hugo Lead"
+
+---
+
+To complete this showcase:
+
+1. Write the story about your site in this file.
+2. Add a summary to the `bio.md` file in this folder.
+3. Replace the `featured-template.png` with a screenshot of your site. You can rename it, but it must contain the word `featured`.
+4. Create a new pull request in https://github.com/gohugoio/hugoDocs/pulls
+
+The content of this bundle explained:
+
+index.md
+: The main content file. Fill in required front matter metadata and write your story. I does not have to be a novel. It can even be self-promotional, but it should include Hugo in some form.
+
+bio.md
+: A short summary of the website. Site credits (who built it) fits nicely here.
+
+featured.png
+: A reasonably sized screenshot of your website. It can be named anything, but the name must start with "featured". The sample image is `1500x750` (2:1 aspect ratio).
+

docs/config.toml

@@ -34,7 +34,6 @@ section = [ "HTML", "RSS"]
 
 [mediaTypes]
 [mediaTypes."text/netlify"]
-suffix = ""
 delimiter = ""
 
 [outputFormats]
@@ -70,7 +69,7 @@ twitter = "GoHugoIO"
 [params]
   description = "The world’s fastest framework for building websites"
   ## Used for views in rendered HTML (i.e., rather than using the .Hugo variable)
-  release = "0.43"
+  release = "0.53"
   ## Setting this to true will add a "noindex" to *EVERY* page on the site
   removefromexternalsearch = false
   ## Gh repo for site footer (include trailing slash)
@@ -108,7 +107,7 @@ twitter = "GoHugoIO"
 # Note that you can also set this per image processing.
 resampleFilter = "CatmullRom"
 
-# Defatult JPEG quality setting. Default is 75.
+# Default JPEG quality setting. Default is 75.
 quality = 75
 
 anchor = "smart"
@@ -167,7 +166,11 @@ anchor = "smart"
   weight = 35
   identifier = "variables"
   url = "/variables/"
-
+[[menu.docs]]
+  name = "Hugo Pipes"
+  weight = 36
+  identifier = "pipes"
+  url = "/hugo-pipes/"
 [[menu.docs]]
   name = "CLI"
   weight = 40

docs/content/en/about/features.md

@@ -12,7 +12,6 @@ menu:
 weight: 20
 sections_weight: 20
 draft: false
-aliases: [/about/features]
 toc: true
 ---
 
@@ -53,12 +52,13 @@ toc: true
 * Integrated [Google Analytics][] support
 * Automatic [RSS][] creation
 * Support for [Go][], [Amber], and [Ace][] HTML templates
-* [Syntax highlighting][] powered by [Pygments][]
+* [Syntax highlighting][] powered by [Chroma][] (partly compatible with Pygments)
 
 
 [Ace]: /templates/alternatives/
 [aliases]: /content-management/urls/#aliases
 [Amber]: https://github.com/eknkc/amber
+[Chroma]: https://github.com/alecthomas/chroma
 [content summaries]: /content-management/summaries/
 [content types]: /content-management/types/
 [Disqus]: https://disqus.com/
@@ -77,7 +77,6 @@ toc: true
 [Permalink]: /content-management/urls/#permalinks
 [Powerful theming]: /themes/
 [Pretty URLs]: /content-management/urls/
-[Pygments]: http://pygments.org/
 [RSS]: /templates/rss/
 [Shortcodes]: /content-management/shortcodes/
 [sort content]: /templates/

docs/content/en/about/hugo-and-gdpr.md

@@ -28,6 +28,7 @@ toc: true
  Note that:
 
  * These settings have their defaults setting set to _off_, i.e. how it worked before Hugo `0.41`. You must do your own evaluation of your site and apply the appropriate settings.
+ * These settings work with the [internal templates](/templates/internal/). Some theme may contain custom templates for embedding services like Google Analytics. In that case these options have no effect.
  * We will continue this work and improve this further in future Hugo versions.
 
 ## All Privacy Settings

docs/content/en/about/new-in-032/index.md

@@ -24,7 +24,7 @@ This documentation belongs in other places in this documentation site, but is pu
 
 Also see this demo project from [bep](https://github.com/bep/), the clever Norwegian behind these new features:
 
-* http://hugotest.bep.is/
+* https://temp.bep.is/hugotest/
 * https://github.com/bep/hugotest (source)
 
 ## Page Resources
@@ -199,7 +199,7 @@ You can configure an `imaging` section in `config.toml` with default image proce
 # See https://github.com/disintegration/imaging
 resampleFilter = "box"
 
-# Defatult JPEG quality setting. Default is 75.
+# Default JPEG quality setting. Default is 75.
 quality = 68
 ```
 

docs/content/en/about/what-is-hugo.md

@@ -43,27 +43,23 @@ Hugo is for people building a blog, a company site, a portfolio site, documentat
 
 [@spf13]: https://twitter.com/@spf13
 [Aerobatic]: https://www.aerobatic.com/
-[Amazon S3]: http://aws.amazon.com/s3/
-[Azure]: https://blogs.msdn.microsoft.com/acoat/2016/01/28/publish-a-static-web-site-using-azure-web-apps/
-[CloudFront]: http://aws.amazon.com/cloudfront/ "Amazon CloudFront"
-[contributing to it]: https://github.com/gohugoio/hugo
-[DreamHost]: http://www.dreamhost.com/
+[Amazon S3]: https://aws.amazon.com/s3/
+[Azure]: https://docs.microsoft.com/en-us/azure/storage/blobs/storage-blob-static-website
+[CloudFront]: https://aws.amazon.com/cloudfront/ "Amazon CloudFront"
+[DreamHost]: https://www.dreamhost.com/
 [Firebase]: https://firebase.google.com/docs/hosting/ "Firebase static hosting"
 [GitHub Pages]: https://pages.github.com/
 [GitLab Pages]: https://about.gitlab.com/features/pages/
 [Go language]: https://golang.org/
 [GoDaddy]: https://www.godaddy.com/ "Godaddy.com Hosting"
-[Google Cloud Storage]: http://cloud.google.com/storage/
+[Google Cloud Storage]: https://cloud.google.com/storage/
 [Heroku]: https://www.heroku.com/
-[Jekyll]: http://jekyllrb.com/
 [Jekyll]: https://jekyllrb.com/
 [Middleman]: https://middlemanapp.com/
-[Middleman]: https://middlemanapp.com/
-[Nanoc]: http://nanoc.ws/
 [Nanoc]: https://nanoc.ws/
 [Netlify]: https://netlify.com
+[Rackspace]: https://www.rackspace.com/cloud/files
+[Surge]: https://surge.sh
+[contributing to it]: https://github.com/gohugoio/hugo
 [rackspace]: https://www.rackspace.com/cloud/files
 [static site generator]: /about/benefits/
-[Rackspace]: https://www.rackspace.com/cloud/files
-[static site generator]: /about/benefits/
-[Surge]: https://surge.sh

docs/content/en/commands/hugo.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo"
 slug: hugo
 url: /commands/hugo/
@@ -24,48 +24,46 @@ hugo [flags]
 ### Options
 
 ```
-  -b, --baseURL string             hostname (and path) to the root, e.g. http://spf13.com/
-  -D, --buildDrafts                include content marked as draft
-  -E, --buildExpired               include expired content
-  -F, --buildFuture                include content with publishdate in the future
-      --cacheDir string            filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/
-      --canonifyURLs               (deprecated) if true, all relative URLs will be canonicalized using baseURL
-      --cleanDestinationDir        remove files from destination not found in static directories
-      --config string              config file (default is path/config.yaml|json|toml)
-  -c, --contentDir string          filesystem path to content directory
-      --debug                      debug output
-  -d, --destination string         filesystem path to write files to
-      --disableKinds stringSlice   disable different kind of pages (home, RSS etc.)
-      --enableGitInfo              add Git revision, date and author info to the pages
-      --forceSyncStatic            copy all files when static is changed.
-      --gc                         enable to run some cleanup tasks (remove unused cache files) after the build
-  -h, --help                       help for hugo
-      --i18n-warnings              print missing translations
-      --ignoreCache                ignores the cache directory
-  -l, --layoutDir string           filesystem path to layout directory
-      --log                        enable Logging
-      --logFile string             log File path (if set, logging enabled automatically)
-      --noChmod                    don't sync permission mode of files
-      --noTimes                    don't sync modification time of files
-      --pluralizeListTitles        (deprecated) pluralize titles in lists using inflect (default true)
-      --preserveTaxonomyNames      (deprecated) preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")
-      --quiet                      build in quiet mode
-      --renderToMemory             render to memory (only useful for benchmark testing)
-  -s, --source string              filesystem path to read files relative from
-      --stepAnalysis               display memory and timing of different steps of the program
-      --templateMetrics            display metrics about template executions
-      --templateMetricsHints       calculate some improvement hints when combined with --templateMetrics
-  -t, --theme string               theme to use (located in /themes/THEMENAME/)
-      --themesDir string           filesystem path to themes directory
-      --uglyURLs                   (deprecated) if true, use /filename.html instead of /filename/
-  -v, --verbose                    verbose output
-      --verboseLog                 verbose logging
-  -w, --watch                      watch filesystem for changes and recreate as needed
+  -b, --baseURL string         hostname (and path) to the root, e.g. http://spf13.com/
+  -D, --buildDrafts            include content marked as draft
+  -E, --buildExpired           include expired content
+  -F, --buildFuture            include content with publishdate in the future
+      --cacheDir string        filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/
+      --cleanDestinationDir    remove files from destination not found in static directories
+      --config string          config file (default is path/config.yaml|json|toml)
+      --configDir string       config dir (default "config")
+  -c, --contentDir string      filesystem path to content directory
+      --debug                  debug output
+  -d, --destination string     filesystem path to write files to
+      --disableKinds strings   disable different kind of pages (home, RSS etc.)
+      --enableGitInfo          add Git revision, date and author info to the pages
+  -e, --environment string     build environment
+      --forceSyncStatic        copy all files when static is changed.
+      --gc                     enable to run some cleanup tasks (remove unused cache files) after the build
+  -h, --help                   help for hugo
+      --i18n-warnings          print missing translations
+      --ignoreCache            ignores the cache directory
+  -l, --layoutDir string       filesystem path to layout directory
+      --log                    enable Logging
+      --logFile string         log File path (if set, logging enabled automatically)
+      --minify                 minify any supported output format (HTML, XML etc.)
+      --noChmod                don't sync permission mode of files
+      --noTimes                don't sync modification time of files
+      --quiet                  build in quiet mode
+      --renderToMemory         render to memory (only useful for benchmark testing)
+  -s, --source string          filesystem path to read files relative from
+      --stepAnalysis           display memory and timing of different steps of the program
+      --templateMetrics        display metrics about template executions
+      --templateMetricsHints   calculate some improvement hints when combined with --templateMetrics
+  -t, --theme string           theme to use (located in /themes/THEMENAME/)
+      --themesDir string       filesystem path to themes directory
+  -v, --verbose                verbose output
+      --verboseLog             verbose logging
+  -w, --watch                  watch filesystem for changes and recreate as needed
 ```
 
 ### SEE ALSO
 
-* [hugo benchmark](/commands/hugo_benchmark/)	 - Benchmark Hugo by building a site a number of times.
 * [hugo check](/commands/hugo_check/)	 - Contains some verification checks
 * [hugo config](/commands/hugo_config/)	 - Print the site configuration
 * [hugo convert](/commands/hugo_convert/)	 - Convert your content to different formats
@@ -77,4 +75,4 @@ hugo [flags]
 * [hugo server](/commands/hugo_server/)	 - A high performance webserver
 * [hugo version](/commands/hugo_version/)	 - Print the version number of Hugo
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018

docs/content/en/commands/hugo_benchmark.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-12
 title: "hugo benchmark"
 slug: hugo_benchmark
 url: /commands/hugo_benchmark/
@@ -20,54 +20,53 @@ hugo benchmark [flags]
 ### Options
 
 ```
-  -b, --baseURL string             hostname (and path) to the root, e.g. http://spf13.com/
-  -D, --buildDrafts                include content marked as draft
-  -E, --buildExpired               include expired content
-  -F, --buildFuture                include content with publishdate in the future
-      --cacheDir string            filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/
-      --canonifyURLs               (deprecated) if true, all relative URLs will be canonicalized using baseURL
-      --cleanDestinationDir        remove files from destination not found in static directories
-  -c, --contentDir string          filesystem path to content directory
-  -n, --count int                  number of times to build the site (default 13)
-      --cpuprofile string          path/filename for the CPU profile file
-  -d, --destination string         filesystem path to write files to
-      --disableKinds stringSlice   disable different kind of pages (home, RSS etc.)
-      --enableGitInfo              add Git revision, date and author info to the pages
-      --forceSyncStatic            copy all files when static is changed.
-      --gc                         enable to run some cleanup tasks (remove unused cache files) after the build
-  -h, --help                       help for benchmark
-      --i18n-warnings              print missing translations
-      --ignoreCache                ignores the cache directory
-  -l, --layoutDir string           filesystem path to layout directory
-      --memprofile string          path/filename for the memory profile file
-      --noChmod                    don't sync permission mode of files
-      --noTimes                    don't sync modification time of files
-      --pluralizeListTitles        (deprecated) pluralize titles in lists using inflect (default true)
-      --preserveTaxonomyNames      (deprecated) preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")
-      --renderToMemory             render to memory (only useful for benchmark testing)
-  -s, --source string              filesystem path to read files relative from
-      --stepAnalysis               display memory and timing of different steps of the program
-      --templateMetrics            display metrics about template executions
-      --templateMetricsHints       calculate some improvement hints when combined with --templateMetrics
-  -t, --theme string               theme to use (located in /themes/THEMENAME/)
-      --themesDir string           filesystem path to themes directory
-      --uglyURLs                   (deprecated) if true, use /filename.html instead of /filename/
+  -b, --baseURL string         hostname (and path) to the root, e.g. http://spf13.com/
+  -D, --buildDrafts            include content marked as draft
+  -E, --buildExpired           include expired content
+  -F, --buildFuture            include content with publishdate in the future
+      --cacheDir string        filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/
+      --cleanDestinationDir    remove files from destination not found in static directories
+  -c, --contentDir string      filesystem path to content directory
+  -n, --count int              number of times to build the site (default 13)
+      --cpuprofile string      path/filename for the CPU profile file
+  -d, --destination string     filesystem path to write files to
+      --disableKinds strings   disable different kind of pages (home, RSS etc.)
+      --enableGitInfo          add Git revision, date and author info to the pages
+  -e, --environment string     build environment
+      --forceSyncStatic        copy all files when static is changed.
+      --gc                     enable to run some cleanup tasks (remove unused cache files) after the build
+  -h, --help                   help for benchmark
+      --i18n-warnings          print missing translations
+      --ignoreCache            ignores the cache directory
+  -l, --layoutDir string       filesystem path to layout directory
+      --memprofile string      path/filename for the memory profile file
+      --minify                 minify any supported output format (HTML, XML etc.)
+      --noChmod                don't sync permission mode of files
+      --noTimes                don't sync modification time of files
+      --renderToMemory         render to memory (only useful for benchmark testing)
+  -s, --source string          filesystem path to read files relative from
+      --stepAnalysis           display memory and timing of different steps of the program
+      --templateMetrics        display metrics about template executions
+      --templateMetricsHints   calculate some improvement hints when combined with --templateMetrics
+  -t, --theme string           theme to use (located in /themes/THEMENAME/)
+      --themesDir string       filesystem path to themes directory
 ```
 
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-      --quiet            build in quiet mode
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+      --quiet              build in quiet mode
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
 
 * [hugo](/commands/hugo/)	 - hugo builds your site
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 12-Dec-2018

docs/content/en/commands/hugo_check.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo check"
 slug: hugo_check
 url: /commands/hugo_check/
@@ -21,13 +21,14 @@ Contains some verification checks
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-      --quiet            build in quiet mode
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+      --quiet              build in quiet mode
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
@@ -35,4 +36,4 @@ Contains some verification checks
 * [hugo](/commands/hugo/)	 - hugo builds your site
 * [hugo check ulimit](/commands/hugo_check_ulimit/)	 - Check system ulimit settings
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018

docs/content/en/commands/hugo_check_ulimit.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo check ulimit"
 slug: hugo_check_ulimit
 url: /commands/hugo_check_ulimit/
@@ -26,17 +26,18 @@ hugo check ulimit [flags]
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-      --quiet            build in quiet mode
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+      --quiet              build in quiet mode
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
 
 * [hugo check](/commands/hugo_check/)	 - Contains some verification checks
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018

docs/content/en/commands/hugo_config.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo config"
 slug: hugo_config
 url: /commands/hugo_config/
@@ -26,17 +26,18 @@ hugo config [flags]
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-      --quiet            build in quiet mode
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+      --quiet              build in quiet mode
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
 
 * [hugo](/commands/hugo/)	 - hugo builds your site
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018

docs/content/en/commands/hugo_convert.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo convert"
 slug: hugo_convert
 url: /commands/hugo_convert/
@@ -26,13 +26,14 @@ See convert's subcommands toJSON, toTOML and toYAML for more information.
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-      --quiet            build in quiet mode
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+      --quiet              build in quiet mode
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
@@ -42,4 +43,4 @@ See convert's subcommands toJSON, toTOML and toYAML for more information.
 * [hugo convert toTOML](/commands/hugo_convert_totoml/)	 - Convert front matter to TOML
 * [hugo convert toYAML](/commands/hugo_convert_toyaml/)	 - Convert front matter to YAML
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018

docs/content/en/commands/hugo_convert_toJSON.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo convert toJSON"
 slug: hugo_convert_toJSON
 url: /commands/hugo_convert_tojson/
@@ -26,20 +26,21 @@ hugo convert toJSON [flags]
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-  -o, --output string    filesystem path to write files to
-      --quiet            build in quiet mode
-  -s, --source string    filesystem path to read files relative from
-      --unsafe           enable less safe operations, please backup first
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+  -o, --output string      filesystem path to write files to
+      --quiet              build in quiet mode
+  -s, --source string      filesystem path to read files relative from
+      --unsafe             enable less safe operations, please backup first
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
 
 * [hugo convert](/commands/hugo_convert/)	 - Convert your content to different formats
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018

docs/content/en/commands/hugo_convert_toTOML.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo convert toTOML"
 slug: hugo_convert_toTOML
 url: /commands/hugo_convert_totoml/
@@ -26,20 +26,21 @@ hugo convert toTOML [flags]
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-  -o, --output string    filesystem path to write files to
-      --quiet            build in quiet mode
-  -s, --source string    filesystem path to read files relative from
-      --unsafe           enable less safe operations, please backup first
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+  -o, --output string      filesystem path to write files to
+      --quiet              build in quiet mode
+  -s, --source string      filesystem path to read files relative from
+      --unsafe             enable less safe operations, please backup first
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
 
 * [hugo convert](/commands/hugo_convert/)	 - Convert your content to different formats
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018

docs/content/en/commands/hugo_convert_toYAML.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo convert toYAML"
 slug: hugo_convert_toYAML
 url: /commands/hugo_convert_toyaml/
@@ -26,20 +26,21 @@ hugo convert toYAML [flags]
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-  -o, --output string    filesystem path to write files to
-      --quiet            build in quiet mode
-  -s, --source string    filesystem path to read files relative from
-      --unsafe           enable less safe operations, please backup first
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+  -o, --output string      filesystem path to write files to
+      --quiet              build in quiet mode
+  -s, --source string      filesystem path to read files relative from
+      --unsafe             enable less safe operations, please backup first
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
 
 * [hugo convert](/commands/hugo_convert/)	 - Convert your content to different formats
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018

docs/content/en/commands/hugo_env.md

@@ -1,5 +1,5 @@
 ---
-date: 2018-04-16
+date: 2018-12-23
 title: "hugo env"
 slug: hugo_env
 url: /commands/hugo_env/
@@ -25,17 +25,18 @@ hugo env [flags]
 ### Options inherited from parent commands
 
 ```
-      --config string    config file (default is path/config.yaml|json|toml)
-      --debug            debug output
-      --log              enable Logging
-      --logFile string   log File path (if set, logging enabled automatically)
-      --quiet            build in quiet mode
-  -v, --verbose          verbose output
-      --verboseLog       verbose logging
+      --config string      config file (default is path/config.yaml|json|toml)
+      --configDir string   config dir (default "config")
+      --debug              debug output
+      --log                enable Logging
+      --logFile string     log File path (if set, logging enabled automatically)
+      --quiet              build in quiet mode
+  -v, --verbose            verbose output
+      --verboseLog         verbose logging
 ```
 
 ### SEE ALSO
 
 * [hugo](/commands/hugo/)	 - hugo builds your site
 
-###### Auto generated by spf13/cobra on 16-Apr-2018
+###### Auto generated by spf13/cobra on 23-Dec-2018