.circleci/config.yml

@@ -1,115 +1,50 @@
-parameters:
-
-# v2: 11m.
 defaults: &defaults
-  resource_class: large
+  working_directory: /go/src/github.com/gohugoio
   docker:
-      - image: bepsays/ci-hugoreleaser:1.22400.20000
+      - image: bepsays/ci-goreleaser:0.34.2-11
-environment: &buildenv
+    
-      GOMODCACHE: /root/project/gomodcache
 version: 2
 jobs:
-  prepare_release:
+  build:
-    <<: *defaults 
+    <<: *defaults
-    environment: &buildenv
-        GOMODCACHE: /root/project/gomodcache
     steps:
-      - setup_remote_docker
+      - checkout:
-      - 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: |
+            command: |
-            cd hugo
+                go get -d github.com/magefile/mage/...
-            go mod download
+                git clone git@github.com:gohugoio/hugoDocs.git
-            go run -tags release main.go release --step 1
+                cd hugo
-      - save_cache:
+                mage vendor
-          key: git-sha-{{ .Revision }}
+                mage check
-          paths:
+      - persist_to_workspace:
-            - hugo
+          root: .
-            - gomodcache
+          paths: .
-  build_container1:
+  release:
-    <<: [*defaults]
+    <<: *defaults
-    environment:
-      <<: [*buildenv]
     steps:
-      - &restore-cache
+      - attach_workspace:
-        restore_cache:
+          at: /go/src/github.com/gohugoio
-          key: git-sha-{{ .Revision }}
       - run:
-          no_output_timeout: 20m
+            command: |
-          command: |
+                    cd hugo
-            mkdir -p /tmp/files/dist1
+                    git config --global user.email "bjorn.erik.pedersen+hugoreleaser@gmail.com"
-            cd hugo
+                    git config --global user.name "hugoreleaser"
-            hugoreleaser build -paths "builds/container1/**" -workers 3 -dist /tmp/files/dist1 -chunks $CIRCLE_NODE_TOTAL -chunk-index $CIRCLE_NODE_INDEX
+                    go run -tags release main.go release -r ${CIRCLE_BRANCH}
-      - &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.22400.20000
-    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:
-          name: Add github.com to known hosts
-          command: ssh-keyscan github.com >> ~/.ssh/known_hosts
-      - 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:  
-        - prepare_release:
+        - build:
             filters:
               branches:
                 only: /release-.*/
-        - build_container1:
+        - hold:
+            type: approval
             requires:
-            - prepare_release
+              - build
-        - build_container2:
+        - release:
-            requires:
-            - prepare_release
-        - archive_and_release:
             context: org-global
             requires:
-            - build_container1
+              - hold
-            - build_container2
-     
-  
-       

.dockerignore

@@ -6,4 +6,3 @@
 .circleci
 docs
 examples
-Dockerfile

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,23 +0,0 @@
----
-name: 'Bug report'
-labels: 'Bug, NeedsTriage'
-assignees: ''
-about: Create a report to help us improve
----
-
-<!--
-Please do not use the issue queue for questions or troubleshooting. Unless you are certain that your issue is a software defect, use the forum:
-
-https://discourse.gohugo.io
--->
-
-<!-- Please answer these questions before submitting your issue. Thanks! -->
-
-### What version of Hugo are you using (`hugo version`)?
-
-<pre>
-$ hugo version
-
-</pre>
-
-### Does this issue reproduce with the latest release?

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-    - name: SUPPORT, ISSUES and TROUBLESHOOTING
-      url: https://discourse.gohugo.io/
-      about: Please DO NOT use Github for support requests. Please visit https://discourse.gohugo.io for support! You will be helped much faster there. If you ignore this request your issue might be closed with a discourse label.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,11 +0,0 @@
----
-name: Proposal
-about: Propose a new feature for Hugo
-title: ''
-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/dependabot.yml

@@ -1,7 +0,0 @@
-# See https://docs.github.com/en/github/administering-a-repository/configuration-options-for-dependency-updates#package-ecosystem
-version: 2
-updates:
-  - package-ecosystem: "gomod"
-    directory: "/"
-    schedule:
-      interval: "daily"

.github/stale.yml

@@ -0,0 +1,23 @@
+# 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/image.yml

@@ -1,49 +0,0 @@
-name: Build Docker image
-
-on:
-  release:
-    types: [published]
-  pull_request:
-permissions:
-  packages: write
-
-env:
-  REGISTRY_IMAGE: ghcr.io/gohugoio/hugo
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81 # v5.5.1
-        with:
-          images: ${{ env.REGISTRY_IMAGE }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db # v3.6.1
-
-      - name: Login to GHCR
-        # Login is only needed when the image is pushed
-        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3.3.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build and push
-        id: build
-        uses: docker/build-push-action@16ebe778df0e7752d2cfcbd924afdbbd89c1a755 # v6.6.1
-        with:
-          context: .
-          provenance: mode=max
-          sbom: true
-          push: ${{ github.event_name != 'pull_request' }}
-          platforms: linux/amd64,linux/arm64
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          build-args: HUGO_BUILD_TAGS=extended,withdeploy

.github/workflows/stale.yml

@@ -1,52 +0,0 @@
-name: 'Close stale and lock closed issues and PRs'
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '30 1 * * *'
-permissions:
-  contents: read
-jobs:
-  stale:
-    permissions:
-      issues: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    steps:
-      - uses: dessant/lock-threads@7de207be1d3ce97a9abe6ff1306222982d1ca9f9 # v5.0.1
-        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@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9.0.0
-        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,132 +0,0 @@
-on:
-  push:
-    branches: [master]
-  pull_request:
-name: Test
-env:
-  GOPROXY: https://proxy.golang.org
-  GO111MODULE: on
-  SASS_VERSION: 1.80.3
-  DART_SASS_SHA_LINUX: 7c933edbad0a7d389192c5b79393485c088bd2c4398e32f5754c32af006a9ffd
-  DART_SASS_SHA_MACOS: 79e060b0e131c3bb3c16926bafc371dc33feab122bfa8c01aa337a072097967b
-  DART_SASS_SHA_WINDOWS: 0bc4708b37cd1bac4740e83ac5e3176e66b774f77fd5dd364da5b5cfc9bfb469
-permissions:
-  contents: read
-jobs:
-  test:
-    strategy:
-      matrix:
-        go-version: [1.23.x, 1.24.x]
-        os: [ubuntu-latest, windows-latest] # macos disabled for now because of disk space issues.
-    runs-on: ${{ matrix.os }}
-    steps:
-      - if: matrix.os == 'ubuntu-latest'
-        name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be # v1.3.1
-        with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: false
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: true
-          swap-storage: true
-      - name: Checkout code
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
-      - name: Install Go
-        uses: actions/setup-go@0a12ed9d6a96ab950c8f026ed9f722fe0da7ef32 # v5.0.2
-        with:
-          go-version: ${{ matrix.go-version }}
-          check-latest: true
-          cache: true
-          cache-dependency-path: |
-            **/go.sum
-            **/go.mod
-      - name: Install Ruby
-        uses: ruby/setup-ruby@a6e6f86333f0a2523ece813039b8b4be04560854 # v1.190.0
-        with:
-          ruby-version: "2.7"
-          bundler-cache: true #
-      - name: Install Python
-        uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f # v5.1.1
-        with:
-          python-version: "3.x"
-      - name: Install Mage
-        run: go install github.com/magefile/mage@v1.15.0
-      - name: Install asciidoctor
-        uses: reitzig/actions-asciidoctor@c642db5eedd1d729bb8c92034770d0b2f769eda6 # v2.0.2
-      - name: Install docutils
-        run: |
-          pip install docutils
-          rst2html --version
-      - if: matrix.os == 'ubuntu-latest'
-        name: Install pandoc on Linux
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y pandoc
-      - if: matrix.os == 'macos-latest'
-        run: |
-          brew install pandoc
-      - if: matrix.os == 'windows-latest'
-        run: |
-          choco install pandoc
-      - run: pandoc -v
-      - if: matrix.os == 'windows-latest'
-        run: |
-          choco install mingw
-      - if: matrix.os == 'ubuntu-latest'
-        name: Install dart-sass Linux
-        run: |
-          echo "Install Dart Sass version ${SASS_VERSION} ..."
-          curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
-          echo "${DART_SASS_SHA_LINUX}  dart-sass-${SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
-          tar -xvf "dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
-          echo "$GOBIN"
-          echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
-      - if: matrix.os == 'macos-latest'
-        name: Install dart-sass MacOS
-        run: |
-          echo "Install Dart Sass version ${SASS_VERSION} ..."
-          curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
-          echo "${DART_SASS_SHA_MACOS}  dart-sass-${SASS_VERSION}-macos-x64.tar.gz" | shasum -a 256 -c;
-          tar -xvf "dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
-          echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
-      - if: matrix.os == 'windows-latest'
-        name: Install dart-sass Windows
-        run: |
-          echo "Install Dart Sass version ${env:SASS_VERSION} ..."
-          curl -LJO "https://github.com/sass/dart-sass/releases/download/${env:SASS_VERSION}/dart-sass-${env:SASS_VERSION}-windows-x64.zip";
-          Expand-Archive -Path "dart-sass-${env:SASS_VERSION}-windows-x64.zip" -DestinationPath .;
-          echo  "$env:GITHUB_WORKSPACE/dart-sass/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
-      - if: matrix.os == 'ubuntu-latest'
-        name: Install staticcheck
-        run: go install honnef.co/go/tools/cmd/staticcheck@latest
-      - if: matrix.os == 'ubuntu-latest'
-        name: Run staticcheck
-        run: staticcheck ./...
-      - if: matrix.os != 'windows-latest'
-        name: Check
-        run: |
-          sass --version;
-          mage -v check;
-        env:
-          HUGO_BUILD_TAGS: extended,withdeploy
-      - if: matrix.os == 'windows-latest'
-        # See issue #11052. We limit the build to regular test (no -race flag) on Windows for now.
-        name: Test
-        run: |
-          mage -v test;
-        env:
-          HUGO_BUILD_TAGS: extended,withdeploy
-      - name: Build tags
-        run: |
-          go install -tags extended
-      - if: matrix.os == 'ubuntu-latest'
-        name: Build for dragonfly
-        run: |
-          go install
-        env:
-          GOARCH: amd64
-          GOOS: dragonfly

.gitignore

@@ -1,6 +1,21 @@
-
+hugo
+docs/public*
+/.idea
+hugo.exe
 *.test
-imports.*
+*.prof
-dist/
+nohup.out
-public/
+cover.out
-.DS_Store 
+*.swp
+*.swo
+.DS_Store
+*~
+vendor/*/
+*.bench
+*.debug
+coverage*.out
+
+dock.sh
+
+GoBuilds
+dist

.travis.yml

@@ -0,0 +1,30 @@
+language: go
+sudo: false
+dist: trusty
+env:
+  HUGO_BUILD_TAGS="extended"
+git:
+  depth: false
+go:
+  - 1.9.7
+  - "1.10.3"
+  - tip
+os:
+  - linux
+  - osx
+matrix:
+  allow_failures:
+    - go: tip
+  fast_finish: true
+install:
+  - go get github.com/magefile/mage
+  - mage -v vendor
+script:
+  - mage -v test
+  - mage -v check
+  - mage -v hugo
+  - ./hugo -s docs/
+  - ./hugo --renderToMemory -s docs/
+before_install:
+  - gem install asciidoctor
+  - type asciidoctor

CONTRIBUTING.md

@@ -1,5 +1,3 @@
->**Note:** We would appreciate if you hold on with any big refactoring (like renaming deprecated Go packages), mainly because of potential for extra merge work for future coming in in the near future.
-
 # Contributing to Hugo
 
 We welcome contributions to Hugo of any kind including documentation, themes,
@@ -20,8 +18,11 @@ The Hugo community and maintainers are [very active](https://github.com/gohugoio
 * [Submitting Patches](#submitting-patches)
   * [Code Contribution Guidelines](#code-contribution-guidelines)
   * [Git Commit Message Guidelines](#git-commit-message-guidelines)
+  * [Vendored Dependencies](#vendored-dependencies)
   * [Fetching the Sources From GitHub](#fetching-the-sources-from-github)
-  * [Building Hugo with Your Changes](#building-hugo-with-your-changes)
+  * [Using Git Remotes](#using-git-remotes)
+  * [Build Hugo with Your Changes](#build-hugo-with-your-changes)
+  * [Updating the Hugo Sources](#updating-the-hugo-sources)
 
 ## Asking Support Questions
 
@@ -31,16 +32,12 @@ Please don't use the GitHub issue tracker to ask questions.
 ## Reporting Issues
 
 If you believe you have found a defect in Hugo or its documentation, use
-the GitHub issue tracker to report
+the GitHub [issue tracker](https://github.com/gohugoio/hugo/issues) 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`) and your operating system.
 
-- [Hugo Issues · gohugoio/hugo](https://github.com/gohugoio/hugo/issues)
-- [Hugo Documentation Issues · gohugoio/hugoDocs](https://github.com/gohugoio/hugoDocs/issues)
-- [Hugo Website Theme Issues · gohugoio/hugoThemesSite](https://github.com/gohugoio/hugoThemesSite/issues)
-
 ## Code Contribution
 
 Hugo has become a fully featured static site generator, so any new functionality must:
@@ -50,15 +47,15 @@ Hugo has become a fully featured static site generator, so any new functionality
 * strive not to break existing sites.
 * close or update an open [Hugo issue](https://github.com/gohugoio/hugo/issues)
 
-If it is of some complexity, the contributor is expected to maintain and support the new feature in the future (answer questions on the forum, fix any bugs etc.).
+If it is of some complexity, the contributor is expected to maintain and support the new future (answer questions on the forum, fix any bugs etc.).
 
-Any non-trivial code change needs to update an open [issue](https://github.com/gohugoio/hugo/issues). A non-trivial code change without an issue reference with one of the labels `bug` or `enhancement` will not be merged.
+It is recommended to open up a discussion on the [Hugo Forum](https://discourse.gohugo.io/) to get feedback on your idea before you begin. If you are submitting a complex feature, create a small design proposal on the [Hugo issue tracker](https://github.com/gohugoio/hugo/issues) before you start.
 
-Note that we do not accept new features that require [CGO](https://github.com/golang/go/wiki/cgo).
-We have one exception to this rule which is LibSASS.
 
 **Bug fixes are, of course, always welcome.**
 
+
+
 ## 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.
@@ -76,28 +73,24 @@ To make the contribution process as seamless as possible, we ask for the followi
     * Run `go fmt`.
     * Add documentation if you are adding new features or changing functionality.  The docs site lives in `/docs`.
     * Squash your commits into a single commit. `git rebase -i`. It’s okay to force update your pull request with `git push -f`.
-    * Ensure that `mage check` succeeds. [Travis CI](https://travis-ci.org/gohugoio/hugo) (Windows, Linux and macOS) will fail the build if `mage check` fails.
+    * Ensure that `mage check` succeeds. [Travis CI](https://travis-ci.org/gohugoio/hugo) (Linux and macOS) and [AppVeyor](https://ci.appveyor.com/project/gohugoio/hugo/branch/master) (Windows) will fail the build if `mage check` fails.
     * Follow the **Git Commit Message Guidelines** below.
 
 ### Git Commit Message Guidelines
 
-This [blog article](https://cbea.ms/git-commit/) is a good resource for learning how to write good commit messages,
+This [blog article](http://chris.beams.io/posts/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:
-*"js: Return error when option x is not set"*, **NOT** *"returning some error."*
+*"Return error on wrong use of the Paginator"*, **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.
-* Note that the above excludes nouns seen in other repositories, e.g. "chore:".
 
 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
@@ -113,23 +106,30 @@ Fixes #1949
 
 ###  Fetching the Sources 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:
+Due to the way Go handles package imports, the best approach for working on a
+Hugo fork is to use Git Remotes.  Here's a simple walk-through for getting
+started:
 
-```bash
+1. Get the Hugo source:
-mkdir $HOME/src
-cd $HOME/src
-git clone https://github.com/gohugoio/hugo.git
-cd hugo
-go install
-```
 
-For some convenient build and test targets, you also will want to install Mage:
+    ```bash
+    go get -u -v -d github.com/gohugoio/hugo
+    ```
 
-```bash
+1. Install Mage:
-go install github.com/magefile/mage
-```
 
-Now, to make a change to Hugo's source:
+    ```bash
+    go get github.com/magefile/mage
+    ```
+
+1. Change to the Hugo source directory and fetch the dependencies:
+
+    ```bash
+    cd $HOME/go/src/github.com/gohugoio/hugo
+    mage vendor
+    ```
+
+    Note that Hugo uses [Go Dep](https://github.com/golang/dep) to vendor dependencies, rather than a simple `go get`. We don't commit the vendored packages themselves to the Hugo git repository. The call to `mage vendor` takes care of all this for you.
 
 1. Create a new branch for your changes (the branch name is arbitrary):
 
@@ -148,7 +148,7 @@ Now, to make a change to Hugo's source:
 1. Add your fork as a new remote (the remote name, "fork" in this example, is arbitrary):
 
     ```bash
-    git remote add fork git@github.com:USERNAME/hugo.git
+    git remote add fork git://github.com/USERNAME/hugo.git
     ```
 
 1. Push the changes to your new remote:
@@ -167,7 +167,7 @@ Hugo uses [mage](https://github.com/magefile/mage) to sync vendor dependencies,
 cd $HOME/go/src/github.com/gohugoio/hugo
 ```
 
-To build Hugo:
+To build Hugo: 
 
 ```bash
 mage hugo
@@ -197,3 +197,15 @@ mage -l
 ```bash
 HUGO_BUILD_TAGS=extended mage install
 ````
+
+### Updating the Hugo Sources
+
+If you want to stay in sync with the Hugo repository, you can easily pull down
+the source changes, but you'll need to keep the vendored packages up-to-date as
+well.
+
+```bash
+git pull
+mage vendor
+```
+

Dockerfile

@@ -2,98 +2,26 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/
 
-ARG GO_VERSION="1.24"
+FROM golang:1.10.3-alpine3.7 AS build
-ARG ALPINE_VERSION="3.22"
-ARG DART_SASS_VERSION="1.79.3"
 
-FROM --platform=$BUILDPLATFORM tonistiigi/xx:1.5.0 AS xx
+ENV CGO_ENABLED=0
-FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine${ALPINE_VERSION} AS gobuild
+ENV GOOS=linux
-FROM golang:${GO_VERSION}-alpine${ALPINE_VERSION} AS gorun
-
-
-FROM gobuild AS build
-
-RUN apk add clang lld
-
-# Set up cross-compilation helpers
-COPY --from=xx / /
-
-ARG TARGETPLATFORM
-RUN xx-apk add musl-dev gcc g++
-
-# Optionally set HUGO_BUILD_TAGS to "none" or "withdeploy" when building like so:
-# docker build --build-arg HUGO_BUILD_TAGS=withdeploy .
-#
-# We build the extended version by default.
-ARG HUGO_BUILD_TAGS="extended"
-ENV CGO_ENABLED=1
-ENV GOPROXY=https://proxy.golang.org
-ENV GOCACHE=/root/.cache/go-build
-ENV GOMODCACHE=/go/pkg/mod
-ARG TARGETPLATFORM
 
 WORKDIR /go/src/github.com/gohugoio/hugo
-
-# For  --mount=type=cache the value of target is the default cache id, so
-# for the go mod cache it would be good if we could share it with other Go images using the same setup,
-# but the go build cache needs to be per platform.
-# See this comment: https://github.com/moby/buildkit/issues/1706#issuecomment-702238282
-RUN --mount=target=. \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=cache,target=/root/.cache/go-build,id=go-build-$TARGETPLATFORM <<EOT
-    set -ex
-    xx-go build -tags "$HUGO_BUILD_TAGS" -ldflags "-s -w -X github.com/gohugoio/hugo/common/hugo.vendorInfo=docker" -o /usr/bin/hugo
-    xx-verify /usr/bin/hugo
-EOT
-
-# dart-sass downloads the dart-sass runtime dependency
-FROM alpine:${ALPINE_VERSION} AS dart-sass
-ARG TARGETARCH
-ARG DART_SASS_VERSION
-ARG DART_ARCH=${TARGETARCH/amd64/x64}
-WORKDIR /out
-ADD https://github.com/sass/dart-sass/releases/download/${DART_SASS_VERSION}/dart-sass-${DART_SASS_VERSION}-linux-${DART_ARCH}.tar.gz .
-RUN tar -xf dart-sass-${DART_SASS_VERSION}-linux-${DART_ARCH}.tar.gz
-
-FROM gorun AS final
-
-COPY --from=build /usr/bin/hugo /usr/bin/hugo
-
-# libc6-compat  are required for extended libraries (libsass, libwebp).
 RUN apk add --no-cache \
-    libc6-compat \
     git \
-    runuser \
+    musl-dev && \
-    nodejs \
+  go get github.com/golang/dep/cmd/dep
-    npm
+COPY . /go/src/github.com/gohugoio/hugo/
+RUN dep ensure -vendor-only && \
+  go install -ldflags '-s -w'
 
-RUN mkdir -p /var/hugo/bin /cache && \
+# ---
-    addgroup -Sg 1000 hugo && \
-    adduser -Sg hugo -u 1000 -h /var/hugo hugo && \
-    chown -R hugo: /var/hugo /cache && \
-    # For the Hugo's Git integration to work.
-    runuser -u hugo -- git config --global --add safe.directory /project && \
-    # See https://github.com/gohugoio/hugo/issues/9810
-    runuser -u hugo -- git config --global core.quotepath false
 
-USER hugo:hugo
+FROM scratch
-VOLUME /project
+COPY --from=build /go/bin/hugo /hugo
-WORKDIR /project
+WORKDIR /site
-ENV HUGO_CACHEDIR=/cache
+VOLUME  /site
-ENV PATH="/var/hugo/bin:$PATH"
+EXPOSE  1313
-
+ENTRYPOINT [ "/hugo" ]
-COPY scripts/docker/entrypoint.sh /entrypoint.sh
+CMD [ "--help" ]
-COPY --from=dart-sass /out/dart-sass /var/hugo/bin/dart-sass
-
-# Update PATH to reflect the new dependencies.
-# For more complex setups, we should probably find a way to
-# delegate this to the script itself, but this will have to do for now.
-# Also, the dart-sass binary is a little special, other binaries can be put/linked
-# directly in /var/hugo/bin.
-ENV PATH="/var/hugo/bin/dart-sass:$PATH"
-
-# Expose port for live server
-EXPOSE 1313
-
-ENTRYPOINT ["/entrypoint.sh"]
-CMD ["--help"]

Gopkg.lock

@@ -0,0 +1,714 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  branch = "master"
+  digest = "1:f6a10073544cc0bd1eb9fd9f8d9bf4644971910a0f8393d51b5b4d286e554849"
+  name = "github.com/BurntSushi/locker"
+  packages = ["."]
+  pruneopts = ""
+  revision = "a6e239ea1c69bff1cfdb20c4b73dadf52f784b6a"
+
+[[projects]]
+  branch = "master"
+  digest = "1:af3600b068c8dd0e004122f154de7ece06b0b13376f79e976701aab4834c860a"
+  name = "github.com/BurntSushi/toml"
+  packages = ["."]
+  pruneopts = ""
+  revision = "a368813c5e648fee92e5f6c30e3944ff9d5e8895"
+
+[[projects]]
+  digest = "1:1080c443bebc98b1c25665b46b321dc02f8a4d384fe544379dcba1e651f59321"
+  name = "github.com/PuerkitoBio/purell"
+  packages = ["."]
+  pruneopts = ""
+  revision = "0bcb03f4b4d0a9428594752bd2a3b9aa0a9d4bd4"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:331a419049c2be691e5ba1d24342fc77c7e767a80c666a18fd8a9f7b82419c1c"
+  name = "github.com/PuerkitoBio/urlesc"
+  packages = ["."]
+  pruneopts = ""
+  revision = "de5bf2ad457846296e2031421a34e2568e304e35"
+
+[[projects]]
+  branch = "master"
+  digest = "1:60d5ffa86fb76749180841154b3714cde4771723b7e52329fb97ec916a6a68a6"
+  name = "github.com/alecthomas/assert"
+  packages = ["."]
+  pruneopts = ""
+  revision = "405dbfeb8e38effee6e723317226e93fff912d06"
+
+[[projects]]
+  digest = "1:2d78d7ffff1988e613e4946d6a6914190db0b38d533e392208797d2f557c92b6"
+  name = "github.com/alecthomas/chroma"
+  packages = [
+    ".",
+    "formatters",
+    "formatters/html",
+    "lexers",
+    "lexers/a",
+    "lexers/b",
+    "lexers/c",
+    "lexers/circular",
+    "lexers/d",
+    "lexers/e",
+    "lexers/f",
+    "lexers/g",
+    "lexers/h",
+    "lexers/i",
+    "lexers/internal",
+    "lexers/j",
+    "lexers/k",
+    "lexers/l",
+    "lexers/m",
+    "lexers/n",
+    "lexers/o",
+    "lexers/p",
+    "lexers/q",
+    "lexers/r",
+    "lexers/s",
+    "lexers/t",
+    "lexers/v",
+    "lexers/w",
+    "lexers/x",
+    "lexers/y",
+    "styles",
+  ]
+  pruneopts = ""
+  revision = "1b755a90bd109f170385cb3964f0abdfd3451145"
+
+[[projects]]
+  branch = "master"
+  digest = "1:ba0a389824c3c3d378f5f334370524b7d04b5a5ccedce7dd2da05ae8d3868609"
+  name = "github.com/alecthomas/colour"
+  packages = ["."]
+  pruneopts = ""
+  revision = "60882d9e27213e8552dcff6328914fe4c2b44bc9"
+
+[[projects]]
+  branch = "master"
+  digest = "1:5723237c9114bb92b4571532d9580dd0ed885ec3eb371d58085c074895c04a51"
+  name = "github.com/alecthomas/repr"
+  packages = ["."]
+  pruneopts = ""
+  revision = "f49988b46e025398b9f834f7c726afe001ec481f"
+
+[[projects]]
+  digest = "1:05d0e4ae6b8d0273647964fe26762e3345d5d196aaeb858838e75336703451ba"
+  name = "github.com/bep/debounce"
+  packages = ["."]
+  pruneopts = ""
+  revision = "844797fa1dd9ba969d71b62797ff19d1e49d4eac"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:88b2a2ccfbcf8aa697ec140e196c524f40bbdc8e6f6d03ff79354bc694cb677d"
+  name = "github.com/bep/gitmap"
+  packages = ["."]
+  pruneopts = ""
+  revision = "012701e8669671499fc43e9792335a1dcbfe2afb"
+
+[[projects]]
+  branch = "master"
+  digest = "1:7337271448975bc9cf3deae77bb2d7f7fc937c60c59b606ffcd25bfc754dd2ec"
+  name = "github.com/bep/go-tocss"
+  packages = [
+    "scss",
+    "scss/libsass",
+    "tocss",
+  ]
+  pruneopts = ""
+  revision = "2abb118dc8688b6c7df44e12f4152c2bded9b19c"
+
+[[projects]]
+  digest = "1:e5ad472b763adca2591568384b8f07974d2da4a98b55ffb360e2cecc2a216bae"
+  name = "github.com/chaseadamsio/goorgeous"
+  packages = ["."]
+  pruneopts = ""
+  revision = "dcf1ef873b8987bf12596fe6951c48347986eb2f"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:f30036d9c6eb2b9262edac69b5f6b59e25b25310ffee3035ab0e7c4b722a8552"
+  name = "github.com/cpuguy83/go-md2man"
+  packages = ["md2man"]
+  pruneopts = ""
+  revision = "a65d4d2de4d5f7c74868dfa9b202a3c8be315aaa"
+  version = "v1.0.6"
+
+[[projects]]
+  branch = "master"
+  digest = "1:8f6c36ee73ded871996ada894e20dfecde56557d08b4d1849d5489076679971f"
+  name = "github.com/danwakefield/fnmatch"
+  packages = ["."]
+  pruneopts = ""
+  revision = "cbb64ac3d964b81592e64f957ad53df015803288"
+
+[[projects]]
+  digest = "1:0a39ec8bf5629610a4bc7873a92039ee509246da3cef1a0ea60f1ed7e5f9cea5"
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  pruneopts = ""
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:8dc164acd41f84c9f704362d061f90cf45014c3b7eb3fead126efb7d152e2efc"
+  name = "github.com/disintegration/imaging"
+  packages = ["."]
+  pruneopts = ""
+  revision = "dd50a3ee9985ccd313a2f03c398fcaedc96dc707"
+  version = "v1.2.4"
+
+[[projects]]
+  digest = "1:536d2bdf1cdef7ec49e1cb4a8a083ae639159f0fd11a5829fe4d35ecb8cc3a1a"
+  name = "github.com/dlclark/regexp2"
+  packages = [
+    ".",
+    "syntax",
+  ]
+  pruneopts = ""
+  revision = "487489b64fb796de2e55f4e8a4ad1e145f80e957"
+  version = "v1.1.6"
+
+[[projects]]
+  branch = "master"
+  digest = "1:fbbae68d476d61afb78178dd4c5532dbfff154e2fea72d1312138bf35c613ec1"
+  name = "github.com/eknkc/amber"
+  packages = [
+    ".",
+    "parser",
+  ]
+  pruneopts = ""
+  revision = "cdade1c073850f4ffc70a829e31235ea6892853b"
+
+[[projects]]
+  digest = "1:e5c807ac3b60699ccec9263f6eec756251b17e78582eb149f90ac345d9e58327"
+  name = "github.com/fortytw2/leaktest"
+  packages = ["."]
+  pruneopts = ""
+  revision = "a5ef70473c97b71626b9abeda80ee92ba2a7de9e"
+  version = "v1.2.0"
+
+[[projects]]
+  digest = "1:b2106f1668ea5efc1ecc480f7e922a093adb9563fd9ce58585292871f0d0f229"
+  name = "github.com/fsnotify/fsnotify"
+  packages = ["."]
+  pruneopts = ""
+  revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
+  version = "v1.4.7"
+
+[[projects]]
+  digest = "1:b7a7e17513aeee6492d93015c7bf29c86a0c1c91210ea56b21e36c1a40958cba"
+  name = "github.com/gobwas/glob"
+  packages = [
+    ".",
+    "compiler",
+    "match",
+    "syntax",
+    "syntax/ast",
+    "syntax/lexer",
+    "util/runes",
+    "util/strings",
+  ]
+  pruneopts = ""
+  revision = "5ccd90ef52e1e632236f7326478d4faa74f99438"
+  version = "v0.2.3"
+
+[[projects]]
+  digest = "1:fe1b4d4cbe48c0d55507c55f8663aa4185576cc58fa0c8be03bb8f19dfe17a9c"
+  name = "github.com/gorilla/websocket"
+  packages = ["."]
+  pruneopts = ""
+  revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b"
+  version = "v1.2.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4423ee95d6ee30bb22f680445c58889bb5b91e1b955405bf34374a053784a8a2"
+  name = "github.com/hashicorp/go-immutable-radix"
+  packages = ["."]
+  pruneopts = ""
+  revision = "7f3cd4390caab3250a57f30efdb2a65dd7649ecf"
+
+[[projects]]
+  branch = "master"
+  digest = "1:9c776d7d9c54b7ed89f119e449983c3f24c0023e75001d6092442412ebca6b94"
+  name = "github.com/hashicorp/golang-lru"
+  packages = ["simplelru"]
+  pruneopts = ""
+  revision = "0fb14efe8c47ae851c0034ed7a448854d3d34cf3"
+
+[[projects]]
+  branch = "master"
+  digest = "1:ccfc44438ba7fc24effffbe9c7b75bbbb51e7a275e361e62a4dbffbc9e8e43d9"
+  name = "github.com/hashicorp/hcl"
+  packages = [
+    ".",
+    "hcl/ast",
+    "hcl/parser",
+    "hcl/printer",
+    "hcl/scanner",
+    "hcl/strconv",
+    "hcl/token",
+    "json/parser",
+    "json/scanner",
+    "json/token",
+  ]
+  pruneopts = ""
+  revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168"
+
+[[projects]]
+  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
+  name = "github.com/inconshreveable/mousetrap"
+  packages = ["."]
+  pruneopts = ""
+  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+  version = "v1.0"
+
+[[projects]]
+  digest = "1:3b82a4308adc7319d0c7efbad106e966cbbf70e47f16fb5f7aca131b01f6f9b1"
+  name = "github.com/jdkato/prose"
+  packages = [
+    "internal/util",
+    "transform",
+  ]
+  pruneopts = ""
+  revision = "20d3663d4bc9dd10d75abcde9d92e04b4861c674"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:f72872791669f287262777a6a635c7aaebbdd9919cffacea802f8f9c1dc2e6f6"
+  name = "github.com/kyokomi/emoji"
+  packages = ["."]
+  pruneopts = ""
+  revision = "7e06b236c489543f53868841f188a294e3383eab"
+  version = "v1.5"
+
+[[projects]]
+  digest = "1:3ee69edc976a8e66debd179073163cbbef426faa7c0ef2d8ff8e3be159699d2e"
+  name = "github.com/magefile/mage"
+  packages = [
+    "mg",
+    "sh",
+  ]
+  pruneopts = ""
+  revision = "2f974307b636f59c13b88704cf350a4772fef271"
+  version = "v1.0.2"
+
+[[projects]]
+  digest = "1:093cd7ebfdecf5692c66f0b0f7a1877d796c89d9940f5769439c53dc65264036"
+  name = "github.com/magiconair/properties"
+  packages = ["."]
+  pruneopts = ""
+  revision = "c3beff4c2358b44d0493c7dda585e7db7ff28ae6"
+  version = "v1.7.6"
+
+[[projects]]
+  digest = "1:fd46423a2fe75d52968baf37471b99e6f05cea3ac29c756128ead26af34e1c35"
+  name = "github.com/markbates/inflect"
+  packages = ["."]
+  pruneopts = ""
+  revision = "a12c3aec81a6a938bf584a4bac567afed9256586"
+
+[[projects]]
+  digest = "1:78229b46ddb7434f881390029bd1af7661294af31f6802e0e1bedaad4ab0af3c"
+  name = "github.com/mattn/go-isatty"
+  packages = ["."]
+  pruneopts = ""
+  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
+  version = "v0.0.3"
+
+[[projects]]
+  digest = "1:81e673df85e765593a863f67cba4544cf40e8919590f04d67664940786c2b61a"
+  name = "github.com/mattn/go-runewidth"
+  packages = ["."]
+  pruneopts = ""
+  revision = "9e777a8366cce605130a531d2cd6363d07ad7317"
+  version = "v0.0.2"
+
+[[projects]]
+  digest = "1:6066f4c384723dd468c96adc13bfe4d977f182c2305e1a82c94bb50e1507d528"
+  name = "github.com/miekg/mmark"
+  packages = ["."]
+  pruneopts = ""
+  revision = "fd2f6c1403b37925bd7fe13af05853b8ae58ee5f"
+  version = "v1.3.6"
+
+[[projects]]
+  branch = "master"
+  digest = "1:0de0f377aeccd41384e883c59c6f184c9db01c96db33a2724a1eaadd60f92629"
+  name = "github.com/mitchellh/hashstructure"
+  packages = ["."]
+  pruneopts = ""
+  revision = "2bca23e0e452137f789efbc8610126fd8b94f73b"
+
+[[projects]]
+  branch = "master"
+  digest = "1:59fa50d593e5673a0dfffa1852b66fd700c05b35e368680b4b89a68fdb2c1379"
+  name = "github.com/mitchellh/mapstructure"
+  packages = ["."]
+  pruneopts = ""
+  revision = "00c29f56e2386353d58c599509e8dc3801b0d716"
+
+[[projects]]
+  branch = "master"
+  digest = "1:08b8db6381176e5472815f67f29b2b8b21d5bf3adaba4de3e5416faaf26f3689"
+  name = "github.com/muesli/smartcrop"
+  packages = [
+    ".",
+    "options",
+  ]
+  pruneopts = ""
+  revision = "f6ebaa786a12a0fdb2d7c6dee72808e68c296464"
+
+[[projects]]
+  digest = "1:34afc91b88b56c71639e275ff3ea8179a8f094ddc86df96e26074000cade42fe"
+  name = "github.com/nicksnyder/go-i18n"
+  packages = [
+    "i18n/bundle",
+    "i18n/language",
+    "i18n/translation",
+  ]
+  pruneopts = ""
+  revision = "0dc1626d56435e9d605a29875701721c54bc9bbd"
+  version = "v1.10.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:2656200f82783893859c77903afc794d97c1f5054e2b57f7021e33a6047e7b1e"
+  name = "github.com/olekukonko/tablewriter"
+  packages = ["."]
+  pruneopts = ""
+  revision = "b8a9be070da40449e501c3c4730a889e42d87a9e"
+
+[[projects]]
+  digest = "1:fef37519c971ab3c464318a0c9da6a7fb9c21439aa587e61bf10af651e6119b9"
+  name = "github.com/pelletier/go-toml"
+  packages = ["."]
+  pruneopts = ""
+  revision = "acdc4509485b587f5e675510c4f2c63e90ff68a8"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:256484dbbcd271f9ecebc6795b2df8cad4c458dd0f5fd82a8c2fa0c29f233411"
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  pruneopts = ""
+  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:10bc894f31df5ca3366a50122ee2ade6b56f3f5531c523a8a551748a0663aa1b"
+  name = "github.com/russross/blackfriday"
+  packages = ["."]
+  pruneopts = ""
+  revision = "11635eb403ff09dbc3a6b5a007ab5ab09151c229"
+
+[[projects]]
+  digest = "1:afa9b7bb3d9e633ef32e46ab4b6a87b5376271e3d86b09a379029bbb10e26fa0"
+  name = "github.com/sanity-io/litter"
+  packages = ["."]
+  pruneopts = ""
+  revision = "ae543b7ba8fd6af63e4976198f146e1348ae53c1"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:1ebe873a8dc99e3316c30fea2e211038c4d1fcb605eee17e00a5e91b8817925e"
+  name = "github.com/sergi/go-diff"
+  packages = ["diffmatchpatch"]
+  pruneopts = ""
+  revision = "1744e2970ca51c86172c8190fadad617561ed6e7"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:606fa779c7a80ab6a9ec5836cd12759f86cd6e1d82d5d60cf7ec5133e78c6cf8"
+  name = "github.com/shurcooL/sanitized_anchor_name"
+  packages = ["."]
+  pruneopts = ""
+  revision = "86672fcb3f950f35f2e675df2240550f2a50762f"
+
+[[projects]]
+  digest = "1:3d6c88f060fdaac3291f3d18f58eb542fe3a2b330609b269962d26d0c99104be"
+  name = "github.com/spf13/afero"
+  packages = [
+    ".",
+    "mem",
+  ]
+  pruneopts = ""
+  revision = "787d034dfe70e44075ccc060d346146ef53270ad"
+  version = "v1.1.1"
+
+[[projects]]
+  digest = "1:d0b38ba6da419a6d4380700218eeec8623841d44a856bb57369c172fbf692ab4"
+  name = "github.com/spf13/cast"
+  packages = ["."]
+  pruneopts = ""
+  revision = "8965335b8c7107321228e3e3702cab9832751bac"
+  version = "v1.2.0"
+
+[[projects]]
+  digest = "1:9e14345bfb9aa30952b41ffceaa2acd559933cfe3d17bd87b7f6e54b6c618492"
+  name = "github.com/spf13/cobra"
+  packages = [
+    ".",
+    "doc",
+  ]
+  pruneopts = ""
+  revision = "a1f051bc3eba734da4772d60e2d677f47cf93ef4"
+  version = "v0.0.2"
+
+[[projects]]
+  branch = "master"
+  digest = "1:7c00f445c89f468abd5ab86546ba1fa11bac66e63325ade8ca05aa7220791fc7"
+  name = "github.com/spf13/fsync"
+  packages = ["."]
+  pruneopts = ""
+  revision = "12a01e648f05a938100a26858d2d59a120307a18"
+
+[[projects]]
+  branch = "master"
+  digest = "1:104517520aab91164020ab6524a5d6b7cafc641b2e42ac6236f6ac1deac4f66a"
+  name = "github.com/spf13/jwalterweatherman"
+  packages = ["."]
+  pruneopts = ""
+  revision = "7c0cea34c8ece3fbeb2b27ab9b59511d360fb394"
+
+[[projects]]
+  branch = "master"
+  digest = "1:5082c0d57a199dabc0868010784039249af0932fad2990b51ad9404c9a6b6e5d"
+  name = "github.com/spf13/nitro"
+  packages = ["."]
+  pruneopts = ""
+  revision = "24d7ef30a12da0bdc5e2eb370a79c659ddccf0e8"
+
+[[projects]]
+  digest = "1:261bc565833ef4f02121450d74eb88d5ae4bd74bfe5d0e862cddb8550ec35000"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  pruneopts = ""
+  revision = "e57e3eeb33f795204c1ca35f56c44f83227c6e66"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:79af66c513727a0ed32fb4137ad7d0613b01e8e2f5ce9479724e26e2c9068011"
+  name = "github.com/spf13/viper"
+  packages = ["."]
+  pruneopts = ""
+  revision = "b5e8006cbee93ec955a89ab31e0e3ce3204f3736"
+  version = "v1.0.2"
+
+[[projects]]
+  digest = "1:a70d585d45f695f2e8e6782569bdf181419667a35e6035ceb086706b495aa21a"
+  name = "github.com/stretchr/testify"
+  packages = [
+    "assert",
+    "require",
+  ]
+  pruneopts = ""
+  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
+  version = "v1.2.1"
+
+[[projects]]
+  digest = "1:54b1c3f97e0d74b571055cc17af4a978b6160e6ccfda73608aba048e404319c1"
+  name = "github.com/tdewolff/minify"
+  packages = [
+    ".",
+    "css",
+    "html",
+    "js",
+    "json",
+    "svg",
+    "xml",
+  ]
+  pruneopts = ""
+  revision = "8d72a4127ae33b755e95bffede9b92e396267ce2"
+  version = "v2.3.5"
+
+[[projects]]
+  digest = "1:33d327ae34260328b00ed15f89961446d805797a96de8643a983020825bb51ae"
+  name = "github.com/tdewolff/parse"
+  packages = [
+    ".",
+    "buffer",
+    "css",
+    "html",
+    "js",
+    "json",
+    "strconv",
+    "svg",
+    "xml",
+  ]
+  pruneopts = ""
+  revision = "d739d6fccb0971177e06352fea02d3552625efb1"
+  version = "v2.3.3"
+
+[[projects]]
+  branch = "master"
+  digest = "1:12e69a2969bdcdf2928607e51966a868482c2a450f1c97c5dde004257c8369ff"
+  name = "github.com/wellington/go-libsass"
+  packages = ["libs"]
+  pruneopts = ""
+  revision = "615eaa47ef794d037c1906a0eb7bf85375a5decf"
+
+[[projects]]
+  digest = "1:b1e5dc66cd8ad9712eb8fd4dfaecac6ae45cbcde94476c5b64d905c5d789eef7"
+  name = "github.com/yosssi/ace"
+  packages = ["."]
+  pruneopts = ""
+  revision = "ea038f4770b6746c3f8f84f14fa60d9fe1205b56"
+  version = "v0.0.5"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4525c51a65e4974007814da8e2621343840d769d80b2b2ab79e6958342726587"
+  name = "golang.org/x/image"
+  packages = [
+    "bmp",
+    "draw",
+    "math/f64",
+    "riff",
+    "tiff",
+    "tiff/lzw",
+    "vp8",
+    "vp8l",
+    "webp",
+  ]
+  pruneopts = ""
+  revision = "f315e440302883054d0c2bd85486878cb4f8572c"
+
+[[projects]]
+  branch = "master"
+  digest = "1:8bb19e8d6e1321626d3f58ffee75699e86940c79d959b30fcf632883d7c4d303"
+  name = "golang.org/x/net"
+  packages = [
+    "context",
+    "idna",
+  ]
+  pruneopts = ""
+  revision = "61147c48b25b599e5b561d2e9c4f3e1ef489ca41"
+
+[[projects]]
+  branch = "master"
+  digest = "1:d84d0f563cc649de4c9a8272a0395f75b11952202d18d4d927e933cc91493062"
+  name = "golang.org/x/sync"
+  packages = ["errgroup"]
+  pruneopts = ""
+  revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca"
+
+[[projects]]
+  branch = "master"
+  digest = "1:137a530894d869c2fb09e135e6bb7a5d701347ba273471eaa2483053f8fbeb35"
+  name = "golang.org/x/sys"
+  packages = ["unix"]
+  pruneopts = ""
+  revision = "3b87a42e500a6dc65dae1a55d0b641295971163e"
+
+[[projects]]
+  branch = "master"
+  digest = "1:4cf01dae652ef4428cf9d354bdec79467e436ecfa92d943b1ada8184e1a938b6"
+  name = "golang.org/x/text"
+  packages = [
+    "collate",
+    "collate/build",
+    "internal/colltab",
+    "internal/gen",
+    "internal/language",
+    "internal/language/compact",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
+    "transform",
+    "unicode/bidi",
+    "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable",
+    "width",
+  ]
+  pruneopts = ""
+  revision = "2cb43934f0eece38629746959acc633cba083fe4"
+
+[[projects]]
+  branch = "v2"
+  digest = "1:f0620375dd1f6251d9973b5f2596228cc8042e887cd7f827e4220bc1ce8c30e2"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  pruneopts = ""
+  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/BurntSushi/locker",
+    "github.com/BurntSushi/toml",
+    "github.com/PuerkitoBio/purell",
+    "github.com/alecthomas/assert",
+    "github.com/alecthomas/chroma",
+    "github.com/alecthomas/chroma/formatters",
+    "github.com/alecthomas/chroma/formatters/html",
+    "github.com/alecthomas/chroma/lexers",
+    "github.com/alecthomas/chroma/styles",
+    "github.com/bep/debounce",
+    "github.com/bep/gitmap",
+    "github.com/bep/go-tocss/scss",
+    "github.com/bep/go-tocss/scss/libsass",
+    "github.com/bep/go-tocss/tocss",
+    "github.com/chaseadamsio/goorgeous",
+    "github.com/disintegration/imaging",
+    "github.com/eknkc/amber",
+    "github.com/fortytw2/leaktest",
+    "github.com/fsnotify/fsnotify",
+    "github.com/gobwas/glob",
+    "github.com/gorilla/websocket",
+    "github.com/hashicorp/go-immutable-radix",
+    "github.com/jdkato/prose/transform",
+    "github.com/kyokomi/emoji",
+    "github.com/magefile/mage/mg",
+    "github.com/magefile/mage/sh",
+    "github.com/markbates/inflect",
+    "github.com/miekg/mmark",
+    "github.com/mitchellh/hashstructure",
+    "github.com/mitchellh/mapstructure",
+    "github.com/muesli/smartcrop",
+    "github.com/nicksnyder/go-i18n/i18n/bundle",
+    "github.com/nicksnyder/go-i18n/i18n/language",
+    "github.com/olekukonko/tablewriter",
+    "github.com/russross/blackfriday",
+    "github.com/sanity-io/litter",
+    "github.com/spf13/afero",
+    "github.com/spf13/cast",
+    "github.com/spf13/cobra",
+    "github.com/spf13/cobra/doc",
+    "github.com/spf13/fsync",
+    "github.com/spf13/jwalterweatherman",
+    "github.com/spf13/nitro",
+    "github.com/spf13/pflag",
+    "github.com/spf13/viper",
+    "github.com/stretchr/testify/assert",
+    "github.com/stretchr/testify/require",
+    "github.com/tdewolff/minify",
+    "github.com/tdewolff/minify/css",
+    "github.com/tdewolff/minify/html",
+    "github.com/tdewolff/minify/js",
+    "github.com/tdewolff/minify/json",
+    "github.com/tdewolff/minify/svg",
+    "github.com/tdewolff/minify/xml",
+    "github.com/yosssi/ace",
+    "golang.org/x/image/webp",
+    "golang.org/x/net/context",
+    "golang.org/x/sync/errgroup",
+    "golang.org/x/text/transform",
+    "golang.org/x/text/unicode/norm",
+    "gopkg.in/yaml.v2",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

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

README.md

@@ -1,282 +1,126 @@
-[bep]: https://github.com/bep
+![Hugo](https://raw.githubusercontent.com/gohugoio/hugoDocs/master/static/img/hugo-logo.png)
-[bugs]: https://github.com/gohugoio/hugo/issues?q=is%3Aopen+is%3Aissue+label%3ABug
-[contributing]: CONTRIBUTING.md
-[create a proposal]: https://github.com/gohugoio/hugo/issues/new?labels=Proposal%2C+NeedsTriage&template=feature_request.md
-[documentation repository]: https://github.com/gohugoio/hugoDocs
-[documentation]: https://gohugo.io/documentation
-[dragonfly bsd, freebsd, netbsd, and openbsd]: https://gohugo.io/installation/bsd
-[features]: https://gohugo.io/about/features/
-[forum]: https://discourse.gohugo.io
-[friends]: https://github.com/gohugoio/hugo/graphs/contributors
-[go]: https://go.dev/
-[hugo modules]: https://gohugo.io/hugo-modules/
-[installation]: https://gohugo.io/installation
-[issue queue]: https://github.com/gohugoio/hugo/issues
-[linux]: https://gohugo.io/installation/linux
-[macos]: https://gohugo.io/installation/macos
-[prebuilt binary]: https://github.com/gohugoio/hugo/releases/latest
-[requesting help]: https://discourse.gohugo.io/t/requesting-help/9132
-[spf13]: https://github.com/spf13
-[static site generator]: https://en.wikipedia.org/wiki/Static_site_generator
-[support]: https://discourse.gohugo.io
-[themes]: https://themes.gohugo.io/
-[website]: https://gohugo.io
-[windows]: https://gohugo.io/installation/windows
 
-<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], [spf13], and [friends] in [Go].
+[Website](https://gohugo.io) |
-
+[Forum](https://discourse.gohugo.io) |
----
+[Developer Chat (no support)](https://gitter.im/gohugoio/hugo) |
+[Documentation](https://gohugo.io/overview/introduction/) |
+[Installation Guide](https://gohugo.io/overview/installing/) |
+[Contribution Guide](CONTRIBUTING.md) |
+[Twitter](http://twitter.com/gohugoio)
 
 [![GoDoc](https://godoc.org/github.com/gohugoio/hugo?status.svg)](https://godoc.org/github.com/gohugoio/hugo)
-[![Tests on Linux, MacOS and Windows](https://github.com/gohugoio/hugo/workflows/Test/badge.svg)](https://github.com/gohugoio/hugo/actions?query=workflow%3ATest)
+[![Linux and macOS Build Status](https://api.travis-ci.org/gohugoio/hugo.svg?branch=master&label=Linux+and+macOS+build "Linux and macOS Build Status")](https://travis-ci.org/gohugoio/hugo)
+[![Windows Build Status](https://ci.appveyor.com/api/projects/status/a5mr220vsd091kua?svg=true&label=Windows+build "Windows Build Status")](https://ci.appveyor.com/project/bep/hugo/branch/master)
+[![Dev chat at https://gitter.im/gohugoio/hugo](https://img.shields.io/badge/gitter-developer_chat-46bc99.svg)](https://gitter.im/spf13/hugo?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Go Report Card](https://goreportcard.com/badge/github.com/gohugoio/hugo)](https://goreportcard.com/report/github.com/gohugoio/hugo)
 
-[Website] | [Installation] | [Documentation] | [Support] | [Contributing] | <a rel="me" href="https://fosstodon.org/@gohugoio">Mastodon</a>
-
 ## Overview
 
-Hugo is a [static site generator] written in [Go], optimized for speed and designed for flexibility. With its advanced templating system and fast asset pipelines, Hugo renders a complete site in seconds, often less.
+Hugo is a static HTML and CSS website generator written in [Go][].
+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.
 
-Due to its flexible framework, multilingual support, and powerful taxonomy system, Hugo is widely used to create:
+Hugo relies on Markdown files with front matter for metadata, and you can run Hugo from any directory.
+This works well for shared hosts and other systems where you don’t have a privileged account.
 
-- Corporate, government, nonprofit, education, news, event, and project sites
+Hugo renders a typical website of moderate size in a fraction of a second.
-- Documentation sites
+A good rule of thumb is that each piece of content renders in around 1 millisecond.
-- Image portfolios
-- Landing pages
-- Business, professional, and personal blogs
-- Resumes and CVs
 
-Use Hugo's embedded web server during development to instantly see changes to content, structure, behavior, and presentation. Then deploy the site to your host, or push changes to your Git provider for automated builds and deployment.
+Hugo is designed to work well for any kind of website including blogs, tumbles, and docs.
 
-Hugo's fast asset pipelines include:
+#### Supported Architectures
 
-- Image processing &ndash; Convert, resize, crop, rotate, adjust colors, apply filters, overlay text and images, and extract EXIF data
+Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBSD, macOS (Darwin), and [Android](https://gist.github.com/bep/a0d8a26cf6b4f8bc992729b8e50b480b) for x64, i386 and ARM architectures.
-- JavaScript bundling &ndash; Transpile TypeScript and JSX to JavaScript, bundle, tree shake, minify, create source maps, and perform SRI hashing.
-- Sass processing &ndash; Transpile Sass to CSS, bundle, tree shake, minify, create source maps, perform SRI hashing, and integrate with PostCSS
-- Tailwind CSS processing &ndash; Compile Tailwind CSS utility classes into standard CSS, bundle, tree shake, optimize, minify, perform SRI hashing, and integrate with PostCSS
 
-And with [Hugo Modules], you can share content, assets, data, translations, themes, templates, and configuration with other projects via public or private Git repositories.
+Hugo may also be compiled from source wherever the Go compiler tool chain can run, e.g. for other operating systems including DragonFly BSD, OpenBSD, Plan 9, and Solaris.
 
-See the [features] section of the documentation for a comprehensive summary of Hugo's capabilities.
+**Complete documentation is available at [Hugo Documentation][].**
 
-## Sponsors
+## Choose How to Install
 
-<p>&nbsp;</p>
+If you want to use Hugo as your site generator, simply install the Hugo binaries.
-<p float="left">
+The Hugo binaries have no external dependencies.
-  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></a>
-&nbsp;&nbsp;&nbsp;
-  <a href="https://www.jetbrains.com/go/?utm_source=OSS&utm_medium=referral&utm_campaign=hugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/goland.svg" width="200" alt="The complete IDE crafted for professional Go developers."></a>
-  &nbsp;&nbsp;&nbsp;
-  <a href="https://pinme.eth.limo/?s=hugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/logo-pinme.svg" width="200" alt="PinMe."></a>
-</p>
 
-## Editions
+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.
 
-Hugo is available in three editions: standard, extended, and extended/deploy. While the standard edition provides core functionality, the extended and extended/deploy editions offer advanced features.
+Finally, you can install the Hugo source code with `go`, build the binaries yourself, and run Hugo that way.
+Building the binaries is an easy task for an experienced `go` getter.
 
-Feature|extended edition|extended/deploy edition
+### Install Hugo as Your Site Generator (Binary Install)
-:--|:-:|:-:
-Encode to the WebP format when [processing images]. You can decode WebP images with any edition.|:heavy_check_mark:|:heavy_check_mark:
-[Transpile Sass to CSS] using the embedded LibSass transpiler. You can use the [Dart Sass] transpiler with any edition.|:heavy_check_mark:|:heavy_check_mark:
-Deploy your site directly to a Google Cloud Storage bucket, an AWS S3 bucket, or an Azure Storage container. See&nbsp;[details].|:x:|:heavy_check_mark:
 
-[dart sass]: https://gohugo.io/functions/css/sass/#dart-sass
+Use the [installation instructions in the Hugo documentation](https://gohugo.io/overview/installing/).
-[processing images]: https://gohugo.io/content-management/image-processing/
-[transpile sass to css]: https://gohugo.io/functions/css/sass/
-[details]: https://gohugo.io/hosting-and-deployment/hugo-deploy/
 
-Unless your specific deployment needs require the extended/deploy edition, we recommend the extended edition.
+### Build and Install the Binaries from Source (Advanced Install)
 
-## Installation
+#### Prerequisite Tools
 
-Install Hugo from a [prebuilt binary], package manager, or package repository. Please see the installation instructions for your operating system:
+* [Git](http://git-scm.com/)
+* [Go (latest or previous version)](https://golang.org/dl/)
 
-- [macOS]
+#### Vendored Dependencies
-- [Linux]
-- [Windows]
-- [DragonFly BSD, FreeBSD, NetBSD, and OpenBSD]
 
-## Build from source
+Hugo uses [dep](https://github.com/golang/dep) to vendor dependencies, but we don't commit the vendored packages themselves to the Hugo git repository. Therefore, a simple `go get` is _not_ supported because the command is not vendor aware.
 
-Prerequisites to build Hugo from source:
+The simplest way is to use [mage](https://github.com/magefile/mage) (a Make alternative for Go projects.)
 
-- Standard edition: Go 1.23.0 or later
+#### Fetch from GitHub
-- Extended edition: Go 1.23.0 or later, and GCC
-- Extended/deploy edition: Go 1.23.0 or later, and GCC
 
-Build the standard edition:
+```bash
-
+go get github.com/magefile/mage
-```text
+go get -d github.com/gohugoio/hugo
-go install github.com/gohugoio/hugo@latest
+cd ${GOPATH:-$HOME/go}/src/github.com/gohugoio/hugo
+mage vendor
+mage install
 ```
 
-Build the extended edition:
+**If you are a Windows user, substitute the `$HOME` environment variable above with `%USERPROFILE%`.**
+	
+## The Hugo Documentation
 
-```text
+The Hugo documentation now lives in its own repository, see https://github.com/gohugoio/hugoDocs. But we do keep a version of that documentation as a `git subtree` in this repository. To build the sub folder `/docs` as a Hugo site, you need to clone this repo:
-CGO_ENABLED=1 go install -tags extended github.com/gohugoio/hugo@latest
+
+```bash
+git clone git@github.com:gohugoio/hugo.git
 ```
-
+## Contributing to Hugo
-Build the extended/deploy edition:
-
-```text
-CGO_ENABLED=1 go install -tags extended,withdeploy github.com/gohugoio/hugo@latest
-```
-
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=gohugoio/hugo&type=Timeline)](https://star-history.com/#gohugoio/hugo&Timeline)
-
-## Documentation
-
-Hugo's [documentation] includes installation instructions, a quick start guide, conceptual explanations, reference information, and examples.
-
-Please submit documentation issues and pull requests to the [documentation repository].
-
-## Support
-
-Please **do not use the issue queue** for questions or troubleshooting. Unless you are certain that your issue is a software defect, use the [forum].
-
-Hugo’s [forum] is an active community of users and developers who answer questions, share knowledge, and provide examples. A quick search of over 20,000 topics will often answer your question. Please be sure to read about [requesting help] before asking your first question.
-
-## Contributing
-
-You can contribute to the Hugo project by:
-
-- Answering questions on the [forum]
-- Improving the [documentation]
-- Monitoring the [issue queue]
-- Creating or improving [themes]
-- Squashing [bugs]
-
-Please submit documentation issues and pull requests to the [documentation repository].
-
-If you have an idea for an enhancement or new feature, create a new topic on the [forum] in the "Feature" category. This will help you to:
-
-- Determine if the capability already exists
-- Measure interest
-- Refine the concept
-
-If there is sufficient interest, [create a proposal]. Do not submit a pull request until the project lead accepts the proposal.
 
 For a complete guide to contributing to Hugo, see the [Contribution Guide](CONTRIBUTING.md).
 
-## Dependencies
+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,
+helping to manage issues, etc.
 
-Hugo stands on the shoulders of great open source libraries. Run `hugo env --logLevel info` to display a list of dependencies.
+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.
 
-<details>
+### Asking Support Questions
-<summary>See current dependencies</summary>
 
-```text
+We have an active [discussion forum](https://discourse.gohugo.io) where users and developers can ask questions.
-github.com/BurntSushi/locker="v0.0.0-20171006230638-a6e239ea1c69"
+Please don't use the GitHub issue tracker to ask questions.
-github.com/PuerkitoBio/goquery="v1.10.1"
+
-github.com/alecthomas/chroma/v2="v2.15.0"
+### Reporting Issues
-github.com/andybalholm/cascadia="v1.3.3"
+
-github.com/armon/go-radix="v1.0.1-0.20221118154546-54df44f2176c"
+If you believe you have found a defect in Hugo or its documentation, use
-github.com/bep/clocks="v0.5.0"
+the GitHub issue tracker to report the problem to the Hugo maintainers.
-github.com/bep/debounce="v1.2.0"
+If you're not sure if it's a bug or not, start by asking in the [discussion forum](https://discourse.gohugo.io).
-github.com/bep/gitmap="v1.6.0"
+When reporting the issue, please provide the version of Hugo in use (`hugo version`).
-github.com/bep/goat="v0.5.0"
+
-github.com/bep/godartsass/v2="v2.3.2"
+### Submitting Patches
-github.com/bep/golibsass="v1.2.0"
+
-github.com/bep/gowebp="v0.3.0"
+The Hugo project welcomes all contributors and contributions regardless of skill or experience level.
-github.com/bep/imagemeta="v0.8.4"
+If you are interested in helping with the project, we will help you with your contribution.
-github.com/bep/lazycache="v0.7.0"
+Hugo is a very active project with many contributions happening daily.
-github.com/bep/logg="v0.4.0"
+
-github.com/bep/mclib="v1.20400.20402"
+Because we want to create the best possible product for our users and the best contribution experience for our developers,
-github.com/bep/overlayfs="v0.9.2"
+we have a set of guidelines which ensure that all contributions are acceptable.
-github.com/bep/simplecobra="v0.5.0"
+The guidelines are not intended as a filter or barrier to participation.
-github.com/bep/tmc="v0.5.1"
+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.
-github.com/cespare/xxhash/v2="v2.3.0"
+
-github.com/clbanning/mxj/v2="v2.7.0"
+For a complete guide to contributing code to Hugo, see the [Contribution Guide](CONTRIBUTING.md).
-github.com/cpuguy83/go-md2man/v2="v2.0.4"
+
-github.com/disintegration/gift="v1.2.1"
+[![Analytics](https://ga-beacon.appspot.com/UA-7131036-6/hugo/readme)](https://github.com/igrigorik/ga-beacon)
-github.com/dlclark/regexp2="v1.11.5"
+
-github.com/dop251/goja="v0.0.0-20250125213203-5ef83b82af17"
+[Go]: https://golang.org/
-github.com/evanw/esbuild="v0.24.2"
+[Hugo Documentation]: https://gohugo.io/overview/introduction/
-github.com/fatih/color="v1.18.0"
-github.com/frankban/quicktest="v1.14.6"
-github.com/fsnotify/fsnotify="v1.8.0"
-github.com/getkin/kin-openapi="v0.129.0"
-github.com/ghodss/yaml="v1.0.0"
-github.com/go-openapi/jsonpointer="v0.21.0"
-github.com/go-openapi/swag="v0.23.0"
-github.com/go-sourcemap/sourcemap="v2.1.4+incompatible"
-github.com/gobuffalo/flect="v1.0.3"
-github.com/gobwas/glob="v0.2.3"
-github.com/gohugoio/go-i18n/v2="v2.1.3-0.20230805085216-e63c13218d0e"
-github.com/gohugoio/hashstructure="v0.5.0"
-github.com/gohugoio/httpcache="v0.7.0"
-github.com/gohugoio/hugo-goldmark-extensions/extras="v0.2.0"
-github.com/gohugoio/hugo-goldmark-extensions/passthrough="v0.3.0"
-github.com/gohugoio/locales="v0.14.0"
-github.com/gohugoio/localescompressed="v1.0.1"
-github.com/golang/freetype="v0.0.0-20170609003504-e2365dfdc4a0"
-github.com/google/go-cmp="v0.6.0"
-github.com/google/pprof="v0.0.0-20250208200701-d0013a598941"
-github.com/gorilla/websocket="v1.5.3"
-github.com/hairyhenderson/go-codeowners="v0.7.0"
-github.com/hashicorp/golang-lru/v2="v2.0.7"
-github.com/jdkato/prose="v1.2.1"
-github.com/josharian/intern="v1.0.0"
-github.com/kr/pretty="v0.3.1"
-github.com/kr/text="v0.2.0"
-github.com/kyokomi/emoji/v2="v2.2.13"
-github.com/lucasb-eyer/go-colorful="v1.2.0"
-github.com/mailru/easyjson="v0.7.7"
-github.com/makeworld-the-better-one/dither/v2="v2.4.0"
-github.com/marekm4/color-extractor="v1.2.1"
-github.com/mattn/go-colorable="v0.1.13"
-github.com/mattn/go-isatty="v0.0.20"
-github.com/mattn/go-runewidth="v0.0.9"
-github.com/mazznoer/csscolorparser="v0.1.5"
-github.com/mitchellh/mapstructure="v1.5.1-0.20231216201459-8508981c8b6c"
-github.com/mohae/deepcopy="v0.0.0-20170929034955-c48cc78d4826"
-github.com/muesli/smartcrop="v0.3.0"
-github.com/niklasfasching/go-org="v1.7.0"
-github.com/oasdiff/yaml3="v0.0.0-20241210130736-a94c01f36349"
-github.com/oasdiff/yaml="v0.0.0-20241210131133-6b86fb107d80"
-github.com/olekukonko/tablewriter="v0.0.5"
-github.com/pbnjay/memory="v0.0.0-20210728143218-7b4eea64cf58"
-github.com/pelletier/go-toml/v2="v2.2.3"
-github.com/perimeterx/marshmallow="v1.1.5"
-github.com/pkg/browser="v0.0.0-20240102092130-5ac0b6a4141c"
-github.com/pkg/errors="v0.9.1"
-github.com/rivo/uniseg="v0.4.7"
-github.com/rogpeppe/go-internal="v1.13.1"
-github.com/russross/blackfriday/v2="v2.1.0"
-github.com/sass/libsass="3.6.6"
-github.com/spf13/afero="v1.11.0"
-github.com/spf13/cast="v1.7.1"
-github.com/spf13/cobra="v1.8.1"
-github.com/spf13/fsync="v0.10.1"
-github.com/spf13/pflag="v1.0.6"
-github.com/tdewolff/minify/v2="v2.20.37"
-github.com/tdewolff/parse/v2="v2.7.15"
-github.com/tetratelabs/wazero="v1.8.2"
-github.com/webmproject/libwebp="v1.3.2"
-github.com/yuin/goldmark-emoji="v1.0.4"
-github.com/yuin/goldmark="v1.7.8"
-go.uber.org/automaxprocs="v1.5.3"
-golang.org/x/crypto="v0.33.0"
-golang.org/x/exp="v0.0.0-20250210185358-939b2ce775ac"
-golang.org/x/image="v0.24.0"
-golang.org/x/mod="v0.23.0"
-golang.org/x/net="v0.35.0"
-golang.org/x/sync="v0.11.0"
-golang.org/x/sys="v0.30.0"
-golang.org/x/text="v0.22.0"
-golang.org/x/tools="v0.30.0"
-golang.org/x/xerrors="v0.0.0-20240903120638-7835f813f4da"
-gonum.org/v1/plot="v0.15.0"
-google.golang.org/protobuf="v1.36.5"
-gopkg.in/yaml.v2="v2.4.0"
-gopkg.in/yaml.v3="v3.0.1"
-oss.terrastruct.com/d2="v0.6.9"
-oss.terrastruct.com/util-go="v0.0.0-20241005222610-44c011a04896"
-rsc.io/qr="v0.2.0"
-software.sslmate.com/src/go-pkcs12="v0.2.0"
-```
-</details>

SECURITY.md

@@ -1,7 +0,0 @@
-## Security Policy
-
-### Reporting a Vulnerability
-
-Please report (suspected) security vulnerabilities to **[bjorn.erik.pedersen@gmail.com](mailto:bjorn.erik.pedersen@gmail.com)**. You will receive a response from us within 48 hours. If we can confirm the issue, we will release a patch as soon as possible depending on the complexity of the issue but historically within days.
-
-Also see [Hugo's Security Model](https://gohugo.io/about/security/).

appveyor.yml

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

bench.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+# allow user to override go executable by running as GOEXE=xxx make ...
+GOEXE="${GOEXE-go}"
+
+# Convenience script to
+# - For a given branch
+# - Run  benchmark tests for a given package
+# - Do the same for master
+# - then compare the two runs with benchcmp
+
+benchFilter=".*"
+
+if (( $# < 2 ));
+  then
+    echo "USAGE: ./bench.sh <git-branch> <package-to-bench> (and <benchmark filter> (regexp, optional))"
+    exit 1
+fi
+
+
+
+if [ $# -eq 3 ]; then
+  benchFilter=$3
+fi
+
+
+BRANCH=$1
+PACKAGE=$2
+
+git checkout $BRANCH
+"${GOEXE}" test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-$BRANCH.txt
+
+git checkout master
+"${GOEXE}" test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-master.txt
+
+
+benchcmp /tmp/bench-$PACKAGE-master.txt /tmp/bench-$PACKAGE-$BRANCH.txt

benchSite.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# allow user to override go executable by running as GOEXE=xxx make ...
+GOEXE="${GOEXE-go}"
+
+# Send in a regexp mathing the benchmarks you want to run, i.e. './benchSite.sh "YAML"'. 
+# Note the quotes, which will be needed for more complex expressions.
+# The above will run all variations, but only for front matter YAML.
+
+echo "Running with BenchmarkSiteBuilding/${1}"
+
+"${GOEXE}" test -run="NONE" -bench="BenchmarkSiteBuilding/${1}" -test.benchmem=true ./hugolib -memprofile mem.prof -count 3 -cpuprofile cpu.prof

bepdock.sh

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

bufferpool/bufpool.go

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

bufferpool/bufpool_test.go

@@ -14,18 +14,14 @@
 package bufferpool
 
 import (
+	"github.com/stretchr/testify/assert"
 	"testing"
-
-	qt "github.com/frankban/quicktest"
 )
 
 func TestBufferPool(t *testing.T) {
-	c := qt.New(t)
-
 	buff := GetBuffer()
 	buff.WriteString("do be do be do")
-	c.Assert(buff.String(), qt.Equals, "do be do be do")
+	assert.Equal(t, "do be do be do", buff.String())
 	PutBuffer(buff)
-
+	assert.Equal(t, 0, buff.Len())
-	c.Assert(buff.Len(), qt.Equals, 0)
 }

cache/docs.go

@@ -1,2 +0,0 @@
-// Package cache contains the different cache implementations.
-package cache

cache/dynacache/dynacache.go

@@ -1,647 +0,0 @@
-// Copyright 2024 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 dynacache
-
-import (
-	"context"
-	"fmt"
-	"math"
-	"path"
-	"regexp"
-	"runtime"
-	"sync"
-	"time"
-
-	"github.com/bep/lazycache"
-	"github.com/bep/logg"
-	"github.com/gohugoio/hugo/common/collections"
-	"github.com/gohugoio/hugo/common/herrors"
-	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/paths"
-	"github.com/gohugoio/hugo/common/rungroup"
-	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/identity"
-	"github.com/gohugoio/hugo/resources/resource"
-)
-
-const minMaxSize = 10
-
-type KeyIdentity struct {
-	Key      any
-	Identity identity.Identity
-}
-
-// New creates a new cache.
-func New(opts Options) *Cache {
-	if opts.CheckInterval == 0 {
-		opts.CheckInterval = time.Second * 2
-	}
-
-	if opts.MaxSize == 0 {
-		opts.MaxSize = 100000
-	}
-	if opts.Log == nil {
-		panic("nil Log")
-	}
-
-	if opts.MinMaxSize == 0 {
-		opts.MinMaxSize = 30
-	}
-
-	stats := &stats{
-		opts:             opts,
-		adjustmentFactor: 1.0,
-		currentMaxSize:   opts.MaxSize,
-		availableMemory:  config.GetMemoryLimit(),
-	}
-
-	infol := opts.Log.InfoCommand("dynacache")
-
-	evictedIdentities := collections.NewStack[KeyIdentity]()
-
-	onEvict := func(k, v any) {
-		if !opts.Watching {
-			return
-		}
-		identity.WalkIdentitiesShallow(v, func(level int, id identity.Identity) bool {
-			evictedIdentities.Push(KeyIdentity{Key: k, Identity: id})
-			return false
-		})
-		resource.MarkStale(v)
-	}
-
-	c := &Cache{
-		partitions:        make(map[string]PartitionManager),
-		onEvict:           onEvict,
-		evictedIdentities: evictedIdentities,
-		opts:              opts,
-		stats:             stats,
-		infol:             infol,
-	}
-
-	c.stop = c.start()
-
-	return c
-}
-
-// Options for the cache.
-type Options struct {
-	Log           loggers.Logger
-	CheckInterval time.Duration
-	MaxSize       int
-	MinMaxSize    int
-	Watching      bool
-}
-
-// Options for a partition.
-type OptionsPartition struct {
-	// When to clear the this partition.
-	ClearWhen ClearWhen
-
-	// Weight is a number between 1 and 100 that indicates how, in general, how big this partition may get.
-	Weight int
-}
-
-func (o OptionsPartition) WeightFraction() float64 {
-	return float64(o.Weight) / 100
-}
-
-func (o OptionsPartition) CalculateMaxSize(maxSizePerPartition int) int {
-	return int(math.Floor(float64(maxSizePerPartition) * o.WeightFraction()))
-}
-
-// A dynamic partitioned cache.
-type Cache struct {
-	mu sync.RWMutex
-
-	partitions map[string]PartitionManager
-
-	onEvict           func(k, v any)
-	evictedIdentities *collections.Stack[KeyIdentity]
-
-	opts  Options
-	infol logg.LevelLogger
-
-	stats    *stats
-	stopOnce sync.Once
-	stop     func()
-}
-
-// DrainEvictedIdentities drains the evicted identities from the cache.
-func (c *Cache) DrainEvictedIdentities() []KeyIdentity {
-	return c.evictedIdentities.Drain()
-}
-
-// DrainEvictedIdentitiesMatching drains the evicted identities from the cache that match the given predicate.
-func (c *Cache) DrainEvictedIdentitiesMatching(predicate func(KeyIdentity) bool) []KeyIdentity {
-	return c.evictedIdentities.DrainMatching(predicate)
-}
-
-// ClearMatching clears all partition for which the predicate returns true.
-func (c *Cache) ClearMatching(predicatePartition func(k string, p PartitionManager) bool, predicateValue func(k, v any) bool) {
-	if predicatePartition == nil {
-		predicatePartition = func(k string, p PartitionManager) bool { return true }
-	}
-	if predicateValue == nil {
-		panic("nil predicateValue")
-	}
-	g := rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
-		NumWorkers: len(c.partitions),
-		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearMatching(predicateValue)
-			return nil
-		},
-	})
-
-	for k, p := range c.partitions {
-		if !predicatePartition(k, p) {
-			continue
-		}
-		g.Enqueue(p)
-	}
-
-	g.Wait()
-}
-
-// ClearOnRebuild prepares the cache for a new rebuild taking the given changeset into account.
-// predicate is optional and will clear any entry for which it returns true.
-func (c *Cache) ClearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity) {
-	g := rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
-		NumWorkers: len(c.partitions),
-		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearOnRebuild(predicate, changeset...)
-			return nil
-		},
-	})
-
-	for _, p := range c.partitions {
-		g.Enqueue(p)
-	}
-
-	g.Wait()
-
-	// Clear any entries marked as stale above.
-	g = rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
-		NumWorkers: len(c.partitions),
-		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearStale()
-			return nil
-		},
-	})
-
-	for _, p := range c.partitions {
-		g.Enqueue(p)
-	}
-
-	g.Wait()
-}
-
-type keysProvider interface {
-	Keys() []string
-}
-
-// Keys returns a list of keys in all partitions.
-func (c *Cache) Keys(predicate func(s string) bool) []string {
-	if predicate == nil {
-		predicate = func(s string) bool { return true }
-	}
-	var keys []string
-	for pn, g := range c.partitions {
-		pkeys := g.(keysProvider).Keys()
-		for _, k := range pkeys {
-			p := path.Join(pn, k)
-			if predicate(p) {
-				keys = append(keys, p)
-			}
-		}
-
-	}
-	return keys
-}
-
-func calculateMaxSizePerPartition(maxItemsTotal, totalWeightQuantity, numPartitions int) int {
-	if numPartitions == 0 {
-		panic("numPartitions must be > 0")
-	}
-	if totalWeightQuantity == 0 {
-		panic("totalWeightQuantity must be > 0")
-	}
-
-	avgWeight := float64(totalWeightQuantity) / float64(numPartitions)
-	return int(math.Floor(float64(maxItemsTotal) / float64(numPartitions) * (100.0 / avgWeight)))
-}
-
-// Stop stops the cache.
-func (c *Cache) Stop() {
-	c.stopOnce.Do(func() {
-		c.stop()
-	})
-}
-
-func (c *Cache) adjustCurrentMaxSize() {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	if len(c.partitions) == 0 {
-		return
-	}
-	var m runtime.MemStats
-	runtime.ReadMemStats(&m)
-	s := c.stats
-	s.memstatsCurrent = m
-	// fmt.Printf("\n\nAvailable = %v\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\nMaxSize = %d\nAdjustmentFactor=%f\n\n", helpers.FormatByteCount(s.availableMemory), helpers.FormatByteCount(m.Alloc), helpers.FormatByteCount(m.TotalAlloc), helpers.FormatByteCount(m.Sys), m.NumGC, c.stats.currentMaxSize, s.adjustmentFactor)
-
-	if s.availableMemory >= s.memstatsCurrent.Alloc {
-		if s.adjustmentFactor <= 1.0 {
-			s.adjustmentFactor += 0.2
-		}
-	} else {
-		// We're low on memory.
-		s.adjustmentFactor -= 0.4
-	}
-
-	if s.adjustmentFactor <= 0 {
-		s.adjustmentFactor = 0.05
-	}
-
-	if !s.adjustCurrentMaxSize() {
-		return
-	}
-
-	totalWeight := 0
-	for _, pm := range c.partitions {
-		totalWeight += pm.getOptions().Weight
-	}
-
-	maxSizePerPartition := calculateMaxSizePerPartition(c.stats.currentMaxSize, totalWeight, len(c.partitions))
-
-	evicted := 0
-	for _, p := range c.partitions {
-		evicted += p.adjustMaxSize(p.getOptions().CalculateMaxSize(maxSizePerPartition))
-	}
-
-	if evicted > 0 {
-		c.infol.
-			WithFields(
-				logg.Fields{
-					{Name: "evicted", Value: evicted},
-					{Name: "numGC", Value: m.NumGC},
-					{Name: "limit", Value: helpers.FormatByteCount(c.stats.availableMemory)},
-					{Name: "alloc", Value: helpers.FormatByteCount(m.Alloc)},
-					{Name: "totalAlloc", Value: helpers.FormatByteCount(m.TotalAlloc)},
-				},
-			).Logf("adjusted partitions' max size")
-	}
-}
-
-func (c *Cache) start() func() {
-	ticker := time.NewTicker(c.opts.CheckInterval)
-	quit := make(chan struct{})
-
-	go func() {
-		for {
-			select {
-			case <-ticker.C:
-				c.adjustCurrentMaxSize()
-				// Reset the ticker to avoid drift.
-				ticker.Reset(c.opts.CheckInterval)
-			case <-quit:
-				ticker.Stop()
-				return
-			}
-		}
-	}()
-
-	return func() {
-		close(quit)
-	}
-}
-
-var partitionNameRe = regexp.MustCompile(`^\/[a-zA-Z0-9]{4}(\/[a-zA-Z0-9]+)?(\/[a-zA-Z0-9]+)?`)
-
-// GetOrCreatePartition gets or creates a partition with the given name.
-func GetOrCreatePartition[K comparable, V any](c *Cache, name string, opts OptionsPartition) *Partition[K, V] {
-	if c == nil {
-		panic("nil Cache")
-	}
-	if opts.Weight < 1 || opts.Weight > 100 {
-		panic("invalid Weight, must be between 1 and 100")
-	}
-
-	if partitionNameRe.FindString(name) != name {
-		panic(fmt.Sprintf("invalid partition name %q", name))
-	}
-
-	c.mu.RLock()
-	p, found := c.partitions[name]
-	c.mu.RUnlock()
-	if found {
-		return p.(*Partition[K, V])
-	}
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	// Double check.
-	p, found = c.partitions[name]
-	if found {
-		return p.(*Partition[K, V])
-	}
-
-	// At this point, we don't know the number of partitions or their configuration, but
-	// this will be re-adjusted later.
-	const numberOfPartitionsEstimate = 10
-	maxSize := opts.CalculateMaxSize(c.opts.MaxSize / numberOfPartitionsEstimate)
-
-	onEvict := func(k K, v V) {
-		c.onEvict(k, v)
-	}
-
-	// Create a new partition and cache it.
-	partition := &Partition[K, V]{
-		c:       lazycache.New(lazycache.Options[K, V]{MaxEntries: maxSize, OnEvict: onEvict}),
-		maxSize: maxSize,
-		trace:   c.opts.Log.Logger().WithLevel(logg.LevelTrace).WithField("partition", name),
-		opts:    opts,
-	}
-
-	c.partitions[name] = partition
-
-	return partition
-}
-
-// Partition is a partition in the cache.
-type Partition[K comparable, V any] struct {
-	c *lazycache.Cache[K, V]
-
-	zero V
-
-	trace logg.LevelLogger
-	opts  OptionsPartition
-
-	maxSize int
-}
-
-// GetOrCreate gets or creates a value for the given key.
-func (p *Partition[K, V]) GetOrCreate(key K, create func(key K) (V, error)) (V, error) {
-	v, err := p.doGetOrCreate(key, create)
-	if err != nil {
-		return p.zero, err
-	}
-	if resource.StaleVersion(v) > 0 {
-		p.c.Delete(key)
-		return p.doGetOrCreate(key, create)
-	}
-	return v, err
-}
-
-func (p *Partition[K, V]) doGetOrCreate(key K, create func(key K) (V, error)) (V, error) {
-	v, _, err := p.c.GetOrCreate(key, create)
-	return v, err
-}
-
-func (p *Partition[K, V]) GetOrCreateWitTimeout(key K, duration time.Duration, create func(key K) (V, error)) (V, error) {
-	v, err := p.doGetOrCreateWitTimeout(key, duration, create)
-	if err != nil {
-		return p.zero, err
-	}
-	if resource.StaleVersion(v) > 0 {
-		p.c.Delete(key)
-		return p.doGetOrCreateWitTimeout(key, duration, create)
-	}
-	return v, err
-}
-
-// GetOrCreateWitTimeout gets or creates a value for the given key and times out if the create function
-// takes too long.
-func (p *Partition[K, V]) doGetOrCreateWitTimeout(key K, duration time.Duration, create func(key K) (V, error)) (V, error) {
-	resultch := make(chan V, 1)
-	errch := make(chan error, 1)
-
-	go func() {
-		var (
-			v   V
-			err error
-		)
-		defer func() {
-			if r := recover(); r != nil {
-				if rerr, ok := r.(error); ok {
-					err = rerr
-				} else {
-					err = fmt.Errorf("panic: %v", r)
-				}
-			}
-			if err != nil {
-				errch <- err
-			} else {
-				resultch <- v
-			}
-		}()
-		v, _, err = p.c.GetOrCreate(key, create)
-	}()
-
-	select {
-	case v := <-resultch:
-		return v, nil
-	case err := <-errch:
-		return p.zero, err
-	case <-time.After(duration):
-		return p.zero, &herrors.TimeoutError{
-			Duration: duration,
-		}
-	}
-}
-
-func (p *Partition[K, V]) clearMatching(predicate func(k, v any) bool) {
-	p.c.DeleteFunc(func(key K, v V) bool {
-		if predicate(key, v) {
-			p.trace.Log(
-				logg.StringFunc(
-					func() string {
-						return fmt.Sprintf("clearing cache key %v", key)
-					},
-				),
-			)
-			return true
-		}
-		return false
-	})
-}
-
-func (p *Partition[K, V]) clearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity) {
-	if predicate == nil {
-		predicate = func(k, v any) bool {
-			return false
-		}
-	}
-	opts := p.getOptions()
-	if opts.ClearWhen == ClearNever {
-		return
-	}
-
-	if opts.ClearWhen == ClearOnRebuild {
-		// Clear all.
-		p.Clear()
-		return
-	}
-
-	depsFinder := identity.NewFinder(identity.FinderConfig{})
-
-	shouldDelete := func(key K, v V) bool {
-		// We always clear elements marked as stale.
-		if resource.StaleVersion(v) > 0 {
-			return true
-		}
-
-		// Now check if this entry has changed based on the changeset
-		// based on filesystem events.
-		if len(changeset) == 0 {
-			// Nothing changed.
-			return false
-		}
-
-		var probablyDependent bool
-		identity.WalkIdentitiesShallow(v, func(level int, id2 identity.Identity) bool {
-			for _, id := range changeset {
-				if r := depsFinder.Contains(id, id2, -1); r > 0 {
-					// It's probably dependent, evict from cache.
-					probablyDependent = true
-					return true
-				}
-			}
-			return false
-		})
-
-		return probablyDependent
-	}
-
-	// First pass.
-	// Second pass needs to be done in a separate loop to catch any
-	// elements marked as stale in the other partitions.
-	p.c.DeleteFunc(func(key K, v V) bool {
-		if predicate(key, v) || shouldDelete(key, v) {
-			p.trace.Log(
-				logg.StringFunc(
-					func() string {
-						return fmt.Sprintf("first pass: clearing cache key %v", key)
-					},
-				),
-			)
-			return true
-		}
-		return false
-	})
-}
-
-func (p *Partition[K, V]) Keys() []K {
-	var keys []K
-	p.c.DeleteFunc(func(key K, v V) bool {
-		keys = append(keys, key)
-		return false
-	})
-	return keys
-}
-
-func (p *Partition[K, V]) clearStale() {
-	p.c.DeleteFunc(func(key K, v V) bool {
-		staleVersion := resource.StaleVersion(v)
-		if staleVersion > 0 {
-			p.trace.Log(
-				logg.StringFunc(
-					func() string {
-						return fmt.Sprintf("second pass: clearing cache key %v", key)
-					},
-				),
-			)
-		}
-
-		return staleVersion > 0
-	})
-}
-
-// adjustMaxSize adjusts the max size of the and returns the number of items evicted.
-func (p *Partition[K, V]) adjustMaxSize(newMaxSize int) int {
-	if newMaxSize < minMaxSize {
-		newMaxSize = minMaxSize
-	}
-	oldMaxSize := p.maxSize
-	if newMaxSize == oldMaxSize {
-		return 0
-	}
-	p.maxSize = newMaxSize
-	// fmt.Println("Adjusting max size of partition from", oldMaxSize, "to", newMaxSize)
-	return p.c.Resize(newMaxSize)
-}
-
-func (p *Partition[K, V]) getMaxSize() int {
-	return p.maxSize
-}
-
-func (p *Partition[K, V]) getOptions() OptionsPartition {
-	return p.opts
-}
-
-func (p *Partition[K, V]) Clear() {
-	p.c.DeleteFunc(func(key K, v V) bool {
-		return true
-	})
-}
-
-func (p *Partition[K, V]) Get(ctx context.Context, key K) (V, bool) {
-	return p.c.Get(key)
-}
-
-type PartitionManager interface {
-	adjustMaxSize(addend int) int
-	getMaxSize() int
-	getOptions() OptionsPartition
-	clearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity)
-	clearMatching(predicate func(k, v any) bool)
-	clearStale()
-}
-
-const (
-	ClearOnRebuild ClearWhen = iota + 1
-	ClearOnChange
-	ClearNever
-)
-
-type ClearWhen int
-
-type stats struct {
-	opts            Options
-	memstatsCurrent runtime.MemStats
-	currentMaxSize  int
-	availableMemory uint64
-
-	adjustmentFactor float64
-}
-
-func (s *stats) adjustCurrentMaxSize() bool {
-	newCurrentMaxSize := int(math.Floor(float64(s.opts.MaxSize) * s.adjustmentFactor))
-
-	if newCurrentMaxSize < s.opts.MinMaxSize {
-		newCurrentMaxSize = int(s.opts.MinMaxSize)
-	}
-	changed := newCurrentMaxSize != s.currentMaxSize
-	s.currentMaxSize = newCurrentMaxSize
-	return changed
-}
-
-// CleanKey turns s into a format suitable for a cache key for this package.
-// The key will be a Unix-styled path with a leading slash but no trailing slash.
-func CleanKey(s string) string {
-	return path.Clean(paths.ToSlashPreserveLeading(s))
-}

cache/dynacache/dynacache_test.go

@@ -1,230 +0,0 @@
-// Copyright 2024 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 dynacache
-
-import (
-	"errors"
-	"fmt"
-	"path/filepath"
-	"testing"
-	"time"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/identity"
-	"github.com/gohugoio/hugo/resources/resource"
-)
-
-var (
-	_ resource.StaleInfo = (*testItem)(nil)
-	_ identity.Identity  = (*testItem)(nil)
-)
-
-type testItem struct {
-	name         string
-	staleVersion uint32
-}
-
-func (t testItem) StaleVersion() uint32 {
-	return t.staleVersion
-}
-
-func (t testItem) IdentifierBase() string {
-	return t.name
-}
-
-func TestCache(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	cache := New(Options{
-		Log: loggers.NewDefault(),
-	})
-
-	c.Cleanup(func() {
-		cache.Stop()
-	})
-
-	opts := OptionsPartition{Weight: 30}
-
-	c.Assert(cache, qt.Not(qt.IsNil))
-
-	p1 := GetOrCreatePartition[string, testItem](cache, "/aaaa/bbbb", opts)
-	c.Assert(p1, qt.Not(qt.IsNil))
-
-	p2 := GetOrCreatePartition[string, testItem](cache, "/aaaa/bbbb", opts)
-
-	c.Assert(func() { GetOrCreatePartition[string, testItem](cache, "foo bar", opts) }, qt.PanicMatches, ".*invalid partition name.*")
-	c.Assert(func() { GetOrCreatePartition[string, testItem](cache, "/aaaa/cccc", OptionsPartition{Weight: 1234}) }, qt.PanicMatches, ".*invalid Weight.*")
-
-	c.Assert(p2, qt.Equals, p1)
-
-	p3 := GetOrCreatePartition[string, testItem](cache, "/aaaa/cccc", opts)
-	c.Assert(p3, qt.Not(qt.IsNil))
-	c.Assert(p3, qt.Not(qt.Equals), p1)
-
-	c.Assert(func() { New(Options{}) }, qt.PanicMatches, ".*nil Log.*")
-}
-
-func TestCalculateMaxSizePerPartition(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	c.Assert(calculateMaxSizePerPartition(1000, 500, 5), qt.Equals, 200)
-	c.Assert(calculateMaxSizePerPartition(1000, 250, 5), qt.Equals, 400)
-	c.Assert(func() { calculateMaxSizePerPartition(1000, 250, 0) }, qt.PanicMatches, ".*must be > 0.*")
-	c.Assert(func() { calculateMaxSizePerPartition(1000, 0, 1) }, qt.PanicMatches, ".*must be > 0.*")
-}
-
-func TestCleanKey(t *testing.T) {
-	c := qt.New(t)
-
-	c.Assert(CleanKey("a/b/c"), qt.Equals, "/a/b/c")
-	c.Assert(CleanKey("/a/b/c"), qt.Equals, "/a/b/c")
-	c.Assert(CleanKey("a/b/c/"), qt.Equals, "/a/b/c")
-	c.Assert(CleanKey(filepath.FromSlash("/a/b/c/")), qt.Equals, "/a/b/c")
-}
-
-func newTestCache(t *testing.T) *Cache {
-	cache := New(
-		Options{
-			Log: loggers.NewDefault(),
-		},
-	)
-
-	p1 := GetOrCreatePartition[string, testItem](cache, "/aaaa/bbbb", OptionsPartition{Weight: 30, ClearWhen: ClearOnRebuild})
-	p2 := GetOrCreatePartition[string, testItem](cache, "/aaaa/cccc", OptionsPartition{Weight: 30, ClearWhen: ClearOnChange})
-
-	p1.GetOrCreate("clearOnRebuild", func(string) (testItem, error) {
-		return testItem{}, nil
-	})
-
-	p2.GetOrCreate("clearBecauseStale", func(string) (testItem, error) {
-		return testItem{
-			staleVersion: 32,
-		}, nil
-	})
-
-	p2.GetOrCreate("clearBecauseIdentityChanged", func(string) (testItem, error) {
-		return testItem{
-			name: "changed",
-		}, nil
-	})
-
-	p2.GetOrCreate("clearNever", func(string) (testItem, error) {
-		return testItem{
-			staleVersion: 0,
-		}, nil
-	})
-
-	t.Cleanup(func() {
-		cache.Stop()
-	})
-
-	return cache
-}
-
-func TestClear(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	predicateAll := func(string) bool {
-		return true
-	}
-
-	cache := newTestCache(t)
-
-	c.Assert(cache.Keys(predicateAll), qt.HasLen, 4)
-
-	cache.ClearOnRebuild(nil)
-
-	// Stale items are always cleared.
-	c.Assert(cache.Keys(predicateAll), qt.HasLen, 2)
-
-	cache = newTestCache(t)
-	cache.ClearOnRebuild(nil, identity.StringIdentity("changed"))
-
-	c.Assert(cache.Keys(nil), qt.HasLen, 1)
-
-	cache = newTestCache(t)
-
-	cache.ClearMatching(nil, func(k, v any) bool {
-		return k.(string) == "clearOnRebuild"
-	})
-
-	c.Assert(cache.Keys(predicateAll), qt.HasLen, 3)
-
-	cache.adjustCurrentMaxSize()
-}
-
-func TestPanicInCreate(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-	cache := newTestCache(t)
-
-	p1 := GetOrCreatePartition[string, testItem](cache, "/aaaa/bbbb", OptionsPartition{Weight: 30, ClearWhen: ClearOnRebuild})
-
-	willPanic := func(i int) func() {
-		return func() {
-			p1.GetOrCreate(fmt.Sprintf("panic-%d", i), func(key string) (testItem, error) {
-				panic(errors.New(key))
-			})
-		}
-	}
-
-	// GetOrCreateWitTimeout needs to recover from panics in the create func.
-	willErr := func(i int) error {
-		_, err := p1.GetOrCreateWitTimeout(fmt.Sprintf("error-%d", i), 10*time.Second, func(key string) (testItem, error) {
-			return testItem{}, errors.New(key)
-		})
-		return err
-	}
-
-	for i := range 3 {
-		for range 3 {
-			c.Assert(willPanic(i), qt.PanicMatches, fmt.Sprintf("panic-%d", i))
-			c.Assert(willErr(i), qt.ErrorMatches, fmt.Sprintf("error-%d", i))
-		}
-	}
-
-	// Test the same keys again without the panic.
-	for i := range 3 {
-		for range 3 {
-			v, err := p1.GetOrCreate(fmt.Sprintf("panic-%d", i), func(key string) (testItem, error) {
-				return testItem{
-					name: key,
-				}, nil
-			})
-			c.Assert(err, qt.IsNil)
-			c.Assert(v.name, qt.Equals, fmt.Sprintf("panic-%d", i))
-
-			v, err = p1.GetOrCreateWitTimeout(fmt.Sprintf("error-%d", i), 10*time.Second, func(key string) (testItem, error) {
-				return testItem{
-					name: key,
-				}, nil
-			})
-			c.Assert(err, qt.IsNil)
-			c.Assert(v.name, qt.Equals, fmt.Sprintf("error-%d", i))
-		}
-	}
-}
-
-func TestAdjustCurrentMaxSize(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-	cache := newTestCache(t)
-	alloc := cache.stats.memstatsCurrent.Alloc
-	cache.adjustCurrentMaxSize()
-	c.Assert(cache.stats.memstatsCurrent.Alloc, qt.Not(qt.Equals), alloc)
-}

cache/filecache/filecache.go

@@ -1,496 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package filecache
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/gohugoio/httpcache"
-	"github.com/gohugoio/hugo/common/hugio"
-	"github.com/gohugoio/hugo/hugofs"
-
-	"github.com/gohugoio/hugo/helpers"
-
-	"github.com/BurntSushi/locker"
-	"github.com/spf13/afero"
-)
-
-// ErrFatal can be used to signal an unrecoverable error.
-var ErrFatal = errors.New("fatal filecache error")
-
-const (
-	FilecacheRootDirname = "filecache"
-)
-
-// Cache caches a set of files in a directory. This is usually a file on
-// disk, but since this is backed by an Afero file system, it can be anything.
-type Cache struct {
-	Fs afero.Fs
-
-	// Max age for items in this cache. Negative duration means forever,
-	// 0 is effectively turning this cache off.
-	maxAge time.Duration
-
-	// When set, we just remove this entire root directory on expiration.
-	pruneAllRootDir string
-
-	nlocker *lockTracker
-
-	initOnce sync.Once
-	initErr  error
-}
-
-type lockTracker struct {
-	seenMu sync.RWMutex
-	seen   map[string]struct{}
-
-	*locker.Locker
-}
-
-// Lock tracks the ids in use. We use this information to do garbage collection
-// after a Hugo build.
-func (l *lockTracker) Lock(id string) {
-	l.seenMu.RLock()
-	if _, seen := l.seen[id]; !seen {
-		l.seenMu.RUnlock()
-		l.seenMu.Lock()
-		l.seen[id] = struct{}{}
-		l.seenMu.Unlock()
-	} else {
-		l.seenMu.RUnlock()
-	}
-
-	l.Locker.Lock(id)
-}
-
-// ItemInfo contains info about a cached file.
-type ItemInfo struct {
-	// This is the file's name relative to the cache's filesystem.
-	Name string
-}
-
-// NewCache creates a new file cache with the given filesystem and max age.
-func NewCache(fs afero.Fs, maxAge time.Duration, pruneAllRootDir string) *Cache {
-	return &Cache{
-		Fs:              fs,
-		nlocker:         &lockTracker{Locker: locker.NewLocker(), seen: make(map[string]struct{})},
-		maxAge:          maxAge,
-		pruneAllRootDir: pruneAllRootDir,
-	}
-}
-
-// lockedFile is a file with a lock that is released on Close.
-type lockedFile struct {
-	afero.File
-	unlock func()
-}
-
-func (l *lockedFile) Close() error {
-	defer l.unlock()
-	return l.File.Close()
-}
-
-func (c *Cache) init() error {
-	c.initOnce.Do(func() {
-		// Create the base dir if it does not exist.
-		if err := c.Fs.MkdirAll("", 0o777); err != nil && !os.IsExist(err) {
-			c.initErr = err
-		}
-	})
-	return c.initErr
-}
-
-// WriteCloser returns a transactional writer into the cache.
-// It's important that it's closed when done.
-func (c *Cache) WriteCloser(id string) (ItemInfo, io.WriteCloser, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
-
-	id = cleanID(id)
-	c.nlocker.Lock(id)
-
-	info := ItemInfo{Name: id}
-
-	f, err := helpers.OpenFileForWriting(c.Fs, id)
-	if err != nil {
-		c.nlocker.Unlock(id)
-		return info, nil, err
-	}
-
-	return info, &lockedFile{
-		File:   f,
-		unlock: func() { c.nlocker.Unlock(id) },
-	}, nil
-}
-
-// ReadOrCreate tries to lookup the file in cache.
-// If found, it is passed to read and then closed.
-// If not found a new file is created and passed to create, which should close
-// it when done.
-func (c *Cache) ReadOrCreate(id string,
-	read func(info ItemInfo, r io.ReadSeeker) error,
-	create func(info ItemInfo, w io.WriteCloser) error,
-) (info ItemInfo, err error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, err
-	}
-
-	id = cleanID(id)
-
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
-
-	info = ItemInfo{Name: id}
-
-	if r := c.getOrRemove(id); r != nil {
-		err = read(info, r)
-		defer r.Close()
-		if err == nil || err == ErrFatal {
-			// See https://github.com/gohugoio/hugo/issues/6401
-			// To recover from file corruption we handle read errors
-			// as the cache item was not found.
-			// Any file permission issue will also fail in the next step.
-			return
-		}
-	}
-
-	f, err := helpers.OpenFileForWriting(c.Fs, id)
-	if err != nil {
-		return
-	}
-
-	err = create(info, f)
-
-	return
-}
-
-// NamedLock locks the given id. The lock is released when the returned function is called.
-func (c *Cache) NamedLock(id string) func() {
-	id = cleanID(id)
-	c.nlocker.Lock(id)
-	return func() {
-		c.nlocker.Unlock(id)
-	}
-}
-
-// GetOrCreate tries to get the file with the given id from cache. If not found or expired, create will
-// be invoked and the result cached.
-// This method is protected by a named lock using the given id as identifier.
-func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (ItemInfo, io.ReadCloser, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
-	id = cleanID(id)
-
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
-
-	info := ItemInfo{Name: id}
-
-	if r := c.getOrRemove(id); r != nil {
-		return info, r, nil
-	}
-
-	var (
-		r   io.ReadCloser
-		err error
-	)
-
-	r, err = create()
-	if err != nil {
-		return info, nil, err
-	}
-
-	if c.maxAge == 0 {
-		// No caching.
-		return info, hugio.ToReadCloser(r), nil
-	}
-
-	var buff bytes.Buffer
-	return info,
-		hugio.ToReadCloser(&buff),
-		c.writeReader(id, io.TeeReader(r, &buff))
-}
-
-func (c *Cache) writeReader(id string, r io.Reader) error {
-	dir := filepath.Dir(id)
-	if dir != "" {
-		_ = c.Fs.MkdirAll(dir, 0o777)
-	}
-	f, err := c.Fs.Create(id)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	_, _ = io.Copy(f, r)
-
-	return nil
-}
-
-// GetOrCreateBytes is the same as GetOrCreate, but produces a byte slice.
-func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (ItemInfo, []byte, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
-	id = cleanID(id)
-
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
-
-	info := ItemInfo{Name: id}
-
-	if r := c.getOrRemove(id); r != nil {
-		defer r.Close()
-		b, err := io.ReadAll(r)
-		return info, b, err
-	}
-
-	var (
-		b   []byte
-		err error
-	)
-
-	b, err = create()
-	if err != nil {
-		return info, nil, err
-	}
-
-	if c.maxAge == 0 {
-		return info, b, nil
-	}
-
-	if err := c.writeReader(id, bytes.NewReader(b)); err != nil {
-		return info, nil, err
-	}
-
-	return info, b, nil
-}
-
-// GetBytes gets the file content with the given id from the cache, nil if none found.
-func (c *Cache) GetBytes(id string) (ItemInfo, []byte, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
-	id = cleanID(id)
-
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
-
-	info := ItemInfo{Name: id}
-
-	if r := c.getOrRemove(id); r != nil {
-		defer r.Close()
-		b, err := io.ReadAll(r)
-		return info, b, err
-	}
-
-	return info, nil, nil
-}
-
-// Get gets the file with the given id from the cache, nil if none found.
-func (c *Cache) Get(id string) (ItemInfo, io.ReadCloser, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
-	id = cleanID(id)
-
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
-
-	info := ItemInfo{Name: id}
-
-	r := c.getOrRemove(id)
-
-	return info, r, nil
-}
-
-// getOrRemove gets the file with the given id. If it's expired, it will
-// be removed.
-func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
-	if c.maxAge == 0 {
-		// No caching.
-		return nil
-	}
-
-	if removed, err := c.removeIfExpired(id); err != nil || removed {
-		return nil
-	}
-
-	f, err := c.Fs.Open(id)
-	if err != nil {
-		return nil
-	}
-
-	return f
-}
-
-func (c *Cache) getBytesAndRemoveIfExpired(id string) ([]byte, bool) {
-	if c.maxAge == 0 {
-		// No caching.
-		return nil, false
-	}
-
-	f, err := c.Fs.Open(id)
-	if err != nil {
-		return nil, false
-	}
-	defer f.Close()
-
-	b, err := io.ReadAll(f)
-	if err != nil {
-		return nil, false
-	}
-
-	removed, err := c.removeIfExpired(id)
-	if err != nil {
-		return nil, false
-	}
-
-	return b, removed
-}
-
-func (c *Cache) removeIfExpired(id string) (bool, error) {
-	if c.maxAge <= 0 {
-		return false, nil
-	}
-
-	fi, err := c.Fs.Stat(id)
-	if err != nil {
-		return false, err
-	}
-
-	if c.isExpired(fi.ModTime()) {
-		c.Fs.Remove(id)
-		return true, nil
-	}
-
-	return false, nil
-}
-
-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
-}
-
-// For testing
-func (c *Cache) GetString(id string) string {
-	id = cleanID(id)
-
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
-
-	f, err := c.Fs.Open(id)
-	if err != nil {
-		return ""
-	}
-	defer f.Close()
-
-	b, _ := io.ReadAll(f)
-	return string(b)
-}
-
-// Caches is a named set of caches.
-type Caches map[string]*Cache
-
-// Get gets a named cache, nil if none found.
-func (f Caches) Get(name string) *Cache {
-	return f[strings.ToLower(name)]
-}
-
-// NewCaches creates a new set of file caches from the given
-// configuration.
-func NewCaches(p *helpers.PathSpec) (Caches, error) {
-	dcfg := p.Cfg.GetConfigSection("caches").(Configs)
-	fs := p.Fs.Source
-
-	m := make(Caches)
-	for k, v := range dcfg {
-		var cfs afero.Fs
-
-		if v.IsResourceDir {
-			cfs = p.BaseFs.ResourcesCache
-		} else {
-			cfs = fs
-		}
-
-		if cfs == nil {
-			panic("nil fs")
-		}
-
-		baseDir := v.DirCompiled
-
-		bfs := hugofs.NewBasePathFs(cfs, baseDir)
-
-		var pruneAllRootDir string
-		if k == CacheKeyModules {
-			pruneAllRootDir = "pkg"
-		}
-
-		m[k] = NewCache(bfs, v.MaxAge, pruneAllRootDir)
-	}
-
-	return m, nil
-}
-
-func cleanID(name string) string {
-	return strings.TrimPrefix(filepath.Clean(name), helpers.FilePathSeparator)
-}
-
-// AsHTTPCache returns an httpcache.Cache implementation for this file cache.
-// Note that none of the methods are protected by named locks, so you need to make sure
-// to do that in your own code.
-func (c *Cache) AsHTTPCache() httpcache.Cache {
-	return &httpCache{c: c}
-}
-
-type httpCache struct {
-	c *Cache
-}
-
-func (h *httpCache) Get(id string) (resp []byte, ok bool) {
-	id = cleanID(id)
-	b, removed := h.c.getBytesAndRemoveIfExpired(id)
-
-	return b, !removed
-}
-
-func (h *httpCache) Set(id string, resp []byte) {
-	if h.c.maxAge == 0 {
-		return
-	}
-
-	id = cleanID(id)
-
-	if err := h.c.writeReader(id, bytes.NewReader(resp)); err != nil {
-		panic(err)
-	}
-}
-
-func (h *httpCache) Delete(key string) {
-	h.c.Fs.Remove(key)
-}

cache/filecache/filecache_config.go

@@ -1,247 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package filecache provides a file based cache for Hugo.
-package filecache
-
-import (
-	"errors"
-	"fmt"
-	"path"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/gohugoio/hugo/common/maps"
-	"github.com/gohugoio/hugo/config"
-
-	"github.com/mitchellh/mapstructure"
-	"github.com/spf13/afero"
-)
-
-const (
-	resourcesGenDir = ":resourceDir/_gen"
-	cacheDirProject = ":cacheDir/:project"
-)
-
-var defaultCacheConfig = FileCacheConfig{
-	MaxAge: -1, // Never expire
-	Dir:    cacheDirProject,
-}
-
-const (
-	CacheKeyGetJSON     = "getjson"
-	CacheKeyGetCSV      = "getcsv"
-	CacheKeyImages      = "images"
-	CacheKeyAssets      = "assets"
-	CacheKeyModules     = "modules"
-	CacheKeyGetResource = "getresource"
-	CacheKeyMisc        = "misc"
-)
-
-type Configs map[string]FileCacheConfig
-
-// For internal use.
-func (c Configs) CacheDirModules() string {
-	return c[CacheKeyModules].DirCompiled
-}
-
-var defaultCacheConfigs = Configs{
-	CacheKeyModules: {
-		MaxAge: -1,
-		Dir:    ":cacheDir/modules",
-	},
-	CacheKeyGetJSON: defaultCacheConfig,
-	CacheKeyGetCSV:  defaultCacheConfig,
-	CacheKeyImages: {
-		MaxAge: -1,
-		Dir:    resourcesGenDir,
-	},
-	CacheKeyAssets: {
-		MaxAge: -1,
-		Dir:    resourcesGenDir,
-	},
-	CacheKeyGetResource: {
-		MaxAge: -1, // Never expire
-		Dir:    cacheDirProject,
-	},
-	CacheKeyMisc: {
-		MaxAge: -1,
-		Dir:    cacheDirProject,
-	},
-}
-
-type FileCacheConfig struct {
-	// Max age of cache entries in this cache. Any items older than this will
-	// be removed and not returned from the cache.
-	// A negative value means forever, 0 means cache is disabled.
-	// Hugo is lenient with what types it accepts here, but we recommend using
-	// a duration string, a sequence of  decimal numbers, each with optional fraction and a unit suffix,
-	// such as "300ms", "1.5h" or "2h45m".
-	// Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
-	MaxAge time.Duration
-
-	// The directory where files are stored.
-	Dir         string
-	DirCompiled string `json:"-"`
-
-	// Will resources/_gen will get its own composite filesystem that
-	// also checks any theme.
-	IsResourceDir bool `json:"-"`
-}
-
-// GetJSONCache gets the file cache for getJSON.
-func (f Caches) GetJSONCache() *Cache {
-	return f[CacheKeyGetJSON]
-}
-
-// GetCSVCache gets the file cache for getCSV.
-func (f Caches) GetCSVCache() *Cache {
-	return f[CacheKeyGetCSV]
-}
-
-// ImageCache gets the file cache for processed images.
-func (f Caches) ImageCache() *Cache {
-	return f[CacheKeyImages]
-}
-
-// ModulesCache gets the file cache for Hugo Modules.
-func (f Caches) ModulesCache() *Cache {
-	return f[CacheKeyModules]
-}
-
-// AssetsCache gets the file cache for assets (processed resources, SCSS etc.).
-func (f Caches) AssetsCache() *Cache {
-	return f[CacheKeyAssets]
-}
-
-// MiscCache gets the file cache for miscellaneous stuff.
-func (f Caches) MiscCache() *Cache {
-	return f[CacheKeyMisc]
-}
-
-// GetResourceCache gets the file cache for remote resources.
-func (f Caches) GetResourceCache() *Cache {
-	return f[CacheKeyGetResource]
-}
-
-func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Configs, error) {
-	c := make(Configs)
-	valid := make(map[string]bool)
-	// Add defaults
-	for k, v := range defaultCacheConfigs {
-		c[k] = v
-		valid[k] = true
-	}
-
-	_, isOsFs := fs.(*afero.OsFs)
-
-	for k, v := range m {
-		if _, ok := v.(maps.Params); !ok {
-			continue
-		}
-		cc := defaultCacheConfig
-
-		dc := &mapstructure.DecoderConfig{
-			Result:           &cc,
-			DecodeHook:       mapstructure.StringToTimeDurationHookFunc(),
-			WeaklyTypedInput: true,
-		}
-
-		decoder, err := mapstructure.NewDecoder(dc)
-		if err != nil {
-			return c, err
-		}
-
-		if err := decoder.Decode(v); err != nil {
-			return nil, fmt.Errorf("failed to decode filecache config: %w", err)
-		}
-
-		if cc.Dir == "" {
-			return c, errors.New("must provide cache Dir")
-		}
-
-		name := strings.ToLower(k)
-		if !valid[name] {
-			return nil, fmt.Errorf("%q is not a valid cache name", name)
-		}
-
-		c[name] = cc
-	}
-
-	for k, v := range c {
-		dir := filepath.ToSlash(filepath.Clean(v.Dir))
-		hadSlash := strings.HasPrefix(dir, "/")
-		parts := strings.Split(dir, "/")
-
-		for i, part := range parts {
-			if strings.HasPrefix(part, ":") {
-				resolved, isResource, err := resolveDirPlaceholder(fs, bcfg, part)
-				if err != nil {
-					return c, err
-				}
-				if isResource {
-					v.IsResourceDir = true
-				}
-				parts[i] = resolved
-			}
-		}
-
-		dir = path.Join(parts...)
-		if hadSlash {
-			dir = "/" + dir
-		}
-		v.DirCompiled = filepath.Clean(filepath.FromSlash(dir))
-
-		if !v.IsResourceDir {
-			if isOsFs && !filepath.IsAbs(v.DirCompiled) {
-				return c, fmt.Errorf("%q must resolve to an absolute directory", v.DirCompiled)
-			}
-
-			// Avoid cache in root, e.g. / (Unix) or c:\ (Windows)
-			if len(strings.TrimPrefix(v.DirCompiled, filepath.VolumeName(v.DirCompiled))) == 1 {
-				return c, fmt.Errorf("%q is a root folder and not allowed as cache dir", v.DirCompiled)
-			}
-		}
-
-		if !strings.HasPrefix(v.DirCompiled, "_gen") {
-			// We do cache eviction (file removes) and since the user can set
-			// his/hers own cache directory, we really want to make sure
-			// we do not delete any files that do not belong to this cache.
-			// We do add the cache name as the root, but this is an extra safe
-			// guard. We skip the files inside /resources/_gen/ because
-			// that would be breaking.
-			v.DirCompiled = filepath.Join(v.DirCompiled, FilecacheRootDirname, k)
-		} else {
-			v.DirCompiled = filepath.Join(v.DirCompiled, k)
-		}
-
-		c[k] = v
-	}
-
-	return c, nil
-}
-
-// Resolves :resourceDir => /myproject/resources etc., :cacheDir => ...
-func resolveDirPlaceholder(fs afero.Fs, bcfg config.BaseConfig, placeholder string) (cacheDir string, isResource bool, err error) {
-	switch strings.ToLower(placeholder) {
-	case ":resourcedir":
-		return "", true, nil
-	case ":cachedir":
-		return bcfg.CacheDir, false, nil
-	case ":project":
-		return filepath.Base(bcfg.WorkingDir), false, nil
-	}
-
-	return "", false, fmt.Errorf("%q is not a valid placeholder (valid values are :cacheDir or :resourceDir)", placeholder)
-}

cache/filecache/filecache_config_test.go

@@ -1,146 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package filecache_test
-
-import (
-	"path/filepath"
-	"runtime"
-	"testing"
-	"time"
-
-	"github.com/spf13/afero"
-
-	"github.com/gohugoio/hugo/cache/filecache"
-	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/config/testconfig"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestDecodeConfig(t *testing.T) {
-	t.Parallel()
-
-	c := qt.New(t)
-
-	configStr := `
-resourceDir = "myresources"
-contentDir = "content"
-dataDir = "data"
-i18nDir = "i18n"
-layoutDir = "layouts"
-assetDir = "assets"
-archetypeDir = "archetypes"
-
-[caches]
-[caches.getJSON]
-maxAge = "10m"
-dir = "/path/to/c1"
-[caches.getCSV]
-maxAge = "11h"
-dir = "/path/to/c2"
-[caches.images]
-dir = "/path/to/c3"
-[caches.getResource]
-dir = "/path/to/c4"
-`
-
-	cfg, err := config.FromConfigString(configStr, "toml")
-	c.Assert(err, qt.IsNil)
-	fs := afero.NewMemMapFs()
-	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)
-
-	c2 := decoded["getcsv"]
-	c.Assert(c2.MaxAge.String(), qt.Equals, "11h0m0s")
-	c.Assert(c2.DirCompiled, qt.Equals, filepath.FromSlash("/path/to/c2/filecache/getcsv"))
-
-	c3 := decoded["images"]
-	c.Assert(c3.MaxAge, qt.Equals, time.Duration(-1))
-	c.Assert(c3.DirCompiled, qt.Equals, filepath.FromSlash("/path/to/c3/filecache/images"))
-
-	c4 := decoded["getresource"]
-	c.Assert(c4.MaxAge, qt.Equals, time.Duration(-1))
-	c.Assert(c4.DirCompiled, qt.Equals, filepath.FromSlash("/path/to/c4/filecache/getresource"))
-}
-
-func TestDecodeConfigIgnoreCache(t *testing.T) {
-	t.Parallel()
-
-	c := qt.New(t)
-
-	configStr := `
-resourceDir = "myresources"
-contentDir = "content"
-dataDir = "data"
-i18nDir = "i18n"
-layoutDir = "layouts"
-assetDir = "assets"
-archeTypedir = "archetypes"
-
-ignoreCache = true
-[caches]
-[caches.getJSON]
-maxAge = 1234
-dir = "/path/to/c1"
-[caches.getCSV]
-maxAge = 3456
-dir = "/path/to/c2"
-[caches.images]
-dir = "/path/to/c3"
-[caches.getResource]
-dir = "/path/to/c4"
-`
-
-	cfg, err := config.FromConfigString(configStr, "toml")
-	c.Assert(err, qt.IsNil)
-	fs := afero.NewMemMapFs()
-	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)
-
-	for _, v := range decoded {
-		c.Assert(v.MaxAge, qt.Equals, time.Duration(0))
-	}
-}
-
-func TestDecodeConfigDefault(t *testing.T) {
-	c := qt.New(t)
-	cfg := config.New()
-
-	if runtime.GOOS == "windows" {
-		cfg.Set("resourceDir", "c:\\cache\\resources")
-		cfg.Set("cacheDir", "c:\\cache\\thecache")
-
-	} else {
-		cfg.Set("resourceDir", "/cache/resources")
-		cfg.Set("cacheDir", "/cache/thecache")
-	}
-	cfg.Set("workingDir", filepath.FromSlash("/my/cool/hugoproject"))
-
-	fs := afero.NewMemMapFs()
-	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)
-
-	imgConfig := decoded[filecache.CacheKeyImages]
-	jsonConfig := decoded[filecache.CacheKeyGetJSON]
-
-	if runtime.GOOS == "windows" {
-		c.Assert(imgConfig.DirCompiled, qt.Equals, filepath.FromSlash("_gen/images"))
-	} else {
-		c.Assert(imgConfig.DirCompiled, qt.Equals, "_gen/images")
-		c.Assert(jsonConfig.DirCompiled, qt.Equals, "/cache/thecache/hugoproject/filecache/getjson")
-	}
-
-	c.Assert(imgConfig.IsResourceDir, qt.Equals, true)
-	c.Assert(jsonConfig.IsResourceDir, qt.Equals, false)
-}

cache/filecache/filecache_integration_test.go

@@ -1,106 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package filecache_test
-
-import (
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/bep/logg"
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/htesting"
-	"github.com/gohugoio/hugo/hugolib"
-)
-
-// See issue #10781. That issue wouldn't have been triggered if we kept
-// the empty root directories (e.g. _resources/gen/images).
-// It's still an upstream Go issue that we also need to handle, but
-// this is a test for the first part.
-func TestPruneShouldPreserveEmptyCacheRoots(t *testing.T) {
-	files := `
--- hugo.toml --
-baseURL = "https://example.com"
--- content/_index.md --
----
-title: "Home"
----
-
-`
-
-	b := hugolib.NewIntegrationTestBuilder(
-		hugolib.IntegrationTestConfig{T: t, TxtarString: files, RunGC: true, NeedsOsFS: true},
-	).Build()
-
-	_, err := b.H.BaseFs.ResourcesCache.Stat(filepath.Join("_gen", "images"))
-
-	b.Assert(err, qt.IsNil)
-}
-
-func TestPruneImages(t *testing.T) {
-	if htesting.IsCI() {
-		// TODO(bep)
-		t.Skip("skip flaky test on CI server")
-	}
-	t.Skip("skip flaky test")
-	files := `
--- hugo.toml --
-baseURL = "https://example.com"
-[caches]
-[caches.images]
-maxAge = "200ms"
-dir = ":resourceDir/_gen"
--- content/_index.md --
----
-title: "Home"
----
--- assets/a/pixel.png --
-iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
--- layouts/index.html --
-{{ warnf "HOME!" }}
-{{ $img := resources.GetMatch "**.png" }}
-{{ $img = $img.Resize "3x3" }}
-{{ $img.RelPermalink }}
-
-
-
-`
-
-	b := hugolib.NewIntegrationTestBuilder(
-		hugolib.IntegrationTestConfig{T: t, TxtarString: files, Running: true, RunGC: true, NeedsOsFS: true, LogLevel: logg.LevelInfo},
-	).Build()
-
-	b.Assert(b.GCCount, qt.Equals, 0)
-	b.Assert(b.H, qt.IsNotNil)
-
-	imagesCacheDir := filepath.Join("_gen", "images")
-	_, err := b.H.BaseFs.ResourcesCache.Stat(imagesCacheDir)
-
-	b.Assert(err, qt.IsNil)
-
-	// TODO(bep) we need a way to test full rebuilds.
-	// For now, just sleep a little so the cache elements expires.
-	time.Sleep(500 * time.Millisecond)
-
-	b.RenameFile("assets/a/pixel.png", "assets/b/pixel2.png").Build()
-
-	b.Assert(b.GCCount, qt.Equals, 1)
-	// Build it again to GC the empty a dir.
-	b.Build()
-
-	_, err = b.H.BaseFs.ResourcesCache.Stat(filepath.Join(imagesCacheDir, "a"))
-	b.Assert(err, qt.Not(qt.IsNil))
-	_, err = b.H.BaseFs.ResourcesCache.Stat(imagesCacheDir)
-	b.Assert(err, qt.IsNil)
-}

cache/filecache/filecache_pruner.go

@@ -1,137 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package filecache
-
-import (
-	"fmt"
-	"io"
-	"os"
-
-	"github.com/gohugoio/hugo/common/herrors"
-	"github.com/gohugoio/hugo/hugofs"
-
-	"github.com/spf13/afero"
-)
-
-// Prune removes expired and unused items from this cache.
-// The last one requires a full build so the cache usage can be tracked.
-// Note that we operate directly on the filesystem here, so this is not
-// thread safe.
-func (c Caches) Prune() (int, error) {
-	counter := 0
-	for k, cache := range c {
-		count, err := cache.Prune(false)
-
-		counter += count
-
-		if err != nil {
-			if herrors.IsNotExist(err) {
-				continue
-			}
-			return counter, fmt.Errorf("failed to prune cache %q: %w", k, err)
-		}
-
-	}
-
-	return counter, nil
-}
-
-// Prune removes expired and unused items from this cache.
-// If force is set, everything will be removed not considering expiry time.
-func (c *Cache) Prune(force bool) (int, error) {
-	if c.pruneAllRootDir != "" {
-		return c.pruneRootDir(force)
-	}
-	if err := c.init(); err != nil {
-		return 0, err
-	}
-
-	counter := 0
-
-	err := afero.Walk(c.Fs, "", func(name string, info os.FileInfo, err error) error {
-		if info == nil {
-			return nil
-		}
-
-		name = cleanID(name)
-
-		if info.IsDir() {
-			f, err := c.Fs.Open(name)
-			if err != nil {
-				// This cache dir may not exist.
-				return nil
-			}
-			_, err = f.Readdirnames(1)
-			f.Close()
-			if err == io.EOF {
-				// Empty dir.
-				if name == "." {
-					// e.g. /_gen/images -- keep it even if empty.
-					err = nil
-				} else {
-					err = c.Fs.Remove(name)
-				}
-			}
-
-			if err != nil && !herrors.IsNotExist(err) {
-				return err
-			}
-
-			return nil
-		}
-
-		shouldRemove := force || c.isExpired(info.ModTime())
-
-		if !shouldRemove && len(c.nlocker.seen) > 0 {
-			// Remove it if it's not been touched/used in the last build.
-			_, seen := c.nlocker.seen[name]
-			shouldRemove = !seen
-		}
-
-		if shouldRemove {
-			err := c.Fs.Remove(name)
-			if err == nil {
-				counter++
-			}
-
-			if err != nil && !herrors.IsNotExist(err) {
-				return err
-			}
-
-		}
-
-		return nil
-	})
-
-	return counter, err
-}
-
-func (c *Cache) pruneRootDir(force bool) (int, error) {
-	if err := c.init(); err != nil {
-		return 0, err
-	}
-	info, err := c.Fs.Stat(c.pruneAllRootDir)
-	if err != nil {
-		if herrors.IsNotExist(err) {
-			return 0, nil
-		}
-		return 0, err
-	}
-
-	if !force && !c.isExpired(info.ModTime()) {
-		return 0, nil
-	}
-
-	return hugofs.MakeReadableAndRemoveAllModulePkgDir(c.Fs, c.pruneAllRootDir)
-}

cache/filecache/filecache_pruner_test.go

@@ -1,111 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package filecache_test
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/gohugoio/hugo/cache/filecache"
-	"github.com/spf13/afero"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestPrune(t *testing.T) {
-	t.Parallel()
-
-	c := qt.New(t)
-
-	configStr := `
-resourceDir = "myresources"
-contentDir = "content"
-dataDir = "data"
-i18nDir = "i18n"
-layoutDir = "layouts"
-assetDir = "assets"
-archeTypedir = "archetypes"
-
-[caches]
-[caches.getjson]
-maxAge = "200ms"
-dir = "/cache/c"
-[caches.getcsv]
-maxAge = "200ms"
-dir = "/cache/d"
-[caches.assets]
-maxAge = "200ms"
-dir = ":resourceDir/_gen"
-[caches.images]
-maxAge = "200ms"
-dir = ":resourceDir/_gen"
-`
-
-	for _, name := range []string{filecache.CacheKeyGetCSV, filecache.CacheKeyGetJSON, filecache.CacheKeyAssets, filecache.CacheKeyImages} {
-		msg := qt.Commentf("cache: %s", name)
-		p := newPathsSpec(t, afero.NewMemMapFs(), configStr)
-		caches, err := filecache.NewCaches(p)
-		c.Assert(err, qt.IsNil)
-		cache := caches[name]
-		for i := range 10 {
-			id := fmt.Sprintf("i%d", i)
-			cache.GetOrCreateBytes(id, func() ([]byte, error) {
-				return []byte("abc"), nil
-			})
-			if i == 4 {
-				// This will expire the first 5
-				time.Sleep(201 * time.Millisecond)
-			}
-		}
-
-		count, err := caches.Prune()
-		c.Assert(err, qt.IsNil)
-		c.Assert(count, qt.Equals, 5, msg)
-
-		for i := range 10 {
-			id := fmt.Sprintf("i%d", i)
-			v := cache.GetString(id)
-			if i < 5 {
-				c.Assert(v, qt.Equals, "")
-			} else {
-				c.Assert(v, qt.Equals, "abc")
-			}
-		}
-
-		caches, err = filecache.NewCaches(p)
-		c.Assert(err, qt.IsNil)
-		cache = caches[name]
-		// Touch one and then prune.
-		cache.GetOrCreateBytes("i5", func() ([]byte, error) {
-			return []byte("abc"), nil
-		})
-
-		count, err = caches.Prune()
-		c.Assert(err, qt.IsNil)
-		c.Assert(count, qt.Equals, 4)
-
-		// Now only the i5 should be left.
-		for i := range 10 {
-			id := fmt.Sprintf("i%d", i)
-			v := cache.GetString(id)
-			if i != 5 {
-				c.Assert(v, qt.Equals, "")
-			} else {
-				c.Assert(v, qt.Equals, "abc")
-			}
-		}
-
-	}
-}

cache/filecache/filecache_test.go

@@ -1,276 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package filecache_test
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/gohugoio/hugo/cache/filecache"
-	"github.com/gohugoio/hugo/common/hugio"
-	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/config/testconfig"
-	"github.com/gohugoio/hugo/helpers"
-
-	"github.com/gohugoio/hugo/hugofs"
-	"github.com/spf13/afero"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestFileCache(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	tempWorkingDir := t.TempDir()
-	tempCacheDir := t.TempDir()
-
-	osfs := afero.NewOsFs()
-
-	for _, test := range []struct {
-		cacheDir   string
-		workingDir string
-	}{
-		// Run with same dirs twice to make sure that works.
-		{tempCacheDir, tempWorkingDir},
-		{tempCacheDir, tempWorkingDir},
-	} {
-
-		configStr := `
-workingDir = "WORKING_DIR"
-resourceDir = "resources"
-cacheDir = "CACHEDIR"
-contentDir = "content"
-dataDir = "data"
-i18nDir = "i18n"
-layoutDir = "layouts"
-assetDir = "assets"
-archeTypedir = "archetypes"
-
-[caches]
-[caches.getJSON]
-maxAge = "10h"
-dir = ":cacheDir/c"
-
-`
-
-		winPathSep := "\\\\"
-
-		replacer := strings.NewReplacer("CACHEDIR", test.cacheDir, "WORKING_DIR", test.workingDir)
-
-		configStr = replacer.Replace(configStr)
-		configStr = strings.Replace(configStr, "\\", winPathSep, -1)
-
-		p := newPathsSpec(t, osfs, configStr)
-
-		caches, err := filecache.NewCaches(p)
-		c.Assert(err, qt.IsNil)
-
-		cache := caches.Get("GetJSON")
-		c.Assert(cache, qt.Not(qt.IsNil))
-
-		cache = caches.Get("Images")
-		c.Assert(cache, qt.Not(qt.IsNil))
-
-		rf := func(s string) func() (io.ReadCloser, error) {
-			return func() (io.ReadCloser, error) {
-				return struct {
-					io.ReadSeeker
-					io.Closer
-				}{
-					strings.NewReader(s),
-					io.NopCloser(nil),
-				}, nil
-			}
-		}
-
-		bf := func() ([]byte, error) {
-			return []byte("bcd"), nil
-		}
-
-		for _, ca := range []*filecache.Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
-			for range 2 {
-				info, r, err := ca.GetOrCreate("a", rf("abc"))
-				c.Assert(err, qt.IsNil)
-				c.Assert(r, qt.Not(qt.IsNil))
-				c.Assert(info.Name, qt.Equals, "a")
-				b, _ := io.ReadAll(r)
-				r.Close()
-				c.Assert(string(b), qt.Equals, "abc")
-
-				info, b, err = ca.GetOrCreateBytes("b", bf)
-				c.Assert(err, qt.IsNil)
-				c.Assert(r, qt.Not(qt.IsNil))
-				c.Assert(info.Name, qt.Equals, "b")
-				c.Assert(string(b), qt.Equals, "bcd")
-
-				_, b, err = ca.GetOrCreateBytes("a", bf)
-				c.Assert(err, qt.IsNil)
-				c.Assert(string(b), qt.Equals, "abc")
-
-				_, r, err = ca.GetOrCreate("a", rf("bcd"))
-				c.Assert(err, qt.IsNil)
-				b, _ = io.ReadAll(r)
-				r.Close()
-				c.Assert(string(b), qt.Equals, "abc")
-			}
-		}
-
-		c.Assert(caches.Get("getJSON"), qt.Not(qt.IsNil))
-
-		info, w, err := caches.ImageCache().WriteCloser("mykey")
-		c.Assert(err, qt.IsNil)
-		c.Assert(info.Name, qt.Equals, "mykey")
-		io.WriteString(w, "Hugo is great!")
-		w.Close()
-		c.Assert(caches.ImageCache().GetString("mykey"), qt.Equals, "Hugo is great!")
-
-		info, r, err := caches.ImageCache().Get("mykey")
-		c.Assert(err, qt.IsNil)
-		c.Assert(r, qt.Not(qt.IsNil))
-		c.Assert(info.Name, qt.Equals, "mykey")
-		b, _ := io.ReadAll(r)
-		r.Close()
-		c.Assert(string(b), qt.Equals, "Hugo is great!")
-
-		info, b, err = caches.ImageCache().GetBytes("mykey")
-		c.Assert(err, qt.IsNil)
-		c.Assert(info.Name, qt.Equals, "mykey")
-		c.Assert(string(b), qt.Equals, "Hugo is great!")
-
-	}
-}
-
-func TestFileCacheConcurrent(t *testing.T) {
-	t.Parallel()
-
-	c := qt.New(t)
-
-	configStr := `
-resourceDir = "myresources"
-contentDir = "content"
-dataDir = "data"
-i18nDir = "i18n"
-layoutDir = "layouts"
-assetDir = "assets"
-archeTypedir = "archetypes"
-
-[caches]
-[caches.getjson]
-maxAge = "1s"
-dir = "/cache/c"
-
-`
-
-	p := newPathsSpec(t, afero.NewMemMapFs(), configStr)
-
-	caches, err := filecache.NewCaches(p)
-	c.Assert(err, qt.IsNil)
-
-	const cacheName = "getjson"
-
-	filenameData := func(i int) (string, string) {
-		data := fmt.Sprintf("data: %d", i)
-		filename := fmt.Sprintf("file%d", i)
-		return filename, data
-	}
-
-	var wg sync.WaitGroup
-
-	for i := range 50 {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			for range 20 {
-				ca := caches.Get(cacheName)
-				c.Assert(ca, qt.Not(qt.IsNil))
-				filename, data := filenameData(i)
-				_, r, err := ca.GetOrCreate(filename, func() (io.ReadCloser, error) {
-					return hugio.ToReadCloser(strings.NewReader(data)), nil
-				})
-				c.Assert(err, qt.IsNil)
-				b, _ := io.ReadAll(r)
-				r.Close()
-				c.Assert(string(b), qt.Equals, data)
-				// Trigger some expiration.
-				time.Sleep(50 * time.Millisecond)
-			}
-		}(i)
-
-	}
-	wg.Wait()
-}
-
-func TestFileCacheReadOrCreateErrorInRead(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	var result string
-
-	rf := func(failLevel int) func(info filecache.ItemInfo, r io.ReadSeeker) error {
-		return func(info filecache.ItemInfo, r io.ReadSeeker) error {
-			if failLevel > 0 {
-				if failLevel > 1 {
-					return filecache.ErrFatal
-				}
-				return errors.New("fail")
-			}
-
-			b, _ := io.ReadAll(r)
-			result = string(b)
-
-			return nil
-		}
-	}
-
-	bf := func(s string) func(info filecache.ItemInfo, w io.WriteCloser) error {
-		return func(info filecache.ItemInfo, w io.WriteCloser) error {
-			defer w.Close()
-			result = s
-			_, err := w.Write([]byte(s))
-			return err
-		}
-	}
-
-	cache := filecache.NewCache(afero.NewMemMapFs(), 100*time.Hour, "")
-
-	const id = "a32"
-
-	_, err := cache.ReadOrCreate(id, rf(0), bf("v1"))
-	c.Assert(err, qt.IsNil)
-	c.Assert(result, qt.Equals, "v1")
-	_, err = cache.ReadOrCreate(id, rf(0), bf("v2"))
-	c.Assert(err, qt.IsNil)
-	c.Assert(result, qt.Equals, "v1")
-	_, err = cache.ReadOrCreate(id, rf(1), bf("v3"))
-	c.Assert(err, qt.IsNil)
-	c.Assert(result, qt.Equals, "v3")
-	_, err = cache.ReadOrCreate(id, rf(2), bf("v3"))
-	c.Assert(err, qt.Equals, filecache.ErrFatal)
-}
-
-func newPathsSpec(t *testing.T, fs afero.Fs, configStr string) *helpers.PathSpec {
-	c := qt.New(t)
-	cfg, err := config.FromConfigString(configStr, "toml")
-	c.Assert(err, qt.IsNil)
-	acfg := testconfig.GetTestConfig(fs, cfg)
-	p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, acfg.BaseConfig()), acfg, nil)
-	c.Assert(err, qt.IsNil)
-	return p
-}

cache/httpcache/httpcache.go

@@ -1,229 +0,0 @@
-// Copyright 2024 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 httpcache
-
-import (
-	"encoding/json"
-	"time"
-
-	"github.com/gobwas/glob"
-	"github.com/gohugoio/hugo/common/predicate"
-	"github.com/gohugoio/hugo/config"
-	"github.com/mitchellh/mapstructure"
-)
-
-// DefaultConfig holds the default configuration for the HTTP cache.
-var DefaultConfig = Config{
-	Cache: Cache{
-		For: GlobMatcher{
-			Excludes: []string{"**"},
-		},
-	},
-	Polls: []PollConfig{
-		{
-			For: GlobMatcher{
-				Includes: []string{"**"},
-			},
-			Disable: true,
-		},
-	},
-}
-
-// Config holds the configuration for the HTTP cache.
-type Config struct {
-	// Configures the HTTP cache behavior (RFC 9111).
-	// When this is not enabled for a resource, Hugo will go straight to the file cache.
-	Cache Cache
-
-	// Polls holds a list of configurations for polling remote resources to detect changes in watch mode.
-	// This can be disabled for some resources, typically if they are known to not change.
-	Polls []PollConfig
-}
-
-type Cache struct {
-	// Enable HTTP cache behavior (RFC 9111) for these resources.
-	For GlobMatcher
-}
-
-func (c *Config) Compile() (ConfigCompiled, error) {
-	var cc ConfigCompiled
-
-	p, err := c.Cache.For.CompilePredicate()
-	if err != nil {
-		return cc, err
-	}
-
-	cc.For = p
-
-	for _, pc := range c.Polls {
-
-		p, err := pc.For.CompilePredicate()
-		if err != nil {
-			return cc, err
-		}
-
-		cc.PollConfigs = append(cc.PollConfigs, PollConfigCompiled{
-			For:    p,
-			Config: pc,
-		})
-	}
-
-	return cc, nil
-}
-
-// PollConfig holds the configuration for polling remote resources to detect changes in watch mode.
-type PollConfig struct {
-	// What remote resources to apply this configuration to.
-	For GlobMatcher
-
-	// Disable polling for this configuration.
-	Disable bool
-
-	// Low is the lower bound for the polling interval.
-	// This is the starting point when the resource has recently changed,
-	// if that resource stops changing, the polling interval will gradually increase towards High.
-	Low time.Duration
-
-	// High is the upper bound for the polling interval.
-	// This is the interval used when the resource is stable.
-	High time.Duration
-}
-
-func (c PollConfig) MarshalJSON() (b []byte, err error) {
-	// Marshal the durations as strings.
-	type Alias PollConfig
-	return json.Marshal(&struct {
-		Low  string
-		High string
-		Alias
-	}{
-		Low:   c.Low.String(),
-		High:  c.High.String(),
-		Alias: (Alias)(c),
-	})
-}
-
-type GlobMatcher struct {
-	// Excludes holds a list of glob patterns that will be excluded.
-	Excludes []string
-
-	// Includes holds a list of glob patterns that will be included.
-	Includes []string
-}
-
-func (gm GlobMatcher) IsZero() bool {
-	return len(gm.Includes) == 0 && len(gm.Excludes) == 0
-}
-
-type ConfigCompiled struct {
-	For         predicate.P[string]
-	PollConfigs []PollConfigCompiled
-}
-
-func (c *ConfigCompiled) PollConfigFor(s string) PollConfigCompiled {
-	for _, pc := range c.PollConfigs {
-		if pc.For(s) {
-			return pc
-		}
-	}
-	return PollConfigCompiled{}
-}
-
-func (c *ConfigCompiled) IsPollingDisabled() bool {
-	for _, pc := range c.PollConfigs {
-		if !pc.Config.Disable {
-			return false
-		}
-	}
-	return true
-}
-
-type PollConfigCompiled struct {
-	For    predicate.P[string]
-	Config PollConfig
-}
-
-func (p PollConfigCompiled) IsZero() bool {
-	return p.For == nil
-}
-
-func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
-	if gm.IsZero() {
-		panic("no includes or excludes")
-	}
-	var p predicate.P[string]
-	for _, include := range gm.Includes {
-		g, err := glob.Compile(include, '/')
-		if err != nil {
-			return nil, err
-		}
-		fn := func(s string) bool {
-			return g.Match(s)
-		}
-		p = p.Or(fn)
-	}
-
-	for _, exclude := range gm.Excludes {
-		g, err := glob.Compile(exclude, '/')
-		if err != nil {
-			return nil, err
-		}
-		fn := func(s string) bool {
-			return !g.Match(s)
-		}
-		p = p.And(fn)
-	}
-
-	return p, nil
-}
-
-func DecodeConfig(_ config.BaseConfig, m map[string]any) (Config, error) {
-	if len(m) == 0 {
-		return DefaultConfig, nil
-	}
-
-	var c Config
-
-	dc := &mapstructure.DecoderConfig{
-		Result:           &c,
-		DecodeHook:       mapstructure.StringToTimeDurationHookFunc(),
-		WeaklyTypedInput: true,
-	}
-
-	decoder, err := mapstructure.NewDecoder(dc)
-	if err != nil {
-		return c, err
-	}
-
-	if err := decoder.Decode(m); err != nil {
-		return c, err
-	}
-
-	if c.Cache.For.IsZero() {
-		c.Cache.For = DefaultConfig.Cache.For
-	}
-
-	for pci := range c.Polls {
-		if c.Polls[pci].For.IsZero() {
-			c.Polls[pci].For = DefaultConfig.Cache.For
-			c.Polls[pci].Disable = true
-		}
-	}
-
-	if len(c.Polls) == 0 {
-		c.Polls = DefaultConfig.Polls
-	}
-
-	return c, nil
-}

cache/httpcache/httpcache_integration_test.go

@@ -1,95 +0,0 @@
-// Copyright 2024 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 httpcache_test
-
-import (
-	"testing"
-	"time"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/hugolib"
-)
-
-func TestConfigCustom(t *testing.T) {
-	t.Parallel()
-
-	files := `
--- hugo.toml --
-[httpcache]
-[httpcache.cache.for]
-includes = ["**gohugo.io**"]
-[[httpcache.polls]]
-low = "5s"
-high = "32s"
-[httpcache.polls.for]
-includes = ["**gohugo.io**"]
-		
-	
-`
-
-	b := hugolib.Test(t, files)
-
-	httpcacheConf := b.H.Configs.Base.HTTPCache
-	compiled := b.H.Configs.Base.C.HTTPCache
-
-	b.Assert(httpcacheConf.Cache.For.Includes, qt.DeepEquals, []string{"**gohugo.io**"})
-	b.Assert(httpcacheConf.Cache.For.Excludes, qt.IsNil)
-
-	pc := compiled.PollConfigFor("https://gohugo.io/foo.jpg")
-	b.Assert(pc.Config.Low, qt.Equals, 5*time.Second)
-	b.Assert(pc.Config.High, qt.Equals, 32*time.Second)
-	b.Assert(compiled.PollConfigFor("https://example.com/foo.jpg").IsZero(), qt.IsTrue)
-}
-
-func TestConfigDefault(t *testing.T) {
-	t.Parallel()
-
-	files := `
--- hugo.toml --
-`
-	b := hugolib.Test(t, files)
-
-	compiled := b.H.Configs.Base.C.HTTPCache
-
-	b.Assert(compiled.For("https://gohugo.io/posts.json"), qt.IsFalse)
-	b.Assert(compiled.For("https://gohugo.io/foo.jpg"), qt.IsFalse)
-	b.Assert(compiled.PollConfigFor("https://gohugo.io/foo.jpg").Config.Disable, qt.IsTrue)
-}
-
-func TestConfigPollsOnly(t *testing.T) {
-	t.Parallel()
-	files := `
--- hugo.toml --
-[httpcache]
-[[httpcache.polls]]
-low = "5s"
-high = "32s"
-[httpcache.polls.for]
-includes = ["**gohugo.io**"]
-		
-	
-`
-
-	b := hugolib.Test(t, files)
-
-	compiled := b.H.Configs.Base.C.HTTPCache
-
-	b.Assert(compiled.For("https://gohugo.io/posts.json"), qt.IsFalse)
-	b.Assert(compiled.For("https://gohugo.io/foo.jpg"), qt.IsFalse)
-
-	pc := compiled.PollConfigFor("https://gohugo.io/foo.jpg")
-	b.Assert(pc.Config.Low, qt.Equals, 5*time.Second)
-	b.Assert(pc.Config.High, qt.Equals, 32*time.Second)
-	b.Assert(compiled.PollConfigFor("https://example.com/foo.jpg").IsZero(), qt.IsTrue)
-}

cache/httpcache/httpcache_test.go

@@ -1,73 +0,0 @@
-// Copyright 2024 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 httpcache
-
-import (
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/config"
-)
-
-func TestGlobMatcher(t *testing.T) {
-	c := qt.New(t)
-
-	g := GlobMatcher{
-		Includes: []string{"**/*.jpg", "**.png", "**/bar/**"},
-		Excludes: []string{"**/foo.jpg", "**.css"},
-	}
-
-	p, err := g.CompilePredicate()
-	c.Assert(err, qt.IsNil)
-
-	c.Assert(p("foo.jpg"), qt.IsFalse)
-	c.Assert(p("foo.png"), qt.IsTrue)
-	c.Assert(p("foo/bar.jpg"), qt.IsTrue)
-	c.Assert(p("foo/bar.png"), qt.IsTrue)
-	c.Assert(p("foo/bar/foo.jpg"), qt.IsFalse)
-	c.Assert(p("foo/bar/foo.css"), qt.IsFalse)
-	c.Assert(p("foo.css"), qt.IsFalse)
-	c.Assert(p("foo/bar/foo.css"), qt.IsFalse)
-	c.Assert(p("foo/bar/foo.xml"), qt.IsTrue)
-}
-
-func TestDefaultConfig(t *testing.T) {
-	c := qt.New(t)
-
-	_, err := DefaultConfig.Compile()
-	c.Assert(err, qt.IsNil)
-}
-
-func TestDecodeConfigInjectsDefaultAndCompiles(t *testing.T) {
-	c := qt.New(t)
-
-	cfg, err := DecodeConfig(config.BaseConfig{}, map[string]interface{}{})
-	c.Assert(err, qt.IsNil)
-	c.Assert(cfg, qt.DeepEquals, DefaultConfig)
-
-	_, err = cfg.Compile()
-	c.Assert(err, qt.IsNil)
-
-	cfg, err = DecodeConfig(config.BaseConfig{}, map[string]any{
-		"cache": map[string]any{
-			"polls": []map[string]any{
-				{"disable": true},
-			},
-		},
-	})
-	c.Assert(err, qt.IsNil)
-
-	_, err = cfg.Compile()
-	c.Assert(err, qt.IsNil)
-}

cache/partitioned_lazy_cache.go

@@ -0,0 +1,99 @@
+// Copyright 2017-present 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 cache
+
+import (
+	"sync"
+)
+
+// Partition represents a cache partition where Load is the callback
+// for when the partition is needed.
+type Partition struct {
+	Key  string
+	Load func() (map[string]interface{}, error)
+}
+
+// Lazy represents a lazily loaded cache.
+type Lazy struct {
+	initSync sync.Once
+	initErr  error
+	cache    map[string]interface{}
+	load     func() (map[string]interface{}, error)
+}
+
+// NewLazy creates a lazy cache with the given load func.
+func NewLazy(load func() (map[string]interface{}, error)) *Lazy {
+	return &Lazy{load: load}
+}
+
+func (l *Lazy) init() error {
+	l.initSync.Do(func() {
+		c, err := l.load()
+		l.cache = c
+		l.initErr = err
+
+	})
+
+	return l.initErr
+}
+
+// Get initializes the cache if not already initialized, then looks up the
+// given key.
+func (l *Lazy) Get(key string) (interface{}, bool, error) {
+	l.init()
+	if l.initErr != nil {
+		return nil, false, l.initErr
+	}
+	v, found := l.cache[key]
+	return v, found, nil
+}
+
+// PartitionedLazyCache is a lazily loaded cache paritioned by a supplied string key.
+type PartitionedLazyCache struct {
+	partitions map[string]*Lazy
+}
+
+// NewPartitionedLazyCache creates a new NewPartitionedLazyCache with the supplied
+// partitions.
+func NewPartitionedLazyCache(partitions ...Partition) *PartitionedLazyCache {
+	lazyPartitions := make(map[string]*Lazy, len(partitions))
+	for _, partition := range partitions {
+		lazyPartitions[partition.Key] = NewLazy(partition.Load)
+	}
+	cache := &PartitionedLazyCache{partitions: lazyPartitions}
+
+	return cache
+}
+
+// Get initializes the partition if not already done so, then looks up the given
+// key in the given partition, returns nil if no value found.
+func (c *PartitionedLazyCache) Get(partition, key string) (interface{}, error) {
+	p, found := c.partitions[partition]
+
+	if !found {
+		return nil, nil
+	}
+
+	v, found, err := p.Get(key)
+	if err != nil {
+		return nil, err
+	}
+
+	if found {
+		return v, nil
+	}
+
+	return nil, nil
+
+}

cache/partitioned_lazy_cache_test.go

@@ -0,0 +1,138 @@
+// Copyright 2017-present 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 cache
+
+import (
+	"errors"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewPartitionedLazyCache(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	p1 := Partition{
+		Key: "p1",
+		Load: func() (map[string]interface{}, error) {
+			return map[string]interface{}{
+				"p1_1":   "p1v1",
+				"p1_2":   "p1v2",
+				"p1_nil": nil,
+			}, nil
+		},
+	}
+
+	p2 := Partition{
+		Key: "p2",
+		Load: func() (map[string]interface{}, error) {
+			return map[string]interface{}{
+				"p2_1": "p2v1",
+				"p2_2": "p2v2",
+				"p2_3": "p2v3",
+			}, nil
+		},
+	}
+
+	cache := NewPartitionedLazyCache(p1, p2)
+
+	v, err := cache.Get("p1", "p1_1")
+	assert.NoError(err)
+	assert.Equal("p1v1", v)
+
+	v, err = cache.Get("p1", "p2_1")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	v, err = cache.Get("p1", "p1_nil")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	v, err = cache.Get("p2", "p2_3")
+	assert.NoError(err)
+	assert.Equal("p2v3", v)
+
+	v, err = cache.Get("doesnotexist", "p1_1")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	v, err = cache.Get("p1", "doesnotexist")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	errorP := Partition{
+		Key: "p3",
+		Load: func() (map[string]interface{}, error) {
+			return nil, errors.New("Failed")
+		},
+	}
+
+	cache = NewPartitionedLazyCache(errorP)
+
+	v, err = cache.Get("p1", "doesnotexist")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	_, err = cache.Get("p3", "doesnotexist")
+	assert.Error(err)
+
+}
+
+func TestConcurrentPartitionedLazyCache(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	var wg sync.WaitGroup
+
+	p1 := Partition{
+		Key: "p1",
+		Load: func() (map[string]interface{}, error) {
+			return map[string]interface{}{
+				"p1_1":   "p1v1",
+				"p1_2":   "p1v2",
+				"p1_nil": nil,
+			}, nil
+		},
+	}
+
+	p2 := Partition{
+		Key: "p2",
+		Load: func() (map[string]interface{}, error) {
+			return map[string]interface{}{
+				"p2_1": "p2v1",
+				"p2_2": "p2v2",
+				"p2_3": "p2v3",
+			}, nil
+		},
+	}
+
+	cache := NewPartitionedLazyCache(p1, p2)
+
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 10; j++ {
+				v, err := cache.Get("p1", "p1_1")
+				assert.NoError(err)
+				assert.Equal("p1v1", v)
+			}
+		}()
+	}
+	wg.Wait()
+}

check_gofmt.sh

@@ -1,2 +0,0 @@
-#!/usr/bin/env bash
-diff <(gofmt -d .) <(printf '')

codegen/methods.go

@@ -1,540 +0,0 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
-// Some functions in this file (see comments) is based on the Go source code,
-// copyright The Go Authors and  governed by a BSD-style license.
-//
-// 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 codegen contains helpers for code generation.
-package codegen
-
-import (
-	"fmt"
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"os"
-	"path"
-	"path/filepath"
-	"reflect"
-	"regexp"
-	"slices"
-	"sort"
-	"strings"
-	"sync"
-)
-
-// Make room for insertions
-const weightWidth = 1000
-
-// NewInspector creates a new Inspector given a source root.
-func NewInspector(root string) *Inspector {
-	return &Inspector{ProjectRootDir: root}
-}
-
-// Inspector provides methods to help code generation. It uses a combination
-// of reflection and source code AST to do the heavy lifting.
-type Inspector struct {
-	ProjectRootDir string
-
-	init sync.Once
-
-	// Determines method order. Go's reflect sorts lexicographically, so
-	// we must parse the source to preserve this order.
-	methodWeight map[string]map[string]int
-}
-
-// MethodsFromTypes create a method set from the include slice, excluding any
-// method in exclude.
-func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.Type) Methods {
-	c.parseSource()
-
-	var methods Methods
-
-	excludes := make(map[string]bool)
-
-	if len(exclude) > 0 {
-		for _, m := range c.MethodsFromTypes(exclude, nil) {
-			excludes[m.Name] = true
-		}
-	}
-
-	// There may be overlapping interfaces in types. Do a simple check for now.
-	seen := make(map[string]bool)
-
-	nameAndPackage := func(t reflect.Type) (string, string) {
-		var name, pkg string
-
-		isPointer := t.Kind() == reflect.Ptr
-
-		if isPointer {
-			t = t.Elem()
-		}
-
-		pkgPrefix := ""
-		if pkgPath := t.PkgPath(); pkgPath != "" {
-			pkgPath = strings.TrimSuffix(pkgPath, "/")
-			_, shortPath := path.Split(pkgPath)
-			pkgPrefix = shortPath + "."
-			pkg = pkgPath
-		}
-
-		name = t.Name()
-		if name == "" {
-			// interface{}
-			name = t.String()
-		}
-
-		if isPointer {
-			pkgPrefix = "*" + pkgPrefix
-		}
-
-		name = pkgPrefix + name
-
-		return name, pkg
-	}
-
-	for _, t := range include {
-		for i := range t.NumMethod() {
-
-			m := t.Method(i)
-			if excludes[m.Name] || seen[m.Name] {
-				continue
-			}
-
-			seen[m.Name] = true
-
-			if m.PkgPath != "" {
-				// Not exported
-				continue
-			}
-
-			numIn := m.Type.NumIn()
-
-			ownerName, _ := nameAndPackage(t)
-
-			method := Method{Owner: t, OwnerName: ownerName, Name: m.Name}
-
-			for i := range numIn {
-				in := m.Type.In(i)
-
-				name, pkg := nameAndPackage(in)
-
-				if pkg != "" {
-					method.Imports = append(method.Imports, pkg)
-				}
-
-				method.In = append(method.In, name)
-			}
-
-			numOut := m.Type.NumOut()
-
-			if numOut > 0 {
-				for i := range numOut {
-					out := m.Type.Out(i)
-					name, pkg := nameAndPackage(out)
-
-					if pkg != "" {
-						method.Imports = append(method.Imports, pkg)
-					}
-
-					method.Out = append(method.Out, name)
-				}
-			}
-
-			methods = append(methods, method)
-		}
-	}
-
-	sort.SliceStable(methods, func(i, j int) bool {
-		mi, mj := methods[i], methods[j]
-
-		wi := c.methodWeight[mi.OwnerName][mi.Name]
-		wj := c.methodWeight[mj.OwnerName][mj.Name]
-
-		if wi == wj {
-			return mi.Name < mj.Name
-		}
-
-		return wi < wj
-	})
-
-	return methods
-}
-
-func (c *Inspector) parseSource() {
-	c.init.Do(func() {
-		if !strings.Contains(c.ProjectRootDir, "hugo") {
-			panic("dir must be set to the Hugo root")
-		}
-
-		c.methodWeight = make(map[string]map[string]int)
-		dirExcludes := regexp.MustCompile("docs|examples")
-		fileExcludes := regexp.MustCompile("autogen")
-		var filenames []string
-
-		filepath.Walk(c.ProjectRootDir, func(path string, info os.FileInfo, err error) error {
-			if info.IsDir() {
-				if dirExcludes.MatchString(info.Name()) {
-					return filepath.SkipDir
-				}
-			}
-
-			if !strings.HasSuffix(path, ".go") || fileExcludes.MatchString(path) {
-				return nil
-			}
-
-			filenames = append(filenames, path)
-
-			return nil
-		})
-
-		for _, filename := range filenames {
-
-			pkg := c.packageFromPath(filename)
-
-			fset := token.NewFileSet()
-			node, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
-			if err != nil {
-				panic(err)
-			}
-
-			ast.Inspect(node, func(n ast.Node) bool {
-				switch t := n.(type) {
-				case *ast.TypeSpec:
-					if t.Name.IsExported() {
-						switch it := t.Type.(type) {
-						case *ast.InterfaceType:
-							iface := pkg + "." + t.Name.Name
-							methodNames := collectMethodsRecursive(pkg, it.Methods.List)
-							weights := make(map[string]int)
-							weight := weightWidth
-							for _, name := range methodNames {
-								weights[name] = weight
-								weight += weightWidth
-							}
-							c.methodWeight[iface] = weights
-						}
-					}
-				}
-				return true
-			})
-
-		}
-
-		// Complement
-		for _, v1 := range c.methodWeight {
-			for k2, w := range v1 {
-				if v, found := c.methodWeight[k2]; found {
-					for k3, v3 := range v {
-						v1[k3] = (v3 / weightWidth) + w
-					}
-				}
-			}
-		}
-	})
-}
-
-func (c *Inspector) packageFromPath(p string) string {
-	p = filepath.ToSlash(p)
-	base := path.Base(p)
-	if !strings.Contains(base, ".") {
-		return base
-	}
-	return path.Base(strings.TrimSuffix(p, base))
-}
-
-// Method holds enough information about it to recreate it.
-type Method struct {
-	// The interface we extracted this method from.
-	Owner reflect.Type
-
-	// String version of the above, on the form PACKAGE.NAME, e.g.
-	// page.Page
-	OwnerName string
-
-	// Method name.
-	Name string
-
-	// Imports needed to satisfy the method signature.
-	Imports []string
-
-	// Argument types, including any package prefix, e.g. string, int, interface{},
-	// net.Url
-	In []string
-
-	// Return types.
-	Out []string
-}
-
-// Declaration creates a method declaration (without any body) for the given receiver.
-func (m Method) Declaration(receiver string) string {
-	return fmt.Sprintf("func (%s %s) %s%s %s", receiverShort(receiver), receiver, m.Name, m.inStr(), m.outStr())
-}
-
-// DeclarationNamed creates a method declaration (without any body) for the given receiver
-// with named return values.
-func (m Method) DeclarationNamed(receiver string) string {
-	return fmt.Sprintf("func (%s %s) %s%s %s", receiverShort(receiver), receiver, m.Name, m.inStr(), m.outStrNamed())
-}
-
-// Delegate creates a delegate call string.
-func (m Method) Delegate(receiver, delegate string) string {
-	ret := ""
-	if len(m.Out) > 0 {
-		ret = "return "
-	}
-	return fmt.Sprintf("%s%s.%s.%s%s", ret, receiverShort(receiver), delegate, m.Name, m.inOutStr())
-}
-
-func (m Method) String() string {
-	return m.Name + m.inStr() + " " + m.outStr() + "\n"
-}
-
-func (m Method) inOutStr() string {
-	if len(m.In) == 0 {
-		return "()"
-	}
-
-	args := make([]string, len(m.In))
-	for i := range args {
-		args[i] = fmt.Sprintf("arg%d", i)
-	}
-	return "(" + strings.Join(args, ", ") + ")"
-}
-
-func (m Method) inStr() string {
-	if len(m.In) == 0 {
-		return "()"
-	}
-
-	args := make([]string, len(m.In))
-	for i := range args {
-		args[i] = fmt.Sprintf("arg%d %s", i, m.In[i])
-	}
-	return "(" + strings.Join(args, ", ") + ")"
-}
-
-func (m Method) outStr() string {
-	if len(m.Out) == 0 {
-		return ""
-	}
-	if len(m.Out) == 1 {
-		return m.Out[0]
-	}
-
-	return "(" + strings.Join(m.Out, ", ") + ")"
-}
-
-func (m Method) outStrNamed() string {
-	if len(m.Out) == 0 {
-		return ""
-	}
-
-	outs := make([]string, len(m.Out))
-	for i := range outs {
-		outs[i] = fmt.Sprintf("o%d %s", i, m.Out[i])
-	}
-
-	return "(" + strings.Join(outs, ", ") + ")"
-}
-
-// Methods represents a list of methods for one or more interfaces.
-// The order matches the defined order in their source file(s).
-type Methods []Method
-
-// Imports returns a sorted list of package imports needed to satisfy the
-// signatures of all methods.
-func (m Methods) Imports() []string {
-	var pkgImports []string
-	for _, method := range m {
-		pkgImports = append(pkgImports, method.Imports...)
-	}
-	if len(pkgImports) > 0 {
-		pkgImports = uniqueNonEmptyStrings(pkgImports)
-		sort.Strings(pkgImports)
-	}
-	return pkgImports
-}
-
-// ToMarshalJSON creates a MarshalJSON method for these methods. Any method name
-// matching any of the regexps in excludes will be ignored.
-func (m Methods) ToMarshalJSON(receiver, pkgPath string, excludes ...string) (string, []string) {
-	var sb strings.Builder
-
-	r := receiverShort(receiver)
-	what := firstToUpper(trimAsterisk(receiver))
-	pgkName := path.Base(pkgPath)
-
-	fmt.Fprintf(&sb, "func Marshal%sToJSON(%s %s) ([]byte, error) {\n", what, r, receiver)
-
-	var methods Methods
-	excludeRes := make([]*regexp.Regexp, len(excludes))
-
-	for i, exclude := range excludes {
-		excludeRes[i] = regexp.MustCompile(exclude)
-	}
-
-	for _, method := range m {
-		// Exclude methods with arguments and incompatible return values
-		if len(method.In) > 0 || len(method.Out) == 0 || len(method.Out) > 2 {
-			continue
-		}
-
-		if len(method.Out) == 2 {
-			if method.Out[1] != "error" {
-				continue
-			}
-		}
-
-		for _, re := range excludeRes {
-			if re.MatchString(method.Name) {
-				continue
-			}
-		}
-
-		methods = append(methods, method)
-	}
-
-	for _, method := range methods {
-		varn := varName(method.Name)
-		if len(method.Out) == 1 {
-			fmt.Fprintf(&sb, "\t%s := %s.%s()\n", varn, r, method.Name)
-		} else {
-			fmt.Fprintf(&sb, "\t%s, err := %s.%s()\n", varn, r, method.Name)
-			fmt.Fprint(&sb, "\tif err != nil {\n\t\treturn nil, err\n\t}\n")
-		}
-	}
-
-	fmt.Fprint(&sb, "\n\ts := struct {\n")
-
-	for _, method := range methods {
-		fmt.Fprintf(&sb, "\t\t%s %s\n", method.Name, typeName(method.Out[0], pgkName))
-	}
-
-	fmt.Fprint(&sb, "\n\t}{\n")
-
-	for _, method := range methods {
-		varn := varName(method.Name)
-		fmt.Fprintf(&sb, "\t\t%s: %s,\n", method.Name, varn)
-	}
-
-	fmt.Fprint(&sb, "\n\t}\n\n")
-	fmt.Fprint(&sb, "\treturn json.Marshal(&s)\n}")
-
-	pkgImports := append(methods.Imports(), "encoding/json")
-
-	if pkgPath != "" {
-		// Exclude self
-		for i, pkgImp := range pkgImports {
-			if pkgImp == pkgPath {
-				pkgImports = slices.Delete(pkgImports, i, i+1)
-			}
-		}
-	}
-
-	return sb.String(), pkgImports
-}
-
-func collectMethodsRecursive(pkg string, f []*ast.Field) []string {
-	var methodNames []string
-	for _, m := range f {
-		if m.Names != nil {
-			methodNames = append(methodNames, m.Names[0].Name)
-			continue
-		}
-
-		if ident, ok := m.Type.(*ast.Ident); ok && ident.Obj != nil {
-			switch tt := ident.Obj.Decl.(*ast.TypeSpec).Type.(type) {
-			case *ast.InterfaceType:
-				// Embedded interface
-				methodNames = append(
-					methodNames,
-					collectMethodsRecursive(
-						pkg,
-						tt.Methods.List)...)
-			}
-		} else {
-			// Embedded, but in a different file/package. Return the
-			// package.Name and deal with that later.
-			name := packageName(m.Type)
-			if !strings.Contains(name, ".") {
-				// Assume current package
-				name = pkg + "." + name
-			}
-			methodNames = append(methodNames, name)
-		}
-	}
-
-	return methodNames
-}
-
-func firstToLower(name string) string {
-	return strings.ToLower(name[:1]) + name[1:]
-}
-
-func firstToUpper(name string) string {
-	return strings.ToUpper(name[:1]) + name[1:]
-}
-
-func packageName(e ast.Expr) string {
-	switch tp := e.(type) {
-	case *ast.Ident:
-		return tp.Name
-	case *ast.SelectorExpr:
-		return fmt.Sprintf("%s.%s", packageName(tp.X), packageName(tp.Sel))
-	}
-	return ""
-}
-
-func receiverShort(receiver string) string {
-	return strings.ToLower(trimAsterisk(receiver))[:1]
-}
-
-func trimAsterisk(name string) string {
-	return strings.TrimPrefix(name, "*")
-}
-
-func typeName(name, pkg string) string {
-	return strings.TrimPrefix(name, pkg+".")
-}
-
-func uniqueNonEmptyStrings(s []string) []string {
-	var unique []string
-	set := map[string]any{}
-	for _, val := range s {
-		if val == "" {
-			continue
-		}
-		if _, ok := set[val]; !ok {
-			unique = append(unique, val)
-			set[val] = val
-		}
-	}
-	return unique
-}
-
-func varName(name string) string {
-	name = firstToLower(name)
-
-	// Adjust some reserved keywords, see https://golang.org/ref/spec#Keywords
-	switch name {
-	case "type":
-		name = "typ"
-	case "package":
-		name = "pkg"
-		// Not reserved, but syntax highlighters has it as a keyword.
-	case "len":
-		name = "length"
-	}
-
-	return name
-}

codegen/methods2_test.go

@@ -1,20 +0,0 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package codegen
-
-type IEmbed interface {
-	MethodEmbed3(s string) string
-	MethodEmbed1() string
-	MethodEmbed2()
-}

codegen/methods_test.go

@@ -1,96 +0,0 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package codegen
-
-import (
-	"fmt"
-	"net"
-	"os"
-	"reflect"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/common/herrors"
-)
-
-func TestMethods(t *testing.T) {
-	var (
-		zeroIE     = reflect.TypeOf((*IEmbed)(nil)).Elem()
-		zeroIEOnly = reflect.TypeOf((*IEOnly)(nil)).Elem()
-		zeroI      = reflect.TypeOf((*I)(nil)).Elem()
-	)
-
-	dir, _ := os.Getwd()
-	insp := NewInspector(dir)
-
-	t.Run("MethodsFromTypes", func(t *testing.T) {
-		c := qt.New(t)
-
-		methods := insp.MethodsFromTypes([]reflect.Type{zeroI}, nil)
-
-		methodsStr := fmt.Sprint(methods)
-
-		c.Assert(methodsStr, qt.Contains, "Method1(arg0 herrors.ErrorContext)")
-		c.Assert(methodsStr, qt.Contains, "Method7() interface {}")
-		c.Assert(methodsStr, qt.Contains, "Method0() string\n Method4() string")
-		c.Assert(methodsStr, qt.Contains, "MethodEmbed3(arg0 string) string\n MethodEmbed1() string")
-
-		c.Assert(methods.Imports(), qt.Contains, "github.com/gohugoio/hugo/common/herrors")
-	})
-
-	t.Run("EmbedOnly", func(t *testing.T) {
-		c := qt.New(t)
-
-		methods := insp.MethodsFromTypes([]reflect.Type{zeroIEOnly}, nil)
-
-		methodsStr := fmt.Sprint(methods)
-
-		c.Assert(methodsStr, qt.Contains, "MethodEmbed3(arg0 string) string")
-	})
-
-	t.Run("ToMarshalJSON", func(t *testing.T) {
-		c := qt.New(t)
-
-		m, pkg := insp.MethodsFromTypes(
-			[]reflect.Type{zeroI},
-			[]reflect.Type{zeroIE}).ToMarshalJSON("*page", "page")
-
-		c.Assert(m, qt.Contains, "method6 := p.Method6()")
-		c.Assert(m, qt.Contains, "Method0: method0,")
-		c.Assert(m, qt.Contains, "return json.Marshal(&s)")
-
-		c.Assert(pkg, qt.Contains, "github.com/gohugoio/hugo/common/herrors")
-		c.Assert(pkg, qt.Contains, "encoding/json")
-
-		fmt.Println(pkg)
-	})
-}
-
-type I interface {
-	IEmbed
-	Method0() string
-	Method4() string
-	Method1(myerr herrors.ErrorContext)
-	Method3(myint int, mystring string)
-	Method5() (string, error)
-	Method6() *net.IP
-	Method7() any
-	Method8() herrors.ErrorContext
-	method2()
-	method9() os.FileInfo
-}
-
-type IEOnly interface {
-	IEmbed
-}

commands/benchmark.go

@@ -0,0 +1,115 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"time"
+
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+type benchmarkCmd struct {
+	benchmarkTimes int
+	cpuProfileFile string
+	memProfileFile string
+
+	*baseBuilderCmd
+}
+
+func (b *commandsBuilder) newBenchmarkCmd() *benchmarkCmd {
+	cmd := &cobra.Command{
+		Use:   "benchmark",
+		Short: "Benchmark Hugo by building a site a number of times.",
+		Long: `Hugo can build a site many times over and analyze the running process
+creating a benchmark.`,
+	}
+
+	c := &benchmarkCmd{baseBuilderCmd: b.newBuilderCmd(cmd)}
+
+	cmd.Flags().StringVar(&c.cpuProfileFile, "cpuprofile", "", "path/filename for the CPU profile file")
+	cmd.Flags().StringVar(&c.memProfileFile, "memprofile", "", "path/filename for the memory profile file")
+	cmd.Flags().IntVarP(&c.benchmarkTimes, "count", "n", 13, "number of times to build the site")
+	cmd.Flags().Bool("renderToMemory", false, "render to memory (only useful for benchmark testing)")
+
+	cmd.RunE = c.benchmark
+
+	return c
+}
+
+func (c *benchmarkCmd) benchmark(cmd *cobra.Command, args []string) error {
+	cfgInit := func(c *commandeer) error {
+		return nil
+	}
+
+	comm, err := initializeConfig(true, false, &c.hugoBuilderCommon, c, cfgInit)
+	if err != nil {
+		return err
+	}
+
+	var memProf *os.File
+	if c.memProfileFile != "" {
+		memProf, err = os.Create(c.memProfileFile)
+		if err != nil {
+			return err
+		}
+	}
+
+	var cpuProf *os.File
+	if c.cpuProfileFile != "" {
+		cpuProf, err = os.Create(c.cpuProfileFile)
+		if err != nil {
+			return err
+		}
+	}
+
+	var memStats runtime.MemStats
+	runtime.ReadMemStats(&memStats)
+	memAllocated := memStats.TotalAlloc
+	mallocs := memStats.Mallocs
+	if cpuProf != nil {
+		pprof.StartCPUProfile(cpuProf)
+	}
+
+	t := time.Now()
+	for i := 0; i < c.benchmarkTimes; i++ {
+		if err = comm.resetAndBuildSites(); err != nil {
+			return err
+		}
+	}
+	totalTime := time.Since(t)
+
+	if memProf != nil {
+		pprof.WriteHeapProfile(memProf)
+		memProf.Close()
+	}
+	if cpuProf != nil {
+		pprof.StopCPUProfile()
+		cpuProf.Close()
+	}
+
+	runtime.ReadMemStats(&memStats)
+	totalMemAllocated := memStats.TotalAlloc - memAllocated
+	totalMallocs := memStats.Mallocs - mallocs
+
+	jww.FEEDBACK.Println()
+	jww.FEEDBACK.Printf("Average time per operation: %vms\n", int(1000*totalTime.Seconds()/float64(c.benchmarkTimes)))
+	jww.FEEDBACK.Printf("Average memory allocated per operation: %vkB\n", totalMemAllocated/uint64(c.benchmarkTimes)/1024)
+	jww.FEEDBACK.Printf("Average allocations per operation: %v\n", totalMallocs/uint64(c.benchmarkTimes))
+
+	return nil
+}

commands/check.go

@@ -0,0 +1,34 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !darwin
+
+package commands
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var _ cmder = (*checkCmd)(nil)
+
+type checkCmd struct {
+	*baseCmd
+}
+
+func newCheckCmd() *checkCmd {
+	return &checkCmd{baseCmd: &baseCmd{cmd: &cobra.Command{
+		Use:   "check",
+		Short: "Contains some verification checks",
+	},
+	}}
+}

commands/check_darwin.go

@@ -0,0 +1,36 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"github.com/spf13/cobra"
+)
+
+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
+}

commands/commandeer.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,666 +14,323 @@
 package commands
 
 import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"log"
 	"os"
-	"os/signal"
 	"path/filepath"
-	"runtime"
+	"regexp"
-	"strings"
 	"sync"
-	"sync/atomic"
-	"syscall"
 	"time"
 
-	"go.uber.org/automaxprocs/maxprocs"
-
-	"github.com/bep/clocks"
-	"github.com/bep/lazycache"
-	"github.com/bep/logg"
-	"github.com/bep/overlayfs"
-	"github.com/bep/simplecobra"
-
-	"github.com/gohugoio/hugo/common/hstrings"
-	"github.com/gohugoio/hugo/common/htime"
-	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/paths"
-	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/config/allconfig"
+
+	"github.com/spf13/cobra"
+
+	"github.com/spf13/afero"
+
+	"github.com/gohugoio/hugo/hugolib"
+
+	"github.com/bep/debounce"
+	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/langs"
-	"github.com/gohugoio/hugo/identity"
-	"github.com/gohugoio/hugo/resources/kinds"
-	"github.com/spf13/afero"
-	"github.com/spf13/cobra"
 )
 
-var errHelp = errors.New("help requested")
+type commandeerHugoState struct {
+	*deps.DepsCfg
+	hugo     *hugolib.HugoSites
+	fsCreate sync.Once
+}
 
-// Execute executes a command.
+type commandeer struct {
-func Execute(args []string) error {
+	*commandeerHugoState
-	// Default GOMAXPROCS to be CPU limit aware, still respecting GOMAXPROCS env.
+
-	maxprocs.Set()
+	// Currently only set when in "fast render mode". But it seems to
-	x, err := newExec()
+	// be fast enough that we could maybe just add it for all server modes.
-	if err != nil {
+	changeDetector *fileChangeDetector
-		return err
+
+	// We need to reuse this on server rebuilds.
+	destinationFs afero.Fs
+
+	h    *hugoBuilderCommon
+	ftch flagsToConfigHandler
+
+	visitedURLs *types.EvictingStringQueue
+
+	doWithCommandeer func(c *commandeer) error
+
+	// We watch these for changes.
+	configFiles []string
+
+	// Used in cases where we get flooded with events in server mode.
+	debounce func(f func())
+
+	serverPorts         []int
+	languagesConfigured bool
+	languages           langs.Languages
+
+	configured bool
+}
+
+func (c *commandeer) Set(key string, value interface{}) {
+	if c.configured {
+		panic("commandeer cannot be changed")
 	}
-	args = mapLegacyArgs(args)
+	c.Cfg.Set(key, value)
-	cd, err := x.Execute(context.Background(), args)
+}
-	if cd != nil {
+
-		if closer, ok := cd.Root.Command.(types.Closer); ok {
+func (c *commandeer) initFs(fs *hugofs.Fs) error {
-			closer.Close()
+	c.destinationFs = fs.Destination
+	c.DepsCfg.Fs = fs
+
+	return nil
+}
+
+func newCommandeer(mustHaveConfigFile, running bool, h *hugoBuilderCommon, f flagsToConfigHandler, doWithCommandeer 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.
+		// It is better to wait for some seconds in those cases rather than get flooded
+		// with rebuilds.
+		rebuildDebouncer, _, _ = debounce.New(4 * time.Second)
+	}
+
+	c := &commandeer{
+		h:                   h,
+		ftch:                f,
+		commandeerHugoState: &commandeerHugoState{},
+		doWithCommandeer:    doWithCommandeer,
+		visitedURLs:         types.NewEvictingStringQueue(10),
+		debounce:            rebuildDebouncer,
+	}
+
+	return c, c.loadConfig(mustHaveConfigFile, running)
+}
+
+type fileChangeDetector struct {
+	sync.Mutex
+	current map[string]string
+	prev    map[string]string
+
+	irrelevantRe *regexp.Regexp
+}
+
+func (f *fileChangeDetector) OnFileClose(name, md5sum string) {
+	f.Lock()
+	defer f.Unlock()
+	f.current[name] = md5sum
+}
+
+func (f *fileChangeDetector) changed() []string {
+	if f == nil {
+		return nil
+	}
+	f.Lock()
+	defer f.Unlock()
+	var c []string
+	for k, v := range f.current {
+		vv, found := f.prev[k]
+		if !found || v != vv {
+			c = append(c, k)
 		}
 	}
 
-	if err != nil {
+	return f.filterIrrelevant(c)
-		if err == errHelp {
+}
-			cd.CobraCommand.Help()
+
-			fmt.Println()
+func (f *fileChangeDetector) filterIrrelevant(in []string) []string {
+	var filtered []string
+	for _, v := range in {
+		if !f.irrelevantRe.MatchString(v) {
+			filtered = append(filtered, v)
+		}
+	}
+	return filtered
+}
+
+func (f *fileChangeDetector) PrepareNew() {
+	if f == nil {
+		return
+	}
+
+	f.Lock()
+	defer f.Unlock()
+
+	if f.current == nil {
+		f.current = make(map[string]string)
+		f.prev = make(map[string]string)
+		return
+	}
+
+	f.prev = make(map[string]string)
+	for k, v := range f.current {
+		f.prev[k] = v
+	}
+	f.current = make(map[string]string)
+}
+
+func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
+
+	if c.DepsCfg == nil {
+		c.DepsCfg = &deps.DepsCfg{}
+	}
+
+	cfg := c.DepsCfg
+	c.configured = false
+	cfg.Running = running
+
+	var dir string
+	if c.h.source != "" {
+		dir, _ = filepath.Abs(c.h.source)
+	} else {
+		dir, _ = os.Getwd()
+	}
+
+	var sourceFs afero.Fs = hugofs.Os
+	if c.DepsCfg.Fs != nil {
+		sourceFs = c.DepsCfg.Fs.Source
+	}
+
+	doWithConfig := func(cfg config.Provider) error {
+
+		if c.ftch != nil {
+			c.ftch.flagsToConfig(cfg)
+		}
+
+		cfg.Set("workingDir", dir)
+
+		return nil
+	}
+
+	doWithCommandeer := func(cfg config.Provider) error {
+		c.Cfg = cfg
+		if c.doWithCommandeer == nil {
 			return nil
 		}
-		if simplecobra.IsCommandError(err) {
+		err := c.doWithCommandeer(c)
-			// Print the help, but also return the error to fail the command.
-			cd.CobraCommand.Help()
-			fmt.Println()
-		}
-	}
-	return err
-}
-
-type commonConfig struct {
-	mu      *sync.Mutex
-	configs *allconfig.Configs
-	cfg     config.Provider
-	fs      *hugofs.Fs
-}
-
-type configKey struct {
-	counter                    int32
-	ignoreModulesDoesNotExists bool
-}
-
-// This is the root command.
-type rootCommand struct {
-	Printf  func(format string, v ...any)
-	Println func(a ...any)
-	StdOut  io.Writer
-	StdErr  io.Writer
-
-	logger loggers.Logger
-
-	// The main cache busting key for the caches below.
-	configVersionID atomic.Int32
-
-	// Some, but not all commands need access to these.
-	// Some needs more than one, so keep them in a small cache.
-	commonConfigs *lazycache.Cache[configKey, *commonConfig]
-	hugoSites     *lazycache.Cache[configKey, *hugolib.HugoSites]
-
-	// changesFromBuild received from Hugo in watch mode.
-	changesFromBuild chan []identity.Identity
-
-	commands []simplecobra.Commander
-
-	// Flags
-	source      string
-	buildWatch  bool
-	environment string
-
-	// Common build flags.
-	baseURL         string
-	gc              bool
-	poll            string
-	forceSyncStatic bool
-
-	// Profile flags (for debugging of performance problems)
-	cpuprofile   string
-	memprofile   string
-	mutexprofile string
-	traceprofile string
-	printm       bool
-
-	logLevel string
-
-	quiet   bool
-	devMode bool // Hidden flag.
-
-	renderToMemory bool
-
-	cfgFile string
-	cfgDir  string
-}
-
-func (r *rootCommand) isVerbose() bool {
-	return r.logger.Level() <= logg.LevelInfo
-}
-
-func (r *rootCommand) Close() error {
-	if r.hugoSites != nil {
-		r.hugoSites.DeleteFunc(func(key configKey, value *hugolib.HugoSites) bool {
-			if value != nil {
-				value.Close()
-			}
-			return false
-		})
-	}
-	return nil
-}
-
-func (r *rootCommand) Build(cd *simplecobra.Commandeer, bcfg hugolib.BuildCfg, cfg config.Provider) (*hugolib.HugoSites, error) {
-	h, err := r.Hugo(cfg)
-	if err != nil {
-		return nil, err
-	}
-	if err := h.Build(bcfg); err != nil {
-		return nil, err
-	}
-
-	return h, nil
-}
-
-func (r *rootCommand) Commands() []simplecobra.Commander {
-	return r.commands
-}
-
-func (r *rootCommand) ConfigFromConfig(key configKey, oldConf *commonConfig) (*commonConfig, error) {
-	cc, _, err := r.commonConfigs.GetOrCreate(key, func(key configKey) (*commonConfig, error) {
-		fs := oldConf.fs
-		configs, err := allconfig.LoadConfig(
-			allconfig.ConfigSourceDescriptor{
-				Flags:                    oldConf.cfg,
-				Fs:                       fs.Source,
-				Filename:                 r.cfgFile,
-				ConfigDir:                r.cfgDir,
-				Logger:                   r.logger,
-				Environment:              r.environment,
-				IgnoreModuleDoesNotExist: key.ignoreModulesDoesNotExists,
-			},
-		)
-		if err != nil {
-			return nil, err
-		}
-
-		if !configs.Base.C.Clock.IsZero() {
-			// TODO(bep) find a better place for this.
-			htime.Clock = clocks.Start(configs.Base.C.Clock)
-		}
-
-		return &commonConfig{
-			mu:      oldConf.mu,
-			configs: configs,
-			cfg:     oldConf.cfg,
-			fs:      fs,
-		}, nil
-	})
-
-	return cc, err
-}
-
-func (r *rootCommand) ConfigFromProvider(key configKey, cfg config.Provider) (*commonConfig, error) {
-	if cfg == nil {
-		panic("cfg must be set")
-	}
-	cc, _, err := r.commonConfigs.GetOrCreate(key, func(key configKey) (*commonConfig, error) {
-		var dir string
-		if r.source != "" {
-			dir, _ = filepath.Abs(r.source)
-		} else {
-			dir, _ = os.Getwd()
-		}
-
-		if cfg == nil {
-			cfg = config.New()
-		}
-
-		if !cfg.IsSet("workingDir") {
-			cfg.Set("workingDir", dir)
-		} else {
-			if err := os.MkdirAll(cfg.GetString("workingDir"), 0o777); err != nil {
-				return nil, fmt.Errorf("failed to create workingDir: %w", err)
-			}
-		}
-
-		// Load the config first to allow publishDir to be configured in config file.
-		configs, err := allconfig.LoadConfig(
-			allconfig.ConfigSourceDescriptor{
-				Flags:                    cfg,
-				Fs:                       hugofs.Os,
-				Filename:                 r.cfgFile,
-				ConfigDir:                r.cfgDir,
-				Environment:              r.environment,
-				Logger:                   r.logger,
-				IgnoreModuleDoesNotExist: key.ignoreModulesDoesNotExists,
-			},
-		)
-		if err != nil {
-			return nil, err
-		}
-
-		base := configs.Base
-
-		cfg.Set("publishDir", base.PublishDir)
-		cfg.Set("publishDirStatic", base.PublishDir)
-		cfg.Set("publishDirDynamic", base.PublishDir)
-
-		renderStaticToDisk := cfg.GetBool("renderStaticToDisk")
-
-		sourceFs := hugofs.Os
-		var destinationFs afero.Fs
-		if cfg.GetBool("renderToMemory") {
-			destinationFs = afero.NewMemMapFs()
-			if renderStaticToDisk {
-				// Hybrid, render dynamic content to Root.
-				cfg.Set("publishDirDynamic", "/")
-			} else {
-				// Rendering to memoryFS, publish to Root regardless of publishDir.
-				cfg.Set("publishDirDynamic", "/")
-				cfg.Set("publishDirStatic", "/")
-			}
-		} else {
-			destinationFs = hugofs.Os
-		}
-
-		fs := hugofs.NewFromSourceAndDestination(sourceFs, destinationFs, cfg)
-
-		if renderStaticToDisk {
-			dynamicFs := fs.PublishDir
-			publishDirStatic := cfg.GetString("publishDirStatic")
-			workingDir := cfg.GetString("workingDir")
-			absPublishDirStatic := paths.AbsPathify(workingDir, publishDirStatic)
-			staticFs := hugofs.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
-
-		}
-
-		if !base.C.Clock.IsZero() {
-			// TODO(bep) find a better place for this.
-			htime.Clock = clocks.Start(configs.Base.C.Clock)
-		}
-
-		if base.PrintPathWarnings {
-			// Note that we only care about the "dynamic creates" here,
-			// so skip the static fs.
-			fs.PublishDir = hugofs.NewCreateCountingFs(fs.PublishDir)
-		}
-
-		commonConfig := &commonConfig{
-			mu:      &sync.Mutex{},
-			configs: configs,
-			cfg:     cfg,
-			fs:      fs,
-		}
-
-		return commonConfig, nil
-	})
-
-	return cc, err
-}
-
-func (r *rootCommand) HugFromConfig(conf *commonConfig) (*hugolib.HugoSites, error) {
-	k := configKey{counter: r.configVersionID.Load()}
-	h, _, err := r.hugoSites.GetOrCreate(k, func(key configKey) (*hugolib.HugoSites, error) {
-		depsCfg := r.newDepsConfig(conf)
-		return hugolib.NewHugoSites(depsCfg)
-	})
-	return h, err
-}
-
-func (r *rootCommand) Hugo(cfg config.Provider) (*hugolib.HugoSites, error) {
-	return r.getOrCreateHugo(cfg, false)
-}
-
-func (r *rootCommand) getOrCreateHugo(cfg config.Provider, ignoreModuleDoesNotExist bool) (*hugolib.HugoSites, error) {
-	k := configKey{counter: r.configVersionID.Load(), ignoreModulesDoesNotExists: ignoreModuleDoesNotExist}
-	h, _, err := r.hugoSites.GetOrCreate(k, func(key configKey) (*hugolib.HugoSites, error) {
-		conf, err := r.ConfigFromProvider(key, cfg)
-		if err != nil {
-			return nil, err
-		}
-		depsCfg := r.newDepsConfig(conf)
-		return hugolib.NewHugoSites(depsCfg)
-	})
-	return h, err
-}
-
-func (r *rootCommand) newDepsConfig(conf *commonConfig) deps.DepsCfg {
-	return deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, StdOut: r.logger.StdOut(), StdErr: r.logger.StdErr(), LogLevel: r.logger.Level(), ChangesFromBuild: r.changesFromBuild}
-}
-
-func (r *rootCommand) Name() string {
-	return "hugo"
-}
-
-func (r *rootCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	b := newHugoBuilder(r, nil)
-
-	if !r.buildWatch {
-		defer b.postBuild("Total", time.Now())
-	}
-
-	if err := b.loadConfig(cd, false); err != nil {
 		return err
 	}
 
-	err := func() error {
+	config, configFiles, err := hugolib.LoadConfig(
-		if r.buildWatch {
+		hugolib.ConfigSourceDescriptor{Fs: sourceFs, Path: c.h.source, WorkingDir: dir, Filename: c.h.cfgFile},
-			defer r.timeTrack(time.Now(), "Built")
+		doWithCommandeer,
-		}
+		doWithConfig)
-		err := b.build()
+
-		if err != nil {
+	if err != nil {
+		if mustHaveConfigFile {
 			return err
 		}
-		return nil
+		if err != hugolib.ErrNoConfigFile {
-	}()
+			return err
-	if err != nil {
+		}
-		return err
+
 	}
 
-	if !r.buildWatch {
+	c.configFiles = configFiles
-		// Done.
+
-		return nil
+	if l, ok := c.Cfg.Get("languagesSorted").(langs.Languages); ok {
+		c.languagesConfigured = true
+		c.languages = l
 	}
 
-	watchDirs, err := b.getDirList()
+	// This is potentially double work, but we need to do this one more time now
-	if err != nil {
+	// that all the languages have been configured.
-		return err
+	if c.doWithCommandeer != nil {
-	}
+		if err := c.doWithCommandeer(c); err != nil {
-
+			return err
-	watchGroups := helpers.ExtractAndGroupRootPaths(watchDirs)
-
-	for _, group := range watchGroups {
-		r.Printf("Watching for changes in %s\n", group)
-	}
-	watcher, err := b.newWatcher(r.poll, watchDirs...)
-	if err != nil {
-		return err
-	}
-
-	defer watcher.Close()
-
-	r.Println("Press Ctrl+C to stop")
-
-	sigs := make(chan os.Signal, 1)
-	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
-
-	<-sigs
-
-	return nil
-}
-
-func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	r.StdOut = os.Stdout
-	r.StdErr = os.Stderr
-	if r.quiet {
-		r.StdOut = io.Discard
-		r.StdErr = io.Discard
-	}
-	// Used by mkcert (server).
-	log.SetOutput(r.StdOut)
-
-	r.Printf = func(format string, v ...any) {
-		if !r.quiet {
-			fmt.Fprintf(r.StdOut, format, v...)
 		}
 	}
-	r.Println = func(a ...any) {
+
-		if !r.quiet {
+	logger, err := c.createLogger(config)
-			fmt.Fprintln(r.StdOut, a...)
-		}
-	}
-	_, running := runner.Command.(*serverCommand)
-	var err error
-	r.logger, err = r.createLogger(running)
 	if err != nil {
 		return err
 	}
-	// Set up the global logger early to allow info deprecations during config load.
-	loggers.SetGlobalLogger(r.logger)
 
-	r.changesFromBuild = make(chan []identity.Identity, 10)
+	cfg.Logger = logger
+
+	createMemFs := config.GetBool("renderToMemory")
+
+	if createMemFs {
+		// Rendering to memoryFS, publish to Root regardless of publishDir.
+		config.Set("publishDir", "/")
+	}
+
+	c.fsCreate.Do(func() {
+		fs := hugofs.NewFrom(sourceFs, config)
+
+		if c.destinationFs != 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)
+		}
+
+		doLiveReload := !c.h.buildWatch && !config.GetBool("disableLiveReload")
+		fastRenderMode := doLiveReload && !config.GetBool("disableFastRender")
+
+		if fastRenderMode {
+			// For now, fast render mode only. It should, however, be fast enough
+			// for the full variant, too.
+			changeDetector := &fileChangeDetector{
+				// We use this detector to decide to do a Hot reload of a single path or not.
+				// We need to filter out source maps and possibly some other to be able
+				// to make that decision.
+				irrelevantRe: regexp.MustCompile(`\.map$`),
+			}
+			changeDetector.PrepareNew()
+			fs.Destination = hugofs.NewHashingFs(fs.Destination, changeDetector)
+			c.changeDetector = changeDetector
+		}
+
+		err = c.initFs(fs)
+		if err != nil {
+			return
+		}
+
+		var h *hugolib.HugoSites
+
+		h, err = hugolib.NewHugoSites(*c.DepsCfg)
+		c.hugo = h
 
-	r.commonConfigs = lazycache.New(lazycache.Options[configKey, *commonConfig]{MaxEntries: 5})
-	// We don't want to keep stale HugoSites in memory longer than needed.
-	r.hugoSites = lazycache.New(lazycache.Options[configKey, *hugolib.HugoSites]{
-		MaxEntries: 1,
-		OnEvict: func(key configKey, value *hugolib.HugoSites) {
-			value.Close()
-			runtime.GC()
-		},
 	})
 
-	return nil
+	if err != nil {
-}
+		return err
+	}
 
-func (r *rootCommand) createLogger(running bool) (loggers.Logger, error) {
+	cacheDir := config.GetString("cacheDir")
-	level := logg.LevelWarn
+	if cacheDir != "" {
-
+		if helpers.FilePathSeparator != cacheDir[len(cacheDir)-1:] {
-	if r.devMode {
+			cacheDir = cacheDir + helpers.FilePathSeparator
-		level = logg.LevelTrace
+		}
+		isDir, err := helpers.DirExists(cacheDir, sourceFs)
+		checkErr(cfg.Logger, err)
+		if !isDir {
+			mkdir(cacheDir)
+		}
+		config.Set("cacheDir", cacheDir)
 	} else {
-		if r.logLevel != "" {
+		config.Set("cacheDir", helpers.GetTempDir("hugo_cache", sourceFs))
-			switch strings.ToLower(r.logLevel) {
+	}
-			case "debug":
+
-				level = logg.LevelDebug
+	cfg.Logger.INFO.Println("Using config file:", config.ConfigFileUsed())
-			case "info":
+
-				level = logg.LevelInfo
+	themeDir := c.hugo.PathSpec.GetFirstThemeDir()
-			case "warn", "warning":
+	if themeDir != "" {
-				level = logg.LevelWarn
+		if _, err := sourceFs.Stat(themeDir); os.IsNotExist(err) {
-			case "error":
+			return newSystemError("Unable to find theme Directory:", themeDir)
-				level = logg.LevelError
-			default:
-				return nil, fmt.Errorf("invalid log level: %q, must be one of debug, warn, info or error", r.logLevel)
-			}
 		}
 	}
 
-	optsLogger := loggers.Options{
+	themeVersionMismatch, minVersion := c.isThemeVsHugoVersionMismatch(sourceFs)
-		DistinctLevel: logg.LevelWarn,
+
-		Level:         level,
+	if themeVersionMismatch {
-		StdOut:        r.StdOut,
+		cfg.Logger.ERROR.Printf("Current theme does not support Hugo version %s. Minimum version required is %s\n",
-		StdErr:        r.StdErr,
+			helpers.CurrentHugoVersion.ReleaseVersion(), minVersion)
-		StoreErrors:   running,
 	}
 
-	return loggers.New(optsLogger), nil
-}
-
-func (r *rootCommand) resetLogs() {
-	r.logger.Reset()
-	loggers.Log().Reset()
-}
-
-// IsTestRun reports whether the command is running as a test.
-func (r *rootCommand) IsTestRun() bool {
-	return os.Getenv("HUGO_TESTRUN") != ""
-}
-
-func (r *rootCommand) Init(cd *simplecobra.Commandeer) error {
-	return r.initRootCommand("", cd)
-}
-
-func (r *rootCommand) initRootCommand(subCommandName string, cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	commandName := "hugo"
-	if subCommandName != "" {
-		commandName = subCommandName
-	}
-	cmd.Use = fmt.Sprintf("%s [flags]", commandName)
-	cmd.Short = "Build your site"
-	cmd.Long = `COMMAND_NAME is the main command, used to build your Hugo site.
-
-Hugo is a Fast and Flexible Static Site Generator
-built with love by spf13 and friends in Go.
-
-Complete documentation is available at https://gohugo.io/.`
-
-	cmd.Long = strings.ReplaceAll(cmd.Long, "COMMAND_NAME", commandName)
-
-	// Configure persistent flags
-	cmd.PersistentFlags().StringVarP(&r.source, "source", "s", "", "filesystem path to read files relative from")
-	_ = cmd.MarkFlagDirname("source")
-	cmd.PersistentFlags().StringP("destination", "d", "", "filesystem path to write files to")
-	_ = cmd.MarkFlagDirname("destination")
-
-	cmd.PersistentFlags().StringVarP(&r.environment, "environment", "e", "", "build environment")
-	_ = cmd.RegisterFlagCompletionFunc("environment", cobra.NoFileCompletions)
-	cmd.PersistentFlags().StringP("themesDir", "", "", "filesystem path to themes directory")
-	_ = cmd.MarkFlagDirname("themesDir")
-	cmd.PersistentFlags().StringP("ignoreVendorPaths", "", "", "ignores any _vendor for module paths matching the given Glob pattern")
-	cmd.PersistentFlags().BoolP("noBuildLock", "", false, "don't create .hugo_build.lock file")
-	_ = cmd.RegisterFlagCompletionFunc("ignoreVendorPaths", cobra.NoFileCompletions)
-	cmd.PersistentFlags().String("clock", "", "set the clock used by Hugo, e.g. --clock 2021-11-06T22:30:00.00+09:00")
-	_ = cmd.RegisterFlagCompletionFunc("clock", cobra.NoFileCompletions)
-
-	cmd.PersistentFlags().StringVar(&r.cfgFile, "config", "", "config file (default is hugo.yaml|json|toml)")
-	_ = cmd.MarkFlagFilename("config", config.ValidConfigFileExtensions...)
-	cmd.PersistentFlags().StringVar(&r.cfgDir, "configDir", "config", "config dir")
-	_ = cmd.MarkFlagDirname("configDir")
-	cmd.PersistentFlags().BoolVar(&r.quiet, "quiet", false, "build in quiet mode")
-	cmd.PersistentFlags().BoolVarP(&r.renderToMemory, "renderToMemory", "M", false, "render to memory (mostly useful when running the server)")
-
-	cmd.PersistentFlags().BoolVarP(&r.devMode, "devMode", "", false, "only used for internal testing, flag hidden.")
-	cmd.PersistentFlags().StringVar(&r.logLevel, "logLevel", "", "log level (debug|info|warn|error)")
-	_ = cmd.RegisterFlagCompletionFunc("logLevel", cobra.FixedCompletions([]string{"debug", "info", "warn", "error"}, cobra.ShellCompDirectiveNoFileComp))
-	cmd.Flags().BoolVarP(&r.buildWatch, "watch", "w", false, "watch filesystem for changes and recreate as needed")
-
-	cmd.PersistentFlags().MarkHidden("devMode")
-
-	// Configure local flags
-	applyLocalFlagsBuild(cmd, r)
-
 	return nil
-}
+
-
-// A sub set of the complete build flags. These flags are used by new and mod.
-func applyLocalFlagsBuildConfig(cmd *cobra.Command, r *rootCommand) {
-	cmd.Flags().StringSliceP("theme", "t", []string{}, "themes to use (located in /themes/THEMENAME/)")
-	_ = cmd.MarkFlagDirname("theme")
-	cmd.Flags().StringVarP(&r.baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. https://spf13.com/")
-	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory")
-	_ = cmd.MarkFlagDirname("cacheDir")
-	cmd.Flags().StringP("contentDir", "c", "", "filesystem path to content directory")
-	cmd.Flags().StringSliceP("renderSegments", "", []string{}, "named segments to render (configured in the segments config)")
-}
-
-// Flags needed to do a build (used by hugo and hugo server commands)
-func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
-	applyLocalFlagsBuildConfig(cmd, r)
-	cmd.Flags().Bool("cleanDestinationDir", false, "remove files from destination not found in static directories")
-	cmd.Flags().BoolP("buildDrafts", "D", false, "include content marked as draft")
-	cmd.Flags().BoolP("buildFuture", "F", false, "include content with publishdate in the future")
-	cmd.Flags().BoolP("buildExpired", "E", false, "include expired content")
-	cmd.Flags().BoolP("ignoreCache", "", false, "ignores the cache directory")
-	cmd.Flags().Bool("enableGitInfo", false, "add Git revision, date, author, and CODEOWNERS info to the pages")
-	cmd.Flags().StringP("layoutDir", "l", "", "filesystem path to layout directory")
-	_ = cmd.MarkFlagDirname("layoutDir")
-	cmd.Flags().BoolVar(&r.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
-	cmd.Flags().StringVar(&r.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.RegisterFlagCompletionFunc("poll", cobra.NoFileCompletions)
-	cmd.Flags().Bool("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().BoolVar(&r.forceSyncStatic, "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("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(&r.cpuprofile, "profile-cpu", "", "", "write cpu profile to `file`")
-	cmd.Flags().StringVarP(&r.memprofile, "profile-mem", "", "", "write memory profile to `file`")
-	cmd.Flags().BoolVarP(&r.printm, "printMemoryUsage", "", false, "print memory usage to screen at intervals")
-	cmd.Flags().StringVarP(&r.mutexprofile, "profile-mutex", "", "", "write Mutex profile to `file`")
-	cmd.Flags().StringVarP(&r.traceprofile, "trace", "", "", "write trace to `file` (not useful in general)")
-
-	// Hide these for now.
-	cmd.Flags().MarkHidden("profile-cpu")
-	cmd.Flags().MarkHidden("profile-mem")
-	cmd.Flags().MarkHidden("profile-mutex")
-
-	cmd.Flags().StringSlice("disableKinds", []string{}, "disable different kind of pages (home, RSS etc.)")
-	_ = cmd.RegisterFlagCompletionFunc("disableKinds", cobra.FixedCompletions(kinds.AllKinds, cobra.ShellCompDirectiveNoFileComp))
-	cmd.Flags().Bool("minify", false, "minify any supported output format (HTML, XML etc.)")
-}
-
-func (r *rootCommand) timeTrack(start time.Time, name string) {
-	elapsed := time.Since(start)
-	r.Printf("%s in %v ms\n", name, int(1000*elapsed.Seconds()))
-}
-
-type simpleCommand struct {
-	use   string
-	name  string
-	short string
-	long  string
-	run   func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *rootCommand, args []string) error
-	withc func(cmd *cobra.Command, r *rootCommand)
-	initc func(cd *simplecobra.Commandeer) error
-
-	commands []simplecobra.Commander
-
-	rootCmd *rootCommand
-}
-
-func (c *simpleCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *simpleCommand) Name() string {
-	return c.name
-}
-
-func (c *simpleCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	if c.run == nil {
-		return nil
-	}
-	return c.run(ctx, cd, c.rootCmd, args)
-}
-
-func (c *simpleCommand) Init(cd *simplecobra.Commandeer) error {
-	c.rootCmd = cd.Root.Command.(*rootCommand)
-	cmd := cd.CobraCommand
-	cmd.Short = c.short
-	cmd.Long = c.long
-	if c.use != "" {
-		cmd.Use = c.use
-	}
-	if c.withc != nil {
-		c.withc(cmd, c.rootCmd)
-	}
-	return nil
-}
-
-func (c *simpleCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	if c.initc != nil {
-		return c.initc(cd)
-	}
-	return nil
-}
-
-func mapLegacyArgs(args []string) []string {
-	if len(args) > 1 && args[0] == "new" && !hstrings.EqualAny(args[1], "site", "theme", "content") {
-		// Insert "content" as the second argument
-		args = append(args[:1], append([]string{"content"}, args[1:]...)...)
-	}
-	return args
 }

commands/commands.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2017 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,60 +14,269 @@
 package commands
 
 import (
-	"context"
+	"os"
 
-	"github.com/bep/simplecobra"
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+
+	"github.com/spf13/nitro"
 )
 
-// newExec wires up all of Hugo's CLI.
+type commandsBuilder struct {
-func newExec() (*simplecobra.Exec, error) {
+	hugoBuilderCommon
-	rootCmd := &rootCommand{
+
-		commands: []simplecobra.Commander{
+	commands []cmder
-			newHugoBuildCmd(),
+}
-			newVersionCmd(),
+
-			newEnvCommand(),
+func newCommandsBuilder() *commandsBuilder {
-			newServerCommand(),
+	return &commandsBuilder{}
-			newDeployCommand(),
+}
-			newConfigCommand(),
+
-			newNewCommand(),
+func (b *commandsBuilder) addCommands(commands ...cmder) *commandsBuilder {
-			newConvertCommand(),
+	b.commands = append(b.commands, commands...)
-			newImportCommand(),
+	return b
-			newListCommand(),
+}
-			newModCommands(),
+
-			newGenCommand(),
+func (b *commandsBuilder) addAll() *commandsBuilder {
-			newReleaseCommand(),
+	b.addCommands(
-		},
+		b.newServerCmd(),
+		newVersionCmd(),
+		newEnvCmd(),
+		newConfigCmd(),
+		newCheckCmd(),
+		b.newBenchmarkCmd(),
+		newConvertCmd(),
+		newNewCmd(),
+		newListCmd(),
+		newImportCmd(),
+		newGenCmd(),
+		createReleaser(),
+	)
+
+	return b
+}
+
+func (b *commandsBuilder) build() *hugoCmd {
+	h := b.newHugoCmd()
+	addCommands(h.getCommand(), b.commands...)
+	return h
+}
+
+func addCommands(root *cobra.Command, commands ...cmder) {
+	for _, command := range commands {
+		cmd := command.getCommand()
+		if cmd == nil {
+			continue
+		}
+		root.AddCommand(cmd)
 	}
-
-	return simplecobra.New(rootCmd)
 }
 
-func newHugoBuildCmd() simplecobra.Commander {
+type baseCmd struct {
-	return &hugoBuildCommand{}
+	cmd *cobra.Command
 }
 
-// hugoBuildCommand just delegates to the rootCommand.
+var _ commandsBuilderGetter = (*baseBuilderCmd)(nil)
-type hugoBuildCommand struct {
+
-	rootCmd *rootCommand
+// Used in tests.
+type commandsBuilderGetter interface {
+	getCmmandsBuilder() *commandsBuilder
+}
+type baseBuilderCmd struct {
+	*baseCmd
+	*commandsBuilder
 }
 
-func (c *hugoBuildCommand) Commands() []simplecobra.Commander {
+func (b *baseBuilderCmd) getCmmandsBuilder() *commandsBuilder {
+	return b.commandsBuilder
+}
+
+func (c *baseCmd) getCommand() *cobra.Command {
+	return c.cmd
+}
+
+func newBaseCmd(cmd *cobra.Command) *baseCmd {
+	return &baseCmd{cmd: cmd}
+}
+
+func (b *commandsBuilder) newBuilderCmd(cmd *cobra.Command) *baseBuilderCmd {
+	bcmd := &baseBuilderCmd{commandsBuilder: b, baseCmd: &baseCmd{cmd: cmd}}
+	bcmd.hugoBuilderCommon.handleFlags(cmd)
+	return bcmd
+}
+
+func (c *baseCmd) flagsToConfig(cfg config.Provider) {
+	initializeFlags(c.cmd, cfg)
+}
+
+type hugoCmd struct {
+	*baseBuilderCmd
+
+	// Need to get the sites once built.
+	c *commandeer
+}
+
+var _ cmder = (*nilCommand)(nil)
+
+type nilCommand struct {
+}
+
+func (c *nilCommand) getCommand() *cobra.Command {
 	return nil
 }
 
-func (c *hugoBuildCommand) Name() string {
+func (c *nilCommand) flagsToConfig(cfg config.Provider) {
-	return "build"
+
 }
 
-func (c *hugoBuildCommand) Init(cd *simplecobra.Commandeer) error {
+func (b *commandsBuilder) newHugoCmd() *hugoCmd {
-	c.rootCmd = cd.Root.Command.(*rootCommand)
+	cc := &hugoCmd{}
-	return c.rootCmd.initRootCommand("build", cd)
+
+	cc.baseBuilderCmd = b.newBuilderCmd(&cobra.Command{
+		Use:   "hugo",
+		Short: "hugo builds your site",
+		Long: `hugo is the main command, used to build your Hugo site.
+
+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/.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfgInit := func(c *commandeer) error {
+				if cc.buildWatch {
+					c.Set("disableLiveReload", true)
+				}
+				return nil
+			}
+
+			c, err := initializeConfig(true, cc.buildWatch, &cc.hugoBuilderCommon, cc, cfgInit)
+			if err != nil {
+				return err
+			}
+			cc.c = c
+
+			return c.build()
+		},
+	})
+
+	cc.cmd.PersistentFlags().StringVar(&cc.cfgFile, "config", "", "config file (default is path/config.yaml|json|toml)")
+	cc.cmd.PersistentFlags().BoolVar(&cc.quiet, "quiet", false, "build in quiet mode")
+
+	// Set bash-completion
+	validConfigFilenames := []string{"json", "js", "yaml", "yml", "toml", "tml"}
+	_ = cc.cmd.PersistentFlags().SetAnnotation("config", cobra.BashCompFilenameExt, validConfigFilenames)
+
+	cc.cmd.PersistentFlags().BoolVarP(&cc.verbose, "verbose", "v", false, "verbose output")
+	cc.cmd.PersistentFlags().BoolVarP(&cc.debug, "debug", "", false, "debug output")
+	cc.cmd.PersistentFlags().BoolVar(&cc.logging, "log", false, "enable Logging")
+	cc.cmd.PersistentFlags().StringVar(&cc.logFile, "logFile", "", "log File path (if set, logging enabled automatically)")
+	cc.cmd.PersistentFlags().BoolVar(&cc.verboseLog, "verboseLog", false, "verbose logging")
+
+	cc.cmd.Flags().BoolVarP(&cc.buildWatch, "watch", "w", false, "watch filesystem for changes and recreate as needed")
+
+	cc.cmd.Flags().Bool("renderToMemory", false, "render to memory (only useful for benchmark testing)")
+
+	// Set bash-completion
+	_ = cc.cmd.PersistentFlags().SetAnnotation("logFile", cobra.BashCompFilenameExt, []string{})
+
+	cc.cmd.SetGlobalNormalizationFunc(helpers.NormalizeHugoFlags)
+	cc.cmd.SilenceUsage = true
+
+	return cc
 }
 
-func (c *hugoBuildCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
+type hugoBuilderCommon struct {
-	return c.rootCmd.PreRun(cd, runner)
+	source  string
+	baseURL string
+
+	buildWatch bool
+
+	gc bool
+
+	// TODO(bep) var vs string
+	logging    bool
+	verbose    bool
+	verboseLog bool
+	debug      bool
+	quiet      bool
+
+	cfgFile string
+	logFile string
 }
 
-func (c *hugoBuildCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
+func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
-	return c.rootCmd.Run(ctx, cd, args)
+	cmd.Flags().Bool("cleanDestinationDir", false, "remove files from destination not found in static directories")
+	cmd.Flags().BoolP("buildDrafts", "D", false, "include content marked as draft")
+	cmd.Flags().BoolP("buildFuture", "F", false, "include content with publishdate in the future")
+	cmd.Flags().BoolP("buildExpired", "E", false, "include expired content")
+	cmd.Flags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
+	cmd.Flags().StringP("contentDir", "c", "", "filesystem path to content directory")
+	cmd.Flags().StringP("layoutDir", "l", "", "filesystem path to layout directory")
+	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/")
+	cmd.Flags().BoolP("ignoreCache", "", false, "ignores the cache directory")
+	cmd.Flags().StringP("destination", "d", "", "filesystem path to write files to")
+	cmd.Flags().StringP("theme", "t", "", "theme to use (located in /themes/THEMENAME/)")
+	cmd.Flags().StringP("themesDir", "", "", "filesystem path to themes directory")
+	cmd.Flags().Bool("uglyURLs", false, "(deprecated) if true, use /filename.html instead of /filename/")
+	cmd.Flags().Bool("canonifyURLs", false, "(deprecated) if true, all relative URLs will be canonicalized using baseURL")
+	cmd.Flags().StringVarP(&cc.baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. http://spf13.com/")
+	cmd.Flags().Bool("enableGitInfo", false, "add Git revision, date and author info to the pages")
+	cmd.Flags().BoolVar(&cc.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
+
+	cmd.Flags().BoolVar(&nitro.AnalysisOn, "stepAnalysis", false, "display memory and timing of different steps of the program")
+	cmd.Flags().Bool("templateMetrics", false, "display metrics about template executions")
+	cmd.Flags().Bool("templateMetricsHints", false, "calculate some improvement hints when combined with --templateMetrics")
+	cmd.Flags().Bool("pluralizeListTitles", true, "(deprecated) pluralize titles in lists using inflect")
+	cmd.Flags().Bool("preserveTaxonomyNames", false, `(deprecated) preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")`)
+	cmd.Flags().BoolP("forceSyncStatic", "", false, "copy all files when static is changed.")
+	cmd.Flags().BoolP("noTimes", "", false, "don't sync modification time of files")
+	cmd.Flags().BoolP("noChmod", "", false, "don't sync permission mode of files")
+	cmd.Flags().BoolP("i18n-warnings", "", false, "print missing translations")
+
+	cmd.Flags().StringSlice("disableKinds", []string{}, "disable different kind of pages (home, RSS etc.)")
+
+	// Set bash-completion.
+	// Each flag must first be defined before using the SetAnnotation() call.
+	_ = cmd.Flags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.Flags().SetAnnotation("cacheDir", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.Flags().SetAnnotation("destination", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
+}
+
+func checkErr(logger *jww.Notepad, err error, s ...string) {
+	if err == nil {
+		return
+	}
+	if len(s) == 0 {
+		logger.CRITICAL.Println(err)
+		return
+	}
+	for _, message := range s {
+		logger.ERROR.Println(message)
+	}
+	logger.ERROR.Println(err)
+}
+
+func stopOnErr(logger *jww.Notepad, err error, s ...string) {
+	if err == nil {
+		return
+	}
+
+	defer os.Exit(-1)
+
+	if len(s) == 0 {
+		newMessage := err.Error()
+		// Printing an empty string results in a error with
+		// no message, no bueno.
+		if newMessage != "" {
+			logger.CRITICAL.Println(newMessage)
+		}
+	}
+	for _, message := range s {
+		if message != "" {
+			logger.CRITICAL.Println(message)
+		}
+	}
 }

commands/commands_test.go

@@ -0,0 +1,253 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestExecute(t *testing.T) {
+
+	assert := require.New(t)
+
+	dir, err := createSimpleTestSite(t)
+	assert.NoError(err)
+
+	defer func() {
+		os.RemoveAll(dir)
+	}()
+
+	resp := Execute([]string{"-s=" + dir})
+	assert.NoError(resp.Err)
+	result := resp.Result
+	assert.True(len(result.Sites) == 1)
+	assert.True(len(result.Sites[0].RegularPages) == 1)
+}
+
+func TestCommandsPersistentFlags(t *testing.T) {
+	assert := require.New(t)
+
+	noOpRunE := func(cmd *cobra.Command, args []string) error {
+		return nil
+	}
+
+	tests := []struct {
+		args  []string
+		check func(command []cmder)
+	}{{[]string{"server",
+		"--config=myconfig.toml",
+		"--contentDir=mycontent",
+		"--disableKinds=page,home",
+		"--layoutDir=mylayouts",
+		"--theme=mytheme",
+		"--gc",
+		"--themesDir=mythemes",
+		"--cleanDestinationDir",
+		"--navigateToChanged",
+		"--disableLiveReload",
+		"--noHTTPCache",
+		"--i18n-warnings",
+		"--destination=/tmp/mydestination",
+		"-b=https://example.com/b/",
+		"--port=1366",
+		"--renderToDisk",
+		"--source=mysource",
+		"--uglyURLs"}, func(commands []cmder) {
+		var sc *serverCmd
+		for _, command := range commands {
+			if b, ok := command.(commandsBuilderGetter); ok {
+				v := b.getCmmandsBuilder().hugoBuilderCommon
+				assert.Equal("myconfig.toml", v.cfgFile)
+				assert.Equal("mysource", v.source)
+				assert.Equal("https://example.com/b/", v.baseURL)
+			}
+
+			if srvCmd, ok := command.(*serverCmd); ok {
+				sc = srvCmd
+			}
+		}
+
+		assert.NotNil(sc)
+		assert.True(sc.navigateToChanged)
+		assert.True(sc.disableLiveReload)
+		assert.True(sc.noHTTPCache)
+		assert.True(sc.renderToDisk)
+		assert.Equal(1366, sc.serverPort)
+
+		cfg := viper.New()
+		sc.flagsToConfig(cfg)
+		assert.Equal("/tmp/mydestination", cfg.GetString("publishDir"))
+		assert.Equal("mycontent", cfg.GetString("contentDir"))
+		assert.Equal("mylayouts", cfg.GetString("layoutDir"))
+		assert.Equal("mytheme", cfg.GetString("theme"))
+		assert.Equal("mythemes", cfg.GetString("themesDir"))
+		assert.Equal("https://example.com/b/", cfg.GetString("baseURL"))
+
+		assert.Equal([]string{"page", "home"}, cfg.Get("disableKinds"))
+
+		assert.True(cfg.GetBool("uglyURLs"))
+		assert.True(cfg.GetBool("gc"))
+
+		// The flag is named i18n-warnings
+		assert.True(cfg.GetBool("logI18nWarnings"))
+
+	}}}
+
+	for _, test := range tests {
+		b := newCommandsBuilder()
+		root := b.addAll().build()
+
+		for _, c := range b.commands {
+			if c.getCommand() == nil {
+				continue
+			}
+			// We are only intereseted in the flag handling here.
+			c.getCommand().RunE = noOpRunE
+		}
+		rootCmd := root.getCommand()
+		rootCmd.SetArgs(test.args)
+		assert.NoError(rootCmd.Execute())
+		test.check(b.commands)
+	}
+
+}
+
+func TestCommandsExecute(t *testing.T) {
+
+	assert := require.New(t)
+
+	dir, err := createSimpleTestSite(t)
+	assert.NoError(err)
+
+	dirOut, err := ioutil.TempDir("", "hugo-cli-out")
+	assert.NoError(err)
+
+	defer func() {
+		os.RemoveAll(dir)
+		os.RemoveAll(dirOut)
+	}()
+
+	sourceFlag := fmt.Sprintf("-s=%s", dir)
+
+	tests := []struct {
+		commands           []string
+		flags              []string
+		expectErrToContain string
+	}{
+		// TODO(bep) permission issue on my OSX? "operation not permitted" {[]string{"check", "ulimit"}, nil, false},
+		{[]string{"env"}, nil, ""},
+		{[]string{"version"}, nil, ""},
+		// no args = hugo build
+		{nil, []string{sourceFlag}, ""},
+		{nil, []string{sourceFlag, "--renderToMemory"}, ""},
+		{[]string{"config"}, []string{sourceFlag}, ""},
+		{[]string{"benchmark"}, []string{sourceFlag, "-n=1"}, ""},
+		{[]string{"convert", "toTOML"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "toml")}, ""},
+		{[]string{"convert", "toYAML"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "yaml")}, ""},
+		{[]string{"convert", "toJSON"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "json")}, ""},
+		{[]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")}, ""},
+		{[]string{"list", "drafts"}, []string{sourceFlag}, ""},
+		{[]string{"list", "expired"}, []string{sourceFlag}, ""},
+		{[]string{"list", "future"}, []string{sourceFlag}, ""},
+		{[]string{"new", "new-page.md"}, []string{sourceFlag}, ""},
+		{[]string{"new", "site", filepath.Join(dirOut, "new-site")}, nil, ""},
+		{[]string{"unknowncommand"}, nil, "unknown command"},
+		// TODO(bep) cli refactor fix https://github.com/gohugoio/hugo/issues/4450
+		//{[]string{"new", "theme", filepath.Join(dirOut, "new-theme")}, nil,false},
+	}
+
+	for _, test := range tests {
+
+		hugoCmd := newCommandsBuilder().addAll().build().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 != "" {
+			assert.Error(err, fmt.Sprintf("%v", test.commands))
+			assert.Contains(err.Error(), test.expectErrToContain)
+		} else {
+			assert.NoError(err, fmt.Sprintf("%v", test.commands))
+		}
+
+	}
+
+}
+
+func createSimpleTestSite(t *testing.T) (string, error) {
+	d, e := ioutil.TempDir("", "hugo-cli")
+	if e != nil {
+		return "", e
+	}
+
+	// Just the basic. These are for CLI tests, not site testing.
+	writeFile(t, filepath.Join(d, "config.toml"), `
+
+baseURL = "https://example.org"
+title = "Hugo Commands"
+
+`)
+
+	writeFile(t, filepath.Join(d, "content", "p1.md"), `
+---
+title: "P1"
+weight: 1
+---
+
+Content
+
+`)
+
+	writeFile(t, filepath.Join(d, "layouts", "_default", "single.html"), `
+
+Single: {{ .Title }}
+
+`)
+
+	writeFile(t, filepath.Join(d, "layouts", "_default", "list.html"), `
+
+List: {{ .Title }}
+
+`)
+
+	return d, nil
+
+}
+
+func writeFile(t *testing.T, 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) {
+	if err != nil {
+		t.Fatal(err)
+	}
+}

commands/config.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// 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.
@@ -9,231 +9,69 @@
 // 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.
+// limitations under the License.Print the version number of Hug
 
 package commands
 
 import (
-	"bytes"
+	"reflect"
-	"context"
+	"sort"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-	"time"
 
-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/maps"
-	"github.com/gohugoio/hugo/config/allconfig"
-	"github.com/gohugoio/hugo/modules"
-	"github.com/gohugoio/hugo/parser"
-	"github.com/gohugoio/hugo/parser/metadecoders"
 	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+	"github.com/spf13/viper"
 )
 
-// newConfigCommand creates a new config command and its subcommands.
+var _ cmder = (*configCmd)(nil)
-func newConfigCommand() *configCommand {
+
-	return &configCommand{
+type configCmd struct {
-		commands: []simplecobra.Commander{
+	hugoBuilderCommon
-			&configMountsCommand{},
+	*baseCmd
-		},
-	}
 }
 
-type configCommand struct {
+func newConfigCmd() *configCmd {
-	r *rootCommand
+	cc := &configCmd{}
-
+	cc.baseCmd = newBaseCmd(&cobra.Command{
-	format    string
+		Use:   "config",
-	lang      string
+		Short: "Print the site configuration",
-	printZero bool
+		Long:  `Print the site configuration, both default and custom settings.`,
-
+		RunE:  cc.printConfig,
-	commands []simplecobra.Commander
-}
-
-func (c *configCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *configCommand) Name() string {
-	return "config"
-}
-
-func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	conf, err := c.r.ConfigFromProvider(configKey{counter: c.r.configVersionID.Load()}, flagsToCfg(cd, nil))
-	if err != nil {
-		return err
-	}
-	var config *allconfig.Config
-	if c.lang != "" {
-		var found bool
-		config, found = conf.configs.LanguageConfigMap[c.lang]
-		if !found {
-			return fmt.Errorf("language %q not found", c.lang)
-		}
-	} else {
-		config = conf.configs.LanguageConfigSlice[0]
-	}
-
-	var buf bytes.Buffer
-	dec := json.NewEncoder(&buf)
-	dec.SetIndent("", "  ")
-	dec.SetEscapeHTML(false)
-
-	if err := dec.Encode(parser.ReplacingJSONMarshaller{Value: config, KeysToLower: true, OmitEmpty: !c.printZero}); err != nil {
-		return err
-	}
-
-	format := strings.ToLower(c.format)
-
-	switch format {
-	case "json":
-		os.Stdout.Write(buf.Bytes())
-	default:
-		// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
-		var m map[string]any
-		if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
-			return err
-		}
-		maps.ConvertFloat64WithNoDecimalsToInt(m)
-		switch format {
-		case "yaml":
-			return parser.InterfaceToConfig(m, metadecoders.YAML, os.Stdout)
-		case "toml":
-			return parser.InterfaceToConfig(m, metadecoders.TOML, os.Stdout)
-		default:
-			return fmt.Errorf("unsupported format: %q", format)
-		}
-	}
-
-	return nil
-}
-
-func (c *configCommand) Init(cd *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	cmd := cd.CobraCommand
-	cmd.Short = "Display site configuration"
-	cmd.Long = `Display site configuration, both default and custom settings.`
-	cmd.Flags().StringVar(&c.format, "format", "toml", "preferred file format (toml, yaml or json)")
-	_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
-	cmd.Flags().StringVar(&c.lang, "lang", "", "the language to display config for. Defaults to the first language defined.")
-	cmd.Flags().BoolVar(&c.printZero, "printZero", false, `include config options with zero values (e.g. false, 0, "") in the output`)
-	_ = cmd.RegisterFlagCompletionFunc("lang", cobra.NoFileCompletions)
-	applyLocalFlagsBuildConfig(cmd, c.r)
-
-	return nil
-}
-
-func (c *configCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	return nil
-}
-
-type configModMount struct {
-	Source string `json:"source"`
-	Target string `json:"target"`
-	Lang   string `json:"lang,omitempty"`
-}
-
-type configModMounts struct {
-	verbose bool
-	m       modules.Module
-}
-
-// MarshalJSON is for internal use only.
-func (m *configModMounts) MarshalJSON() ([]byte, error) {
-	var mounts []configModMount
-
-	for _, mount := range m.m.Mounts() {
-		mounts = append(mounts, configModMount{
-			Source: mount.Source,
-			Target: mount.Target,
-			Lang:   mount.Lang,
-		})
-	}
-
-	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 []configModMount `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"`
-		Version string           `json:"version"`
-		Time    time.Time        `json:"time"`
-		Owner   string           `json:"owner"`
-		Dir     string           `json:"dir"`
-		Mounts  []configModMount `json:"mounts"`
-	}{
-		Path:    m.m.Path(),
-		Version: m.m.Version(),
-		Time:    m.m.Time(),
-		Owner:   ownerPath,
-		Dir:     m.m.Dir(),
-		Mounts:  mounts,
 	})
+
+	cc.cmd.Flags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
+
+	return cc
 }
 
-type configMountsCommand struct {
+func (c *configCmd) printConfig(cmd *cobra.Command, args []string) error {
-	r         *rootCommand
+	cfg, err := initializeConfig(true, false, &c.hugoBuilderCommon, c, nil)
-	configCmd *configCommand
-}
 
-func (c *configMountsCommand) Commands() []simplecobra.Commander {
-	return nil
-}
-
-func (c *configMountsCommand) Name() string {
-	return "mounts"
-}
-
-func (c *configMountsCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	r := c.configCmd.r
-	conf, err := r.ConfigFromProvider(configKey{counter: c.r.configVersionID.Load()}, flagsToCfg(cd, nil))
 	if err != nil {
 		return err
 	}
 
-	for _, m := range conf.configs.Modules {
+	allSettings := cfg.Cfg.(*viper.Viper).AllSettings()
-		if err := parser.InterfaceToConfig(&configModMounts{m: m, verbose: r.isVerbose()}, metadecoders.JSON, os.Stdout); err != nil {
+
-			return err
+	var separator string
+	if allSettings["metadataformat"] == "toml" {
+		separator = " = "
+	} else {
+		separator = ": "
+	}
+
+	var keys []string
+	for k := range allSettings {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		kv := reflect.ValueOf(allSettings[k])
+		if kv.Kind() == reflect.String {
+			jww.FEEDBACK.Printf("%s%s\"%+v\"\n", k, separator, allSettings[k])
+		} else {
+			jww.FEEDBACK.Printf("%s%s%+v\n", k, separator, allSettings[k])
 		}
 	}
-	return nil
-}
 
-func (c *configMountsCommand) Init(cd *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	cmd := cd.CobraCommand
-	cmd.Short = "Print the configured file mounts"
-	cmd.ValidArgsFunction = cobra.NoFileCompletions
-	applyLocalFlagsBuildConfig(cmd, c.r)
-	return nil
-}
-
-func (c *configMountsCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.configCmd = cd.Parent.Command.(*configCommand)
 	return nil
 }

commands/convert.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// 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.
@@ -14,216 +14,181 @@
 package commands
 
 import (
-	"bytes"
-	"context"
 	"fmt"
-	"path/filepath"
-	"strings"
 	"time"
 
-	"github.com/bep/simplecobra"
+	src "github.com/gohugoio/hugo/source"
-	"github.com/gohugoio/hugo/config"
+
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/hugolib"
+
+	"path/filepath"
+
 	"github.com/gohugoio/hugo/parser"
-	"github.com/gohugoio/hugo/parser/metadecoders"
+	"github.com/spf13/cast"
-	"github.com/gohugoio/hugo/parser/pageparser"
-	"github.com/gohugoio/hugo/resources/page"
 	"github.com/spf13/cobra"
 )
 
-func newConvertCommand() *convertCommand {
+var (
-	var c *convertCommand
+	_ cmder = (*convertCmd)(nil)
-	c = &convertCommand{
+)
-		commands: []simplecobra.Commander{
+
-			&simpleCommand{
+type convertCmd struct {
-				name:  "toJSON",
+	hugoBuilderCommon
-				short: "Convert front matter to JSON",
-				long: `toJSON converts all front matter in the content directory
-to use JSON for the front matter.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					return c.convertContents(metadecoders.JSON)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "toTOML",
-				short: "Convert front matter to TOML",
-				long: `toTOML converts all front matter in the content directory
-to use TOML for the front matter.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					return c.convertContents(metadecoders.TOML)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "toYAML",
-				short: "Convert front matter to YAML",
-				long: `toYAML converts all front matter in the content directory
-to use YAML for the front matter.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					return c.convertContents(metadecoders.YAML)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-		},
-	}
-	return c
-}
 
-type convertCommand struct {
-	// Flags.
 	outputDir string
 	unsafe    bool
 
-	// Deps.
+	*baseCmd
-	r *rootCommand
-	h *hugolib.HugoSites
-
-	// Commands.
-	commands []simplecobra.Commander
 }
 
-func (c *convertCommand) Commands() []simplecobra.Commander {
+func newConvertCmd() *convertCmd {
-	return c.commands
+	cc := &convertCmd{}
+
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "convert",
+		Short: "Convert your content to different formats",
+		Long: `Convert your content (e.g. front matter) to different formats.
+
+See convert's subcommands toJSON, toTOML and toYAML for more information.`,
+		RunE: nil,
+	})
+
+	cc.cmd.AddCommand(
+		&cobra.Command{
+			Use:   "toJSON",
+			Short: "Convert front matter to JSON",
+			Long: `toJSON converts all front matter in the content directory
+to use JSON for the front matter.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return cc.convertContents(rune([]byte(parser.JSONLead)[0]))
+			},
+		},
+		&cobra.Command{
+			Use:   "toTOML",
+			Short: "Convert front matter to TOML",
+			Long: `toTOML converts all front matter in the content directory
+to use TOML for the front matter.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return cc.convertContents(rune([]byte(parser.TOMLLead)[0]))
+			},
+		},
+		&cobra.Command{
+			Use:   "toYAML",
+			Short: "Convert front matter to YAML",
+			Long: `toYAML converts all front matter in the content directory
+to use YAML for the front matter.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return cc.convertContents(rune([]byte(parser.YAMLLead)[0]))
+			},
+		},
+	)
+
+	cc.cmd.PersistentFlags().StringVarP(&cc.outputDir, "output", "o", "", "filesystem path to write files to")
+	cc.cmd.PersistentFlags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
+	cc.cmd.PersistentFlags().BoolVar(&cc.unsafe, "unsafe", false, "enable less safe operations, please backup first")
+	cc.cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+
+	return cc
 }
 
-func (c *convertCommand) Name() string {
+func (cc *convertCmd) convertContents(mark rune) error {
-	return "convert"
+	if cc.outputDir == "" && !cc.unsafe {
-}
+		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
+	}
 
-func (c *convertCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
+	c, err := initializeConfig(true, false, &cc.hugoBuilderCommon, cc, nil)
-	return nil
-}
-
-func (c *convertCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Convert front matter to another format"
-	cmd.Long = `Convert front matter to another format.
-
-See convert's subcommands toJSON, toTOML and toYAML for more information.`
-
-	cmd.PersistentFlags().StringVarP(&c.outputDir, "output", "o", "", "filesystem path to write files to")
-	_ = cmd.MarkFlagDirname("output")
-	cmd.PersistentFlags().BoolVar(&c.unsafe, "unsafe", false, "enable less safe operations, please backup first")
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *convertCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	cfg := config.New()
-	cfg.Set("buildDrafts", true)
-	h, err := c.r.Hugo(flagsToCfg(cd, cfg))
 	if err != nil {
 		return err
 	}
-	c.h = h
+
+	h, err := hugolib.NewHugoSites(*c.DepsCfg)
+	if err != nil {
+		return err
+	}
+
+	if err := h.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+		return err
+	}
+
+	site := h.Sites[0]
+
+	site.Log.FEEDBACK.Println("processing", len(site.AllPages), "content files")
+	for _, p := range site.AllPages {
+		if err := cc.convertAndSavePage(p, site, mark); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
-func (c *convertCommand) convertAndSavePage(p page.Page, site *hugolib.Site, targetFormat metadecoders.Format) error {
+func (cc *convertCmd) convertAndSavePage(p *hugolib.Page, site *hugolib.Site, mark rune) error {
 	// The resources are not in .Site.AllPages.
-	for _, r := range p.Resources().ByType("page") {
+	for _, r := range p.Resources.ByType("page") {
-		if err := c.convertAndSavePage(r.(page.Page), site, targetFormat); err != nil {
+		if err := cc.convertAndSavePage(r.(*hugolib.Page), site, mark); err != nil {
 			return err
 		}
 	}
 
-	if p.File() == nil {
+	if p.Filename() == "" {
 		// No content file.
 		return nil
 	}
 
-	errMsg := fmt.Errorf("error processing file %q", p.File().Path())
+	site.Log.INFO.Println("Attempting to convert", p.LogicalName())
-
+	newPage, err := site.NewPage(p.LogicalName())
-	site.Log.Infoln("attempting to convert", p.File().Filename())
-
-	f := p.File()
-	file, err := f.FileInfo().Meta().Open()
 	if err != nil {
-		site.Log.Errorln(errMsg)
+		return err
+	}
+
+	f, _ := p.File.(src.ReadableFile)
+	file, err := f.Open()
+	if err != nil {
+		site.Log.ERROR.Println("Error reading file:", p.Path())
 		file.Close()
 		return nil
 	}
 
-	pf, err := pageparser.ParseFrontMatterAndContent(file)
+	psr, err := parser.ReadFrom(file)
 	if err != nil {
-		site.Log.Errorln(errMsg)
+		site.Log.ERROR.Println("Error processing file:", p.Path())
 		file.Close()
 		return err
 	}
 
 	file.Close()
 
+	metadata, err := psr.Metadata()
+	if err != nil {
+		site.Log.ERROR.Println("Error processing file:", p.Path())
+		return err
+	}
+
 	// better handling of dates in formats that don't have support for them
-	if pf.FrontMatterFormat == metadecoders.JSON || pf.FrontMatterFormat == metadecoders.YAML || pf.FrontMatterFormat == metadecoders.TOML {
+	if mark == parser.FormatToLeadRune("json") || mark == parser.FormatToLeadRune("yaml") || mark == parser.FormatToLeadRune("toml") {
-		for k, v := range pf.FrontMatter {
+		newMetadata := cast.ToStringMap(metadata)
+		for k, v := range newMetadata {
 			switch vv := v.(type) {
 			case time.Time:
-				pf.FrontMatter[k] = vv.Format(time.RFC3339)
+				newMetadata[k] = vv.Format(time.RFC3339)
 			}
 		}
+		metadata = newMetadata
 	}
 
-	var newContent bytes.Buffer
+	newPage.SetSourceContent(psr.Content())
-	err = parser.InterfaceToFrontMatter(pf.FrontMatter, targetFormat, &newContent)
+	if err = newPage.SetSourceMetaData(metadata, mark); err != nil {
-	if err != nil {
+		site.Log.ERROR.Printf("Failed to set source metadata for file %q: %s. For more info see For more info see https://github.com/gohugoio/hugo/issues/2458", newPage.FullFilePath(), err)
-		site.Log.Errorln(errMsg)
+		return nil
-		return err
 	}
 
-	newContent.Write(pf.Content)
+	newFilename := p.Filename()
-
+	if cc.outputDir != "" {
-	newFilename := p.File().Filename()
+		newFilename = filepath.Join(cc.outputDir, p.Dir(), newPage.LogicalName())
-
-	if c.outputDir != "" {
-		contentDir := strings.TrimSuffix(newFilename, p.File().Path())
-		contentDir = filepath.Base(contentDir)
-
-		newFilename = filepath.Join(c.outputDir, contentDir, p.File().Path())
 	}
 
-	fs := hugofs.Os
+	if err = newPage.SaveSourceAs(newFilename); err != nil {
-	if err := helpers.WriteToDisk(newFilename, &newContent, fs); err != nil {
+		return fmt.Errorf("Failed to save file %q: %s", newFilename, err)
-		return fmt.Errorf("failed to save file %q:: %w", newFilename, err)
 	}
 
 	return nil
 }
-
-func (c *convertCommand) convertContents(format metadecoders.Format) error {
-	if c.outputDir == "" && !c.unsafe {
-		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
-	}
-
-	if err := c.h.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
-		return err
-	}
-
-	site := c.h.Sites[0]
-
-	var pagesBackedByFile page.Pages
-	for _, p := range site.AllPages() {
-		if p.File() == nil {
-			continue
-		}
-		pagesBackedByFile = append(pagesBackedByFile, p)
-	}
-
-	site.Log.Println("processing", len(pagesBackedByFile), "content files")
-	for _, p := range site.AllPages() {
-		if err := c.convertAndSavePage(p, site, format); err != nil {
-			return err
-		}
-	}
-	return nil
-}

commands/deploy.go

@@ -1,51 +0,0 @@
-// Copyright 2024 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.
-
-//go:build withdeploy
-
-package commands
-
-import (
-	"context"
-
-	"github.com/gohugoio/hugo/deploy"
-
-	"github.com/bep/simplecobra"
-	"github.com/spf13/cobra"
-)
-
-func newDeployCommand() simplecobra.Commander {
-	return &simpleCommand{
-		name:  "deploy",
-		short: "Deploy your site to a cloud provider",
-		long: `Deploy your site to a cloud provider
-
-See https://gohugo.io/hosting-and-deployment/hugo-deploy/ for detailed
-documentation.
-`,
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			h, err := r.Hugo(flagsToCfgWithAdditionalConfigBase(cd, nil, "deployment"))
-			if err != nil {
-				return err
-			}
-			deployer, err := deploy.New(h.Configs.GetFirstLanguageConfig(), h.Log, h.PathSpec.PublishFs)
-			if err != nil {
-				return err
-			}
-			return deployer.Deploy(ctx)
-		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			applyDeployFlags(cmd, r)
-		},
-	}
-}

commands/deploy_flags.go

@@ -1,33 +0,0 @@
-// Copyright 2024 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 (
-	"github.com/gohugoio/hugo/deploy/deployconfig"
-	"github.com/spf13/cobra"
-)
-
-func applyDeployFlags(cmd *cobra.Command, r *rootCommand) {
-	cmd.ValidArgsFunction = cobra.NoFileCompletions
-	cmd.Flags().String("target", "", "target deployment from deployments section in config file; defaults to the first one")
-	_ = cmd.RegisterFlagCompletionFunc("target", cobra.NoFileCompletions)
-	cmd.Flags().Bool("confirm", false, "ask for confirmation before making changes to the target")
-	cmd.Flags().Bool("dryRun", false, "dry run")
-	cmd.Flags().Bool("force", false, "force upload of all files")
-	cmd.Flags().Bool("invalidateCDN", deployconfig.DefaultConfig.InvalidateCDN, "invalidate the CDN cache listed in the deployment target")
-	cmd.Flags().Int("maxDeletes", deployconfig.DefaultConfig.MaxDeletes, "maximum # of files to delete, or -1 to disable")
-	_ = cmd.RegisterFlagCompletionFunc("maxDeletes", cobra.NoFileCompletions)
-	cmd.Flags().Int("workers", deployconfig.DefaultConfig.Workers, "number of workers to transfer files. defaults to 10")
-	_ = cmd.RegisterFlagCompletionFunc("workers", cobra.NoFileCompletions)
-}

commands/deploy_off.go

@@ -1,50 +0,0 @@
-// Copyright 2024 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.
-
-//go:build !withdeploy
-
-// Copyright 2024 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 (
-	"context"
-	"errors"
-
-	"github.com/bep/simplecobra"
-	"github.com/spf13/cobra"
-)
-
-func newDeployCommand() simplecobra.Commander {
-	return &simpleCommand{
-		name: "deploy",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			return errors.New("deploy not supported in this version of Hugo; install a release with 'withdeploy' in the archive filename or build yourself with the 'withdeploy' build tag. Also see https://github.com/gohugoio/hugo/pull/12995")
-		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			applyDeployFlags(cmd, r)
-			cmd.Hidden = true
-		},
-	}
-}

commands/env.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2016 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,57 +14,31 @@
 package commands
 
 import (
-	"context"
 	"runtime"
 
-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
 )
 
-func newEnvCommand() simplecobra.Commander {
+var _ cmder = (*envCmd)(nil)
-	return &simpleCommand{
-		name:  "env",
-		short: "Display version and environment info",
-		long:  "Display version and environment info. This is useful in Hugo bug reports",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			r.Printf("%s\n", hugo.BuildVersionString())
-			r.Printf("GOOS=%q\n", runtime.GOOS)
-			r.Printf("GOARCH=%q\n", runtime.GOARCH)
-			r.Printf("GOVERSION=%q\n", runtime.Version())
 
-			if r.isVerbose() {
+type envCmd struct {
-				deps := hugo.GetDependencyList()
+	*baseCmd
-				for _, dep := range deps {
-					r.Printf("%s\n", dep)
-				}
-			} else {
-				// These are also included in the GetDependencyList above;
-				// always print these as these are most likely the most useful to know about.
-				deps := hugo.GetDependencyListNonGo()
-				for _, dep := range deps {
-					r.Printf("%s\n", dep)
-				}
-			}
-			return nil
-		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			cmd.ValidArgsFunction = cobra.NoFileCompletions
-		},
-	}
 }
 
-func newVersionCmd() simplecobra.Commander {
+func newEnvCmd() *envCmd {
-	return &simpleCommand{
+	return &envCmd{baseCmd: newBaseCmd(&cobra.Command{
-		name: "version",
+		Use:   "env",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
+		Short: "Print Hugo version and environment info",
-			r.Println(hugo.BuildVersionString())
+		Long:  `Print Hugo version and environment info. This is useful in Hugo bug reports.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			printHugoVersion()
+			jww.FEEDBACK.Printf("GOOS=%q\n", runtime.GOOS)
+			jww.FEEDBACK.Printf("GOARCH=%q\n", runtime.GOARCH)
+			jww.FEEDBACK.Printf("GOVERSION=%q\n", runtime.Version())
+
 			return nil
 		},
-		short: "Display version",
+	}),
-		long:  "Display version and environment info. This is useful in Hugo bug reports.",
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			cmd.ValidArgsFunction = cobra.NoFileCompletions
-		},
 	}
 }

commands/gen.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// 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.
@@ -14,290 +14,28 @@
 package commands
 
 import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"slices"
-	"strings"
-
-	"github.com/alecthomas/chroma/v2"
-	"github.com/alecthomas/chroma/v2/formatters/html"
-	"github.com/alecthomas/chroma/v2/styles"
-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/hugo"
-	"github.com/gohugoio/hugo/docshelper"
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/hugolib"
-	"github.com/gohugoio/hugo/parser"
 	"github.com/spf13/cobra"
-	"github.com/spf13/cobra/doc"
-	"gopkg.in/yaml.v2"
 )
 
-func newGenCommand() *genCommand {
+var _ cmder = (*genCmd)(nil)
-	var (
-		// Flags.
-		gendocdir string
-		genmandir string
 
-		// Chroma flags.
+type genCmd struct {
-		style                  string
+	*baseCmd
-		highlightStyle         string
-		lineNumbersInlineStyle string
-		lineNumbersTableStyle  string
-		omitEmpty              bool
-	)
-
-	newChromaStyles := func() simplecobra.Commander {
-		return &simpleCommand{
-			name:  "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 markup.highlight.noClasses is disabled in config.
-
-See https://xyproto.github.io/splash/docs/all.html for a preview of the available styles`,
-
-			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-				style = strings.ToLower(style)
-				if !slices.Contains(styles.Names(), style) {
-					return fmt.Errorf("invalid style: %s", style)
-				}
-				builder := styles.Get(style).Builder()
-				if highlightStyle != "" {
-					builder.Add(chroma.LineHighlight, highlightStyle)
-				}
-				if lineNumbersInlineStyle != "" {
-					builder.Add(chroma.LineNumbers, lineNumbersInlineStyle)
-				}
-				if lineNumbersTableStyle != "" {
-					builder.Add(chroma.LineNumbersTable, lineNumbersTableStyle)
-				}
-				style, err := builder.Build()
-				if err != nil {
-					return err
-				}
-
-				var formatter *html.Formatter
-				if omitEmpty {
-					formatter = html.New(html.WithClasses(true))
-				} else {
-					formatter = html.New(html.WithAllClasses(true))
-				}
-
-				w := os.Stdout
-				fmt.Fprintf(w, "/* Generated using: hugo %s */\n\n", strings.Join(os.Args[1:], " "))
-				formatter.WriteCSS(w, style)
-				return nil
-			},
-			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVar(&style, "style", "friendly", "highlighter style (see https://xyproto.github.io/splash/docs/)")
-				_ = cmd.RegisterFlagCompletionFunc("style", cobra.NoFileCompletions)
-				cmd.PersistentFlags().StringVar(&highlightStyle, "highlightStyle", "", `foreground and background colors for highlighted lines, e.g. --highlightStyle "#fff000 bg:#000fff"`)
-				_ = cmd.RegisterFlagCompletionFunc("highlightStyle", cobra.NoFileCompletions)
-				cmd.PersistentFlags().StringVar(&lineNumbersInlineStyle, "lineNumbersInlineStyle", "", `foreground and background colors for inline line numbers, e.g. --lineNumbersInlineStyle "#fff000 bg:#000fff"`)
-				_ = cmd.RegisterFlagCompletionFunc("lineNumbersInlineStyle", cobra.NoFileCompletions)
-				cmd.PersistentFlags().StringVar(&lineNumbersTableStyle, "lineNumbersTableStyle", "", `foreground and background colors for table line numbers, e.g. --lineNumbersTableStyle "#fff000 bg:#000fff"`)
-				_ = cmd.RegisterFlagCompletionFunc("lineNumbersTableStyle", cobra.NoFileCompletions)
-				cmd.PersistentFlags().BoolVar(&omitEmpty, "omitEmpty", false, `omit empty CSS rules`)
-				_ = cmd.RegisterFlagCompletionFunc("omitEmpty", cobra.NoFileCompletions)
-			},
-		}
-	}
-
-	newMan := func() simplecobra.Commander {
-		return &simpleCommand{
-			name:  "man",
-			short: "Generate man pages for the Hugo CLI",
-			long: `This command automatically generates up-to-date man pages of Hugo's
-	command-line interface.  By default, it creates the man page files
-	in the "man" directory under the current directory.`,
-
-			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-				header := &doc.GenManHeader{
-					Section: "1",
-					Manual:  "Hugo Manual",
-					Source:  fmt.Sprintf("Hugo %s", hugo.CurrentVersion),
-				}
-				if !strings.HasSuffix(genmandir, helpers.FilePathSeparator) {
-					genmandir += helpers.FilePathSeparator
-				}
-				if found, _ := helpers.Exists(genmandir, hugofs.Os); !found {
-					r.Println("Directory", genmandir, "does not exist, creating...")
-					if err := hugofs.Os.MkdirAll(genmandir, 0o777); err != nil {
-						return err
-					}
-				}
-				cd.CobraCommand.Root().DisableAutoGenTag = true
-
-				r.Println("Generating Hugo man pages in", genmandir, "...")
-				doc.GenManTree(cd.CobraCommand.Root(), header, genmandir)
-
-				r.Println("Done.")
-
-				return nil
-			},
-			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVar(&genmandir, "dir", "man/", "the directory to write the man pages.")
-				_ = cmd.MarkFlagDirname("dir")
-			},
-		}
-	}
-
-	newGen := func() simplecobra.Commander {
-		const gendocFrontmatterTemplate = `---
-title: "%s"
-slug: %s
-url: %s
----
-`
-
-		return &simpleCommand{
-			name:  "doc",
-			short: "Generate Markdown documentation for the Hugo CLI",
-			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 https://gohugo.io/.
-
-	It creates one Markdown file per command with front matter suitable
-	for rendering in Hugo.`,
-			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-				cd.CobraCommand.VisitParents(func(c *cobra.Command) {
-					// Disable the "Auto generated by spf13/cobra on DATE"
-					// as it creates a lot of diffs.
-					c.DisableAutoGenTag = true
-				})
-				if !strings.HasSuffix(gendocdir, helpers.FilePathSeparator) {
-					gendocdir += helpers.FilePathSeparator
-				}
-				if found, _ := helpers.Exists(gendocdir, hugofs.Os); !found {
-					r.Println("Directory", gendocdir, "does not exist, creating...")
-					if err := hugofs.Os.MkdirAll(gendocdir, 0o777); err != nil {
-						return err
-					}
-				}
-				prepender := func(filename string) string {
-					name := filepath.Base(filename)
-					base := strings.TrimSuffix(name, path.Ext(name))
-					url := "/docs/reference/commands/" + strings.ToLower(base) + "/"
-					return fmt.Sprintf(gendocFrontmatterTemplate, strings.Replace(base, "_", " ", -1), base, url)
-				}
-
-				linkHandler := func(name string) string {
-					base := strings.TrimSuffix(name, path.Ext(name))
-					return "/docs/reference/commands/" + strings.ToLower(base) + "/"
-				}
-				r.Println("Generating Hugo command-line documentation in", gendocdir, "...")
-				doc.GenMarkdownTreeCustom(cd.CobraCommand.Root(), gendocdir, prepender, linkHandler)
-				r.Println("Done.")
-
-				return nil
-			},
-			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVar(&gendocdir, "dir", "/tmp/hugodoc/", "the directory to write the doc.")
-				_ = cmd.MarkFlagDirname("dir")
-			},
-		}
-	}
-
-	var docsHelperTarget string
-
-	newDocsHelper := func() simplecobra.Commander {
-		return &simpleCommand{
-			name:  "docshelper",
-			short: "Generate some data files for the Hugo docs",
-
-			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-				r.Println("Generate docs data to", docsHelperTarget)
-
-				var buf bytes.Buffer
-				jsonEnc := json.NewEncoder(&buf)
-
-				configProvider := func() docshelper.DocProvider {
-					conf := hugolib.DefaultConfig()
-					conf.CacheDir = "" // The default value does not make sense in the docs.
-					defaultConfig := parser.NullBoolJSONMarshaller{Wrapped: parser.LowerCaseCamelJSONMarshaller{Value: conf}}
-					return docshelper.DocProvider{"config": defaultConfig}
-				}
-
-				docshelper.AddDocProviderFunc(configProvider)
-				if err := jsonEnc.Encode(docshelper.GetDocProvider()); err != nil {
-					return err
-				}
-
-				// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
-				var m map[string]any
-				if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
-					return err
-				}
-
-				targetFile := filepath.Join(docsHelperTarget, "docs.yaml")
-
-				f, err := os.Create(targetFile)
-				if err != nil {
-					return err
-				}
-				defer f.Close()
-				yamlEnc := yaml.NewEncoder(f)
-				if err := yamlEnc.Encode(m); err != nil {
-					return err
-				}
-
-				r.Println("Done!")
-				return nil
-			},
-			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.Hidden = true
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVarP(&docsHelperTarget, "dir", "", "docs/data", "data dir")
-			},
-		}
-	}
-
-	return &genCommand{
-		commands: []simplecobra.Commander{
-			newChromaStyles(),
-			newGen(),
-			newMan(),
-			newDocsHelper(),
-		},
-	}
 }
 
-type genCommand struct {
+func newGenCmd() *genCmd {
-	rootCmd *rootCommand
+	cc := &genCmd{}
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "gen",
+		Short: "A collection of several useful generators.",
+	})
 
-	commands []simplecobra.Commander
+	cc.cmd.AddCommand(
-}
+		newGenautocompleteCmd().getCommand(),
-
+		newGenDocCmd().getCommand(),
-func (c *genCommand) Commands() []simplecobra.Commander {
+		newGenManCmd().getCommand(),
-	return c.commands
+		createGenDocsHelper().getCommand(),
-}
+		createGenChromaStyles().getCommand())
-
+
-func (c *genCommand) Name() string {
+	return cc
-	return "gen"
-}
-
-func (c *genCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	return nil
-}
-
-func (c *genCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Generate documentation and syntax highlighting styles"
-	cmd.Long = "Generate documentation for your project using Hugo's documentation engine, including syntax highlighting for various programming languages."
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *genCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.rootCmd = cd.Root.Command.(*rootCommand)
-	return nil
 }

commands/genautocomplete.go

@@ -0,0 +1,80 @@
+// 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 (
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*genautocompleteCmd)(nil)
+
+type genautocompleteCmd struct {
+	autocompleteTarget string
+
+	// bash for now (zsh and others will come)
+	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.
+
+NOTE: The current version supports Bash only.
+      This should work for *nix systems with Bash installed.
+
+By default, the file is written directly to /etc/bash_completion.d
+for convenience, and the command may need superuser rights, e.g.:
+
+	$ sudo hugo gen autocomplete
+
+Add ` + "`--completionfile=/path/to/file`" + ` flag to set alternative
+file-path and name.
+
+Logout and in again to reload the completion scripts,
+or just source them in directly:
+
+	$ . /etc/bash_completion`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if cc.autocompleteType != "bash" {
+				return newUserError("Only Bash is supported for now")
+			}
+
+			err := cmd.Root().GenBashCompletionFile(cc.autocompleteTarget)
+
+			if err != nil {
+				return err
+			}
+
+			jww.FEEDBACK.Println("Bash completion file for Hugo saved to", cc.autocompleteTarget)
+
+			return nil
+		},
+	})
+
+	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteTarget, "completionfile", "", "/etc/bash_completion.d/hugo.sh", "autocompletion file")
+	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteType, "type", "", "bash", "autocompletion type (currently only bash supported)")
+
+	// For bash-completion
+	cc.cmd.PersistentFlags().SetAnnotation("completionfile", cobra.BashCompFilenameExt, []string{})
+
+	return cc
+}

commands/genchromastyles.go

@@ -0,0 +1,74 @@
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"os"
+
+	"github.com/alecthomas/chroma"
+	"github.com/alecthomas/chroma/formatters/html"
+	"github.com/alecthomas/chroma/styles"
+	"github.com/spf13/cobra"
+)
+
+var (
+	_ cmder = (*genChromaStyles)(nil)
+)
+
+type genChromaStyles struct {
+	style          string
+	highlightStyle string
+	linesStyle     string
+	*baseCmd
+}
+
+// TODO(bep) highlight
+func createGenChromaStyles() *genChromaStyles {
+	g := &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.
+
+See https://help.farbox.com/pygments.html for preview of available styles`,
+		}),
+	}
+
+	g.cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		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.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)")
+
+	return g
+}
+
+func (g *genChromaStyles) generate() error {
+	builder := styles.Get(g.style).Builder()
+	if g.highlightStyle != "" {
+		builder.Add(chroma.LineHighlight, g.highlightStyle)
+	}
+	if g.linesStyle != "" {
+		builder.Add(chroma.LineNumbers, g.linesStyle)
+	}
+	style, err := builder.Build()
+	if err != nil {
+		return err
+	}
+	formatter := html.New(html.WithClasses())
+	formatter.WriteCSS(os.Stdout, style)
+	return nil
+}

commands/gendoc.go

@@ -0,0 +1,96 @@
+// Copyright 2016 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 (
+	"fmt"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*genDocCmd)(nil)
+
+type genDocCmd struct {
+	gendocdir string
+	*baseCmd
+}
+
+func newGenDocCmd() *genDocCmd {
+	const gendocFrontmatterTemplate = `---
+date: %s
+title: "%s"
+slug: %s
+url: %s
+---
+`
+
+	cc := &genDocCmd{}
+
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "doc",
+		Short: "Generate Markdown documentation for the Hugo CLI.",
+		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/.
+
+It creates one Markdown file per command with front matter suitable
+for rendering in Hugo.`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if !strings.HasSuffix(cc.gendocdir, helpers.FilePathSeparator) {
+				cc.gendocdir += helpers.FilePathSeparator
+			}
+			if found, _ := helpers.Exists(cc.gendocdir, hugofs.Os); !found {
+				jww.FEEDBACK.Println("Directory", cc.gendocdir, "does not exist, creating...")
+				if err := hugofs.Os.MkdirAll(cc.gendocdir, 0777); err != nil {
+					return err
+				}
+			}
+			now := time.Now().Format("2006-01-02")
+			prepender := func(filename string) string {
+				name := filepath.Base(filename)
+				base := strings.TrimSuffix(name, path.Ext(name))
+				url := "/commands/" + strings.ToLower(base) + "/"
+				return fmt.Sprintf(gendocFrontmatterTemplate, now, strings.Replace(base, "_", " ", -1), base, url)
+			}
+
+			linkHandler := func(name string) string {
+				base := strings.TrimSuffix(name, path.Ext(name))
+				return "/commands/" + strings.ToLower(base) + "/"
+			}
+
+			jww.FEEDBACK.Println("Generating Hugo command-line documentation in", cc.gendocdir, "...")
+			doc.GenMarkdownTreeCustom(cmd.Root(), cc.gendocdir, prepender, linkHandler)
+			jww.FEEDBACK.Println("Done.")
+
+			return nil
+		},
+	})
+
+	cc.cmd.PersistentFlags().StringVar(&cc.gendocdir, "dir", "/tmp/hugodoc/", "the directory to write the doc.")
+
+	// For bash-completion
+	cc.cmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
+
+	return cc
+}

commands/gendocshelper.go

@@ -0,0 +1,74 @@
+// Copyright 2017-present 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 (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/docshelper"
+	"github.com/spf13/cobra"
+)
+
+var (
+	_ cmder = (*genDocsHelper)(nil)
+)
+
+type genDocsHelper struct {
+	target string
+	*baseCmd
+}
+
+func createGenDocsHelper() *genDocsHelper {
+	g := &genDocsHelper{
+		baseCmd: newBaseCmd(&cobra.Command{
+			Use:    "docshelper",
+			Short:  "Generate some data files for the Hugo docs.",
+			Hidden: true,
+		}),
+	}
+
+	g.cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return g.generate()
+	}
+
+	g.cmd.PersistentFlags().StringVarP(&g.target, "dir", "", "docs/data", "data dir")
+
+	return g
+}
+
+func (g *genDocsHelper) generate() error {
+	fmt.Println("Generate docs data to", g.target)
+
+	targetFile := filepath.Join(g.target, "docs.json")
+
+	f, err := os.Create(targetFile)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	enc := json.NewEncoder(f)
+	enc.SetIndent("", "  ")
+
+	if err := enc.Encode(docshelper.DocProviders); err != nil {
+		return err
+	}
+
+	fmt.Println("Done!")
+	return nil
+
+}

commands/genman.go

@@ -0,0 +1,76 @@
+// Copyright 2016 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 (
+	"fmt"
+	"strings"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*genManCmd)(nil)
+
+type genManCmd struct {
+	genmandir string
+	*baseCmd
+}
+
+func newGenManCmd() *genManCmd {
+	cc := &genManCmd{}
+
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "man",
+		Short: "Generate man pages for the Hugo CLI",
+		Long: `This command automatically generates up-to-date man pages of Hugo's
+command-line interface.  By default, it creates the man page files
+in the "man" directory under the current directory.`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			header := &doc.GenManHeader{
+				Section: "1",
+				Manual:  "Hugo Manual",
+				Source:  fmt.Sprintf("Hugo %s", helpers.CurrentHugoVersion),
+			}
+			if !strings.HasSuffix(cc.genmandir, helpers.FilePathSeparator) {
+				cc.genmandir += helpers.FilePathSeparator
+			}
+			if found, _ := helpers.Exists(cc.genmandir, hugofs.Os); !found {
+				jww.FEEDBACK.Println("Directory", cc.genmandir, "does not exist, creating...")
+				if err := hugofs.Os.MkdirAll(cc.genmandir, 0777); err != nil {
+					return err
+				}
+			}
+			cmd.Root().DisableAutoGenTag = true
+
+			jww.FEEDBACK.Println("Generating Hugo man pages in", cc.genmandir, "...")
+			doc.GenManTree(cmd.Root(), header, cc.genmandir)
+
+			jww.FEEDBACK.Println("Done.")
+
+			return nil
+		},
+	})
+
+	cc.cmd.PersistentFlags().StringVar(&cc.genmandir, "dir", "man/", "the directory to write the man pages.")
+
+	// For bash-completion
+	cc.cmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
+
+	return cc
+}

commands/helpers.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,111 +11,62 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// Package commands defines and implements command-line commands and flags
+// used by Hugo. Commands and flags are implemented using Cobra.
 package commands
 
 import (
-	"errors"
 	"fmt"
-	"log"
+	"regexp"
-	"os"
-	"path/filepath"
-	"strings"
 
-	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/config"
-	"github.com/spf13/pflag"
+	"github.com/spf13/cobra"
 )
 
-const (
+type flagsToConfigHandler interface {
-	ansiEsc    = "\u001B"
+	flagsToConfig(cfg config.Provider)
-	clearLine  = "\r\033[K"
-	hideCursor = ansiEsc + "[?25l"
-	showCursor = ansiEsc + "[?25h"
-)
-
-func newUserError(a ...any) *simplecobra.CommandError {
-	return &simplecobra.CommandError{Err: errors.New(fmt.Sprint(a...))}
 }
 
-func setValueFromFlag(flags *pflag.FlagSet, key string, cfg config.Provider, targetKey string, force bool) {
+type cmder interface {
-	key = strings.TrimSpace(key)
+	flagsToConfigHandler
-	if (force && flags.Lookup(key) != nil) || flags.Changed(key) {
+	getCommand() *cobra.Command
-		f := flags.Lookup(key)
-		configKey := key
-		if targetKey != "" {
-			configKey = targetKey
-		}
-		// Gotta love this API.
-		switch f.Value.Type() {
-		case "bool":
-			bv, _ := flags.GetBool(key)
-			cfg.Set(configKey, bv)
-		case "string":
-			cfg.Set(configKey, f.Value.String())
-		case "stringSlice":
-			bv, _ := flags.GetStringSlice(key)
-			cfg.Set(configKey, bv)
-		case "int":
-			iv, _ := flags.GetInt(key)
-			cfg.Set(configKey, iv)
-		default:
-			panic(fmt.Sprintf("update switch with %s", f.Value.Type()))
-		}
-
-	}
 }
 
-func flagsToCfg(cd *simplecobra.Commandeer, cfg config.Provider) config.Provider {
+// commandError is an error used to signal different error situations in command handling.
-	return flagsToCfgWithAdditionalConfigBase(cd, cfg, "")
+type commandError struct {
+	s         string
+	userError bool
 }
 
-func flagsToCfgWithAdditionalConfigBase(cd *simplecobra.Commandeer, cfg config.Provider, additionalConfigBase string) config.Provider {
+func (c commandError) Error() string {
-	if cfg == nil {
+	return c.s
-		cfg = config.New()
-	}
-
-	// Flags with a different name in the config.
-	keyMap := map[string]string{
-		"minify":      "minifyOutput",
-		"destination": "publishDir",
-		"editor":      "newContentEditor",
-	}
-
-	// Flags that we for some reason don't want to expose in the site config.
-	internalKeySet := map[string]bool{
-		"quiet":          true,
-		"verbose":        true,
-		"watch":          true,
-		"liveReloadPort": true,
-		"renderToMemory": true,
-		"clock":          true,
-	}
-
-	cmd := cd.CobraCommand
-	flags := cmd.Flags()
-
-	flags.VisitAll(func(f *pflag.Flag) {
-		if f.Changed {
-			targetKey := f.Name
-			if internalKeySet[targetKey] {
-				targetKey = "internal." + targetKey
-			} else if mapped, ok := keyMap[targetKey]; ok {
-				targetKey = mapped
-			}
-			setValueFromFlag(flags, f.Name, cfg, targetKey, false)
-			if additionalConfigBase != "" {
-				setValueFromFlag(flags, f.Name, cfg, additionalConfigBase+"."+targetKey, true)
-			}
-		}
-	})
-
-	return cfg
 }
 
-func mkdir(x ...string) {
+func (c commandError) isUserError() bool {
-	p := filepath.Join(x...)
+	return c.userError
-	err := os.MkdirAll(p, 0o777) // before umask
+}
-	if err != nil {
+
-		log.Fatal(err)
+func newUserError(a ...interface{}) commandError {
-	}
+	return commandError{s: fmt.Sprintln(a...), userError: true}
+}
+
+func newSystemError(a ...interface{}) commandError {
+	return commandError{s: fmt.Sprintln(a...), userError: false}
+}
+
+func newSystemErrorF(format string, a ...interface{}) 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")
+
+func isUserError(err error) bool {
+	if cErr, ok := err.(commandError); ok && cErr.isUserError() {
+		return true
+	}
+
+	return userErrorRegexp.MatchString(err.Error())
 }

commands/helpers_others.go

@@ -0,0 +1,23 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !windows
+
+package commands
+
+const (
+	ansiEsc    = "\u001B"
+	clearLine  = "\r\033[K"
+	hideCursor = ansiEsc + "[?25l"
+	showCursor = ansiEsc + "[?25h"
+)

commands/helpers_windows.go

@@ -0,0 +1,23 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build windows
+
+package commands
+
+const (
+	ansiEsc    = ""
+	clearLine  = ""
+	hideCursor = ""
+	showCursor = ""
+)

commands/hugo.go

@@ -0,0 +1,971 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package commands defines and implements command-line commands and flags
+// used by Hugo. Commands and flags are implemented using Cobra.
+package commands
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os/signal"
+	"sort"
+	"sync/atomic"
+	"syscall"
+
+	"github.com/gohugoio/hugo/hugolib/filesystems"
+
+	"golang.org/x/sync/errgroup"
+
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/config"
+
+	"github.com/gohugoio/hugo/parser"
+	flag "github.com/spf13/pflag"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/livereload"
+	"github.com/gohugoio/hugo/watcher"
+	"github.com/spf13/afero"
+	"github.com/spf13/cobra"
+	"github.com/spf13/fsync"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+// The Response value from Execute.
+type Response struct {
+	// The build Result will only be set in the hugo build command.
+	Result *hugolib.HugoSites
+
+	// Err is set when the command failed to execute.
+	Err error
+
+	// The command that was executed.
+	Cmd *cobra.Command
+}
+
+func (r Response) IsUserError() bool {
+	return r.Err != nil && isUserError(r.Err)
+}
+
+// Execute adds all child commands to the root command HugoCmd and sets flags appropriately.
+// The args are usually filled with os.Args[1:].
+func Execute(args []string) Response {
+	hugoCmd := newCommandsBuilder().addAll().build()
+	cmd := hugoCmd.getCommand()
+	cmd.SetArgs(args)
+
+	c, err := cmd.ExecuteC()
+
+	var resp Response
+
+	if c == cmd && hugoCmd.c != nil {
+		// Root command executed
+		resp.Result = hugoCmd.c.hugo
+	}
+
+	if err == nil {
+		errCount := int(jww.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError))
+		if errCount > 0 {
+			err = fmt.Errorf("logged %d errors", errCount)
+		} else if resp.Result != nil {
+			errCount = resp.Result.NumLogErrors()
+			if errCount > 0 {
+				err = fmt.Errorf("logged %d errors", errCount)
+			}
+		}
+
+	}
+
+	resp.Err = err
+	resp.Cmd = c
+
+	return resp
+}
+
+// InitializeConfig initializes a config file with sensible default configuration flags.
+func initializeConfig(mustHaveConfigFile, running bool,
+	h *hugoBuilderCommon,
+	f flagsToConfigHandler,
+	doWithCommandeer func(c *commandeer) error) (*commandeer, error) {
+
+	c, err := newCommandeer(mustHaveConfigFile, running, h, f, doWithCommandeer)
+	if err != nil {
+		return nil, err
+	}
+
+	return c, nil
+
+}
+
+func (c *commandeer) createLogger(cfg config.Provider) (*jww.Notepad, error) {
+	var (
+		logHandle       = ioutil.Discard
+		logThreshold    = jww.LevelWarn
+		logFile         = cfg.GetString("logFile")
+		outHandle       = os.Stdout
+		stdoutThreshold = jww.LevelError
+	)
+
+	if c.h.verboseLog || c.h.logging || (c.h.logFile != "") {
+		var err error
+		if logFile != "" {
+			logHandle, err = os.OpenFile(logFile, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
+			if err != nil {
+				return nil, newSystemError("Failed to open log file:", logFile, err)
+			}
+		} else {
+			logHandle, err = ioutil.TempFile("", "hugo")
+			if err != nil {
+				return nil, newSystemError(err)
+			}
+		}
+	} else if !c.h.quiet && cfg.GetBool("verbose") {
+		stdoutThreshold = jww.LevelInfo
+	}
+
+	if cfg.GetBool("debug") {
+		stdoutThreshold = jww.LevelDebug
+	}
+
+	if c.h.verboseLog {
+		logThreshold = jww.LevelInfo
+		if cfg.GetBool("debug") {
+			logThreshold = jww.LevelDebug
+		}
+	}
+
+	// The global logger is used in some few cases.
+	jww.SetLogOutput(logHandle)
+	jww.SetLogThreshold(logThreshold)
+	jww.SetStdoutThreshold(stdoutThreshold)
+	helpers.InitLoggers()
+
+	return jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime), nil
+}
+
+func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
+	persFlagKeys := []string{
+		"debug",
+		"verbose",
+		"logFile",
+		// Moved from vars
+	}
+	flagKeys := []string{
+		"cleanDestinationDir",
+		"buildDrafts",
+		"buildFuture",
+		"buildExpired",
+		"uglyURLs",
+		"canonifyURLs",
+		"enableRobotsTXT",
+		"enableGitInfo",
+		"pluralizeListTitles",
+		"preserveTaxonomyNames",
+		"ignoreCache",
+		"forceSyncStatic",
+		"noTimes",
+		"noChmod",
+		"templateMetrics",
+		"templateMetricsHints",
+
+		// Moved from vars.
+		"baseURL",
+		"buildWatch",
+		"cacheDir",
+		"cfgFile",
+		"contentDir",
+		"debug",
+		"destination",
+		"disableKinds",
+		"gc",
+		"layoutDir",
+		"logFile",
+		"i18n-warnings",
+		"quiet",
+		"renderToMemory",
+		"source",
+		"theme",
+		"themesDir",
+		"verbose",
+		"verboseLog",
+	}
+
+	for _, key := range persFlagKeys {
+		setValueFromFlag(cmd.PersistentFlags(), key, cfg, "")
+	}
+	for _, key := range flagKeys {
+		setValueFromFlag(cmd.Flags(), key, cfg, "")
+	}
+
+	// Set some "config aliases"
+	setValueFromFlag(cmd.Flags(), "destination", cfg, "publishDir")
+	setValueFromFlag(cmd.Flags(), "i18n-warnings", cfg, "logI18nWarnings")
+
+}
+
+var deprecatedFlags = map[string]bool{
+	strings.ToLower("uglyURLs"):              true,
+	strings.ToLower("pluralizeListTitles"):   true,
+	strings.ToLower("preserveTaxonomyNames"): true,
+	strings.ToLower("canonifyURLs"):          true,
+}
+
+func setValueFromFlag(flags *flag.FlagSet, key string, cfg config.Provider, targetKey string) {
+	key = strings.TrimSpace(key)
+	if flags.Changed(key) {
+		if _, deprecated := deprecatedFlags[strings.ToLower(key)]; deprecated {
+			msg := fmt.Sprintf(`Set "%s = true" in your config.toml.
+If you need to set this configuration value from the command line, set it via an OS environment variable: "HUGO_%s=true hugo"`, key, strings.ToUpper(key))
+			// Remove in Hugo 0.38
+			helpers.Deprecated("hugo", "--"+key+" flag", msg, true)
+		}
+		f := flags.Lookup(key)
+		configKey := key
+		if targetKey != "" {
+			configKey = targetKey
+		}
+		// Gotta love this API.
+		switch f.Value.Type() {
+		case "bool":
+			bv, _ := flags.GetBool(key)
+			cfg.Set(configKey, bv)
+		case "string":
+			cfg.Set(configKey, f.Value.String())
+		case "stringSlice":
+			bv, _ := flags.GetStringSlice(key)
+			cfg.Set(configKey, bv)
+		default:
+			panic(fmt.Sprintf("update switch with %s", f.Value.Type()))
+		}
+
+	}
+}
+
+func (c *commandeer) fullBuild() error {
+	var (
+		g         errgroup.Group
+		langCount map[string]uint64
+	)
+
+	if !c.h.quiet {
+		fmt.Print(hideCursor + "Building sites … ")
+		defer func() {
+			fmt.Print(showCursor + clearLine)
+		}()
+	}
+
+	copyStaticFunc := func() error {
+		cnt, err := c.copyStatic()
+		if err != nil {
+			if !os.IsNotExist(err) {
+				return fmt.Errorf("Error copying static files: %s", err)
+			}
+			c.Logger.WARN.Println("No Static directory found")
+		}
+		langCount = cnt
+		langCount = cnt
+		return nil
+	}
+	buildSitesFunc := func() error {
+		if err := c.buildSites(); err != nil {
+			return fmt.Errorf("Error building site: %s", err)
+		}
+		return nil
+	}
+	// Do not copy static files and build sites in parallel if cleanDestinationDir is enabled.
+	// This flag deletes all static resources in /public folder that are missing in /static,
+	// and it does so at the end of copyStatic() call.
+	if c.Cfg.GetBool("cleanDestinationDir") {
+		if err := copyStaticFunc(); err != nil {
+			return err
+		}
+		if err := buildSitesFunc(); err != nil {
+			return err
+		}
+	} else {
+		g.Go(copyStaticFunc)
+		g.Go(buildSitesFunc)
+		if err := g.Wait(); err != nil {
+			return err
+		}
+	}
+
+	for _, s := range c.hugo.Sites {
+		s.ProcessingStats.Static = langCount[s.Language.Lang]
+	}
+
+	if c.h.gc {
+		count, err := c.hugo.GC()
+		if err != nil {
+			return err
+		}
+		for _, s := range c.hugo.Sites {
+			// We have no way of knowing what site the garbage belonged to.
+			s.ProcessingStats.Cleaned = uint64(count)
+		}
+	}
+
+	return nil
+
+}
+
+func (c *commandeer) build() error {
+	defer c.timeTrack(time.Now(), "Total")
+
+	if err := c.fullBuild(); err != nil {
+		return err
+	}
+
+	// TODO(bep) Feedback?
+	if !c.h.quiet {
+		fmt.Println()
+		c.hugo.PrintProcessingStats(os.Stdout)
+		fmt.Println()
+	}
+
+	if c.h.buildWatch {
+		watchDirs, err := c.getDirList()
+		if err != nil {
+			return err
+		}
+		c.Logger.FEEDBACK.Println("Watching for changes in", c.hugo.PathSpec.AbsPathify(c.Cfg.GetString("contentDir")))
+		c.Logger.FEEDBACK.Println("Press Ctrl+C to stop")
+		watcher, err := c.newWatcher(watchDirs...)
+		checkErr(c.Logger, err)
+		defer watcher.Close()
+
+		var sigs = make(chan os.Signal)
+		signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+
+		<-sigs
+	}
+
+	return nil
+}
+
+func (c *commandeer) serverBuild() error {
+	defer c.timeTrack(time.Now(), "Total")
+
+	if err := c.fullBuild(); err != nil {
+		return err
+	}
+
+	// TODO(bep) Feedback?
+	if !c.h.quiet {
+		fmt.Println()
+		c.hugo.PrintProcessingStats(os.Stdout)
+		fmt.Println()
+	}
+
+	return nil
+}
+
+func (c *commandeer) copyStatic() (map[string]uint64, error) {
+	return c.doWithPublishDirs(c.copyStaticTo)
+}
+
+func (c *commandeer) doWithPublishDirs(f func(sourceFs *filesystems.SourceFilesystem) (uint64, error)) (map[string]uint64, error) {
+
+	langCount := make(map[string]uint64)
+
+	staticFilesystems := c.hugo.BaseFs.SourceFilesystems.Static
+
+	if len(staticFilesystems) == 0 {
+		c.Logger.WARN.Println("No static directories found to sync")
+		return langCount, nil
+	}
+
+	for lang, fs := range staticFilesystems {
+		cnt, err := f(fs)
+		if err != nil {
+			return langCount, err
+		}
+		if lang == "" {
+			// Not multihost
+			for _, l := range c.languages {
+				langCount[l.Lang] = cnt
+			}
+		} else {
+			langCount[lang] = cnt
+		}
+	}
+
+	return langCount, nil
+}
+
+type countingStatFs struct {
+	afero.Fs
+	statCounter uint64
+}
+
+func (fs *countingStatFs) Stat(name string) (os.FileInfo, error) {
+	f, err := fs.Fs.Stat(name)
+	if err == nil {
+		if !f.IsDir() {
+			atomic.AddUint64(&fs.statCounter, 1)
+		}
+	}
+	return f, err
+}
+
+func (c *commandeer) copyStaticTo(sourceFs *filesystems.SourceFilesystem) (uint64, error) {
+	publishDir := c.hugo.PathSpec.PublishDir
+	// If root, remove the second '/'
+	if publishDir == "//" {
+		publishDir = helpers.FilePathSeparator
+	}
+
+	if sourceFs.PublishFolder != "" {
+		publishDir = filepath.Join(publishDir, sourceFs.PublishFolder)
+	}
+
+	fs := &countingStatFs{Fs: sourceFs.Fs}
+
+	syncer := fsync.NewSyncer()
+	syncer.NoTimes = c.Cfg.GetBool("noTimes")
+	syncer.NoChmod = c.Cfg.GetBool("noChmod")
+	syncer.SrcFs = fs
+	syncer.DestFs = c.Fs.Destination
+	// Now that we are using a unionFs for the static directories
+	// We can effectively clean the publishDir on initial sync
+	syncer.Delete = c.Cfg.GetBool("cleanDestinationDir")
+
+	if syncer.Delete {
+		c.Logger.INFO.Println("removing all files from destination that don't exist in static dirs")
+
+		syncer.DeleteFilter = func(f os.FileInfo) bool {
+			return f.IsDir() && strings.HasPrefix(f.Name(), ".")
+		}
+	}
+	c.Logger.INFO.Println("syncing static files to", publishDir)
+
+	var err error
+
+	// because we are using a baseFs (to get the union right).
+	// set sync src to root
+	err = syncer.Sync(publishDir, helpers.FilePathSeparator)
+	if err != nil {
+		return 0, err
+	}
+
+	// Sync runs Stat 3 times for every source file (which sounds much)
+	numFiles := fs.statCounter / 3
+
+	return numFiles, err
+}
+
+func (c *commandeer) firstPathSpec() *helpers.PathSpec {
+	return c.hugo.Sites[0].PathSpec
+}
+
+func (c *commandeer) timeTrack(start time.Time, name string) {
+	if c.h.quiet {
+		return
+	}
+	elapsed := time.Since(start)
+	c.Logger.FEEDBACK.Printf("%s in %v ms", name, int(1000*elapsed.Seconds()))
+}
+
+// getDirList provides NewWatcher() with a list of directories to watch for changes.
+func (c *commandeer) getDirList() ([]string, error) {
+	var a []string
+
+	// To handle nested symlinked content dirs
+	var seen = make(map[string]bool)
+	var nested []string
+
+	newWalker := func(allowSymbolicDirs bool) func(path string, fi os.FileInfo, err error) error {
+		return func(path string, fi os.FileInfo, err error) error {
+			if err != nil {
+				if os.IsNotExist(err) {
+					return nil
+				}
+
+				c.Logger.ERROR.Println("Walker: ", err)
+				return nil
+			}
+
+			// Skip .git directories.
+			// Related to https://github.com/gohugoio/hugo/issues/3468.
+			if fi.Name() == ".git" {
+				return nil
+			}
+
+			if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
+				link, err := filepath.EvalSymlinks(path)
+				if err != nil {
+					c.Logger.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", path, err)
+					return nil
+				}
+				linkfi, err := helpers.LstatIfPossible(c.Fs.Source, link)
+				if err != nil {
+					c.Logger.ERROR.Printf("Cannot stat %q: %s", link, err)
+					return nil
+				}
+				if !allowSymbolicDirs && !linkfi.Mode().IsRegular() {
+					c.Logger.ERROR.Printf("Symbolic links for directories not supported, skipping %q", path)
+					return nil
+				}
+
+				if allowSymbolicDirs && linkfi.IsDir() {
+					// afero.Walk will not walk symbolic links, so wee need to do it.
+					if !seen[path] {
+						seen[path] = true
+						nested = append(nested, path)
+					}
+					return nil
+				}
+
+				fi = linkfi
+			}
+
+			if fi.IsDir() {
+				if fi.Name() == ".git" ||
+					fi.Name() == "node_modules" || fi.Name() == "bower_components" {
+					return filepath.SkipDir
+				}
+				a = append(a, path)
+			}
+			return nil
+		}
+	}
+
+	symLinkWalker := newWalker(true)
+	regularWalker := newWalker(false)
+
+	// SymbolicWalk will log anny ERRORs
+	// Also note that the Dirnames fetched below will contain any relevant theme
+	// directories.
+	for _, contentDir := range c.hugo.PathSpec.BaseFs.Content.Dirnames {
+		_ = helpers.SymbolicWalk(c.Fs.Source, contentDir, symLinkWalker)
+	}
+
+	for _, staticDir := range c.hugo.PathSpec.BaseFs.Data.Dirnames {
+		_ = helpers.SymbolicWalk(c.Fs.Source, staticDir, regularWalker)
+	}
+
+	for _, staticDir := range c.hugo.PathSpec.BaseFs.I18n.Dirnames {
+		_ = helpers.SymbolicWalk(c.Fs.Source, staticDir, regularWalker)
+	}
+
+	for _, staticDir := range c.hugo.PathSpec.BaseFs.Layouts.Dirnames {
+		_ = helpers.SymbolicWalk(c.Fs.Source, staticDir, regularWalker)
+	}
+
+	for _, staticFilesystem := range c.hugo.PathSpec.BaseFs.Static {
+		for _, staticDir := range staticFilesystem.Dirnames {
+			_ = helpers.SymbolicWalk(c.Fs.Source, staticDir, regularWalker)
+		}
+	}
+
+	for _, assetDir := range c.hugo.PathSpec.BaseFs.Assets.Dirnames {
+		_ = helpers.SymbolicWalk(c.Fs.Source, assetDir, regularWalker)
+	}
+
+	if len(nested) > 0 {
+		for {
+
+			toWalk := nested
+			nested = nested[:0]
+
+			for _, d := range toWalk {
+				_ = helpers.SymbolicWalk(c.Fs.Source, d, symLinkWalker)
+			}
+
+			if len(nested) == 0 {
+				break
+			}
+		}
+	}
+
+	a = helpers.UniqueStrings(a)
+	sort.Strings(a)
+
+	return a, nil
+}
+
+func (c *commandeer) resetAndBuildSites() (err error) {
+	if !c.h.quiet {
+		c.Logger.FEEDBACK.Println("Started building sites ...")
+	}
+	return c.hugo.Build(hugolib.BuildCfg{ResetState: true})
+}
+
+func (c *commandeer) buildSites() (err error) {
+	return c.hugo.Build(hugolib.BuildCfg{})
+}
+
+func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
+	defer c.timeTrack(time.Now(), "Total")
+
+	visited := c.visitedURLs.PeekAllSet()
+	doLiveReload := !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
+	if doLiveReload && !c.Cfg.GetBool("disableFastRender") {
+
+		// Make sure we always render the home pages
+		for _, l := range c.languages {
+			langPath := c.hugo.PathSpec.GetLangSubDir(l.Lang)
+			if langPath != "" {
+				langPath = langPath + "/"
+			}
+			home := c.hugo.PathSpec.PrependBasePath("/" + langPath)
+			visited[home] = true
+		}
+
+	}
+	return c.hugo.Build(hugolib.BuildCfg{RecentlyVisited: visited}, events...)
+}
+
+func (c *commandeer) fullRebuild() {
+	c.commandeerHugoState = &commandeerHugoState{}
+	if err := c.loadConfig(true, true); err != nil {
+		jww.ERROR.Println("Failed to reload config:", err)
+	} else if err := c.buildSites(); err != nil {
+		jww.ERROR.Println(err)
+	} else if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
+		livereload.ForceRefresh()
+	}
+}
+
+// newWatcher creates a new watcher to watch filesystem events.
+func (c *commandeer) newWatcher(dirList ...string) (*watcher.Batcher, error) {
+	if runtime.GOOS == "darwin" {
+		tweakLimit()
+	}
+
+	staticSyncer, err := newStaticSyncer(c)
+	if err != nil {
+		return nil, err
+	}
+
+	watcher, err := watcher.New(1 * time.Second)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for _, d := range dirList {
+		if d != "" {
+			_ = watcher.Add(d)
+		}
+	}
+
+	// Identifies changes to config (config.toml) files.
+	configSet := make(map[string]bool)
+
+	for _, configFile := range c.configFiles {
+		c.Logger.FEEDBACK.Println("Watching for config changes in", configFile)
+		watcher.Add(configFile)
+		configSet[configFile] = true
+	}
+
+	go func() {
+		for {
+			select {
+			case evs := <-watcher.Events:
+				if len(evs) > 50 {
+					// This is probably a mass edit of the content dir.
+					// Schedule a full rebuild for when it slows down.
+					c.debounce(c.fullRebuild)
+					continue
+				}
+
+				c.Logger.INFO.Println("Received System Events:", evs)
+
+				staticEvents := []fsnotify.Event{}
+				dynamicEvents := []fsnotify.Event{}
+
+				// Special handling for symbolic links inside /content.
+				filtered := []fsnotify.Event{}
+				for _, ev := range evs {
+					if configSet[ev.Name] {
+						if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
+							continue
+						}
+						// Config file changed. Need full rebuild.
+						c.fullRebuild()
+						break
+					}
+
+					// Check the most specific first, i.e. files.
+					contentMapped := c.hugo.ContentChanges.GetSymbolicLinkMappings(ev.Name)
+					if len(contentMapped) > 0 {
+						for _, mapped := range contentMapped {
+							filtered = append(filtered, fsnotify.Event{Name: mapped, Op: ev.Op})
+						}
+						continue
+					}
+
+					// Check for any symbolic directory mapping.
+
+					dir, name := filepath.Split(ev.Name)
+
+					contentMapped = c.hugo.ContentChanges.GetSymbolicLinkMappings(dir)
+
+					if len(contentMapped) == 0 {
+						filtered = append(filtered, ev)
+						continue
+					}
+
+					for _, mapped := range contentMapped {
+						mappedFilename := filepath.Join(mapped, name)
+						filtered = append(filtered, fsnotify.Event{Name: mappedFilename, Op: ev.Op})
+					}
+				}
+
+				evs = filtered
+
+				for _, ev := range evs {
+					ext := filepath.Ext(ev.Name)
+					baseName := filepath.Base(ev.Name)
+					istemp := strings.HasSuffix(ext, "~") ||
+						(ext == ".swp") || // vim
+						(ext == ".swx") || // vim
+						(ext == ".tmp") || // generic temp file
+						(ext == ".DS_Store") || // OSX Thumbnail
+						baseName == "4913" || // vim
+						strings.HasPrefix(ext, ".goutputstream") || // gnome
+						strings.HasSuffix(ext, "jb_old___") || // intelliJ
+						strings.HasSuffix(ext, "jb_tmp___") || // intelliJ
+						strings.HasSuffix(ext, "jb_bak___") || // intelliJ
+						strings.HasPrefix(ext, ".sb-") || // byword
+						strings.HasPrefix(baseName, ".#") || // emacs
+						strings.HasPrefix(baseName, "#") // emacs
+					if istemp {
+						continue
+					}
+					// Sometimes during rm -rf operations a '"": REMOVE' is triggered. Just ignore these
+					if ev.Name == "" {
+						continue
+					}
+
+					// Write and rename operations are often followed by CHMOD.
+					// There may be valid use cases for rebuilding the site on CHMOD,
+					// but that will require more complex logic than this simple conditional.
+					// On OS X this seems to be related to Spotlight, see:
+					// https://github.com/go-fsnotify/fsnotify/issues/15
+					// A workaround is to put your site(s) on the Spotlight exception list,
+					// but that may be a little mysterious for most end users.
+					// So, for now, we skip reload on CHMOD.
+					// We do have to check for WRITE though. On slower laptops a Chmod
+					// could be aggregated with other important events, and we still want
+					// to rebuild on those
+					if ev.Op&(fsnotify.Chmod|fsnotify.Write|fsnotify.Create) == fsnotify.Chmod {
+						continue
+					}
+
+					walkAdder := func(path string, f os.FileInfo, err error) error {
+						if f.IsDir() {
+							c.Logger.FEEDBACK.Println("adding created directory to watchlist", path)
+							if err := watcher.Add(path); err != nil {
+								return err
+							}
+						} else if !staticSyncer.isStatic(path) {
+							// Hugo's rebuilding logic is entirely file based. When you drop a new folder into
+							// /content on OSX, the above logic will handle future watching of those files,
+							// but the initial CREATE is lost.
+							dynamicEvents = append(dynamicEvents, fsnotify.Event{Name: path, Op: fsnotify.Create})
+						}
+						return nil
+					}
+
+					// recursively add new directories to watch list
+					// When mkdir -p is used, only the top directory triggers an event (at least on OSX)
+					if ev.Op&fsnotify.Create == fsnotify.Create {
+						if s, err := c.Fs.Source.Stat(ev.Name); err == nil && s.Mode().IsDir() {
+							_ = helpers.SymbolicWalk(c.Fs.Source, ev.Name, walkAdder)
+						}
+					}
+
+					if staticSyncer.isStatic(ev.Name) {
+						staticEvents = append(staticEvents, ev)
+					} else {
+						dynamicEvents = append(dynamicEvents, ev)
+					}
+				}
+
+				if len(staticEvents) > 0 {
+					c.Logger.FEEDBACK.Println("\nStatic file changes detected")
+					const layout = "2006-01-02 15:04:05.000 -0700"
+					c.Logger.FEEDBACK.Println(time.Now().Format(layout))
+
+					if c.Cfg.GetBool("forceSyncStatic") {
+						c.Logger.FEEDBACK.Printf("Syncing all static files\n")
+						_, err := c.copyStatic()
+						if err != nil {
+							stopOnErr(c.Logger, err, "Error copying static files to publish dir")
+						}
+					} else {
+						if err := staticSyncer.syncsStaticEvents(staticEvents); err != nil {
+							c.Logger.ERROR.Println(err)
+							continue
+						}
+					}
+
+					if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
+						// Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
+
+						// force refresh when more than one file
+						if len(staticEvents) == 1 {
+							ev := staticEvents[0]
+							path := c.hugo.BaseFs.SourceFilesystems.MakeStaticPathRelative(ev.Name)
+							path = c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(path), false)
+							livereload.RefreshPath(path)
+						} else {
+							livereload.ForceRefresh()
+						}
+					}
+				}
+
+				if len(dynamicEvents) > 0 {
+					partitionedEvents := partitionDynamicEvents(
+						c.firstPathSpec().BaseFs.SourceFilesystems,
+						dynamicEvents)
+
+					doLiveReload := !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
+					onePageName := pickOneWriteOrCreatePath(partitionedEvents.ContentEvents)
+
+					c.Logger.FEEDBACK.Println("\nChange detected, rebuilding site")
+					const layout = "2006-01-02 15:04:05.000 -0700"
+					c.Logger.FEEDBACK.Println(time.Now().Format(layout))
+
+					c.changeDetector.PrepareNew()
+					if err := c.rebuildSites(dynamicEvents); err != nil {
+						c.Logger.ERROR.Println("Failed to rebuild site:", err)
+					}
+
+					if doLiveReload {
+						if len(partitionedEvents.ContentEvents) == 0 && len(partitionedEvents.AssetEvents) > 0 {
+							changed := c.changeDetector.changed()
+							if c.changeDetector != nil && len(changed) == 0 {
+								// Nothing has changed.
+								continue
+							} else if len(changed) == 1 {
+								pathToRefresh := c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(changed[0]), false)
+								livereload.RefreshPath(pathToRefresh)
+							} else {
+								livereload.ForceRefresh()
+							}
+						}
+
+						if len(partitionedEvents.ContentEvents) > 0 {
+
+							navigate := c.Cfg.GetBool("navigateToChanged")
+							// We have fetched the same page above, but it may have
+							// changed.
+							var p *hugolib.Page
+
+							if navigate {
+								if onePageName != "" {
+									p = c.hugo.GetContentPage(onePageName)
+								}
+							}
+
+							if p != nil {
+								livereload.NavigateToPathForPort(p.RelPermalink(), p.Site.ServerPort())
+							} else {
+								livereload.ForceRefresh()
+							}
+						}
+					}
+				}
+			case err := <-watcher.Errors:
+				if err != nil {
+					c.Logger.ERROR.Println(err)
+				}
+			}
+		}
+	}()
+
+	return watcher, nil
+}
+
+// dynamicEvents contains events that is considered dynamic, as in "not static".
+// Both of these categories will trigger a new build, but the asset events
+// does not fit into the "navigate to changed" logic.
+type dynamicEvents struct {
+	ContentEvents []fsnotify.Event
+	AssetEvents   []fsnotify.Event
+}
+
+func partitionDynamicEvents(sourceFs *filesystems.SourceFilesystems, events []fsnotify.Event) (de dynamicEvents) {
+	for _, e := range events {
+		if sourceFs.IsAsset(e.Name) {
+			de.AssetEvents = append(de.AssetEvents, e)
+		} else {
+			de.ContentEvents = append(de.ContentEvents, e)
+		}
+	}
+	return
+
+}
+
+func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
+	name := ""
+
+	// Some editors (for example notepad.exe on Windows) triggers a change
+	// both for directory and file. So we pick the longest path, which should
+	// be the file itself.
+	for _, ev := range events {
+		if (ev.Op&fsnotify.Write == fsnotify.Write || ev.Op&fsnotify.Create == fsnotify.Create) && len(ev.Name) > len(name) {
+			name = ev.Name
+		}
+	}
+
+	return name
+}
+
+// isThemeVsHugoVersionMismatch returns whether the current Hugo version is
+// less than any of the themes' min_version.
+func (c *commandeer) isThemeVsHugoVersionMismatch(fs afero.Fs) (mismatch bool, requiredMinVersion string) {
+	if !c.hugo.PathSpec.ThemeSet() {
+		return
+	}
+
+	for _, absThemeDir := range c.hugo.BaseFs.AbsThemeDirs {
+
+		path := filepath.Join(absThemeDir, "theme.toml")
+
+		exists, err := helpers.Exists(path, fs)
+
+		if err != nil || !exists {
+			continue
+		}
+
+		b, err := afero.ReadFile(fs, path)
+
+		tomlMeta, err := parser.HandleTOMLMetaData(b)
+
+		if err != nil {
+			continue
+		}
+
+		if minVersion, ok := tomlMeta["min_version"]; ok {
+			if helpers.CompareVersion(minVersion) > 0 {
+				return true, fmt.Sprint(minVersion)
+			}
+		}
+
+	}
+
+	return
+}

commands/hugo_windows.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// 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.
@@ -13,21 +13,15 @@
 
 package commands
 
-import (
+import "github.com/spf13/cobra"
-	// 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
 	cobra.MousetrapHelpText = `
 
-  Hugo is a command-line tool for generating static websites.
+  Hugo is a command-line tool for generating static website.
-
-  You need to open PowerShell and run Hugo from there.
 
+  You need to open cmd.exe and run Hugo from there.
+  
   Visit https://gohugo.io/ for more information.`
 }

commands/import.go

@@ -1,618 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package commands
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-
-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/htime"
-	"github.com/gohugoio/hugo/common/hugio"
-	"github.com/gohugoio/hugo/common/maps"
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/parser"
-	"github.com/gohugoio/hugo/parser/metadecoders"
-	"github.com/gohugoio/hugo/parser/pageparser"
-	"github.com/spf13/afero"
-	"github.com/spf13/cobra"
-)
-
-func newImportCommand() *importCommand {
-	var c *importCommand
-	c = &importCommand{
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "jekyll",
-				short: "hugo import from Jekyll",
-				long: `hugo import from Jekyll.
-		
-Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					if len(args) < 2 {
-						return newUserError(`import from jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.")
-					}
-					return c.importFromJekyll(args)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					cmd.Flags().BoolVar(&c.force, "force", false, "allow import into non-empty target directory")
-				},
-			},
-		},
-	}
-
-	return c
-}
-
-type importCommand struct {
-	r *rootCommand
-
-	force bool
-
-	commands []simplecobra.Commander
-}
-
-func (c *importCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *importCommand) Name() string {
-	return "import"
-}
-
-func (c *importCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	return nil
-}
-
-func (c *importCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Import a site from another system"
-	cmd.Long = `Import a site from another system.
-
-Import requires a subcommand, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`."
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *importCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	return nil
-}
-
-func (i *importCommand) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]any) (err error) {
-	title := "My New Hugo Site"
-	baseURL := "http://example.org/"
-
-	for key, value := range jekyllConfig {
-		lowerKey := strings.ToLower(key)
-
-		switch lowerKey {
-		case "title":
-			if str, ok := value.(string); ok {
-				title = str
-			}
-
-		case "url":
-			if str, ok := value.(string); ok {
-				baseURL = str
-			}
-		}
-	}
-
-	in := map[string]any{
-		"baseURL":            baseURL,
-		"title":              title,
-		"languageCode":       "en-us",
-		"disablePathToLower": true,
-	}
-
-	var buf bytes.Buffer
-	err = parser.InterfaceToConfig(in, kind, &buf)
-	if err != nil {
-		return err
-	}
-
-	return helpers.WriteToDisk(filepath.Join(inpath, "hugo."+string(kind)), &buf, fs)
-}
-
-func (c *importCommand) getJekyllDirInfo(fs afero.Fs, jekyllRoot string) (map[string]bool, bool) {
-	postDirs := make(map[string]bool)
-	hasAnyPost := false
-	if entries, err := os.ReadDir(jekyllRoot); err == nil {
-		for _, entry := range entries {
-			if entry.IsDir() {
-				subDir := filepath.Join(jekyllRoot, entry.Name())
-				if isPostDir, hasAnyPostInDir := c.retrieveJekyllPostDir(fs, subDir); isPostDir {
-					postDirs[entry.Name()] = hasAnyPostInDir
-					if hasAnyPostInDir {
-						hasAnyPost = true
-					}
-				}
-			}
-		}
-	}
-	return postDirs, hasAnyPost
-}
-
-func (c *importCommand) createSiteFromJekyll(jekyllRoot, targetDir string, jekyllPostDirs map[string]bool) error {
-	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")
-		}
-
-		isEmpty, _ := helpers.IsEmpty(targetDir, fs)
-
-		if !isEmpty && !c.force {
-			return errors.New("target path \"" + targetDir + "\" exists and is not empty")
-		}
-	}
-
-	jekyllConfig := c.loadJekyllConfig(fs, jekyllRoot)
-
-	mkdir(targetDir, "layouts")
-	mkdir(targetDir, "content")
-	mkdir(targetDir, "archetypes")
-	mkdir(targetDir, "static")
-	mkdir(targetDir, "data")
-	mkdir(targetDir, "themes")
-
-	c.createConfigFromJekyll(fs, targetDir, "yaml", jekyllConfig)
-
-	c.copyJekyllFilesAndFolders(jekyllRoot, filepath.Join(targetDir, "static"), jekyllPostDirs)
-
-	return nil
-}
-
-func (c *importCommand) convertJekyllContent(m any, content string) (string, error) {
-	metadata, _ := maps.ToStringMapE(m)
-
-	lines := strings.Split(content, "\n")
-	var resultLines []string
-	for _, line := range lines {
-		resultLines = append(resultLines, strings.Trim(line, "\r\n"))
-	}
-
-	content = strings.Join(resultLines, "\n")
-
-	excerptSep := "<!--more-->"
-	if value, ok := metadata["excerpt_separator"]; ok {
-		if str, strOk := value.(string); strOk {
-			content = strings.Replace(content, strings.TrimSpace(str), excerptSep, -1)
-		}
-	}
-
-	replaceList := []struct {
-		re      *regexp.Regexp
-		replace string
-	}{
-		{regexp.MustCompile("(?i)<!-- more -->"), "<!--more-->"},
-		{regexp.MustCompile(`\{%\s*raw\s*%\}\s*(.*?)\s*\{%\s*endraw\s*%\}`), "$1"},
-		{regexp.MustCompile(`{%\s*endhighlight\s*%}`), "{{< / highlight >}}"},
-	}
-
-	for _, replace := range replaceList {
-		content = replace.re.ReplaceAllString(content, replace.replace)
-	}
-
-	replaceListFunc := []struct {
-		re      *regexp.Regexp
-		replace func(string) string
-	}{
-		// Octopress image tag: http://octopress.org/docs/plugins/image-tag/
-		{regexp.MustCompile(`{%\s+img\s*(.*?)\s*%}`), c.replaceImageTag},
-		{regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`), c.replaceHighlightTag},
-	}
-
-	for _, replace := range replaceListFunc {
-		content = replace.re.ReplaceAllStringFunc(content, replace.replace)
-	}
-
-	var buf bytes.Buffer
-	if len(metadata) != 0 {
-		err := parser.InterfaceToFrontMatter(m, metadecoders.YAML, &buf)
-		if err != nil {
-			return "", err
-		}
-	}
-	buf.WriteString(content)
-
-	return buf.String(), nil
-}
-
-func (c *importCommand) convertJekyllMetaData(m any, postName string, postDate time.Time, draft bool) (any, error) {
-	metadata, err := maps.ToStringMapE(m)
-	if err != nil {
-		return nil, err
-	}
-
-	if draft {
-		metadata["draft"] = true
-	}
-
-	for key, value := range metadata {
-		lowerKey := strings.ToLower(key)
-
-		switch lowerKey {
-		case "layout":
-			delete(metadata, key)
-		case "permalink":
-			if str, ok := value.(string); ok {
-				metadata["url"] = str
-			}
-			delete(metadata, key)
-		case "category":
-			if str, ok := value.(string); ok {
-				metadata["categories"] = []string{str}
-			}
-			delete(metadata, key)
-		case "excerpt_separator":
-			if key != lowerKey {
-				delete(metadata, key)
-				metadata[lowerKey] = value
-			}
-		case "date":
-			if str, ok := value.(string); ok {
-				re := regexp.MustCompile(`(\d+):(\d+):(\d+)`)
-				r := re.FindAllStringSubmatch(str, -1)
-				if len(r) > 0 {
-					hour, _ := strconv.Atoi(r[0][1])
-					minute, _ := strconv.Atoi(r[0][2])
-					second, _ := strconv.Atoi(r[0][3])
-					postDate = time.Date(postDate.Year(), postDate.Month(), postDate.Day(), hour, minute, second, 0, time.UTC)
-				}
-			}
-			delete(metadata, key)
-		}
-
-	}
-
-	metadata["date"] = postDate.Format(time.RFC3339)
-
-	return metadata, nil
-}
-
-func (c *importCommand) convertJekyllPost(path, relPath, targetDir string, draft bool) error {
-	log.Println("Converting", path)
-
-	filename := filepath.Base(path)
-	postDate, postName, err := c.parseJekyllFilename(filename)
-	if err != nil {
-		c.r.Printf("Failed to parse filename '%s': %s. Skipping.", filename, err)
-		return nil
-	}
-
-	log.Println(filename, postDate, postName)
-
-	targetFile := filepath.Join(targetDir, relPath)
-	targetParentDir := filepath.Dir(targetFile)
-	os.MkdirAll(targetParentDir, 0o777)
-
-	contentBytes, err := os.ReadFile(path)
-	if err != nil {
-		c.r.logger.Errorln("Read file error:", path)
-		return err
-	}
-	pf, err := pageparser.ParseFrontMatterAndContent(bytes.NewReader(contentBytes))
-	if err != nil {
-		return fmt.Errorf("failed to parse file %q: %s", filename, err)
-	}
-	newmetadata, err := c.convertJekyllMetaData(pf.FrontMatter, postName, postDate, draft)
-	if err != nil {
-		return fmt.Errorf("failed to convert metadata for file %q: %s", filename, err)
-	}
-
-	content, err := c.convertJekyllContent(newmetadata, string(pf.Content))
-	if err != nil {
-		return fmt.Errorf("failed to convert content for file %q: %s", filename, err)
-	}
-
-	fs := hugofs.Os
-	if err := helpers.WriteToDisk(targetFile, strings.NewReader(content), fs); err != nil {
-		return fmt.Errorf("failed to save file %q: %s", filename, err)
-	}
-	return nil
-}
-
-func (c *importCommand) copyJekyllFilesAndFolders(jekyllRoot, dest string, jekyllPostDirs map[string]bool) (err error) {
-	fs := hugofs.Os
-
-	fi, err := fs.Stat(jekyllRoot)
-	if err != nil {
-		return err
-	}
-	if !fi.IsDir() {
-		return errors.New(jekyllRoot + " is not a directory")
-	}
-	err = os.MkdirAll(dest, fi.Mode())
-	if err != nil {
-		return err
-	}
-	entries, err := os.ReadDir(jekyllRoot)
-	if err != nil {
-		return err
-	}
-
-	for _, entry := range entries {
-		sfp := filepath.Join(jekyllRoot, entry.Name())
-		dfp := filepath.Join(dest, entry.Name())
-		if entry.IsDir() {
-			if entry.Name()[0] != '_' && entry.Name()[0] != '.' {
-				if _, ok := jekyllPostDirs[entry.Name()]; !ok {
-					err = hugio.CopyDir(fs, sfp, dfp, nil)
-					if err != nil {
-						c.r.logger.Errorln(err)
-					}
-				}
-			}
-		} else {
-			lowerEntryName := strings.ToLower(entry.Name())
-			exceptSuffix := []string{
-				".md", ".markdown", ".html", ".htm",
-				".xml", ".textile", "rakefile", "gemfile", ".lock",
-			}
-			isExcept := false
-			for _, suffix := range exceptSuffix {
-				if strings.HasSuffix(lowerEntryName, suffix) {
-					isExcept = true
-					break
-				}
-			}
-
-			if !isExcept && entry.Name()[0] != '.' && entry.Name()[0] != '_' {
-				err = hugio.CopyFile(fs, sfp, dfp)
-				if err != nil {
-					c.r.logger.Errorln(err)
-				}
-			}
-		}
-
-	}
-	return nil
-}
-
-func (c *importCommand) importFromJekyll(args []string) error {
-	jekyllRoot, err := filepath.Abs(filepath.Clean(args[0]))
-	if err != nil {
-		return newUserError("path error:", args[0])
-	}
-
-	targetDir, err := filepath.Abs(filepath.Clean(args[1]))
-	if err != nil {
-		return newUserError("path error:", args[1])
-	}
-
-	c.r.Println("Import Jekyll from:", jekyllRoot, "to:", targetDir)
-
-	if strings.HasPrefix(filepath.Dir(targetDir), jekyllRoot) {
-		return newUserError("abort: target path should not be inside the Jekyll root")
-	}
-
-	fs := afero.NewOsFs()
-	jekyllPostDirs, hasAnyPost := c.getJekyllDirInfo(fs, jekyllRoot)
-	if !hasAnyPost {
-		return errors.New("abort: jekyll root contains neither posts nor drafts")
-	}
-
-	err = c.createSiteFromJekyll(jekyllRoot, targetDir, jekyllPostDirs)
-	if err != nil {
-		return newUserError(err)
-	}
-
-	c.r.Println("Importing...")
-
-	fileCount := 0
-	callback := func(path string, fi hugofs.FileMetaInfo) error {
-		if fi.IsDir() {
-			return nil
-		}
-
-		relPath, err := filepath.Rel(jekyllRoot, path)
-		if err != nil {
-			return newUserError("get rel path error:", path)
-		}
-
-		relPath = filepath.ToSlash(relPath)
-		draft := false
-
-		switch {
-		case strings.Contains(relPath, "_posts/"):
-			relPath = filepath.Join("content/post", strings.Replace(relPath, "_posts/", "", -1))
-		case strings.Contains(relPath, "_drafts/"):
-			relPath = filepath.Join("content/draft", strings.Replace(relPath, "_drafts/", "", -1))
-			draft = true
-		default:
-			return nil
-		}
-
-		fileCount++
-		return c.convertJekyllPost(path, relPath, targetDir, draft)
-	}
-
-	for jekyllPostDir, hasAnyPostInDir := range jekyllPostDirs {
-		if hasAnyPostInDir {
-			if err = helpers.Walk(hugofs.Os, filepath.Join(jekyllRoot, jekyllPostDir), callback); err != nil {
-				return err
-			}
-		}
-	}
-
-	c.r.Println("Congratulations!", fileCount, "post(s) imported!")
-	c.r.Println("Now, start Hugo by yourself:\n")
-	c.r.Println("cd " + args[1])
-	c.r.Println("git init")
-	c.r.Println("git submodule add https://github.com/theNewDynamic/gohugo-theme-ananke themes/ananke")
-	c.r.Println("echo \"theme = 'ananke'\" > hugo.toml")
-	c.r.Println("hugo server")
-
-	return nil
-}
-
-func (c *importCommand) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]any {
-	path := filepath.Join(jekyllRoot, "_config.yml")
-
-	exists, err := helpers.Exists(path, fs)
-
-	if err != nil || !exists {
-		c.r.Println("_config.yaml not found: Is the specified Jekyll root correct?")
-		return nil
-	}
-
-	f, err := fs.Open(path)
-	if err != nil {
-		return nil
-	}
-
-	defer f.Close()
-
-	b, err := io.ReadAll(f)
-	if err != nil {
-		return nil
-	}
-
-	m, err := metadecoders.Default.UnmarshalToMap(b, metadecoders.YAML)
-	if err != nil {
-		return nil
-	}
-
-	return m
-}
-
-func (c *importCommand) parseJekyllFilename(filename string) (time.Time, string, error) {
-	re := regexp.MustCompile(`(\d+-\d+-\d+)-(.+)\..*`)
-	r := re.FindAllStringSubmatch(filename, -1)
-	if len(r) == 0 {
-		return htime.Now(), "", errors.New("filename not match")
-	}
-
-	postDate, err := time.Parse("2006-1-2", r[0][1])
-	if err != nil {
-		return htime.Now(), "", err
-	}
-
-	postName := r[0][2]
-
-	return postDate, postName, nil
-}
-
-func (c *importCommand) replaceHighlightTag(match string) string {
-	r := regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`)
-	parts := r.FindStringSubmatch(match)
-	lastQuote := rune(0)
-	f := func(c rune) bool {
-		switch {
-		case c == lastQuote:
-			lastQuote = rune(0)
-			return false
-		case lastQuote != rune(0):
-			return false
-		case unicode.In(c, unicode.Quotation_Mark):
-			lastQuote = c
-			return false
-		default:
-			return unicode.IsSpace(c)
-		}
-	}
-	// splitting string by space but considering quoted section
-	items := strings.FieldsFunc(parts[1], f)
-
-	result := bytes.NewBufferString("{{< highlight ")
-	result.WriteString(items[0]) // language
-	options := items[1:]
-	for i, opt := range options {
-		opt = strings.Replace(opt, "\"", "", -1)
-		if opt == "linenos" {
-			opt = "linenos=table"
-		}
-		if i == 0 {
-			opt = " \"" + opt
-		}
-		if i < len(options)-1 {
-			opt += ","
-		} else if i == len(options)-1 {
-			opt += "\""
-		}
-		result.WriteString(opt)
-	}
-
-	result.WriteString(" >}}")
-	return result.String()
-}
-
-func (c *importCommand) replaceImageTag(match string) string {
-	r := regexp.MustCompile(`{%\s+img\s*(\p{L}*)\s+([\S]*/[\S]+)\s+(\d*)\s*(\d*)\s*(.*?)\s*%}`)
-	result := bytes.NewBufferString("{{< figure ")
-	parts := r.FindStringSubmatch(match)
-	// Index 0 is the entire string, ignore
-	c.replaceOptionalPart(result, "class", parts[1])
-	c.replaceOptionalPart(result, "src", parts[2])
-	c.replaceOptionalPart(result, "width", parts[3])
-	c.replaceOptionalPart(result, "height", parts[4])
-	// title + alt
-	part := parts[5]
-	if len(part) > 0 {
-		splits := strings.Split(part, "'")
-		lenSplits := len(splits)
-		if lenSplits == 1 {
-			c.replaceOptionalPart(result, "title", splits[0])
-		} else if lenSplits == 3 {
-			c.replaceOptionalPart(result, "title", splits[1])
-		} else if lenSplits == 5 {
-			c.replaceOptionalPart(result, "title", splits[1])
-			c.replaceOptionalPart(result, "alt", splits[3])
-		}
-	}
-	result.WriteString(">}}")
-	return result.String()
-}
-
-func (c *importCommand) replaceOptionalPart(buffer *bytes.Buffer, partName string, part string) {
-	if len(part) > 0 {
-		buffer.WriteString(partName + "=\"" + part + "\" ")
-	}
-}
-
-func (c *importCommand) retrieveJekyllPostDir(fs afero.Fs, dir string) (bool, bool) {
-	if strings.HasSuffix(dir, "_posts") || strings.HasSuffix(dir, "_drafts") {
-		isEmpty, _ := helpers.IsEmpty(dir, fs)
-		return true, !isEmpty
-	}
-
-	if entries, err := os.ReadDir(dir); err == nil {
-		for _, entry := range entries {
-			if entry.IsDir() {
-				subDir := filepath.Join(dir, entry.Name())
-				if isPostDir, hasAnyPost := c.retrieveJekyllPostDir(fs, subDir); isPostDir {
-					return isPostDir, hasAnyPost
-				}
-			}
-		}
-	}
-
-	return false, true
-}

commands/import_jekyll.go

@@ -0,0 +1,614 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"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/cast"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*importCmd)(nil)
+
+type importCmd struct {
+	*baseCmd
+}
+
+func newImportCmd() *importCmd {
+	cc := &importCmd{}
+
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "import",
+		Short: "Import your site from others.",
+		Long: `Import your site from other web site generators like Jekyll.
+
+Import requires a subcommand, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
+		RunE: nil,
+	})
+
+	importJekyllCmd := &cobra.Command{
+		Use:   "jekyll",
+		Short: "hugo import from Jekyll",
+		Long: `hugo import from Jekyll.
+
+Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
+		RunE: cc.importFromJekyll,
+	}
+
+	importJekyllCmd.Flags().Bool("force", false, "allow import into non-empty target directory")
+
+	cc.cmd.AddCommand(importJekyllCmd)
+
+	return cc
+
+}
+
+func (i *importCmd) importFromJekyll(cmd *cobra.Command, args []string) error {
+
+	if len(args) < 2 {
+		return newUserError(`Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.")
+	}
+
+	jekyllRoot, err := filepath.Abs(filepath.Clean(args[0]))
+	if err != nil {
+		return newUserError("Path error:", args[0])
+	}
+
+	targetDir, err := filepath.Abs(filepath.Clean(args[1]))
+	if err != nil {
+		return newUserError("Path error:", args[1])
+	}
+
+	jww.INFO.Println("Import Jekyll from:", jekyllRoot, "to:", targetDir)
+
+	if strings.HasPrefix(filepath.Dir(targetDir), jekyllRoot) {
+		return newUserError("Target path should not be inside the Jekyll root, aborting.")
+	}
+
+	forceImport, _ := cmd.Flags().GetBool("force")
+
+	fs := afero.NewOsFs()
+	jekyllPostDirs, hasAnyPost := i.getJekyllDirInfo(fs, jekyllRoot)
+	if !hasAnyPost {
+		return errors.New("Your Jekyll root contains neither posts nor drafts, aborting.")
+	}
+
+	site, err := i.createSiteFromJekyll(jekyllRoot, targetDir, jekyllPostDirs, forceImport)
+
+	if err != nil {
+		return newUserError(err)
+	}
+
+	jww.FEEDBACK.Println("Importing...")
+
+	fileCount := 0
+	callback := func(path string, fi os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if fi.IsDir() {
+			return nil
+		}
+
+		relPath, err := filepath.Rel(jekyllRoot, path)
+		if err != nil {
+			return newUserError("Get rel path error:", path)
+		}
+
+		relPath = filepath.ToSlash(relPath)
+		draft := false
+
+		switch {
+		case strings.Contains(relPath, "_posts/"):
+			relPath = filepath.Join("content/post", strings.Replace(relPath, "_posts/", "", -1))
+		case strings.Contains(relPath, "_drafts/"):
+			relPath = filepath.Join("content/draft", strings.Replace(relPath, "_drafts/", "", -1))
+			draft = true
+		default:
+			return nil
+		}
+
+		fileCount++
+		return convertJekyllPost(site, path, relPath, targetDir, draft)
+	}
+
+	for jekyllPostDir, hasAnyPostInDir := range jekyllPostDirs {
+		if hasAnyPostInDir {
+			if err = helpers.SymbolicWalk(hugofs.Os, filepath.Join(jekyllRoot, jekyllPostDir), callback); err != nil {
+				return err
+			}
+		}
+	}
+
+	jww.FEEDBACK.Println("Congratulations!", fileCount, "post(s) imported!")
+	jww.FEEDBACK.Println("Now, start Hugo by yourself:\n" +
+		"$ git clone https://github.com/spf13/herring-cove.git " + args[1] + "/themes/herring-cove")
+	jww.FEEDBACK.Println("$ cd " + args[1] + "\n$ hugo server --theme=herring-cove")
+
+	return nil
+}
+
+func (i *importCmd) getJekyllDirInfo(fs afero.Fs, jekyllRoot string) (map[string]bool, bool) {
+	postDirs := make(map[string]bool)
+	hasAnyPost := false
+	if entries, err := ioutil.ReadDir(jekyllRoot); err == nil {
+		for _, entry := range entries {
+			if entry.IsDir() {
+				subDir := filepath.Join(jekyllRoot, entry.Name())
+				if isPostDir, hasAnyPostInDir := i.retrieveJekyllPostDir(fs, subDir); isPostDir {
+					postDirs[entry.Name()] = hasAnyPostInDir
+					if hasAnyPostInDir {
+						hasAnyPost = true
+					}
+				}
+			}
+		}
+	}
+	return postDirs, hasAnyPost
+}
+
+func (i *importCmd) retrieveJekyllPostDir(fs afero.Fs, dir string) (bool, bool) {
+	if strings.HasSuffix(dir, "_posts") || strings.HasSuffix(dir, "_drafts") {
+		isEmpty, _ := helpers.IsEmpty(dir, fs)
+		return true, !isEmpty
+	}
+
+	if entries, err := ioutil.ReadDir(dir); err == nil {
+		for _, entry := range entries {
+			if entry.IsDir() {
+				subDir := filepath.Join(dir, entry.Name())
+				if isPostDir, hasAnyPost := i.retrieveJekyllPostDir(fs, subDir); isPostDir {
+					return isPostDir, hasAnyPost
+				}
+			}
+		}
+	}
+
+	return false, true
+}
+
+func (i *importCmd) createSiteFromJekyll(jekyllRoot, targetDir string, jekyllPostDirs map[string]bool, force bool) (*hugolib.Site, error) {
+	s, err := hugolib.NewSiteDefaultLang()
+	if err != nil {
+		return nil, err
+	}
+
+	fs := s.Fs.Source
+	if exists, _ := helpers.Exists(targetDir, fs); exists {
+		if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
+			return nil, errors.New("Target path \"" + targetDir + "\" already exists but not a directory")
+		}
+
+		isEmpty, _ := helpers.IsEmpty(targetDir, fs)
+
+		if !isEmpty && !force {
+			return nil, errors.New("Target path \"" + targetDir + "\" already exists and is not empty")
+		}
+	}
+
+	jekyllConfig := i.loadJekyllConfig(fs, jekyllRoot)
+
+	mkdir(targetDir, "layouts")
+	mkdir(targetDir, "content")
+	mkdir(targetDir, "archetypes")
+	mkdir(targetDir, "static")
+	mkdir(targetDir, "data")
+	mkdir(targetDir, "themes")
+
+	i.createConfigFromJekyll(fs, targetDir, "yaml", jekyllConfig)
+
+	i.copyJekyllFilesAndFolders(jekyllRoot, filepath.Join(targetDir, "static"), jekyllPostDirs)
+
+	return s, nil
+}
+
+func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]interface{} {
+	path := filepath.Join(jekyllRoot, "_config.yml")
+
+	exists, err := helpers.Exists(path, fs)
+
+	if err != nil || !exists {
+		jww.WARN.Println("_config.yaml not found: Is the specified Jekyll root correct?")
+		return nil
+	}
+
+	f, err := fs.Open(path)
+	if err != nil {
+		return nil
+	}
+
+	defer f.Close()
+
+	b, err := ioutil.ReadAll(f)
+
+	if err != nil {
+		return nil
+	}
+
+	c, err := parser.HandleYAMLMetaData(b)
+
+	if err != nil {
+		return nil
+	}
+
+	return c
+}
+
+func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind string, jekyllConfig map[string]interface{}) (err error) {
+	title := "My New Hugo Site"
+	baseURL := "http://example.org/"
+
+	for key, value := range jekyllConfig {
+		lowerKey := strings.ToLower(key)
+
+		switch lowerKey {
+		case "title":
+			if str, ok := value.(string); ok {
+				title = str
+			}
+
+		case "url":
+			if str, ok := value.(string); ok {
+				baseURL = str
+			}
+		}
+	}
+
+	in := map[string]interface{}{
+		"baseURL":            baseURL,
+		"title":              title,
+		"languageCode":       "en-us",
+		"disablePathToLower": true,
+	}
+	kind = parser.FormatSanitize(kind)
+
+	var buf bytes.Buffer
+	err = parser.InterfaceToConfig(in, parser.FormatToLeadRune(kind), &buf)
+	if err != nil {
+		return err
+	}
+
+	return helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), &buf, fs)
+}
+
+func copyFile(source string, dest string) error {
+	sf, err := os.Open(source)
+	if err != nil {
+		return err
+	}
+	defer sf.Close()
+	df, err := os.Create(dest)
+	if err != nil {
+		return err
+	}
+	defer df.Close()
+	_, err = io.Copy(df, sf)
+	if err == nil {
+		si, err := os.Stat(source)
+		if err != nil {
+			err = os.Chmod(dest, si.Mode())
+
+			if err != nil {
+				return err
+			}
+		}
+
+	}
+	return nil
+}
+
+func copyDir(source string, dest string) error {
+	fi, err := os.Stat(source)
+	if err != nil {
+		return err
+	}
+	if !fi.IsDir() {
+		return errors.New(source + " is not a directory")
+	}
+	err = os.MkdirAll(dest, fi.Mode())
+	if err != nil {
+		return err
+	}
+	entries, err := ioutil.ReadDir(source)
+	for _, entry := range entries {
+		sfp := filepath.Join(source, entry.Name())
+		dfp := filepath.Join(dest, entry.Name())
+		if entry.IsDir() {
+			err = copyDir(sfp, dfp)
+			if err != nil {
+				jww.ERROR.Println(err)
+			}
+		} else {
+			err = copyFile(sfp, dfp)
+			if err != nil {
+				jww.ERROR.Println(err)
+			}
+		}
+
+	}
+	return nil
+}
+
+func (i *importCmd) copyJekyllFilesAndFolders(jekyllRoot, dest string, jekyllPostDirs map[string]bool) (err error) {
+	fi, err := os.Stat(jekyllRoot)
+	if err != nil {
+		return err
+	}
+	if !fi.IsDir() {
+		return errors.New(jekyllRoot + " is not a directory")
+	}
+	err = os.MkdirAll(dest, fi.Mode())
+	if err != nil {
+		return err
+	}
+	entries, err := ioutil.ReadDir(jekyllRoot)
+	for _, entry := range entries {
+		sfp := filepath.Join(jekyllRoot, entry.Name())
+		dfp := filepath.Join(dest, entry.Name())
+		if entry.IsDir() {
+			if entry.Name()[0] != '_' && entry.Name()[0] != '.' {
+				if _, ok := jekyllPostDirs[entry.Name()]; !ok {
+					err = copyDir(sfp, dfp)
+					if err != nil {
+						jww.ERROR.Println(err)
+					}
+				}
+			}
+		} else {
+			lowerEntryName := strings.ToLower(entry.Name())
+			exceptSuffix := []string{".md", ".markdown", ".html", ".htm",
+				".xml", ".textile", "rakefile", "gemfile", ".lock"}
+			isExcept := false
+			for _, suffix := range exceptSuffix {
+				if strings.HasSuffix(lowerEntryName, suffix) {
+					isExcept = true
+					break
+				}
+			}
+
+			if !isExcept && entry.Name()[0] != '.' && entry.Name()[0] != '_' {
+				err = copyFile(sfp, dfp)
+				if err != nil {
+					jww.ERROR.Println(err)
+				}
+			}
+		}
+
+	}
+	return nil
+}
+
+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")
+	}
+
+	postDate, err := time.Parse("2006-1-2", r[0][1])
+	if err != nil {
+		return time.Now(), "", err
+	}
+
+	postName := r[0][2]
+
+	return postDate, postName, nil
+}
+
+func convertJekyllPost(s *hugolib.Site, path, relPath, targetDir string, draft bool) error {
+	jww.TRACE.Println("Converting", path)
+
+	filename := filepath.Base(path)
+	postDate, postName, err := parseJekyllFilename(filename)
+	if err != nil {
+		jww.WARN.Printf("Failed to parse filename '%s': %s. Skipping.", filename, err)
+		return nil
+	}
+
+	jww.TRACE.Println(filename, postDate, postName)
+
+	targetFile := filepath.Join(targetDir, relPath)
+	targetParentDir := filepath.Dir(targetFile)
+	os.MkdirAll(targetParentDir, 0777)
+
+	contentBytes, err := ioutil.ReadFile(path)
+	if err != nil {
+		jww.ERROR.Println("Read file error:", path)
+		return err
+	}
+
+	psr, err := parser.ReadFrom(bytes.NewReader(contentBytes))
+	if err != nil {
+		jww.ERROR.Println("Parse file error:", path)
+		return err
+	}
+
+	metadata, err := psr.Metadata()
+	if err != nil {
+		jww.ERROR.Println("Processing file error:", path)
+		return err
+	}
+
+	newmetadata, err := convertJekyllMetaData(metadata, postName, postDate, draft)
+	if err != nil {
+		jww.ERROR.Println("Convert metadata error:", path)
+		return err
+	}
+
+	jww.TRACE.Println(newmetadata)
+	content := convertJekyllContent(newmetadata, string(psr.Content()))
+
+	page, err := s.NewPage(filename)
+	if err != nil {
+		jww.ERROR.Println("New page error", filename)
+		return err
+	}
+
+	page.SetSourceContent([]byte(content))
+	page.SetSourceMetaData(newmetadata, parser.FormatToLeadRune("yaml"))
+	page.SaveSourceAs(targetFile)
+
+	jww.TRACE.Println("Target file:", targetFile)
+
+	return nil
+}
+
+func convertJekyllMetaData(m interface{}, postName string, postDate time.Time, draft bool) (interface{}, error) {
+	metadata, err := cast.ToStringMapE(m)
+	if err != nil {
+		return nil, err
+	}
+
+	if draft {
+		metadata["draft"] = true
+	}
+
+	for key, value := range metadata {
+		lowerKey := strings.ToLower(key)
+
+		switch lowerKey {
+		case "layout":
+			delete(metadata, key)
+		case "permalink":
+			if str, ok := value.(string); ok {
+				metadata["url"] = str
+			}
+			delete(metadata, key)
+		case "category":
+			if str, ok := value.(string); ok {
+				metadata["categories"] = []string{str}
+			}
+			delete(metadata, key)
+		case "excerpt_separator":
+			if key != lowerKey {
+				delete(metadata, key)
+				metadata[lowerKey] = value
+			}
+		case "date":
+			if str, ok := value.(string); ok {
+				re := regexp.MustCompile(`(\d+):(\d+):(\d+)`)
+				r := re.FindAllStringSubmatch(str, -1)
+				if len(r) > 0 {
+					hour, _ := strconv.Atoi(r[0][1])
+					minute, _ := strconv.Atoi(r[0][2])
+					second, _ := strconv.Atoi(r[0][3])
+					postDate = time.Date(postDate.Year(), postDate.Month(), postDate.Day(), hour, minute, second, 0, time.UTC)
+				}
+			}
+			delete(metadata, key)
+		}
+
+	}
+
+	metadata["date"] = postDate.Format(time.RFC3339)
+
+	return metadata, nil
+}
+
+func convertJekyllContent(m interface{}, content string) string {
+	metadata, _ := cast.ToStringMapE(m)
+
+	lines := strings.Split(content, "\n")
+	var resultLines []string
+	for _, line := range lines {
+		resultLines = append(resultLines, strings.Trim(line, "\r\n"))
+	}
+
+	content = strings.Join(resultLines, "\n")
+
+	excerptSep := "<!--more-->"
+	if value, ok := metadata["excerpt_separator"]; ok {
+		if str, strOk := value.(string); strOk {
+			content = strings.Replace(content, strings.TrimSpace(str), excerptSep, -1)
+		}
+	}
+
+	replaceList := []struct {
+		re      *regexp.Regexp
+		replace string
+	}{
+		{regexp.MustCompile("(?i)<!-- more -->"), "<!--more-->"},
+		{regexp.MustCompile(`\{%\s*raw\s*%\}\s*(.*?)\s*\{%\s*endraw\s*%\}`), "$1"},
+		{regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`), "{{< highlight $1 >}}"},
+		{regexp.MustCompile(`{%\s*endhighlight\s*%}`), "{{< / highlight >}}"},
+	}
+
+	for _, replace := range replaceList {
+		content = replace.re.ReplaceAllString(content, replace.replace)
+	}
+
+	replaceListFunc := []struct {
+		re      *regexp.Regexp
+		replace func(string) string
+	}{
+		// Octopress image tag: http://octopress.org/docs/plugins/image-tag/
+		{regexp.MustCompile(`{%\s+img\s*(.*?)\s*%}`), replaceImageTag},
+	}
+
+	for _, replace := range replaceListFunc {
+		content = replace.re.ReplaceAllStringFunc(content, replace.replace)
+	}
+
+	return content
+}
+
+func replaceImageTag(match string) string {
+	r := regexp.MustCompile(`{%\s+img\s*(\p{L}*)\s+([\S]*/[\S]+)\s+(\d*)\s*(\d*)\s*(.*?)\s*%}`)
+	result := bytes.NewBufferString("{{< figure ")
+	parts := r.FindStringSubmatch(match)
+	// Index 0 is the entire string, ignore
+	replaceOptionalPart(result, "class", parts[1])
+	replaceOptionalPart(result, "src", parts[2])
+	replaceOptionalPart(result, "width", parts[3])
+	replaceOptionalPart(result, "height", parts[4])
+	// title + alt
+	part := parts[5]
+	if len(part) > 0 {
+		splits := strings.Split(part, "'")
+		lenSplits := len(splits)
+		if lenSplits == 1 {
+			replaceOptionalPart(result, "title", splits[0])
+		} else if lenSplits == 3 {
+			replaceOptionalPart(result, "title", splits[1])
+		} else if lenSplits == 5 {
+			replaceOptionalPart(result, "title", splits[1])
+			replaceOptionalPart(result, "alt", splits[3])
+		}
+	}
+	result.WriteString(">}}")
+	return result.String()
+
+}
+func replaceOptionalPart(buffer *bytes.Buffer, partName string, part string) {
+	if len(part) > 0 {
+		buffer.WriteString(partName + "=\"" + part + "\" ")
+	}
+}

commands/import_jekyll_test.go

@@ -0,0 +1,126 @@
+// 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 (
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+func TestParseJekyllFilename(t *testing.T) {
+	filenameArray := []string{
+		"2015-01-02-test.md",
+		"2012-03-15-中文.markup",
+	}
+
+	expectResult := []struct {
+		postDate time.Time
+		postName string
+	}{
+		{time.Date(2015, time.January, 2, 0, 0, 0, 0, time.UTC), "test"},
+		{time.Date(2012, time.March, 15, 0, 0, 0, 0, time.UTC), "中文"},
+	}
+
+	for i, filename := range filenameArray {
+		postDate, postName, err := parseJekyllFilename(filename)
+		assert.Equal(t, err, nil)
+		assert.Equal(t, expectResult[i].postDate.Format("2006-01-02"), postDate.Format("2006-01-02"))
+		assert.Equal(t, expectResult[i].postName, postName)
+	}
+}
+
+func TestConvertJekyllMetadata(t *testing.T) {
+	testDataList := []struct {
+		metadata interface{}
+		postName string
+		postDate time.Time
+		draft    bool
+		expect   string
+	}{
+		{map[interface{}]interface{}{}, "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z"}`},
+		{map[interface{}]interface{}{}, "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
+			`{"date":"2015-10-01T00:00:00Z","draft":true}`},
+		{map[interface{}]interface{}{"Permalink": "/permalink.html", "layout": "post"},
+			"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"},
+			"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},
+			"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"},
+			"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"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z"}`},
+	}
+
+	for _, data := range testDataList {
+		result, err := convertJekyllMetaData(data.metadata, data.postName, data.postDate, data.draft)
+		assert.Equal(t, nil, err)
+		jsonResult, err := json.Marshal(result)
+		assert.Equal(t, nil, err)
+		assert.Equal(t, data.expect, string(jsonResult))
+	}
+}
+
+func TestConvertJekyllContent(t *testing.T) {
+	testDataList := []struct {
+		metadata interface{}
+		content  string
+		expect   string
+	}{
+		{map[interface{}]interface{}{},
+			`Test content\n<!-- more -->\npart2 content`, `Test content\n<!--more-->\npart2 content`},
+		{map[interface{}]interface{}{},
+			`Test content\n<!-- More -->\npart2 content`, `Test content\n<!--more-->\npart2 content`},
+		{map[interface{}]interface{}{"excerpt_separator": "<!--sep-->"},
+			`Test content\n<!--sep-->\npart2 content`, `Test content\n<!--more-->\npart2 content`},
+		{map[interface{}]interface{}{}, "{% raw %}text{% endraw %}", "text"},
+		{map[interface{}]interface{}{}, "{%raw%} text2 {%endraw %}", "text2"},
+		{map[interface{}]interface{}{},
+			"{% highlight go %}\nvar s int\n{% endhighlight %}",
+			"{{< highlight go >}}\nvar s int\n{{< / highlight >}}"},
+
+		// Octopress image tag
+		{map[interface{}]interface{}{},
+			"{% img http://placekitten.com/890/280 %}",
+			"{{< figure src=\"http://placekitten.com/890/280\" >}}"},
+		{map[interface{}]interface{}{},
+			"{% img left http://placekitten.com/320/250 Place Kitten #2 %}",
+			"{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}"},
+		{map[interface{}]interface{}{},
+			"{% 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{}{},
+			"{% 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{}{},
+			"{% 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{}{},
+			"{% 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\" >}}"},
+	}
+
+	for _, data := range testDataList {
+		result := convertJekyllContent(data.metadata, data.content)
+		assert.Equal(t, data.expect, result)
+	}
+}

commands/limit_darwin.go

@@ -0,0 +1,78 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"syscall"
+
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*limitCmd)(nil)
+
+type limitCmd struct {
+	*baseCmd
+}
+
+func newLimitCmd() *limitCmd {
+	ccmd := &cobra.Command{
+		Use:   "ulimit",
+		Short: "Check system ulimit settings",
+		Long: `Hugo will inspect the current ulimit settings on the system.
+This is primarily to ensure that Hugo can watch enough files on some OSs`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			var rLimit syscall.Rlimit
+			err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+			if err != nil {
+				return newSystemError("Error Getting Rlimit ", err)
+			}
+
+			jww.FEEDBACK.Println("Current rLimit:", rLimit)
+
+			jww.FEEDBACK.Println("Attempting to increase limit")
+			rLimit.Max = 999999
+			rLimit.Cur = 999999
+			err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+			if err != nil {
+				return newSystemError("Error Setting rLimit ", err)
+			}
+			err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+			if err != nil {
+				return newSystemError("Error Getting rLimit ", err)
+			}
+			jww.FEEDBACK.Println("rLimit after change:", rLimit)
+
+			return nil
+		},
+	}
+
+	return &limitCmd{baseCmd: newBaseCmd(ccmd)}
+}
+
+func tweakLimit() {
+	var rLimit syscall.Rlimit
+	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+	if err != nil {
+		jww.ERROR.Println("Unable to obtain rLimit", err)
+	}
+	if rLimit.Cur < rLimit.Max {
+		rLimit.Max = 64000
+		rLimit.Cur = 64000
+		err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+		if err != nil {
+			jww.WARN.Println("Unable to increase number of open files limit", err)
+		}
+	}
+}

commands/limit_others.go

@@ -0,0 +1,20 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !darwin
+
+package commands
+
+func tweakLimit() {
+	// nothing to do
+}

commands/list.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// 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.
@@ -14,200 +14,144 @@
 package commands
 
 import (
-	"context"
-	"encoding/csv"
-	"os"
 	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
 
-	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/hugolib"
-	"github.com/gohugoio/hugo/resources/page"
-	"github.com/gohugoio/hugo/resources/resource"
 	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
 )
 
-// newListCommand creates a new list command and its subcommands.
+var _ cmder = (*listCmd)(nil)
-func newListCommand() *listCommand {
-	createRecord := func(workingDir string, p page.Page) []string {
-		return []string{
-			filepath.ToSlash(strings.TrimPrefix(p.File().Filename(), workingDir+string(os.PathSeparator))),
-			p.Slug(),
-			p.Title(),
-			p.Date().Format(time.RFC3339),
-			p.ExpiryDate().Format(time.RFC3339),
-			p.PublishDate().Format(time.RFC3339),
-			strconv.FormatBool(p.Draft()),
-			p.Permalink(),
-			p.Kind(),
-			p.Section(),
-		}
-	}
 
-	list := func(cd *simplecobra.Commandeer, r *rootCommand, shouldInclude func(page.Page) bool, opts ...any) error {
+type listCmd struct {
-		bcfg := hugolib.BuildCfg{SkipRender: true}
+	hugoBuilderCommon
-		cfg := flagsToCfg(cd, nil)
+	*baseCmd
-		for i := 0; i < len(opts); i += 2 {
+}
-			cfg.Set(opts[i].(string), opts[i+1])
-		}
-		h, err := r.Build(cd, bcfg, cfg)
-		if err != nil {
-			return err
-		}
 
-		writer := csv.NewWriter(r.StdOut)
+func newListCmd() *listCmd {
-		defer writer.Flush()
+	cc := &listCmd{}
 
-		writer.Write([]string{
+	cc.baseCmd = newBaseCmd(&cobra.Command{
-			"path",
+		Use:   "list",
-			"slug",
+		Short: "Listing out various types of content",
-			"title",
+		Long: `Listing out various types of content.
-			"date",
-			"expiryDate",
-			"publishDate",
-			"draft",
-			"permalink",
-			"kind",
-			"section",
-		})
 
-		for _, p := range h.Pages() {
+List requires a subcommand, e.g. ` + "`hugo list drafts`.",
-			if shouldInclude(p) {
+		RunE: nil,
-				record := createRecord(h.Conf.BaseConfig().WorkingDir, p)
+	})
-				if err := writer.Write(record); err != nil {
+
+	cc.cmd.AddCommand(
+		&cobra.Command{
+			Use:   "drafts",
+			Short: "List all drafts",
+			Long:  `List all of the drafts in your content directory.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				cfgInit := func(c *commandeer) error {
+					c.Set("buildDrafts", true)
+					return nil
+				}
+				c, err := initializeConfig(true, false, &cc.hugoBuilderCommon, cc, cfgInit)
+				if err != nil {
 					return err
 				}
-			}
-		}
 
-		return nil
+				sites, err := hugolib.NewHugoSites(*c.DepsCfg)
-	}
 
-	return &listCommand{
+				if err != nil {
-		commands: []simplecobra.Commander{
+					return newSystemError("Error creating sites", err)
-			&simpleCommand{
+				}
-				name:  "drafts",
+
-				short: "List draft content",
+				if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
-				long:  `List draft content.`,
+					return newSystemError("Error Processing Source Content", err)
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
+				}
-					shouldInclude := func(p page.Page) bool {
+
-						if !p.Draft() || p.File() == nil {
+				for _, p := range sites.Pages() {
-							return false
+					if p.IsDraft() {
-						}
+						jww.FEEDBACK.Println(filepath.Join(p.File.Dir(), p.File.LogicalName()))
-						return true
 					}
-					return list(cd, r, shouldInclude,
+
-						"buildDrafts", true,
+				}
-						"buildFuture", true,
+
-						"buildExpired", true,
+				return nil
-					)
+
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "future",
-				short: "List future content",
-				long:  `List content with a future publication date.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						if !resource.IsFuture(p) || p.File() == nil {
-							return false
-						}
-						return true
-					}
-					return list(cd, r, shouldInclude,
-						"buildFuture", true,
-						"buildDrafts", true,
-					)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "expired",
-				short: "List expired content",
-				long:  `List content with a past expiration date.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						if !resource.IsExpired(p) || p.File() == nil {
-							return false
-						}
-						return true
-					}
-					return list(cd, r, shouldInclude,
-						"buildExpired", true,
-						"buildDrafts", true,
-					)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "all",
-				short: "List all content",
-				long:  `List all content including draft, future, and expired.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						return p.File() != nil
-					}
-					return list(cd, r, shouldInclude, "buildDrafts", true, "buildFuture", true, "buildExpired", true)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "published",
-				short: "List published content",
-				long:  `List content that is not draft, future, or expired.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						return !p.Draft() && !resource.IsFuture(p) && !resource.IsExpired(p) && p.File() != nil
-					}
-					return list(cd, r, shouldInclude)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
 			},
 		},
-	}
+		&cobra.Command{
-}
+			Use:   "future",
-
+			Short: "List all posts dated in the future",
-type listCommand struct {
+			Long: `List all of the posts in your content directory which will be
-	commands []simplecobra.Commander
+posted in the future.`,
-}
+			RunE: func(cmd *cobra.Command, args []string) error {
-
+				cfgInit := func(c *commandeer) error {
-func (c *listCommand) Commands() []simplecobra.Commander {
+					c.Set("buildFuture", true)
-	return c.commands
+					return nil
-}
+				}
-
+				c, err := initializeConfig(true, false, &cc.hugoBuilderCommon, cc, cfgInit)
-func (c *listCommand) Name() string {
+				if err != nil {
-	return "list"
+					return err
-}
+				}
-
+
-func (c *listCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
+				sites, err := hugolib.NewHugoSites(*c.DepsCfg)
-	// Do nothing.
+
-	return nil
+				if err != nil {
-}
+					return newSystemError("Error creating sites", err)
-
+				}
-func (c *listCommand) Init(cd *simplecobra.Commandeer) error {
+
-	cmd := cd.CobraCommand
+				if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
-	cmd.Short = "List content"
+					return newSystemError("Error Processing Source Content", err)
-	cmd.Long = `List content.
+				}
-
+
-List requires a subcommand, e.g. hugo list drafts`
+				for _, p := range sites.Pages() {
-
+					if p.IsFuture() {
-	cmd.RunE = nil
+						jww.FEEDBACK.Println(filepath.Join(p.File.Dir(), p.File.LogicalName()))
-	return nil
+					}
-}
+
-
+				}
-func (c *listCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
+
-	return nil
+				return nil
+
+			},
+		},
+		&cobra.Command{
+			Use:   "expired",
+			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 {
+				cfgInit := func(c *commandeer) error {
+					c.Set("buildExpired", true)
+					return nil
+				}
+				c, err := initializeConfig(true, false, &cc.hugoBuilderCommon, cc, cfgInit)
+				if err != nil {
+					return err
+				}
+
+				sites, err := hugolib.NewHugoSites(*c.DepsCfg)
+
+				if err != nil {
+					return newSystemError("Error creating sites", err)
+				}
+
+				if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+					return newSystemError("Error Processing Source Content", err)
+				}
+
+				for _, p := range sites.Pages() {
+					if p.IsExpired() {
+						jww.FEEDBACK.Println(filepath.Join(p.File.Dir(), p.File.LogicalName()))
+					}
+
+				}
+
+				return nil
+
+			},
+		},
+	)
+
+	cc.cmd.PersistentFlags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
+	cc.cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+
+	return cc
 }

commands/mod.go

@@ -1,344 +0,0 @@
-// Copyright 2024 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 (
-	"context"
-	"errors"
-	"os"
-	"path/filepath"
-
-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/modules/npm"
-	"github.com/spf13/cobra"
-)
-
-const commonUsageMod = `
-Note that Hugo will always start out by resolving the components defined in the site
-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.
-
-`
-
-// buildConfigCommands creates a new config command and its subcommands.
-func newModCommands() *modCommands {
-	var (
-		clean   bool
-		pattern string
-		all     bool
-	)
-
-	npmCommand := &simpleCommand{
-		name:  "npm",
-		short: "Various npm helpers",
-		long:  `Various npm (Node package manager) helpers.`,
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "pack",
-				short: "Experimental: Prepares and writes a composite package.json file for your project",
-				long: `Prepares and writes a composite package.json file for your project.
-
-On first run it creates a "package.hugo.json" in the project root if not already there. This file will be used as a template file
-with the base dependency set.
-
-This set will be merged with all "package.hugo.json" files found in the dependency tree, picking the version closest to the project.
-
-This command is marked as 'Experimental'. We think it's a great idea, so it's not likely to be
-removed from Hugo, but we need to test this out in "real life" to get a feel of it,
-so this may/will change in future versions of Hugo.
-`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.Hugo(flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					return npm.Pack(h.BaseFs.ProjectSourceFs, h.BaseFs.AssetsWithDuplicatesPreserved.Fs)
-				},
-			},
-		},
-	}
-
-	return &modCommands{
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "init",
-				short: "Initialize this project as a Hugo Module",
-				long: `Initialize this project as a Hugo Module.
-	It will try to guess the module path, but you may help by passing it as an argument, e.g:
-
-		hugo mod init github.com/gohugoio/testshortcodes
-
-	Note that Hugo Modules supports multi-module projects, so you can initialize a Hugo Module
-	inside a subfolder on GitHub, as one example.
-	`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.getOrCreateHugo(flagsToCfg(cd, nil), true)
-					if err != nil {
-						return err
-					}
-					var initPath string
-					if len(args) >= 1 {
-						initPath = args[0]
-					}
-					c := h.Configs.ModulesClient
-					if err := c.Init(initPath); err != nil {
-						return err
-					}
-					return nil
-				},
-			},
-			&simpleCommand{
-				name:  "verify",
-				short: "Verify dependencies",
-				long:  `Verify checks that the dependencies of the current module, which are stored in a local downloaded source cache, have not been modified since being downloaded.`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-					cmd.Flags().BoolVarP(&clean, "clean", "", false, "delete module cache for dependencies that fail verification")
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					client := conf.configs.ModulesClient
-					return client.Verify(clean)
-				},
-			},
-			&simpleCommand{
-				name:  "graph",
-				short: "Print a module dependency graph",
-				long: `Print a module dependency graph with information about module status (disabled, vendored).
-Note that for vendored modules, that is the version listed and not the one from go.mod.
-`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-					cmd.Flags().BoolVarP(&clean, "clean", "", false, "delete module cache for dependencies that fail verification")
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					client := conf.configs.ModulesClient
-					return client.Graph(os.Stdout)
-				},
-			},
-			&simpleCommand{
-				name:  "clean",
-				short: "Delete the Hugo Module cache for the current project",
-				long:  `Delete the Hugo Module cache for the current project.`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-					cmd.Flags().StringVarP(&pattern, "pattern", "", "", `pattern matching module paths to clean (all if not set), e.g. "**hugo*"`)
-					_ = cmd.RegisterFlagCompletionFunc("pattern", cobra.NoFileCompletions)
-					cmd.Flags().BoolVarP(&all, "all", "", false, "clean entire module cache")
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.Hugo(flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					if all {
-						modCache := h.ResourceSpec.FileCaches.ModulesCache()
-						count, err := modCache.Prune(true)
-						r.Printf("Deleted %d files from module cache.", count)
-						return err
-					}
-
-					return h.Configs.ModulesClient.Clean(pattern)
-				},
-			},
-			&simpleCommand{
-				name:  "tidy",
-				short: "Remove unused entries in go.mod and go.sum",
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.Hugo(flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					return h.Configs.ModulesClient.Tidy()
-				},
-			},
-			&simpleCommand{
-				name:  "vendor",
-				short: "Vendor all module dependencies into the _vendor directory",
-				long: `Vendor all module dependencies into the _vendor directory.
-	If a module is vendored, that is where Hugo will look for it's dependencies.
-	`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.Hugo(flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					return h.Configs.ModulesClient.Vendor()
-				},
-			},
-
-			&simpleCommand{
-				name:  "get",
-				short: "Resolves dependencies in your current Hugo project",
-				long: `
-Resolves dependencies in your current Hugo project.
-
-Some examples:
-
-Install the latest version possible for a given module:
-
-    hugo mod get github.com/gohugoio/testshortcodes
-
-Install a specific version:
-
-    hugo mod get github.com/gohugoio/testshortcodes@v0.3.0
-
-Install the latest versions of all direct module dependencies:
-
-    hugo mod get
-    hugo mod get ./... (recursive)
-
-Install the latest versions of all module dependencies (direct and indirect):
-
-    hugo mod get -u
-    hugo mod get -u ./... (recursive)
-
-Run "go help get" for more information. All flags available for "go get" is also relevant here.
-` + commonUsageMod,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.DisableFlagParsing = true
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					// We currently just pass on the flags we get to Go and
-					// need to do the flag handling manually.
-					if len(args) == 1 && (args[0] == "-h" || args[0] == "--help") {
-						return errHelp
-					}
-
-					var lastArg string
-					if len(args) != 0 {
-						lastArg = args[len(args)-1]
-					}
-
-					if lastArg == "./..." {
-						args = args[:len(args)-1]
-						// Do a recursive update.
-						dirname, err := os.Getwd()
-						if err != nil {
-							return err
-						}
-
-						// Sanity chesimplecobra. We do recursive walking and want to avoid
-						// accidents.
-						if len(dirname) < 5 {
-							return errors.New("must not be run from the file system root")
-						}
-
-						filepath.Walk(dirname, func(path string, info os.FileInfo, err error) error {
-							if info.IsDir() {
-								return nil
-							}
-							if info.Name() == "go.mod" {
-								// Found a module.
-								dir := filepath.Dir(path)
-
-								cfg := config.New()
-								cfg.Set("workingDir", dir)
-								conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Add(1)}, flagsToCfg(cd, cfg))
-								if err != nil {
-									return err
-								}
-								r.Println("Update module in", conf.configs.Base.WorkingDir)
-								client := conf.configs.ModulesClient
-								return client.Get(args...)
-
-							}
-							return nil
-						})
-						return nil
-					} else {
-						conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, nil))
-						if err != nil {
-							return err
-						}
-						client := conf.configs.ModulesClient
-						return client.Get(args...)
-					}
-				},
-			},
-			npmCommand,
-		},
-	}
-}
-
-type modCommands struct {
-	r *rootCommand
-
-	commands []simplecobra.Commander
-}
-
-func (c *modCommands) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *modCommands) Name() string {
-	return "mod"
-}
-
-func (c *modCommands) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	_, err := c.r.ConfigFromProvider(configKey{counter: c.r.configVersionID.Load()}, nil)
-	if err != nil {
-		return err
-	}
-	// config := conf.configs.Base
-
-	return nil
-}
-
-func (c *modCommands) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Manage modules"
-	cmd.Long = `Various helpers to help manage the modules in your project's dependency graph.
-Most operations here requires a Go version installed on your system (>= Go 1.12) and the relevant VCS client (typically Git).
-This is not needed if you only operate on modules inside /themes or if you have vendored them via "hugo mod vendor".
-
-` + commonUsageMod
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *modCommands) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	return nil
-}

commands/new.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,213 +15,148 @@ package commands
 
 import (
 	"bytes"
-	"context"
+	"os"
 	"path/filepath"
 	"strings"
 
-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/paths"
-	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/create"
-	"github.com/gohugoio/hugo/create/skeletons"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
 )
 
-func newNewCommand() *newCommand {
+var _ cmder = (*newCmd)(nil)
-	var (
-		force       bool
-		contentType string
-		format      string
-	)
 
-	var c *newCommand
+type newCmd struct {
-	c = &newCommand{
+	hugoBuilderCommon
-		commands: []simplecobra.Commander{
+	contentEditor string
-			&simpleCommand{
+	contentType   string
-				name:  "content",
+
-				use:   "content [path]",
+	*baseCmd
-				short: "Create new content",
+}
-				long: `Create a new content file and automatically set the date and title.
+
+func newNewCmd() *newCmd {
+	cc := &newCmd{}
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "new [path]",
+		Short: "Create new content for your site",
+		Long: `Create a new content file and automatically set the date and title.
 It will guess which kind of file to create based on the path provided.
 
 You can also specify the kind with ` + "`-k KIND`" + `.
 
-If archetypes are provided in your theme or site, they will be used.
+If archetypes are provided in your theme or site, they will be used.`,
 
-Ensure you run this within the root directory of your site.`,
+		RunE: cc.newContent,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
+	})
-					if len(args) < 1 {
-						return newUserError("path needs to be provided")
-					}
-					h, err := r.Hugo(flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					return create.NewContent(h, contentType, args[0], force)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-						if len(args) != 0 {
-							return []string{}, cobra.ShellCompDirectiveNoFileComp
-						}
-						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
-					}
-					cmd.Flags().StringVarP(&contentType, "kind", "k", "", "content type to create")
-					cmd.Flags().String("editor", "", "edit new content with this editor, if provided")
-					_ = cmd.RegisterFlagCompletionFunc("editor", cobra.NoFileCompletions)
-					cmd.Flags().BoolVarP(&force, "force", "f", false, "overwrite file if it already exists")
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-			},
-			&simpleCommand{
-				name:  "site",
-				use:   "site [path]",
-				short: "Create a new site",
-				long:  `Create a new site at the specified path.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					if len(args) < 1 {
-						return newUserError("path needs to be provided")
-					}
-					createpath, err := filepath.Abs(filepath.Clean(args[0]))
-					if err != nil {
-						return err
-					}
 
-					cfg := config.New()
+	cc.cmd.Flags().StringVarP(&cc.contentType, "kind", "k", "", "content type to create")
-					cfg.Set("workingDir", createpath)
+	cc.cmd.PersistentFlags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
-					cfg.Set("publishDir", "public")
+	cc.cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+	cc.cmd.Flags().StringVar(&cc.contentEditor, "editor", "", "edit new content with this editor, if provided")
 
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, cfg))
+	cc.cmd.AddCommand(newNewSiteCmd().getCommand())
-					if err != nil {
+	cc.cmd.AddCommand(newNewThemeCmd().getCommand())
-						return err
-					}
-					sourceFs := conf.fs.Source
 
-					err = skeletons.CreateSite(createpath, sourceFs, force, format)
+	return cc
-					if err != nil {
+}
-						return err
-					}
 
-					r.Printf("Congratulations! Your new Hugo site was created in %s.\n\n", createpath)
+func (n *newCmd) newContent(cmd *cobra.Command, args []string) error {
-					r.Println(c.newSiteNextStepsText(createpath, format))
+	cfgInit := func(c *commandeer) error {
-
+		if cmd.Flags().Changed("editor") {
-					return nil
+			c.Set("newContentEditor", n.contentEditor)
-				},
+		}
-				withc: func(cmd *cobra.Command, r *rootCommand) {
+		return nil
-					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-						if len(args) != 0 {
-							return []string{}, cobra.ShellCompDirectiveNoFileComp
-						}
-						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
-					}
-					cmd.Flags().BoolVarP(&force, "force", "f", false, "init inside non-empty directory")
-					cmd.Flags().StringVar(&format, "format", "toml", "preferred file format (toml, yaml or json)")
-					_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
-				},
-			},
-			&simpleCommand{
-				name:  "theme",
-				use:   "theme [name]",
-				short: "Create a new theme",
-				long: `Create a new theme with the specified name in the ./themes directory.
-This generates a functional theme including template examples and sample content.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					if len(args) < 1 {
-						return newUserError("theme name needs to be provided")
-					}
-					cfg := config.New()
-					cfg.Set("publishDir", "public")
-
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, cfg))
-					if err != nil {
-						return err
-					}
-					sourceFs := conf.fs.Source
-					createpath := paths.AbsPathify(conf.configs.Base.WorkingDir, filepath.Join(conf.configs.Base.ThemesDir, args[0]))
-					r.Println("Creating new theme in", createpath)
-
-					err = skeletons.CreateTheme(createpath, sourceFs, format)
-					if err != nil {
-						return err
-					}
-
-					return nil
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-						if len(args) != 0 {
-							return []string{}, cobra.ShellCompDirectiveNoFileComp
-						}
-						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
-					}
-					cmd.Flags().StringVar(&format, "format", "toml", "preferred file format (toml, yaml or json)")
-					_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
-				},
-			},
-		},
 	}
 
-	return c
+	c, err := initializeConfig(true, false, &n.hugoBuilderCommon, n, cfgInit)
+
+	if err != nil {
+		return err
+	}
+
+	if len(args) < 1 {
+		return newUserError("path needs to be provided")
+	}
+
+	createPath := args[0]
+
+	var kind string
+
+	createPath, kind = newContentPathSection(createPath)
+
+	if n.contentType != "" {
+		kind = n.contentType
+	}
+
+	cfg := c.DepsCfg
+
+	ps, err := helpers.NewPathSpec(cfg.Fs, cfg.Cfg)
+	if err != nil {
+		return err
+	}
+
+	// If a site isn't in use in the archetype template, we can skip the build.
+	siteFactory := func(filename string, siteUsed bool) (*hugolib.Site, error) {
+		if !siteUsed {
+			return hugolib.NewSite(*cfg)
+		}
+		var s *hugolib.Site
+
+		if err := c.hugo.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+			return nil, err
+		}
+
+		s = c.hugo.Sites[0]
+
+		if len(c.hugo.Sites) > 1 {
+			// Find the best match.
+			for _, ss := range c.hugo.Sites {
+				if strings.Contains(createPath, "."+ss.Language.Lang) {
+					s = ss
+					break
+				}
+			}
+		}
+		return s, nil
+	}
+
+	return create.NewContent(ps, siteFactory, kind, createPath)
 }
 
-type newCommand struct {
+func mkdir(x ...string) {
-	rootCmd *rootCommand
+	p := filepath.Join(x...)
 
-	commands []simplecobra.Commander
+	err := os.MkdirAll(p, 0777) // before umask
+	if err != nil {
+		jww.FATAL.Fatalln(err)
+	}
 }
 
-func (c *newCommand) Commands() []simplecobra.Commander {
+func touchFile(fs afero.Fs, x ...string) {
-	return c.commands
+	inpath := filepath.Join(x...)
+	mkdir(filepath.Dir(inpath))
+	err := helpers.WriteToDisk(inpath, bytes.NewReader([]byte{}), fs)
+	if err != nil {
+		jww.FATAL.Fatalln(err)
+	}
 }
 
-func (c *newCommand) Name() string {
+func newContentPathSection(path string) (string, string) {
-	return "new"
+	// Forward slashes is used in all examples. Convert if needed.
-}
+	// Issue #1133
-
+	createpath := filepath.FromSlash(path)
-func (c *newCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
+	var section string
-	return nil
+	// assume the first directory is the section (kind)
-}
+	if strings.Contains(createpath[1:], helpers.FilePathSeparator) {
-
+		parts := strings.Split(strings.TrimPrefix(createpath, helpers.FilePathSeparator), helpers.FilePathSeparator)
-func (c *newCommand) Init(cd *simplecobra.Commandeer) error {
+		if len(parts) > 0 {
-	cmd := cd.CobraCommand
+			section = parts[0]
-	cmd.Short = "Create new content"
+		}
-	cmd.Long = `Create a new content file and automatically set the date and title.
+
-It will guess which kind of file to create based on the path provided.
+	}
-
+
-You can also specify the kind with ` + "`-k KIND`" + `.
+	return createpath, section
-
-If archetypes are provided in your theme or site, they will be used.
-
-Ensure you run this within the root directory of your site.`
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *newCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.rootCmd = cd.Root.Command.(*rootCommand)
-	return nil
-}
-
-func (c *newCommand) newSiteNextStepsText(path string, format string) string {
-	format = strings.ToLower(format)
-	var nextStepsText bytes.Buffer
-
-	nextStepsText.WriteString(`Just a few more steps...
-
-1. Change the current directory to ` + path + `.
-2. Create or install a theme:
-   - Create a new theme with the command "hugo new theme <THEMENAME>"
-   - Or, install a theme from https://themes.gohugo.io/
-3. Edit hugo.` + format + `, setting the "theme" property to the theme name.
-4. Create new content with the command "hugo new content `)
-
-	nextStepsText.WriteString(filepath.Join("<SECTIONNAME>", "<FILENAME>.<FORMAT>"))
-
-	nextStepsText.WriteString(`".
-5. Start the embedded web server with the command "hugo server --buildDrafts".
-
-See documentation at https://gohugo.io/.`)
-
-	return nextStepsText.String()
 }

commands/new_content_test.go

@@ -0,0 +1,128 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Issue #1133
+func TestNewContentPathSectionWithForwardSlashes(t *testing.T) {
+	p, s := newContentPathSection("/post/new.md")
+	assert.Equal(t, filepath.FromSlash("/post/new.md"), p)
+	assert.Equal(t, "post", s)
+}
+
+func checkNewSiteInited(fs *hugofs.Fs, basepath string, t *testing.T) {
+
+	paths := []string{
+		filepath.Join(basepath, "layouts"),
+		filepath.Join(basepath, "content"),
+		filepath.Join(basepath, "archetypes"),
+		filepath.Join(basepath, "static"),
+		filepath.Join(basepath, "data"),
+		filepath.Join(basepath, "config.toml"),
+	}
+
+	for _, path := range paths {
+		_, err := fs.Source.Stat(path)
+		require.NoError(t, err)
+	}
+}
+
+func TestDoNewSite(t *testing.T) {
+	n := newNewSiteCmd()
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+
+	require.NoError(t, n.doNewSite(fs, basepath, false))
+
+	checkNewSiteInited(fs, basepath, t)
+}
+
+func TestDoNewSite_noerror_base_exists_but_empty(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+	n := newNewSiteCmd()
+
+	require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+
+	require.NoError(t, n.doNewSite(fs, basepath, false))
+}
+
+func TestDoNewSite_error_base_exists(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+	n := newNewSiteCmd()
+
+	require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+	_, err := fs.Source.Create(filepath.Join(basepath, "foo"))
+	require.NoError(t, err)
+	// Since the directory already exists and isn't empty, expect an error
+	require.Error(t, n.doNewSite(fs, basepath, false))
+
+}
+
+func TestDoNewSite_force_empty_dir(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+	n := newNewSiteCmd()
+
+	require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+
+	require.NoError(t, n.doNewSite(fs, basepath, true))
+
+	checkNewSiteInited(fs, basepath, t)
+}
+
+func TestDoNewSite_error_force_dir_inside_exists(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+	n := newNewSiteCmd()
+
+	contentPath := filepath.Join(basepath, "content")
+
+	require.NoError(t, fs.Source.MkdirAll(contentPath, 777))
+	require.Error(t, n.doNewSite(fs, basepath, true))
+}
+
+func TestDoNewSite_error_force_config_inside_exists(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+	n := newNewSiteCmd()
+
+	configPath := filepath.Join(basepath, "config.toml")
+	require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+	_, err := fs.Source.Create(configPath)
+	require.NoError(t, err)
+
+	require.Error(t, n.doNewSite(fs, basepath, true))
+}
+
+func newTestCfg() (*viper.Viper, *hugofs.Fs) {
+
+	v := viper.New()
+	fs := hugofs.NewMem(v)
+
+	v.SetFs(fs.Source)
+
+	return v, fs
+
+}

commands/new_site.go

@@ -0,0 +1,163 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"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)
+
+type newSiteCmd struct {
+	configFormat string
+
+	*baseCmd
+}
+
+func newNewSiteCmd() *newSiteCmd {
+	ccmd := &newSiteCmd{}
+
+	cmd := &cobra.Command{
+		Use:   "site [path]",
+		Short: "Create a new site (skeleton)",
+		Long: `Create a new site in the provided directory.
+The new site will have the correct structure, but no content or theme yet.
+Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
+		RunE: ccmd.newSite,
+	}
+
+	cmd.Flags().StringVarP(&ccmd.configFormat, "format", "f", "toml", "config & frontmatter format")
+	cmd.Flags().Bool("force", false, "init inside non-empty directory")
+
+	ccmd.baseCmd = newBaseCmd(cmd)
+
+	return ccmd
+
+}
+
+func (n *newSiteCmd) doNewSite(fs *hugofs.Fs, basepath string, force bool) error {
+	archeTypePath := filepath.Join(basepath, "archetypes")
+	dirs := []string{
+		filepath.Join(basepath, "layouts"),
+		filepath.Join(basepath, "content"),
+		archeTypePath,
+		filepath.Join(basepath, "static"),
+		filepath.Join(basepath, "data"),
+		filepath.Join(basepath, "themes"),
+	}
+
+	if exists, _ := helpers.Exists(basepath, fs.Source); exists {
+		if isDir, _ := helpers.IsDir(basepath, fs.Source); !isDir {
+			return errors.New(basepath + " already exists but not a directory")
+		}
+
+		isEmpty, _ := helpers.IsEmpty(basepath, fs.Source)
+
+		switch {
+		case !isEmpty && !force:
+			return errors.New(basepath + " already exists and is not empty")
+
+		case !isEmpty && force:
+			all := append(dirs, filepath.Join(basepath, "config."+n.configFormat))
+			for _, path := range all {
+				if exists, _ := helpers.Exists(path, fs.Source); exists {
+					return errors.New(path + " already exists")
+				}
+			}
+		}
+	}
+
+	for _, dir := range dirs {
+		if err := fs.Source.MkdirAll(dir, 0777); err != nil {
+			return fmt.Errorf("Failed to create dir: %s", err)
+		}
+	}
+
+	createConfig(fs, basepath, n.configFormat)
+
+	// Create a default archetype file.
+	helpers.SafeWriteToDisk(filepath.Join(archeTypePath, "default.md"),
+		strings.NewReader(create.ArchetypeTemplateTemplate), fs.Source)
+
+	jww.FEEDBACK.Printf("Congratulations! Your new Hugo site is created in %s.\n\n", basepath)
+	jww.FEEDBACK.Println(nextStepsText())
+
+	return nil
+}
+
+// newSite creates a new Hugo site and initializes a structured Hugo directory.
+func (n *newSiteCmd) newSite(cmd *cobra.Command, args []string) error {
+	if len(args) < 1 {
+		return newUserError("path needs to be provided")
+	}
+
+	createpath, err := filepath.Abs(filepath.Clean(args[0]))
+	if err != nil {
+		return newUserError(err)
+	}
+
+	forceNew, _ := cmd.Flags().GetBool("force")
+
+	return n.doNewSite(hugofs.NewDefault(viper.New()), createpath, forceNew)
+}
+
+func createConfig(fs *hugofs.Fs, inpath string, kind string) (err error) {
+	in := map[string]string{
+		"baseURL":      "http://example.org/",
+		"title":        "My New Hugo Site",
+		"languageCode": "en-us",
+	}
+	kind = parser.FormatSanitize(kind)
+
+	var buf bytes.Buffer
+	err = parser.InterfaceToConfig(in, parser.FormatToLeadRune(kind), &buf)
+	if err != nil {
+		return err
+	}
+
+	return helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), &buf, fs.Source)
+}
+
+func nextStepsText() string {
+	var nextStepsText bytes.Buffer
+
+	nextStepsText.WriteString(`Just a few more steps and you're ready to go:
+
+1. Download a theme into the same-named folder.
+   Choose a theme from https://themes.gohugo.io/, or
+   create your own with the "hugo new theme <THEMENAME>" command.
+2. Perhaps you want to add some content. You can add single files
+   with "hugo new `)
+
+	nextStepsText.WriteString(filepath.Join("<SECTIONNAME>", "<FILENAME>.<FORMAT>"))
+
+	nextStepsText.WriteString(`".
+3. Start the built-in live server via "hugo server".
+
+Visit https://gohugo.io/ for quickstart guide and full documentation.`)
+
+	return nextStepsText.String()
+}

commands/new_theme.go

@@ -0,0 +1,179 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*newThemeCmd)(nil)
+
+type newThemeCmd struct {
+	*baseCmd
+	hugoBuilderCommon
+}
+
+func newNewThemeCmd() *newThemeCmd {
+	ccmd := &newThemeCmd{baseCmd: newBaseCmd(nil)}
+
+	cmd := &cobra.Command{
+		Use:   "theme [name]",
+		Short: "Create a new theme",
+		Long: `Create a new theme (skeleton) called [name] in the current directory.
+New theme is a skeleton. Please add content to the touched files. Add your
+name to the copyright line in the license and adjust the theme.toml file
+as you see fit.`,
+		RunE: ccmd.newTheme,
+	}
+
+	ccmd.cmd = cmd
+
+	return ccmd
+}
+
+// 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)
+
+	if err != nil {
+		return err
+	}
+
+	if len(args) < 1 {
+		return newUserError("theme name needs to be provided")
+	}
+
+	createpath := c.hugo.PathSpec.AbsPathify(filepath.Join(c.Cfg.GetString("themesDir"), args[0]))
+	jww.FEEDBACK.Println("Creating theme at", createpath)
+
+	cfg := c.DepsCfg
+
+	if x, _ := helpers.Exists(createpath, cfg.Fs.Source); x {
+		return errors.New(createpath + " already exists")
+	}
+
+	mkdir(createpath, "layouts", "_default")
+	mkdir(createpath, "layouts", "partials")
+
+	touchFile(cfg.Fs.Source, createpath, "layouts", "index.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "404.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "_default", "list.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "_default", "single.html")
+
+	baseofDefault := []byte(`<!DOCTYPE html>
+<html>
+    {{- partial "head.html" . -}}
+    <body>
+        {{- partial "header.html" . -}}
+        <div id="content">
+        {{- block "main" . }}{{- end }}
+        </div>
+        {{- partial "footer.html" . -}}
+    </body>
+</html>
+`)
+	err = helpers.WriteToDisk(filepath.Join(createpath, "layouts", "_default", "baseof.html"), bytes.NewReader(baseofDefault), cfg.Fs.Source)
+	if err != nil {
+		return err
+	}
+
+	touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "head.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "header.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "footer.html")
+
+	mkdir(createpath, "archetypes")
+
+	archDefault := []byte("+++\n+++\n")
+
+	err = helpers.WriteToDisk(filepath.Join(createpath, "archetypes", "default.md"), bytes.NewReader(archDefault), cfg.Fs.Source)
+	if err != nil {
+		return err
+	}
+
+	mkdir(createpath, "static", "js")
+	mkdir(createpath, "static", "css")
+
+	by := []byte(`The MIT License (MIT)
+
+Copyright (c) ` + time.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
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+`)
+
+	err = helpers.WriteToDisk(filepath.Join(createpath, "LICENSE"), bytes.NewReader(by), cfg.Fs.Source)
+	if err != nil {
+		return err
+	}
+
+	n.createThemeMD(cfg.Fs, createpath)
+
+	return nil
+}
+
+func (n *newThemeCmd) createThemeMD(fs *hugofs.Fs, inpath string) (err error) {
+
+	by := []byte(`# theme.toml template for a Hugo theme
+# See https://github.com/gohugoio/hugoThemes#themetoml for an example
+
+name = "` + strings.Title(helpers.MakeTitle(filepath.Base(inpath))) + `"
+license = "MIT"
+licenselink = "https://github.com/yourname/yourtheme/blob/master/LICENSE"
+description = ""
+homepage = "http://example.com/"
+tags = []
+features = []
+min_version = "0.41"
+
+[author]
+  name = ""
+  homepage = ""
+
+# If porting an existing theme
+[original]
+  name = ""
+  homepage = ""
+  repo = ""
+`)
+
+	err = helpers.WriteToDisk(filepath.Join(inpath, "theme.toml"), bytes.NewReader(by), fs.Source)
+	if err != nil {
+		return
+	}
+
+	return nil
+}

commands/release.go

@@ -1,4 +1,6 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// +build release
+
+// Copyright 2017-present 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,40 +16,57 @@
 package commands
 
 import (
-	"context"
+	"errors"
 
-	"github.com/bep/simplecobra"
+	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/releaser"
 	"github.com/spf13/cobra"
 )
 
-// Note: This is a command only meant for internal use and must be run
+var _ cmder = (*releaseCommandeer)(nil)
-// via "go run -tags release main.go release" on the actual code base that is in the release.
-func newReleaseCommand() simplecobra.Commander {
-	var (
-		step     int
-		skipPush bool
-		try      bool
-	)
 
-	return &simpleCommand{
+type releaseCommandeer struct {
-		name:  "release",
+	cmd *cobra.Command
-		short: "Release a new version of Hugo",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			rel, err := releaser.New(skipPush, try, step)
-			if err != nil {
-				return err
-			}
 
-			return rel.Run()
+	version string
-		},
+
-		withc: func(cmd *cobra.Command, r *rootCommand) {
+	skipPublish bool
-			cmd.Hidden = true
+	try         bool
-			cmd.ValidArgsFunction = cobra.NoFileCompletions
+}
-			cmd.PersistentFlags().BoolVarP(&skipPush, "skip-push", "", false, "skip pushing to remote")
+
-			cmd.PersistentFlags().BoolVarP(&try, "try", "", false, "no changes")
+func createReleaser() cmder {
-			cmd.PersistentFlags().IntVarP(&step, "step", "", 0, "step to run (1: set new version 2: prepare next dev version)")
+	// Note: This is a command only meant for internal use and must be run
-			_ = cmd.RegisterFlagCompletionFunc("step", cobra.FixedCompletions([]string{"1", "2"}, cobra.ShellCompDirectiveNoFileComp))
+	// via "go run -tags release main.go release" on the actual code base that is in the release.
+	r := &releaseCommandeer{
+		cmd: &cobra.Command{
+			Use:    "release",
+			Short:  "Release a new version of Hugo.",
+			Hidden: true,
 		},
 	}
+
+	r.cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		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")
+
+	return r
+}
+
+func (c *releaseCommandeer) getCommand() *cobra.Command {
+	return c.cmd
+}
+
+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")
+	}
+	return releaser.New(r.version, r.skipPublish, r.try).Run()
 }

commands/release_noop.go

@@ -0,0 +1,20 @@
+// +build !release
+
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+func createReleaser() cmder {
+	return &nilCommand{}
+}

commands/server_test.go

@@ -0,0 +1,118 @@
+// 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 (
+	"fmt"
+	"net/http"
+	"os"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestServer(t *testing.T) {
+	if isWindowsCI() {
+		// TODO(bep) not sure why server tests have started to fail on the Windows CI server.
+		t.Skip("Skip server test on appveyor")
+	}
+	assert := require.New(t)
+	dir, err := createSimpleTestSite(t)
+	assert.NoError(err)
+
+	// Let us hope that this port is available on all systems ...
+	port := 1331
+
+	defer func() {
+		os.RemoveAll(dir)
+	}()
+
+	stop := make(chan bool)
+
+	b := newCommandsBuilder()
+	scmd := b.newServerCmdSignaled(stop)
+
+	cmd := scmd.getCommand()
+	cmd.SetArgs([]string{"-s=" + dir, fmt.Sprintf("-p=%d", port)})
+
+	go func() {
+		_, err = cmd.ExecuteC()
+		assert.NoError(err)
+	}()
+
+	// 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)
+
+	resp, err := http.Get("http://localhost:1331/")
+	assert.NoError(err)
+	defer resp.Body.Close()
+	homeContent := helpers.ReaderToString(resp.Body)
+
+	assert.Contains(homeContent, "List: Hugo Commands")
+
+	// Stop the server.
+	stop <- true
+
+}
+
+func TestFixURL(t *testing.T) {
+	type data struct {
+		TestName   string
+		CLIBaseURL string
+		CfgBaseURL string
+		AppendPort bool
+		Port       int
+		Result     string
+	}
+	tests := []data{
+		{"Basic http localhost", "", "http://foo.com", true, 1313, "http://localhost:1313/"},
+		{"Basic https production, http localhost", "", "https://foo.com", true, 1313, "http://localhost:1313/"},
+		{"Basic subdir", "", "http://foo.com/bar", true, 1313, "http://localhost:1313/bar/"},
+		{"Basic production", "http://foo.com", "http://foo.com", false, 80, "http://foo.com/"},
+		{"Production subdir", "http://foo.com/bar", "http://foo.com/bar", false, 80, "http://foo.com/bar/"},
+		{"No http", "", "foo.com", true, 1313, "//localhost:1313/"},
+		{"Override configured port", "", "foo.com:2020", true, 1313, "//localhost:1313/"},
+		{"No http production", "foo.com", "foo.com", false, 80, "//foo.com/"},
+		{"No http production with port", "foo.com", "foo.com", true, 2020, "//foo.com:2020/"},
+		{"No config", "", "", true, 1313, "//localhost:1313/"},
+	}
+
+	for i, test := range tests {
+		b := newCommandsBuilder()
+		s := b.newServerCmd()
+		v := viper.New()
+		baseURL := test.CLIBaseURL
+		v.Set("baseURL", test.CfgBaseURL)
+		s.serverAppend = test.AppendPort
+		s.serverPort = test.Port
+		result, err := s.fixURL(v, baseURL, s.serverPort)
+		if err != nil {
+			t.Errorf("Test #%d %s: unexpected error %s", i, test.TestName, err)
+		}
+		if result != test.Result {
+			t.Errorf("Test #%d %s: expected %q, got %q", i, test.TestName, test.Result, result)
+		}
+	}
+}
+
+func isWindowsCI() bool {
+	return runtime.GOOS == "windows" && os.Getenv("CI") != ""
+}

commands/static_syncer.go

@@ -0,0 +1,130 @@
+// Copyright 2017 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/hugolib/filesystems"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/spf13/fsync"
+)
+
+type staticSyncer struct {
+	c *commandeer
+}
+
+func newStaticSyncer(c *commandeer) (*staticSyncer, error) {
+	return &staticSyncer{c: c}, nil
+}
+
+func (s *staticSyncer) isStatic(filename string) bool {
+	return s.c.hugo.BaseFs.SourceFilesystems.IsStatic(filename)
+}
+
+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
+		}
+
+		if sourceFs.PublishFolder != "" {
+			publishDir = filepath.Join(publishDir, sourceFs.PublishFolder)
+		}
+
+		syncer := fsync.NewSyncer()
+		syncer.NoTimes = c.Cfg.GetBool("noTimes")
+		syncer.NoChmod = c.Cfg.GetBool("noChmod")
+		syncer.SrcFs = sourceFs.Fs
+		syncer.DestFs = c.Fs.Destination
+
+		// prevent spamming the log on changes
+		logger := helpers.NewDistinctFeedbackLogger()
+
+		for _, ev := range staticEvents {
+			// Due to our approach of layering both directories and the content's rendered output
+			// into one we can't accurately remove a file not in one of the source directories.
+			// If a file is in the local static dir and also in the theme static dir and we remove
+			// it from one of those locations we expect it to still exist in the destination
+			//
+			// If Hugo generates a file (from the content dir) over a static file
+			// the content generated file should take precedence.
+			//
+			// Because we are now watching and handling individual events it is possible that a static
+			// event that occupies the same path as a content generated file will take precedence
+			// until a regeneration of the content takes places.
+			//
+			// Hugo assumes that these cases are very rare and will permit this bad behavior
+			// The alternative is to track every single file and which pipeline rendered it
+			// and then to handle conflict resolution on every event.
+
+			fromPath := ev.Name
+
+			relPath := sourceFs.MakePathRelative(fromPath)
+			if relPath == "" {
+				// Not member of this virtual host.
+				continue
+			}
+
+			// Remove || rename is harder and will require an assumption.
+			// Hugo takes the following approach:
+			// If the static file exists in any of the static source directories after this event
+			// Hugo will re-sync it.
+			// If it does not exist in all of the static directories Hugo will remove it.
+			//
+			// This assumes that Hugo has not generated content on top of a static file and then removed
+			// the source of that static file. In this case Hugo will incorrectly remove that file
+			// from the published directory.
+			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", 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 {
+						c.Logger.ERROR.Println(err)
+					}
+				} else {
+					c.Logger.ERROR.Println(err)
+				}
+
+				continue
+			}
+
+			// For all other event operations Hugo will sync static.
+			logger.Println("Syncing", relPath, "to", publishDir)
+			if err := syncer.Sync(filepath.Join(publishDir, relPath), relPath); err != nil {
+				c.Logger.ERROR.Println(err)
+			}
+		}
+
+		return 0, nil
+	}
+
+	_, err := c.doWithPublishDirs(syncFn)
+	return err
+
+}

commands/version.go

@@ -0,0 +1,68 @@
+// 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 (
+	"runtime"
+	"strings"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/resource/tocss/scss"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*versionCmd)(nil)
+
+type versionCmd struct {
+	*baseCmd
+}
+
+func newVersionCmd() *versionCmd {
+	return &versionCmd{
+		newBaseCmd(&cobra.Command{
+			Use:   "version",
+			Short: "Print the version number of Hugo",
+			Long:  `All software has versions. This is Hugo's.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				printHugoVersion()
+				return nil
+			},
+		}),
+	}
+}
+
+func printHugoVersion() {
+	program := "Hugo Static Site Generator"
+
+	version := "v" + helpers.CurrentHugoVersion.String()
+	if hugolib.CommitHash != "" {
+		version += "-" + strings.ToUpper(hugolib.CommitHash)
+	}
+	if scss.Supports() {
+		version += "/extended"
+	}
+
+	osArch := runtime.GOOS + "/" + runtime.GOARCH
+
+	var buildDate string
+	if hugolib.BuildDate != "" {
+		buildDate = hugolib.BuildDate
+	} else {
+		buildDate = "unknown"
+	}
+
+	jww.FEEDBACK.Println(program, version, osArch, "BuildDate:", buildDate)
+}

common/collections/append.go

@@ -1,152 +0,0 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package collections
-
-import (
-	"fmt"
-	"reflect"
-)
-
-// Append appends from to a slice to and returns the resulting slice.
-// If length of from is one and the only element is a slice of same type as to,
-// it will be appended.
-func Append(to any, from ...any) (any, error) {
-	if len(from) == 0 {
-		return to, nil
-	}
-	tov, toIsNil := indirect(reflect.ValueOf(to))
-
-	toIsNil = toIsNil || to == nil
-	var tot reflect.Type
-
-	if !toIsNil {
-		if tov.Kind() == reflect.Slice {
-			// Create a copy of tov, so we don't modify the original.
-			c := reflect.MakeSlice(tov.Type(), tov.Len(), tov.Len()+len(from))
-			reflect.Copy(c, tov)
-			tov = c
-		}
-
-		if tov.Kind() != reflect.Slice {
-			return nil, fmt.Errorf("expected a slice, got %T", to)
-		}
-
-		tot = tov.Type().Elem()
-		if tot.Kind() == reflect.Slice {
-			totvt := tot.Elem()
-			fromvs := make([]reflect.Value, len(from))
-			for i, f := range from {
-				fromv := reflect.ValueOf(f)
-				fromt := fromv.Type()
-				if fromt.Kind() == reflect.Slice {
-					fromt = fromt.Elem()
-				}
-				if totvt != fromt {
-					return nil, fmt.Errorf("cannot append slice of %s to slice of %s", fromt, totvt)
-				} else {
-					fromvs[i] = fromv
-				}
-			}
-			return reflect.Append(tov, fromvs...).Interface(), nil
-
-		}
-
-		toIsNil = tov.Len() == 0
-
-		if len(from) == 1 {
-			fromv := reflect.ValueOf(from[0])
-			if !fromv.IsValid() {
-				// from[0] is nil
-				return appendToInterfaceSliceFromValues(tov, fromv)
-			}
-			fromt := fromv.Type()
-			if fromt.Kind() == reflect.Slice {
-				fromt = fromt.Elem()
-			}
-			if fromv.Kind() == reflect.Slice {
-				if toIsNil {
-					// If we get nil []string, we just return the []string
-					return from[0], nil
-				}
-
-				// If we get []string []string, we append the from slice to to
-				if tot == fromt {
-					return reflect.AppendSlice(tov, fromv).Interface(), nil
-				} else if !fromt.AssignableTo(tot) {
-					// Fall back to a []interface{} slice.
-					return appendToInterfaceSliceFromValues(tov, fromv)
-				}
-
-			}
-		}
-	}
-
-	if toIsNil {
-		return Slice(from...), nil
-	}
-
-	for _, f := range from {
-		fv := reflect.ValueOf(f)
-		if !fv.IsValid() || !fv.Type().AssignableTo(tot) {
-			// Fall back to a []interface{} slice.
-			tov, _ := indirect(reflect.ValueOf(to))
-			return appendToInterfaceSlice(tov, from...)
-		}
-		tov = reflect.Append(tov, fv)
-	}
-
-	return tov.Interface(), nil
-}
-
-func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]any, error) {
-	var tos []any
-
-	for _, slice := range []reflect.Value{slice1, slice2} {
-		if !slice.IsValid() {
-			tos = append(tos, nil)
-			continue
-		}
-		for i := range slice.Len() {
-			tos = append(tos, slice.Index(i).Interface())
-		}
-	}
-
-	return tos, nil
-}
-
-func appendToInterfaceSlice(tov reflect.Value, from ...any) ([]any, error) {
-	var tos []any
-
-	for i := range tov.Len() {
-		tos = append(tos, tov.Index(i).Interface())
-	}
-
-	tos = append(tos, from...)
-
-	return tos, nil
-}
-
-// indirect is borrowed from the Go stdlib: 'text/template/exec.go'
-// TODO(bep) consolidate
-func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
-	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
-		if v.IsNil() {
-			return v, true
-		}
-		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
-			break
-		}
-	}
-	return v, false
-}

common/collections/append_test.go

@@ -1,213 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package collections
-
-import (
-	"html/template"
-	"reflect"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestAppend(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	for i, test := range []struct {
-		start    any
-		addend   []any
-		expected any
-	}{
-		{[]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"}},
-			[]any{&tstSlicer{"c"}},
-			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}},
-		},
-		{
-			&tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
-			[]any{&tstSlicer{"c"}},
-			tstSlicers{
-				&tstSlicer{"a"},
-				&tstSlicer{"b"},
-				&tstSlicer{"c"},
-			},
-		},
-		{
-			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}},
-			[]any{&tstSlicerIn1{"c"}},
-			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}, &tstSlicerIn1{"c"}},
-		},
-		// https://github.com/gohugoio/hugo/issues/5361
-		{
-			[]string{"a", "b"},
-			[]any{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
-			[]any{"a", "b", &tstSlicer{"a"}, &tstSlicer{"b"}},
-		},
-		{
-			[]string{"a", "b"},
-			[]any{&tstSlicer{"a"}},
-			[]any{"a", "b", &tstSlicer{"a"}},
-		},
-		// Errors
-		{"", []any{[]string{"a", "b"}}, false},
-		// No string concatenation.
-		{
-			"ab",
-			[]any{"c"},
-			false,
-		},
-		{[]string{"a", "b"}, []any{nil}, []any{"a", "b", nil}},
-		{[]string{"a", "b"}, []any{nil, "d", nil}, []any{"a", "b", nil, "d", nil}},
-		{[]any{"a", nil, "c"}, []any{"d", nil, "f"}, []any{"a", nil, "c", "d", nil, "f"}},
-		{[]string{"a", "b"}, []any{}, []string{"a", "b"}},
-	} {
-
-		result, err := Append(test.start, test.addend...)
-
-		if b, ok := test.expected.(bool); ok && !b {
-
-			c.Assert(err, qt.Not(qt.IsNil))
-			continue
-		}
-
-		c.Assert(err, qt.IsNil)
-		c.Assert(result, qt.DeepEquals, test.expected, qt.Commentf("test: [%d] %v", i, test))
-	}
-}
-
-// #11093
-func TestAppendToMultiDimensionalSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	for _, test := range []struct {
-		to       any
-		from     []any
-		expected any
-	}{
-		{
-			[][]string{{"a", "b"}},
-			[]any{[]string{"c", "d"}},
-			[][]string{
-				{"a", "b"},
-				{"c", "d"},
-			},
-		},
-		{
-			[][]string{{"a", "b"}},
-			[]any{[]string{"c", "d"}, []string{"e", "f"}},
-			[][]string{
-				{"a", "b"},
-				{"c", "d"},
-				{"e", "f"},
-			},
-		},
-		{
-			[][]string{{"a", "b"}},
-			[]any{[]int{1, 2}},
-			false,
-		},
-	} {
-		result, err := Append(test.to, test.from...)
-		if b, ok := test.expected.(bool); ok && !b {
-			c.Assert(err, qt.Not(qt.IsNil))
-		} else {
-			c.Assert(err, qt.IsNil)
-			c.Assert(result, qt.DeepEquals, test.expected)
-		}
-	}
-}
-
-func TestAppendShouldMakeACopyOfTheInputSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-	slice := make([]string, 0, 100)
-	slice = append(slice, "a", "b")
-	result, err := Append(slice, "c")
-	c.Assert(err, qt.IsNil)
-	slice[0] = "d"
-	c.Assert(result, qt.DeepEquals, []string{"a", "b", "c"})
-	c.Assert(slice, qt.DeepEquals, []string{"d", "b"})
-}
-
-func TestIndirect(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	type testStruct struct {
-		Field string
-	}
-
-	var (
-		nilPtr      *testStruct
-		nilIface    interface{} = nil
-		nonNilIface interface{} = &testStruct{Field: "hello"}
-	)
-
-	tests := []struct {
-		name     string
-		input    any
-		wantKind reflect.Kind
-		wantNil  bool
-	}{
-		{
-			name:     "nil pointer",
-			input:    nilPtr,
-			wantKind: reflect.Ptr,
-			wantNil:  true,
-		},
-		{
-			name:     "nil interface",
-			input:    nilIface,
-			wantKind: reflect.Invalid,
-			wantNil:  false,
-		},
-		{
-			name:     "non-nil pointer to struct",
-			input:    &testStruct{Field: "abc"},
-			wantKind: reflect.Struct,
-			wantNil:  false,
-		},
-		{
-			name:     "non-nil interface holding pointer",
-			input:    nonNilIface,
-			wantKind: reflect.Struct,
-			wantNil:  false,
-		},
-		{
-			name:     "plain value",
-			input:    testStruct{Field: "xyz"},
-			wantKind: reflect.Struct,
-			wantNil:  false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			v := reflect.ValueOf(tt.input)
-			got, isNil := indirect(v)
-
-			c.Assert(got.Kind(), qt.Equals, tt.wantKind)
-			c.Assert(isNil, qt.Equals, tt.wantNil)
-		})
-	}
-}

common/collections/collections.go

@@ -1,21 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package collections contains common Hugo functionality related to collection
-// handling.
-package collections
-
-// Grouper defines a very generic way to group items by a given key.
-type Grouper interface {
-	Group(key any, items any) (any, error)
-}

common/collections/order.go

@@ -1,20 +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 collections
-
-type Order interface {
-	// Ordinal is a zero-based ordinal that represents the order of an object
-	// in a collection.
-	Ordinal() int
-}

common/collections/slice.go

@@ -1,95 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package collections
-
-import (
-	"reflect"
-	"sort"
-)
-
-// Slicer defines a very generic way to create a typed slice. This is used
-// in collections.Slice template func to get types such as Pages, PageGroups etc.
-// instead of the less useful []interface{}.
-type Slicer interface {
-	Slice(items any) (any, error)
-}
-
-// Slice returns a slice of all passed arguments.
-func Slice(args ...any) any {
-	if len(args) == 0 {
-		return args
-	}
-
-	first := args[0]
-	firstType := reflect.TypeOf(first)
-
-	if firstType == nil {
-		return args
-	}
-
-	if g, ok := first.(Slicer); ok {
-		v, err := g.Slice(args)
-		if err == nil {
-			return v
-		}
-
-		// If Slice fails, the items are not of the same type and
-		// []interface{} is the best we can do.
-		return args
-	}
-
-	if len(args) > 1 {
-		// This can be a mix of types.
-		for i := 1; i < len(args); i++ {
-			if firstType != reflect.TypeOf(args[i]) {
-				// []interface{} is the best we can do
-				return args
-			}
-		}
-	}
-
-	slice := reflect.MakeSlice(reflect.SliceOf(firstType), len(args), len(args))
-	for i, arg := range args {
-		slice.Index(i).Set(reflect.ValueOf(arg))
-	}
-	return slice.Interface()
-}
-
-// 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
-}
-
-type SortedStringSlice []string
-
-// Contains returns true if s is in ss.
-func (ss SortedStringSlice) Contains(s string) bool {
-	i := sort.SearchStrings(ss, s)
-	return i < len(ss) && ss[i] == s
-}
-
-// Count returns the number of times s is in ss.
-func (ss SortedStringSlice) Count(s string) int {
-	var count int
-	i := sort.SearchStrings(ss, s)
-	for i < len(ss) && ss[i] == s {
-		count++
-		i++
-	}
-	return count
-}

common/collections/slice_test.go

@@ -1,172 +0,0 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package collections
-
-import (
-	"errors"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-var (
-	_ Slicer              = (*tstSlicer)(nil)
-	_ Slicer              = (*tstSlicerIn1)(nil)
-	_ Slicer              = (*tstSlicerIn2)(nil)
-	_ testSlicerInterface = (*tstSlicerIn1)(nil)
-	_ testSlicerInterface = (*tstSlicerIn1)(nil)
-)
-
-type testSlicerInterface interface {
-	Name() string
-}
-
-type testSlicerInterfaces []testSlicerInterface
-
-type tstSlicerIn1 struct {
-	TheName string
-}
-
-type tstSlicerIn2 struct {
-	TheName string
-}
-
-type tstSlicer struct {
-	TheName string
-}
-
-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) {
-		case testSlicerInterface:
-			result[i] = vv
-		default:
-			return nil, errors.New("invalid type")
-		}
-	}
-	return result, nil
-}
-
-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) {
-		case testSlicerInterface:
-			result[i] = vv
-		default:
-			return nil, errors.New("invalid type")
-		}
-	}
-	return result, nil
-}
-
-func (p *tstSlicerIn1) Name() string {
-	return p.TheName
-}
-
-func (p *tstSlicerIn2) Name() string {
-	return p.TheName
-}
-
-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) {
-		case *tstSlicer:
-			result[i] = vv
-		default:
-			return nil, errors.New("invalid type")
-		}
-	}
-	return result, nil
-}
-
-type tstSlicers []*tstSlicer
-
-func TestSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	for i, test := range []struct {
-		args     []any
-		expected any
-	}{
-		{[]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)
-
-		result := Slice(test.args...)
-
-		c.Assert(test.expected, qt.DeepEquals, result, errMsg)
-	}
-}
-
-func TestSortedStringSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	var s SortedStringSlice = []string{"a", "b", "b", "b", "c", "d"}
-
-	c.Assert(s.Contains("a"), qt.IsTrue)
-	c.Assert(s.Contains("b"), qt.IsTrue)
-	c.Assert(s.Contains("z"), qt.IsFalse)
-	c.Assert(s.Count("b"), qt.Equals, 3)
-	c.Assert(s.Count("z"), qt.Equals, 0)
-	c.Assert(s.Count("a"), qt.Equals, 1)
-}
-
-func TestStringSliceToInterfaceSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	tests := []struct {
-		name string
-		in   []string
-		want []any
-	}{
-		{
-			name: "empty slice",
-			in:   []string{},
-			want: []any{},
-		},
-		{
-			name: "single element",
-			in:   []string{"hello"},
-			want: []any{"hello"},
-		},
-		{
-			name: "multiple elements",
-			in:   []string{"a", "b", "c"},
-			want: []any{"a", "b", "c"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := StringSliceToInterfaceSlice(tt.in)
-			c.Assert(got, qt.DeepEquals, tt.want)
-		})
-	}
-}

common/collections/stack.go

@@ -1,82 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package collections
-
-import "slices"
-
-import "sync"
-
-// Stack is a simple LIFO stack that is safe for concurrent use.
-type Stack[T any] struct {
-	items []T
-	zero  T
-	mu    sync.RWMutex
-}
-
-func NewStack[T any]() *Stack[T] {
-	return &Stack[T]{}
-}
-
-func (s *Stack[T]) Push(item T) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.items = append(s.items, item)
-}
-
-func (s *Stack[T]) Pop() (T, bool) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if len(s.items) == 0 {
-		return s.zero, false
-	}
-	item := s.items[len(s.items)-1]
-	s.items = s.items[:len(s.items)-1]
-	return item, true
-}
-
-func (s *Stack[T]) Peek() (T, bool) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	if len(s.items) == 0 {
-		return s.zero, false
-	}
-	return s.items[len(s.items)-1], true
-}
-
-func (s *Stack[T]) Len() int {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return len(s.items)
-}
-
-func (s *Stack[T]) Drain() []T {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	items := s.items
-	s.items = nil
-	return items
-}
-
-func (s *Stack[T]) DrainMatching(predicate func(T) bool) []T {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	var items []T
-	for i := len(s.items) - 1; i >= 0; i-- {
-		if predicate(s.items[i]) {
-			items = append(items, s.items[i])
-			s.items = slices.Delete(s.items, i, i+1)
-		}
-	}
-	return items
-}

common/collections/stack_test.go

@@ -1,77 +0,0 @@
-package collections
-
-import (
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestNewStack(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	s := NewStack[int]()
-
-	c.Assert(s, qt.IsNotNil)
-}
-
-func TestStackBasic(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	s := NewStack[int]()
-
-	c.Assert(s.Len(), qt.Equals, 0)
-
-	s.Push(1)
-	s.Push(2)
-	s.Push(3)
-
-	c.Assert(s.Len(), qt.Equals, 3)
-
-	top, ok := s.Peek()
-	c.Assert(ok, qt.Equals, true)
-	c.Assert(top, qt.Equals, 3)
-
-	popped, ok := s.Pop()
-	c.Assert(ok, qt.Equals, true)
-	c.Assert(popped, qt.Equals, 3)
-
-	c.Assert(s.Len(), qt.Equals, 2)
-
-	_, _ = s.Pop()
-	_, _ = s.Pop()
-	_, ok = s.Pop()
-
-	c.Assert(ok, qt.Equals, false)
-}
-
-func TestStackDrain(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	s := NewStack[string]()
-	s.Push("a")
-	s.Push("b")
-
-	got := s.Drain()
-
-	c.Assert(got, qt.DeepEquals, []string{"a", "b"})
-	c.Assert(s.Len(), qt.Equals, 0)
-}
-
-func TestStackDrainMatching(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	s := NewStack[int]()
-	s.Push(1)
-	s.Push(2)
-	s.Push(3)
-	s.Push(4)
-
-	got := s.DrainMatching(func(v int) bool { return v%2 == 0 })
-
-	c.Assert(got, qt.DeepEquals, []int{4, 2})
-	c.Assert(s.Drain(), qt.DeepEquals, []int{1, 3})
-}

common/constants/constants.go

@@ -1,49 +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 constants
-
-// Error/Warning IDs.
-// Do not change these values.
-const (
-	// IDs for remote errors in tpl/data.
-	ErrRemoteGetJSON = "error-remote-getjson"
-	ErrRemoteGetCSV  = "error-remote-getcsv"
-
-	WarnFrontMatterParamsOverrides = "warning-frontmatter-params-overrides"
-	WarnRenderShortcodesInHTML     = "warning-rendershortcodes-in-html"
-	WarnGoldmarkRawHTML            = "warning-goldmark-raw-html"
-	WarnPartialSuperfluousPrefix   = "warning-partial-superfluous-prefix"
-	WarnHomePageIsLeafBundle       = "warning-home-page-is-leaf-bundle"
-)
-
-// Field/method names with special meaning.
-const (
-	FieldRelPermalink = "RelPermalink"
-	FieldPermalink    = "Permalink"
-)
-
-// IsFieldRelOrPermalink returns whether the given name is a RelPermalink or Permalink.
-func IsFieldRelOrPermalink(name string) bool {
-	return name == FieldRelPermalink || name == FieldPermalink
-}
-
-// Resource transformations.
-const (
-	ResourceTransformationFingerprint = "fingerprint"
-)
-
-// IsResourceTransformationPermalinkHash returns whether the given name is a resource transformation that changes the permalink based on the content.
-func IsResourceTransformationPermalinkHash(name string) bool {
-	return name == ResourceTransformationFingerprint
-}

common/docs.go

@@ -1,2 +0,0 @@
-// Package common provides common helper functionality for Hugo.
-package common

common/errors/errors.go

@@ -0,0 +1,23 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package errors contains common Hugo errors and error related utilities.
+package errors
+
+import (
+	"errors"
+)
+
+// We will, at least to begin with, make some Hugo features (SCSS with libsass) optional,
+// and this error is used to signal those situations.
+var FeatureNotAvailableErr = errors.New("this feature is not available in your current Hugo version")

common/hashing/hashing.go

@@ -1,194 +0,0 @@
-// Copyright 2024 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 hashing provides common hashing utilities.
-package hashing
-
-import (
-	"crypto/md5"
-	"encoding/hex"
-	"io"
-	"strconv"
-	"sync"
-
-	"github.com/cespare/xxhash/v2"
-	"github.com/gohugoio/hashstructure"
-	"github.com/gohugoio/hugo/identity"
-)
-
-// XXHashFromReader calculates the xxHash for the given reader.
-func XXHashFromReader(r io.Reader) (uint64, int64, error) {
-	h := getXxHashReadFrom()
-	defer putXxHashReadFrom(h)
-
-	size, err := io.Copy(h, r)
-	if err != nil {
-		return 0, 0, err
-	}
-	return h.Sum64(), size, nil
-}
-
-// XxHashFromReaderHexEncoded calculates the xxHash for the given reader
-// and returns the hash as a hex encoded string.
-func XxHashFromReaderHexEncoded(r io.Reader) (string, error) {
-	h := getXxHashReadFrom()
-	defer putXxHashReadFrom(h)
-	_, err := io.Copy(h, r)
-	if err != nil {
-		return "", err
-	}
-	hash := h.Sum(nil)
-	return hex.EncodeToString(hash), nil
-}
-
-// XXHashFromString calculates the xxHash for the given string.
-func XXHashFromString(s string) (uint64, error) {
-	h := xxhash.New()
-	h.WriteString(s)
-	return h.Sum64(), nil
-}
-
-// XxHashFromStringHexEncoded calculates the xxHash for the given string
-// and returns the hash as a hex encoded string.
-func XxHashFromStringHexEncoded(f string) string {
-	h := xxhash.New()
-	h.WriteString(f)
-	hash := h.Sum(nil)
-	return hex.EncodeToString(hash)
-}
-
-// MD5FromStringHexEncoded returns the MD5 hash of the given string.
-func MD5FromStringHexEncoded(f string) string {
-	h := md5.New()
-	h.Write([]byte(f))
-	return hex.EncodeToString(h.Sum(nil))
-}
-
-// HashString returns a hash from the given elements.
-// It will panic if the hash cannot be calculated.
-// Note that this hash should be used primarily for identity, not for change detection as
-// it in the more complex values (e.g. Page) will not hash the full content.
-func HashString(vs ...any) string {
-	hash := HashUint64(vs...)
-	return strconv.FormatUint(hash, 10)
-}
-
-// HashStringHex returns a hash from the given elements as a hex encoded string.
-// See HashString for more information.
-func HashStringHex(vs ...any) string {
-	hash := HashUint64(vs...)
-	return strconv.FormatUint(hash, 16)
-}
-
-var hashOptsPool = sync.Pool{
-	New: func() any {
-		return &hashstructure.HashOptions{
-			Hasher: xxhash.New(),
-		}
-	},
-}
-
-func getHashOpts() *hashstructure.HashOptions {
-	return hashOptsPool.Get().(*hashstructure.HashOptions)
-}
-
-func putHashOpts(opts *hashstructure.HashOptions) {
-	opts.Hasher.Reset()
-	hashOptsPool.Put(opts)
-}
-
-// HashUint64 returns a hash from the given elements.
-// It will panic if the hash cannot be calculated.
-// Note that this hash should be used primarily for identity, not for change detection as
-// it in the more complex values (e.g. Page) will not hash the full content.
-func HashUint64(vs ...any) uint64 {
-	var o any
-	if len(vs) == 1 {
-		o = toHashable(vs[0])
-	} else {
-		elements := make([]any, len(vs))
-		for i, e := range vs {
-			elements[i] = toHashable(e)
-		}
-		o = elements
-	}
-
-	hash, err := Hash(o)
-	if err != nil {
-		panic(err)
-	}
-	return hash
-}
-
-// Hash returns a hash from vs.
-func Hash(vs ...any) (uint64, error) {
-	hashOpts := getHashOpts()
-	defer putHashOpts(hashOpts)
-	var v any = vs
-	if len(vs) == 1 {
-		v = vs[0]
-	}
-	return hashstructure.Hash(v, hashOpts)
-}
-
-type keyer interface {
-	Key() string
-}
-
-// For structs, hashstructure.Hash only works on the exported fields,
-// so rewrite the input slice for known identity types.
-func toHashable(v any) any {
-	switch t := v.(type) {
-	case keyer:
-		return t.Key()
-	case identity.IdentityProvider:
-		return t.GetIdentity()
-	default:
-		return v
-	}
-}
-
-type xxhashReadFrom struct {
-	buff []byte
-	*xxhash.Digest
-}
-
-func (x *xxhashReadFrom) ReadFrom(r io.Reader) (int64, error) {
-	for {
-		n, err := r.Read(x.buff)
-		if n > 0 {
-			x.Digest.Write(x.buff[:n])
-		}
-		if err != nil {
-			if err == io.EOF {
-				err = nil
-			}
-			return int64(n), err
-		}
-	}
-}
-
-var xXhashReadFromPool = sync.Pool{
-	New: func() any {
-		return &xxhashReadFrom{Digest: xxhash.New(), buff: make([]byte, 48*1024)}
-	},
-}
-
-func getXxHashReadFrom() *xxhashReadFrom {
-	return xXhashReadFromPool.Get().(*xxhashReadFrom)
-}
-
-func putXxHashReadFrom(h *xxhashReadFrom) {
-	h.Reset()
-	xXhashReadFromPool.Put(h)
-}

common/hashing/hashing_test.go

@@ -1,157 +0,0 @@
-// Copyright 2024 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 hashing
-
-import (
-	"fmt"
-	"math"
-	"strings"
-	"sync"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestXxHashFromReader(t *testing.T) {
-	c := qt.New(t)
-	s := "Hello World"
-	r := strings.NewReader(s)
-	got, size, err := XXHashFromReader(r)
-	c.Assert(err, qt.IsNil)
-	c.Assert(size, qt.Equals, int64(len(s)))
-	c.Assert(got, qt.Equals, uint64(7148569436472236994))
-}
-
-func TestXxHashFromReaderPara(t *testing.T) {
-	c := qt.New(t)
-
-	var wg sync.WaitGroup
-	for i := range 10 {
-		i := i
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := range 100 {
-				s := strings.Repeat("Hello ", i+j+1*42)
-				r := strings.NewReader(s)
-				got, size, err := XXHashFromReader(r)
-				c.Assert(size, qt.Equals, int64(len(s)))
-				c.Assert(err, qt.IsNil)
-				expect, _ := XXHashFromString(s)
-				c.Assert(got, qt.Equals, expect)
-			}
-		}()
-	}
-
-	wg.Wait()
-}
-
-func TestXxHashFromString(t *testing.T) {
-	c := qt.New(t)
-	s := "Hello World"
-	got, err := XXHashFromString(s)
-	c.Assert(err, qt.IsNil)
-	c.Assert(got, qt.Equals, uint64(7148569436472236994))
-}
-
-func TestXxHashFromStringHexEncoded(t *testing.T) {
-	c := qt.New(t)
-	s := "The quick brown fox jumps over the lazy dog"
-	got := XxHashFromStringHexEncoded(s)
-	// Facit: https://asecuritysite.com/encryption/xxhash?val=The%20quick%20brown%20fox%20jumps%20over%20the%20lazy%20dog
-	c.Assert(got, qt.Equals, "0b242d361fda71bc")
-}
-
-func BenchmarkXXHashFromReader(b *testing.B) {
-	r := strings.NewReader("Hello World")
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		XXHashFromReader(r)
-		r.Seek(0, 0)
-	}
-}
-
-func BenchmarkXXHashFromString(b *testing.B) {
-	s := "Hello World"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		XXHashFromString(s)
-	}
-}
-
-func BenchmarkXXHashFromStringHexEncoded(b *testing.B) {
-	s := "The quick brown fox jumps over the lazy dog"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		XxHashFromStringHexEncoded(s)
-	}
-}
-
-func TestHashString(t *testing.T) {
-	c := qt.New(t)
-
-	c.Assert(HashString("a", "b"), qt.Equals, "3176555414984061461")
-	c.Assert(HashString("ab"), qt.Equals, "7347350983217793633")
-
-	var vals []any = []any{"a", "b", tstKeyer{"c"}}
-
-	c.Assert(HashString(vals...), qt.Equals, "4438730547989914315")
-	c.Assert(vals[2], qt.Equals, tstKeyer{"c"})
-}
-
-type tstKeyer struct {
-	key string
-}
-
-func (t tstKeyer) Key() string {
-	return t.key
-}
-
-func (t tstKeyer) String() string {
-	return "key: " + t.key
-}
-
-func BenchmarkHashString(b *testing.B) {
-	word := " hello "
-
-	var tests []string
-
-	for i := 1; i <= 5; i++ {
-		sentence := strings.Repeat(word, int(math.Pow(4, float64(i))))
-		tests = append(tests, sentence)
-	}
-
-	b.ResetTimer()
-
-	for _, test := range tests {
-		b.Run(fmt.Sprintf("n%d", len(test)), func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				HashString(test)
-			}
-		})
-	}
-}
-
-func BenchmarkHashMap(b *testing.B) {
-	m := map[string]any{}
-	for i := range 1000 {
-		m[fmt.Sprintf("key%d", i)] = i
-	}
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		HashString(m)
-	}
-}

common/hcontext/context.go

@@ -1,46 +0,0 @@
-// Copyright 2024 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 hcontext
-
-import "context"
-
-// ContextDispatcher is a generic interface for setting and getting values from a context.
-type ContextDispatcher[T any] interface {
-	Set(ctx context.Context, value T) context.Context
-	Get(ctx context.Context) T
-}
-
-// NewContextDispatcher creates a new ContextDispatcher with the given key.
-func NewContextDispatcher[T any, R comparable](key R) ContextDispatcher[T] {
-	return keyInContext[T, R]{
-		id: key,
-	}
-}
-
-type keyInContext[T any, R comparable] struct {
-	zero T
-	id   R
-}
-
-func (f keyInContext[T, R]) Get(ctx context.Context) T {
-	v := ctx.Value(f.id)
-	if v == nil {
-		return f.zero
-	}
-	return v.(T)
-}
-
-func (f keyInContext[T, R]) Set(ctx context.Context, value T) context.Context {
-	return context.WithValue(ctx, f.id, value)
-}

common/herrors/error_locator.go

@@ -1,170 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package herrors contains common Hugo errors and error related utilities.
-package herrors
-
-import (
-	"io"
-	"path/filepath"
-	"strings"
-
-	"github.com/gohugoio/hugo/common/text"
-)
-
-// LineMatcher contains the elements used to match an error to a line
-type LineMatcher struct {
-	Position text.Position
-	Error    error
-
-	LineNumber int
-	Offset     int
-	Line       string
-}
-
-// LineMatcherFn is used to match a line with an error.
-// It returns the column number or 0 if the line was found, but column could not be determined. Returns -1 if no line match.
-type LineMatcherFn func(m LineMatcher) int
-
-// SimpleLineMatcher simply matches by line number.
-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
-}
-
-// 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
-}
-
-// ContainsMatcher is a line matcher that matches by line content.
-func ContainsMatcher(text string) func(m LineMatcher) int {
-	return func(m LineMatcher) int {
-		if idx := strings.Index(m.Line, text); idx != -1 {
-			return idx + 1
-		}
-		return -1
-	}
-}
-
-// ErrorContext contains contextual information about an error. This will
-// typically be the lines surrounding some problem in a file.
-type ErrorContext struct {
-	// If a match will contain the matched line and up to 2 lines before and after.
-	// Will be empty if no match.
-	Lines []string
-
-	// The position of the error in the Lines above. 0 based.
-	LinesPos int
-
-	// 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
-}
-
-func chromaLexerFromType(fileType string) string {
-	switch fileType {
-	case "html", "htm":
-		return "go-html-template"
-	}
-	return fileType
-}
-
-func extNoDelimiter(filename string) string {
-	return strings.TrimPrefix(filepath.Ext(filename), ".")
-}
-
-func chromaLexerFromFilename(filename string) string {
-	if strings.Contains(filename, "layouts") {
-		return "go-html-template"
-	}
-
-	ext := extNoDelimiter(filename)
-	return chromaLexerFromType(ext)
-}
-
-func locateErrorInString(src string, matcher LineMatcherFn) *ErrorContext {
-	return locateError(strings.NewReader(src), &fileError{}, matcher)
-}
-
-func locateError(r io.Reader, le FileError, matches LineMatcherFn) *ErrorContext {
-	if le == nil {
-		panic("must provide an error")
-	}
-
-	ectx := &ErrorContext{LinesPos: -1, Position: text.Position{Offset: -1}}
-
-	b, err := io.ReadAll(r)
-	if err != nil {
-		return ectx
-	}
-
-	lines := strings.Split(string(b), "\n")
-
-	lineNo := 0
-	posBytes := 0
-
-	for li, line := range lines {
-		lineNo = li + 1
-		m := LineMatcher{
-			Position:   le.Position(),
-			Error:      le,
-			LineNumber: lineNo,
-			Offset:     posBytes,
-			Line:       line,
-		}
-		v := matches(m)
-		if ectx.LinesPos == -1 && v != -1 {
-			ectx.Position.LineNumber = lineNo
-			ectx.Position.ColumnNumber = v
-			break
-		}
-
-		posBytes += len(line)
-	}
-
-	if ectx.Position.LineNumber > 0 {
-		low := max(ectx.Position.LineNumber-3, 0)
-
-		if ectx.Position.LineNumber > 2 {
-			ectx.LinesPos = 2
-		} else {
-			ectx.LinesPos = ectx.Position.LineNumber - 1
-		}
-
-		high := min(ectx.Position.LineNumber+2, len(lines))
-
-		ectx.Lines = lines[low:high]
-
-	}
-
-	return ectx
-}

common/herrors/error_locator_test.go

@@ -1,152 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package herrors contains common Hugo errors and error related utilities.
-package herrors
-
-import (
-	"strings"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestErrorLocator(t *testing.T) {
-	c := qt.New(t)
-
-	lineMatcher := func(m LineMatcher) int {
-		if strings.Contains(m.Line, "THEONE") {
-			return 1
-		}
-		return -1
-	}
-
-	lines := `LINE 1
-LINE 2
-LINE 3
-LINE 4
-This is THEONE
-LINE 6
-LINE 7
-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"})
-
-	c.Assert(pos.LineNumber, qt.Equals, 5)
-	c.Assert(location.LinesPos, qt.Equals, 2)
-
-	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)
-	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 = 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 = locate(`L1
-This THEONE
-`, lineMatcher)
-	c.Assert(location.Lines, qt.DeepEquals, []string{"L1", "This THEONE", ""})
-	c.Assert(location.LinesPos, qt.Equals, 1)
-
-	location = locate(`L1
-L2
-This THEONE
-`, lineMatcher)
-	c.Assert(location.Lines, qt.DeepEquals, []string{"L1", "L2", "This THEONE", ""})
-	c.Assert(location.LinesPos, qt.Equals, 2)
-
-	location = locateErrorInString("NO MATCH", lineMatcher)
-	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) int {
-		if m.LineNumber == 6 {
-			return 1
-		}
-		return -1
-	}
-
-	location = locateErrorInString(`A
-B
-C
-D
-E
-F
-G
-H
-I
-J`, lineMatcher)
-	pos = location.Position
-
-	c.Assert(location.Lines, qt.DeepEquals, []string{"D", "E", "F", "G", "H"})
-	c.Assert(pos.LineNumber, qt.Equals, 6)
-	c.Assert(location.LinesPos, qt.Equals, 2)
-
-	// Test match EOF
-	lineMatcher = func(m LineMatcher) int {
-		if m.LineNumber == 4 {
-			return 1
-		}
-		return -1
-	}
-
-	location = locateErrorInString(`A
-B
-C
-`, lineMatcher)
-
-	pos = location.Position
-
-	c.Assert(location.Lines, qt.DeepEquals, []string{"B", "C", ""})
-	c.Assert(pos.LineNumber, qt.Equals, 4)
-	c.Assert(location.LinesPos, qt.Equals, 2)
-
-	offsetMatcher := func(m LineMatcher) int {
-		if m.Offset == 1 {
-			return 1
-		}
-		return -1
-	}
-
-	location = locateErrorInString(`A
-B
-C
-D
-E`, offsetMatcher)
-
-	pos = location.Position
-
-	c.Assert(location.Lines, qt.DeepEquals, []string{"A", "B", "C", "D"})
-	c.Assert(pos.LineNumber, qt.Equals, 2)
-	c.Assert(location.LinesPos, qt.Equals, 1)
-}