releaser: Bump versions for release of 0.102.2

[ci skip]

.circleci/config.yml

@@ -1,52 +1,114 @@
-defaults: &defaults
-  docker:
-      - image: bepsays/ci-goreleaser:1.16.0-2
-  environment:
-    CGO_ENABLED: "0"
+parameters:
 
+# v2: 11m.
+defaults: &defaults
+  resource_class: large
+  docker:
+      - image: bepsays/ci-hugoreleaser:1.21900.20001
+environment: &buildenv
+      GOMODCACHE: /root/project/gomodcache
 version: 2
 jobs:
-  build:
-    <<: *defaults
+  prepare_release:
+    <<: *defaults 
+    environment: &buildenv
+        GOMODCACHE: /root/project/gomodcache
     steps:
-      - checkout:
+      - &remote-docker
+        setup_remote_docker: 
+          version: 20.10.14
+      - checkout: 
           path: hugo
+      - &git-config
+        run:
+           command: |
+            git config --global user.email "bjorn.erik.pedersen+hugoreleaser@gmail.com"
+            git config --global user.name "hugoreleaser"
       - run:
-            command: |
-                git clone git@github.com:gohugoio/hugoDocs.git
-                cd hugo
-                go mod download
-                sleep 5
-                go mod verify
-                go test -p 1 ./...
-      - persist_to_workspace:
-          root: .
-          paths: .
-  release:
-    <<: *defaults
+          command: |
+            cd hugo
+            go mod download
+            go run -tags release main.go release --step 1
+      - save_cache:
+          key: git-sha-{{ .Revision }}
+          paths:
+            - hugo
+            - gomodcache
+  build_container1:
+    <<: [*defaults]
+    environment:
+      <<: [*buildenv]
     steps:
-      - attach_workspace:
-          at: /root/project
+      - &restore-cache
+        restore_cache:
+          key: git-sha-{{ .Revision }}
       - run:
-            command: |
-                    cd hugo
-                    git config --global user.email "bjorn.erik.pedersen+hugoreleaser@gmail.com"
-                    git config --global user.name "hugoreleaser"
-                    go run -tags release main.go release -r ${CIRCLE_BRANCH}
-
+          no_output_timeout: 20m
+          command: |
+            mkdir -p /tmp/files/dist1
+            cd hugo
+            hugoreleaser build -paths "builds/container1/**" -workers 3 -dist /tmp/files/dist1 -chunks $CIRCLE_NODE_TOTAL -chunk-index $CIRCLE_NODE_INDEX
+      - &persist-workspace
+        persist_to_workspace:
+          root: /tmp/files
+          paths:
+            - dist1
+            - dist2
+    parallelism: 7
+  build_container2:
+    <<: [*defaults]
+    environment:
+        <<: [*buildenv]
+    docker:
+    - image: bepsays/ci-hugoreleaser-linux-arm64:1.21900.20001
+    steps:
+      - *restore-cache
+      - &attach-workspace
+        attach_workspace:
+          at: /tmp/workspace
+      - run:
+          command: |
+                  mkdir -p /tmp/files/dist2
+                  cd hugo
+                  hugoreleaser build -paths "builds/container2/**" -workers 1 -dist /tmp/files/dist2
+      - *persist-workspace
+  archive_and_release:
+    <<: [*defaults]
+    environment:
+        <<: [*buildenv]
+    steps:
+      - *restore-cache
+      - *attach-workspace
+      - *git-config
+      - run:
+          command: |
+            cp -a /tmp/workspace/dist1/. ./hugo/dist
+            cp -a /tmp/workspace/dist2/. ./hugo/dist
+      - run:
+          command: |
+            cd hugo
+            hugoreleaser archive
+            hugoreleaser release
+            go run -tags release main.go release --step 2
 workflows:
   version: 2
   release:
       jobs:  
-        - build:
+        - prepare_release:
             filters:
               branches:
                 only: /release-.*/
-        - hold:
-            type: approval
+        - build_container1:
             requires:
-              - build
-        - release:
+            - prepare_release
+        - build_container2:
+            requires:
+            - prepare_release
+        - archive_and_release:
             context: org-global
             requires:
-              - hold
+            - build_container1
+            - build_container2
+     
+  
+       

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,6 +1,6 @@
 ---
 name: 'Bug report'
-labels: 'bug'
+labels: 'Bug, NeedsTriage'
 assignees: ''
 about: Create a report to help us improve
 ---

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,8 +1,11 @@
 ---
 name: Proposal
-about: Suggest an idea for Hugo
+about: Propose a new feature for Hugo
 title: ''
-labels: 'Proposal'
+labels: 'Proposal, NeedsTriage'
 assignees: ''
 
 ---
+
+
+<!-- Describe this new feature. Think about if it really belongs in the Hugo core module; you may want to discuss it on https://discourse.gohugo.io/ first.  -->

.github/stale.yml

@@ -1,23 +0,0 @@
-# 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 this is a **bug** and you can still reproduce this error on the <code>master</code> branch, please reply with all of the information you have about it in order to keep the issue open.
-
-  If this is a **feature request**, and you feel that it is still relevant and valuable, 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

.github/workflows/stale.yml

@@ -0,0 +1,47 @@
+name: 'Close stale and lock closed issues and PRs'
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '30 1 * * *'
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@08e671be8ac8944d0e132aa71d0ae8ccfb347675
+        with:
+          issue-inactive-days: 21
+          add-issue-labels: 'Outdated'
+          issue-comment: >
+            This issue has been automatically locked since there
+            has not been any recent activity after it was closed.
+            Please open a new issue for related bugs.
+          pr-comment: >
+            This pull request has been automatically locked since there
+            has not been any recent activity after it was closed.
+            Please open a new issue for related bugs.
+      - uses: actions/stale@04a1828bc18ada028d85a0252a47cd2963a91abe
+        with:
+          operations-per-run: 999
+          days-before-issue-stale: 365
+          days-before-pr-stale: 365
+          days-before-issue-close: 56
+          days-before-pr-close: 56
+          stale-issue-message: >
+            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 this is a **bug** and you can still reproduce this error on the <code>master</code> branch, please reply with all of the information you have about it in order to keep the issue open.
+
+            If this is a **feature request**, and you feel that it is still relevant and valuable, 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.
+          stale-pr-message: This PR 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.
+
+            Please check https://github.com/gohugoio/hugo/blob/master/CONTRIBUTING.md#code-contribution and verify that this code contribution fits with the description. If yes, tell is in a comment.
+
+            This PR will automatically be closed in the near future if no further activity occurs. Thank you for all your contributions.
+          stale-issue-label: 'Stale'
+          exempt-issue-labels: 'Keep,Security'
+          stale-pr-label: 'Stale'
+          exempt-pr-labels: 'Keep,Security'

.github/workflows/test.yml

@@ -1,5 +1,7 @@
 on: [push, pull_request]
 name: Test
+permissions:
+  contents: read
 jobs:
   test:
     env:
@@ -7,7 +9,11 @@ jobs:
       GO111MODULE: on
     strategy:
       matrix:
-        go-version: [1.16.x]
+        # Note: We upgraded to Go 1.18 in Hugo v0.95.0
+        # Go 1.18 had some breaking changes on the source level which means Hugo cannot be built
+        # with older Go versions, but the improvements in Go 1.18 were too good to pass on (e.g. break and continue).
+        # Note that you don't need Go (or Go 1.18) to run a pre-built binary.
+        go-version: [1.18.x,1.19.x]
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
@@ -24,7 +30,7 @@ jobs:
       with:
         python-version: '3.x'
     - name: Install Mage
-      run: go get github.com/magefile/mage@07afc7d24f4d6d6442305d49552f04fbda5ccb3e
+      run: go install github.com/magefile/mage@07afc7d24f4d6d6442305d49552f04fbda5ccb3e
     - name: Install asciidoctor
       uses: reitzig/actions-asciidoctor@7570212ae20b63653481675fb1ff62d1073632b0
     - name: Checkout code
@@ -43,8 +49,11 @@ jobs:
         brew install pandoc
     - if: matrix.os == 'windows-latest'
       run: |
-        choco install pandoc
+        Choco-Install -PackageName pandoc
     - run: pandoc -v
+    - if: matrix.os == 'windows-latest'
+      run: |
+        Choco-Install -PackageName mingw -ArgumentList "--version","10.2.0","--allow-downgrade"
     - if: matrix.os == 'ubuntu-latest'
       name: Install dart-sass-embedded Linux
       run: |
@@ -66,15 +75,17 @@ jobs:
         echo "6ae442129dbb3334bc21ef851261da6c0c1b560da790ca2e1350871d00ab816d  sass_embedded-1.0.0-beta.6-windows-x64.zip" | sha256sum -c;
         unzip sass_embedded-1.0.0-beta.6-windows-x64.zip;
         echo  "$env:GITHUB_WORKSPACE/sass_embedded/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
-    - name: Test
+    - name: Check
       run: |
-        mage -v test
         mage -v check;
+      env:
+        HUGO_BUILD_TAGS: extended
     - name: Build Docs
       env:
         HUGO_BUILD_TAGS: extended
         HUGO_TIMEOUT: 31000
         HUGO_IGNOREERRORS: error-remote-getjson
+        HUGO_SERVICES_INSTAGRAM_ACCESSTOKEN: dummytoken
       run: |
         mage -v hugo
         ./hugo -s docs/

.gitignore

@@ -1,6 +1,7 @@
 /hugo
 docs/public*
 /.idea
+.vscode/*
 hugo.exe
 *.test
 *.prof
@@ -25,3 +26,4 @@ resources/sunset.jpg
 
 vendor
 
+.hugo_build.lock

CONTRIBUTING.md

@@ -1,5 +1,7 @@
 # Contributing to Hugo
 
+**Note  March 16th 2022:** We are currently very constrained on human resources to do code reviews, so we currently require any new Pull Requests to be limited to bug fixes closing an existing issue. Also, we have updated to Go 1.18, but we will currently not accept any generic rewrites, "interface{} to any" replacements and similar.
+
 We welcome contributions to Hugo of any kind including documentation, themes,
 organization, tutorials, blog posts, bug reports, issues, feature requests,
 feature implementations, pull requests, answering questions on the forum,
@@ -81,19 +83,22 @@ To make the contribution process as seamless as possible, we ask for the followi
 
 ### Git Commit Message Guidelines
 
-This [blog article](http://chris.beams.io/posts/git-commit/) is a good resource for learning how to write good commit messages,
+This [blog article](https://cbea.ms/git-commit/) is a good resource for learning how to write good commit messages,
 the most important part being that each commit message should have a title/subject in imperative mood starting with a capital letter and no trailing period:
-*"Return error on wrong use of the Paginator"*, **NOT** *"returning some error."*
+*"js: Return error when option x is not set"*, **NOT** *"returning some error."*
+
+Most title/subjects should have a lower-cased prefix with a colon and one whitespace. The prefix can be:
+
+* The name of the package where (most of) the changes are made (e.g. `media: Add text/calendar`)
+* If the package name is deeply nested/long, try to shorten it from the left side, e.g. `markup/goldmark` is OK, `resources/resource_transformers/js` can be shortened to `js`.
+* If this commit touches several packages with a common functional topic, use that as a prefix, e.g. `errors: Resolve correct line numbers`)
+* If this commit touches many packages without a common functional topic, prefix with `all:` (e.g. `all: Reformat Go code`)
+* If this is a documentation update, prefix with `docs:`.
+* If nothing of the above applies, just leave the prefix out.
 
 Also, if your commit references one or more GitHub issues, always end your commit message body with *See #1234* or *Fixes #1234*.
 Replace *1234* with the GitHub issue ID. The last example will close the issue when the commit is merged into *master*.
 
-Sometimes it makes sense to prefix the commit message with the package name (or docs folder) all lowercased ending with a colon.
-That is fine, but the rest of the rules above apply.
-So it is "tpl: Add emojify template func", not "tpl: add emojify template func.", and "docs: Document emoji", not "doc: document emoji."
-
-Please use a short and descriptive branch name, e.g. **NOT** "patch-1". It's very common but creates a naming conflict each time when a submission is pulled for a review.
-
 An example:
 
 ```text
@@ -124,7 +129,7 @@ go install
 For some convenient build and test targets, you also will want to install Mage:
 
 ```bash
-go get github.com/magefile/mage
+go install github.com/magefile/mage
 ```
 
 Now, to make a change to Hugo's source:

Dockerfile

@@ -2,7 +2,7 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/
 
-FROM golang:1.16-alpine AS build
+FROM golang:1.18-alpine AS build
 
 # Optionally set HUGO_BUILD_TAGS to "extended" or "nodeploy" when building like so:
 #   docker build --build-arg HUGO_BUILD_TAGS=extended .
@@ -19,8 +19,8 @@ COPY . /go/src/github.com/gohugoio/hugo/
 
 # gcc/g++ are required to build SASS libraries for extended version
 RUN apk update && \
-    apk add --no-cache gcc g++ musl-dev && \
-    go get github.com/magefile/mage
+    apk add --no-cache gcc g++ musl-dev git && \
+    go install github.com/magefile/mage
 
 RUN mage hugo && mage install
 

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2022 The Hugo Authors.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -1,6 +1,6 @@
-<img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/static/images/hugo-logo-wide.svg?sanitize=true" alt="Hugo" width="565">
+<a href="https://gohugo.io/"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/static/images/hugo-logo-wide.svg?sanitize=true" alt="Hugo" width="565"></a>
 
-A Fast and Flexible Static Site Generator built with love by [bep](https://github.com/bep), [spf13](http://spf13.com/) and [friends](https://github.com/gohugoio/hugo/graphs/contributors) in [Go][].
+A Fast and Flexible Static Site Generator built with love by [bep](https://github.com/bep), [spf13](https://spf13.com/) and [friends](https://github.com/gohugoio/hugo/graphs/contributors) in [Go](https://go.dev/).
 
 [Website](https://gohugo.io) |
 [Forum](https://discourse.gohugo.io) |
@@ -13,9 +13,18 @@ A Fast and Flexible Static Site Generator built with love by [bep](https://githu
 [![Tests on Linux, MacOS and Windows](https://github.com/gohugoio/hugo/workflows/Test/badge.svg)](https://github.com/gohugoio/hugo/actions?query=workflow%3ATest)
 [![Go Report Card](https://goreportcard.com/badge/github.com/gohugoio/hugo)](https://goreportcard.com/report/github.com/gohugoio/hugo)
 
+* [Overview](#overview)
+* [Supported Architectures](#supported-architectures)
+* [Choose How to Install](#choose-how-to-install)
+   * [Install Hugo as Your Site Generator (Binary Install)](#install-hugo-as-your-site-generator-binary-install)
+   * [Build and Install the Binaries from Source (Advanced Install)](#build-and-install-the-binaries-from-source-advanced-install)
+* [The Hugo Documentation](#the-hugo-documentation)
+* [Contributing to Hugo](#contributing-code-to-hugo)
+* [Dependencies](#dependencies)
+
 ## Overview
 
-Hugo is a static HTML and CSS website generator written in [Go][].
+Hugo is a static HTML and CSS website generator written in [Go](https://go.dev/).
 It is optimized for speed, ease of use, and configurability.
 Hugo takes a directory with content and templates and renders them into a full HTML website.
 
@@ -27,9 +36,9 @@ A good rule of thumb is that each piece of content renders in around 1 milliseco
 
 Hugo is designed to work well for any kind of website including blogs, tumbles, and docs.
 
-#### Supported Architectures
+## Supported Architectures
 
-Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBSD, DragonFly BSD, Open BSD, macOS (Darwin), and [Android](https://gist.github.com/bep/a0d8a26cf6b4f8bc992729b8e50b480b) for x64, i386 and ARM architectures.
+Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBSD, DragonFly BSD, OpenBSD, macOS (Darwin), and [Android](https://gist.github.com/bep/a0d8a26cf6b4f8bc992729b8e50b480b) for x64, i386 and ARM architectures.
 
 Hugo may also be compiled from source wherever the Go compiler tool chain can run, e.g. for other operating systems including Plan 9 and Solaris.
 
@@ -38,7 +47,6 @@ Hugo may also be compiled from source wherever the Go compiler tool chain can ru
 ## Choose How to Install
 
 If you want to use Hugo as your site generator, simply install the Hugo binaries.
-The Hugo binaries have no external dependencies.
 
 To contribute to the Hugo source code or documentation, you should [fork the Hugo GitHub project](https://github.com/gohugoio/hugo#fork-destination-box) and clone it to your local machine.
 
@@ -54,11 +62,11 @@ Use the [installation instructions in the Hugo documentation](https://gohugo.io/
 #### Prerequisite Tools
 
 * [Git](https://git-scm.com/)
-* [Go (we test it with the last 2 major versions; but note that Hugo 0.81.0 only builds with >= Go 1.16.)](https://golang.org/dl/)
+* [Go (we test it with the last 2 major versions; but note that Hugo 0.95.0 only builds with >= Go 1.18.)](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:
+To fetch and build the source from GitHub:
 
 ```bash
 mkdir $HOME/src
@@ -83,7 +91,9 @@ The Hugo documentation now lives in its own repository, see https://github.com/g
 ```bash
 git clone git@github.com:gohugoio/hugo.git
 ```
-## Contributing to Hugo
+## Contributing code to Hugo
+
+**Note  March 16th 2022:** We are currently very constrained on human resources to do code reviews, so we currently require any new Pull Requests to be limited to bug fixes closing an existing issue. Also, we have updated to Go 1.18, but we will currently not accept any generic rewrites, "interface{} to any" replacements and similar.
 
 For a complete guide to contributing to Hugo, see the [Contribution Guide](CONTRIBUTING.md).
 
@@ -94,103 +104,137 @@ helping to manage issues, etc.
 
 The Hugo community and maintainers are [very active](https://github.com/gohugoio/hugo/pulse/monthly) and helpful, and the project benefits greatly from this activity.
 
-### Asking Support Questions
+## Asking Support Questions
 
 We have an active [discussion forum](https://discourse.gohugo.io) where users and developers can ask questions.
 Please don't use the GitHub issue tracker to ask questions.
 
-### Reporting Issues
+## Reporting Issues
 
 If you believe you have found a defect in Hugo or its documentation, use
 the GitHub issue tracker to report the problem to the Hugo maintainers.
 If you're not sure if it's a bug or not, start by asking in the [discussion forum](https://discourse.gohugo.io).
 When reporting the issue, please provide the version of Hugo in use (`hugo version`).
 
-### Submitting Patches
-
-The Hugo project welcomes all contributors and contributions regardless of skill or experience level.
-If you are interested in helping with the project, we will help you with your contribution.
-Hugo is a very active project with many contributions happening daily.
-
-We want to create the best possible product for our users and the best contribution experience for our developers,
-we have a set of guidelines which ensure that all contributions are acceptable.
-The guidelines are not intended as a filter or barrier to participation.
-If you are unfamiliar with the contribution process, the Hugo team will help you and teach you how to bring your contribution in accordance with the guidelines.
-
-For a complete guide to contributing code to Hugo, see the [Contribution Guide](CONTRIBUTING.md).
-
-[![Analytics](https://ga-beacon.appspot.com/UA-7131036-6/hugo/readme)](https://github.com/igrigorik/ga-beacon)
-
-[Go]: https://golang.org/
-[Hugo Documentation]: https://gohugo.io/overview/introduction/
-
 ## Dependencies
 
-Hugo stands on the shoulder of many great open source libraries, in lexical order:
+Hugo stands on the shoulder of many great open source libraries.
+
+If you run `hugo env -v` you will get a complete and up to date list.
+
+In Hugo 0.100.1 that list is, in lexical order:
+
+```
+cloud.google.com/go/compute="v1.6.1"
+cloud.google.com/go/iam="v0.3.0"
+cloud.google.com/go/storage="v1.22.0"
+cloud.google.com/go="v0.101.0"
+github.com/Azure/azure-pipeline-go="v0.2.3"
+github.com/Azure/azure-storage-blob-go="v0.14.0"
+github.com/Azure/go-autorest/autorest/adal="v0.9.15"
+github.com/Azure/go-autorest/autorest/date="v0.3.0"
+github.com/Azure/go-autorest/autorest="v0.11.20"
+github.com/Azure/go-autorest/logger="v0.2.1"
+github.com/Azure/go-autorest/tracing="v0.6.0"
+github.com/BurntSushi/locker="v0.0.0-20171006230638-a6e239ea1c69"
+github.com/PuerkitoBio/purell="v1.1.1"
+github.com/PuerkitoBio/urlesc="v0.0.0-20170810143723-de5bf2ad4578"
+github.com/alecthomas/chroma="v0.10.0"
+github.com/armon/go-radix="v1.0.0"
+github.com/aws/aws-sdk-go-v2/config="v1.7.0"
+github.com/aws/aws-sdk-go-v2/credentials="v1.4.0"
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds="v1.5.0"
+github.com/aws/aws-sdk-go-v2/internal/ini="v1.2.2"
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url="v1.3.0"
+github.com/aws/aws-sdk-go-v2/service/sso="v1.4.0"
+github.com/aws/aws-sdk-go-v2/service/sts="v1.7.0"
+github.com/aws/aws-sdk-go-v2="v1.9.0"
+github.com/aws/aws-sdk-go="v1.43.5"
+github.com/aws/smithy-go="v1.8.0"
+github.com/bep/clock="v0.3.0"
+github.com/bep/debounce="v1.2.0"
+github.com/bep/gitmap="v1.1.2"
+github.com/bep/goat="v0.5.0"
+github.com/bep/godartsass="v0.14.0"
+github.com/bep/golibsass="v1.1.0"
+github.com/bep/gowebp="v0.1.0"
+github.com/bep/overlayfs="v0.6.0"
+github.com/bep/tmc="v0.5.1"
+github.com/clbanning/mxj/v2="v2.5.5"
+github.com/cli/safeexec="v1.0.0"
+github.com/cpuguy83/go-md2man/v2="v2.0.1"
+github.com/disintegration/gift="v1.2.1"
+github.com/dlclark/regexp2="v1.4.0"
+github.com/dustin/go-humanize="v1.0.0"
+github.com/evanw/esbuild="v0.14.42"
+github.com/frankban/quicktest="v1.14.3"
+github.com/fsnotify/fsnotify="v1.5.4"
+github.com/getkin/kin-openapi="v0.94.0"
+github.com/ghodss/yaml="v1.0.0"
+github.com/go-openapi/jsonpointer="v0.19.5"
+github.com/go-openapi/swag="v0.19.5"
+github.com/gobuffalo/flect="v0.2.5"
+github.com/gobwas/glob="v0.2.3"
+github.com/gohugoio/go-i18n/v2="v2.1.3-0.20210430103248-4c28c89f8013"
+github.com/gohugoio/locales="v0.14.0"
+github.com/gohugoio/localescompressed="v1.0.1"
+github.com/golang-jwt/jwt/v4="v4.0.0"
+github.com/golang/groupcache="v0.0.0-20210331224755-41bb18bfe9da"
+github.com/golang/protobuf="v1.5.2"
+github.com/google/go-cmp="v0.5.8"
+github.com/google/uuid="v1.3.0"
+github.com/google/wire="v0.5.0"
+github.com/googleapis/gax-go/v2="v2.3.0"
+github.com/googleapis/go-type-adapters="v1.0.0"
+github.com/gorilla/websocket="v1.5.0"
+github.com/hairyhenderson/go-codeowners="v0.2.3-0.20201026200250-cdc7c0759690"
+github.com/inconshreveable/mousetrap="v1.0.0"
+github.com/jdkato/prose="v1.2.1"
+github.com/jmespath/go-jmespath="v0.4.0"
+github.com/kr/pretty="v0.3.0"
+github.com/kr/text="v0.2.0"
+github.com/kyokomi/emoji/v2="v2.2.9"
+github.com/mailru/easyjson="v0.0.0-20190626092158-b2ccc519800e"
+github.com/mattn/go-ieproxy="v0.0.1"
+github.com/mattn/go-isatty="v0.0.14"
+github.com/mattn/go-runewidth="v0.0.9"
+github.com/mitchellh/hashstructure="v1.1.0"
+github.com/mitchellh/mapstructure="v1.5.0"
+github.com/muesli/smartcrop="v0.3.0"
+github.com/niklasfasching/go-org="v1.6.2"
+github.com/olekukonko/tablewriter="v0.0.5"
+github.com/pelletier/go-toml/v2="v2.0.0-beta.7.0.20220408132554-2377ac4bc04c"
+github.com/rogpeppe/go-internal="v1.8.1"
+github.com/russross/blackfriday/v2="v2.1.0"
+github.com/rwcarlsen/goexif="v0.0.0-20190401172101-9e8deecbddbd"
+github.com/sanity-io/litter="v1.5.5"
+github.com/sass/libsass="3.6.5"
+github.com/spf13/afero="v1.8.2"
+github.com/spf13/cast="v1.5.0"
+github.com/spf13/cobra="v1.4.0"
+github.com/spf13/fsync="v0.9.0"
+github.com/spf13/jwalterweatherman="v1.1.0"
+github.com/spf13/pflag="v1.0.5"
+github.com/tdewolff/minify/v2="v2.11.5"
+github.com/tdewolff/parse/v2="v2.5.31"
+github.com/webmproject/libwebp="v1.2.0"
+github.com/yuin/goldmark="v1.4.12"
+go.opencensus.io="v0.23.0"
+go.uber.org/atomic="v1.9.0"
+gocloud.dev="v0.24.0"
+golang.org/x/crypto="v0.0.0-20211108221036-ceb1ce70b4fa"
+golang.org/x/image="v0.0.0-20211028202545-6944b10bf410"
+golang.org/x/net="v0.0.0-20220425223048-2871e0cb64e4"
+golang.org/x/oauth2="v0.0.0-20220411215720-9780585627b5"
+golang.org/x/sync="v0.0.0-20210220032951-036812b2e83c"
+golang.org/x/sys="v0.0.0-20220422013727-9388b58f7150"
+golang.org/x/text="v0.3.7"
+golang.org/x/tools="v0.1.10"
+golang.org/x/xerrors="v0.0.0-20220411194840-2f41105eb62f"
+google.golang.org/api="v0.76.0"
+google.golang.org/genproto="v0.0.0-20220426171045-31bebdecfb46"
+google.golang.org/grpc="v1.46.0"
+google.golang.org/protobuf="v1.28.0"
+gopkg.in/yaml.v2="v2.4.0"
+```
 
- | Dependency  | License |
- | :------------- | :------------- |
- | [github.com/alecthomas/chroma](https://github.com/alecthomas/chroma) | MIT License |
- | [github.com/armon/go-radix](https://github.com/armon/go-radix) | MIT License |
- | [github.com/aws/aws-sdk-go](https://github.com/aws/aws-sdk-go) | Apache License 2.0 |
- | [github.com/bep/debounce](https://github.com/bep/debounce) | MIT License |
- | [github.com/bep/gitmap](https://github.com/bep/gitmap) | MIT License |
- | [github.com/bep/golibsass](https://github.com/bep/golibsass) | MIT License |
- | [github.com/bep/tmc](https://github.com/bep/tmc) | MIT License |
- | [github.com/BurntSushi/locker](https://github.com/BurntSushi/locker) | The Unlicense |
- | [github.com/BurntSushi/toml](https://github.com/BurntSushi/toml) | MIT License |
- | [github.com/cpuguy83/go-md2man](https://github.com/cpuguy83/go-md2man) | MIT License |
- | [github.com/danwakefield/fnmatch](https://github.com/danwakefield/fnmatch) | BSD 2-Clause "Simplified" License |
- | [github.com/disintegration/gift](https://github.com/disintegration/gift) | MIT License |
- | [github.com/dustin/go-humanize](https://github.com/dustin/go-humanize) | MIT License |
- | [github.com/fsnotify/fsnotify](https://github.com/fsnotify/fsnotify) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/gobwas/glob](https://github.com/gobwas/glob) | MIT License |
- | [github.com/gorilla/websocket](https://github.com/gorilla/websocket) | BSD 2-Clause "Simplified" License |
- | [github.com/hashicorp/golang-lru](https://github.com/hashicorp/golang-lru) | Mozilla Public License 2.0 |
- | [github.com/hashicorp/hcl](https://github.com/hashicorp/hcl) | Mozilla Public License 2.0 |
- | [github.com/jdkato/prose](https://github.com/jdkato/prose) | MIT License |
- | [github.com/kr/pretty](https://github.com/kr/pretty) | MIT License |
- | [github.com/kyokomi/emoji](https://github.com/kyokomi/emoji) | MIT License |
- | [github.com/magiconair/properties](https://github.com/magiconair/properties) | BSD 2-Clause "Simplified" License |
- | [github.com/markbates/inflect](https://github.com/markbates/inflect) | MIT License |
- | [github.com/mattn/go-isatty](https://github.com/mattn/go-isatty) | MIT License |
- | [github.com/mattn/go-runewidth](https://github.com/mattn/go-runewidth) | MIT License |
- | [github.com/miekg/mmark](https://github.com/miekg/mmark) | Simplified BSD License |
- | [github.com/mitchellh/hashstructure](https://github.com/mitchellh/hashstructure) | MIT License |
- | [github.com/mitchellh/mapstructure](https://github.com/mitchellh/mapstructure) | MIT License |
- | [github.com/muesli/smartcrop](https://github.com/muesli/smartcrop) | MIT License |
- | [github.com/nicksnyder/go-i18n](https://github.com/nicksnyder/go-i18n) | MIT License |
- | [github.com/niklasfasching/go-org](https://github.com/niklasfasching/go-org) | MIT License |
- | [github.com/olekukonko/tablewriter](https://github.com/olekukonko/tablewriter) | MIT License |
- | [github.com/pelletier/go-toml](https://github.com/pelletier/go-toml) | MIT License |
- | [github.com/pkg/errors](https://github.com/pkg/errors) | BSD 2-Clause "Simplified" License |
- | [github.com/PuerkitoBio/purell](https://github.com/PuerkitoBio/purell) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/PuerkitoBio/urlesc](https://github.com/PuerkitoBio/urlesc) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/rogpeppe/go-internal](https://github.com/rogpeppe/go-internal) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/russross/blackfriday](https://github.com/russross/blackfriday)  | Simplified BSD License |
- | [github.com/rwcarlsen/goexif](https://github.com/rwcarlsen/goexif) | BSD 2-Clause "Simplified" License |
- | [github.com/spf13/afero](https://github.com/spf13/afero) | Apache License 2.0 |
- | [github.com/spf13/cast](https://github.com/spf13/cast) | MIT License |
- | [github.com/spf13/cobra](https://github.com/spf13/cobra) | Apache License 2.0 |
- | [github.com/spf13/fsync](https://github.com/spf13/fsync) | MIT License |
- | [github.com/spf13/jwalterweatherman](https://github.com/spf13/jwalterweatherman) | MIT License |
- | [github.com/spf13/pflag](https://github.com/spf13/pflag) | BSD 3-Clause "New" or "Revised" License |
- | [github.com/spf13/viper](https://github.com/spf13/viper) | MIT License |
- | [github.com/tdewolff/minify](https://github.com/tdewolff/minify) | MIT License |
- | [github.com/tdewolff/parse](https://github.com/tdewolff/parse) | MIT License |
- | [github.com/yuin/goldmark](https://github.com/yuin/goldmark) | MIT License |
- | [github.com/yuin/goldmark-highlighting](https://github.com/yuin/goldmark-highlighting) | MIT License |
- | [go.opencensus.io](https://go.opencensus.io) | Apache License 2.0 |
- | [go.uber.org/atomic](https://go.uber.org/atomic) | MIT License |
- | [gocloud.dev](https://gocloud.dev) | Apache License 2.0 |
- | [golang.org/x/image](https://golang.org/x/image) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/net](https://golang.org/x/net) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/oauth2](https://golang.org/x/oauth2) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/sync](https://golang.org/x/sync) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/sys](https://golang.org/x/sys) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/text](https://golang.org/x/text) | BSD 3-Clause "New" or "Revised" License |
- | [golang.org/x/xerrors](https://golang.org/x/xerrors) | BSD 3-Clause "New" or "Revised" License |
- | [google.golang.org/api](https://google.golang.org/api) | BSD 3-Clause "New" or "Revised" License |
- | [google.golang.org/genproto](https://google.golang.org/genproto) | Apache License 2.0 |
- | [gopkg.in/ini.v1](https://gopkg.in/ini.v1) | Apache License 2.0 |
- | [gopkg.in/yaml.v2](https://gopkg.in/yaml.v2) | Apache License 2.0 |

bufferpool/bufpool.go

@@ -20,7 +20,7 @@ import (
 )
 
 var bufferPool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return &bytes.Buffer{}
 	},
 }

cache/filecache/filecache.go

@@ -175,7 +175,12 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It
 		return info, r, nil
 	}
 
-	r, err := create()
+	var (
+		r   io.ReadCloser
+		err error
+	)
+
+	r, err = create()
 	if err != nil {
 		return info, nil, err
 	}
@@ -206,7 +211,12 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 		return info, b, err
 	}
 
-	b, err := create()
+	var (
+		b   []byte
+		err error
+	)
+
+	b, err = create()
 	if err != nil {
 		return info, nil, err
 	}
@@ -285,6 +295,9 @@ func (c *Cache) isExpired(modTime time.Time) bool {
 	if c.maxAge < 0 {
 		return false
 	}
+
+	// Note the use of time.Since here.
+	// We cannot use Hugo's global Clock for this.
 	return c.maxAge == 0 || time.Since(modTime) > c.maxAge
 }
 

cache/filecache/filecache_config.go

@@ -14,17 +14,21 @@
 package filecache
 
 import (
+	"fmt"
 	"path"
 	"path/filepath"
 	"strings"
 	"time"
 
+	"github.com/gohugoio/hugo/common/maps"
+
 	"github.com/gohugoio/hugo/config"
 
 	"github.com/gohugoio/hugo/helpers"
 
+	"errors"
+
 	"github.com/mitchellh/mapstructure"
-	"github.com/pkg/errors"
 	"github.com/spf13/afero"
 )
 
@@ -32,19 +36,21 @@ const (
 	cachesConfigKey = "caches"
 
 	resourcesGenDir = ":resourceDir/_gen"
+	cacheDirProject = ":cacheDir/:project"
 )
 
 var defaultCacheConfig = Config{
 	MaxAge: -1, // Never expire
-	Dir:    ":cacheDir/:project",
+	Dir:    cacheDirProject,
 }
 
 const (
-	cacheKeyGetJSON = "getjson"
-	cacheKeyGetCSV  = "getcsv"
-	cacheKeyImages  = "images"
-	cacheKeyAssets  = "assets"
-	cacheKeyModules = "modules"
+	cacheKeyGetJSON     = "getjson"
+	cacheKeyGetCSV      = "getcsv"
+	cacheKeyImages      = "images"
+	cacheKeyAssets      = "assets"
+	cacheKeyModules     = "modules"
+	cacheKeyGetResource = "getresource"
 )
 
 type Configs map[string]Config
@@ -68,6 +74,10 @@ var defaultCacheConfigs = Configs{
 		MaxAge: -1,
 		Dir:    resourcesGenDir,
 	},
+	cacheKeyGetResource: Config{
+		MaxAge: -1, // Never expire
+		Dir:    cacheDirProject,
+	},
 }
 
 type Config struct {
@@ -109,6 +119,11 @@ func (f Caches) AssetsCache() *Cache {
 	return f[cacheKeyAssets]
 }
 
+// GetResourceCache gets the file cache for remote resources.
+func (f Caches) GetResourceCache() *Cache {
+	return f[cacheKeyGetResource]
+}
+
 func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 	c := make(Configs)
 	valid := make(map[string]bool)
@@ -123,6 +138,9 @@ func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 	_, isOsFs := fs.(*afero.OsFs)
 
 	for k, v := range m {
+		if _, ok := v.(maps.Params); !ok {
+			continue
+		}
 		cc := defaultCacheConfig
 
 		dc := &mapstructure.DecoderConfig{
@@ -137,7 +155,7 @@ func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 		}
 
 		if err := decoder.Decode(v); err != nil {
-			return nil, err
+			return nil, fmt.Errorf("failed to decode filecache config: %w", err)
 		}
 
 		if cc.Dir == "" {
@@ -146,7 +164,7 @@ func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 
 		name := strings.ToLower(k)
 		if !valid[name] {
-			return nil, errors.Errorf("%q is not a valid cache name", name)
+			return nil, fmt.Errorf("%q is not a valid cache name", name)
 		}
 
 		c[name] = cc
@@ -181,12 +199,12 @@ func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 
 		if !v.isResourceDir {
 			if isOsFs && !filepath.IsAbs(v.Dir) {
-				return c, errors.Errorf("%q must resolve to an absolute directory", v.Dir)
+				return c, fmt.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)
+				return c, fmt.Errorf("%q is a root folder and not allowed as cache dir", v.Dir)
 			}
 		}
 
@@ -226,5 +244,5 @@ func resolveDirPlaceholder(fs afero.Fs, cfg config.Provider, placeholder string)
 		return filepath.Base(workingDir), false, nil
 	}
 
-	return "", false, errors.Errorf("%q is not a valid placeholder (valid values are :cacheDir or :resourceDir)", placeholder)
+	return "", false, fmt.Errorf("%q is not a valid placeholder (valid values are :cacheDir or :resourceDir)", placeholder)
 }

cache/filecache/filecache_config_test.go

@@ -25,7 +25,6 @@ import (
 	"github.com/gohugoio/hugo/config"
 
 	qt "github.com/frankban/quicktest"
-	"github.com/spf13/viper"
 )
 
 func TestDecodeConfig(t *testing.T) {
@@ -51,7 +50,8 @@ maxAge = "11h"
 dir = "/path/to/c2"
 [caches.images]
 dir = "/path/to/c3"
-
+[caches.getResource]
+dir = "/path/to/c4"
 `
 
 	cfg, err := config.FromConfigString(configStr, "toml")
@@ -60,7 +60,7 @@ dir = "/path/to/c3"
 	decoded, err := DecodeConfig(fs, cfg)
 	c.Assert(err, qt.IsNil)
 
-	c.Assert(len(decoded), qt.Equals, 5)
+	c.Assert(len(decoded), qt.Equals, 6)
 
 	c2 := decoded["getcsv"]
 	c.Assert(c2.MaxAge.String(), qt.Equals, "11h0m0s")
@@ -69,6 +69,10 @@ dir = "/path/to/c3"
 	c3 := decoded["images"]
 	c.Assert(c3.MaxAge, qt.Equals, time.Duration(-1))
 	c.Assert(c3.Dir, qt.Equals, filepath.FromSlash("/path/to/c3/filecache/images"))
+
+	c4 := decoded["getresource"]
+	c.Assert(c4.MaxAge, qt.Equals, time.Duration(-1))
+	c.Assert(c4.Dir, qt.Equals, filepath.FromSlash("/path/to/c4/filecache/getresource"))
 }
 
 func TestDecodeConfigIgnoreCache(t *testing.T) {
@@ -95,7 +99,8 @@ maxAge = 3456
 dir = "/path/to/c2"
 [caches.images]
 dir = "/path/to/c3"
-
+[caches.getResource]
+dir = "/path/to/c4"
 `
 
 	cfg, err := config.FromConfigString(configStr, "toml")
@@ -104,7 +109,7 @@ dir = "/path/to/c3"
 	decoded, err := DecodeConfig(fs, cfg)
 	c.Assert(err, qt.IsNil)
 
-	c.Assert(len(decoded), qt.Equals, 5)
+	c.Assert(len(decoded), qt.Equals, 6)
 
 	for _, v := range decoded {
 		c.Assert(v.MaxAge, qt.Equals, time.Duration(0))
@@ -130,7 +135,7 @@ func TestDecodeConfigDefault(t *testing.T) {
 
 	c.Assert(err, qt.IsNil)
 
-	c.Assert(len(decoded), qt.Equals, 5)
+	c.Assert(len(decoded), qt.Equals, 6)
 
 	imgConfig := decoded[cacheKeyImages]
 	jsonConfig := decoded[cacheKeyGetJSON]
@@ -178,8 +183,8 @@ dir = "/"
 	c.Assert(err, qt.Not(qt.IsNil))
 }
 
-func newTestConfig() *viper.Viper {
-	cfg := viper.New()
+func newTestConfig() config.Provider {
+	cfg := config.NewWithTestDefaults()
 	cfg.Set("workingDir", filepath.FromSlash("/my/cool/hugoproject"))
 	cfg.Set("contentDir", "content")
 	cfg.Set("dataDir", "data")

cache/filecache/filecache_pruner.go

@@ -14,12 +14,12 @@
 package filecache
 
 import (
+	"fmt"
 	"io"
 	"os"
 
 	"github.com/gohugoio/hugo/hugofs"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/afero"
 )
 
@@ -39,7 +39,7 @@ func (c Caches) Prune() (int, error) {
 			if os.IsNotExist(err) {
 				continue
 			}
-			return counter, errors.Wrapf(err, "failed to prune cache %q", k)
+			return counter, fmt.Errorf("failed to prune cache %q: %w", k, err)
 		}
 
 	}

cache/filecache/filecache_test.go

@@ -342,6 +342,7 @@ func newPathsSpec(t *testing.T, fs afero.Fs, configStr string) *helpers.PathSpec
 	cfg, err := config.FromConfigString(configStr, "toml")
 	c.Assert(err, qt.IsNil)
 	initConfig(fs, cfg)
+	config.SetBaseTestDefaults(cfg)
 	p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, cfg), cfg, nil)
 	c.Assert(err, qt.IsNil)
 	return p

cache/namedmemcache/named_cache.go

@@ -30,7 +30,7 @@ type Cache struct {
 }
 
 type cacheEntry struct {
-	value interface{}
+	value any
 	err   error
 }
 
@@ -55,7 +55,7 @@ func (c *Cache) Clear() {
 // create will be called and cached.
 // This method is thread safe. It also guarantees that the create func for a given
 // key is invoked only once for this cache.
-func (c *Cache) GetOrCreate(key string, create func() (interface{}, error)) (interface{}, error) {
+func (c *Cache) GetOrCreate(key string, create func() (any, error)) (any, error) {
 	c.mu.RLock()
 	entry, found := c.cache[key]
 	c.mu.RUnlock()

cache/namedmemcache/named_cache_test.go

@@ -28,7 +28,7 @@ func TestNamedCache(t *testing.T) {
 	cache := New()
 
 	counter := 0
-	create := func() (interface{}, error) {
+	create := func() (any, error) {
 		counter++
 		return counter, nil
 	}
@@ -58,8 +58,8 @@ func TestNamedCacheConcurrent(t *testing.T) {
 
 	cache := New()
 
-	create := func(i int) func() (interface{}, error) {
-		return func() (interface{}, error) {
+	create := func(i int) func() (any, error) {
+		return func() (any, error) {
 			return i, nil
 		}
 	}

codegen/methods.go

@@ -505,7 +505,7 @@ func typeName(name, pkg string) string {
 
 func uniqueNonEmptyStrings(s []string) []string {
 	var unique []string
-	set := map[string]interface{}{}
+	set := map[string]any{}
 	for _, val := range s {
 		if val == "" {
 			continue

codegen/methods_test.go

@@ -85,7 +85,7 @@ type I interface {
 	Method3(myint int, mystring string)
 	Method5() (string, error)
 	Method6() *net.IP
-	Method7() interface{}
+	Method7() any
 	Method8() herrors.ErrorContext
 	method2()
 	method9() os.FileInfo

commands/commandeer.go

@@ -14,9 +14,10 @@
 package commands
 
 import (
-	"bytes"
 	"errors"
+	"fmt"
 	"io/ioutil"
+	"net"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -28,8 +29,11 @@ import (
 	"golang.org/x/sync/semaphore"
 
 	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/htime"
 	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/common/paths"
 
+	"github.com/spf13/cast"
 	jww "github.com/spf13/jwalterweatherman"
 
 	"github.com/gohugoio/hugo/common/loggers"
@@ -40,7 +44,9 @@ import (
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/spf13/afero"
 
+	"github.com/bep/clock"
 	"github.com/bep/debounce"
+	"github.com/bep/overlayfs"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/helpers"
@@ -61,12 +67,21 @@ type commandeer struct {
 	logger       loggers.Logger
 	serverConfig *config.Server
 
+	buildLock func() (unlock func(), err error)
+
+	// Loading state
+	mustHaveConfigFile bool
+	failOnInitErr      bool
+	running            bool
+
 	// Currently only set when in "fast render mode". But it seems to
 	// be fast enough that we could maybe just add it for all server modes.
 	changeDetector *fileChangeDetector
 
-	// We need to reuse this on server rebuilds.
-	destinationFs afero.Fs
+	// We need to reuse these on server rebuilds.
+	// These 2 will be different if --renderStaticToDisk is set.
+	publishDirFs       afero.Fs
+	publishDirServerFs afero.Fs
 
 	h    *hugoBuilderCommon
 	ftch flagsToConfigHandler
@@ -81,13 +96,14 @@ type commandeer struct {
 	// Used in cases where we get flooded with events in server mode.
 	debounce func(f func())
 
-	serverPorts         []int
-	languagesConfigured bool
-	languages           langs.Languages
-	doLiveReload        bool
-	fastRenderMode      bool
-	showErrorInBrowser  bool
-	wasError            bool
+	serverPorts []serverPortListener
+
+	languages          langs.Languages
+	doLiveReload       bool
+	renderStaticToDisk bool
+	fastRenderMode     bool
+	showErrorInBrowser bool
+	wasError           bool
 
 	configured bool
 	paused     bool
@@ -98,6 +114,11 @@ type commandeer struct {
 	buildErr error
 }
 
+type serverPortListener struct {
+	p  int
+	ln net.Listener
+}
+
 func newCommandeerHugoState() *commandeerHugoState {
 	return &commandeerHugoState{
 		created: make(chan struct{}),
@@ -109,37 +130,38 @@ func (c *commandeerHugoState) hugo() *hugolib.HugoSites {
 	return c.hugoSites
 }
 
+func (c *commandeerHugoState) hugoTry() *hugolib.HugoSites {
+	select {
+	case <-c.created:
+		return c.hugoSites
+	case <-time.After(time.Millisecond * 100):
+		return nil
+	}
+}
+
 func (c *commandeer) errCount() int {
 	return int(c.logger.LogCounters().ErrorCounter.Count())
 }
 
-func (c *commandeer) getErrorWithContext() interface{} {
+func (c *commandeer) getErrorWithContext() any {
 	errCount := c.errCount()
 
 	if errCount == 0 {
 		return nil
 	}
 
-	m := make(map[string]interface{})
+	m := make(map[string]any)
 
-	m["Error"] = errors.New(removeErrorPrefixFromLog(c.logger.Errors()))
+	//xwm["Error"] = errors.New(cleanErrorLog(removeErrorPrefixFromLog(c.logger.Errors())))
+	m["Error"] = errors.New(cleanErrorLog(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.FprintStackTraceFromErr(&b, c.buildErr)
-		m["StackTrace"] = b.String()
-	}
+	ferrors := herrors.UnwrapFileErrorsWithErrorContext(c.buildErr)
+	m["Files"] = ferrors
 
 	return m
 }
 
-func (c *commandeer) Set(key string, value interface{}) {
+func (c *commandeer) Set(key string, value any) {
 	if c.configured {
 		panic("commandeer cannot be changed")
 	}
@@ -147,13 +169,29 @@ func (c *commandeer) Set(key string, value interface{}) {
 }
 
 func (c *commandeer) initFs(fs *hugofs.Fs) error {
-	c.destinationFs = fs.Destination
+	c.publishDirFs = fs.PublishDir
+	c.publishDirServerFs = fs.PublishDirServer
 	c.DepsCfg.Fs = fs
 
 	return nil
 }
 
-func newCommandeer(mustHaveConfigFile, running bool, h *hugoBuilderCommon, f flagsToConfigHandler, cfgInit func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) {
+func (c *commandeer) initClock(loc *time.Location) error {
+	bt := c.Cfg.GetString("clock")
+	if bt == "" {
+		return nil
+	}
+
+	t, err := cast.StringToDateInDefaultLocation(bt, loc)
+	if err != nil {
+		return fmt.Errorf(`failed to parse "clock" flag: %s`, err)
+	}
+
+	htime.Clock = clock.Start(t)
+	return nil
+}
+
+func newCommandeer(mustHaveConfigFile, failOnInitErr, running bool, h *hugoBuilderCommon, f flagsToConfigHandler, cfgInit func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) {
 	var rebuildDebouncer func(f func())
 	if running {
 		// The time value used is tested with mass content replacements in a fairly big Hugo site.
@@ -175,11 +213,17 @@ func newCommandeer(mustHaveConfigFile, running bool, h *hugoBuilderCommon, f fla
 		visitedURLs:         types.NewEvictingStringQueue(10),
 		debounce:            rebuildDebouncer,
 		fullRebuildSem:      semaphore.NewWeighted(1),
+
+		// Init state
+		mustHaveConfigFile: mustHaveConfigFile,
+		failOnInitErr:      failOnInitErr,
+		running:            running,
+
 		// This will be replaced later, but we need something to log to before the configuration is read.
 		logger: loggers.NewLogger(jww.LevelWarn, jww.LevelError, out, ioutil.Discard, running),
 	}
 
-	return c, c.loadConfig(mustHaveConfigFile, running)
+	return c, c.loadConfig()
 }
 
 type fileChangeDetector struct {
@@ -244,7 +288,7 @@ func (f *fileChangeDetector) PrepareNew() {
 	f.current = make(map[string]string)
 }
 
-func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
+func (c *commandeer) loadConfig() error {
 	if c.DepsCfg == nil {
 		c.DepsCfg = &deps.DepsCfg{}
 	}
@@ -256,7 +300,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 
 	cfg := c.DepsCfg
 	c.configured = false
-	cfg.Running = running
+	cfg.Running = c.running
 
 	var dir string
 	if c.h.source != "" {
@@ -270,7 +314,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		sourceFs = c.DepsCfg.Fs.Source
 	}
 
-	environment := c.h.getEnvironment(running)
+	environment := c.h.getEnvironment(c.running)
 
 	doWithConfig := func(cfg config.Provider) error {
 		if c.ftch != nil {
@@ -303,27 +347,41 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 			WorkingDir:   dir,
 			Filename:     c.h.cfgFile,
 			AbsConfigDir: c.h.getConfigDir(dir),
-			Environ:      os.Environ(),
 			Environment:  environment,
 		},
 		cfgSetAndInit,
 		doWithConfig)
 
-	if err != nil && mustHaveConfigFile {
-		return err
-	} else if mustHaveConfigFile && len(configFiles) == 0 {
+	if err != nil {
+		// We should improve the error handling here,
+		// but with hugo mod init and similar there is a chicken and egg situation
+		// with modules already configured in config.toml, so ignore those errors.
+		if c.mustHaveConfigFile || (c.failOnInitErr && !moduleNotFoundRe.MatchString(err.Error())) {
+			return err
+		} else {
+			// Just make it a warning.
+			c.logger.Warnln(err)
+		}
+	} else if c.mustHaveConfigFile && len(configFiles) == 0 {
 		return hugolib.ErrNoConfigFile
 	}
 
 	c.configFiles = configFiles
 
-	if l, ok := c.Cfg.Get("languagesSorted").(langs.Languages); ok {
-		c.languagesConfigured = true
-		c.languages = l
+	var ok bool
+	loc := time.Local
+	c.languages, ok = c.Cfg.Get("languagesSorted").(langs.Languages)
+	if ok {
+		loc = langs.GetLocation(c.languages[0])
+	}
+
+	err = c.initClock(loc)
+	if err != nil {
+		return err
 	}
 
 	// Set some commonly used flags
-	c.doLiveReload = running && !c.Cfg.GetBool("disableLiveReload")
+	c.doLiveReload = c.running && !c.Cfg.GetBool("disableLiveReload")
 	c.fastRenderMode = c.doLiveReload && !c.Cfg.GetBool("disableFastRender")
 	c.showErrorInBrowser = c.doLiveReload && !c.Cfg.GetBool("disableBrowserError")
 
@@ -335,7 +393,7 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 		}
 	}
 
-	logger, err := c.createLogger(config, running)
+	logger, err := c.createLogger(config)
 	if err != nil {
 		return err
 	}
@@ -348,21 +406,57 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 	}
 
 	createMemFs := config.GetBool("renderToMemory")
+	c.renderStaticToDisk = config.GetBool("renderStaticToDisk")
 
 	if createMemFs {
 		// Rendering to memoryFS, publish to Root regardless of publishDir.
 		config.Set("publishDir", "/")
+		config.Set("publishDirStatic", "/")
+	} else if c.renderStaticToDisk {
+		// Hybrid, render dynamic content to Root.
+		config.Set("publishDirStatic", config.Get("publishDir"))
+		config.Set("publishDir", "/")
+
 	}
 
 	c.fsCreate.Do(func() {
-		fs := hugofs.NewFrom(sourceFs, config)
+		// Assume both source and destination are using same filesystem.
+		fs := hugofs.NewFromSourceAndDestination(sourceFs, sourceFs, config)
 
-		if c.destinationFs != nil {
+		if c.publishDirFs != nil {
 			// Need to reuse the destination on server rebuilds.
-			fs.Destination = c.destinationFs
-		} else if createMemFs {
-			// Hugo writes the output to memory instead of the disk.
-			fs.Destination = new(afero.MemMapFs)
+			fs.PublishDir = c.publishDirFs
+			fs.PublishDirServer = c.publishDirServerFs
+		} else {
+			if c.renderStaticToDisk {
+				publishDirStatic := config.GetString("publishDirStatic")
+				workingDir := config.GetString("workingDir")
+				absPublishDirStatic := paths.AbsPathify(workingDir, publishDirStatic)
+
+				fs = hugofs.NewFromSourceAndDestination(sourceFs, afero.NewMemMapFs(), config)
+				// Writes the dynamic output to memory,
+				// while serve others directly from /public on disk.
+				dynamicFs := fs.PublishDir
+				staticFs := afero.NewBasePathFs(afero.NewOsFs(), absPublishDirStatic)
+
+				// Serve from both the static and dynamic fs,
+				// the first will take priority.
+				// THis is a read-only filesystem,
+				// we do all the writes to
+				// fs.Destination and fs.DestinationStatic.
+				fs.PublishDirServer = overlayfs.New(
+					overlayfs.Options{
+						Fss: []afero.Fs{
+							dynamicFs,
+							staticFs,
+						},
+					},
+				)
+				fs.PublishDirStatic = staticFs
+			} else if createMemFs {
+				// Hugo writes the output to memory instead of the disk.
+				fs = hugofs.NewFromSourceAndDestination(sourceFs, afero.NewMemMapFs(), config)
+			}
 		}
 
 		if c.fastRenderMode {
@@ -376,12 +470,15 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 			}
 
 			changeDetector.PrepareNew()
-			fs.Destination = hugofs.NewHashingFs(fs.Destination, changeDetector)
+			fs.PublishDir = hugofs.NewHashingFs(fs.PublishDir, changeDetector)
+			fs.PublishDirStatic = hugofs.NewHashingFs(fs.PublishDirStatic, changeDetector)
 			c.changeDetector = changeDetector
 		}
 
 		if c.Cfg.GetBool("logPathWarnings") {
-			fs.Destination = hugofs.NewCreateCountingFs(fs.Destination)
+			// Note that we only care about the "dynamic creates" here,
+			// so skip the static fs.
+			fs.PublishDir = hugofs.NewCreateCountingFs(fs.PublishDir)
 		}
 
 		// To debug hard-to-find path issues.
@@ -395,8 +492,17 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 
 		var h *hugolib.HugoSites
 
-		h, err = hugolib.NewHugoSites(*c.DepsCfg)
+		var createErr error
+		h, createErr = hugolib.NewHugoSites(*c.DepsCfg)
+		if h == nil || c.failOnInitErr {
+			err = createErr
+		}
+
 		c.hugoSites = h
+		// TODO(bep) improve.
+		if c.buildLock == nil && h != nil {
+			c.buildLock = h.LockBuild
+		}
 		close(c.created)
 	})
 
@@ -410,7 +516,5 @@ func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
 	}
 	config.Set("cacheDir", cacheDir)
 
-	cfg.Logger.Infoln("Using config file:", config.ConfigFileUsed())
-
 	return nil
 }

commands/commands.go

@@ -18,10 +18,9 @@ import (
 	"os"
 	"time"
 
-	"github.com/gohugoio/hugo/hugolib/paths"
-
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
+	hpaths "github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/spf13/cobra"
@@ -48,7 +47,6 @@ func (b *commandsBuilder) addAll() *commandsBuilder {
 		newVersionCmd(),
 		newEnvCmd(),
 		b.newConfigCmd(),
-		newCheckCmd(),
 		b.newDeployCmd(),
 		b.newConvertCmd(),
 		b.newNewCmd(),
@@ -131,8 +129,7 @@ type hugoCmd struct {
 
 var _ cmder = (*nilCommand)(nil)
 
-type nilCommand struct {
-}
+type nilCommand struct{}
 
 func (c *nilCommand) getCommand() *cobra.Command {
 	return nil
@@ -152,7 +149,7 @@ func (b *commandsBuilder) newHugoCmd() *hugoCmd {
 Hugo is a Fast and Flexible Static Site Generator
 built with love by spf13 and friends in Go.
 
-Complete documentation is available at http://gohugo.io/.`,
+Complete documentation is available at https://gohugo.io/.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			defer cc.timeTrack(time.Now(), "Total")
 			cfgInit := func(c *commandeer) error {
@@ -162,13 +159,21 @@ Complete documentation is available at http://gohugo.io/.`,
 				return nil
 			}
 
-			c, err := initializeConfig(true, cc.buildWatch, &cc.hugoBuilderCommon, cc, cfgInit)
+			// prevent cobra printing error so it can be handled here (before the timeTrack prints)
+			cmd.SilenceErrors = true
+
+			c, err := initializeConfig(true, true, cc.buildWatch, &cc.hugoBuilderCommon, cc, cfgInit)
 			if err != nil {
+				cmd.PrintErrln("Error:", err.Error())
 				return err
 			}
 			cc.c = c
 
-			return c.build()
+			err = c.build()
+			if err != nil {
+				cmd.PrintErrln("Error:", err.Error())
+			}
+			return err
 		},
 	})
 
@@ -204,6 +209,8 @@ type hugoBuilderCommon struct {
 	environment string
 
 	buildWatch bool
+	poll       string
+	clock      string
 
 	gc bool
 
@@ -236,14 +243,14 @@ func (cc *hugoBuilderCommon) timeTrack(start time.Time, name string) {
 
 func (cc *hugoBuilderCommon) getConfigDir(baseDir string) string {
 	if cc.cfgDir != "" {
-		return paths.AbsPathify(baseDir, cc.cfgDir)
+		return hpaths.AbsPathify(baseDir, cc.cfgDir)
 	}
 
 	if v, found := os.LookupEnv("HUGO_CONFIGDIR"); found {
-		return paths.AbsPathify(baseDir, v)
+		return hpaths.AbsPathify(baseDir, v)
 	}
 
-	return paths.AbsPathify(baseDir, "config")
+	return hpaths.AbsPathify(baseDir, "config")
 }
 
 func (cc *hugoBuilderCommon) getEnvironment(isServer bool) string {
@@ -272,8 +279,8 @@ func (cc *hugoBuilderCommon) handleCommonBuilderFlags(cmd *cobra.Command) {
 	cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
 	cmd.PersistentFlags().StringVarP(&cc.environment, "environment", "e", "", "build environment")
 	cmd.PersistentFlags().StringP("themesDir", "", "", "filesystem path to themes directory")
-	cmd.PersistentFlags().BoolP("ignoreVendor", "", false, "ignores any _vendor directory")
 	cmd.PersistentFlags().StringP("ignoreVendorPaths", "", "", "ignores any _vendor for module paths matching the given Glob pattern")
+	cmd.PersistentFlags().StringVar(&cc.clock, "clock", "", "set the clock used by Hugo, e.g. --clock 2021-11-06T22:30:00.00+09:00")
 }
 
 func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
@@ -288,20 +295,23 @@ func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 	cmd.Flags().BoolP("ignoreCache", "", false, "ignores the cache directory")
 	cmd.Flags().StringP("destination", "d", "", "filesystem path to write files to")
 	cmd.Flags().StringSliceP("theme", "t", []string{}, "themes to use (located in /themes/THEMENAME/)")
-	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().StringVarP(&cc.baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. https://spf13.com/")
+	cmd.Flags().Bool("enableGitInfo", false, "add Git revision, date, author, and CODEOWNERS info to the pages")
 	cmd.Flags().BoolVar(&cc.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
-
+	cmd.Flags().StringVar(&cc.poll, "poll", "", "set this to a poll interval, e.g --poll 700ms, to use a poll based approach to watch for file system changes")
+	cmd.Flags().BoolVar(&loggers.PanicOnWarning, "panicOnWarning", false, "panic on first WARNING log")
 	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().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")
-	cmd.Flags().BoolP("i18n-warnings", "", false, "print missing translations")
-	cmd.Flags().BoolP("path-warnings", "", false, "print warnings on duplicate target paths etc.")
+	cmd.Flags().BoolP("noBuildLock", "", false, "don't create .hugo_build.lock file")
+	cmd.Flags().BoolP("printI18nWarnings", "", false, "print missing translations")
+	cmd.Flags().BoolP("printPathWarnings", "", false, "print warnings on duplicate target paths etc.")
+	cmd.Flags().BoolP("printUnusedTemplates", "", false, "print warnings on unused templates.")
 	cmd.Flags().StringVarP(&cc.cpuprofile, "profile-cpu", "", "", "write cpu profile to `file`")
 	cmd.Flags().StringVarP(&cc.memprofile, "profile-mem", "", "", "write memory profile to `file`")
-	cmd.Flags().BoolVarP(&cc.printm, "print-mem", "", false, "print memory usage to screen at intervals")
+	cmd.Flags().BoolVarP(&cc.printm, "printMemoryUsage", "", false, "print memory usage to screen at intervals")
 	cmd.Flags().StringVarP(&cc.mutexprofile, "profile-mutex", "", "", "write Mutex profile to `file`")
 	cmd.Flags().StringVarP(&cc.traceprofile, "trace", "", "", "write trace to `file` (not useful in general)")
 

commands/commands_test.go

@@ -20,7 +20,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/gohugoio/hugo/htesting"
+	"github.com/gohugoio/hugo/config"
 
 	"github.com/spf13/afero"
 
@@ -29,7 +29,6 @@ import (
 	"github.com/gohugoio/hugo/common/types"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 
 	qt "github.com/frankban/quicktest"
 )
@@ -37,15 +36,13 @@ import (
 func TestExecute(t *testing.T) {
 	c := qt.New(t)
 
-	createSite := func(c *qt.C) (string, func()) {
-		dir, clean, err := createSimpleTestSite(t, testSiteConfig{})
-		c.Assert(err, qt.IsNil)
-		return dir, clean
+	createSite := func(c *qt.C) string {
+		dir := createSimpleTestSite(t, testSiteConfig{})
+		return dir
 	}
 
 	c.Run("hugo", func(c *qt.C) {
-		dir, clean := createSite(c)
-		defer clean()
+		dir := createSite(c)
 		resp := Execute([]string{"-s=" + dir})
 		c.Assert(resp.Err, qt.IsNil)
 		result := resp.Result
@@ -55,8 +52,7 @@ func TestExecute(t *testing.T) {
 	})
 
 	c.Run("hugo, set environment", func(c *qt.C) {
-		dir, clean := createSite(c)
-		defer clean()
+		dir := createSite(c)
 		resp := Execute([]string{"-s=" + dir, "-e=staging"})
 		c.Assert(resp.Err, qt.IsNil)
 		result := resp.Result
@@ -64,9 +60,8 @@ func TestExecute(t *testing.T) {
 	})
 
 	c.Run("convert toJSON", func(c *qt.C) {
-		dir, clean := createSite(c)
+		dir := createSite(c)
 		output := filepath.Join(dir, "myjson")
-		defer clean()
 		resp := Execute([]string{"convert", "toJSON", "-s=" + dir, "-e=staging", "-o=" + output})
 		c.Assert(resp.Err, qt.IsNil)
 		converted := readFileFrom(c, filepath.Join(output, "content", "p1.md"))
@@ -74,8 +69,7 @@ func TestExecute(t *testing.T) {
 	})
 
 	c.Run("config, set environment", func(c *qt.C) {
-		dir, clean := createSite(c)
-		defer clean()
+		dir := createSite(c)
 		out, err := captureStdout(func() error {
 			resp := Execute([]string{"config", "-s=" + dir, "-e=staging"})
 			return resp.Err
@@ -85,16 +79,14 @@ func TestExecute(t *testing.T) {
 	})
 
 	c.Run("deploy, environment set", func(c *qt.C) {
-		dir, clean := createSite(c)
-		defer clean()
+		dir := createSite(c)
 		resp := Execute([]string{"deploy", "-s=" + dir, "-e=staging", "--target=mydeployment", "--dryRun"})
 		c.Assert(resp.Err, qt.Not(qt.IsNil))
 		c.Assert(resp.Err.Error(), qt.Contains, `no driver registered for "hugocloud"`)
 	})
 
 	c.Run("list", func(c *qt.C) {
-		dir, clean := createSite(c)
-		defer clean()
+		dir := createSite(c)
 		out, err := captureStdout(func() error {
 			resp := Execute([]string{"list", "all", "-s=" + dir, "-e=staging"})
 			return resp.Err
@@ -104,8 +96,7 @@ func TestExecute(t *testing.T) {
 	})
 
 	c.Run("new theme", func(c *qt.C) {
-		dir, clean := createSite(c)
-		defer clean()
+		dir := createSite(c)
 		themesDir := filepath.Join(dir, "mythemes")
 		resp := Execute([]string{"new", "theme", "mytheme", "-s=" + dir, "-e=staging", "--themesDir=" + themesDir})
 		c.Assert(resp.Err, qt.IsNil)
@@ -114,13 +105,12 @@ func TestExecute(t *testing.T) {
 	})
 
 	c.Run("new site", func(c *qt.C) {
-		dir, clean := createSite(c)
-		defer clean()
+		dir := createSite(c)
 		siteDir := filepath.Join(dir, "mysite")
 		resp := Execute([]string{"new", "site", siteDir, "-e=staging"})
 		c.Assert(resp.Err, qt.IsNil)
 		config := readFileFrom(c, filepath.Join(siteDir, "config.toml"))
-		c.Assert(config, qt.Contains, "baseURL = \"http://example.org/\"")
+		c.Assert(config, qt.Contains, "baseURL = 'http://example.org/'")
 		checkNewSiteInited(c, siteDir)
 	})
 }
@@ -161,22 +151,12 @@ func TestFlags(t *testing.T) {
 		args  []string
 		check func(c *qt.C, cmd *serverCmd)
 	}{
-		{
-			// https://github.com/gohugoio/hugo/issues/7642
-			name: "ignoreVendor as bool",
-			args: []string{"server", "--ignoreVendor"},
-			check: func(c *qt.C, cmd *serverCmd) {
-				cfg := viper.New()
-				cmd.flagsToConfig(cfg)
-				c.Assert(cfg.Get("ignoreVendor"), qt.Equals, true)
-			},
-		},
 		{
 			// https://github.com/gohugoio/hugo/issues/7642
 			name: "ignoreVendorPaths",
 			args: []string{"server", "--ignoreVendorPaths=github.com/**"},
 			check: func(c *qt.C, cmd *serverCmd) {
-				cfg := viper.New()
+				cfg := config.NewWithTestDefaults()
 				cmd.flagsToConfig(cfg)
 				c.Assert(cfg.Get("ignoreVendorPaths"), qt.Equals, "github.com/**")
 			},
@@ -199,13 +179,14 @@ func TestFlags(t *testing.T) {
 				"--navigateToChanged",
 				"--disableLiveReload",
 				"--noHTTPCache",
-				"--i18n-warnings",
+				"--printI18nWarnings",
 				"--destination=/tmp/mydestination",
 				"-b=https://example.com/b/",
 				"--port=1366",
 				"--renderToDisk",
 				"--source=mysource",
-				"--path-warnings",
+				"--printPathWarnings",
+				"--printUnusedTemplates",
 			},
 			check: func(c *qt.C, sc *serverCmd) {
 				c.Assert(sc, qt.Not(qt.IsNil))
@@ -216,7 +197,7 @@ func TestFlags(t *testing.T) {
 				c.Assert(sc.serverPort, qt.Equals, 1366)
 				c.Assert(sc.environment, qt.Equals, "testing")
 
-				cfg := viper.New()
+				cfg := config.NewWithTestDefaults()
 				sc.flagsToConfig(cfg)
 				c.Assert(cfg.GetString("publishDir"), qt.Equals, "/tmp/mydestination")
 				c.Assert(cfg.GetString("contentDir"), qt.Equals, "mycontent")
@@ -229,10 +210,10 @@ func TestFlags(t *testing.T) {
 
 				c.Assert(cfg.GetBool("gc"), qt.Equals, true)
 
-				// The flag is named path-warnings
+				// The flag is named printPathWarnings
 				c.Assert(cfg.GetBool("logPathWarnings"), qt.Equals, true)
 
-				// The flag is named i18n-warnings
+				// The flag is named printI18nWarnings
 				c.Assert(cfg.GetBool("logI18nWarnings"), qt.Equals, true)
 			},
 		},
@@ -261,14 +242,8 @@ func TestFlags(t *testing.T) {
 func TestCommandsExecute(t *testing.T) {
 	c := qt.New(t)
 
-	dir, clean, err := createSimpleTestSite(t, testSiteConfig{})
-	c.Assert(err, qt.IsNil)
-
-	dirOut, clean2, err := htesting.CreateTempDir(hugofs.Os, "hugo-cli-out")
-	c.Assert(err, qt.IsNil)
-
-	defer clean()
-	defer clean2()
+	dir := createSimpleTestSite(t, testSiteConfig{})
+	dirOut := t.TempDir()
 
 	sourceFlag := fmt.Sprintf("-s=%s", dir)
 
@@ -283,11 +258,14 @@ func TestCommandsExecute(t *testing.T) {
 		// no args = hugo build
 		{nil, []string{sourceFlag}, ""},
 		{nil, []string{sourceFlag, "--renderToMemory"}, ""},
+		{[]string{"completion", "bash"}, nil, ""},
+		{[]string{"completion", "fish"}, nil, ""},
+		{[]string{"completion", "powershell"}, nil, ""},
+		{[]string{"completion", "zsh"}, nil, ""},
 		{[]string{"config"}, []string{sourceFlag}, ""},
 		{[]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")}, ""},
-		{[]string{"gen", "autocomplete"}, []string{"--completionfile=" + filepath.Join(dirOut, "autocomplete.txt")}, ""},
 		{[]string{"gen", "chromastyles"}, []string{"--style=manni"}, ""},
 		{[]string{"gen", "doc"}, []string{"--dir=" + filepath.Join(dirOut, "doc")}, ""},
 		{[]string{"gen", "man"}, []string{"--dir=" + filepath.Join(dirOut, "man")}, ""},
@@ -302,29 +280,35 @@ func TestCommandsExecute(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		b := newCommandsBuilder().addAll().build()
-		hugoCmd := b.getCommand()
-		test.flags = append(test.flags, "--quiet")
-		hugoCmd.SetArgs(append(test.commands, test.flags...))
-
-		// TODO(bep) capture output and add some simple asserts
-		// TODO(bep) misspelled subcommands does not return an error. We should investigate this
-		// but before that, check for "Error: unknown command".
-
-		_, err := hugoCmd.ExecuteC()
-		if test.expectErrToContain != "" {
-			c.Assert(err, qt.Not(qt.IsNil))
-			c.Assert(err.Error(), qt.Contains, test.expectErrToContain)
-		} else {
-			c.Assert(err, qt.IsNil)
+		name := "hugo"
+		if len(test.commands) > 0 {
+			name = test.commands[0]
 		}
+		c.Run(name, func(c *qt.C) {
+			b := newCommandsBuilder().addAll().build()
+			hugoCmd := b.getCommand()
+			test.flags = append(test.flags, "--quiet")
+			hugoCmd.SetArgs(append(test.commands, test.flags...))
 
-		// Assert that we have not left any development debug artifacts in
-		// the code.
-		if b.c != nil {
-			_, ok := b.c.destinationFs.(types.DevMarker)
-			c.Assert(ok, qt.Equals, false)
-		}
+			// TODO(bep) capture output and add some simple asserts
+			// TODO(bep) misspelled subcommands does not return an error. We should investigate this
+			// but before that, check for "Error: unknown command".
+
+			_, err := hugoCmd.ExecuteC()
+			if test.expectErrToContain != "" {
+				c.Assert(err, qt.Not(qt.IsNil))
+				c.Assert(err.Error(), qt.Contains, test.expectErrToContain)
+			} else {
+				c.Assert(err, qt.IsNil)
+			}
+
+			// Assert that we have not left any development debug artifacts in
+			// the code.
+			if b.c != nil {
+				_, ok := b.c.publishDirFs.(types.DevMarker)
+				c.Assert(ok, qt.Equals, false)
+			}
+		})
 
 	}
 }
@@ -334,11 +318,8 @@ type testSiteConfig struct {
 	contentDir string
 }
 
-func createSimpleTestSite(t *testing.T, cfg testSiteConfig) (string, func(), error) {
-	d, clean, e := htesting.CreateTempDir(hugofs.Os, "hugo-cli")
-	if e != nil {
-		return "", nil, e
-	}
+func createSimpleTestSite(t testing.TB, cfg testSiteConfig) string {
+	dir := t.TempDir()
 
 	cfgStr := `
 
@@ -357,21 +338,23 @@ title = "Hugo Commands"
 		contentDir = cfg.contentDir
 	}
 
-	os.MkdirAll(filepath.Join(d, "public"), 0777)
+	os.MkdirAll(filepath.Join(dir, "public"), 0777)
 
 	// Just the basic. These are for CLI tests, not site testing.
-	writeFile(t, filepath.Join(d, "config.toml"), cfgStr)
-	writeFile(t, filepath.Join(d, "config", "staging", "params.toml"), `myparam="paramstaging"`)
-	writeFile(t, filepath.Join(d, "config", "staging", "deployment.toml"), `
+	writeFile(t, filepath.Join(dir, "config.toml"), cfgStr)
+	writeFile(t, filepath.Join(dir, "config", "staging", "params.toml"), `myparam="paramstaging"`)
+	writeFile(t, filepath.Join(dir, "config", "staging", "deployment.toml"), `
 [[targets]]
 name = "mydeployment"
 URL = "hugocloud://hugotestbucket"
 `)
 
-	writeFile(t, filepath.Join(d, "config", "testing", "params.toml"), `myparam="paramtesting"`)
-	writeFile(t, filepath.Join(d, "config", "production", "params.toml"), `myparam="paramproduction"`)
+	writeFile(t, filepath.Join(dir, "config", "testing", "params.toml"), `myparam="paramtesting"`)
+	writeFile(t, filepath.Join(dir, "config", "production", "params.toml"), `myparam="paramproduction"`)
 
-	writeFile(t, filepath.Join(d, contentDir, "p1.md"), `
+	writeFile(t, filepath.Join(dir, "static", "myfile.txt"), `Hello World!`)
+
+	writeFile(t, filepath.Join(dir, contentDir, "p1.md"), `
 ---
 title: "P1"
 weight: 1
@@ -381,28 +364,32 @@ Content
 
 `)
 
-	writeFile(t, filepath.Join(d, "layouts", "_default", "single.html"), `
+	writeFile(t, filepath.Join(dir, "layouts", "_default", "single.html"), `
 
 Single: {{ .Title }}
 
 `)
 
-	writeFile(t, filepath.Join(d, "layouts", "_default", "list.html"), `
+	writeFile(t, filepath.Join(dir, "layouts", "_default", "list.html"), `
 
 List: {{ .Title }}
 Environment: {{ hugo.Environment }}
 
+For issue 9788:
+{{ $foo :="abc" | resources.FromString "foo.css" | minify | resources.PostProcess }}
+PostProcess: {{ $foo.RelPermalink }}
+
 `)
 
-	return d, clean, nil
+	return dir
 }
 
-func writeFile(t *testing.T, filename, content string) {
+func writeFile(t testing.TB, filename, content string) {
 	must(t, os.MkdirAll(filepath.Dir(filename), os.FileMode(0755)))
 	must(t, ioutil.WriteFile(filename, []byte(content), os.FileMode(0755)))
 }
 
-func must(t *testing.T, err error) {
+func must(t testing.TB, err error) {
 	if err != nil {
 		t.Fatal(err)
 	}

commands/config.go

@@ -21,6 +21,9 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/common/maps"
 
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
@@ -28,7 +31,6 @@ import (
 	"github.com/gohugoio/hugo/modules"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )
 
 var _ cmder = (*configCmd)(nil)
@@ -60,7 +62,7 @@ func (b *commandsBuilder) newConfigCmd() *configCmd {
 }
 
 func (c *configCmd) printMounts(cmd *cobra.Command, args []string) error {
-	cfg, err := initializeConfig(true, false, &c.hugoBuilderCommon, c, nil)
+	cfg, err := initializeConfig(true, false, false, &c.hugoBuilderCommon, c, nil)
 	if err != nil {
 		return err
 	}
@@ -68,7 +70,7 @@ func (c *configCmd) printMounts(cmd *cobra.Command, args []string) error {
 	allModules := cfg.Cfg.Get("allmodules").(modules.Modules)
 
 	for _, m := range allModules {
-		if err := parser.InterfaceToConfig(&modMounts{m: m}, metadecoders.JSON, os.Stdout); err != nil {
+		if err := parser.InterfaceToConfig(&modMounts{m: m, verbose: c.verbose}, metadecoders.JSON, os.Stdout); err != nil {
 			return err
 		}
 	}
@@ -76,12 +78,12 @@ func (c *configCmd) printMounts(cmd *cobra.Command, args []string) error {
 }
 
 func (c *configCmd) printConfig(cmd *cobra.Command, args []string) error {
-	cfg, err := initializeConfig(true, false, &c.hugoBuilderCommon, c, nil)
+	cfg, err := initializeConfig(true, false, false, &c.hugoBuilderCommon, c, nil)
 	if err != nil {
 		return err
 	}
 
-	allSettings := cfg.Cfg.(*viper.Viper).AllSettings()
+	allSettings := cfg.Cfg.Get("").(maps.Params)
 
 	// We need to clean up this, but we store objects in the config that
 	// isn't really interesting to the end user, so filter these.
@@ -114,7 +116,8 @@ func (c *configCmd) printConfig(cmd *cobra.Command, args []string) error {
 }
 
 type modMounts struct {
-	m modules.Module
+	verbose bool
+	m       modules.Module
 }
 
 type modMount struct {
@@ -134,13 +137,49 @@ func (m *modMounts) MarshalJSON() ([]byte, error) {
 		})
 	}
 
+	var ownerPath string
+	if m.m.Owner() != nil {
+		ownerPath = m.m.Owner().Path()
+	}
+
+	if m.verbose {
+		config := m.m.Config()
+		return json.Marshal(&struct {
+			Path        string              `json:"path"`
+			Version     string              `json:"version"`
+			Time        time.Time           `json:"time"`
+			Owner       string              `json:"owner"`
+			Dir         string              `json:"dir"`
+			Meta        map[string]any      `json:"meta"`
+			HugoVersion modules.HugoVersion `json:"hugoVersion"`
+
+			Mounts []modMount `json:"mounts"`
+		}{
+			Path:        m.m.Path(),
+			Version:     m.m.Version(),
+			Time:        m.m.Time(),
+			Owner:       ownerPath,
+			Dir:         m.m.Dir(),
+			Meta:        config.Params,
+			HugoVersion: config.HugoVersion,
+			Mounts:      mounts,
+		})
+	}
+
 	return json.Marshal(&struct {
-		Path   string     `json:"path"`
-		Dir    string     `json:"dir"`
-		Mounts []modMount `json:"mounts"`
+		Path    string     `json:"path"`
+		Version string     `json:"version"`
+		Time    time.Time  `json:"time"`
+		Owner   string     `json:"owner"`
+		Dir     string     `json:"dir"`
+		Mounts  []modMount `json:"mounts"`
 	}{
-		Path:   m.m.Path(),
-		Dir:    m.m.Dir(),
-		Mounts: mounts,
+		Path:    m.m.Path(),
+		Version: m.m.Version(),
+		Time:    m.m.Time(),
+		Owner:   ownerPath,
+		Dir:     m.m.Dir(),
+		Mounts:  mounts,
 	})
+
 }

commands/convert.go

@@ -31,8 +31,6 @@ import (
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
 
-	"github.com/pkg/errors"
-
 	"github.com/gohugoio/hugo/hugolib"
 
 	"github.com/spf13/cobra"
@@ -102,7 +100,7 @@ func (cc *convertCmd) convertContents(format metadecoders.Format) error {
 		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
 	}
 
-	c, err := initializeConfig(true, false, &cc.hugoBuilderCommon, cc, nil)
+	c, err := initializeConfig(true, false, false, &cc.hugoBuilderCommon, cc, nil)
 	if err != nil {
 		return err
 	}
@@ -142,7 +140,7 @@ func (cc *convertCmd) convertAndSavePage(p page.Page, site *hugolib.Site, target
 		return nil
 	}
 
-	errMsg := fmt.Errorf("Error processing file %q", p.Path())
+	errMsg := fmt.Errorf("Error processing file %q", p.File().Path())
 
 	site.Log.Infoln("Attempting to convert", p.File().Filename())
 
@@ -185,15 +183,15 @@ func (cc *convertCmd) convertAndSavePage(p page.Page, site *hugolib.Site, target
 	newFilename := p.File().Filename()
 
 	if cc.outputDir != "" {
-		contentDir := strings.TrimSuffix(newFilename, p.Path())
+		contentDir := strings.TrimSuffix(newFilename, p.File().Path())
 		contentDir = filepath.Base(contentDir)
 
-		newFilename = filepath.Join(cc.outputDir, contentDir, p.Path())
+		newFilename = filepath.Join(cc.outputDir, contentDir, p.File().Path())
 	}
 
 	fs := hugofs.Os
 	if err := helpers.WriteToDisk(newFilename, &newContent, fs); err != nil {
-		return errors.Wrapf(err, "Failed to save file %q:", newFilename)
+		return fmt.Errorf("Failed to save file %q:: %w", newFilename, err)
 	}
 
 	return nil
@@ -202,7 +200,7 @@ func (cc *convertCmd) convertAndSavePage(p page.Page, site *hugolib.Site, target
 type parsedFile struct {
 	frontMatterFormat metadecoders.Format
 	frontMatterSource []byte
-	frontMatter       map[string]interface{}
+	frontMatter       map[string]any
 
 	// Everything after Front Matter
 	content []byte

commands/deploy.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !nodeploy
 // +build !nodeploy
 
 package commands
@@ -60,7 +61,7 @@ documentation.
 				c.Set("maxDeletes", cc.maxDeletes)
 				return nil
 			}
-			comm, err := initializeConfig(true, false, &cc.hugoBuilderCommon, cc, cfgInit)
+			comm, err := initializeConfig(true, true, false, &cc.hugoBuilderCommon, cc, cfgInit)
 			if err != nil {
 				return err
 			}

commands/gen.go

@@ -31,7 +31,6 @@ func newGenCmd() *genCmd {
 	})
 
 	cc.cmd.AddCommand(
-		newGenautocompleteCmd().getCommand(),
 		newGenDocCmd().getCommand(),
 		newGenManCmd().getCommand(),
 		createGenDocsHelper().getCommand(),

commands/genautocomplete.go

@@ -1,93 +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 (
-	"io"
-	"os"
-
-	"github.com/spf13/cobra"
-	jww "github.com/spf13/jwalterweatherman"
-)
-
-var _ cmder = (*genautocompleteCmd)(nil)
-
-type genautocompleteCmd struct {
-	autocompleteTarget string
-
-	// bash, zsh, fish or powershell
-	autocompleteType string
-
-	*baseCmd
-}
-
-func newGenautocompleteCmd() *genautocompleteCmd {
-	cc := &genautocompleteCmd{}
-
-	cc.baseCmd = newBaseCmd(&cobra.Command{
-		Use:   "autocomplete",
-		Short: "Generate shell autocompletion script for Hugo",
-		Long: `Generates a shell autocompletion script for Hugo.
-
-The script is written to the console (stdout).
-
-To write to file, add the ` + "`--completionfile=/path/to/file`" + ` flag.
-
-Add ` + "`--type={bash, zsh, fish or powershell}`" + ` flag to set alternative
-shell type.
-
-Logout and in again to reload the completion scripts,
-or just source them in directly:
-
-	$ . /etc/bash_completion or /path/to/file`,
-
-		RunE: func(cmd *cobra.Command, args []string) error {
-			var err error
-			var target io.Writer
-
-			if cc.autocompleteTarget == "" {
-				target = os.Stdout
-			} else {
-				target, _ = os.OpenFile(cc.autocompleteTarget, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-			}
-
-			switch cc.autocompleteType {
-			case "bash":
-				err = cmd.Root().GenBashCompletion(target)
-			case "zsh":
-				err = cmd.Root().GenZshCompletion(target)
-			case "fish":
-				err = cmd.Root().GenFishCompletion(target, true)
-			case "powershell":
-				err = cmd.Root().GenPowerShellCompletion(target)
-			default:
-				return newUserError("Unsupported completion type")
-			}
-
-			if err != nil {
-				return err
-			}
-
-			if cc.autocompleteTarget != "" {
-				jww.FEEDBACK.Println(cc.autocompleteType+" completion file for Hugo saved to", cc.autocompleteTarget)
-			}
-			return nil
-		},
-	})
-
-	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteTarget, "completionfile", "f", "", "autocompletion file, defaults to stdout")
-	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteType, "type", "t", "bash", "autocompletion type (bash, zsh, fish, or powershell)")
-
-	return cc
-}

commands/genchromastyles.go

@@ -16,9 +16,9 @@ package commands
 import (
 	"os"
 
-	"github.com/alecthomas/chroma"
-	"github.com/alecthomas/chroma/formatters/html"
-	"github.com/alecthomas/chroma/styles"
+	"github.com/alecthomas/chroma/v2"
+	"github.com/alecthomas/chroma/v2/formatters/html"
+	"github.com/alecthomas/chroma/v2/styles"
 	"github.com/spf13/cobra"
 )
 
@@ -37,9 +37,9 @@ func createGenChromaStyles() *genChromaStyles {
 		baseCmd: newBaseCmd(&cobra.Command{
 			Use:   "chromastyles",
 			Short: "Generate CSS stylesheet for the Chroma code highlighter",
-			Long: `Generate CSS stylesheet for the Chroma code highlighter for a given style. This stylesheet is needed if pygmentsUseClasses is enabled in config.
+			Long: `Generate CSS stylesheet for the Chroma code highlighter for a given style. This stylesheet is needed if markup.highlight.noClasses is disabled in config.
 
-See https://help.farbox.com/pygments.html for preview of available styles`,
+See https://xyproto.github.io/splash/docs/all.html for a preview of the available styles`,
 		}),
 	}
 
@@ -47,7 +47,7 @@ See https://help.farbox.com/pygments.html for preview of available styles`,
 		return g.generate()
 	}
 
-	g.cmd.PersistentFlags().StringVar(&g.style, "style", "friendly", "highlighter style (see https://help.farbox.com/pygments.html)")
+	g.cmd.PersistentFlags().StringVar(&g.style, "style", "friendly", "highlighter style (see https://xyproto.github.io/splash/docs/)")
 	g.cmd.PersistentFlags().StringVar(&g.highlightStyle, "highlightStyle", "bg:#ffffcc", "style used for highlighting lines (see https://github.com/alecthomas/chroma)")
 	g.cmd.PersistentFlags().StringVar(&g.linesStyle, "linesStyle", "", "style used for line numbers (see https://github.com/alecthomas/chroma)")
 

commands/gendoc.go

@@ -49,7 +49,7 @@ url: %s
 		Long: `Generate Markdown documentation for the Hugo CLI.
 
 This command is, mostly, used to create up-to-date documentation
-of Hugo's command-line interface for http://gohugo.io/.
+of Hugo's command-line interface for https://gohugo.io/.
 
 It creates one Markdown file per command with front matter suitable
 for rendering in Hugo.`,

commands/helpers.go

@@ -53,22 +53,22 @@ func (c commandError) isUserError() bool {
 	return c.userError
 }
 
-func newUserError(a ...interface{}) commandError {
+func newUserError(a ...any) commandError {
 	return commandError{s: fmt.Sprintln(a...), userError: true}
 }
 
-func newSystemError(a ...interface{}) commandError {
+func newSystemError(a ...any) commandError {
 	return commandError{s: fmt.Sprintln(a...), userError: false}
 }
 
-func newSystemErrorF(format string, a ...interface{}) commandError {
+func newSystemErrorF(format string, a ...any) commandError {
 	return commandError{s: fmt.Sprintf(format, a...), userError: false}
 }
 
 // Catch some of the obvious user errors from Cobra.
 // We don't want to show the usage message for every error.
 // The below may be to generic. Time will show.
-var userErrorRegexp = regexp.MustCompile("argument|flag|shorthand")
+var userErrorRegexp = regexp.MustCompile("unknown flag")
 
 func isUserError(err error) bool {
 	if cErr, ok := err.(commandError); ok && cErr.isUserError() {

commands/hugo.go

@@ -30,13 +30,18 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/gohugoio/hugo/hugofs/files"
+	"github.com/gohugoio/hugo/tpl"
+
+	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/htime"
+	"github.com/gohugoio/hugo/common/types"
+
 	"github.com/gohugoio/hugo/hugofs"
 
 	"github.com/gohugoio/hugo/resources/page"
 
-	"github.com/pkg/errors"
-
-	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/terminal"
 
@@ -113,19 +118,25 @@ func Execute(args []string) Response {
 }
 
 // InitializeConfig initializes a config file with sensible default configuration flags.
-func initializeConfig(mustHaveConfigFile, running bool,
+func initializeConfig(mustHaveConfigFile, failOnInitErr, running bool,
 	h *hugoBuilderCommon,
 	f flagsToConfigHandler,
 	cfgInit func(c *commandeer) error) (*commandeer, error) {
-	c, err := newCommandeer(mustHaveConfigFile, running, h, f, cfgInit)
+	c, err := newCommandeer(mustHaveConfigFile, failOnInitErr, running, h, f, cfgInit)
 	if err != nil {
 		return nil, err
 	}
 
+	if h := c.hugoTry(); h != nil {
+		for _, s := range h.Sites {
+			s.RegisterMediaTypes()
+		}
+	}
+
 	return c, nil
 }
 
-func (c *commandeer) createLogger(cfg config.Provider, running bool) (loggers.Logger, error) {
+func (c *commandeer) createLogger(cfg config.Provider) (loggers.Logger, error) {
 	var (
 		logHandle       = ioutil.Discard
 		logThreshold    = jww.LevelWarn
@@ -169,7 +180,7 @@ func (c *commandeer) createLogger(cfg config.Provider, running bool) (loggers.Lo
 	loggers.InitGlobalLogger(stdoutThreshold, logThreshold, outHandle, logHandle)
 	helpers.InitLoggers()
 
-	return loggers.NewLogger(stdoutThreshold, logThreshold, outHandle, logHandle, running), nil
+	return loggers.NewLogger(stdoutThreshold, logThreshold, outHandle, logHandle, c.running), nil
 }
 
 func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
@@ -184,6 +195,7 @@ func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
 		"buildDrafts",
 		"buildFuture",
 		"buildExpired",
+		"clock",
 		"uglyURLs",
 		"canonifyURLs",
 		"enableRobotsTXT",
@@ -194,7 +206,7 @@ func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
 		"forceSyncStatic",
 		"noTimes",
 		"noChmod",
-		"ignoreVendor",
+		"noBuildLock",
 		"ignoreVendorPaths",
 		"templateMetrics",
 		"templateMetricsHints",
@@ -212,7 +224,8 @@ func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
 		"dryRun",
 		"force",
 		"gc",
-		"i18n-warnings",
+		"printI18nWarnings",
+		"printUnusedTemplates",
 		"invalidateCDN",
 		"layoutDir",
 		"logFile",
@@ -239,8 +252,8 @@ func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
 
 	// Set some "config aliases"
 	setValueFromFlag(cmd.Flags(), "destination", cfg, "publishDir", false)
-	setValueFromFlag(cmd.Flags(), "i18n-warnings", cfg, "logI18nWarnings", false)
-	setValueFromFlag(cmd.Flags(), "path-warnings", cfg, "logPathWarnings", false)
+	setValueFromFlag(cmd.Flags(), "printI18nWarnings", cfg, "logI18nWarnings", false)
+	setValueFromFlag(cmd.Flags(), "printPathWarnings", cfg, "logPathWarnings", false)
 }
 
 func setValueFromFlag(flags *flag.FlagSet, key string, cfg config.Provider, targetKey string, force bool) {
@@ -271,11 +284,7 @@ func setValueFromFlag(flags *flag.FlagSet, key string, cfg config.Provider, targ
 	}
 }
 
-func isTerminal() bool {
-	return terminal.IsTerminal(os.Stdout)
-}
-
-func (c *commandeer) fullBuild() error {
+func (c *commandeer) fullBuild(noBuildLock bool) error {
 	var (
 		g         errgroup.Group
 		langCount map[string]uint64
@@ -283,7 +292,8 @@ func (c *commandeer) fullBuild() error {
 
 	if !c.h.quiet {
 		fmt.Println("Start building sites … ")
-		if isTerminal() {
+		fmt.Println(hugo.BuildVersionString())
+		if terminal.IsTerminal(os.Stdout) {
 			defer func() {
 				fmt.Print(showCursor + clearLine)
 			}()
@@ -293,14 +303,14 @@ func (c *commandeer) fullBuild() error {
 	copyStaticFunc := func() error {
 		cnt, err := c.copyStatic()
 		if err != nil {
-			return errors.Wrap(err, "Error copying static files")
+			return fmt.Errorf("Error copying static files: %w", err)
 		}
 		langCount = cnt
 		return nil
 	}
 	buildSitesFunc := func() error {
-		if err := c.buildSites(); err != nil {
-			return errors.Wrap(err, "Error building site")
+		if err := c.buildSites(noBuildLock); err != nil {
+			return fmt.Errorf("Error building site: %w", err)
 		}
 		return nil
 	}
@@ -347,10 +357,10 @@ func (c *commandeer) initCPUProfile() (func(), error) {
 
 	f, err := os.Create(c.h.cpuprofile)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create CPU profile")
+		return nil, fmt.Errorf("failed to create CPU profile: %w", err)
 	}
 	if err := pprof.StartCPUProfile(f); err != nil {
-		return nil, errors.Wrap(err, "failed to start CPU profile")
+		return nil, fmt.Errorf("failed to start CPU profile: %w", err)
 	}
 	return func() {
 		pprof.StopCPUProfile()
@@ -381,11 +391,11 @@ func (c *commandeer) initTraceProfile() (func(), error) {
 
 	f, err := os.Create(c.h.traceprofile)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create trace file")
+		return nil, fmt.Errorf("failed to create trace file: %w", err)
 	}
 
 	if err := trace.Start(f); err != nil {
-		return nil, errors.Wrap(err, "failed to start trace")
+		return nil, fmt.Errorf("failed to start trace: %w", err)
 	}
 
 	return func() {
@@ -492,22 +502,26 @@ func (c *commandeer) build() error {
 		}
 	}()
 
-	if err := c.fullBuild(); err != nil {
+	if err := c.fullBuild(false); err != nil {
 		return err
 	}
 
-	// TODO(bep) Feedback?
 	if !c.h.quiet {
 		fmt.Println()
 		c.hugo().PrintProcessingStats(os.Stdout)
 		fmt.Println()
 
-		if createCounter, ok := c.destinationFs.(hugofs.DuplicatesReporter); ok {
+		if createCounter, ok := c.publishDirFs.(hugofs.DuplicatesReporter); ok {
 			dupes := createCounter.ReportDuplicates()
 			if dupes != "" {
 				c.logger.Warnln("Duplicate target paths:", dupes)
 			}
 		}
+
+		unusedTemplates := c.hugo().Tmpl().(tpl.UnusedTemplatesProvider).UnusedTemplates()
+		for _, unusedTemplate := range unusedTemplates {
+			c.logger.Warnf("Template %s is unused, source file %s", unusedTemplate.Name(), unusedTemplate.Filename())
+		}
 	}
 
 	if c.h.buildWatch {
@@ -521,7 +535,7 @@ func (c *commandeer) build() error {
 
 		c.logger.Printf("Watching for changes in %s%s{%s}\n", baseWatchDir, helpers.FilePathSeparator, rootWatchDirs)
 		c.logger.Println("Press Ctrl+C to stop")
-		watcher, err := c.newWatcher(watchDirs...)
+		watcher, err := c.newWatcher(c.h.poll, watchDirs...)
 		checkErr(c.Logger, err)
 		defer watcher.Close()
 
@@ -535,8 +549,6 @@ func (c *commandeer) build() error {
 }
 
 func (c *commandeer) serverBuild() error {
-	defer c.timeTrack(time.Now(), "Built")
-
 	stopProfiling, err := c.initProfiling()
 	if err != nil {
 		return err
@@ -548,7 +560,7 @@ func (c *commandeer) serverBuild() error {
 		}
 	}()
 
-	if err := c.fullBuild(); err != nil {
+	if err := c.fullBuild(false); err != nil {
 		return err
 	}
 
@@ -625,11 +637,7 @@ func chmodFilter(dst, src os.FileInfo) bool {
 }
 
 func (c *commandeer) copyStaticTo(sourceFs *filesystems.SourceFilesystem) (uint64, error) {
-	publishDir := c.hugo().PathSpec.PublishDir
-	// If root, remove the second '/'
-	if publishDir == "//" {
-		publishDir = helpers.FilePathSeparator
-	}
+	publishDir := helpers.FilePathSeparator
 
 	if sourceFs.PublishFolder != "" {
 		publishDir = filepath.Join(publishDir, sourceFs.PublishFolder)
@@ -642,7 +650,10 @@ func (c *commandeer) copyStaticTo(sourceFs *filesystems.SourceFilesystem) (uint6
 	syncer.NoChmod = c.Cfg.GetBool("noChmod")
 	syncer.ChmodFilter = chmodFilter
 	syncer.SrcFs = fs
-	syncer.DestFs = c.Fs.Destination
+	syncer.DestFs = c.Fs.PublishDir
+	if c.renderStaticToDisk {
+		syncer.DestFs = c.Fs.PublishDirStatic
+	}
 	// Now that we are using a unionFs for the static directories
 	// We can effectively clean the publishDir on initial sync
 	syncer.Delete = c.Cfg.GetBool("cleanDestinationDir")
@@ -674,6 +685,10 @@ func (c *commandeer) firstPathSpec() *helpers.PathSpec {
 }
 
 func (c *commandeer) timeTrack(start time.Time, name string) {
+	// Note the use of time.Since here and time.Now in the callers.
+	// We have a htime.Sinnce, but that may be adjusted to the future,
+	// and that does not make sense here, esp. when used before the
+	// global Clock is initialized.
 	elapsed := time.Since(start)
 	c.logger.Printf("%s in %v ms", name, int(1000*elapsed.Seconds()))
 }
@@ -694,7 +709,7 @@ func (c *commandeer) getDirList() ([]string, error) {
 				return filepath.SkipDir
 			}
 
-			filenames = append(filenames, fi.Meta().Filename())
+			filenames = append(filenames, fi.Meta().Filename)
 		}
 
 		return nil
@@ -703,7 +718,7 @@ func (c *commandeer) getDirList() ([]string, error) {
 	watchFiles := c.hugo().PathSpec.BaseFs.WatchDirs()
 	for _, fi := range watchFiles {
 		if !fi.IsDir() {
-			filenames = append(filenames, fi.Meta().Filename())
+			filenames = append(filenames, fi.Meta().Filename)
 			continue
 		}
 
@@ -718,23 +733,22 @@ func (c *commandeer) getDirList() ([]string, error) {
 	return filenames, nil
 }
 
-func (c *commandeer) buildSites() (err error) {
-	return c.hugo().Build(hugolib.BuildCfg{})
+func (c *commandeer) buildSites(noBuildLock bool) (err error) {
+	return c.hugo().Build(hugolib.BuildCfg{NoBuildLock: noBuildLock})
 }
 
 func (c *commandeer) handleBuildErr(err error, msg string) {
 	c.buildErr = err
-
-	c.logger.Errorln(msg + ":\n")
-	c.logger.Errorln(helpers.FirstUpper(err.Error()))
-	if !c.h.quiet && c.h.verbose {
-		herrors.PrintStackTraceFromErr(err)
-	}
+	c.logger.Errorln(msg + ": " + cleanErrorLog(err.Error()))
 }
 
 func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
-	defer c.timeTrack(time.Now(), "Total")
-
+	if c.buildErr != nil {
+		ferrs := herrors.UnwrapFileErrorsWithErrorContext(c.buildErr)
+		for _, err := range ferrs {
+			events = append(events, fsnotify.Event{Name: err.Position().Filename, Op: fsnotify.Write})
+		}
+	}
 	c.buildErr = nil
 	visited := c.visitedURLs.PeekAllSet()
 	if c.fastRenderMode {
@@ -748,7 +762,7 @@ func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
 			visited[home] = true
 		}
 	}
-	return c.hugo().Build(hugolib.BuildCfg{RecentlyVisited: visited, ErrRecovery: c.wasError}, events...)
+	return c.hugo().Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: visited, ErrRecovery: c.wasError}, events...)
 }
 
 func (c *commandeer) partialReRender(urls ...string) error {
@@ -760,7 +774,9 @@ func (c *commandeer) partialReRender(urls ...string) error {
 	for _, url := range urls {
 		visited[url] = true
 	}
-	return c.hugo().Build(hugolib.BuildCfg{RecentlyVisited: visited, PartialReRender: true, ErrRecovery: c.wasError})
+
+	// Note: We do not set NoBuildLock as the file lock is not acquired at this stage.
+	return c.hugo().Build(hugolib.BuildCfg{NoBuildLock: false, RecentlyVisited: visited, PartialReRender: true, ErrRecovery: c.wasError})
 }
 
 func (c *commandeer) fullRebuild(changeType string) {
@@ -790,7 +806,7 @@ func (c *commandeer) fullRebuild(changeType string) {
 		defer c.timeTrack(time.Now(), "Rebuilt")
 
 		c.commandeerHugoState = newCommandeerHugoState()
-		err := c.loadConfig(true, true)
+		err := c.loadConfig()
 		if err != nil {
 			// Set the processing on pause until the state is recovered.
 			c.paused = true
@@ -807,7 +823,7 @@ func (c *commandeer) fullRebuild(changeType string) {
 				return
 			}
 
-			err = c.buildSites()
+			err = c.buildSites(true)
 			if err != nil {
 				c.logger.Errorln(err)
 			} else if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
@@ -818,7 +834,7 @@ func (c *commandeer) fullRebuild(changeType string) {
 }
 
 // newWatcher creates a new watcher to watch filesystem events.
-func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
+func (c *commandeer) newWatcher(pollIntervalStr string, dirList ...string) (*watcher.Batcher, error) {
 	if runtime.GOOS == "darwin" {
 		tweakLimit()
 	}
@@ -828,13 +844,32 @@ func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
 		return nil, err
 	}
 
-	watcher, err := watcher.New(1 * time.Second)
+	var pollInterval time.Duration
+	poll := pollIntervalStr != ""
+	if poll {
+		pollInterval, err = types.ToDurationE(pollIntervalStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid value for flag poll: %s", err)
+		}
+		c.logger.Printf("Use watcher with poll interval %v", pollInterval)
+	}
+
+	if pollInterval == 0 {
+		pollInterval = 500 * time.Millisecond
+	}
+
+	watcher, err := watcher.New(500*time.Millisecond, pollInterval, poll)
 	if err != nil {
 		return nil, err
 	}
 
+	spec := c.hugo().Deps.SourceSpec
+
 	for _, d := range dirList {
 		if d != "" {
+			if spec.IgnoreFile(d) {
+				continue
+			}
 			_ = watcher.Add(d)
 		}
 	}
@@ -852,13 +887,19 @@ func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
 		for {
 			select {
 			case evs := <-watcher.Events:
+				unlock, err := c.buildLock()
+				if err != nil {
+					c.logger.Errorln("Failed to acquire a build lock: %s", err)
+					return
+				}
 				c.handleEvents(watcher, staticSyncer, evs, configSet)
 				if c.showErrorInBrowser && c.errCount() > 0 {
 					// Need to reload browser to show the error
 					livereload.ForceRefresh()
 				}
-			case err := <-watcher.Errors:
-				if err != nil {
+				unlock()
+			case err := <-watcher.Errors():
+				if err != nil && !os.IsNotExist(err) {
 					c.logger.Errorln("Error while watching:", err)
 				}
 			}
@@ -877,7 +918,7 @@ func (c *commandeer) printChangeDetected(typ string) {
 
 	c.logger.Println(msg)
 	const layout = "2006-01-02 15:04:05.000 -0700"
-	c.logger.Println(time.Now().Format(layout))
+	c.logger.Println(htime.Now().Format(layout))
 }
 
 const (
@@ -1110,9 +1151,13 @@ func (c *commandeer) handleEvents(watcher *watcher.Batcher,
 
 		c.printChangeDetected("")
 		c.changeDetector.PrepareNew()
-		if err := c.rebuildSites(dynamicEvents); err != nil {
-			c.handleBuildErr(err, "Rebuild failed")
-		}
+
+		func() {
+			defer c.timeTrack(time.Now(), "Total")
+			if err := c.rebuildSites(dynamicEvents); err != nil {
+				c.handleBuildErr(err, "Rebuild failed")
+			}
+		}()
 
 		if doLiveReload {
 			if len(partitionedEvents.ContentEvents) == 0 && len(partitionedEvents.AssetEvents) > 0 {
@@ -1177,12 +1222,16 @@ func partitionDynamicEvents(sourceFs *filesystems.SourceFilesystems, events []fs
 func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
 	name := ""
 
-	// Some editors (for example notepad.exe on Windows) triggers a change
-	// both for directory and file. So we pick the longest path, which should
-	// be the file itself.
 	for _, ev := range events {
-		if (ev.Op&fsnotify.Write == fsnotify.Write || ev.Op&fsnotify.Create == fsnotify.Create) && len(ev.Name) > len(name) {
-			name = ev.Name
+		if ev.Op&fsnotify.Write == fsnotify.Write || ev.Op&fsnotify.Create == fsnotify.Create {
+			if files.IsIndexContentFile(ev.Name) {
+				return ev.Name
+			}
+
+			if files.IsContentFile(ev.Name) {
+				name = ev.Name
+			}
+
 		}
 	}
 

commands/hugo_test.go

@@ -14,34 +14,193 @@
 package commands
 
 import (
+	"bytes"
+	"fmt"
+	"math/rand"
+	"path/filepath"
+	"strings"
 	"testing"
 
+	"github.com/bep/clock"
 	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/common/htime"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/afero"
+	"golang.org/x/tools/txtar"
 )
 
 // Issue #5662
 func TestHugoWithContentDirOverride(t *testing.T) {
+	t.Parallel()
 	c := qt.New(t)
 
+	files := `
+-- config.toml --
+baseURL = "https://example.org"
+title = "Hugo Commands"
+-- mycontent/p1.md --
+---
+title: "P1"
+---
+-- layouts/_default/single.html --
+Page: {{ .Title }}|
+
+`
+	s := newTestHugoCmdBuilder(c, files, []string{"-c", "mycontent"}).Build()
+	s.AssertFileContent("public/p1/index.html", `Page: P1|`)
+
+}
+
+// Issue #9794
+func TestHugoStaticFilesMultipleStaticAndManyFolders(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	files := `
+-- config.toml --
+baseURL = "https://example.org"
+theme = "mytheme"
+-- layouts/index.html --
+Home.
+
+`
+	const (
+		numDirs     = 33
+		numFilesMax = 12
+	)
+
+	r := rand.New(rand.NewSource(32))
+
+	for i := 0; i < numDirs; i++ {
+		for j := 0; j < r.Intn(numFilesMax); j++ {
+			if j%3 == 0 {
+				files += fmt.Sprintf("-- themes/mytheme/static/d%d/f%d.txt --\nHellot%d-%d\n", i, j, i, j)
+				files += fmt.Sprintf("-- themes/mytheme/static/d%d/ft%d.txt --\nHellot%d-%d\n", i, j, i, j)
+			}
+			files += fmt.Sprintf("-- static/d%d/f%d.txt --\nHello%d-%d\n", i, j, i, j)
+		}
+	}
+
+	r = rand.New(rand.NewSource(32))
+
+	s := newTestHugoCmdBuilder(c, files, []string{"-c", "mycontent"}).Build()
+	for i := 0; i < numDirs; i++ {
+		for j := 0; j < r.Intn(numFilesMax); j++ {
+			if j%3 == 0 {
+				if j%3 == 0 {
+					s.AssertFileContent(fmt.Sprintf("public/d%d/ft%d.txt", i, j), fmt.Sprintf("Hellot%d-%d", i, j))
+				}
+				s.AssertFileContent(fmt.Sprintf("public/d%d/f%d.txt", i, j), fmt.Sprintf("Hello%d-%d", i, j))
+			}
+		}
+	}
+
+}
+
+// Issue #8787
+func TestHugoListCommandsWithClockFlag(t *testing.T) {
+	t.Cleanup(func() { htime.Clock = clock.System() })
+
+	c := qt.New(t)
+
+	files := `
+-- config.toml --
+baseURL = "https://example.org"
+title = "Hugo Commands"
+timeZone = "UTC"
+-- content/past.md --
+---
+title: "Past"
+date: 2000-11-06
+---
+-- content/future.md --
+---
+title: "Future"
+date: 2200-11-06
+---
+-- layouts/_default/single.html --
+Page: {{ .Title }}|
+
+`
+	s := newTestHugoCmdBuilder(c, files, []string{"list", "future"})
+	s.captureOut = true
+	s.Build()
+	p := filepath.Join("content", "future.md")
+	s.AssertStdout(p + ",2200-11-06T00:00:00Z")
+
+	s = newTestHugoCmdBuilder(c, files, []string{"list", "future", "--clock", "2300-11-06"}).Build()
+	s.AssertStdout("")
+}
+
+type testHugoCmdBuilder struct {
+	*qt.C
+
+	fs    afero.Fs
+	dir   string
+	files string
+	args  []string
+
+	captureOut bool
+	out        string
+}
+
+func newTestHugoCmdBuilder(c *qt.C, files string, args []string) *testHugoCmdBuilder {
+	s := &testHugoCmdBuilder{C: c, files: files, args: args}
+	s.dir = s.TempDir()
+	s.fs = afero.NewBasePathFs(hugofs.Os, s.dir)
+
+	return s
+}
+
+func (s *testHugoCmdBuilder) Build() *testHugoCmdBuilder {
+	data := txtar.Parse([]byte(s.files))
+
+	for _, f := range data.Files {
+		filename := filepath.Clean(f.Name)
+		data := bytes.TrimSuffix(f.Data, []byte("\n"))
+		s.Assert(s.fs.MkdirAll(filepath.Dir(filename), 0777), qt.IsNil)
+		s.Assert(afero.WriteFile(s.fs, filename, data, 0666), qt.IsNil)
+	}
+
 	hugoCmd := newCommandsBuilder().addAll().build()
 	cmd := hugoCmd.getCommand()
+	args := append(s.args, "-s="+s.dir, "--quiet")
+	cmd.SetArgs(args)
 
-	contentDir := "contentOverride"
+	if s.captureOut {
+		out, err := captureStdout(func() error {
+			_, err := cmd.ExecuteC()
+			return err
+		})
+		s.Assert(err, qt.IsNil)
+		s.out = out
+	} else {
+		_, err := cmd.ExecuteC()
+		s.Assert(err, qt.IsNil)
+	}
 
-	cfgStr := `
-
-baseURL = "https://example.org"
-title = "Hugo Commands"
-
-contentDir = "thisdoesnotexist"
-
-`
-	dir, clean, err := createSimpleTestSite(t, testSiteConfig{configTOML: cfgStr, contentDir: contentDir})
-	c.Assert(err, qt.IsNil)
-	defer clean()
-
-	cmd.SetArgs([]string{"-s=" + dir, "-c=" + contentDir})
-
-	_, err = cmd.ExecuteC()
-	c.Assert(err, qt.IsNil)
+	return s
+}
+
+func (s *testHugoCmdBuilder) AssertFileContent(filename string, matches ...string) {
+	s.Helper()
+	data, err := afero.ReadFile(s.fs, filename)
+	s.Assert(err, qt.IsNil)
+	content := strings.TrimSpace(string(data))
+	for _, m := range matches {
+		lines := strings.Split(m, "\n")
+		for _, match := range lines {
+			match = strings.TrimSpace(match)
+			if match == "" || strings.HasPrefix(match, "#") {
+				continue
+			}
+			s.Assert(content, qt.Contains, match, qt.Commentf(m))
+		}
+	}
+}
+
+func (s *testHugoCmdBuilder) AssertStdout(match string) {
+	s.Helper()
+	content := strings.TrimSpace(s.out)
+	s.Assert(content, qt.Contains, strings.TrimSpace(match))
 }

commands/hugo_windows.go

@@ -13,7 +13,13 @@
 
 package commands
 
-import "github.com/spf13/cobra"
+import (
+	// For time zone lookups on Windows without Go installed.
+	// See #8892
+	_ "time/tzdata"
+
+	"github.com/spf13/cobra"
+)
 
 func init() {
 	// This message to show to Windows users if Hugo is opened from explorer.exe

commands/import_jekyll.go

@@ -28,6 +28,7 @@ import (
 
 	"github.com/gohugoio/hugo/parser/pageparser"
 
+	"github.com/gohugoio/hugo/common/htime"
 	"github.com/gohugoio/hugo/common/hugio"
 
 	"github.com/gohugoio/hugo/parser/metadecoders"
@@ -35,7 +36,6 @@ import (
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/parser"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
@@ -201,12 +201,7 @@ func (i *importCmd) retrieveJekyllPostDir(fs afero.Fs, dir string) (bool, bool)
 }
 
 func (i *importCmd) createSiteFromJekyll(jekyllRoot, targetDir string, jekyllPostDirs map[string]bool, force bool) error {
-	s, err := hugolib.NewSiteDefaultLang()
-	if err != nil {
-		return err
-	}
-
-	fs := s.Fs.Source
+	fs := &afero.OsFs{}
 	if exists, _ := helpers.Exists(targetDir, fs); exists {
 		if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
 			return errors.New("target path \"" + targetDir + "\" exists but is not a directory")
@@ -235,7 +230,7 @@ func (i *importCmd) createSiteFromJekyll(jekyllRoot, targetDir string, jekyllPos
 	return nil
 }
 
-func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]interface{} {
+func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]any {
 	path := filepath.Join(jekyllRoot, "_config.yml")
 
 	exists, err := helpers.Exists(path, fs)
@@ -265,7 +260,7 @@ func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]
 	return c
 }
 
-func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]interface{}) (err error) {
+func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]any) (err error) {
 	title := "My New Hugo Site"
 	baseURL := "http://example.org/"
 
@@ -285,7 +280,7 @@ func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind meta
 		}
 	}
 
-	in := map[string]interface{}{
+	in := map[string]any{
 		"baseURL":            baseURL,
 		"title":              title,
 		"languageCode":       "en-us",
@@ -362,12 +357,12 @@ func parseJekyllFilename(filename string) (time.Time, string, error) {
 	re := regexp.MustCompile(`(\d+-\d+-\d+)-(.+)\..*`)
 	r := re.FindAllStringSubmatch(filename, -1)
 	if len(r) == 0 {
-		return time.Now(), "", errors.New("filename not match")
+		return htime.Now(), "", errors.New("filename not match")
 	}
 
 	postDate, err := time.Parse("2006-1-2", r[0][1])
 	if err != nil {
-		return time.Now(), "", err
+		return htime.Now(), "", err
 	}
 
 	postName := r[0][2]
@@ -423,7 +418,7 @@ func convertJekyllPost(path, relPath, targetDir string, draft bool) error {
 	return nil
 }
 
-func convertJekyllMetaData(m interface{}, postName string, postDate time.Time, draft bool) (interface{}, error) {
+func convertJekyllMetaData(m any, postName string, postDate time.Time, draft bool) (any, error) {
 	metadata, err := maps.ToStringMapE(m)
 	if err != nil {
 		return nil, err
@@ -475,7 +470,7 @@ func convertJekyllMetaData(m interface{}, postName string, postDate time.Time, d
 	return metadata, nil
 }
 
-func convertJekyllContent(m interface{}, content string) (string, error) {
+func convertJekyllContent(m any, content string) (string, error) {
 	metadata, _ := maps.ToStringMapE(m)
 
 	lines := strings.Split(content, "\n")

commands/import_jekyll_test.go

@@ -47,44 +47,44 @@ func TestParseJekyllFilename(t *testing.T) {
 func TestConvertJekyllMetadata(t *testing.T) {
 	c := qt.New(t)
 	testDataList := []struct {
-		metadata interface{}
+		metadata any
 		postName string
 		postDate time.Time
 		draft    bool
 		expect   string
 	}{
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z"}`,
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
 			`{"date":"2015-10-01T00:00:00Z","draft":true}`,
 		},
 		{
-			map[interface{}]interface{}{"Permalink": "/permalink.html", "layout": "post"},
+			map[any]any{"Permalink": "/permalink.html", "layout": "post"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
 		},
 		{
-			map[interface{}]interface{}{"permalink": "/permalink.html"},
+			map[any]any{"permalink": "/permalink.html"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
 		},
 		{
-			map[interface{}]interface{}{"category": nil, "permalink": 123},
+			map[any]any{"category": nil, "permalink": 123},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z"}`,
 		},
 		{
-			map[interface{}]interface{}{"Excerpt_Separator": "sep"},
+			map[any]any{"Excerpt_Separator": "sep"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z","excerpt_separator":"sep"}`,
 		},
 		{
-			map[interface{}]interface{}{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
+			map[any]any{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z"}`,
 		},
@@ -102,69 +102,69 @@ func TestConvertJekyllMetadata(t *testing.T) {
 func TestConvertJekyllContent(t *testing.T) {
 	c := qt.New(t)
 	testDataList := []struct {
-		metadata interface{}
+		metadata any
 		content  string
 		expect   string
 	}{
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"Test content\r\n<!-- more -->\npart2 content", "Test content\n<!--more-->\npart2 content",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"Test content\n<!-- More -->\npart2 content", "Test content\n<!--more-->\npart2 content",
 		},
 		{
-			map[interface{}]interface{}{"excerpt_separator": "<!--sep-->"},
+			map[any]any{"excerpt_separator": "<!--sep-->"},
 			"Test content\n<!--sep-->\npart2 content",
 			"---\nexcerpt_separator: <!--sep-->\n---\nTest content\n<!--more-->\npart2 content",
 		},
-		{map[interface{}]interface{}{}, "{% raw %}text{% endraw %}", "text"},
-		{map[interface{}]interface{}{}, "{%raw%} text2 {%endraw %}", "text2"},
+		{map[any]any{}, "{% raw %}text{% endraw %}", "text"},
+		{map[any]any{}, "{%raw%} text2 {%endraw %}", "text2"},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% highlight go %}\nvar s int\n{% endhighlight %}",
 			"{{< highlight go >}}\nvar s int\n{{< / highlight >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% 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{}{},
+			map[any]any{},
 			"{% img http://placekitten.com/890/280 %}",
 			"{{< figure src=\"http://placekitten.com/890/280\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img left http://placekitten.com/320/250 Place Kitten #2 %}",
 			"{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #3' %}",
 			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #3\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
 			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
 			"{{< figure src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img right /placekitten/300/500 'Place Kitten #4' 'An image of a very cute kitten' %}",
 			"{{< figure class=\"right\" src=\"/placekitten/300/500\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
 		},
 		{
-			map[interface{}]interface{}{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
+			map[any]any{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
 			"somecontent",
 			"---\nDate: \"2015-10-01 12:13:11\"\ncategory: book\nlayout: post\n---\nsomecontent",
 		},

commands/limit_others.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !darwin
 // +build !darwin
 
 package commands

commands/list.go

@@ -32,7 +32,7 @@ type listCmd struct {
 	*baseBuilderCmd
 }
 
-func (lc *listCmd) buildSites(config map[string]interface{}) (*hugolib.HugoSites, error) {
+func (lc *listCmd) buildSites(config map[string]any) (*hugolib.HugoSites, error) {
 	cfgInit := func(c *commandeer) error {
 		for key, value := range config {
 			c.Set(key, value)
@@ -40,7 +40,7 @@ func (lc *listCmd) buildSites(config map[string]interface{}) (*hugolib.HugoSites
 		return nil
 	}
 
-	c, err := initializeConfig(true, false, &lc.hugoBuilderCommon, lc, cfgInit)
+	c, err := initializeConfig(true, true, false, &lc.hugoBuilderCommon, lc, cfgInit)
 	if err != nil {
 		return nil, err
 	}
@@ -75,7 +75,7 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Short: "List all drafts",
 			Long:  `List all of the drafts in your content directory.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				sites, err := cc.buildSites(map[string]interface{}{"buildDrafts": true})
+				sites, err := cc.buildSites(map[string]any{"buildDrafts": true})
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -94,7 +94,11 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Short: "List all posts dated in the future",
 			Long:  `List all of the posts in your content directory which will be posted in the future.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				sites, err := cc.buildSites(map[string]interface{}{"buildFuture": true})
+				sites, err := cc.buildSites(map[string]any{"buildFuture": true})
+				if err != nil {
+					return newSystemError("Error building sites", err)
+				}
+
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -122,7 +126,11 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Short: "List all posts already expired",
 			Long:  `List all of the posts in your content directory which has already expired.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				sites, err := cc.buildSites(map[string]interface{}{"buildExpired": true})
+				sites, err := cc.buildSites(map[string]any{"buildExpired": true})
+				if err != nil {
+					return newSystemError("Error building sites", err)
+				}
+
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -150,7 +158,7 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Short: "List all posts",
 			Long:  `List all of the posts in your content directory, include drafts, future and expired pages.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				sites, err := cc.buildSites(map[string]interface{}{
+				sites, err := cc.buildSites(map[string]any{
 					"buildExpired": true,
 					"buildDrafts":  true,
 					"buildFuture":  true,

commands/list_test.go

@@ -29,17 +29,14 @@ func captureStdout(f func() error) (string, error) {
 
 func TestListAll(t *testing.T) {
 	c := qt.New(t)
-	dir, clean, err := createSimpleTestSite(t, testSiteConfig{})
-	defer clean()
-
-	c.Assert(err, qt.IsNil)
+	dir := createSimpleTestSite(t, testSiteConfig{})
 
 	hugoCmd := newCommandsBuilder().addAll().build()
 	cmd := hugoCmd.getCommand()
 
-	defer func() {
+	t.Cleanup(func() {
 		os.RemoveAll(dir)
-	}()
+	})
 
 	cmd.SetArgs([]string{"-s=" + dir, "list", "all"})
 

commands/mod.go

@@ -71,11 +71,12 @@ Also note that if you configure a positive maxAge for the "modules" file cache,
 			if all {
 				com, err := c.initConfig(false)
 
-				if err != nil && !moduleNotFoundRe.MatchString(err.Error()) {
+				if err != nil && com == nil {
 					return err
 				}
 
-				_, err = com.hugo().FileCaches.ModulesCache().Prune(true)
+				count, err := com.hugo().FileCaches.ModulesCache().Prune(true)
+				com.logger.Printf("Deleted %d files from module cache.", count)
 				return err
 			}
 			return c.withModsClient(true, func(c *modules.Client) error {
@@ -95,7 +96,7 @@ func (b *commandsBuilder) newModCmd() *modCmd {
 
 	const commonUsage = `
 Note that Hugo will always start out by resolving the components defined in the site
-configuration, provided by a _vendor directory (if no --ignoreVendor flag provided),
+configuration, provided by a _vendor directory (if no --ignoreVendorPaths flag provided),
 Go Modules, or a folder inside the themes directory, in that order.
 
 See https://gohugo.io/hugo-modules/ for more information.
@@ -284,7 +285,7 @@ func (c *modCmd) withHugo(f func(*hugolib.HugoSites) error) error {
 }
 
 func (c *modCmd) initConfig(failOnNoConfig bool) (*commandeer, error) {
-	com, err := initializeConfig(failOnNoConfig, false, &c.hugoBuilderCommon, c, nil)
+	com, err := initializeConfig(failOnNoConfig, false, false, &c.hugoBuilderCommon, c, nil)
 	if err != nil {
 		return nil, err
 	}

commands/new.go

@@ -71,7 +71,7 @@ func (n *newCmd) newContent(cmd *cobra.Command, args []string) error {
 		return nil
 	}
 
-	c, err := initializeConfig(true, false, &n.hugoBuilderCommon, n, cfgInit)
+	c, err := initializeConfig(true, true, false, &n.hugoBuilderCommon, n, cfgInit)
 	if err != nil {
 		return err
 	}
@@ -80,17 +80,7 @@ func (n *newCmd) newContent(cmd *cobra.Command, args []string) error {
 		return newUserError("path needs to be provided")
 	}
 
-	createPath := args[0]
-
-	var kind string
-
-	createPath, kind = newContentPathSection(c.hugo(), createPath)
-
-	if n.contentType != "" {
-		kind = n.contentType
-	}
-
-	return create.NewContent(c.hugo(), kind, createPath)
+	return create.NewContent(c.hugo(), n.contentType, args[0])
 }
 
 func mkdir(x ...string) {
@@ -118,7 +108,7 @@ func newContentPathSection(h *hugolib.HugoSites, path string) (string, string) {
 
 	if h != nil {
 		for _, dir := range h.BaseFs.Content.Dirs {
-			createpath = strings.TrimPrefix(createpath, dir.Meta().Filename())
+			createpath = strings.TrimPrefix(createpath, dir.Meta().Filename)
 		}
 	}
 

commands/new_site.go

@@ -16,20 +16,19 @@ package commands
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"path/filepath"
 	"strings"
 
+	"github.com/gohugoio/hugo/config"
 	"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"
 	"github.com/gohugoio/hugo/parser"
 	"github.com/spf13/cobra"
 	jww "github.com/spf13/jwalterweatherman"
-	"github.com/spf13/viper"
 )
 
 var _ cmder = (*newSiteCmd)(nil)
@@ -52,7 +51,7 @@ Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 		RunE: cc.newSite,
 	}
 
-	cmd.Flags().StringVarP(&cc.configFormat, "format", "f", "toml", "config & frontmatter format")
+	cmd.Flags().StringVarP(&cc.configFormat, "format", "f", "toml", "config file format")
 	cmd.Flags().Bool("force", false, "init inside non-empty directory")
 
 	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
@@ -94,7 +93,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 _errors.Wrap(err, "Failed to create dir")
+			return fmt.Errorf("Failed to create dir: %w", err)
 		}
 	}
 
@@ -102,7 +101,7 @@ func (n *newSiteCmd) doNewSite(fs *hugofs.Fs, basepath string, force bool) error
 
 	// Create a default archetype file.
 	helpers.SafeWriteToDisk(filepath.Join(archeTypePath, "default.md"),
-		strings.NewReader(create.ArchetypeTemplateTemplate), fs.Source)
+		strings.NewReader(create.DefaultArchetypeTemplateTemplate), fs.Source)
 
 	jww.FEEDBACK.Printf("Congratulations! Your new Hugo site is created in %s.\n\n", basepath)
 	jww.FEEDBACK.Println(nextStepsText())
@@ -122,8 +121,10 @@ func (n *newSiteCmd) newSite(cmd *cobra.Command, args []string) error {
 	}
 
 	forceNew, _ := cmd.Flags().GetBool("force")
-
-	return n.doNewSite(hugofs.NewDefault(viper.New()), createpath, forceNew)
+	cfg := config.New()
+	cfg.Set("workingDir", createpath)
+	cfg.Set("publishDir", "public")
+	return n.doNewSite(hugofs.NewDefault(cfg), createpath, forceNew)
 }
 
 func createConfig(fs *hugofs.Fs, inpath string, kind string) (err error) {

commands/new_theme.go

@@ -18,8 +18,8 @@ import (
 	"errors"
 	"path/filepath"
 	"strings"
-	"time"
 
+	"github.com/gohugoio/hugo/common/htime"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/spf13/cobra"
@@ -52,7 +52,7 @@ as you see fit.`,
 
 // newTheme creates a new Hugo theme template
 func (n *newThemeCmd) newTheme(cmd *cobra.Command, args []string) error {
-	c, err := initializeConfig(false, false, &n.hugoBuilderCommon, n, nil)
+	c, err := initializeConfig(false, false, false, &n.hugoBuilderCommon, n, nil)
 	if err != nil {
 		return err
 	}
@@ -113,7 +113,7 @@ func (n *newThemeCmd) newTheme(cmd *cobra.Command, args []string) error {
 
 	by := []byte(`The MIT License (MIT)
 
-Copyright (c) ` + time.Now().Format("2006") + ` YOUR_NAME_HERE
+Copyright (c) ` + htime.Now().Format("2006") + ` YOUR_NAME_HERE
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

commands/nodeploy.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build nodeploy
 // +build nodeploy
 
 package commands

commands/release.go

@@ -1,3 +1,4 @@
+//go:build release
 // +build release
 
 // Copyright 2017-present The Hugo Authors. All rights reserved.
@@ -16,8 +17,6 @@
 package commands
 
 import (
-	"errors"
-
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/releaser"
 	"github.com/spf13/cobra"
@@ -28,10 +27,9 @@ var _ cmder = (*releaseCommandeer)(nil)
 type releaseCommandeer struct {
 	cmd *cobra.Command
 
-	version string
-
-	skipPublish bool
-	try         bool
+	step     int
+	skipPush bool
+	try      bool
 }
 
 func createReleaser() cmder {
@@ -49,9 +47,9 @@ func createReleaser() cmder {
 		return r.release()
 	}
 
-	r.cmd.PersistentFlags().StringVarP(&r.version, "rel", "r", "", "new release version, i.e. 0.25.1")
-	r.cmd.PersistentFlags().BoolVarP(&r.skipPublish, "skip-publish", "", false, "skip all publishing pipes of the release")
-	r.cmd.PersistentFlags().BoolVarP(&r.try, "try", "", false, "simulate a release, i.e. no changes")
+	r.cmd.PersistentFlags().BoolVarP(&r.skipPush, "skip-push", "", false, "skip pushing to remote")
+	r.cmd.PersistentFlags().BoolVarP(&r.try, "try", "", false, "no changes")
+	r.cmd.PersistentFlags().IntVarP(&r.step, "step", "", 0, "step to run (1: set new version 2: prepare next dev version)")
 
 	return r
 }
@@ -64,8 +62,10 @@ func (c *releaseCommandeer) flagsToConfig(cfg config.Provider) {
 }
 
 func (r *releaseCommandeer) release() error {
-	if r.version == "" {
-		return errors.New("must set the --rel flag to the relevant version number")
+	rel, err := releaser.New(r.skipPush, r.try, r.step)
+	if err != nil {
+		return err
 	}
-	return releaser.New(r.version, r.skipPublish, r.try).Run()
+
+	return rel.Run()
 }

commands/release_noop.go

@@ -1,3 +1,4 @@
+//go:build !release
 // +build !release
 
 // Copyright 2018 The Hugo Authors. All rights reserved.

commands/server.go

@@ -15,6 +15,7 @@ package commands
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"io"
 	"net"
@@ -22,6 +23,7 @@ import (
 	"net/url"
 	"os"
 	"os/signal"
+	"path"
 	"path/filepath"
 	"regexp"
 	"runtime"
@@ -31,7 +33,11 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/gohugoio/hugo/common/htime"
+	"github.com/gohugoio/hugo/common/paths"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/tpl"
+	"golang.org/x/sync/errgroup"
 
 	"github.com/gohugoio/hugo/livereload"
 
@@ -44,17 +50,18 @@ import (
 
 type serverCmd struct {
 	// Can be used to stop the server. Useful in tests
-	stop <-chan bool
+	stop chan bool
 
-	disableLiveReload bool
-	navigateToChanged bool
-	renderToDisk      bool
-	serverAppend      bool
-	serverInterface   string
-	serverPort        int
-	liveReloadPort    int
-	serverWatch       bool
-	noHTTPCache       bool
+	disableLiveReload  bool
+	navigateToChanged  bool
+	renderToDisk       bool
+	renderStaticToDisk bool
+	serverAppend       bool
+	serverInterface    string
+	serverPort         int
+	liveReloadPort     int
+	serverWatch        bool
+	noHTTPCache        bool
 
 	disableFastRender   bool
 	disableBrowserError bool
@@ -66,7 +73,7 @@ func (b *commandsBuilder) newServerCmd() *serverCmd {
 	return b.newServerCmdSignaled(nil)
 }
 
-func (b *commandsBuilder) newServerCmdSignaled(stop <-chan bool) *serverCmd {
+func (b *commandsBuilder) newServerCmdSignaled(stop chan bool) *serverCmd {
 	cc := &serverCmd{stop: stop}
 
 	cc.baseBuilderCmd = b.newBuilderCmd(&cobra.Command{
@@ -85,7 +92,13 @@ By default hugo will also watch your files for any changes you make and
 automatically rebuild the site. It will then live reload any open browser pages
 and push the latest content to them. As most Hugo sites are built in a fraction
 of a second, you will be able to save and see your changes nearly instantly.`,
-		RunE: cc.server,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			err := cc.server(cmd, args)
+			if err != nil && cc.stop != nil {
+				cc.stop <- true
+			}
+			return err
+		},
 	})
 
 	cc.cmd.Flags().IntVarP(&cc.serverPort, "port", "p", 1313, "port on which the server will listen")
@@ -96,7 +109,8 @@ of a second, you will be able to save and see your changes nearly instantly.`,
 	cc.cmd.Flags().BoolVarP(&cc.serverAppend, "appendPort", "", true, "append port to baseURL")
 	cc.cmd.Flags().BoolVar(&cc.disableLiveReload, "disableLiveReload", false, "watch without enabling live browser reload on rebuild")
 	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.renderToDisk, "renderToDisk", false, "serve all files from disk (default is from memory)")
+	cc.cmd.Flags().BoolVar(&cc.renderStaticToDisk, "renderStaticToDisk", false, "serve static files from disk and dynamic files from memory")
 	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")
 
@@ -126,8 +140,6 @@ func (f noDirFile) Readdir(count int) ([]os.FileInfo, error) {
 	return nil, nil
 }
 
-var serverPorts []int
-
 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")
@@ -137,8 +149,9 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 
 	var serverCfgInit sync.Once
 
-	cfgInit := func(c *commandeer) error {
-		c.Set("renderToMemory", !sc.renderToDisk)
+	cfgInit := func(c *commandeer) (rerr error) {
+		c.Set("renderToMemory", !(sc.renderToDisk || sc.renderStaticToDisk))
+		c.Set("renderStaticToDisk", sc.renderStaticToDisk)
 		if cmd.Flags().Changed("navigateToChanged") {
 			c.Set("navigateToChanged", sc.navigateToChanged)
 		}
@@ -155,64 +168,68 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 			c.Set("watch", true)
 		}
 
-		// TODO(bep) yes, we should fix.
-		if !c.languagesConfigured {
+		// TODO(bep) see issue 9901
+		// cfgInit is called twice, before and after the languages have been initialized.
+		// The servers (below) can not be initialized before we
+		// know if we're configured in a multihost setup.
+		if len(c.languages) == 0 {
 			return nil
 		}
 
-		var err error
-
 		// We can only do this once.
 		serverCfgInit.Do(func() {
-			serverPorts = make([]int, 1)
+			c.serverPorts = make([]serverPortListener, 1)
 
 			if c.languages.IsMultihost() {
 				if !sc.serverAppend {
-					err = newSystemError("--appendPort=false not supported when in multihost mode")
+					rerr = newSystemError("--appendPort=false not supported when in multihost mode")
 				}
-				serverPorts = make([]int, len(c.languages))
+				c.serverPorts = make([]serverPortListener, len(c.languages))
 			}
 
 			currentServerPort := sc.serverPort
 
-			for i := 0; i < len(serverPorts); i++ {
+			for i := 0; i < len(c.serverPorts); i++ {
 				l, err := net.Listen("tcp", net.JoinHostPort(sc.serverInterface, strconv.Itoa(currentServerPort)))
 				if err == nil {
-					l.Close()
-					serverPorts[i] = currentServerPort
+					c.serverPorts[i] = serverPortListener{ln: l, p: currentServerPort}
 				} else {
 					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)
+						rerr = newSystemErrorF("Server startup failed: %s", err)
+						return
 					}
 					c.logger.Println("port", sc.serverPort, "already in use, attempting to use an available port")
-					sp, err := helpers.FindAvailablePort()
+					l, sp, err := helpers.TCPListen()
 					if err != nil {
-						err = newSystemError("Unable to find alternative port to use:", err)
+						rerr = newSystemError("Unable to find alternative port to use:", err)
+						return
 					}
-					serverPorts[i] = sp.Port
+					c.serverPorts[i] = serverPortListener{ln: l, p: sp.Port}
 				}
 
-				currentServerPort = serverPorts[i] + 1
+				currentServerPort = c.serverPorts[i].p + 1
 			}
 		})
 
-		c.serverPorts = serverPorts
+		if rerr != nil {
+			return
+		}
 
 		c.Set("port", sc.serverPort)
 		if sc.liveReloadPort != -1 {
 			c.Set("liveReloadPort", sc.liveReloadPort)
 		} else {
-			c.Set("liveReloadPort", serverPorts[0])
+			c.Set("liveReloadPort", c.serverPorts[0].p)
 		}
 
 		isMultiHost := c.languages.IsMultihost()
 		for i, language := range c.languages {
 			var serverPort int
 			if isMultiHost {
-				serverPort = serverPorts[i]
+				serverPort = c.serverPorts[i].p
 			} else {
-				serverPort = serverPorts[0]
+				serverPort = c.serverPorts[0].p
 			}
 
 			baseURL, err := sc.fixURL(language, sc.baseURL, serverPort)
@@ -227,26 +244,34 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 			}
 		}
 
-		return err
+		return
 	}
 
 	if err := memStats(); err != nil {
 		jww.WARN.Println("memstats error:", err)
 	}
 
-	c, err := initializeConfig(true, true, &sc.hugoBuilderCommon, sc, cfgInit)
+	// silence errors in cobra so we can handle them here
+	cmd.SilenceErrors = true
+
+	c, err := initializeConfig(true, true, true, &sc.hugoBuilderCommon, sc, cfgInit)
+	if err != nil {
+		cmd.PrintErrln("Error:", err.Error())
+		return err
+	}
+
+	err = func() error {
+		defer c.timeTrack(time.Now(), "Built")
+		err := c.serverBuild()
+		if err != nil {
+			cmd.PrintErrln("Error:", err.Error())
+		}
+		return err
+	}()
 	if err != nil {
 		return err
 	}
 
-	if err := c.serverBuild(); err != nil {
-		return err
-	}
-
-	for _, s := range c.hugo().Sites {
-		s.RegisterMediaTypes()
-	}
-
 	// Watch runs its own server as part of the routine
 	if sc.serverWatch {
 
@@ -260,7 +285,7 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 		for _, group := range watchGroups {
 			jww.FEEDBACK.Printf("Watching for changes in %s\n", group)
 		}
-		watcher, err := c.newWatcher(watchDirs...)
+		watcher, err := c.newWatcher(sc.poll, watchDirs...)
 		if err != nil {
 			return err
 		}
@@ -275,7 +300,7 @@ func (sc *serverCmd) server(cmd *cobra.Command, args []string) error {
 func getRootWatchDirsStr(baseDir string, watchDirs []string) string {
 	relWatchDirs := make([]string, len(watchDirs))
 	for i, dir := range watchDirs {
-		relWatchDirs[i], _ = helpers.GetRelativePath(dir, baseDir)
+		relWatchDirs[i], _ = paths.GetRelativePath(dir, baseDir)
 	}
 
 	return strings.Join(helpers.UniqueStringsSorted(helpers.ExtractRootPaths(relWatchDirs)), ",")
@@ -284,7 +309,7 @@ func getRootWatchDirsStr(baseDir string, watchDirs []string) string {
 type fileServer struct {
 	baseURLs      []string
 	roots         []string
-	errorTemplate func(err interface{}) (io.Reader, error)
+	errorTemplate func(err any) (io.Reader, error)
 	c             *commandeer
 	s             *serverCmd
 }
@@ -300,31 +325,39 @@ func (f *fileServer) rewriteRequest(r *http.Request, toPath string) *http.Reques
 	return r2
 }
 
-func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, error) {
+func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string, string, error) {
 	baseURL := f.baseURLs[i]
 	root := f.roots[i]
-	port := f.c.serverPorts[i]
+	port := f.c.serverPorts[i].p
+	listener := f.c.serverPorts[i].ln
 
+	// For logging only.
+	// TODO(bep) consolidate.
 	publishDir := f.c.Cfg.GetString("publishDir")
+	publishDirStatic := f.c.Cfg.GetString("publishDirStatic")
+	workingDir := f.c.Cfg.GetString("workingDir")
 
 	if root != "" {
 		publishDir = filepath.Join(publishDir, root)
+		publishDirStatic = filepath.Join(publishDirStatic, root)
 	}
-
-	absPublishDir := f.c.hugo().PathSpec.AbsPathify(publishDir)
+	absPublishDir := paths.AbsPathify(workingDir, publishDir)
+	absPublishDirStatic := paths.AbsPathify(workingDir, publishDirStatic)
 
 	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)
+		} else if f.s.renderStaticToDisk {
+			jww.FEEDBACK.Println("Serving pages from memory and static files from " + absPublishDirStatic)
 		} else {
 			jww.FEEDBACK.Println("Serving pages from memory")
 		}
 	}
 
-	httpFs := afero.NewHttpFs(f.c.destinationFs)
-	fs := filesOnlyFs{httpFs.Dir(absPublishDir)}
+	httpFs := afero.NewHttpFs(f.c.publishDirServerFs)
+	fs := filesOnlyFs{httpFs.Dir(path.Join("/", root))}
 
 	if i == 0 && f.c.fastRenderMode {
 		jww.FEEDBACK.Println("Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender")
@@ -333,7 +366,7 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, erro
 	// We're only interested in the path
 	u, err := url.Parse(baseURL)
 	if err != nil {
-		return nil, "", "", errors.Wrap(err, "Invalid baseURL")
+		return nil, nil, "", "", fmt.Errorf("Invalid baseURL: %w", err)
 	}
 
 	decorate := func(h http.Handler) http.Handler {
@@ -439,15 +472,43 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, erro
 
 	endpoint := net.JoinHostPort(f.s.serverInterface, strconv.Itoa(port))
 
-	return mu, u.String(), endpoint, nil
+	return mu, listener, u.String(), endpoint, nil
 }
 
-var logErrorRe = regexp.MustCompile(`(?s)ERROR \d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} `)
+var (
+	logErrorRe                    = regexp.MustCompile(`(?s)ERROR \d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} `)
+	logDuplicateTemplateExecuteRe = regexp.MustCompile(`: template: .*?:\d+:\d+: executing ".*?"`)
+	logDuplicateTemplateParseRe   = regexp.MustCompile(`: template: .*?:\d+:\d*`)
+)
 
 func removeErrorPrefixFromLog(content string) string {
 	return logErrorRe.ReplaceAllLiteralString(content, "")
 }
 
+var logReplacer = strings.NewReplacer(
+	"can't", "can’t", // Chroma lexer does'nt do well with "can't"
+	"*hugolib.pageState", "page.Page", // Page is the public interface.
+	"Rebuild failed:", "",
+)
+
+func cleanErrorLog(content string) string {
+	content = strings.ReplaceAll(content, "\n", " ")
+	content = logReplacer.Replace(content)
+	content = logDuplicateTemplateExecuteRe.ReplaceAllString(content, "")
+	content = logDuplicateTemplateParseRe.ReplaceAllString(content, "")
+	seen := make(map[string]bool)
+	parts := strings.Split(content, ": ")
+	keep := make([]string, 0, len(parts))
+	for _, part := range parts {
+		if seen[part] {
+			continue
+		}
+		seen[part] = true
+		keep = append(keep, part)
+	}
+	return strings.Join(keep, ": ")
+}
+
 func (c *commandeer) serve(s *serverCmd) error {
 	isMultiHost := c.hugo().IsMultihost()
 
@@ -467,19 +528,37 @@ func (c *commandeer) serve(s *serverCmd) error {
 		roots = []string{""}
 	}
 
-	templ, err := c.hugo().TextTmpl().Parse("__default_server_error", buildErrorTemplate)
-	if err != nil {
-		return err
+	// Cache it here. The HugoSites object may be unavaialble later on due to intermitent configuration errors.
+	// To allow the en user to change the error template while the server is running, we use
+	// the freshest template we can provide.
+	var (
+		errTempl     tpl.Template
+		templHandler tpl.TemplateHandler
+	)
+	getErrorTemplateAndHandler := func(h *hugolib.HugoSites) (tpl.Template, tpl.TemplateHandler) {
+		if h == nil {
+			return errTempl, templHandler
+		}
+		templHandler := h.Tmpl()
+		errTempl, found := templHandler.Lookup("_server/error.html")
+		if !found {
+			panic("template server/error.html not found")
+		}
+		return errTempl, templHandler
 	}
+	errTempl, templHandler = getErrorTemplateAndHandler(c.hugo())
 
 	srv := &fileServer{
 		baseURLs: baseURLs,
 		roots:    roots,
 		c:        c,
 		s:        s,
-		errorTemplate: func(ctx interface{}) (io.Reader, error) {
+		errorTemplate: func(ctx any) (io.Reader, error) {
+			// hugoTry does not block, getErrorTemplateAndHandler will fall back
+			// to cached values if nil.
+			templ, handler := getErrorTemplateAndHandler(c.hugoTry())
 			b := &bytes.Buffer{}
-			err := c.hugo().Tmpl().Execute(templ, b, ctx)
+			err := handler.Execute(templ, b, ctx)
 			return b, err
 		},
 	}
@@ -492,9 +571,17 @@ func (c *commandeer) serve(s *serverCmd) error {
 
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+	var servers []*http.Server
+
+	wg1, ctx := errgroup.WithContext(context.Background())
 
 	for i := range baseURLs {
-		mu, serverURL, endpoint, err := srv.createEndpoint(i)
+		mu, listener, serverURL, endpoint, err := srv.createEndpoint(i)
+		srv := &http.Server{
+			Addr:    endpoint,
+			Handler: mu,
+		}
+		servers = append(servers, srv)
 
 		if doLiveReload {
 			u, err := url.Parse(helpers.SanitizeURL(baseURLs[i]))
@@ -506,29 +593,64 @@ func (c *commandeer) serve(s *serverCmd) error {
 			mu.HandleFunc(u.Path+"/livereload", livereload.Handler)
 		}
 		jww.FEEDBACK.Printf("Web Server is available at %s (bind address %s)\n", serverURL, s.serverInterface)
-		go func() {
-			err = http.ListenAndServe(endpoint, mu)
-			if err != nil {
-				c.logger.Errorf("Error: %s\n", err.Error())
-				os.Exit(1)
+		wg1.Go(func() error {
+			err = srv.Serve(listener)
+			if err != nil && err != http.ErrServerClosed {
+				return err
 			}
-		}()
+			return nil
+		})
 	}
 
 	jww.FEEDBACK.Println("Press Ctrl+C to stop")
 
-	if s.stop != nil {
-		select {
-		case <-sigs:
-		case <-s.stop:
+	err := func() error {
+		if s.stop != nil {
+			for {
+				select {
+				case <-sigs:
+					return nil
+				case <-s.stop:
+					return nil
+				case <-ctx.Done():
+					return ctx.Err()
+				}
+			}
+		} else {
+			for {
+				select {
+				case <-sigs:
+					return nil
+				case <-ctx.Done():
+					return ctx.Err()
+				}
+			}
 		}
-	} else {
-		<-sigs
+	}()
+
+	if err != nil {
+		jww.ERROR.Println("Error:", err)
 	}
 
-	c.hugo().Close()
+	if h := c.hugoTry(); h != nil {
+		h.Close()
+	}
 
-	return nil
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	wg2, ctx := errgroup.WithContext(ctx)
+	for _, srv := range servers {
+		srv := srv
+		wg2.Go(func() error {
+			return srv.Shutdown(ctx)
+		})
+	}
+
+	err1, err2 := wg1.Wait(), wg2.Wait()
+	if err1 != nil {
+		return err1
+	}
+	return err2
 }
 
 // fixURL massages the baseURL into a form needed for serving
@@ -572,7 +694,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 "", errors.Wrap(err, "Failed to split baseURL hostpost")
+				return "", fmt.Errorf("Failed to split baseURL hostpost: %w", err)
 			}
 		}
 		u.Host += fmt.Sprintf(":%d", port)
@@ -601,13 +723,13 @@ func memStats() error {
 		go func() {
 			var stats runtime.MemStats
 
-			start := time.Now().UnixNano()
+			start := htime.Now().UnixNano()
 
 			for {
 				runtime.ReadMemStats(&stats)
 				if fileMemStats != nil {
 					fileMemStats.WriteString(fmt.Sprintf("%d\t%d\t%d\t%d\t%d\n",
-						(time.Now().UnixNano()-start)/1000000, stats.HeapSys, stats.HeapAlloc, stats.HeapIdle, stats.HeapReleased))
+						(htime.Now().UnixNano()-start)/1000000, stats.HeapSys, stats.HeapAlloc, stats.HeapIdle, stats.HeapReleased))
 					time.Sleep(interval)
 				} else {
 					break

commands/server_errors.go

@@ -22,67 +22,6 @@ import (
 	"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: #2f1e2e;
-		}
-		main {
-			margin: auto;
-			width: 95%;
-			padding: 1rem;
-		}		
-		.version {
-			color: #ccc;
-			padding: 1rem 0;
-		}
-		.stack {
-			margin-top: 4rem;
-		}
-		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;
-			margin-bottom: 1rem;
-		}
-		a {
-			color: #0594cb;
-			text-decoration: none;
-		}
-		a:hover {
-			color: #ccc;
-		}
-		</style>
-	</head>
-	<body>
-		<main>
-			{{ highlight .Error "apl" "linenos=false,noclasses=true,style=paraiso-dark" }}
-			{{ with .File }}
-			{{ $params := printf "noclasses=true,style=paraiso-dark,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=paraiso-dark" }}
-			{{ end }}
-			<p class="version">{{ .Version }}</p>
-			<a href="">Reload Page</a>
-		</main>
-</body>
-</html>
-`
-
 func injectLiveReloadScript(src io.Reader, baseURL url.URL) string {
 	var b bytes.Buffer
 	chain := transform.Chain{livereloadinject.New(baseURL)}

commands/server_test.go

@@ -17,29 +17,150 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"testing"
 	"time"
 
+	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/helpers"
+	"golang.org/x/net/context"
+	"golang.org/x/sync/errgroup"
 
 	qt "github.com/frankban/quicktest"
-	"github.com/spf13/viper"
 )
 
-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")
-	}
+// Issue 9518
+func TestServerPanicOnConfigError(t *testing.T) {
 	c := qt.New(t)
-	dir, clean, err := createSimpleTestSite(t, testSiteConfig{})
-	defer clean()
-	c.Assert(err, qt.IsNil)
 
-	// Let us hope that this port is available on all systems ...
-	port := 1331
+	config := `
+[markup]
+[markup.highlight]
+linenos='table'
+`
+
+	r := runServerTest(c, 0, config)
+
+	c.Assert(r.err, qt.IsNotNil)
+	c.Assert(r.err.Error(), qt.Contains, "cannot parse 'Highlight.LineNos' as bool:")
+}
+
+func TestServerFlags(t *testing.T) {
+	c := qt.New(t)
+
+	assertPublic := func(c *qt.C, r serverTestResult, renderStaticToDisk bool) {
+		c.Assert(r.err, qt.IsNil)
+		c.Assert(r.homesContent[0], qt.Contains, "Environment: development")
+		c.Assert(r.publicDirnames["myfile.txt"], qt.Equals, renderStaticToDisk)
+
+	}
+
+	for _, test := range []struct {
+		flag   string
+		assert func(c *qt.C, r serverTestResult)
+	}{
+		{"", func(c *qt.C, r serverTestResult) {
+			assertPublic(c, r, false)
+		}},
+		{"--renderToDisk", func(c *qt.C, r serverTestResult) {
+			assertPublic(c, r, true)
+		}},
+		{"--renderStaticToDisk", func(c *qt.C, r serverTestResult) {
+			assertPublic(c, r, true)
+		}},
+	} {
+		c.Run(test.flag, func(c *qt.C) {
+			config := `
+baseURL="https://example.org"
+`
+
+			var args []string
+			if test.flag != "" {
+				args = strings.Split(test.flag, "=")
+			}
+
+			r := runServerTest(c, 1, config, args...)
+
+			test.assert(c, r)
+
+		})
+
+	}
+
+}
+
+func TestServerBugs(t *testing.T) {
+	c := qt.New(t)
+
+	for _, test := range []struct {
+		name       string
+		config     string
+		flag       string
+		numservers int
+		assert     func(c *qt.C, r serverTestResult)
+	}{
+		// Issue 9788
+		{"PostProcess, memory", "", "", 1, func(c *qt.C, r serverTestResult) {
+			c.Assert(r.err, qt.IsNil)
+			c.Assert(r.homesContent[0], qt.Contains, "PostProcess: /foo.min.css")
+		}},
+		{"PostProcess, disk", "", "--renderToDisk", 1, func(c *qt.C, r serverTestResult) {
+			c.Assert(r.err, qt.IsNil)
+			c.Assert(r.homesContent[0], qt.Contains, "PostProcess: /foo.min.css")
+		}},
+		// Isue 9901
+		{"Multihost", `
+defaultContentLanguage = 'en'
+[languages]
+[languages.en]
+baseURL = 'https://example.com'
+title = 'My blog'
+weight = 1
+[languages.fr]
+baseURL = 'https://example.fr'
+title = 'Mon blogue'
+weight = 2
+`, "", 2, func(c *qt.C, r serverTestResult) {
+			c.Assert(r.err, qt.IsNil)
+			for i, s := range []string{"My blog", "Mon blogue"} {
+				c.Assert(r.homesContent[i], qt.Contains, s)
+			}
+		}},
+	} {
+		c.Run(test.name, func(c *qt.C) {
+			if test.config == "" {
+				test.config = `
+baseURL="https://example.org"
+`
+			}
+
+			var args []string
+			if test.flag != "" {
+				args = strings.Split(test.flag, "=")
+			}
+			r := runServerTest(c, test.numservers, test.config, args...)
+			test.assert(c, r)
+
+		})
+
+	}
+
+}
+
+type serverTestResult struct {
+	err            error
+	homesContent   []string
+	publicDirnames map[string]bool
+}
+
+func runServerTest(c *qt.C, getNumHomes int, config string, args ...string) (result serverTestResult) {
+	dir := createSimpleTestSite(c, testSiteConfig{configTOML: config})
+
+	sp, err := helpers.FindAvailablePort()
+	c.Assert(err, qt.IsNil)
+	port := sp.Port
 
 	defer func() {
 		os.RemoveAll(dir)
@@ -51,28 +172,54 @@ func TestServer(t *testing.T) {
 	scmd := b.newServerCmdSignaled(stop)
 
 	cmd := scmd.getCommand()
-	cmd.SetArgs([]string{"-s=" + dir, fmt.Sprintf("-p=%d", port)})
+	args = append([]string{"-s=" + dir, fmt.Sprintf("-p=%d", port)}, args...)
+	cmd.SetArgs(args)
 
-	go func() {
-		_, err = cmd.ExecuteC()
-		c.Assert(err, qt.IsNil)
-	}()
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	wg, ctx := errgroup.WithContext(ctx)
 
-	// There is no way to know exactly when the server is ready for connections.
-	// We could improve by something like https://golang.org/pkg/net/http/httptest/#Server
-	// But for now, let us sleep and pray!
-	time.Sleep(2 * time.Second)
+	wg.Go(func() error {
+		_, err := cmd.ExecuteC()
+		return err
+	})
 
-	resp, err := http.Get("http://localhost:1331/")
-	c.Assert(err, qt.IsNil)
-	defer resp.Body.Close()
-	homeContent := helpers.ReaderToString(resp.Body)
+	if getNumHomes > 0 {
+		// Esp. on slow CI machines, we need to wait a little before the web
+		// server is ready.
+		time.Sleep(567 * time.Millisecond)
+		result.homesContent = make([]string, getNumHomes)
+		for i := 0; i < getNumHomes; i++ {
+			func() {
+				resp, err := http.Get(fmt.Sprintf("http://localhost:%d/", port+i))
+				c.Check(err, qt.IsNil)
+				c.Check(resp.StatusCode, qt.Equals, http.StatusOK)
+				if err == nil {
+					defer resp.Body.Close()
+					result.homesContent[i] = helpers.ReaderToString(resp.Body)
+				}
+			}()
+		}
+	}
 
-	c.Assert(homeContent, qt.Contains, "List: Hugo Commands")
-	c.Assert(homeContent, qt.Contains, "Environment: development")
+	time.Sleep(1 * time.Second)
+
+	select {
+	case <-stop:
+	case stop <- true:
+	}
+
+	pubFiles, err := os.ReadDir(filepath.Join(dir, "public"))
+	c.Check(err, qt.IsNil)
+	result.publicDirnames = make(map[string]bool)
+	for _, f := range pubFiles {
+		result.publicDirnames[f.Name()] = true
+	}
+
+	result.err = wg.Wait()
+
+	return
 
-	// Stop the server.
-	stop <- true
 }
 
 func TestFixURL(t *testing.T) {
@@ -101,7 +248,7 @@ func TestFixURL(t *testing.T) {
 		t.Run(test.TestName, func(t *testing.T) {
 			b := newCommandsBuilder()
 			s := b.newServerCmd()
-			v := viper.New()
+			v := config.NewWithTestDefaults()
 			baseURL := test.CLIBaseURL
 			v.Set("baseURL", test.CfgBaseURL)
 			s.serverAppend = test.AppendPort

commands/static_syncer.go

@@ -40,11 +40,7 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 	c := s.c
 
 	syncFn := func(sourceFs *filesystems.SourceFilesystem) (uint64, error) {
-		publishDir := c.hugo().PathSpec.PublishDir
-		// If root, remove the second '/'
-		if publishDir == "//" {
-			publishDir = helpers.FilePathSeparator
-		}
+		publishDir := helpers.FilePathSeparator
 
 		if sourceFs.PublishFolder != "" {
 			publishDir = filepath.Join(publishDir, sourceFs.PublishFolder)
@@ -55,10 +51,13 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 		syncer.NoChmod = c.Cfg.GetBool("noChmod")
 		syncer.ChmodFilter = chmodFilter
 		syncer.SrcFs = sourceFs.Fs
-		syncer.DestFs = c.Fs.Destination
+		syncer.DestFs = c.Fs.PublishDir
+		if c.renderStaticToDisk {
+			syncer.DestFs = c.Fs.PublishDirStatic
+		}
 
 		// prevent spamming the log on changes
-		logger := helpers.NewDistinctFeedbackLogger()
+		logger := helpers.NewDistinctErrorLogger()
 
 		for _, ev := range staticEvents {
 			// Due to our approach of layering both directories and the content's rendered output
@@ -98,15 +97,14 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 			if ev.Op&fsnotify.Rename == fsnotify.Rename || ev.Op&fsnotify.Remove == fsnotify.Remove {
 				if _, err := sourceFs.Fs.Stat(relPath); os.IsNotExist(err) {
 					// If file doesn't exist in any static dir, remove it
-					toRemove := filepath.Join(publishDir, relPath)
+					logger.Println("File no longer exists in static dir, removing", relPath)
+					_ = c.Fs.PublishDirStatic.RemoveAll(relPath)
 
-					logger.Println("File no longer exists in static dir, removing", toRemove)
-					_ = c.Fs.Destination.RemoveAll(toRemove)
 				} else if err == nil {
 					// If file still exists, sync it
 					logger.Println("Syncing", relPath, "to", publishDir)
 
-					if err := syncer.Sync(filepath.Join(publishDir, relPath), relPath); err != nil {
+					if err := syncer.Sync(relPath, relPath); err != nil {
 						c.logger.Errorln(err)
 					}
 				} else {

common/collections/append.go

@@ -21,7 +21,7 @@ import (
 // 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) {
+func Append(to any, from ...any) (any, error) {
 	tov, toIsNil := indirect(reflect.ValueOf(to))
 
 	toIsNil = toIsNil || to == nil
@@ -73,8 +73,8 @@ func Append(to interface{}, from ...interface{}) (interface{}, error) {
 	return tov.Interface(), nil
 }
 
-func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]interface{}, error) {
-	var tos []interface{}
+func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]any, error) {
+	var tos []any
 
 	for _, slice := range []reflect.Value{slice1, slice2} {
 		for i := 0; i < slice.Len(); i++ {
@@ -85,8 +85,8 @@ func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]interface
 	return tos, nil
 }
 
-func appendToInterfaceSlice(tov reflect.Value, from ...interface{}) ([]interface{}, error) {
-	var tos []interface{}
+func appendToInterfaceSlice(tov reflect.Value, from ...any) ([]any, error) {
+	var tos []any
 
 	for i := 0; i < tov.Len(); i++ {
 		tos = append(tos, tov.Index(i).Interface())

common/collections/append_test.go

@@ -25,25 +25,25 @@ func TestAppend(t *testing.T) {
 	c := qt.New(t)
 
 	for _, test := range []struct {
-		start    interface{}
-		addend   []interface{}
-		expected interface{}
+		start    any
+		addend   []any
+		expected any
 	}{
-		{[]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"}},
-		{[]string{"a"}, []interface{}{"b", template.HTML("c")}, []interface{}{"a", "b", template.HTML("c")}},
-		{nil, []interface{}{"a", "b"}, []string{"a", "b"}},
-		{nil, []interface{}{nil}, []interface{}{nil}},
-		{[]interface{}{}, []interface{}{[]string{"c", "d", "e"}}, []string{"c", "d", "e"}},
+		{[]string{"a", "b"}, []any{"c"}, []string{"a", "b", "c"}},
+		{[]string{"a", "b"}, []any{"c", "d", "e"}, []string{"a", "b", "c", "d", "e"}},
+		{[]string{"a", "b"}, []any{[]string{"c", "d", "e"}}, []string{"a", "b", "c", "d", "e"}},
+		{[]string{"a"}, []any{"b", template.HTML("c")}, []any{"a", "b", template.HTML("c")}},
+		{nil, []any{"a", "b"}, []string{"a", "b"}},
+		{nil, []any{nil}, []any{nil}},
+		{[]any{}, []any{[]string{"c", "d", "e"}}, []string{"c", "d", "e"}},
 		{
 			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
-			[]interface{}{&tstSlicer{"c"}},
+			[]any{&tstSlicer{"c"}},
 			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}},
 		},
 		{
 			&tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
-			[]interface{}{&tstSlicer{"c"}},
+			[]any{&tstSlicer{"c"}},
 			tstSlicers{
 				&tstSlicer{"a"},
 				&tstSlicer{"b"},
@@ -52,26 +52,26 @@ func TestAppend(t *testing.T) {
 		},
 		{
 			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}},
-			[]interface{}{&tstSlicerIn1{"c"}},
+			[]any{&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"}},
+			[]any{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
+			[]any{"a", "b", &tstSlicer{"a"}, &tstSlicer{"b"}},
 		},
 		{
 			[]string{"a", "b"},
-			[]interface{}{&tstSlicer{"a"}},
-			[]interface{}{"a", "b", &tstSlicer{"a"}},
+			[]any{&tstSlicer{"a"}},
+			[]any{"a", "b", &tstSlicer{"a"}},
 		},
 		// Errors
-		{"", []interface{}{[]string{"a", "b"}}, false},
+		{"", []any{[]string{"a", "b"}}, false},
 		// No string concatenation.
 		{
 			"ab",
-			[]interface{}{"c"},
+			[]any{"c"},
 			false,
 		},
 	} {

common/collections/collections.go

@@ -17,5 +17,5 @@ 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)
+	Group(key any, items any) (any, error)
 }

common/collections/slice.go

@@ -21,11 +21,11 @@ import (
 // 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(items any) (any, error)
 }
 
 // Slice returns a slice of all passed arguments.
-func Slice(args ...interface{}) interface{} {
+func Slice(args ...any) any {
 	if len(args) == 0 {
 		return args
 	}
@@ -64,3 +64,13 @@ func Slice(args ...interface{}) interface{} {
 	}
 	return slice.Interface()
 }
+
+// StringSliceToInterfaceSlice converts ss to []interface{}.
+func StringSliceToInterfaceSlice(ss []string) []any {
+	result := make([]any, len(ss))
+	for i, s := range ss {
+		result[i] = s
+	}
+	return result
+
+}

common/collections/slice_test.go

@@ -46,8 +46,8 @@ type tstSlicer struct {
 	TheName string
 }
 
-func (p *tstSlicerIn1) Slice(in interface{}) (interface{}, error) {
-	items := in.([]interface{})
+func (p *tstSlicerIn1) Slice(in any) (any, error) {
+	items := in.([]any)
 	result := make(testSlicerInterfaces, len(items))
 	for i, v := range items {
 		switch vv := v.(type) {
@@ -60,8 +60,8 @@ func (p *tstSlicerIn1) Slice(in interface{}) (interface{}, error) {
 	return result, nil
 }
 
-func (p *tstSlicerIn2) Slice(in interface{}) (interface{}, error) {
-	items := in.([]interface{})
+func (p *tstSlicerIn2) Slice(in any) (any, error) {
+	items := in.([]any)
 	result := make(testSlicerInterfaces, len(items))
 	for i, v := range items {
 		switch vv := v.(type) {
@@ -82,8 +82,8 @@ func (p *tstSlicerIn2) Name() string {
 	return p.TheName
 }
 
-func (p *tstSlicer) Slice(in interface{}) (interface{}, error) {
-	items := in.([]interface{})
+func (p *tstSlicer) Slice(in any) (any, error) {
+	items := in.([]any)
 	result := make(tstSlicers, len(items))
 	for i, v := range items {
 		switch vv := v.(type) {
@@ -103,17 +103,17 @@ func TestSlice(t *testing.T) {
 	c := qt.New(t)
 
 	for i, test := range []struct {
-		args     []interface{}
-		expected interface{}
+		args     []any
+		expected any
 	}{
-		{[]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"}}},
+		{[]any{"a", "b"}, []string{"a", "b"}},
+		{[]any{&tstSlicer{"a"}, &tstSlicer{"b"}}, tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
+		{[]any{&tstSlicer{"a"}, "b"}, []any{&tstSlicer{"a"}, "b"}},
+		{[]any{}, []any{}},
+		{[]any{nil}, []any{nil}},
+		{[]any{5, "b"}, []any{5, "b"}},
+		{[]any{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}, testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}},
+		{[]any{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}, []any{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}},
 	} {
 		errMsg := qt.Commentf("[%d] %v", i, test.args)
 

common/herrors/error_locator.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2022 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.
@@ -21,8 +21,6 @@ import (
 	"strings"
 
 	"github.com/gohugoio/hugo/common/text"
-
-	"github.com/spf13/afero"
 )
 
 // LineMatcher contains the elements used to match an error to a line
@@ -36,14 +34,33 @@ type LineMatcher struct {
 }
 
 // LineMatcherFn is used to match a line with an error.
-type LineMatcherFn func(m LineMatcher) bool
+// It returns the column number or 0 if the line was found, but column could not be determinde. Returns -1 if no line match.
+type LineMatcherFn func(m LineMatcher) int
 
 // SimpleLineMatcher simply matches by line number.
-var SimpleLineMatcher = func(m LineMatcher) bool {
-	return m.Position.LineNumber == m.LineNumber
+var SimpleLineMatcher = func(m LineMatcher) int {
+	if m.Position.LineNumber == m.LineNumber {
+		// We found the line, but don't know the column.
+		return 0
+	}
+	return -1
 }
 
-var _ text.Positioner = ErrorContext{}
+// NopLineMatcher is a matcher that always returns 1.
+// This will effectively give line 1, column 1.
+var NopLineMatcher = func(m LineMatcher) int {
+	return 1
+}
+
+// OffsetMatcher is a line matcher that matches by offset.
+var OffsetMatcher = func(m LineMatcher) int {
+	if m.Offset+len(m.Line) >= m.Position.Offset {
+		// We found the line, but return 0 to signal that we want to determine
+		// the column from the error.
+		return 0
+	}
+	return -1
+}
 
 // ErrorContext contains contextual information about an error. This will
 // typically be the lines surrounding some problem in a file.
@@ -56,114 +73,15 @@ type ErrorContext struct {
 	// The position of the error in the Lines above. 0 based.
 	LinesPos int
 
-	position text.Position
+	// The position of the content in the file. Note that this may be different from the error's position set
+	// in FileError.
+	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":
@@ -185,31 +103,24 @@ func chromaLexerFromFilename(filename string) string {
 	return chromaLexerFromType(ext)
 }
 
-func locateErrorInString(src string, matcher LineMatcherFn) ErrorContext {
+func locateErrorInString(src string, matcher LineMatcherFn) *ErrorContext {
 	return locateError(strings.NewReader(src), &fileError{}, matcher)
 }
 
-func locateError(r io.Reader, le FileError, matches LineMatcherFn) ErrorContext {
+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}
+	ectx := &ErrorContext{LinesPos: -1, Position: text.Position{Offset: -1}}
 
 	b, err := ioutil.ReadAll(r)
 	if err != nil {
-		return errCtx
+		return ectx
 	}
 
-	pos := &errCtx.position
-	lepos := le.Position()
-
 	lines := strings.Split(string(b), "\n")
 
-	if lepos.ColumnNumber >= 0 {
-		pos.ColumnNumber = lepos.ColumnNumber
-	}
-
 	lineNo := 0
 	posBytes := 0
 
@@ -222,34 +133,36 @@ func locateError(r io.Reader, le FileError, matches LineMatcherFn) ErrorContext
 			Offset:     posBytes,
 			Line:       line,
 		}
-		if errCtx.LinesPos == -1 && matches(m) {
-			pos.LineNumber = lineNo
+		v := matches(m)
+		if ectx.LinesPos == -1 && v != -1 {
+			ectx.Position.LineNumber = lineNo
+			ectx.Position.ColumnNumber = v
 			break
 		}
 
 		posBytes += len(line)
 	}
 
-	if pos.LineNumber != -1 {
-		low := pos.LineNumber - 3
+	if ectx.Position.LineNumber > 0 {
+		low := ectx.Position.LineNumber - 3
 		if low < 0 {
 			low = 0
 		}
 
-		if pos.LineNumber > 2 {
-			errCtx.LinesPos = 2
+		if ectx.Position.LineNumber > 2 {
+			ectx.LinesPos = 2
 		} else {
-			errCtx.LinesPos = pos.LineNumber - 1
+			ectx.LinesPos = ectx.Position.LineNumber - 1
 		}
 
-		high := pos.LineNumber + 2
+		high := ectx.Position.LineNumber + 2
 		if high > len(lines) {
 			high = len(lines)
 		}
 
-		errCtx.Lines = lines[low:high]
+		ectx.Lines = lines[low:high]
 
 	}
 
-	return errCtx
+	return ectx
 }

common/herrors/error_locator_test.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2022 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.
@@ -24,8 +24,11 @@ import (
 func TestErrorLocator(t *testing.T) {
 	c := qt.New(t)
 
-	lineMatcher := func(m LineMatcher) bool {
-		return strings.Contains(m.Line, "THEONE")
+	lineMatcher := func(m LineMatcher) int {
+		if strings.Contains(m.Line, "THEONE") {
+			return 1
+		}
+		return -1
 	}
 
 	lines := `LINE 1
@@ -39,35 +42,41 @@ LINE 8
 `
 
 	location := locateErrorInString(lines, lineMatcher)
+	pos := location.Position
 	c.Assert(location.Lines, qt.DeepEquals, []string{"LINE 3", "LINE 4", "This is THEONE", "LINE 6", "LINE 7"})
 
-	pos := location.Position()
 	c.Assert(pos.LineNumber, qt.Equals, 5)
 	c.Assert(location.LinesPos, qt.Equals, 2)
 
-	c.Assert(locateErrorInString(`This is THEONE`, lineMatcher).Lines, qt.DeepEquals, []string{"This is THEONE"})
+	locate := func(s string, m LineMatcherFn) *ErrorContext {
+		ctx := locateErrorInString(s, m)
+		return ctx
+	}
+
+	c.Assert(locate(`This is THEONE`, lineMatcher).Lines, qt.DeepEquals, []string{"This is THEONE"})
 
 	location = locateErrorInString(`L1
 This is THEONE
 L2
 `, lineMatcher)
-	c.Assert(location.Position().LineNumber, qt.Equals, 2)
+	pos = location.Position
+	c.Assert(pos.LineNumber, qt.Equals, 2)
 	c.Assert(location.LinesPos, qt.Equals, 1)
 	c.Assert(location.Lines, qt.DeepEquals, []string{"L1", "This is THEONE", "L2", ""})
 
-	location = locateErrorInString(`This is THEONE
+	location = locate(`This is THEONE
 L2
 `, lineMatcher)
 	c.Assert(location.LinesPos, qt.Equals, 0)
 	c.Assert(location.Lines, qt.DeepEquals, []string{"This is THEONE", "L2", ""})
 
-	location = locateErrorInString(`L1
+	location = locate(`L1
 This THEONE
 `, lineMatcher)
 	c.Assert(location.Lines, qt.DeepEquals, []string{"L1", "This THEONE", ""})
 	c.Assert(location.LinesPos, qt.Equals, 1)
 
-	location = locateErrorInString(`L1
+	location = locate(`L1
 L2
 This THEONE
 `, lineMatcher)
@@ -75,12 +84,16 @@ This THEONE
 	c.Assert(location.LinesPos, qt.Equals, 2)
 
 	location = locateErrorInString("NO MATCH", lineMatcher)
-	c.Assert(location.Position().LineNumber, qt.Equals, -1)
+	pos = location.Position
+	c.Assert(pos.LineNumber, qt.Equals, 0)
 	c.Assert(location.LinesPos, qt.Equals, -1)
 	c.Assert(len(location.Lines), qt.Equals, 0)
 
-	lineMatcher = func(m LineMatcher) bool {
-		return m.LineNumber == 6
+	lineMatcher = func(m LineMatcher) int {
+		if m.LineNumber == 6 {
+			return 1
+		}
+		return -1
 	}
 
 	location = locateErrorInString(`A
@@ -93,14 +106,18 @@ G
 H
 I
 J`, lineMatcher)
+	pos = location.Position
 
 	c.Assert(location.Lines, qt.DeepEquals, []string{"D", "E", "F", "G", "H"})
-	c.Assert(location.Position().LineNumber, qt.Equals, 6)
+	c.Assert(pos.LineNumber, qt.Equals, 6)
 	c.Assert(location.LinesPos, qt.Equals, 2)
 
 	// Test match EOF
-	lineMatcher = func(m LineMatcher) bool {
-		return m.LineNumber == 4
+	lineMatcher = func(m LineMatcher) int {
+		if m.LineNumber == 4 {
+			return 1
+		}
+		return -1
 	}
 
 	location = locateErrorInString(`A
@@ -108,12 +125,17 @@ B
 C
 `, lineMatcher)
 
+	pos = location.Position
+
 	c.Assert(location.Lines, qt.DeepEquals, []string{"B", "C", ""})
-	c.Assert(location.Position().LineNumber, qt.Equals, 4)
+	c.Assert(pos.LineNumber, qt.Equals, 4)
 	c.Assert(location.LinesPos, qt.Equals, 2)
 
-	offsetMatcher := func(m LineMatcher) bool {
-		return m.Offset == 1
+	offsetMatcher := func(m LineMatcher) int {
+		if m.Offset == 1 {
+			return 1
+		}
+		return -1
 	}
 
 	location = locateErrorInString(`A
@@ -122,7 +144,9 @@ C
 D
 E`, offsetMatcher)
 
+	pos = location.Position
+
 	c.Assert(location.Lines, qt.DeepEquals, []string{"A", "B", "C", "D"})
-	c.Assert(location.Position().LineNumber, qt.Equals, 2)
+	c.Assert(pos.LineNumber, qt.Equals, 2)
 	c.Assert(location.LinesPos, qt.Equals, 1)
 }

common/herrors/errors.go

@@ -19,37 +19,11 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"os"
 	"runtime"
 	"runtime/debug"
 	"strconv"
-
-	_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
-}
-
-// PrintStackTraceFromErr prints the error's stack trace to stdoud.
-func PrintStackTraceFromErr(err error) {
-	FprintStackTraceFromErr(os.Stdout, err)
-}
-
-// FprintStackTraceFromErr prints the error's stack trace to w.
-func FprintStackTraceFromErr(w io.Writer, err error) {
-	if err, ok := err.(stackTracer); ok {
-		for _, f := range err.StackTrace() {
-			fmt.Fprintf(w, "%+s:%d\n", f, f)
-		}
-	}
-}
-
 // PrintStackTrace prints the current stacktrace to w.
 func PrintStackTrace(w io.Writer) {
 	buf := make([]byte, 1<<16)
@@ -65,7 +39,7 @@ type ErrorSender interface {
 // Recover is a helper function that can be used to capture panics.
 // Put this at the top of a method/function that crashes in a template:
 //     defer herrors.Recover()
-func Recover(args ...interface{}) {
+func Recover(args ...any) {
 	if r := recover(); r != nil {
 		fmt.Println("ERR:", r)
 		args = append(args, "stacktrace from panic: \n"+string(debug.Stack()), "\n")
@@ -88,3 +62,10 @@ func GetGID() uint64 {
 // We will, at least to begin with, make some Hugo features (SCSS with libsass) optional,
 // and this error is used to signal those situations.
 var ErrFeatureNotAvailable = errors.New("this feature is not available in your current Hugo version, see https://goo.gl/YMrWcn for more information")
+
+// Must panics if err != nil.
+func Must(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

common/herrors/file_error.go

@@ -1,11 +1,11 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2022 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
+// Unless required by applicable lfmtaw 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
@@ -15,61 +15,306 @@ package herrors
 
 import (
 	"encoding/json"
+	"fmt"
+	"io"
+	"path/filepath"
 
+	"github.com/bep/godartsass"
+	"github.com/bep/golibsass/libsass/libsasserrors"
+	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/text"
+	"github.com/pelletier/go-toml/v2"
+	"github.com/spf13/afero"
+	"github.com/tdewolff/parse/v2"
 
-	"github.com/pkg/errors"
+	"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
 
+	// ErroContext holds some context information about the error.
+	ErrorContext() *ErrorContext
+
 	text.Positioner
 
-	// A string identifying the type of file, e.g. JSON, TOML, markdown etc.
-	Type() string
+	// UpdatePosition updates the position of the error.
+	UpdatePosition(pos text.Position) FileError
+
+	// UpdateContent updates the error with a new ErrorContext from the content of the file.
+	UpdateContent(r io.Reader, linematcher LineMatcherFn) FileError
 }
 
-var _ FileError = (*fileError)(nil)
+// Unwrapper can unwrap errors created with fmt.Errorf.
+type Unwrapper interface {
+	Unwrap() error
+}
+
+var (
+	_ FileError = (*fileError)(nil)
+	_ Unwrapper = (*fileError)(nil)
+)
+
+func (fe *fileError) UpdatePosition(pos text.Position) FileError {
+	oldFilename := fe.Position().Filename
+	if pos.Filename != "" && fe.fileType == "" {
+		_, fe.fileType = paths.FileAndExtNoDelimiter(filepath.Clean(pos.Filename))
+	}
+	if pos.Filename == "" {
+		pos.Filename = oldFilename
+	}
+	fe.position = pos
+	return fe
+}
+
+func (fe *fileError) UpdateContent(r io.Reader, linematcher LineMatcherFn) FileError {
+	if linematcher == nil {
+		linematcher = SimpleLineMatcher
+	}
+
+	var (
+		posle = fe.position
+		ectx  *ErrorContext
+	)
+
+	if posle.LineNumber <= 1 && posle.Offset > 0 {
+		// Try to locate the line number from the content if offset is set.
+		ectx = locateError(r, fe, func(m LineMatcher) int {
+			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 linematcher(m)
+			}
+			return -1
+		})
+	} else {
+		ectx = locateError(r, fe, linematcher)
+	}
+
+	if ectx.ChromaLexer == "" {
+		if fe.fileType != "" {
+			ectx.ChromaLexer = chromaLexerFromType(fe.fileType)
+		} else {
+			ectx.ChromaLexer = chromaLexerFromFilename(fe.Position().Filename)
+		}
+	}
+
+	fe.errorContext = ectx
+
+	if ectx.Position.LineNumber > 0 {
+		fe.position.LineNumber = ectx.Position.LineNumber
+	}
+
+	if ectx.Position.ColumnNumber > 0 {
+		fe.position.ColumnNumber = ectx.Position.ColumnNumber
+	}
+
+	return fe
+
+}
 
 type fileError struct {
-	position text.Position
+	position     text.Position
+	errorContext *ErrorContext
 
 	fileType string
 
 	cause error
 }
 
+func (e *fileError) ErrorContext() *ErrorContext {
+	return e.errorContext
+}
+
 // 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 {
+	return fmt.Sprintf("%s: %s", e.position, e.causeString())
 }
 
-func (e *fileError) Error() string {
+func (e *fileError) causeString() string {
 	if e.cause == nil {
 		return ""
 	}
-	return e.cause.Error()
+	switch v := e.cause.(type) {
+	// Avoid repeating the file info in the error message.
+	case godartsass.SassError:
+		return v.Message
+	case libsasserrors.Error:
+		return v.Message
+	default:
+		return v.Error()
+	}
 }
 
-func (f *fileError) Cause() error {
-	return f.cause
+func (e *fileError) Unwrap() error {
+	return e.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}
+// NewFileError creates a new FileError that wraps err.
+// It will try to extract the filename and line number from err.
+func NewFileError(err error) FileError {
+	// Filetype is used to determine the Chroma lexer to use.
+	fileType, pos := extractFileTypePos(err)
 	return &fileError{cause: err, fileType: fileType, position: pos}
 }
 
+// NewFileErrorFromName creates a new FileError that wraps err.
+// The value for name should identify the file, the best
+// being the full filename to the file on disk.
+func NewFileErrorFromName(err error, name string) FileError {
+	// Filetype is used to determine the Chroma lexer to use.
+	fileType, pos := extractFileTypePos(err)
+	pos.Filename = name
+	if fileType == "" {
+		_, fileType = paths.FileAndExtNoDelimiter(filepath.Clean(name))
+	}
+
+	return &fileError{cause: err, fileType: fileType, position: pos}
+
+}
+
+// NewFileErrorFromPos will use the filename and line number from pos to create a new FileError, wrapping err.
+func NewFileErrorFromPos(err error, pos text.Position) FileError {
+	// Filetype is used to determine the Chroma lexer to use.
+	fileType, _ := extractFileTypePos(err)
+	if fileType == "" {
+		_, fileType = paths.FileAndExtNoDelimiter(filepath.Clean(pos.Filename))
+	}
+	return &fileError{cause: err, fileType: fileType, position: pos}
+
+}
+
+func NewFileErrorFromFileInErr(err error, fs afero.Fs, linematcher LineMatcherFn) FileError {
+	fe := NewFileError(err)
+	pos := fe.Position()
+	if pos.Filename == "" {
+		return fe
+	}
+
+	f, realFilename, err2 := openFile(pos.Filename, fs)
+	if err2 != nil {
+		return fe
+	}
+
+	pos.Filename = realFilename
+	defer f.Close()
+	return fe.UpdateContent(f, linematcher)
+}
+
+func NewFileErrorFromFileInPos(err error, pos text.Position, fs afero.Fs, linematcher LineMatcherFn) FileError {
+	if err == nil {
+		panic("err is nil")
+	}
+	f, realFilename, err2 := openFile(pos.Filename, fs)
+	if err2 != nil {
+		return NewFileErrorFromPos(err, pos)
+	}
+	pos.Filename = realFilename
+	defer f.Close()
+	return NewFileErrorFromPos(err, pos).UpdateContent(f, linematcher)
+}
+
+// NewFileErrorFromFile is a convenience method to create a new FileError from a file.
+func NewFileErrorFromFile(err error, filename string, fs afero.Fs, linematcher LineMatcherFn) FileError {
+	if err == nil {
+		panic("err is nil")
+	}
+	f, realFilename, err2 := openFile(filename, fs)
+	if err2 != nil {
+		return NewFileErrorFromName(err, realFilename)
+	}
+	defer f.Close()
+	return NewFileErrorFromName(err, realFilename).UpdateContent(f, linematcher)
+}
+
+func openFile(filename string, fs afero.Fs) (afero.File, string, error) {
+	realFilename := filename
+
+	// We want the most specific filename possible in the error message.
+	fi, err2 := fs.Stat(filename)
+	if err2 == nil {
+		if s, ok := fi.(interface {
+			Filename() string
+		}); ok {
+			realFilename = s.Filename()
+		}
+
+	}
+
+	f, err2 := fs.Open(filename)
+	if err2 != nil {
+		return nil, realFilename, err2
+	}
+
+	return f, realFilename, nil
+}
+
+// Cause returns the underlying error or itself if it does not implement Unwrap.
+func Cause(err error) error {
+	if u := errors.Unwrap(err); u != nil {
+		return u
+	}
+	return err
+}
+
+func extractFileTypePos(err error) (string, text.Position) {
+	err = Cause(err)
+
+	var fileType string
+
+	// LibSass, DartSass
+	if pos := extractPosition(err); pos.LineNumber > 0 || pos.Offset > 0 {
+		_, fileType = paths.FileAndExtNoDelimiter(pos.Filename)
+		return fileType, pos
+	}
+
+	// Default to line 1 col 1 if we don't find any better.
+	pos := text.Position{
+		Offset:       -1,
+		LineNumber:   1,
+		ColumnNumber: 1,
+	}
+
+	// JSON errors.
+	offset, typ := extractOffsetAndType(err)
+	if fileType == "" {
+		fileType = typ
+	}
+
+	if offset >= 0 {
+		pos.Offset = offset
+	}
+
+	// The error type from the minifier contains line number and column number.
+	if line, col := exctractLineNumberAndColumnNumber(err); line >= 0 {
+		pos.LineNumber = line
+		pos.ColumnNumber = col
+		return fileType, pos
+	}
+
+	// Look in the error message for the line number.
+	for _, handle := range lineNumberExtractors {
+		lno, col := handle(err)
+		if lno > 0 {
+			pos.ColumnNumber = col
+			pos.LineNumber = lno
+			break
+		}
+	}
+
+	if fileType == "" && pos.Filename != "" {
+		_, fileType = paths.FileAndExtNoDelimiter(pos.Filename)
+	}
+
+	return fileType, pos
+}
+
 // UnwrapFileError tries to unwrap a FileError from err.
 // It returns nil if this is not possible.
 func UnwrapFileError(err error) FileError {
@@ -77,49 +322,38 @@ func UnwrapFileError(err error) FileError {
 		switch v := err.(type) {
 		case FileError:
 			return v
-		case causer:
-			err = v.Cause()
 		default:
-			return nil
+			err = errors.Unwrap(err)
 		}
 	}
 	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)
+// UnwrapFileErrors tries to unwrap all FileError.
+func UnwrapFileErrors(err error) []FileError {
+	var errs []FileError
+	for err != nil {
+		if v, ok := err.(FileError); ok {
+			errs = append(errs, v)
 		}
+		err = errors.Unwrap(err)
 	}
-	// Fall back to the pointing to line number 1.
-	return NewFileError(fileType, -1, 1, 1, err)
+	return errs
+}
+
+// UnwrapFileErrorsWithErrorContext tries to unwrap all FileError in err that has an ErrorContext.
+func UnwrapFileErrorsWithErrorContext(err error) []FileError {
+	var errs []FileError
+	for err != nil {
+		if v, ok := err.(FileError); ok && v.ErrorContext() != nil {
+			errs = append(errs, v)
+		}
+		err = errors.Unwrap(err)
+	}
+	return errs
 }
 
 func extractOffsetAndType(e error) (int, string) {
-	e = errors.Cause(e)
 	switch v := e.(type) {
 	case *json.UnmarshalTypeError:
 		return int(v.Offset), "json"
@@ -129,3 +363,32 @@ func extractOffsetAndType(e error) (int, string) {
 		return -1, ""
 	}
 }
+
+func exctractLineNumberAndColumnNumber(e error) (int, int) {
+	switch v := e.(type) {
+	case *parse.Error:
+		return v.Line, v.Column
+	case *toml.DecodeError:
+		return v.Position()
+
+	}
+
+	return -1, -1
+}
+
+func extractPosition(e error) (pos text.Position) {
+	switch v := e.(type) {
+	case godartsass.SassError:
+		span := v.Span
+		start := span.Start
+		filename, _ := paths.UrlToFilename(span.Url)
+		pos.Filename = filename
+		pos.Offset = start.Offset
+		pos.ColumnNumber = start.Column
+	case libsasserrors.Error:
+		pos.Filename = v.File
+		pos.LineNumber = v.Line
+		pos.ColumnNumber = v.Column
+	}
+	return
+}

common/herrors/file_error_test.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2022 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.
@@ -14,14 +14,44 @@
 package herrors
 
 import (
+	"fmt"
+	"strings"
 	"testing"
 
-	"github.com/pkg/errors"
+	"errors"
+
+	"github.com/gohugoio/hugo/common/text"
 
 	qt "github.com/frankban/quicktest"
 )
 
-func TestToLineNumberError(t *testing.T) {
+func TestNewFileError(t *testing.T) {
+	t.Parallel()
+
+	c := qt.New(t)
+
+	fe := NewFileErrorFromName(errors.New("bar"), "foo.html")
+	c.Assert(fe.Error(), qt.Equals, `"foo.html:1:1": bar`)
+
+	lines := ""
+	for i := 1; i <= 100; i++ {
+		lines += fmt.Sprintf("line %d\n", i)
+	}
+
+	fe.UpdatePosition(text.Position{LineNumber: 32, ColumnNumber: 2})
+	c.Assert(fe.Error(), qt.Equals, `"foo.html:32:2": bar`)
+	fe.UpdatePosition(text.Position{LineNumber: 0, ColumnNumber: 0, Offset: 212})
+	fe.UpdateContent(strings.NewReader(lines), nil)
+	c.Assert(fe.Error(), qt.Equals, `"foo.html:32:0": bar`)
+	errorContext := fe.ErrorContext()
+	c.Assert(errorContext, qt.IsNotNil)
+	c.Assert(errorContext.Lines, qt.DeepEquals, []string{"line 30", "line 31", "line 32", "line 33", "line 34"})
+	c.Assert(errorContext.LinesPos, qt.Equals, 2)
+	c.Assert(errorContext.ChromaLexer, qt.Equals, "go-html-template")
+
+}
+
+func TestNewFileErrorExtractFromMessage(t *testing.T) {
 	t.Parallel()
 
 	c := qt.New(t)
@@ -36,20 +66,17 @@ func TestToLineNumberError(t *testing.T) {
 		{errors.New(`template: _default/single.html:4:15: executing "_default/single.html" at <.Titles>: can't evaluate field Titles in type *hugolib.PageOutput`), 0, 4, 15},
 		{errors.New("parse failed: template: _default/bundle-resource-meta.html:11: unexpected in operand"), 0, 11, 1},
 		{errors.New(`failed:: template: _default/bundle-resource-meta.html:2:7: executing "main" at <.Titles>`), 0, 2, 7},
-		{errors.New("error in front matter: Near line 32 (last key parsed 'title')"), 0, 32, 1},
 		{errors.New(`failed to load translations: (6, 7): was expecting token =, but got "g" instead`), 0, 6, 7},
+		{errors.New(`execute of template failed: template: index.html:2:5: executing "index.html" at <partial "foo.html" .>: error calling partial: "/layouts/partials/foo.html:3:6": execute of template failed: template: partials/foo.html:3:6: executing "partials/foo.html" at <.ThisDoesNotExist>: can't evaluate field ThisDoesNotExist in type *hugolib.pageStat`), 0, 2, 5},
 	} {
 
-		got := ToFileError("template", test.in)
+		got := NewFileErrorFromName(test.in, "test.txt")
 
 		errMsg := qt.Commentf("[%d][%T]", i, got)
-		le, ok := got.(FileError)
-		c.Assert(ok, qt.Equals, true)
 
-		c.Assert(ok, qt.Equals, true, errMsg)
-		pos := le.Position()
+		pos := got.Position()
 		c.Assert(pos.LineNumber, qt.Equals, test.lineNumber, errMsg)
 		c.Assert(pos.ColumnNumber, qt.Equals, test.columnNumber, errMsg)
-		c.Assert(errors.Cause(got), qt.Not(qt.IsNil))
+		c.Assert(errors.Unwrap(got), qt.Not(qt.IsNil))
 	}
 }

common/herrors/line_number_extractors.go

@@ -20,17 +20,14 @@ import (
 
 var lineNumberExtractors = []lineNumberExtractor{
 	// Template/shortcode parse errors
-	newLineNumberErrHandlerFromRegexp(".*:(\\d+):(\\d*):"),
-	newLineNumberErrHandlerFromRegexp(".*:(\\d+):"),
-
-	// TOML parse errors
-	newLineNumberErrHandlerFromRegexp(".*Near line (\\d+)(\\s.*)"),
+	newLineNumberErrHandlerFromRegexp(`:(\d+):(\d*):`),
+	newLineNumberErrHandlerFromRegexp(`:(\d+):`),
 
 	// YAML parse errors
-	newLineNumberErrHandlerFromRegexp("line (\\d+):"),
+	newLineNumberErrHandlerFromRegexp(`line (\d+):`),
 
 	// i18n bundle errors
-	newLineNumberErrHandlerFromRegexp("\\((\\d+),\\s(\\d*)"),
+	newLineNumberErrHandlerFromRegexp(`\((\d+),\s(\d*)`),
 }
 
 type lineNumberExtractor func(e error) (int, int)
@@ -61,6 +58,6 @@ func extractLineNo(re *regexp.Regexp) lineNumberExtractor {
 			return lno, col
 		}
 
-		return -1, col
+		return 0, col
 	}
 }

common/hexec/exec.go

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

common/hexec/safeCommand.go

@@ -1,45 +0,0 @@
-// Copyright 2020 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package hexec
-
-import (
-	"context"
-
-	"os/exec"
-
-	"github.com/cli/safeexec"
-)
-
-// SafeCommand is a wrapper around os/exec Command which uses a LookPath
-// implementation that does not search in current directory before looking in PATH.
-// See https://github.com/cli/safeexec and the linked issues.
-func SafeCommand(name string, arg ...string) (*exec.Cmd, error) {
-	bin, err := safeexec.LookPath(name)
-	if err != nil {
-		return nil, err
-	}
-
-	return exec.Command(bin, arg...), nil
-}
-
-// SafeCommandContext wraps CommandContext
-// See SafeCommand for more context.
-func SafeCommandContext(ctx context.Context, name string, arg ...string) (*exec.Cmd, error) {
-	bin, err := safeexec.LookPath(name)
-	if err != nil {
-		return nil, err
-	}
-
-	return exec.CommandContext(ctx, bin, arg...), nil
-}

common/hreflect/helpers.go

@@ -17,8 +17,12 @@
 package hreflect
 
 import (
+	"context"
 	"reflect"
+	"sync"
+	"time"
 
+	"github.com/gohugoio/hugo/common/htime"
 	"github.com/gohugoio/hugo/common/types"
 )
 
@@ -60,7 +64,7 @@ func IsFloat(kind reflect.Kind) bool {
 
 // IsTruthful returns whether in represents a truthful value.
 // See IsTruthfulValue
-func IsTruthful(in interface{}) bool {
+func IsTruthful(in any) bool {
 	switch v := in.(type) {
 	case reflect.Value:
 		return IsTruthfulValue(v)
@@ -114,6 +118,96 @@ func IsTruthfulValue(val reflect.Value) (truth bool) {
 	return
 }
 
+type methodKey struct {
+	typ  reflect.Type
+	name string
+}
+
+type methods struct {
+	sync.RWMutex
+	cache map[methodKey]int
+}
+
+var methodCache = &methods{cache: make(map[methodKey]int)}
+
+// GetMethodByName is the same as reflect.Value.MethodByName, but it caches the
+// type lookup.
+func GetMethodByName(v reflect.Value, name string) reflect.Value {
+	index := GetMethodIndexByName(v.Type(), name)
+
+	if index == -1 {
+		return reflect.Value{}
+	}
+
+	return v.Method(index)
+}
+
+// GetMethodIndexByName returns the index of the method with the given name, or
+// -1 if no such method exists.
+func GetMethodIndexByName(tp reflect.Type, name string) int {
+	k := methodKey{tp, name}
+	methodCache.RLock()
+	index, found := methodCache.cache[k]
+	methodCache.RUnlock()
+	if found {
+		return index
+	}
+
+	methodCache.Lock()
+	defer methodCache.Unlock()
+
+	m, ok := tp.MethodByName(name)
+	index = m.Index
+	if !ok {
+		index = -1
+	}
+	methodCache.cache[k] = index
+
+	if !ok {
+		return -1
+	}
+
+	return m.Index
+}
+
+var (
+	timeType           = reflect.TypeOf((*time.Time)(nil)).Elem()
+	asTimeProviderType = reflect.TypeOf((*htime.AsTimeProvider)(nil)).Elem()
+)
+
+// IsTime returns whether tp is a time.Time type or if it can be converted into one
+// in ToTime.
+func IsTime(tp reflect.Type) bool {
+	if tp == timeType {
+		return true
+	}
+
+	if tp.Implements(asTimeProviderType) {
+		return true
+	}
+	return false
+}
+
+// AsTime returns v as a time.Time if possible.
+// The given location is only used if the value implements AsTimeProvider (e.g. go-toml local).
+// A zero Time and false is returned if this isn't possible.
+// Note that this function does not accept string dates.
+func AsTime(v reflect.Value, loc *time.Location) (time.Time, bool) {
+	if v.Kind() == reflect.Interface {
+		return AsTime(v.Elem(), loc)
+	}
+
+	if v.Type() == timeType {
+		return v.Interface().(time.Time), true
+	}
+
+	if v.Type().Implements(asTimeProviderType) {
+		return v.Interface().(htime.AsTimeProvider).AsTime(loc), true
+	}
+
+	return time.Time{}, false
+}
+
 // Based on: https://github.com/golang/go/blob/178a2c42254166cffed1b25fb1d3c7a5727cada6/src/text/template/exec.go#L931
 func indirectInterface(v reflect.Value) reflect.Value {
 	if v.Kind() != reflect.Interface {
@@ -124,3 +218,5 @@ func indirectInterface(v reflect.Value) reflect.Value {
 	}
 	return v.Elem()
 }
+
+var ContextInterface = reflect.TypeOf((*context.Context)(nil)).Elem()

common/hreflect/helpers_test.go

@@ -30,6 +30,16 @@ func TestIsTruthful(t *testing.T) {
 	c.Assert(IsTruthful(time.Time{}), qt.Equals, false)
 }
 
+func TestGetMethodByName(t *testing.T) {
+	c := qt.New(t)
+	v := reflect.ValueOf(&testStruct{})
+	tp := v.Type()
+
+	c.Assert(GetMethodIndexByName(tp, "Method1"), qt.Equals, 0)
+	c.Assert(GetMethodIndexByName(tp, "Method3"), qt.Equals, 2)
+	c.Assert(GetMethodIndexByName(tp, "Foo"), qt.Equals, -1)
+}
+
 func BenchmarkIsTruthFul(b *testing.B) {
 	v := reflect.ValueOf("Hugo")
 
@@ -40,3 +50,37 @@ func BenchmarkIsTruthFul(b *testing.B) {
 		}
 	}
 }
+
+type testStruct struct{}
+
+func (t *testStruct) Method1() string {
+	return "Hugo"
+}
+
+func (t *testStruct) Method2() string {
+	return "Hugo"
+}
+
+func (t *testStruct) Method3() string {
+	return "Hugo"
+}
+
+func (t *testStruct) Method4() string {
+	return "Hugo"
+}
+
+func (t *testStruct) Method5() string {
+	return "Hugo"
+}
+
+func BenchmarkGetMethodByName(b *testing.B) {
+	v := reflect.ValueOf(&testStruct{})
+	methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, method := range methods {
+			_ = GetMethodByName(v, method)
+		}
+	}
+}

common/htime/time.go

@@ -0,0 +1,165 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package htime
+
+import (
+	"strings"
+	"time"
+
+	"github.com/bep/clock"
+	"github.com/spf13/cast"
+
+	"github.com/gohugoio/locales"
+)
+
+var (
+	longDayNames = []string{
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday",
+	}
+
+	shortDayNames = []string{
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat",
+	}
+
+	shortMonthNames = []string{
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec",
+	}
+
+	longMonthNames = []string{
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December",
+	}
+
+	Clock = clock.System()
+)
+
+func NewTimeFormatter(ltr locales.Translator) TimeFormatter {
+	if ltr == nil {
+		panic("must provide a locales.Translator")
+	}
+	return TimeFormatter{
+		ltr: ltr,
+	}
+}
+
+// TimeFormatter is locale aware.
+type TimeFormatter struct {
+	ltr locales.Translator
+}
+
+func (f TimeFormatter) Format(t time.Time, layout string) string {
+	if layout == "" {
+		return ""
+	}
+
+	if layout[0] == ':' {
+		// It may be one of Hugo's custom layouts.
+		switch strings.ToLower(layout[1:]) {
+		case "date_full":
+			return f.ltr.FmtDateFull(t)
+		case "date_long":
+			return f.ltr.FmtDateLong(t)
+		case "date_medium":
+			return f.ltr.FmtDateMedium(t)
+		case "date_short":
+			return f.ltr.FmtDateShort(t)
+		case "time_full":
+			return f.ltr.FmtTimeFull(t)
+		case "time_long":
+			return f.ltr.FmtTimeLong(t)
+		case "time_medium":
+			return f.ltr.FmtTimeMedium(t)
+		case "time_short":
+			return f.ltr.FmtTimeShort(t)
+		}
+	}
+
+	s := t.Format(layout)
+
+	monthIdx := t.Month() - 1 // Month() starts at 1.
+	dayIdx := t.Weekday()
+
+	s = strings.ReplaceAll(s, longMonthNames[monthIdx], f.ltr.MonthWide(t.Month()))
+	if !strings.Contains(s, f.ltr.MonthWide(t.Month())) {
+		s = strings.ReplaceAll(s, shortMonthNames[monthIdx], f.ltr.MonthAbbreviated(t.Month()))
+	}
+	s = strings.ReplaceAll(s, longDayNames[dayIdx], f.ltr.WeekdayWide(t.Weekday()))
+	if !strings.Contains(s, f.ltr.WeekdayWide(t.Weekday())) {
+		s = strings.ReplaceAll(s, shortDayNames[dayIdx], f.ltr.WeekdayAbbreviated(t.Weekday()))
+	}
+
+	return s
+}
+
+func ToTimeInDefaultLocationE(i any, location *time.Location) (tim time.Time, err error) {
+	switch vv := i.(type) {
+	case AsTimeProvider:
+		return vv.AsTime(location), nil
+	// issue #8895
+	// datetimes parsed by `go-toml` have empty zone name
+	// convert back them into string and use `cast`
+	// TODO(bep) add tests, make sure we really need this.
+	case time.Time:
+		i = vv.Format(time.RFC3339)
+	}
+	return cast.ToTimeInDefaultLocationE(i, location)
+}
+
+// Now returns time.Now() or time value based on the `clock` flag.
+// Use this function to fake time inside hugo.
+func Now() time.Time {
+	return Clock.Now()
+}
+
+func Since(t time.Time) time.Duration {
+	return Clock.Since(t)
+}
+
+// AsTimeProvider is implemented by go-toml's LocalDate and LocalDateTime.
+type AsTimeProvider interface {
+	AsTime(zone *time.Location) time.Time
+}

common/htime/time_test.go

@@ -0,0 +1,148 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package htime
+
+import (
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+	translators "github.com/gohugoio/localescompressed"
+)
+
+func TestTimeFormatter(t *testing.T) {
+	c := qt.New(t)
+
+	june06, _ := time.Parse("2006-Jan-02", "2018-Jun-06")
+	june06 = june06.Add(7777 * time.Second)
+
+	jan06, _ := time.Parse("2006-Jan-02", "2018-Jan-06")
+	jan06 = jan06.Add(32 * time.Second)
+
+	mondayNovemberFirst, _ := time.Parse("2006-Jan-02", "2021-11-01")
+	mondayNovemberFirst = mondayNovemberFirst.Add(33 * time.Second)
+
+	c.Run("Norsk nynorsk", func(c *qt.C) {
+		f := NewTimeFormatter(translators.GetTranslator("nn"))
+
+		c.Assert(f.Format(june06, "Monday Jan 2 2006"), qt.Equals, "onsdag juni 6 2018")
+		c.Assert(f.Format(june06, "Mon January 2 2006"), qt.Equals, "on. juni 6 2018")
+		c.Assert(f.Format(june06, "Mon Mon"), qt.Equals, "on. on.")
+	})
+
+	c.Run("Custom layouts Norsk nynorsk", func(c *qt.C) {
+		f := NewTimeFormatter(translators.GetTranslator("nn"))
+
+		c.Assert(f.Format(june06, ":date_full"), qt.Equals, "onsdag 6. juni 2018")
+		c.Assert(f.Format(june06, ":date_long"), qt.Equals, "6. juni 2018")
+		c.Assert(f.Format(june06, ":date_medium"), qt.Equals, "6. juni 2018")
+		c.Assert(f.Format(june06, ":date_short"), qt.Equals, "06.06.2018")
+
+		c.Assert(f.Format(june06, ":time_full"), qt.Equals, "kl. 02:09:37 UTC")
+		c.Assert(f.Format(june06, ":time_long"), qt.Equals, "02:09:37 UTC")
+		c.Assert(f.Format(june06, ":time_medium"), qt.Equals, "02:09:37")
+		c.Assert(f.Format(june06, ":time_short"), qt.Equals, "02:09")
+
+	})
+
+	c.Run("Custom layouts English", func(c *qt.C) {
+		f := NewTimeFormatter(translators.GetTranslator("en"))
+
+		c.Assert(f.Format(june06, ":date_full"), qt.Equals, "Wednesday, June 6, 2018")
+		c.Assert(f.Format(june06, ":date_long"), qt.Equals, "June 6, 2018")
+		c.Assert(f.Format(june06, ":date_medium"), qt.Equals, "Jun 6, 2018")
+		c.Assert(f.Format(june06, ":date_short"), qt.Equals, "6/6/18")
+
+		c.Assert(f.Format(june06, ":time_full"), qt.Equals, "2:09:37 am UTC")
+		c.Assert(f.Format(june06, ":time_long"), qt.Equals, "2:09:37 am UTC")
+		c.Assert(f.Format(june06, ":time_medium"), qt.Equals, "2:09:37 am")
+		c.Assert(f.Format(june06, ":time_short"), qt.Equals, "2:09 am")
+
+	})
+
+	c.Run("English", func(c *qt.C) {
+		f := NewTimeFormatter(translators.GetTranslator("en"))
+
+		c.Assert(f.Format(june06, "Monday Jan 2 2006"), qt.Equals, "Wednesday Jun 6 2018")
+		c.Assert(f.Format(june06, "Mon January 2 2006"), qt.Equals, "Wed June 6 2018")
+		c.Assert(f.Format(june06, "Mon Mon"), qt.Equals, "Wed Wed")
+	})
+
+	c.Run("Weekdays German", func(c *qt.C) {
+		tr := translators.GetTranslator("de")
+		f := NewTimeFormatter(tr)
+
+		// Issue #9107
+		for i, weekDayWideGerman := range []string{"Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"} {
+			date := mondayNovemberFirst.Add(time.Duration(i*24) * time.Hour)
+			c.Assert(tr.WeekdayWide(date.Weekday()), qt.Equals, weekDayWideGerman)
+			c.Assert(f.Format(date, "Monday"), qt.Equals, weekDayWideGerman)
+		}
+
+		for i, weekDayAbbreviatedGerman := range []string{"Mo.", "Di.", "Mi.", "Do.", "Fr.", "Sa.", "So."} {
+			date := mondayNovemberFirst.Add(time.Duration(i*24) * time.Hour)
+			c.Assert(tr.WeekdayAbbreviated(date.Weekday()), qt.Equals, weekDayAbbreviatedGerman)
+			c.Assert(f.Format(date, "Mon"), qt.Equals, weekDayAbbreviatedGerman)
+		}
+	})
+
+	c.Run("Months German", func(c *qt.C) {
+		tr := translators.GetTranslator("de")
+		f := NewTimeFormatter(tr)
+
+		// Issue #9107
+		for i, monthWideNorway := range []string{"Januar", "Februar", "März", "April", "Mai", "Juni", "Juli"} {
+			date := jan06.Add(time.Duration(i*24*31) * time.Hour)
+			c.Assert(tr.MonthWide(date.Month()), qt.Equals, monthWideNorway)
+			c.Assert(f.Format(date, "January"), qt.Equals, monthWideNorway)
+		}
+
+	})
+
+}
+
+func BenchmarkTimeFormatter(b *testing.B) {
+	june06, _ := time.Parse("2006-Jan-02", "2018-Jun-06")
+
+	b.Run("Native", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			got := june06.Format("Monday Jan 2 2006")
+			if got != "Wednesday Jun 6 2018" {
+				b.Fatalf("invalid format, got %q", got)
+			}
+		}
+	})
+
+	b.Run("Localized", func(b *testing.B) {
+		f := NewTimeFormatter(translators.GetTranslator("nn"))
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			got := f.Format(june06, "Monday Jan 2 2006")
+			if got != "onsdag juni 6 2018" {
+				b.Fatalf("invalid format, got %q", got)
+			}
+		}
+	})
+
+	b.Run("Localized Custom", func(b *testing.B) {
+		f := NewTimeFormatter(translators.GetTranslator("nn"))
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			got := f.Format(june06, ":date_medium")
+			if got != "6. juni 2018" {
+				b.Fatalf("invalid format, got %q", got)
+			}
+		}
+	})
+}

common/hugio/copy.go

@@ -14,13 +14,10 @@
 package hugio
 
 import (
+	"fmt"
 	"io"
-	"io/ioutil"
-	"os"
 	"path/filepath"
 
-	"github.com/pkg/errors"
-
 	"github.com/spf13/afero"
 )
 
@@ -54,13 +51,13 @@ func CopyFile(fs afero.Fs, from, to string) error {
 
 // CopyDir copies a directory.
 func CopyDir(fs afero.Fs, from, to string, shouldCopy func(filename string) bool) error {
-	fi, err := os.Stat(from)
+	fi, err := fs.Stat(from)
 	if err != nil {
 		return err
 	}
 
 	if !fi.IsDir() {
-		return errors.Errorf("%q is not a directory", from)
+		return fmt.Errorf("%q is not a directory", from)
 	}
 
 	err = fs.MkdirAll(to, 0777) // before umask
@@ -68,7 +65,7 @@ func CopyDir(fs afero.Fs, from, to string, shouldCopy func(filename string) bool
 		return err
 	}
 
-	entries, _ := ioutil.ReadDir(from)
+	entries, _ := afero.ReadDir(fs, from)
 	for _, entry := range entries {
 		fromFilename := filepath.Join(from, entry.Name())
 		toFilename := filepath.Join(to, entry.Name())

common/hugio/readers.go

@@ -31,6 +31,11 @@ type ReadSeekCloser interface {
 	io.Closer
 }
 
+// ReadSeekCloserProvider provides a ReadSeekCloser.
+type ReadSeekCloserProvider interface {
+	ReadSeekCloser() (ReadSeekCloser, error)
+}
+
 // ReadSeekerNoOpCloser implements ReadSeekCloser by doing nothing in Close.
 // TODO(bep) rename this and similar to ReadSeekerNopCloser, naming used in stdlib, which kind of makes sense.
 type ReadSeekerNoOpCloser struct {

common/hugio/writers.go

@@ -18,6 +18,14 @@ import (
 	"io/ioutil"
 )
 
+// As implemented by strings.Builder.
+type FlexiWriter interface {
+	io.Writer
+	io.ByteWriter
+	WriteString(s string) (int, error)
+	WriteRune(r rune) (int, error)
+}
+
 type multiWriteCloser struct {
 	io.Writer
 	closers []io.WriteCloser

common/hugo/hugo.go

@@ -21,6 +21,8 @@ import (
 	"runtime/debug"
 	"sort"
 	"strings"
+	"sync"
+	"time"
 
 	"github.com/gohugoio/hugo/hugofs/files"
 
@@ -36,13 +38,8 @@ const (
 )
 
 var (
-	// commitHash contains the current Git revision.
-	// Use mage to build to make sure this gets set.
-	commitHash string
-
-	// buildDate contains the date of the current build.
+	// buildDate allows vendor-specified build date when .git/ is unavailable.
 	buildDate string
-
 	// vendorInfo contains vendor notes about the current build.
 	vendorInfo string
 )
@@ -57,6 +54,11 @@ type Info struct {
 	// This can also be set by the user.
 	// It can be any string, but it will be all lower case.
 	Environment string
+
+	// version of go that the Hugo binary was built with
+	GoVersion string
+
+	deps []*Dependency
 }
 
 // Version returns the current version as a comparable version string.
@@ -77,20 +79,42 @@ func (i Info) IsExtended() bool {
 	return IsExtended
 }
 
+// Deps gets a list of dependencies for this Hugo build.
+func (i Info) Deps() []*Dependency {
+	return i.deps
+}
+
 // NewInfo creates a new Hugo Info object.
-func NewInfo(environment string) Info {
+func NewInfo(environment string, deps []*Dependency) Info {
 	if environment == "" {
 		environment = EnvironmentProduction
 	}
+	var (
+		commitHash string
+		buildDate  string
+		goVersion  string
+	)
+
+	bi := getBuildInfo()
+	if bi != nil {
+		commitHash = bi.Revision
+		buildDate = bi.RevisionTime
+		goVersion = bi.GoVersion
+	}
+
 	return Info{
 		CommitHash:  commitHash,
 		BuildDate:   buildDate,
 		Environment: environment,
+		deps:        deps,
+		GoVersion:   goVersion,
 	}
 }
 
+// GetExecEnviron creates and gets the common os/exec environment used in the
+// external programs we interact with via os/exec, e.g. postcss.
 func GetExecEnviron(workDir string, cfg config.Provider, fs afero.Fs) []string {
-	env := os.Environ()
+	var env []string
 	nodepath := filepath.Join(workDir, "node_modules")
 	if np := os.Getenv("NODE_PATH"); np != "" {
 		nodepath = workDir + string(os.PathListSeparator) + np
@@ -98,18 +122,68 @@ func GetExecEnviron(workDir string, cfg config.Provider, fs afero.Fs) []string {
 	config.SetEnvVars(&env, "NODE_PATH", nodepath)
 	config.SetEnvVars(&env, "PWD", workDir)
 	config.SetEnvVars(&env, "HUGO_ENVIRONMENT", cfg.GetString("environment"))
-	fis, err := afero.ReadDir(fs, files.FolderJSConfig)
-	if err == nil {
-		for _, fi := range fis {
-			key := fmt.Sprintf("HUGO_FILE_%s", strings.ReplaceAll(strings.ToUpper(fi.Name()), ".", "_"))
-			value := fi.(hugofs.FileMetaInfo).Meta().Filename()
-			config.SetEnvVars(&env, key, value)
+	config.SetEnvVars(&env, "HUGO_ENV", cfg.GetString("environment"))
+
+	if fs != nil {
+		fis, err := afero.ReadDir(fs, files.FolderJSConfig)
+		if err == nil {
+			for _, fi := range fis {
+				key := fmt.Sprintf("HUGO_FILE_%s", strings.ReplaceAll(strings.ToUpper(fi.Name()), ".", "_"))
+				value := fi.(hugofs.FileMetaInfo).Meta().Filename
+				config.SetEnvVars(&env, key, value)
+			}
 		}
 	}
 
 	return env
 }
 
+type buildInfo struct {
+	VersionControlSystem string
+	Revision             string
+	RevisionTime         string
+	Modified             bool
+
+	GoOS   string
+	GoArch string
+
+	*debug.BuildInfo
+}
+
+var bInfo *buildInfo
+var bInfoInit sync.Once
+
+func getBuildInfo() *buildInfo {
+	bInfoInit.Do(func() {
+		bi, ok := debug.ReadBuildInfo()
+		if !ok {
+			return
+		}
+
+		bInfo = &buildInfo{BuildInfo: bi}
+
+		for _, s := range bInfo.Settings {
+			switch s.Key {
+			case "vcs":
+				bInfo.VersionControlSystem = s.Value
+			case "vcs.revision":
+				bInfo.Revision = s.Value
+			case "vcs.time":
+				bInfo.RevisionTime = s.Value
+			case "vcs.modified":
+				bInfo.Modified = s.Value == "true"
+			case "GOOS":
+				bInfo.GoOS = s.Value
+			case "GOARCH":
+				bInfo.GoArch = s.Value
+			}
+		}
+
+	})
+
+	return bInfo
+}
+
 // GetDependencyList returns a sorted dependency list on the format package="version".
 // It includes both Go dependencies and (a manually maintained) list of C(++) dependencies.
 func GetDependencyList() []string {
@@ -122,13 +196,14 @@ func GetDependencyList() []string {
 	if IsExtended {
 		deps = append(
 			deps,
-			formatDep("github.com/sass/libsass", "3.6.4"),
+			// TODO(bep) consider adding a DepsNonGo() method to these upstream projects.
+			formatDep("github.com/sass/libsass", "3.6.5"),
 			formatDep("github.com/webmproject/libwebp", "v1.2.0"),
 		)
 	}
 
-	bi, ok := debug.ReadBuildInfo()
-	if !ok {
+	bi := getBuildInfo()
+	if bi == nil {
 		return deps
 	}
 
@@ -140,3 +215,37 @@ func GetDependencyList() []string {
 
 	return deps
 }
+
+// IsRunningAsTest reports whether we are running as a test.
+func IsRunningAsTest() bool {
+	for _, arg := range os.Args {
+		if strings.HasPrefix(arg, "-test") {
+			return true
+		}
+	}
+	return false
+}
+
+// Dependency is a single dependency, which can be either a Hugo Module or a local theme.
+type Dependency struct {
+	// Returns the path to this module.
+	// This will either be the module path, e.g. "github.com/gohugoio/myshortcodes",
+	// or the path below your /theme folder, e.g. "mytheme".
+	Path string
+
+	// The module version.
+	Version string
+
+	// Whether this dependency is vendored.
+	Vendor bool
+
+	// Time version was created.
+	Time time.Time
+
+	// In the dependency tree, this is the first module that defines this module
+	// as a dependency.
+	Owner *Dependency
+
+	// Replaced by this dependency.
+	Replace *Dependency
+}

common/hugo/hugo_test.go

@@ -23,17 +23,22 @@ import (
 func TestHugoInfo(t *testing.T) {
 	c := qt.New(t)
 
-	hugoInfo := NewInfo("")
+	hugoInfo := NewInfo("", nil)
 
 	c.Assert(hugoInfo.Version(), qt.Equals, CurrentVersion.Version())
 	c.Assert(fmt.Sprintf("%T", VersionString("")), qt.Equals, fmt.Sprintf("%T", hugoInfo.Version()))
-	c.Assert(hugoInfo.CommitHash, qt.Equals, commitHash)
-	c.Assert(hugoInfo.BuildDate, qt.Equals, buildDate)
+
+	bi := getBuildInfo()
+	if bi != nil {
+		c.Assert(hugoInfo.CommitHash, qt.Equals, bi.Revision)
+		c.Assert(hugoInfo.BuildDate, qt.Equals, bi.RevisionTime)
+		c.Assert(hugoInfo.GoVersion, qt.Equals, bi.GoVersion)
+	}
 	c.Assert(hugoInfo.Environment, qt.Equals, "production")
 	c.Assert(string(hugoInfo.Generator()), qt.Contains, fmt.Sprintf("Hugo %s", hugoInfo.Version()))
 	c.Assert(hugoInfo.IsProduction(), qt.Equals, true)
 	c.Assert(hugoInfo.IsExtended(), qt.Equals, IsExtended)
 
-	devHugoInfo := NewInfo("development")
+	devHugoInfo := NewInfo("development", nil)
 	c.Assert(devHugoInfo.IsProduction(), qt.Equals, false)
 }

common/hugo/vars_extended.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build extended
 // +build extended
 
 package hugo

common/hugo/vars_regular.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !extended
 // +build !extended
 
 package hugo

common/hugo/version.go

@@ -16,7 +16,9 @@ package hugo
 import (
 	"fmt"
 	"io"
+	"math"
 	"runtime"
+	"strconv"
 	"strings"
 
 	"github.com/gohugoio/hugo/compare"
@@ -25,8 +27,9 @@ import (
 
 // Version represents the Hugo build version.
 type Version struct {
-	// Major and minor version.
-	Number float32
+	Major int
+
+	Minor int
 
 	// Increment this for bug releases
 	PatchLevel int
@@ -42,7 +45,7 @@ var (
 )
 
 func (v Version) String() string {
-	return version(v.Number, v.PatchLevel, v.Suffix)
+	return version(v.Major, v.Minor, v.PatchLevel, v.Suffix)
 }
 
 // Version returns the Hugo version.
@@ -50,6 +53,11 @@ func (v Version) Version() VersionString {
 	return VersionString(v.String())
 }
 
+// Compare implements the compare.Comparer interface.
+func (h Version) Compare(other any) int {
+	return compareVersions(h, other)
+}
+
 // VersionString represents a Hugo version string.
 type VersionString string
 
@@ -58,13 +66,13 @@ func (h VersionString) String() string {
 }
 
 // Compare implements the compare.Comparer interface.
-func (h VersionString) Compare(other interface{}) int {
+func (h VersionString) Compare(other any) int {
 	v := MustParseVersion(h.String())
-	return compareVersionsWithSuffix(v.Number, v.PatchLevel, v.Suffix, other)
+	return compareVersions(v, other)
 }
 
 // Eq implements the compare.Eqer interface.
-func (h VersionString) Eq(other interface{}) bool {
+func (h VersionString) Eq(other any) bool {
 	s, err := cast.ToStringE(other)
 	if err != nil {
 		return false
@@ -84,10 +92,7 @@ func ParseVersion(s string) (Version, error) {
 		}
 	}
 
-	v, p := parseVersion(s)
-
-	vv.Number = v
-	vv.PatchLevel = p
+	vv.Major, vv.Minor, vv.PatchLevel = parseVersion(s)
 
 	return vv, nil
 }
@@ -110,18 +115,20 @@ func (v Version) ReleaseVersion() Version {
 
 // Next returns the next Hugo release version.
 func (v Version) Next() Version {
-	return Version{Number: v.Number + 0.01}
+	return Version{Major: v.Major, Minor: v.Minor + 1}
 }
 
 // Prev returns the previous Hugo release version.
 func (v Version) Prev() Version {
-	return Version{Number: v.Number - 0.01}
+	return Version{Major: v.Major, Minor: v.Minor - 1}
 }
 
 // NextPatchLevel returns the next patch/bugfix Hugo version.
 // This will be a patch increment on the previous Hugo version.
 func (v Version) NextPatchLevel(level int) Version {
-	return Version{Number: v.Number - 0.01, PatchLevel: level}
+	prev := v.Prev()
+	prev.PatchLevel = level
+	return prev
 }
 
 // BuildVersionString creates a version string. This is what you see when
@@ -131,16 +138,25 @@ func BuildVersionString() string {
 	program := "hugo"
 
 	version := "v" + CurrentVersion.String()
-	if commitHash != "" {
-		version += "-" + strings.ToUpper(commitHash)
+
+	bi := getBuildInfo()
+	if bi == nil {
+		return version
+	}
+	if bi.Revision != "" {
+		version += "-" + bi.Revision
 	}
 	if IsExtended {
 		version += "+extended"
 	}
 
-	osArch := runtime.GOOS + "/" + runtime.GOARCH
+	osArch := bi.GoOS + "/" + bi.GoArch
 
-	date := buildDate
+	date := bi.RevisionTime
+	if date == "" {
+		// Accept vendor-specified build date if .git/ is unavailable.
+		date = buildDate
+	}
 	if date == "" {
 		date = "unknown"
 	}
@@ -155,38 +171,53 @@ func BuildVersionString() string {
 	return versionString
 }
 
-func version(version float32, patchVersion int, suffix string) string {
-	if patchVersion > 0 || version > 0.53 {
-		return fmt.Sprintf("%.2f.%d%s", version, patchVersion, suffix)
+func version(major, minor, patch int, suffix string) string {
+	if patch > 0 || minor > 53 {
+		return fmt.Sprintf("%d.%d.%d%s", major, minor, patch, suffix)
 	}
-	return fmt.Sprintf("%.2f%s", version, suffix)
+	return fmt.Sprintf("%d.%d%s", major, minor, suffix)
 }
 
 // CompareVersion compares the given version string or number against the
 // running Hugo version.
 // 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(CurrentVersion.Number, CurrentVersion.PatchLevel, CurrentVersion.Suffix, version)
+func CompareVersion(version any) int {
+	return compareVersions(CurrentVersion, version)
 }
 
-func compareVersions(inVersion float32, inPatchVersion int, in interface{}) int {
-	return compareVersionsWithSuffix(inVersion, inPatchVersion, "", in)
-}
-
-func compareVersionsWithSuffix(inVersion float32, inPatchVersion int, suffix string, in interface{}) int {
+func compareVersions(inVersion Version, in any) int {
 	var c int
 	switch d := in.(type) {
 	case float64:
-		c = compareFloatVersions(inVersion, float32(d))
+		c = compareFloatWithVersion(d, inVersion)
 	case float32:
-		c = compareFloatVersions(inVersion, d)
+		c = compareFloatWithVersion(float64(d), inVersion)
 	case int:
-		c = compareFloatVersions(inVersion, float32(d))
+		c = compareFloatWithVersion(float64(d), inVersion)
 	case int32:
-		c = compareFloatVersions(inVersion, float32(d))
+		c = compareFloatWithVersion(float64(d), inVersion)
 	case int64:
-		c = compareFloatVersions(inVersion, float32(d))
+		c = compareFloatWithVersion(float64(d), inVersion)
+	case Version:
+		if d.Major == inVersion.Major && d.Minor == inVersion.Minor && d.PatchLevel == inVersion.PatchLevel {
+			return strings.Compare(inVersion.Suffix, d.Suffix)
+		}
+		if d.Major > inVersion.Major {
+			return 1
+		} else if d.Major < inVersion.Major {
+			return -1
+		}
+		if d.Minor > inVersion.Minor {
+			return 1
+		} else if d.Minor < inVersion.Minor {
+			return -1
+		}
+		if d.PatchLevel > inVersion.PatchLevel {
+			return 1
+		} else if d.PatchLevel < inVersion.PatchLevel {
+			return -1
+		}
 	default:
 		s, err := cast.ToStringE(in)
 		if err != nil {
@@ -197,50 +228,55 @@ func compareVersionsWithSuffix(inVersion float32, inPatchVersion int, suffix str
 		if err != nil {
 			return -1
 		}
+		return inVersion.Compare(v)
 
-		if v.Number == inVersion && v.PatchLevel == inPatchVersion {
-			return strings.Compare(suffix, v.Suffix)
-		}
-
-		if v.Number < inVersion || (v.Number == inVersion && v.PatchLevel < inPatchVersion) {
-			return -1
-		}
-
-		return 1
-	}
-
-	if c == 0 && suffix != "" {
-		return 1
 	}
 
 	return c
 }
 
-func parseVersion(s string) (float32, int) {
-	var (
-		v float32
-		p int
-	)
-
-	if strings.Count(s, ".") == 2 {
-		li := strings.LastIndex(s, ".")
-		p = cast.ToInt(s[li+1:])
-		s = s[:li]
+func parseVersion(s string) (int, int, int) {
+	var major, minor, patch int
+	parts := strings.Split(s, ".")
+	if len(parts) > 0 {
+		major, _ = strconv.Atoi(parts[0])
+	}
+	if len(parts) > 1 {
+		minor, _ = strconv.Atoi(parts[1])
+	}
+	if len(parts) > 2 {
+		patch, _ = strconv.Atoi(parts[2])
 	}
 
-	v = float32(cast.ToFloat64(s))
-
-	return v, p
+	return major, minor, patch
 }
 
-func compareFloatVersions(version float32, v float32) int {
-	if v == version {
+// compareFloatWithVersion compares v1 with v2.
+// It returns -1 if v1 is less than v2, 0 if v1 is equal to v2 and 1 if v1 is greater than v2.
+func compareFloatWithVersion(v1 float64, v2 Version) int {
+	mf, minf := math.Modf(v1)
+	v1maj := int(mf)
+	v1min := int(minf * 100)
+
+	if v2.Major == v1maj && v2.Minor == v1min {
 		return 0
 	}
-	if v < version {
+
+	if v1maj > v2.Major {
+		return 1
+
+	}
+
+	if v1maj < v2.Major {
 		return -1
 	}
-	return 1
+
+	if v1min > v2.Minor {
+		return 1
+	}
+
+	return -1
+
 }
 
 func GoMinorVersion() int {

common/hugo/version_current.go

@@ -16,7 +16,8 @@ package hugo
 // CurrentVersion represents the current build version.
 // This should be the only one.
 var CurrentVersion = Version{
-	Number:     0.83,
-	PatchLevel: 0,
+	Major:      0,
+	Minor:      102,
+	PatchLevel: 2,
 	Suffix:     "",
 }

common/hugo/version_test.go

@@ -22,10 +22,10 @@ import (
 func TestHugoVersion(t *testing.T) {
 	c := qt.New(t)
 
-	c.Assert(version(0.15, 0, "-DEV"), qt.Equals, "0.15-DEV")
-	c.Assert(version(0.15, 2, "-DEV"), qt.Equals, "0.15.2-DEV")
+	c.Assert(version(0, 15, 0, "-DEV"), qt.Equals, "0.15-DEV")
+	c.Assert(version(0, 15, 2, "-DEV"), qt.Equals, "0.15.2-DEV")
 
-	v := Version{Number: 0.21, PatchLevel: 0, Suffix: "-DEV"}
+	v := Version{Minor: 21, Suffix: "-DEV"}
 
 	c.Assert(v.ReleaseVersion().String(), qt.Equals, "0.21")
 	c.Assert(v.String(), qt.Equals, "0.21-DEV")
@@ -39,37 +39,36 @@ func TestHugoVersion(t *testing.T) {
 
 	// We started to use full semver versions even for main
 	// releases in v0.54.0
-	v = Version{Number: 0.53, PatchLevel: 0}
+	v = Version{Minor: 53, PatchLevel: 0}
 	c.Assert(v.String(), qt.Equals, "0.53")
 	c.Assert(v.Next().String(), qt.Equals, "0.54.0")
 	c.Assert(v.Next().Next().String(), qt.Equals, "0.55.0")
-	v = Version{Number: 0.54, PatchLevel: 0, Suffix: "-DEV"}
+	v = Version{Minor: 54, PatchLevel: 0, Suffix: "-DEV"}
 	c.Assert(v.String(), qt.Equals, "0.54.0-DEV")
 }
 
 func TestCompareVersions(t *testing.T) {
 	c := qt.New(t)
 
-	c.Assert(compareVersions(0.20, 0, 0.20), qt.Equals, 0)
-	c.Assert(compareVersions(0.20, 0, float32(0.20)), qt.Equals, 0)
-	c.Assert(compareVersions(0.20, 0, float64(0.20)), qt.Equals, 0)
-	c.Assert(compareVersions(0.19, 1, 0.20), qt.Equals, 1)
-	c.Assert(compareVersions(0.19, 3, "0.20.2"), qt.Equals, 1)
-	c.Assert(compareVersions(0.19, 1, 0.01), qt.Equals, -1)
-	c.Assert(compareVersions(0, 1, 3), qt.Equals, 1)
-	c.Assert(compareVersions(0, 1, int32(3)), qt.Equals, 1)
-	c.Assert(compareVersions(0, 1, int64(3)), qt.Equals, 1)
-	c.Assert(compareVersions(0.20, 0, "0.20"), qt.Equals, 0)
-	c.Assert(compareVersions(0.20, 1, "0.20.1"), qt.Equals, 0)
-	c.Assert(compareVersions(0.20, 1, "0.20"), qt.Equals, -1)
-	c.Assert(compareVersions(0.20, 0, "0.20.1"), qt.Equals, 1)
-	c.Assert(compareVersions(0.20, 1, "0.20.2"), qt.Equals, 1)
-	c.Assert(compareVersions(0.21, 1, "0.22.1"), qt.Equals, 1)
-	c.Assert(compareVersions(0.22, 0, "0.22-DEV"), qt.Equals, -1)
-	c.Assert(compareVersions(0.22, 0, "0.22.1-DEV"), qt.Equals, 1)
-	c.Assert(compareVersionsWithSuffix(0.22, 0, "-DEV", "0.22"), qt.Equals, 1)
-	c.Assert(compareVersionsWithSuffix(0.22, 1, "-DEV", "0.22"), qt.Equals, -1)
-	c.Assert(compareVersionsWithSuffix(0.22, 1, "-DEV", "0.22.1-DEV"), qt.Equals, 0)
+	c.Assert(compareVersions(MustParseVersion("0.20.0"), 0.20), qt.Equals, 0)
+	c.Assert(compareVersions(MustParseVersion("0.20.0"), float32(0.20)), qt.Equals, 0)
+	c.Assert(compareVersions(MustParseVersion("0.20.0"), float64(0.20)), qt.Equals, 0)
+	c.Assert(compareVersions(MustParseVersion("0.19.1"), 0.20), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.19.3"), "0.20.2"), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.1"), 3), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.1"), int32(3)), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.1"), int64(3)), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.20"), "0.20"), qt.Equals, 0)
+	c.Assert(compareVersions(MustParseVersion("0.20.1"), "0.20.1"), qt.Equals, 0)
+	c.Assert(compareVersions(MustParseVersion("0.20.1"), "0.20"), qt.Equals, -1)
+	c.Assert(compareVersions(MustParseVersion("0.20.0"), "0.20.1"), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.20.1"), "0.20.2"), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.21.1"), "0.22.1"), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.22.0"), "0.22-DEV"), qt.Equals, -1)
+	c.Assert(compareVersions(MustParseVersion("0.22.0"), "0.22.1-DEV"), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.22.0-DEV"), "0.22"), qt.Equals, 1)
+	c.Assert(compareVersions(MustParseVersion("0.22.1-DEV"), "0.22"), qt.Equals, -1)
+	c.Assert(compareVersions(MustParseVersion("0.22.1-DEV"), "0.22.1-DEV"), qt.Equals, 0)
 }
 
 func TestParseHugoVersion(t *testing.T) {

common/loggers/ignorableLogger.go

@@ -21,7 +21,8 @@ import (
 // IgnorableLogger is a logger that ignores certain log statements.
 type IgnorableLogger interface {
 	Logger
-	Errorsf(statementID, format string, v ...interface{})
+	Errorsf(statementID, format string, v ...any)
+	Apply(logger Logger) IgnorableLogger
 }
 
 type ignorableLogger struct {
@@ -42,7 +43,7 @@ func NewIgnorableLogger(logger Logger, statements ...string) IgnorableLogger {
 }
 
 // Errorsf logs statementID as an ERROR if not configured as ignoreable.
-func (l ignorableLogger) Errorsf(statementID, format string, v ...interface{}) {
+func (l ignorableLogger) Errorsf(statementID, format string, v ...any) {
 	if l.statements[statementID] {
 		// Ignore.
 		return
@@ -55,3 +56,10 @@ ignoreErrors = [%q]`, statementID)
 
 	l.Errorf(format, v...)
 }
+
+func (l ignorableLogger) Apply(logger Logger) IgnorableLogger {
+	return ignorableLogger{
+		Logger:     logger,
+		statements: l.statements,
+	}
+}

common/loggers/loggers.go

@@ -29,8 +29,11 @@ import (
 	jww "github.com/spf13/jwalterweatherman"
 )
 
-// Counts ERROR logs to the global jww logger.
-var GlobalErrorCounter *jww.Counter
+var (
+	// Counts ERROR logs to the global jww logger.
+	GlobalErrorCounter *jww.Counter
+	PanicOnWarning     bool
+)
 
 func init() {
 	GlobalErrorCounter = &jww.Counter{}
@@ -55,19 +58,21 @@ func (w prefixWriter) Write(p []byte) (n int, err error) {
 }
 
 type Logger interface {
-	Printf(format string, v ...interface{})
-	Println(v ...interface{})
+	Printf(format string, v ...any)
+	Println(v ...any)
 	PrintTimerIfDelayed(start time.Time, name string)
 	Debug() *log.Logger
+	Debugf(format string, v ...any)
+	Debugln(v ...any)
 	Info() *log.Logger
-	Infof(format string, v ...interface{})
-	Infoln(v ...interface{})
+	Infof(format string, v ...any)
+	Infoln(v ...any)
 	Warn() *log.Logger
-	Warnf(format string, v ...interface{})
-	Warnln(v ...interface{})
+	Warnf(format string, v ...any)
+	Warnln(v ...any)
 	Error() *log.Logger
-	Errorf(format string, v ...interface{})
-	Errorln(v ...interface{})
+	Errorf(format string, v ...any)
+	Errorln(v ...any)
 	Errors() string
 
 	Out() io.Writer
@@ -96,11 +101,11 @@ type logger struct {
 	errors *bytes.Buffer
 }
 
-func (l *logger) Printf(format string, v ...interface{}) {
+func (l *logger) Printf(format string, v ...any) {
 	l.FEEDBACK.Printf(format, v...)
 }
 
-func (l *logger) Println(v ...interface{}) {
+func (l *logger) Println(v ...any) {
 	l.FEEDBACK.Println(v...)
 }
 
@@ -108,11 +113,19 @@ func (l *logger) Debug() *log.Logger {
 	return l.DEBUG
 }
 
-func (l *logger) Infof(format string, v ...interface{}) {
+func (l *logger) Debugf(format string, v ...any) {
+	l.DEBUG.Printf(format, v...)
+}
+
+func (l *logger) Debugln(v ...any) {
+	l.DEBUG.Println(v...)
+}
+
+func (l *logger) Infof(format string, v ...any) {
 	l.INFO.Printf(format, v...)
 }
 
-func (l *logger) Infoln(v ...interface{}) {
+func (l *logger) Infoln(v ...any) {
 	l.INFO.Println(v...)
 }
 
@@ -120,23 +133,31 @@ func (l *logger) Info() *log.Logger {
 	return l.INFO
 }
 
-func (l *logger) Warnf(format string, v ...interface{}) {
+const panicOnWarningMessage = "Warning trapped. Remove the --panicOnWarning flag to continue."
+
+func (l *logger) Warnf(format string, v ...any) {
 	l.WARN.Printf(format, v...)
+	if PanicOnWarning {
+		panic(panicOnWarningMessage)
+	}
 }
 
-func (l *logger) Warnln(v ...interface{}) {
+func (l *logger) Warnln(v ...any) {
 	l.WARN.Println(v...)
+	if PanicOnWarning {
+		panic(panicOnWarningMessage)
+	}
 }
 
 func (l *logger) Warn() *log.Logger {
 	return l.WARN
 }
 
-func (l *logger) Errorf(format string, v ...interface{}) {
+func (l *logger) Errorf(format string, v ...any) {
 	l.ERROR.Printf(format, v...)
 }
 
-func (l *logger) Errorln(v ...interface{}) {
+func (l *logger) Errorln(v ...any) {
 	l.ERROR.Println(v...)
 }
 
@@ -219,6 +240,11 @@ func NewBasicLoggerForWriter(t jww.Threshold, w io.Writer) Logger {
 	return newLogger(t, jww.LevelError, w, ioutil.Discard, false)
 }
 
+// RemoveANSIColours removes all ANSI colours from the given string.
+func RemoveANSIColours(s string) string {
+	return ansiColorRe.ReplaceAllString(s, "")
+}
+
 var (
 	ansiColorRe = regexp.MustCompile("(?s)\\033\\[\\d*(;\\d*)*m")
 	errorRe     = regexp.MustCompile("^(ERROR|FATAL|WARN)")
@@ -264,7 +290,7 @@ func InitGlobalLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, lo
 }
 
 func getLogWriters(outHandle, logHandle io.Writer) (io.Writer, io.Writer) {
-	isTerm := terminal.IsTerminal(os.Stdout)
+	isTerm := terminal.PrintANSIColors(os.Stdout)
 	if logHandle != ioutil.Discard && isTerm {
 		// Remove any Ansi coloring from log output
 		logHandle = ansiCleaner{w: logHandle}

common/loggers/loggers_test.go

@@ -46,3 +46,15 @@ func TestLoggerToWriterWithPrefix(t *testing.T) {
 
 	c.Assert(b.String(), qt.Equals, "myprefix: Hello Hugo!\n")
 }
+
+func TestRemoveANSIColours(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(RemoveANSIColours(""), qt.Equals, "")
+	c.Assert(RemoveANSIColours("\033[31m"), qt.Equals, "")
+	c.Assert(RemoveANSIColours("\033[31mHello"), qt.Equals, "Hello")
+	c.Assert(RemoveANSIColours("\033[31mHello\033[0m"), qt.Equals, "Hello")
+	c.Assert(RemoveANSIColours("\033[31mHello\033[0m World"), qt.Equals, "Hello World")
+	c.Assert(RemoveANSIColours("\033[31mHello\033[0m World\033[31m!"), qt.Equals, "Hello World!")
+	c.Assert(RemoveANSIColours("\x1b[90m 5 |"), qt.Equals, " 5 |")
+}

common/maps/maps.go

@@ -17,62 +17,89 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/gobwas/glob"
+	"github.com/gohugoio/hugo/common/types"
 
+	"github.com/gobwas/glob"
 	"github.com/spf13/cast"
 )
 
-// ToLower makes all the keys in the given map lower cased and will do so
-// recursively.
-// Notes:
-// * This will modify the map given.
-// * Any nested map[interface{}]interface{} will be converted to Params.
-func ToLower(m Params) {
-	for k, v := range m {
-		var retyped bool
-		switch v.(type) {
-		case map[interface{}]interface{}:
-			var p Params = cast.ToStringMap(v)
-			v = p
-			ToLower(p)
-			retyped = true
-		case map[string]interface{}:
-			var p Params = v.(map[string]interface{})
-			v = p
-			ToLower(p)
-			retyped = true
-		}
-
-		lKey := strings.ToLower(k)
-		if retyped || k != lKey {
-			delete(m, k)
-			m[lKey] = v
-		}
-	}
-}
-
-func ToStringMapE(in interface{}) (map[string]interface{}, error) {
-	switch in.(type) {
+// ToStringMapE converts in to map[string]interface{}.
+func ToStringMapE(in any) (map[string]any, error) {
+	switch vv := in.(type) {
 	case Params:
-		return in.(Params), nil
+		return vv, nil
+	case map[string]string:
+		var m = map[string]any{}
+		for k, v := range vv {
+			m[k] = v
+		}
+		return m, nil
+
 	default:
 		return cast.ToStringMapE(in)
 	}
 }
 
-func ToStringMap(in interface{}) map[string]interface{} {
+// ToParamsAndPrepare converts in to Params and prepares it for use.
+// If in is nil, an empty map is returned.
+// See PrepareParams.
+func ToParamsAndPrepare(in any) (Params, bool) {
+	if types.IsNil(in) {
+		return Params{}, true
+	}
+	m, err := ToStringMapE(in)
+	if err != nil {
+		return nil, false
+	}
+	PrepareParams(m)
+	return m, true
+}
+
+// MustToParamsAndPrepare calls ToParamsAndPrepare and panics if it fails.
+func MustToParamsAndPrepare(in any) Params {
+	if p, ok := ToParamsAndPrepare(in); ok {
+		return p
+	} else {
+		panic(fmt.Sprintf("cannot convert %T to maps.Params", in))
+	}
+}
+
+// ToStringMap converts in to map[string]interface{}.
+func ToStringMap(in any) map[string]any {
 	m, _ := ToStringMapE(in)
 	return m
 }
 
-func ToSliceStringMap(in interface{}) ([]map[string]interface{}, error) {
+// ToStringMapStringE converts in to map[string]string.
+func ToStringMapStringE(in any) (map[string]string, error) {
+	m, err := ToStringMapE(in)
+	if err != nil {
+		return nil, err
+	}
+	return cast.ToStringMapStringE(m)
+}
+
+// ToStringMapString converts in to map[string]string.
+func ToStringMapString(in any) map[string]string {
+	m, _ := ToStringMapStringE(in)
+	return m
+}
+
+// ToStringMapBool converts in to bool.
+func ToStringMapBool(in any) map[string]bool {
+	m, _ := ToStringMapE(in)
+	return cast.ToStringMapBool(m)
+}
+
+// ToSliceStringMap converts in to []map[string]interface{}.
+func ToSliceStringMap(in any) ([]map[string]any, error) {
 	switch v := in.(type) {
-	case []map[string]interface{}:
+	case []map[string]any:
 		return v, nil
-	case []interface{}:
-		var s []map[string]interface{}
+	case []any:
+		var s []map[string]any
 		for _, entry := range v {
-			if vv, ok := entry.(map[string]interface{}); ok {
+			if vv, ok := entry.(map[string]any); ok {
 				s = append(s, vv)
 			}
 		}
@@ -82,6 +109,20 @@ func ToSliceStringMap(in interface{}) ([]map[string]interface{}, error) {
 	}
 }
 
+// LookupEqualFold finds key in m with case insensitive equality checks.
+func LookupEqualFold[T any | string](m map[string]T, key string) (T, bool) {
+	if v, found := m[key]; found {
+		return v, true
+	}
+	for k, v := range m {
+		if strings.EqualFold(k, key) {
+			return v, true
+		}
+	}
+	var s T
+	return s, false
+}
+
 type keyRename struct {
 	pattern glob.Glob
 	newKey  string
@@ -119,7 +160,7 @@ func (r KeyRenamer) getNewKey(keyPath string) string {
 
 // Rename renames the keys in the given map according
 // to the patterns in the current KeyRenamer.
-func (r KeyRenamer) Rename(m map[string]interface{}) {
+func (r KeyRenamer) Rename(m map[string]any) {
 	r.renamePath("", m)
 }
 
@@ -127,20 +168,19 @@ func (KeyRenamer) keyPath(k1, k2 string) string {
 	k1, k2 = strings.ToLower(k1), strings.ToLower(k2)
 	if k1 == "" {
 		return k2
-	} else {
-		return k1 + "/" + k2
 	}
+	return k1 + "/" + k2
 }
 
-func (r KeyRenamer) renamePath(parentKeyPath string, m map[string]interface{}) {
+func (r KeyRenamer) renamePath(parentKeyPath string, m map[string]any) {
 	for key, val := range m {
 		keyPath := r.keyPath(parentKeyPath, key)
 		switch val.(type) {
-		case map[interface{}]interface{}:
+		case map[any]any:
 			val = cast.ToStringMap(val)
-			r.renamePath(keyPath, val.(map[string]interface{}))
-		case map[string]interface{}:
-			r.renamePath(keyPath, val.(map[string]interface{}))
+			r.renamePath(keyPath, val.(map[string]any))
+		case map[string]any:
+			r.renamePath(keyPath, val.(map[string]any))
 		}
 
 		newKey := r.getNewKey(keyPath)

common/maps/maps_test.go

@@ -21,13 +21,13 @@ import (
 	qt "github.com/frankban/quicktest"
 )
 
-func TestToLower(t *testing.T) {
+func TestPrepareParams(t *testing.T) {
 	tests := []struct {
-		input    map[string]interface{}
-		expected map[string]interface{}
+		input    Params
+		expected Params
 	}{
 		{
-			map[string]interface{}{
+			map[string]any{
 				"abC": 32,
 			},
 			Params{
@@ -35,18 +35,21 @@ func TestToLower(t *testing.T) {
 			},
 		},
 		{
-			map[string]interface{}{
+			map[string]any{
 				"abC": 32,
-				"deF": map[interface{}]interface{}{
+				"deF": map[any]any{
 					23: "A value",
-					24: map[string]interface{}{
+					24: map[string]any{
 						"AbCDe": "A value",
 						"eFgHi": "Another value",
 					},
 				},
-				"gHi": map[string]interface{}{
+				"gHi": map[string]any{
 					"J": 25,
 				},
+				"jKl": map[string]string{
+					"M": "26",
+				},
 			},
 			Params{
 				"abc": 32,
@@ -60,14 +63,17 @@ func TestToLower(t *testing.T) {
 				"ghi": Params{
 					"j": 25,
 				},
+				"jkl": Params{
+					"m": "26",
+				},
 			},
 		},
 	}
 
 	for i, test := range tests {
 		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			// ToLower modifies input.
-			ToLower(test.input)
+			// PrepareParams modifies input.
+			PrepareParams(test.input)
 			if !reflect.DeepEqual(test.expected, test.input) {
 				t.Errorf("[%d] Expected\n%#v, got\n%#v\n", i, test.expected, test.input)
 			}
@@ -79,23 +85,23 @@ func TestToSliceStringMap(t *testing.T) {
 	c := qt.New(t)
 
 	tests := []struct {
-		input    interface{}
-		expected []map[string]interface{}
+		input    any
+		expected []map[string]any
 	}{
 		{
-			input: []map[string]interface{}{
+			input: []map[string]any{
 				{"abc": 123},
 			},
-			expected: []map[string]interface{}{
+			expected: []map[string]any{
 				{"abc": 123},
 			},
 		}, {
-			input: []interface{}{
-				map[string]interface{}{
+			input: []any{
+				map[string]any{
 					"def": 456,
 				},
 			},
-			expected: []map[string]interface{}{
+			expected: []map[string]any{
 				{"def": 456},
 			},
 		},
@@ -108,36 +114,46 @@ func TestToSliceStringMap(t *testing.T) {
 	}
 }
 
+func TestToParamsAndPrepare(t *testing.T) {
+	c := qt.New(t)
+	_, ok := ToParamsAndPrepare(map[string]any{"A": "av"})
+	c.Assert(ok, qt.IsTrue)
+
+	params, ok := ToParamsAndPrepare(nil)
+	c.Assert(ok, qt.IsTrue)
+	c.Assert(params, qt.DeepEquals, Params{})
+}
+
 func TestRenameKeys(t *testing.T) {
 	c := qt.New(t)
 
-	m := map[string]interface{}{
+	m := map[string]any{
 		"a":    32,
 		"ren1": "m1",
 		"ren2": "m1_2",
-		"sub": map[string]interface{}{
-			"subsub": map[string]interface{}{
+		"sub": map[string]any{
+			"subsub": map[string]any{
 				"REN1": "m2",
 				"ren2": "m2_2",
 			},
 		},
-		"no": map[string]interface{}{
+		"no": map[string]any{
 			"ren1": "m2",
 			"ren2": "m2_2",
 		},
 	}
 
-	expected := map[string]interface{}{
+	expected := map[string]any{
 		"a":    32,
 		"new1": "m1",
 		"new2": "m1_2",
-		"sub": map[string]interface{}{
-			"subsub": map[string]interface{}{
+		"sub": map[string]any{
+			"subsub": map[string]any{
 				"new1": "m2",
 				"ren2": "m2_2",
 			},
 		},
-		"no": map[string]interface{}{
+		"no": map[string]any{
 			"ren1": "m2",
 			"ren2": "m2_2",
 		},
@@ -155,3 +171,26 @@ func TestRenameKeys(t *testing.T) {
 		t.Errorf("Expected\n%#v, got\n%#v\n", expected, m)
 	}
 }
+
+func TestLookupEqualFold(t *testing.T) {
+	c := qt.New(t)
+
+	m1 := map[string]any{
+		"a": "av",
+		"B": "bv",
+	}
+
+	v, found := LookupEqualFold(m1, "b")
+	c.Assert(found, qt.IsTrue)
+	c.Assert(v, qt.Equals, "bv")
+
+	m2 := map[string]string{
+		"a": "av",
+		"B": "bv",
+	}
+
+	v, found = LookupEqualFold(m2, "b")
+	c.Assert(found, qt.IsTrue)
+	c.Assert(v, qt.Equals, "bv")
+
+}

common/maps/params.go

@@ -14,22 +14,135 @@
 package maps
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/spf13/cast"
 )
 
 // Params is a map where all keys are lower case.
-type Params map[string]interface{}
+type Params map[string]any
 
 // Get does a lower case and nested search in this map.
 // It will return nil if none found.
-func (p Params) Get(indices ...string) interface{} {
+func (p Params) Get(indices ...string) any {
 	v, _, _ := getNested(p, indices)
 	return v
 }
 
-func getNested(m map[string]interface{}, indices []string) (interface{}, string, map[string]interface{}) {
+// Set overwrites values in p with values in pp for common or new keys.
+// This is done recursively.
+func (p Params) Set(pp Params) {
+	for k, v := range pp {
+		vv, found := p[k]
+		if !found {
+			p[k] = v
+		} else {
+			switch vvv := vv.(type) {
+			case Params:
+				if pv, ok := v.(Params); ok {
+					vvv.Set(pv)
+				} else {
+					p[k] = v
+				}
+			default:
+				p[k] = v
+			}
+		}
+	}
+}
+
+// IsZero returns true if p is considered empty.
+func (p Params) IsZero() bool {
+	if p == nil || len(p) == 0 {
+		return true
+	}
+
+	if len(p) > 1 {
+		return false
+	}
+
+	for k, _ := range p {
+		return k == mergeStrategyKey
+	}
+
+	return false
+
+}
+
+// Merge transfers values from pp to p for new keys.
+// This is done recursively.
+func (p Params) Merge(pp Params) {
+	p.merge("", pp)
+}
+
+// MergeRoot transfers values from pp to p for new keys where p is the
+// root of the tree.
+// This is done recursively.
+func (p Params) MergeRoot(pp Params) {
+	ms, _ := p.GetMergeStrategy()
+	p.merge(ms, pp)
+}
+
+func (p Params) merge(ps ParamsMergeStrategy, pp Params) {
+	ns, found := p.GetMergeStrategy()
+
+	var ms = ns
+	if !found && ps != "" {
+		ms = ps
+	}
+
+	noUpdate := ms == ParamsMergeStrategyNone
+	noUpdate = noUpdate || (ps != "" && ps == ParamsMergeStrategyShallow)
+
+	for k, v := range pp {
+
+		if k == mergeStrategyKey {
+			continue
+		}
+		vv, found := p[k]
+
+		if found {
+			// Key matches, if both sides are Params, we try to merge.
+			if vvv, ok := vv.(Params); ok {
+				if pv, ok := v.(Params); ok {
+					vvv.merge(ms, pv)
+				}
+			}
+		} else if !noUpdate {
+			p[k] = v
+		}
+
+	}
+}
+
+func (p Params) GetMergeStrategy() (ParamsMergeStrategy, bool) {
+	if v, found := p[mergeStrategyKey]; found {
+		if s, ok := v.(ParamsMergeStrategy); ok {
+			return s, true
+		}
+	}
+	return ParamsMergeStrategyShallow, false
+}
+
+func (p Params) DeleteMergeStrategy() bool {
+	if _, found := p[mergeStrategyKey]; found {
+		delete(p, mergeStrategyKey)
+		return true
+	}
+	return false
+}
+
+func (p Params) SetDefaultMergeStrategy(s ParamsMergeStrategy) {
+	switch s {
+	case ParamsMergeStrategyDeep, ParamsMergeStrategyNone, ParamsMergeStrategyShallow:
+	default:
+		panic(fmt.Sprintf("invalid merge strategy %q", s))
+	}
+	p[mergeStrategyKey] = s
+}
+
+func getNested(m map[string]any, indices []string) (any, string, map[string]any) {
 	if len(indices) == 0 {
 		return nil, "", nil
 	}
@@ -51,7 +164,7 @@ func getNested(m map[string]interface{}, indices []string) (interface{}, string,
 	switch m2 := v.(type) {
 	case Params:
 		return getNested(m2, indices[1:])
-	case map[string]interface{}:
+	case map[string]any:
 		return getNested(m2, indices[1:])
 	default:
 		return nil, "", nil
@@ -62,7 +175,7 @@ func getNested(m map[string]interface{}, indices []string) (interface{}, string,
 // It will first try the exact match and then try to find it as a nested map value,
 // using the given separator, e.g. "mymap.name".
 // It assumes that all the maps given have lower cased keys.
-func GetNestedParam(keyStr, separator string, candidates ...Params) (interface{}, error) {
+func GetNestedParam(keyStr, separator string, candidates ...Params) (any, error) {
 	keyStr = strings.ToLower(keyStr)
 
 	// Try exact match first
@@ -82,7 +195,7 @@ func GetNestedParam(keyStr, separator string, candidates ...Params) (interface{}
 	return nil, nil
 }
 
-func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) interface{}) (interface{}, string, map[string]interface{}, error) {
+func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) any) (any, string, map[string]any, error) {
 	keySegments := strings.Split(keyStr, separator)
 	if len(keySegments) == 0 {
 		return nil, "", nil, nil
@@ -98,7 +211,7 @@ func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) interf
 	}
 
 	switch m := first.(type) {
-	case map[string]interface{}:
+	case map[string]any:
 		v, key, owner := getNested(m, keySegments[1:])
 		return v, key, owner, nil
 	case Params:
@@ -108,3 +221,69 @@ func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) interf
 
 	return nil, "", nil, nil
 }
+
+// ParamsMergeStrategy tells what strategy to use in Params.Merge.
+type ParamsMergeStrategy string
+
+const (
+	// Do not merge.
+	ParamsMergeStrategyNone ParamsMergeStrategy = "none"
+	// Only add new keys.
+	ParamsMergeStrategyShallow ParamsMergeStrategy = "shallow"
+	// Add new keys, merge existing.
+	ParamsMergeStrategyDeep ParamsMergeStrategy = "deep"
+
+	mergeStrategyKey = "_merge"
+)
+
+func toMergeStrategy(v any) ParamsMergeStrategy {
+	s := ParamsMergeStrategy(cast.ToString(v))
+	switch s {
+	case ParamsMergeStrategyDeep, ParamsMergeStrategyNone, ParamsMergeStrategyShallow:
+		return s
+	default:
+		return ParamsMergeStrategyDeep
+	}
+}
+
+// PrepareParams
+// * makes all the keys in the given map lower cased and will do so
+// * This will modify the map given.
+// * Any nested map[interface{}]interface{}, map[string]interface{},map[string]string  will be converted to Params.
+// * Any _merge value will be converted to proper type and value.
+func PrepareParams(m Params) {
+	for k, v := range m {
+		var retyped bool
+		lKey := strings.ToLower(k)
+		if lKey == mergeStrategyKey {
+			v = toMergeStrategy(v)
+			retyped = true
+		} else {
+			switch vv := v.(type) {
+			case map[any]any:
+				var p Params = cast.ToStringMap(v)
+				v = p
+				PrepareParams(p)
+				retyped = true
+			case map[string]any:
+				var p Params = v.(map[string]any)
+				v = p
+				PrepareParams(p)
+				retyped = true
+			case map[string]string:
+				p := make(Params)
+				for k, v := range vv {
+					p[k] = v
+				}
+				v = p
+				PrepareParams(p)
+				retyped = true
+			}
+		}
+
+		if retyped || k != lKey {
+			delete(m, k)
+			m[lKey] = v
+		}
+	}
+}

common/maps/params_test.go

@@ -20,13 +20,13 @@ import (
 )
 
 func TestGetNestedParam(t *testing.T) {
-	m := map[string]interface{}{
+	m := map[string]any{
 		"string":          "value",
 		"first":           1,
 		"with_underscore": 2,
-		"nested": map[string]interface{}{
+		"nested": map[string]any{
 			"color": "blue",
-			"nestednested": map[string]interface{}{
+			"nestednested": map[string]any{
 				"color": "green",
 			},
 		},
@@ -34,7 +34,7 @@ func TestGetNestedParam(t *testing.T) {
 
 	c := qt.New(t)
 
-	must := func(keyStr, separator string, candidates ...Params) interface{} {
+	must := func(keyStr, separator string, candidates ...Params) any {
 		v, err := GetNestedParam(keyStr, separator, candidates...)
 		c.Assert(err, qt.IsNil)
 		return v
@@ -53,14 +53,14 @@ func TestGetNestedParam(t *testing.T) {
 func TestGetNestedParamFnNestedNewKey(t *testing.T) {
 	c := qt.New(t)
 
-	nested := map[string]interface{}{
+	nested := map[string]any{
 		"color": "blue",
 	}
-	m := map[string]interface{}{
+	m := map[string]any{
 		"nested": nested,
 	}
 
-	existing, nestedKey, owner, err := GetNestedParamFn("nested.new", ".", func(key string) interface{} {
+	existing, nestedKey, owner, err := GetNestedParamFn("nested.new", ".", func(key string) any {
 		return m[key]
 	})
 
@@ -69,3 +69,102 @@ func TestGetNestedParamFnNestedNewKey(t *testing.T) {
 	c.Assert(nestedKey, qt.Equals, "new")
 	c.Assert(owner, qt.DeepEquals, nested)
 }
+
+func TestParamsSetAndMerge(t *testing.T) {
+	c := qt.New(t)
+
+	createParamsPair := func() (Params, Params) {
+		p1 := Params{"a": "av", "c": "cv", "nested": Params{"al2": "al2v", "cl2": "cl2v"}}
+		p2 := Params{"b": "bv", "a": "abv", "nested": Params{"bl2": "bl2v", "al2": "al2bv"}, mergeStrategyKey: ParamsMergeStrategyDeep}
+		return p1, p2
+	}
+
+	p1, p2 := createParamsPair()
+
+	p1.Set(p2)
+
+	c.Assert(p1, qt.DeepEquals, Params{
+		"a": "abv",
+		"c": "cv",
+		"nested": Params{
+			"al2": "al2bv",
+			"cl2": "cl2v",
+			"bl2": "bl2v",
+		},
+		"b":              "bv",
+		mergeStrategyKey: ParamsMergeStrategyDeep,
+	})
+
+	p1, p2 = createParamsPair()
+
+	p1.Merge(p2)
+
+	// Default is to do a shallow merge.
+	c.Assert(p1, qt.DeepEquals, Params{
+		"c": "cv",
+		"nested": Params{
+			"al2": "al2v",
+			"cl2": "cl2v",
+		},
+		"b": "bv",
+		"a": "av",
+	})
+
+	p1, p2 = createParamsPair()
+	p1.SetDefaultMergeStrategy(ParamsMergeStrategyNone)
+	p1.Merge(p2)
+	p1.DeleteMergeStrategy()
+
+	c.Assert(p1, qt.DeepEquals, Params{
+		"a": "av",
+		"c": "cv",
+		"nested": Params{
+			"al2": "al2v",
+			"cl2": "cl2v",
+		},
+	})
+
+	p1, p2 = createParamsPair()
+	p1.SetDefaultMergeStrategy(ParamsMergeStrategyShallow)
+	p1.Merge(p2)
+	p1.DeleteMergeStrategy()
+
+	c.Assert(p1, qt.DeepEquals, Params{
+		"a": "av",
+		"c": "cv",
+		"nested": Params{
+			"al2": "al2v",
+			"cl2": "cl2v",
+		},
+		"b": "bv",
+	})
+
+	p1, p2 = createParamsPair()
+	p1.SetDefaultMergeStrategy(ParamsMergeStrategyDeep)
+	p1.Merge(p2)
+	p1.DeleteMergeStrategy()
+
+	c.Assert(p1, qt.DeepEquals, Params{
+		"nested": Params{
+			"al2": "al2v",
+			"cl2": "cl2v",
+			"bl2": "bl2v",
+		},
+		"b": "bv",
+		"a": "av",
+		"c": "cv",
+	})
+
+}
+
+func TestParamsIsZero(t *testing.T) {
+	c := qt.New(t)
+
+	var nilParams Params
+
+	c.Assert(Params{}.IsZero(), qt.IsTrue)
+	c.Assert(nilParams.IsZero(), qt.IsTrue)
+	c.Assert(Params{"foo": "bar"}.IsZero(), qt.IsFalse)
+	c.Assert(Params{"_merge": "foo", "foo": "bar"}.IsZero(), qt.IsFalse)
+	c.Assert(Params{"_merge": "foo"}.IsZero(), qt.IsTrue)
+}

common/maps/scratch.go

@@ -24,7 +24,7 @@ import (
 
 // Scratch is a writable context used for stateful operations in Page/Node rendering.
 type Scratch struct {
-	values map[string]interface{}
+	values map[string]any
 	mu     sync.RWMutex
 }
 
@@ -50,8 +50,8 @@ func NewScratcher() Scratcher {
 // Supports numeric values and strings.
 //
 // If the first add for a key is an array or slice, then the next value(s) will be appended.
-func (c *Scratch) Add(key string, newAddend interface{}) (string, error) {
-	var newVal interface{}
+func (c *Scratch) Add(key string, newAddend any) (string, error) {
+	var newVal any
 	c.mu.RLock()
 	existingAddend, found := c.values[key]
 	c.mu.RUnlock()
@@ -82,7 +82,7 @@ func (c *Scratch) Add(key string, newAddend interface{}) (string, error) {
 
 // Set stores a value with the given key in the Node context.
 // This value can later be retrieved with Get.
-func (c *Scratch) Set(key string, value interface{}) string {
+func (c *Scratch) Set(key string, value any) string {
 	c.mu.Lock()
 	c.values[key] = value
 	c.mu.Unlock()
@@ -98,7 +98,7 @@ func (c *Scratch) Delete(key string) string {
 }
 
 // Get returns a value previously set by Add or Set.
-func (c *Scratch) Get(key string) interface{} {
+func (c *Scratch) Get(key string) any {
 	c.mu.RLock()
 	val := c.values[key]
 	c.mu.RUnlock()
@@ -109,7 +109,7 @@ func (c *Scratch) Get(key string) interface{} {
 // Values returns the raw backing map. Note that you should just use
 // this method on the locally scoped Scratch instances you obtain via newScratch, not
 // .Page.Scratch etc., as that will lead to concurrency issues.
-func (c *Scratch) Values() map[string]interface{} {
+func (c *Scratch) Values() map[string]any {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	return c.values
@@ -117,20 +117,31 @@ func (c *Scratch) Values() map[string]interface{} {
 
 // SetInMap stores a value to a map with the given key in the Node context.
 // This map can later be retrieved with GetSortedMapValues.
-func (c *Scratch) SetInMap(key string, mapKey string, value interface{}) string {
+func (c *Scratch) SetInMap(key string, mapKey string, value any) string {
 	c.mu.Lock()
 	_, found := c.values[key]
 	if !found {
-		c.values[key] = make(map[string]interface{})
+		c.values[key] = make(map[string]any)
 	}
 
-	c.values[key].(map[string]interface{})[mapKey] = value
+	c.values[key].(map[string]any)[mapKey] = value
+	c.mu.Unlock()
+	return ""
+}
+
+// DeleteInMap deletes a value to a map with the given key in the Node context.
+func (c *Scratch) DeleteInMap(key string, mapKey string) string {
+	c.mu.Lock()
+	_, found := c.values[key]
+	if found {
+		delete(c.values[key].(map[string]any), mapKey)
+	}
 	c.mu.Unlock()
 	return ""
 }
 
 // GetSortedMapValues returns a sorted map previously filled with SetInMap.
-func (c *Scratch) GetSortedMapValues(key string) interface{} {
+func (c *Scratch) GetSortedMapValues(key string) any {
 	c.mu.RLock()
 
 	if c.values[key] == nil {
@@ -138,7 +149,7 @@ func (c *Scratch) GetSortedMapValues(key string) interface{} {
 		return nil
 	}
 
-	unsortedMap := c.values[key].(map[string]interface{})
+	unsortedMap := c.values[key].(map[string]any)
 	c.mu.RUnlock()
 	var keys []string
 	for mapKey := range unsortedMap {
@@ -147,7 +158,7 @@ func (c *Scratch) GetSortedMapValues(key string) interface{} {
 
 	sort.Strings(keys)
 
-	sortedArray := make([]interface{}, len(unsortedMap))
+	sortedArray := make([]any, len(unsortedMap))
 	for i, mapKey := range keys {
 		sortedArray[i] = unsortedMap[mapKey]
 	}
@@ -157,5 +168,5 @@ func (c *Scratch) GetSortedMapValues(key string) interface{} {
 
 // NewScratch returns a new instance of Scratch.
 func NewScratch() *Scratch {
-	return &Scratch{values: make(map[string]interface{})}
+	return &Scratch{values: make(map[string]any)}
 }

common/maps/scratch_test.go

@@ -90,7 +90,7 @@ func TestScratchAddTypedSliceToInterfaceSlice(t *testing.T) {
 	c := qt.New(t)
 
 	scratch := NewScratch()
-	scratch.Set("slice", []interface{}{})
+	scratch.Set("slice", []any{})
 
 	_, err := scratch.Add("slice", []int{1, 2})
 	c.Assert(err, qt.IsNil)
@@ -107,7 +107,7 @@ func TestScratchAddDifferentTypedSliceToInterfaceSlice(t *testing.T) {
 
 	_, err := scratch.Add("slice", []int{1, 2})
 	c.Assert(err, qt.IsNil)
-	c.Assert(scratch.Get("slice"), qt.DeepEquals, []interface{}{"foo", 1, 2})
+	c.Assert(scratch.Get("slice"), qt.DeepEquals, []any{"foo", 1, 2})
 }
 
 func TestScratchSet(t *testing.T) {
@@ -185,7 +185,21 @@ func TestScratchSetInMap(t *testing.T) {
 	scratch.SetInMap("key", "zyx", "Zyx")
 	scratch.SetInMap("key", "abc", "Abc (updated)")
 	scratch.SetInMap("key", "def", "Def")
-	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []interface{}{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"})
+	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []any{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"})
+}
+
+func TestScratchDeleteInMap(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	scratch := NewScratch()
+	scratch.SetInMap("key", "lux", "Lux")
+	scratch.SetInMap("key", "abc", "Abc")
+	scratch.SetInMap("key", "zyx", "Zyx")
+	scratch.DeleteInMap("key", "abc")
+	scratch.SetInMap("key", "def", "Def")
+	scratch.DeleteInMap("key", "lmn") // Do nothing
+	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []any{0: "Def", 1: "Lux", 2: "Zyx"})
 }
 
 func TestScratchGetSortedMapValues(t *testing.T) {

common/math/math.go

@@ -20,7 +20,7 @@ import (
 
 // DoArithmetic performs arithmetic operations (+,-,*,/) using reflection to
 // determine the type of the two terms.
-func DoArithmetic(a, b interface{}, op rune) (interface{}, error) {
+func DoArithmetic(a, b any, op rune) (any, error) {
 	av := reflect.ValueOf(a)
 	bv := reflect.ValueOf(b)
 	var ai, bi int64

common/math/math_test.go

@@ -24,10 +24,10 @@ func TestDoArithmetic(t *testing.T) {
 	c := qt.New(t)
 
 	for _, test := range []struct {
-		a      interface{}
-		b      interface{}
+		a      any
+		b      any
 		op     rune
-		expect interface{}
+		expect any
 	}{
 		{3, 2, '+', int64(5)},
 		{3, 2, '-', int64(1)},

common/paths/path.go

@@ -0,0 +1,265 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package paths
+
+import (
+	"errors"
+	"fmt"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// FilePathSeparator as defined by os.Separator.
+const FilePathSeparator = string(filepath.Separator)
+
+// filepathPathBridge is a bridge for common functionality in filepath vs path
+type filepathPathBridge interface {
+	Base(in string) string
+	Clean(in string) string
+	Dir(in string) string
+	Ext(in string) string
+	Join(elem ...string) string
+	Separator() string
+}
+
+type filepathBridge struct{}
+
+func (filepathBridge) Base(in string) string {
+	return filepath.Base(in)
+}
+
+func (filepathBridge) Clean(in string) string {
+	return filepath.Clean(in)
+}
+
+func (filepathBridge) Dir(in string) string {
+	return filepath.Dir(in)
+}
+
+func (filepathBridge) Ext(in string) string {
+	return filepath.Ext(in)
+}
+
+func (filepathBridge) Join(elem ...string) string {
+	return filepath.Join(elem...)
+}
+
+func (filepathBridge) Separator() string {
+	return FilePathSeparator
+}
+
+var fpb filepathBridge
+
+// AbsPathify creates an absolute path if given a working dir and a relative path.
+// If already absolute, the path is just cleaned.
+func AbsPathify(workingDir, inPath string) string {
+	if filepath.IsAbs(inPath) {
+		return filepath.Clean(inPath)
+	}
+	return filepath.Join(workingDir, inPath)
+}
+
+// MakeTitle converts the path given to a suitable title, trimming whitespace
+// and replacing hyphens with whitespace.
+func MakeTitle(inpath string) string {
+	return strings.Replace(strings.TrimSpace(inpath), "-", " ", -1)
+}
+
+// ReplaceExtension takes a path and an extension, strips the old extension
+// and returns the path with the new extension.
+func ReplaceExtension(path string, newExt string) string {
+	f, _ := fileAndExt(path, fpb)
+	return f + "." + newExt
+}
+
+func makePathRelative(inPath string, possibleDirectories ...string) (string, error) {
+	for _, currentPath := range possibleDirectories {
+		if strings.HasPrefix(inPath, currentPath) {
+			return strings.TrimPrefix(inPath, currentPath), nil
+		}
+	}
+	return inPath, errors.New("can't extract relative path, unknown prefix")
+}
+
+// Should be good enough for Hugo.
+var isFileRe = regexp.MustCompile(`.*\..{1,6}$`)
+
+// GetDottedRelativePath expects a relative path starting after the content directory.
+// It returns a relative path with dots ("..") navigating up the path structure.
+func GetDottedRelativePath(inPath string) string {
+	inPath = filepath.Clean(filepath.FromSlash(inPath))
+
+	if inPath == "." {
+		return "./"
+	}
+
+	if !isFileRe.MatchString(inPath) && !strings.HasSuffix(inPath, FilePathSeparator) {
+		inPath += FilePathSeparator
+	}
+
+	if !strings.HasPrefix(inPath, FilePathSeparator) {
+		inPath = FilePathSeparator + inPath
+	}
+
+	dir, _ := filepath.Split(inPath)
+
+	sectionCount := strings.Count(dir, FilePathSeparator)
+
+	if sectionCount == 0 || dir == FilePathSeparator {
+		return "./"
+	}
+
+	var dottedPath string
+
+	for i := 1; i < sectionCount; i++ {
+		dottedPath += "../"
+	}
+
+	return dottedPath
+}
+
+// ExtNoDelimiter takes a path and returns the extension, excluding the delimiter, i.e. "md".
+func ExtNoDelimiter(in string) string {
+	return strings.TrimPrefix(Ext(in), ".")
+}
+
+// Ext takes a path and returns the extension, including the delimiter, i.e. ".md".
+func Ext(in string) string {
+	_, ext := fileAndExt(in, fpb)
+	return ext
+}
+
+// PathAndExt is the same as FileAndExt, but it uses the path package.
+func PathAndExt(in string) (string, string) {
+	return fileAndExt(in, pb)
+}
+
+// FileAndExt takes a path and returns the file and extension separated,
+// the extension including the delimiter, i.e. ".md".
+func FileAndExt(in string) (string, string) {
+	return fileAndExt(in, fpb)
+}
+
+// FileAndExtNoDelimiter takes a path and returns the file and extension separated,
+// the extension excluding the delimiter, e.g "md".
+func FileAndExtNoDelimiter(in string) (string, string) {
+	file, ext := fileAndExt(in, fpb)
+	return file, strings.TrimPrefix(ext, ".")
+}
+
+// Filename takes a file path, strips out the extension,
+// and returns the name of the file.
+func Filename(in string) (name string) {
+	name, _ = fileAndExt(in, fpb)
+	return
+}
+
+// PathNoExt takes a path, strips out the extension,
+// and returns the name of the file.
+func PathNoExt(in string) string {
+	return strings.TrimSuffix(in, path.Ext(in))
+}
+
+// FileAndExt returns the filename and any extension of a file path as
+// two separate strings.
+//
+// If the path, in, contains a directory name ending in a slash,
+// then both name and ext will be empty strings.
+//
+// If the path, in, is either the current directory, the parent
+// directory or the root directory, or an empty string,
+// then both name and ext will be empty strings.
+//
+// If the path, in, represents the path of a file without an extension,
+// then name will be the name of the file and ext will be an empty string.
+//
+// If the path, in, represents a filename with an extension,
+// then name will be the filename minus any extension - including the dot
+// and ext will contain the extension - minus the dot.
+func fileAndExt(in string, b filepathPathBridge) (name string, ext string) {
+	ext = b.Ext(in)
+	base := b.Base(in)
+
+	return extractFilename(in, ext, base, b.Separator()), ext
+}
+
+func extractFilename(in, ext, base, pathSeparator string) (name string) {
+	// No file name cases. These are defined as:
+	// 1. any "in" path that ends in a pathSeparator
+	// 2. any "base" consisting of just an pathSeparator
+	// 3. any "base" consisting of just an empty string
+	// 4. any "base" consisting of just the current directory i.e. "."
+	// 5. any "base" consisting of just the parent directory i.e. ".."
+	if (strings.LastIndex(in, pathSeparator) == len(in)-1) || base == "" || base == "." || base == ".." || base == pathSeparator {
+		name = "" // there is NO filename
+	} else if ext != "" { // there was an Extension
+		// return the filename minus the extension (and the ".")
+		name = base[:strings.LastIndex(base, ".")]
+	} else {
+		// no extension case so just return base, which willi
+		// be the filename
+		name = base
+	}
+	return
+}
+
+// GetRelativePath returns the relative path of a given path.
+func GetRelativePath(path, base string) (final string, err error) {
+	if filepath.IsAbs(path) && base == "" {
+		return "", errors.New("source: missing base directory")
+	}
+	name := filepath.Clean(path)
+	base = filepath.Clean(base)
+
+	name, err = filepath.Rel(base, name)
+	if err != nil {
+		return "", err
+	}
+
+	if strings.HasSuffix(filepath.FromSlash(path), FilePathSeparator) && !strings.HasSuffix(name, FilePathSeparator) {
+		name += FilePathSeparator
+	}
+	return name, nil
+}
+
+func prettifyPath(in string, b filepathPathBridge) string {
+	if filepath.Ext(in) == "" {
+		// /section/name/  -> /section/name/index.html
+		if len(in) < 2 {
+			return b.Separator()
+		}
+		return b.Join(in, "index.html")
+	}
+	name, ext := fileAndExt(in, b)
+	if name == "index" {
+		// /section/name/index.html -> /section/name/index.html
+		return b.Clean(in)
+	}
+	// /section/name.html -> /section/name/index.html
+	return b.Join(b.Dir(in), name, "index"+ext)
+}
+
+type NamedSlice struct {
+	Name  string
+	Slice []string
+}
+
+func (n NamedSlice) String() string {
+	if len(n.Slice) == 0 {
+		return n.Name
+	}
+	return fmt.Sprintf("%s%s{%s}", n.Name, FilePathSeparator, strings.Join(n.Slice, ","))
+}

common/paths/path_test.go

@@ -0,0 +1,228 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package paths
+
+import (
+	"path/filepath"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestGetRelativePath(t *testing.T) {
+	tests := []struct {
+		path   string
+		base   string
+		expect any
+	}{
+		{filepath.FromSlash("/a/b"), filepath.FromSlash("/a"), filepath.FromSlash("b")},
+		{filepath.FromSlash("/a/b/c/"), filepath.FromSlash("/a"), filepath.FromSlash("b/c/")},
+		{filepath.FromSlash("/c"), filepath.FromSlash("/a/b"), filepath.FromSlash("../../c")},
+		{filepath.FromSlash("/c"), "", false},
+	}
+	for i, this := range tests {
+		// ultimately a fancy wrapper around filepath.Rel
+		result, err := GetRelativePath(this.path, this.base)
+
+		if b, ok := this.expect.(bool); ok && !b {
+			if err == nil {
+				t.Errorf("[%d] GetRelativePath didn't return an expected error", i)
+			}
+		} else {
+			if err != nil {
+				t.Errorf("[%d] GetRelativePath failed: %s", i, err)
+				continue
+			}
+			if result != this.expect {
+				t.Errorf("[%d] GetRelativePath got %v but expected %v", i, result, this.expect)
+			}
+		}
+
+	}
+}
+
+func TestMakePathRelative(t *testing.T) {
+	type test struct {
+		inPath, path1, path2, output string
+	}
+
+	data := []test{
+		{"/abc/bcd/ab.css", "/abc/bcd", "/bbc/bcd", "/ab.css"},
+		{"/abc/bcd/ab.css", "/abcd/bcd", "/abc/bcd", "/ab.css"},
+	}
+
+	for i, d := range data {
+		output, _ := makePathRelative(d.inPath, d.path1, d.path2)
+		if d.output != output {
+			t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output)
+		}
+	}
+	_, error := makePathRelative("a/b/c.ss", "/a/c", "/d/c", "/e/f")
+
+	if error == nil {
+		t.Errorf("Test failed, expected error")
+	}
+}
+
+func TestGetDottedRelativePath(t *testing.T) {
+	// on Windows this will receive both kinds, both country and western ...
+	for _, f := range []func(string) string{filepath.FromSlash, func(s string) string { return s }} {
+		doTestGetDottedRelativePath(f, t)
+	}
+}
+
+func doTestGetDottedRelativePath(urlFixer func(string) string, t *testing.T) {
+	type test struct {
+		input, expected string
+	}
+	data := []test{
+		{"", "./"},
+		{urlFixer("/"), "./"},
+		{urlFixer("post"), "../"},
+		{urlFixer("/post"), "../"},
+		{urlFixer("post/"), "../"},
+		{urlFixer("tags/foo.html"), "../"},
+		{urlFixer("/tags/foo.html"), "../"},
+		{urlFixer("/post/"), "../"},
+		{urlFixer("////post/////"), "../"},
+		{urlFixer("/foo/bar/index.html"), "../../"},
+		{urlFixer("/foo/bar/foo/"), "../../../"},
+		{urlFixer("/foo/bar/foo"), "../../../"},
+		{urlFixer("foo/bar/foo/"), "../../../"},
+		{urlFixer("foo/bar/foo/bar"), "../../../../"},
+		{"404.html", "./"},
+		{"404.xml", "./"},
+		{"/404.html", "./"},
+	}
+	for i, d := range data {
+		output := GetDottedRelativePath(d.input)
+		if d.expected != output {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
+		}
+	}
+}
+
+func TestMakeTitle(t *testing.T) {
+	type test struct {
+		input, expected string
+	}
+	data := []test{
+		{"Make-Title", "Make Title"},
+		{"MakeTitle", "MakeTitle"},
+		{"make_title", "make_title"},
+	}
+	for i, d := range data {
+		output := MakeTitle(d.input)
+		if d.expected != output {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
+		}
+	}
+}
+
+// Replace Extension is probably poorly named, but the intent of the
+// function is to accept a path and return only the file name with a
+// new extension. It's intentionally designed to strip out the path
+// and only provide the name. We should probably rename the function to
+// be more explicit at some point.
+func TestReplaceExtension(t *testing.T) {
+	type test struct {
+		input, newext, expected string
+	}
+	data := []test{
+		// These work according to the above definition
+		{"/some/random/path/file.xml", "html", "file.html"},
+		{"/banana.html", "xml", "banana.xml"},
+		{"./banana.html", "xml", "banana.xml"},
+		{"banana/pie/index.html", "xml", "index.xml"},
+		{"../pies/fish/index.html", "xml", "index.xml"},
+		// but these all fail
+		{"filename-without-an-ext", "ext", "filename-without-an-ext.ext"},
+		{"/filename-without-an-ext", "ext", "filename-without-an-ext.ext"},
+		{"/directory/mydir/", "ext", ".ext"},
+		{"mydir/", "ext", ".ext"},
+	}
+
+	for i, d := range data {
+		output := ReplaceExtension(filepath.FromSlash(d.input), d.newext)
+		if d.expected != output {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
+		}
+	}
+}
+
+func TestExtNoDelimiter(t *testing.T) {
+	c := qt.New(t)
+	c.Assert(ExtNoDelimiter(filepath.FromSlash("/my/data.json")), qt.Equals, "json")
+}
+
+func TestFilename(t *testing.T) {
+	type test struct {
+		input, expected string
+	}
+	data := []test{
+		{"index.html", "index"},
+		{"./index.html", "index"},
+		{"/index.html", "index"},
+		{"index", "index"},
+		{"/tmp/index.html", "index"},
+		{"./filename-no-ext", "filename-no-ext"},
+		{"/filename-no-ext", "filename-no-ext"},
+		{"filename-no-ext", "filename-no-ext"},
+		{"directory/", ""}, // no filename case??
+		{"directory/.hidden.ext", ".hidden"},
+		{"./directory/../~/banana/gold.fish", "gold"},
+		{"../directory/banana.man", "banana"},
+		{"~/mydir/filename.ext", "filename"},
+		{"./directory//tmp/filename.ext", "filename"},
+	}
+
+	for i, d := range data {
+		output := Filename(filepath.FromSlash(d.input))
+		if d.expected != output {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
+		}
+	}
+}
+
+func TestFileAndExt(t *testing.T) {
+	type test struct {
+		input, expectedFile, expectedExt string
+	}
+	data := []test{
+		{"index.html", "index", ".html"},
+		{"./index.html", "index", ".html"},
+		{"/index.html", "index", ".html"},
+		{"index", "index", ""},
+		{"/tmp/index.html", "index", ".html"},
+		{"./filename-no-ext", "filename-no-ext", ""},
+		{"/filename-no-ext", "filename-no-ext", ""},
+		{"filename-no-ext", "filename-no-ext", ""},
+		{"directory/", "", ""}, // no filename case??
+		{"directory/.hidden.ext", ".hidden", ".ext"},
+		{"./directory/../~/banana/gold.fish", "gold", ".fish"},
+		{"../directory/banana.man", "banana", ".man"},
+		{"~/mydir/filename.ext", "filename", ".ext"},
+		{"./directory//tmp/filename.ext", "filename", ".ext"},
+	}
+
+	for i, d := range data {
+		file, ext := fileAndExt(filepath.FromSlash(d.input), fpb)
+		if d.expectedFile != file {
+			t.Errorf("Test %d failed. Expected filename %q got %q.", i, d.expectedFile, file)
+		}
+		if d.expectedExt != ext {
+			t.Errorf("Test %d failed. Expected extension %q got %q.", i, d.expectedExt, ext)
+		}
+	}
+}

common/paths/url.go

@@ -0,0 +1,181 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package paths
+
+import (
+	"fmt"
+	"net/url"
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+type pathBridge struct{}
+
+func (pathBridge) Base(in string) string {
+	return path.Base(in)
+}
+
+func (pathBridge) Clean(in string) string {
+	return path.Clean(in)
+}
+
+func (pathBridge) Dir(in string) string {
+	return path.Dir(in)
+}
+
+func (pathBridge) Ext(in string) string {
+	return path.Ext(in)
+}
+
+func (pathBridge) Join(elem ...string) string {
+	return path.Join(elem...)
+}
+
+func (pathBridge) Separator() string {
+	return "/"
+}
+
+var pb pathBridge
+
+// MakePermalink combines base URL with content path to create full URL paths.
+// Example
+//    base:   http://spf13.com/
+//    path:   post/how-i-blog
+//    result: http://spf13.com/post/how-i-blog
+func MakePermalink(host, plink string) *url.URL {
+	base, err := url.Parse(host)
+	if err != nil {
+		panic(err)
+	}
+
+	p, err := url.Parse(plink)
+	if err != nil {
+		panic(err)
+	}
+
+	if p.Host != "" {
+		panic(fmt.Errorf("can't make permalink from absolute link %q", plink))
+	}
+
+	base.Path = path.Join(base.Path, p.Path)
+
+	// path.Join will strip off the last /, so put it back if it was there.
+	hadTrailingSlash := (plink == "" && strings.HasSuffix(host, "/")) || strings.HasSuffix(p.Path, "/")
+	if hadTrailingSlash && !strings.HasSuffix(base.Path, "/") {
+		base.Path = base.Path + "/"
+	}
+
+	return base
+}
+
+// AddContextRoot adds the context root to an URL if it's not already set.
+// For relative URL entries on sites with a base url with a context root set (i.e. http://example.com/mysite),
+// relative URLs must not include the context root if canonifyURLs is enabled. But if it's disabled, it must be set.
+func AddContextRoot(baseURL, relativePath string) string {
+	url, err := url.Parse(baseURL)
+	if err != nil {
+		panic(err)
+	}
+
+	newPath := path.Join(url.Path, relativePath)
+
+	// path strips trailing slash, ignore root path.
+	if newPath != "/" && strings.HasSuffix(relativePath, "/") {
+		newPath += "/"
+	}
+	return newPath
+}
+
+// URLizeAn
+
+// PrettifyURL takes a URL string and returns a semantic, clean URL.
+func PrettifyURL(in string) string {
+	x := PrettifyURLPath(in)
+
+	if path.Base(x) == "index.html" {
+		return path.Dir(x)
+	}
+
+	if in == "" {
+		return "/"
+	}
+
+	return x
+}
+
+// PrettifyURLPath takes a URL path to a content and converts it
+// to enable pretty URLs.
+//     /section/name.html       becomes /section/name/index.html
+//     /section/name/           becomes /section/name/index.html
+//     /section/name/index.html becomes /section/name/index.html
+func PrettifyURLPath(in string) string {
+	return prettifyPath(in, pb)
+}
+
+// Uglify does the opposite of PrettifyURLPath().
+//     /section/name/index.html becomes /section/name.html
+//     /section/name/           becomes /section/name.html
+//     /section/name.html       becomes /section/name.html
+func Uglify(in string) string {
+	if path.Ext(in) == "" {
+		if len(in) < 2 {
+			return "/"
+		}
+		// /section/name/  -> /section/name.html
+		return path.Clean(in) + ".html"
+	}
+
+	name, ext := fileAndExt(in, pb)
+	if name == "index" {
+		// /section/name/index.html -> /section/name.html
+		d := path.Dir(in)
+		if len(d) > 1 {
+			return d + ext
+		}
+		return in
+	}
+	// /.xml -> /index.xml
+	if name == "" {
+		return path.Dir(in) + "index" + ext
+	}
+	// /section/name.html -> /section/name.html
+	return path.Clean(in)
+}
+
+// UrlToFilename converts the URL s to a filename.
+// If ParseRequestURI fails, the input is just converted to OS specific slashes and returned.
+func UrlToFilename(s string) (string, bool) {
+	u, err := url.ParseRequestURI(s)
+
+	if err != nil {
+		return filepath.FromSlash(s), false
+	}
+
+	p := u.Path
+
+	if p == "" {
+		p, _ = url.QueryUnescape(u.Opaque)
+		return filepath.FromSlash(p), true
+	}
+
+	p = filepath.FromSlash(p)
+
+	if u.Host != "" {
+		// C:\data\file.txt
+		p = strings.ToUpper(u.Host) + ":" + p
+	}
+
+	return p, true
+}

common/paths/url_test.go

@@ -0,0 +1,99 @@
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package paths
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestMakePermalink(t *testing.T) {
+	type test struct {
+		host, link, output string
+	}
+
+	data := []test{
+		{"http://abc.com/foo", "post/bar", "http://abc.com/foo/post/bar"},
+		{"http://abc.com/foo/", "post/bar", "http://abc.com/foo/post/bar"},
+		{"http://abc.com", "post/bar", "http://abc.com/post/bar"},
+		{"http://abc.com", "bar", "http://abc.com/bar"},
+		{"http://abc.com/foo/bar", "post/bar", "http://abc.com/foo/bar/post/bar"},
+		{"http://abc.com/foo/bar", "post/bar/", "http://abc.com/foo/bar/post/bar/"},
+	}
+
+	for i, d := range data {
+		output := MakePermalink(d.host, d.link).String()
+		if d.output != output {
+			t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output)
+		}
+	}
+}
+
+func TestAddContextRoot(t *testing.T) {
+	tests := []struct {
+		baseURL  string
+		url      string
+		expected string
+	}{
+		{"http://example.com/sub/", "/foo", "/sub/foo"},
+		{"http://example.com/sub/", "/foo/index.html", "/sub/foo/index.html"},
+		{"http://example.com/sub1/sub2", "/foo", "/sub1/sub2/foo"},
+		{"http://example.com", "/foo", "/foo"},
+		// cannot guess that the context root is already added int the example below
+		{"http://example.com/sub/", "/sub/foo", "/sub/sub/foo"},
+		{"http://example.com/тря", "/трям/", "/тря/трям/"},
+		{"http://example.com", "/", "/"},
+		{"http://example.com/bar", "//", "/bar/"},
+	}
+
+	for _, test := range tests {
+		output := AddContextRoot(test.baseURL, test.url)
+		if output != test.expected {
+			t.Errorf("Expected %#v, got %#v\n", test.expected, output)
+		}
+	}
+}
+
+func TestPretty(t *testing.T) {
+	c := qt.New(t)
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name.html"))
+	c.Assert("/section/sub/name/index.html", qt.Equals, PrettifyURLPath("/section/sub/name.html"))
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name/"))
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name/index.html"))
+	c.Assert("/index.html", qt.Equals, PrettifyURLPath("/index.html"))
+	c.Assert("/name/index.xml", qt.Equals, PrettifyURLPath("/name.xml"))
+	c.Assert("/", qt.Equals, PrettifyURLPath("/"))
+	c.Assert("/", qt.Equals, PrettifyURLPath(""))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name.html"))
+	c.Assert("/section/sub/name", qt.Equals, PrettifyURL("/section/sub/name.html"))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name/"))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name/index.html"))
+	c.Assert("/", qt.Equals, PrettifyURL("/index.html"))
+	c.Assert("/name/index.xml", qt.Equals, PrettifyURL("/name.xml"))
+	c.Assert("/", qt.Equals, PrettifyURL("/"))
+	c.Assert("/", qt.Equals, PrettifyURL(""))
+}
+
+func TestUgly(t *testing.T) {
+	c := qt.New(t)
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name.html"))
+	c.Assert("/section/sub/name.html", qt.Equals, Uglify("/section/sub/name.html"))
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name/"))
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name/index.html"))
+	c.Assert("/index.html", qt.Equals, Uglify("/index.html"))
+	c.Assert("/name.xml", qt.Equals, Uglify("/name.xml"))
+	c.Assert("/", qt.Equals, Uglify("/"))
+	c.Assert("/", qt.Equals, Uglify(""))
+}

common/terminal/colors.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2022 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -29,6 +29,15 @@ const (
 	noticeColor  = "\033[1;36m%s\033[0m"
 )
 
+// PrintANSIColors returns false if NO_COLOR env variable is set,
+// else  IsTerminal(f).
+func PrintANSIColors(f *os.File) bool {
+	if os.Getenv("NO_COLOR") != "" {
+		return false
+	}
+	return IsTerminal(f)
+}
+
 // 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 {

common/text/position.go

@@ -69,7 +69,7 @@ func createPositionStringFormatter(formatStr string) func(p Position) string {
 	format := replacer.Replace(formatStr)
 
 	f := func(pos Position) string {
-		args := make([]interface{}, len(identifiersFound))
+		args := make([]any, len(identifiersFound))
 		for i, id := range identifiersFound {
 			switch id {
 			case ":file":
@@ -83,7 +83,7 @@ func createPositionStringFormatter(formatStr string) func(p Position) string {
 
 		msg := fmt.Sprintf(format, args...)
 
-		if terminal.IsTerminal(os.Stdout) {
+		if terminal.PrintANSIColors(os.Stdout) {
 			return terminal.Notice(msg)
 		}
 

common/text/transform.go

@@ -14,6 +14,7 @@
 package text
 
 import (
+	"strings"
 	"sync"
 	"unicode"
 
@@ -23,7 +24,7 @@ import (
 )
 
 var accentTransformerPool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
 	},
 }
@@ -45,3 +46,33 @@ func RemoveAccentsString(s string) string {
 	accentTransformerPool.Put(t)
 	return s
 }
+
+// Chomp removes trailing newline characters from s.
+func Chomp(s string) string {
+	return strings.TrimRightFunc(s, func(r rune) bool {
+		return r == '\n' || r == '\r'
+	})
+}
+
+// Puts adds a trailing \n none found.
+func Puts(s string) string {
+	if s == "" || s[len(s)-1] == '\n' {
+		return s
+	}
+	return s + "\n"
+}
+
+// VisitLinesAfter calls the given function for each line, including newlines, in the given string.
+func VisitLinesAfter(s string, fn func(line string)) {
+	high := strings.IndexRune(s, '\n')
+	for high != -1 {
+		fn(s[:high+1])
+		s = s[high+1:]
+
+		high = strings.IndexRune(s, '\n')
+	}
+
+	if s != "" {
+		fn(s)
+	}
+}

common/text/transform_test.go

@@ -26,3 +26,51 @@ func TestRemoveAccents(t *testing.T) {
 	c.Assert(string(RemoveAccents([]byte("Hugo Rocks!"))), qt.Equals, "Hugo Rocks!")
 	c.Assert(string(RemoveAccentsString("Resumé")), qt.Equals, "Resume")
 }
+
+func TestChomp(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(Chomp("\nA\n"), qt.Equals, "\nA")
+	c.Assert(Chomp("A\r\n"), qt.Equals, "A")
+}
+
+func TestPuts(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(Puts("A"), qt.Equals, "A\n")
+	c.Assert(Puts("\nA\n"), qt.Equals, "\nA\n")
+	c.Assert(Puts(""), qt.Equals, "")
+}
+
+func TestVisitLinesAfter(t *testing.T) {
+	const lines = `line 1
+line 2
+
+line 3`
+
+	var collected []string
+
+	VisitLinesAfter(lines, func(s string) {
+		collected = append(collected, s)
+	})
+
+	c := qt.New(t)
+
+	c.Assert(collected, qt.DeepEquals, []string{"line 1\n", "line 2\n", "\n", "line 3"})
+
+}
+
+func BenchmarkVisitLinesAfter(b *testing.B) {
+	const lines = `line 1
+	line 2
+	
+	line 3`
+
+	for i := 0; i < b.N; i++ {
+		VisitLinesAfter(lines, func(s string) {
+
+		})
+
+	}
+
+}

common/types/convert.go

@@ -15,27 +15,78 @@ package types
 
 import (
 	"encoding/json"
+	"fmt"
 	"html/template"
+	"reflect"
+	"time"
 
 	"github.com/spf13/cast"
 )
 
-// ToStringSlicePreserveString converts v to a string slice.
+// ToDuration converts v to time.Duration.
+// See ToDurationE if you need to handle errors.
+func ToDuration(v any) time.Duration {
+	d, _ := ToDurationE(v)
+	return d
+}
+
+// ToDurationE converts v to time.Duration.
+func ToDurationE(v any) (time.Duration, error) {
+	if n := cast.ToInt(v); n > 0 {
+		return time.Duration(n) * time.Millisecond, nil
+	}
+	d, err := time.ParseDuration(cast.ToString(v))
+	if err != nil {
+		return 0, fmt.Errorf("cannot convert %v to time.Duration", v)
+	}
+	return d, nil
+}
+
+// ToStringSlicePreserveString is the same as ToStringSlicePreserveStringE,
+// but it never fails.
+func ToStringSlicePreserveString(v any) []string {
+	vv, _ := ToStringSlicePreserveStringE(v)
+	return vv
+}
+
+// ToStringSlicePreserveStringE converts v to a string slice.
 // If v is a string, it will be wrapped in a string slice.
-func ToStringSlicePreserveString(v interface{}) []string {
+func ToStringSlicePreserveStringE(v any) ([]string, error) {
 	if v == nil {
-		return nil
+		return nil, nil
 	}
 	if sds, ok := v.(string); ok {
-		return []string{sds}
+		return []string{sds}, nil
 	}
-	return cast.ToStringSlice(v)
+	result, err := cast.ToStringSliceE(v)
+	if err == nil {
+		return result, nil
+	}
+
+	// Probably []int or similar. Fall back to reflect.
+	vv := reflect.ValueOf(v)
+
+	switch vv.Kind() {
+	case reflect.Slice, reflect.Array:
+		result = make([]string, vv.Len())
+		for i := 0; i < vv.Len(); i++ {
+			s, err := cast.ToStringE(vv.Index(i).Interface())
+			if err != nil {
+				return nil, err
+			}
+			result[i] = s
+		}
+		return result, nil
+	default:
+		return nil, fmt.Errorf("failed to convert %T to a string slice", v)
+	}
+
 }
 
 // TypeToString converts v to a string if it's a valid string type.
 // Note that this will not try to convert numeric values etc.,
 // use ToString for that.
-func TypeToString(v interface{}) (string, bool) {
+func TypeToString(v any) (string, bool) {
 	switch s := v.(type) {
 	case string:
 		return s, true
@@ -59,13 +110,13 @@ func TypeToString(v interface{}) (string, bool) {
 }
 
 // ToString converts v to a string.
-func ToString(v interface{}) string {
+func ToString(v any) string {
 	s, _ := ToStringE(v)
 	return s
 }
 
 // ToStringE converts v to a string.
-func ToStringE(v interface{}) (string, error) {
+func ToStringE(v any) (string, error) {
 	if s, ok := TypeToString(v); ok {
 		return s, nil
 	}

common/types/convert_test.go

@@ -16,6 +16,7 @@ package types
 import (
 	"encoding/json"
 	"testing"
+	"time"
 
 	qt "github.com/frankban/quicktest"
 )
@@ -24,7 +25,9 @@ func TestToStringSlicePreserveString(t *testing.T) {
 	c := qt.New(t)
 
 	c.Assert(ToStringSlicePreserveString("Hugo"), qt.DeepEquals, []string{"Hugo"})
-	c.Assert(ToStringSlicePreserveString([]interface{}{"A", "B"}), qt.DeepEquals, []string{"A", "B"})
+	c.Assert(ToStringSlicePreserveString(qt.Commentf("Hugo")), qt.DeepEquals, []string{"Hugo"})
+	c.Assert(ToStringSlicePreserveString([]any{"A", "B"}), qt.DeepEquals, []string{"A", "B"})
+	c.Assert(ToStringSlicePreserveString([]int{1, 3}), qt.DeepEquals, []string{"1", "3"})
 	c.Assert(ToStringSlicePreserveString(nil), qt.IsNil)
 }
 
@@ -34,3 +37,13 @@ func TestToString(t *testing.T) {
 	c.Assert(ToString([]byte("Hugo")), qt.Equals, "Hugo")
 	c.Assert(ToString(json.RawMessage("Hugo")), qt.Equals, "Hugo")
 }
+
+func TestToDuration(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(ToDuration("200ms"), qt.Equals, 200*time.Millisecond)
+	c.Assert(ToDuration("200"), qt.Equals, 200*time.Millisecond)
+	c.Assert(ToDuration("4m"), qt.Equals, 4*time.Minute)
+	c.Assert(ToDuration("asdfadf"), qt.Equals, time.Duration(0))
+
+}

common/types/hstring/stringtypes.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2022 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,27 +11,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package commands
+package hstring
 
-import (
-	"github.com/spf13/cobra"
-)
+type RenderedString string
 
-var _ cmder = (*checkCmd)(nil)
-
-type checkCmd struct {
-	*baseCmd
-}
-
-func newCheckCmd() *checkCmd {
-	cc := &checkCmd{baseCmd: &baseCmd{
-		cmd: &cobra.Command{
-			Use:   "check",
-			Short: "Contains some verification checks",
-		},
-	}}
-
-	cc.cmd.AddCommand(newLimitCmd().getCommand())
-
-	return cc
+func (s RenderedString) String() string {
+	return string(s)
 }