bugfix for relative dev path

.devcontainer/devcontainer.json

@@ -1,4 +0,0 @@
-{
-  "image": "ghcr.io/spack/ubuntu20.04-runner-amd64-gcc-11.4:2023.08.01",
-  "postCreateCommand": "./.devcontainer/postCreateCommand.sh"
-}

.devcontainer/postCreateCommand.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# Load spack environment at terminal startup
-cat <<EOF >> /root/.bashrc
-. /workspaces/spack/share/spack/setup-env.sh
-EOF
-
-# Load spack environment in this script
-. /workspaces/spack/share/spack/setup-env.sh
-
-# Ensure generic targets for maximum matching with buildcaches
-spack config --scope site add "packages:all:require:[target=x86_64_v3]"
-spack config --scope site add "concretizer:targets:granularity:generic"
-
-# Find compiler and install gcc-runtime
-spack compiler find --scope site
-
-# Setup buildcaches
-spack mirror add --scope site develop https://binaries.spack.io/develop
-spack buildcache keys --install --trust

.flake8

@@ -1,25 +1,43 @@
 # -*- conf -*-
-# flake8 settings for Spack.
+# flake8 settings for Spack core files.
 #
 # These exceptions are for Spack core files. We're slightly more lenient
 # with packages.  See .flake8_packages for that.
 #
-# This is the only flake8 rule Spack violates somewhat flagrantly
+# E1: Indentation
+# - E129: visually indented line with same indent as next logical line
+#
+# E2: Whitespace
+# - E221: multiple spaces before operator
+# - E241: multiple spaces after ','
+# - E272: multiple spaces before keyword
+#
+# E7: Statement
 # - E731: do not assign a lambda expression, use a def
 #
-# This is the only flake8 exception needed when using Black.
-# - E203: white space around slice operators can be required, ignore : warn
+# W5: Line break warning
+# - W503: line break before binary operator
+# - W504: line break after binary operator
 #
-# We still allow these in packages (Would like to get rid of them or rely on mypy
-# in the future)
-# - F403: from/import * used; unable to detect undefined names
+# These are required to get the package.py files to test clean:
+# - F999: syntax error in doctest
+#
+# N8: PEP8-naming
+# - N801: class names should use CapWords convention
+# - N813: camelcase imported as lowercase
+# - N814: camelcase imported as constant
+#
+# F4: pyflakes import checks, these are now checked by mypy more precisely
+# - F403: from module import *
 # - F405: undefined name or from *
-# - F821: undefined name (needed with from/import *)
+#
+# Black ignores, these are incompatible with black style and do not follow PEP-8
+# - E203: white space around slice operators can be required, ignore : warn
+# - W503: see above, already ignored for line-breaks
 #
 [flake8]
-#ignore = E129,,W503,W504,F999,N801,N813,N814,F403,F405,E203
-extend-ignore = E731,E203
-max-line-length = 99
+ignore = E129,E221,E241,E272,E731,W503,W504,F999,N801,N813,N814,F403,F405
+max-line-length = 88
 
 # F4: Import
 # - F405: `name` may be undefined, or undefined from star imports: `module`
@@ -28,8 +46,7 @@ max-line-length = 99
 # - F821: undefined name `name`
 #
 per-file-ignores =
-  var/spack/repos/*/package.py:F403,F405,F821
-  *-ci-package.py:F403,F405,F821
+  var/spack/repos/*/package.py:F405,F821
 
 # exclude things we usually do not want linting for.
 # These still get linted when passed explicitly, as when spack flake8 passes

.git-blame-ignore-revs

@@ -1,5 +0,0 @@
-# .git-blame-ignore-revs
-# Formatted entire codebase with black 23
-603569e321013a1a63a637813c94c2834d0a0023
-# Formatted entire codebase with black 22
-f52f6e99dbf1131886a80112b8c79dfc414afb7c

.gitattributes

@@ -1,4 +1,3 @@
 *.py diff=python
 *.lp linguist-language=Prolog
 lib/spack/external/* linguist-vendored
-*.bat text eol=crlf

.github/ISSUE_TEMPLATE/build_error.yml

@@ -9,38 +9,26 @@ body:
         Thanks for taking the time to report this build failure. To proceed with the report please:
         1. Title the issue `Installation issue: <name-of-the-package>`.
         2. Provide the information required below.
-
+        
         We encourage you to try, as much as possible, to reduce your problem to the minimal example that still reproduces the issue. That would help us a lot in fixing it quickly and effectively!
   - type: textarea
     id: reproduce
     attributes:
       label: Steps to reproduce the issue
       description: |
-        Fill in the console output from the exact spec you are trying to build.
-      value: |
+        Fill in the exact spec you are trying to build and the relevant part of the error message
+      placeholder: |
         ```console
-        $ spack spec -I <spec>
+        $ spack install <spec>
         ...
         ```
-  - type: textarea
-    id: error
-    attributes:
-      label: Error message
-      description: |
-        Please post the error message from spack inside the `<details>` tag below:
-      value: |
-        <details><summary>Error message</summary>
-
-        <pre>
-        ...
-        </pre></details>
     validations:
       required: true
   - type: textarea
     id: information
     attributes:
       label: Information on your system
-      description: Please include the output of `spack debug report`.
+      description: Please include the output of `spack debug report`
     validations:
       required: true
   - type: markdown
@@ -55,7 +43,7 @@ body:
         Please upload the following files:
         * **`spack-build-out.txt`**
         * **`spack-build-env.txt`**
-
+        
         They should be present in the stage directory of the failing build. Also upload any `config.log` or similar file if one exists.
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,4 +1,4 @@
-name: "\U0001F38A Feature request"
+name: "\U0001F38A Feature request" 
 description: Suggest adding a feature that is not yet in Spack
 labels: [feature]
 body:
@@ -29,11 +29,13 @@ body:
     attributes:
       label: General information
       options:
+        - label: I have run `spack --version` and reported the version of Spack
+          required: true
         - label: I have searched the issues of this repo and believe this is not a duplicate
           required: true
   - type: markdown
     attributes:
       value: |
         If you want to ask a question about the tool (how to use it, what it can currently do, etc.), try the `#general` channel on [our Slack](https://slack.spack.io/) first. We have a welcoming community and chances are you'll get your reply faster and without opening an issue.
-
+        
         Other than that, thanks for taking the time to contribute to Spack!

.github/ISSUE_TEMPLATE/test_error.yml

@@ -1,64 +0,0 @@
-name: "\U0001F4A5 Tests error"
-description: Some package in Spack had stand-alone tests that didn't pass
-title: "Testing issue: "
-labels: [test-error]
-body:
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: Steps to reproduce the failure(s) or link(s) to test output(s)
-      description: |
-        Fill in the test output from the exact spec that is having stand-alone test failures. Links to test outputs (e.g., CDash) can also be provided.
-      value: |
-        ```console
-        $ spack spec -I <spec>
-        ...
-        ```
-  - type: textarea
-    id: error
-    attributes:
-      label: Error message
-      description: |
-        Please post the error message from spack inside the `<details>` tag below:
-      value: |
-        <details><summary>Error message</summary>
-
-        <pre>
-        ...
-        </pre></details>
-    validations:
-      required: true
-  - type: textarea
-    id: information
-    attributes:
-      label: Information on your system or the test runner
-      description: Please include the output of `spack debug report` for your system.
-    validations:
-      required: true
-  - type: markdown
-    attributes:
-      value: |
-        If you have any relevant configuration detail (custom `packages.yaml` or `modules.yaml`, etc.) you can add that here as well.
-  - type: textarea
-    id: additional_information
-    attributes:
-      label: Additional information
-      description: |
-        Please upload test logs or any additional information about the problem.
-  - type: markdown
-    attributes:
-      value: |
-        Some packages have maintainers who have volunteered to debug build failures. Run `spack maintainers <name-of-the-package>` and **@mention** them here if they exist.
-  - type: checkboxes
-    id: checks
-    attributes:
-      label: General information
-      options:
-        - label: I have reported the version of Spack/Python/Platform/Runner
-          required: true
-        - label: I have run `spack maintainers <name-of-the-package>` and **@mentioned** any maintainers
-          required: true
-        - label: I have uploaded any available logs
-          required: true
-        - label: I have searched the issues of this repo and believe this is not a duplicate
-          required: true

.github/dependabot.yml

@@ -5,13 +5,3 @@ updates:
     directory: "/"
     schedule:
       interval: "daily"
-  # Requirements to build documentation
-  - package-ecosystem: "pip"
-    directory: "/lib/spack/docs"
-    schedule:
-      interval: "daily"
-  # Requirements to run style checks
-  - package-ecosystem: "pip"
-    directory: "/.github/workflows/style"
-    schedule:
-      interval: "daily"

.github/pull_request_template.md

@@ -1,6 +0,0 @@
-<!--  
-Remember that `spackbot` can help with your PR in multiple ways:
-- `@spackbot help` shows all the commands that are currently available
-- `@spackbot fix style` tries to push a commit to fix style issues in this PR
-- `@spackbot re-run pipeline` runs the pipelines again, if you have write access to the repository 
--->

.github/workflows/audit.yaml

@@ -1,51 +0,0 @@
-name: audit
-
-on:
-  workflow_call:
-    inputs:
-      with_coverage:
-        required: true
-        type: string
-      python_version:
-        required: true
-        type: string
-
-concurrency:
-  group: audit-${{inputs.python_version}}-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-jobs:
-  # Run audits on all the packages in the built-in repository
-  package-audits:
-    runs-on: ${{ matrix.operating_system }}
-    strategy:
-      matrix:
-        operating_system: ["ubuntu-latest", "macos-latest"]
-    steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
-      with:
-        python-version: ${{inputs.python_version}}
-    - name: Install Python packages
-      run: |
-        pip install --upgrade pip setuptools pytest coverage[toml]
-    - name: Package audits (with coverage)
-      if: ${{ inputs.with_coverage == 'true' }}
-      run: |
-          . share/spack/setup-env.sh
-          coverage run $(which spack) audit packages
-          coverage run $(which spack) -d audit externals        
-          coverage combine
-          coverage xml
-    - name: Package audits (without coverage)
-      if: ${{ inputs.with_coverage == 'false' }}
-      run: |
-          . share/spack/setup-env.sh
-          $(which spack) audit packages
-          $(which spack) audit externals
-    - uses: codecov/codecov-action@84508663e988701840491b86de86b666e8a86bed
-      if: ${{ inputs.with_coverage == 'true' }}
-      with:
-        flags: unittests,audits
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true

.github/workflows/bootstrap-test.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -ex
-source share/spack/setup-env.sh
-$PYTHON bin/spack bootstrap disable spack-install
-$PYTHON bin/spack -d solve zlib
-tree $BOOTSTRAP/store
-exit 0

.github/workflows/bootstrap.yml

@@ -3,16 +3,24 @@ name: Bootstrapping
 on:
   # This Workflow can be triggered manually
   workflow_dispatch:
-  workflow_call:
+  pull_request:
+    branches:
+      - develop
+      - releases/**
+    paths-ignore:
+      # Don't run if we only modified packages in the
+      # built-in repository or documentation
+      - 'var/spack/repos/builtin/**'
+      - '!var/spack/repos/builtin/packages/clingo-bootstrap/**'
+      - '!var/spack/repos/builtin/packages/python/**'
+      - '!var/spack/repos/builtin/packages/re2c/**'
+      - 'lib/spack/docs/**'
   schedule:
     # nightly at 2:16 AM
     - cron: '16 2 * * *'
 
-concurrency:
-  group: bootstrap-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
 jobs:
+
   fedora-clingo-sources:
     runs-on: ubuntu-latest
     container: "fedora:latest"
@@ -23,27 +31,19 @@ jobs:
               bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
               make patch unzip which xz python3 python3-devel tree \
               cmake bison bison-devel libstdc++-static
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-        with:
-          fetch-depth: 0
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
+      - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+      - name: Setup repo and non-root user
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
+          useradd spack-test
+          chown -R spack-test .
       - name: Bootstrap clingo
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.5
-          spack bootstrap disable github-actions-v0.4
+          spack bootstrap untrust github-actions
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -61,27 +61,19 @@ jobs:
               bzip2 curl file g++ gcc gfortran git gnupg2 gzip \
               make patch unzip xz-utils python3 python3-dev tree \
               cmake bison
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-        with:
-          fetch-depth: 0
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
+      - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+      - name: Setup repo and non-root user
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
+          useradd -m spack-test
+          chown -R spack-test .
       - name: Bootstrap clingo
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.5
-          spack bootstrap disable github-actions-v0.4
+          spack bootstrap untrust github-actions
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -98,21 +90,14 @@ jobs:
           apt-get install -y \
               bzip2 curl file g++ gcc gfortran git gnupg2 gzip \
               make patch unzip xz-utils python3 python3-dev tree
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-        with:
-          fetch-depth: 0
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
+      - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+      - name: Setup repo and non-root user
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
+          useradd -m spack-test
+          chown -R spack-test .
       - name: Bootstrap clingo
         shell: runuser -u spack-test -- bash {0}
         run: |
@@ -120,6 +105,7 @@ jobs:
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
 
+
   opensuse-clingo-sources:
     runs-on: ubuntu-latest
     container: "opensuse/leap:latest"
@@ -132,21 +118,16 @@ jobs:
               bzip2 curl file gcc-c++ gcc gcc-fortran tar git gpg2 gzip \
               make patch unzip which xz python3 python3-devel tree \
               cmake bison
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-        with:
-          fetch-depth: 0
-      - name: Setup repo
+      - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+      - name: Setup repo and non-root user
         run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap clingo
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.5
-          spack bootstrap disable github-actions-v0.4
+          spack bootstrap untrust github-actions
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -157,85 +138,57 @@ jobs:
       - name: Install dependencies
         run: |
           brew install cmake bison@2.7 tree
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-      - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
-        with:
-          python-version: "3.12"
+      - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
       - name: Bootstrap clingo
         run: |
           source share/spack/setup-env.sh
           export PATH=/usr/local/opt/bison@2.7/bin:$PATH
-          spack bootstrap disable github-actions-v0.5
-          spack bootstrap disable github-actions-v0.4
+          spack bootstrap untrust github-actions
           spack external find --not-buildable cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
 
   macos-clingo-binaries:
-    runs-on: ${{ matrix.macos-version }}
+    runs-on: macos-latest
     strategy:
       matrix:
-        macos-version: ['macos-11', 'macos-12']
+        python-version: ['3.5', '3.6', '3.7', '3.8', '3.9']
     steps:
       - name: Install dependencies
         run: |
           brew install tree
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+      - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+      - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
+        with:
+          python-version: ${{ matrix.python-version }}
       - name: Bootstrap clingo
         run: |
-          set -ex
-          for ver in '3.7' '3.8' '3.9' '3.10' '3.11' ; do
-            not_found=1
-            ver_dir="$(find $RUNNER_TOOL_CACHE/Python -wholename "*/${ver}.*/*/bin" | grep . || true)"
-            echo "Testing $ver_dir"
-            if [[ -d "$ver_dir" ]] ; then
-              if $ver_dir/python --version ; then
-                export PYTHON="$ver_dir/python"
-                not_found=0
-                old_path="$PATH"
-                export PATH="$ver_dir:$PATH"
-                ./bin/spack-tmpconfig -b ./.github/workflows/bootstrap-test.sh
-                export PATH="$old_path"
-              fi
-            fi
-            # NOTE: test all pythons that exist, not all do on 12
-          done
+          source share/spack/setup-env.sh
+          spack bootstrap untrust spack-install
+          spack -d solve zlib
+          tree ~/.spack/bootstrap/store/
 
   ubuntu-clingo-binaries:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['2.7', '3.5', '3.6', '3.7', '3.8', '3.9']
     steps:
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+      - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+      - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
         with:
-          fetch-depth: 0
-      - name: Setup repo
+          python-version: ${{ matrix.python-version }}
+      - name: Setup repo and non-root user
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap clingo
         run: |
-          set -ex
-          for ver in '3.7' '3.8' '3.9' '3.10' '3.11' ; do
-            not_found=1
-            ver_dir="$(find $RUNNER_TOOL_CACHE/Python -wholename "*/${ver}.*/*/bin" | grep . || true)"
-            echo "Testing $ver_dir"
-            if [[ -d "$ver_dir" ]] ; then
-              if $ver_dir/python --version ; then
-                export PYTHON="$ver_dir/python"
-                not_found=0
-                old_path="$PATH"
-                export PATH="$ver_dir:$PATH"
-                ./bin/spack-tmpconfig -b ./.github/workflows/bootstrap-test.sh
-                export PATH="$old_path"
-              fi
-            fi
-            if (($not_found)) ; then
-              echo Required python version $ver not found in runner!
-              exit 1
-            fi
-          done
+          source share/spack/setup-env.sh
+          spack bootstrap untrust spack-install
+          spack -d solve zlib
+          tree ~/.spack/bootstrap/store/
 
   ubuntu-gnupg-binaries:
     runs-on: ubuntu-latest
@@ -249,27 +202,19 @@ jobs:
           apt-get install -y \
               bzip2 curl file g++ gcc patchelf gfortran git gzip \
               make patch unzip xz-utils python3 python3-dev tree
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-        with:
-          fetch-depth: 0
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
+      - uses: actions/checkout@v2
+      - name: Setup repo and non-root user
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
+          useradd -m spack-test
+          chown -R spack-test .
       - name: Bootstrap GnuPG
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable spack-install
+          spack bootstrap untrust spack-install
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 
@@ -286,28 +231,20 @@ jobs:
               bzip2 curl file g++ gcc patchelf gfortran git gzip \
               make patch unzip xz-utils python3 python3-dev tree \
               gawk
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-        with:
-          fetch-depth: 0
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
+      - uses: actions/checkout@v2
+      - name: Setup repo and non-root user
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
+          useradd -m spack-test
+          chown -R spack-test .
       - name: Bootstrap GnuPG
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
           spack solve zlib
-          spack bootstrap disable github-actions-v0.5
-          spack bootstrap disable github-actions-v0.4
+          spack bootstrap untrust github-actions
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 
@@ -319,13 +256,11 @@ jobs:
           brew install tree
           # Remove GnuPG since we want to bootstrap it
           sudo rm -rf /usr/local/bin/gpg
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+      - uses: actions/checkout@v2
       - name: Bootstrap GnuPG
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable spack-install
+          spack bootstrap untrust spack-install
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 
@@ -337,21 +272,11 @@ jobs:
           brew install gawk tree
           # Remove GnuPG since we want to bootstrap it
           sudo rm -rf /usr/local/bin/gpg
-      - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+      - uses: actions/checkout@v2
       - name: Bootstrap GnuPG
         run: |
           source share/spack/setup-env.sh
           spack solve zlib
-          spack bootstrap disable github-actions-v0.5
-          spack bootstrap disable github-actions-v0.4
+          spack bootstrap untrust github-actions
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
-
-
-# [1] Distros that have patched git to resolve CVE-2022-24765 (e.g. Ubuntu patching v2.25.1)
-#     introduce breaking behaviorso we have to set `safe.directory` in gitconfig ourselves.
-#     See:
-#     - https://github.blog/2022-04-12-git-security-vulnerability-announced/
-#     - https://github.com/actions/checkout/issues/760
-#     - http://changelogs.ubuntu.com/changelogs/pool/main/g/git/git_2.25.1-1ubuntu3.3/changelog

.github/workflows/build-containers.yml

@@ -12,17 +12,10 @@ on:
       - develop
     paths:
       - '.github/workflows/build-containers.yml'
-      - 'share/spack/docker/*'
-      - 'share/spack/templates/container/*'
-      - 'lib/spack/spack/container/*'
   # Let's also build & tag Spack containers on releases.
   release:
     types: [published]
 
-concurrency:
-  group: build_containers-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
 jobs:
   deploy-images:
     runs-on: ubuntu-latest
@@ -35,90 +28,64 @@ jobs:
       # A matrix of Dockerfile paths, associated tags, and which architectures
       # they support.
       matrix:
-        # Meaning of the various items in the matrix list
-        # 0: Container name (e.g. ubuntu-bionic)
-        # 1: Platforms to build for
-        # 2: Base image (e.g. ubuntu:22.04)
-        dockerfile: [[amazon-linux, 'linux/amd64,linux/arm64', 'amazonlinux:2'],
-                     [centos7, 'linux/amd64,linux/arm64,linux/ppc64le', 'centos:7'],
-                     [centos-stream, 'linux/amd64,linux/arm64,linux/ppc64le', 'centos:stream'],
-                     [leap15, 'linux/amd64,linux/arm64,linux/ppc64le', 'opensuse/leap:15'],
-                     [ubuntu-focal, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:20.04'],
-                     [ubuntu-jammy, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:22.04'],
-                     [almalinux8, 'linux/amd64,linux/arm64,linux/ppc64le', 'almalinux:8'],
-                     [almalinux9, 'linux/amd64,linux/arm64,linux/ppc64le', 'almalinux:9'],
-                     [rockylinux8, 'linux/amd64,linux/arm64', 'rockylinux:8'],
-                     [rockylinux9, 'linux/amd64,linux/arm64', 'rockylinux:9'],
-                     [fedora37, 'linux/amd64,linux/arm64,linux/ppc64le', 'fedora:37'],
-                     [fedora38, 'linux/amd64,linux/arm64,linux/ppc64le', 'fedora:38'],
-                     [fedora39, 'linux/amd64,linux/arm64,linux/ppc64le', 'fedora:39'],
-                     [fedora40, 'linux/amd64,linux/arm64,linux/ppc64le', 'fedora:40']]
+        dockerfile: [[amazon-linux, amazonlinux-2.dockerfile, 'linux/amd64,linux/arm64'],
+                     [centos7, centos-7.dockerfile, 'linux/amd64,linux/arm64,linux/ppc64le'],
+                     [leap15, leap-15.dockerfile, 'linux/amd64,linux/arm64,linux/ppc64le'],
+                     [ubuntu-xenial, ubuntu-1604.dockerfile, 'linux/amd64,linux/arm64,linux/ppc64le'],
+                     [ubuntu-bionic, ubuntu-1804.dockerfile, 'linux/amd64,linux/arm64,linux/ppc64le']]
     name: Build ${{ matrix.dockerfile[0] }}
-    if: github.repository == 'spack/spack'
     steps:
       - name: Checkout
-        uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
 
-      - uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81
-        id: docker_meta
-        with:
-          images: |
-              ghcr.io/${{ github.repository_owner }}/${{ matrix.dockerfile[0] }}
-              ${{ github.repository_owner }}/${{ matrix.dockerfile[0] }}
-          tags: |
-              type=schedule,pattern=nightly
-              type=schedule,pattern=develop
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=ref,event=branch
-              type=ref,event=pr
-
-      - name: Generate the Dockerfile
-        env:
-          SPACK_YAML_OS: "${{ matrix.dockerfile[2] }}"
+      - name: Set Container Tag Normal (Nightly)
         run: |
-          .github/workflows/generate_spack_yaml_containerize.sh
-          . share/spack/setup-env.sh
-          mkdir -p dockerfiles/${{ matrix.dockerfile[0] }}
-          spack containerize --last-stage=bootstrap | tee dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile
-          printf "Preparing to build ${{ env.container }} from dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile"
-          if [ ! -f "dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile" ]; then
-              printf "dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile does not exist"
+          container="${{ matrix.dockerfile[0] }}:latest"
+          echo "container=${container}" >> $GITHUB_ENV
+          echo "versioned=${container}" >> $GITHUB_ENV
+
+        # On a new release create a container with the same tag as the release.
+      - name: Set Container Tag on Release
+        if: github.event_name == 'release'
+        run: |
+          versioned="${{matrix.dockerfile[0]}}:${GITHUB_REF##*/}"
+          echo "versioned=${versioned}" >> $GITHUB_ENV
+
+      - name: Check ${{ matrix.dockerfile[1] }} Exists
+        run: |
+          printf "Preparing to build ${{ env.container }} from ${{ matrix.dockerfile[1] }}"
+          if [ ! -f "share/spack/docker/${{ matrix.dockerfile[1]}}" ]; then
+              printf "Dockerfile ${{ matrix.dockerfile[0]}} does not exist"
               exit 1;
           fi
 
-      - name: Upload Dockerfile
-        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32
-        with:
-          name: dockerfiles
-          path: dockerfiles
-
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@68827325e0b33c7199eb31dd4e31fbe9023e06e3
+        uses: docker/setup-qemu-action@27d0a4f181a40b142cce983c5393082c365d1480 # @v1
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@d70bba72b1f3fd22344832f00baa16ece964efeb
+        uses: docker/setup-buildx-action@94ab11c41e45d028884a99163086648e898eed25 # @v1
 
       - name: Log in to GitHub Container Registry
-        uses: docker/login-action@e92390c5fb421da1463c202d546fed0ec5c39f20
+        uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9 # @v1
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Log in to DockerHub
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@e92390c5fb421da1463c202d546fed0ec5c39f20
+        uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9 # @v1
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Build & Deploy ${{ matrix.dockerfile[0] }}
-        uses: docker/build-push-action@2cdde995de11925a030ce8070c3d77a52ffcf1c0
+      - name: Build & Deploy ${{ matrix.dockerfile[1] }}
+        uses: docker/build-push-action@a66e35b9cbcf4ad0ea91ffcaf7bbad63ad9e0229 # @v2
         with:
-          context: dockerfiles/${{ matrix.dockerfile[0] }}
-          platforms: ${{ matrix.dockerfile[1] }}
+          file: share/spack/docker/${{matrix.dockerfile[1]}}
+          platforms: ${{ matrix.dockerfile[2] }}
           push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.docker_meta.outputs.tags }}
-          labels: ${{ steps.docker_meta.outputs.labels }}
+          tags: |
+            spack/${{ env.container }}
+            spack/${{ env.versioned }}
+            ghcr.io/spack/${{ env.container }}
+            ghcr.io/spack/${{ env.versioned }}

.github/workflows/ci.yaml

@@ -1,90 +0,0 @@
-name: ci
-
-on:
-  push:
-    branches:
-      - develop
-      - releases/**
-  pull_request:
-    branches:
-      - develop
-      - releases/**
-
-concurrency:
-  group: ci-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-jobs:
-  prechecks:
-    needs: [ changes ]
-    uses: ./.github/workflows/valid-style.yml
-    secrets: inherit
-    with:
-      with_coverage: ${{ needs.changes.outputs.core }}
-  all-prechecks:
-    needs: [ prechecks ]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Success
-      run: "true"
-  # Check which files have been updated by the PR
-  changes:
-    runs-on: ubuntu-latest
-      # Set job outputs to values from filter step
-    outputs:
-      bootstrap: ${{ steps.filter.outputs.bootstrap }}
-      core: ${{ steps.filter.outputs.core }}
-      packages: ${{ steps.filter.outputs.packages }}
-    steps:
-      - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-        if: ${{ github.event_name == 'push' }}
-        with:
-          fetch-depth: 0
-            # For pull requests it's not necessary to checkout the code
-      - uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36
-        id: filter
-        with:
-          # See https://github.com/dorny/paths-filter/issues/56 for the syntax used below
-          # Don't run if we only modified packages in the
-          # built-in repository or documentation
-          filters: |
-            bootstrap:
-            - 'var/spack/repos/builtin/packages/clingo-bootstrap/**'
-            - 'var/spack/repos/builtin/packages/clingo/**'
-            - 'var/spack/repos/builtin/packages/python/**'
-            - 'var/spack/repos/builtin/packages/re2c/**'
-            - 'lib/spack/**'
-            - 'share/spack/**'
-            - '.github/workflows/bootstrap.yml'
-            - '.github/workflows/ci.yaml'
-            core:
-            - './!(var/**)/**'
-            packages:
-            - 'var/**'
-      # Some links for easier reference:
-      #
-      # "github" context: https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#github-context
-      # job outputs: https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idoutputs
-      # setting environment variables from earlier steps: https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-environment-variable
-      #
-  bootstrap:
-    if: ${{ github.repository == 'spack/spack' && needs.changes.outputs.bootstrap == 'true' }}
-    needs: [ prechecks, changes ]
-    uses: ./.github/workflows/bootstrap.yml
-    secrets: inherit
-  unit-tests:
-    if: ${{ github.repository == 'spack/spack' && needs.changes.outputs.core == 'true' }}
-    needs: [ prechecks, changes ]
-    uses: ./.github/workflows/unit_tests.yaml
-    secrets: inherit
-  windows:
-    if: ${{ github.repository == 'spack/spack' && needs.changes.outputs.core == 'true' }}
-    needs: [ prechecks ]
-    uses: ./.github/workflows/windows_python.yml
-    secrets: inherit
-  all:
-    needs: [ windows, unit-tests, bootstrap ]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Success
-      run: "true"

.github/workflows/execute_installer.ps1

@@ -1,7 +0,0 @@
-$ proc = Start-Process  ${{ env.spack_installer }}\spack.exe "/install /quiet" -Passthru
-$handle = $proc.Handle # cache proc.Handle
-$proc.WaitForExit();
-
-if ($proc.ExitCode -ne 0) {
-    Write-Warning "$_ exited with status code $($proc.ExitCode)"
-}

.github/workflows/generate_spack_yaml_containerize.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-    (echo "spack:" \
-&&   echo "  specs: []" \
-&&   echo "  container:" \
-&&   echo "    format: docker" \
-&&   echo "    images:" \
-&&   echo "      os: \"${SPACK_YAML_OS}\"" \
-&&   echo "      spack:" \
-&&   echo "        ref: ${GITHUB_REF}") > spack.yaml

.github/workflows/install_spack.sh

@@ -2,7 +2,19 @@
 . share/spack/setup-env.sh
 echo -e "config:\n  build_jobs: 2" > etc/spack/config.yaml
 spack config add "packages:all:target:[x86_64]"
-spack compiler find
+# TODO: remove this explicit setting once apple-clang detection is fixed
+cat <<EOF > etc/spack/compilers.yaml
+compilers:
+- compiler:
+    spec: apple-clang@11.0.3
+    paths:
+      cc: /usr/bin/clang
+      cxx: /usr/bin/clang++
+      f77: /usr/local/bin/gfortran-9
+      fc: /usr/local/bin/gfortran-9
+    modules: []
+    operating_system: catalina
+    target: x86_64
+EOF
 spack compiler info apple-clang
 spack debug report
-spack solve zlib

.github/workflows/macos_python.yml

@@ -0,0 +1,64 @@
+# These are nightly package tests for macOS
+# focus areas:
+# - initial user experience
+# - scientific python stack
+name: macOS builds nightly
+
+on:
+  schedule:
+    # nightly at 1 AM
+    - cron: '0 1 * * *'
+  pull_request:
+    branches:
+    - develop
+    paths:
+      # Run if we modify this yaml file
+      - '.github/workflows/macos_python.yml'
+      # TODO: run if we touch any of the recipes involved in this
+
+# GitHub Action Limits
+# https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+
+jobs:
+  install_gcc:
+    name: gcc with clang
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
+      with:
+        python-version: 3.9
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        # 9.2.0 is the latest version on which we apply homebrew patch
+        spack install -v --fail-fast gcc@9.2.0 %apple-clang
+
+  install_jupyter_clang:
+    name: jupyter
+    runs-on: macos-latest
+    timeout-minutes: 700
+    steps:
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
+      with:
+        python-version: 3.9
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        spack install -v --fail-fast py-jupyterlab %apple-clang
+
+  install_scipy_clang:
+    name: scipy, mpl, pd
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
+      with:
+        python-version: 3.9
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        spack install -v --fail-fast py-scipy %apple-clang
+        spack install -v --fail-fast py-matplotlib %apple-clang
+        spack install -v --fail-fast py-pandas %apple-clang

.github/workflows/nightly-win-builds.yml

@@ -1,31 +0,0 @@
-name: Windows Paraview Nightly
-
-on:
-  schedule:
-    - cron: '0 2 * * *' # Run at 2 am
-
-defaults:
-  run:
-    shell:
-     powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}
-
-
-jobs:
-  build-paraview-deps:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip six pywin32 setuptools coverage
-    - name: Build Test
-      run: |
-        spack compiler find
-        spack external find cmake ninja win-sdk win-wdk wgl msmpi
-        spack -d install -y --cdash-upload-url https://cdash.spack.io/submit.php?project=Spack+on+Windows --cdash-track Nightly --only dependencies paraview
-        exit 0

.github/workflows/setup_git.ps1

@@ -1,10 +0,0 @@
-# (c) 2022 Lawrence Livermore National Laboratory
-
-git config --global user.email "spack@example.com"
-git config --global user.name "Test User"
-git config --global core.longpaths true
-
-if ($(git branch --show-current) -ne "develop")
-{
-    git branch develop origin/develop
-}

.github/workflows/style/requirements.txt

@@ -1,7 +0,0 @@
-black==24.4.0
-clingo==5.7.1
-flake8==7.0.0
-isort==5.13.2
-mypy==1.8.0
-types-six==1.16.21.9
-vermin==1.6.0

.github/workflows/system_shortcut_check.ps1

@@ -1,4 +0,0 @@
-param ($systemFolder, $shortcut)
-
-$start = [System.Environment]::GetFolderPath("$systemFolder")
-Invoke-Item "$start\Programs\Spack\$shortcut"

.github/workflows/unit_tests.yaml

@@ -1,60 +1,108 @@
-name: unit tests
+name: linux tests
 
 on:
-  workflow_dispatch:
-  workflow_call:
-
-concurrency:
-  group: unit_tests-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
+  push:
+    branches:
+      - develop
+      - releases/**
+  pull_request:
+    branches:
+      - develop
+      - releases/**
 jobs:
-  # Run unit tests with different configurations on linux
-  ubuntu:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12']
-        concretizer: ['clingo']
-        on_develop:
-        - ${{ github.ref == 'refs/heads/develop' }}
-        include:
-        - python-version: '3.11'
-          os: ubuntu-latest
-          concretizer: original
-          on_develop: ${{ github.ref == 'refs/heads/develop' }}
-        - python-version: '3.6'
-          os: ubuntu-20.04
-          concretizer: clingo
-          on_develop: ${{ github.ref == 'refs/heads/develop' }}
-        exclude:
-        - python-version: '3.7'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.8'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.9'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.10'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.11'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-
+  # Validate that the code can be run on all the Python versions
+  # supported by Spack
+  validate:
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
+      with:
+        python-version: 3.9
+    - name: Install Python Packages
+      run: |
+        pip install --upgrade pip
+        pip install --upgrade vermin
+    - name: vermin (Spack's Core)
+      run: vermin --backport argparse --violations --backport typing -t=2.7- -t=3.5- -vvv lib/spack/spack/ lib/spack/llnl/ bin/
+    - name: vermin (Repositories)
+      run: vermin --backport argparse --violations --backport typing -t=2.7- -t=3.5- -vvv var/spack/repos
+  # Run style checks on the files that have been changed
+  style:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
+      with:
+        python-version: 3.9
+    - name: Install Python packages
+      run: |
+        pip install --upgrade pip six setuptools types-six
+    - name: Setup git configuration
+      run: |
+        # Need this for the git tests to succeed.
+        git --version
+        . .github/workflows/setup_git.sh
+    - name: Run style tests
+      run: |
+          share/spack/qa/run-style-tests
+  # Check which files have been updated by the PR
+  changes:
+    runs-on: ubuntu-latest
+    # Set job outputs to values from filter step
+    outputs:
+      core: ${{ steps.filter.outputs.core }}
+      packages: ${{ steps.filter.outputs.packages }}
+      with_coverage: ${{ steps.coverage.outputs.with_coverage }}
+    steps:
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+      if: ${{ github.event_name == 'push' }}
+      with:
+        fetch-depth: 0
+    # For pull requests it's not necessary to checkout the code
+    - uses: dorny/paths-filter@b2feaf19c27470162a626bd6fa8438ae5b263721
+      id: filter
+      with:
+        # See https://github.com/dorny/paths-filter/issues/56 for the syntax used below
+        filters: |
+          core:
+          - './!(var/**)/**'
+          packages:
+          - 'var/**'
+    # Some links for easier reference:
+    #
+    # "github" context: https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#github-context
+    # job outputs: https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idoutputs
+    # setting environment variables from earlier steps: https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-environment-variable
+    #
+    - id: coverage
+      # Run the subsequent jobs with coverage if core has been modified,
+      # regardless of whether this is a pull request or a push to a branch
+      run: |
+        echo Core changes: ${{ steps.filter.outputs.core }}
+        echo Event name: ${{ github.event_name }}
+        if [ "${{ steps.filter.outputs.core }}" == "true" ]
+        then
+          echo "::set-output name=with_coverage::true"
+        else
+          echo "::set-output name=with_coverage::false"
+        fi
+
+  # Run unit tests with different configurations on linux
+  unittests:
+    needs: [ validate, style, changes ]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [2.7, 3.5, 3.6, 3.7, 3.8, 3.9]
+        concretizer: ['original', 'clingo']
+    steps:
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install System packages
@@ -63,11 +111,15 @@ jobs:
           # Needed for unit tests
           sudo apt-get -y install \
               coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build \
-              cmake bison libbison-dev kcov
+              patchelf cmake bison libbison-dev kcov
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools pytest pytest-xdist pytest-cov
-          pip install --upgrade flake8 "isort>=4.3.5" "mypy>=0.900" "click" "black"
+          pip install --upgrade pip six setuptools pytest codecov coverage[toml]
+          # ensure style checks are not skipped in unit tests for python >= 3.6
+          # note that true/false (i.e., 1/0) are opposite in conditions in python and bash
+          if python -c 'import sys; sys.exit(not sys.version_info >= (3, 6))'; then
+              pip install --upgrade flake8 isort>=4.3.5 mypy>=0.900 black
+          fi
     - name: Setup git configuration
       run: |
           # Need this for the git tests to succeed.
@@ -79,33 +131,41 @@ jobs:
           SPACK_PYTHON: python
       run: |
           . share/spack/setup-env.sh
-          spack bootstrap disable spack-install
-          spack bootstrap now
+          spack bootstrap untrust spack-install
           spack -v solve zlib
-    - name: Run unit tests
+    - name: Run unit tests (full suite with coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       env:
           SPACK_PYTHON: python
-          SPACK_TEST_SOLVER: ${{ matrix.concretizer }}
-          SPACK_TEST_PARALLEL: 2
           COVERAGE: true
-          UNIT_TEST_COVERAGE: ${{ matrix.python-version == '3.11' }}
+          SPACK_TEST_SOLVER: ${{ matrix.concretizer }}
       run: |
           share/spack/qa/run-unit-tests
-    - uses: codecov/codecov-action@84508663e988701840491b86de86b666e8a86bed
+          coverage combine
+          coverage xml
+    - name: Run unit tests (reduced suite without coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'false' }}
+      env:
+          SPACK_PYTHON: python
+          ONLY_PACKAGES: true
+          SPACK_TEST_SOLVER: ${{ matrix.concretizer }}
+      run: |
+          share/spack/qa/run-unit-tests
+    - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       with:
         flags: unittests,linux,${{ matrix.concretizer }}
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true
   # Test shell integration
   shell:
+    needs: [ validate, style, changes ]
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
       with:
-        python-version: '3.11'
+        python-version: 3.9
     - name: Install System packages
       run: |
           sudo apt-get -y update
@@ -113,27 +173,33 @@ jobs:
           sudo apt-get install -y coreutils kcov csh zsh tcsh fish dash bash
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools pytest coverage[toml] pytest-xdist
+          pip install --upgrade pip six setuptools pytest codecov coverage[toml]
     - name: Setup git configuration
       run: |
           # Need this for the git tests to succeed.
           git --version
           . .github/workflows/setup_git.sh
-    - name: Run shell tests
+    - name: Run shell tests (without coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'false' }}
+      run: |
+          share/spack/qa/run-shell-tests
+    - name: Run shell tests (with coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       env:
           COVERAGE: true
       run: |
           share/spack/qa/run-shell-tests
-    - uses: codecov/codecov-action@84508663e988701840491b86de86b666e8a86bed
+    - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       with:
         flags: shelltests,linux
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true
 
   # Test RHEL8 UBI with platform Python. This job is run
   # only on PRs modifying core Spack
   rhel8-platform-python:
+    needs: [ validate, style, changes ]
     runs-on: ubuntu-latest
+    if: ${{ needs.changes.outputs.with_coverage == 'true' }}
     container: registry.access.redhat.com/ubi8/ubi
     steps:
     - name: Install dependencies
@@ -141,11 +207,10 @@ jobs:
           dnf install -y \
               bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
               make patch tcl unzip which xz
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
     - name: Setup repo and non-root user
       run: |
           git --version
-          git config --global --add safe.directory /__w/spack/spack
           git fetch --unshallow
           . .github/workflows/setup_git.sh
           useradd spack-test
@@ -154,77 +219,98 @@ jobs:
       shell: runuser -u spack-test -- bash {0}
       run: |
           source share/spack/setup-env.sh
-          spack -d bootstrap now --dev
+          spack -d solve zlib
           spack unit-test -k 'not cvs and not svn and not hg' -x --verbose
   # Test for the clingo based solver (using clingo-cffi)
   clingo-cffi:
+    needs: [ validate, style, changes ]
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
       with:
-        python-version: '3.11'
+        python-version: 3.9
     - name: Install System packages
       run: |
           sudo apt-get -y update
-          sudo apt-get -y install coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build kcov
+          # Needed for unit tests
+          sudo apt-get -y install \
+              coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build \
+              patchelf kcov
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools pytest coverage[toml] pytest-cov clingo pytest-xdist
-          pip install --upgrade flake8 "isort>=4.3.5" "mypy>=0.900" "click" "black"
+          pip install --upgrade pip six setuptools pytest codecov coverage[toml] clingo
     - name: Setup git configuration
       run: |
           # Need this for the git tests to succeed.
           git --version
           . .github/workflows/setup_git.sh
     - name: Run unit tests (full suite with coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       env:
           COVERAGE: true
           SPACK_TEST_SOLVER: clingo
       run: |
           share/spack/qa/run-unit-tests
-    - uses: codecov/codecov-action@84508663e988701840491b86de86b666e8a86bed
+          coverage combine
+          coverage xml
+    - name: Run unit tests (reduced suite without coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'false' }}
+      env:
+          ONLY_PACKAGES: true
+          SPACK_TEST_SOLVER: clingo
+      run: |
+          share/spack/qa/run-unit-tests
+    - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       with:
         flags: unittests,linux,clingo
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true
   # Run unit tests on MacOS
-  macos:
-    runs-on: ${{ matrix.os }}
+  build:
+    needs: [ validate, style, changes ]
+    runs-on: macos-latest
     strategy:
       matrix:
-        os: [macos-latest, macos-14]
-        python-version: ["3.11"]
+        python-version: [3.8]
     steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
+    - uses: actions/setup-python@dc73133d4da04e56a135ae2246682783cc7c7cb6 # @v2
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools
-          pip install --upgrade pytest coverage[toml] pytest-xdist pytest-cov
+          pip install --upgrade pip six setuptools
+          pip install --upgrade pytest codecov coverage[toml]
     - name: Setup Homebrew packages
       run: |
         brew install dash fish gcc gnupg2 kcov
     - name: Run unit tests
       env:
         SPACK_TEST_SOLVER: clingo
-        SPACK_TEST_PARALLEL: 4
       run: |
         git --version
         . .github/workflows/setup_git.sh
         . share/spack/setup-env.sh
-        $(which spack) bootstrap disable spack-install
+        $(which spack) bootstrap untrust spack-install
         $(which spack) solve zlib
-        common_args=(--dist loadfile --tx '4*popen//python=./bin/spack-tmpconfig python -u ./bin/spack python' -x)
-        $(which spack) unit-test --verbose --cov --cov-config=pyproject.toml --cov-report=xml:coverage.xml "${common_args[@]}"
-    - uses: codecov/codecov-action@84508663e988701840491b86de86b666e8a86bed
+        if [ "${{ needs.changes.outputs.with_coverage }}" == "true" ]
+        then
+          coverage run $(which spack) unit-test -x
+          coverage combine
+          coverage xml
+          # Delete the symlink going from ./lib/spack/docs/_spack_root back to
+          # the initial directory, since it causes ELOOP errors with codecov/actions@2
+          rm lib/spack/docs/_spack_root
+        else
+          echo "ONLY PACKAGE RECIPES CHANGED [skipping coverage]"
+          $(which spack) unit-test -x -m "not maybeslow" -k "package_sanity"
+        fi
+    - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       with:
+        files: ./coverage.xml
         flags: unittests,macos
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true

.github/workflows/valid-style.yml

@@ -1,89 +0,0 @@
-name: style
-
-on:
-  workflow_call:
-    inputs:
-      with_coverage:
-        required: true
-        type: string
-
-concurrency:
-  group: style-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-
-jobs:
-  # Validate that the code can be run on all the Python versions
-  # supported by Spack
-  validate:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
-      with:
-        python-version: '3.11'
-        cache: 'pip'
-    - name: Install Python Packages
-      run: |
-        pip install --upgrade pip setuptools
-        pip install -r .github/workflows/style/requirements.txt
-    - name: vermin (Spack's Core)
-      run: vermin --backport importlib --backport argparse --violations --backport typing -t=3.6- -vvv lib/spack/spack/ lib/spack/llnl/ bin/
-    - name: vermin (Repositories)
-      run: vermin --backport importlib --backport argparse --violations --backport typing -t=3.6- -vvv var/spack/repos
-  # Run style checks on the files that have been changed
-  style:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
-      with:
-        python-version: '3.11'
-        cache: 'pip'
-    - name: Install Python packages
-      run: |
-        pip install --upgrade pip setuptools
-        pip install -r .github/workflows/style/requirements.txt
-    - name: Setup git configuration
-      run: |
-        # Need this for the git tests to succeed.
-        git --version
-        . .github/workflows/setup_git.sh
-    - name: Run style tests
-      run: |
-          share/spack/qa/run-style-tests
-  audit:
-    uses: ./.github/workflows/audit.yaml
-    secrets: inherit
-    with:
-      with_coverage: ${{ inputs.with_coverage }}
-      python_version: '3.11'
-  # Check that spack can bootstrap the development environment on Python 3.6 - RHEL8
-  bootstrap-dev-rhel8:
-    runs-on: ubuntu-latest
-    container: registry.access.redhat.com/ubi8/ubi
-    steps:
-      - name: Install dependencies
-        run: |
-          dnf install -y \
-              bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
-              make patch tcl unzip which xz
-      - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-      - name: Setup repo and non-root user
-        run: |
-          git --version
-          git config --global --add safe.directory /__w/spack/spack
-          git fetch --unshallow
-          . .github/workflows/setup_git.sh
-          useradd spack-test
-          chown -R spack-test .
-      - name: Bootstrap Spack development environment
-        shell: runuser -u spack-test -- bash {0}
-        run: |
-          source share/spack/setup-env.sh
-          spack debug report
-          spack -d bootstrap now --dev
-          spack style -t black
-          spack unit-test -V

.github/workflows/windows_python.yml

@@ -1,83 +0,0 @@
-name: windows
-
-on:
-  workflow_call:
-
-concurrency:
-  group: windows-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell:
-     powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}
-jobs:
-  unit-tests:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip pywin32 setuptools pytest-cov clingo
-    - name: Create local develop
-      run: |
-        ./.github/workflows/setup_git.ps1
-    - name: Unit Test
-      run: |
-        spack unit-test -x --verbose --cov --cov-config=pyproject.toml --ignore=lib/spack/spack/test/cmd
-        ./share/spack/qa/validate_last_exit.ps1
-        coverage combine -a
-        coverage xml
-    - uses: codecov/codecov-action@84508663e988701840491b86de86b666e8a86bed
-      with:
-        flags: unittests,windows
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true
-  unit-tests-cmd:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip pywin32 setuptools coverage pytest-cov clingo
-    - name: Create local develop
-      run: |
-        ./.github/workflows/setup_git.ps1
-    - name: Command Unit Test
-      run: |
-        spack unit-test -x --verbose --cov --cov-config=pyproject.toml lib/spack/spack/test/cmd
-        ./share/spack/qa/validate_last_exit.ps1
-        coverage combine -a
-        coverage xml
-    - uses: codecov/codecov-action@84508663e988701840491b86de86b666e8a86bed
-      with:
-        flags: unittests,windows
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true
-  build-abseil:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip pywin32 setuptools coverage
-    - name: Build Test
-      run: |
-        spack compiler find
-        spack -d external find cmake ninja
-        spack -d install abseil-cpp

.readthedocs.yml

@@ -1,16 +1,10 @@
 version: 2
 
-build:
-  os: "ubuntu-22.04"
-  apt_packages:
-    - graphviz
-  tools:
-    python: "3.11"
-
 sphinx:
   configuration: lib/spack/docs/conf.py
   fail_on_warning: true
 
 python:
+  version: 3.7
   install:
     - requirements: lib/spack/docs/requirements.txt

CITATION.cff

@@ -27,57 +27,12 @@
 # And here's the CITATION.cff format:
 #
 cff-version: 1.2.0
-type: software
 message: "If you are referencing Spack in a publication, please cite the paper below."
-title: "The Spack Package Manager: Bringing Order to HPC Software Chaos"
-abstract: >-
-  Large HPC centers spend considerable time supporting software for thousands of users, but the
-  complexity of HPC software is quickly outpacing the capabilities of existing software management
-  tools. Scientific applications require specific versions of compilers, MPI, and other dependency
-  libraries, so using a single, standard software stack is infeasible. However, managing many
-  configurations is difficult because the configuration space is combinatorial in size. We
-  introduce Spack, a tool used at Lawrence Livermore National Laboratory to manage this complexity.
-  Spack provides a novel, re- cursive specification syntax to invoke parametric builds of packages
-  and dependencies. It allows any number of builds to coexist on the same system, and it ensures
-  that installed packages can find their dependencies, regardless of the environment. We show
-  through real-world use cases that Spack supports diverse and demanding applications, bringing
-  order to HPC software chaos.
 preferred-citation:
-  title: "The Spack Package Manager: Bringing Order to HPC Software Chaos"
   type: conference-paper
-  url: "https://tgamblin.github.io/pubs/spack-sc15.pdf"
+  doi: "10.1145/2807591.2807623"
+  url: "https://github.com/spack/spack"
   authors:
-    - family-names: "Gamblin"
-      given-names: "Todd"
-    - family-names: "LeGendre"
-      given-names: "Matthew"
-    - family-names: "Collette"
-      given-names: "Michael R."
-    - family-names: "Lee"
-      given-names: "Gregory L."
-    - family-names: "Moody"
-      given-names: "Adam"
-    - family-names: "de Supinski"
-      given-names: "Bronis R."
-    - family-names: "Futral"
-      given-names: "Scott"
-  conference:
-    name: "Supercomputing 2015 (SC’15)"
-    city: "Austin"
-    region: "Texas"
-    country: "US"
-    date-start: 2015-11-15
-    date-end: 2015-11-20
-  month: 11
-  year: 2015
-  identifiers:
-    - description: "The concept DOI of the work."
-      type: doi
-      value: 10.1145/2807591.2807623
-    - description: "The DOE Document Release Number of the work"
-      type: other
-      value: "LLNL-CONF-669890"
-authors:
   - family-names: "Gamblin"
     given-names: "Todd"
   - family-names: "LeGendre"
@@ -92,3 +47,12 @@ authors:
     given-names: "Bronis R."
   - family-names: "Futral"
     given-names: "Scott"
+  title: "The Spack Package Manager: Bringing Order to HPC Software Chaos"
+  conference:
+    name: "Supercomputing 2015 (SC’15)"
+    city: "Austin"
+    region: "Texas"
+    country: "USA"
+  month: November 15-20
+  year: 2015
+  notes: LLNL-CONF-669890

COPYRIGHT

@@ -34,22 +34,10 @@ includes the sbang tool directly in bin/sbang. These packages are covered
 by various permissive licenses. A summary listing follows. See the
 license included with each package for full details.
 
-PackageName: altgraph
-PackageHomePage: https://altgraph.readthedocs.io/en/latest/index.html
-PackageLicenseDeclared: MIT
-
 PackageName: argparse
 PackageHomePage: https://pypi.python.org/pypi/argparse
 PackageLicenseDeclared: Python-2.0
 
-PackageName: astunparse
-PackageHomePage: https://github.com/simonpercivall/astunparse
-PackageLicenseDeclared: Python-2.0
-
-PackageName: attrs
-PackageHomePage: https://github.com/python-attrs/attrs
-PackageLicenseDeclared: MIT
-
 PackageName: ctest_log_parser
 PackageHomePage: https://github.com/Kitware/CMake
 PackageLicenseDeclared: BSD-3-Clause
@@ -58,8 +46,8 @@ PackageName: distro
 PackageHomePage: https://pypi.python.org/pypi/distro
 PackageLicenseDeclared: Apache-2.0
 
-PackageName: functools32
-PackageHomePage: https://github.com/MiCHiLU/python-functools32
+PackageName: functools
+PackageHomePage: https://github.com/python/cpython/blob/2.7/Lib/functools.py
 PackageLicenseDeclared: Python-2.0
 
 PackageName: jinja2
@@ -70,10 +58,6 @@ PackageName: jsonschema
 PackageHomePage: https://pypi.python.org/pypi/jsonschema
 PackageLicenseDeclared: MIT
 
-PackageName: macholib
-PackageHomePage: https://macholib.readthedocs.io/en/latest/index.html
-PackageLicenseDeclared: MIT
-
 PackageName: markupsafe
 PackageHomePage: https://pypi.python.org/pypi/MarkupSafe
 PackageLicenseDeclared: BSD-3-Clause
@@ -86,10 +70,6 @@ PackageName: py
 PackageHomePage: https://pypi.python.org/pypi/py
 PackageLicenseDeclared: MIT
 
-PackageName: pyrsistent
-PackageHomePage: http://github.com/tobgu/pyrsistent
-PackageLicenseDeclared: MIT
-
 PackageName: pytest
 PackageHomePage: https://pypi.python.org/pypi/pytest
 PackageLicenseDeclared: MIT
@@ -105,3 +85,11 @@ PackageLicenseDeclared: Apache-2.0 OR MIT
 PackageName: six
 PackageHomePage: https://pypi.python.org/pypi/six
 PackageLicenseDeclared: MIT
+
+PackageName: macholib
+PackageHomePage: https://macholib.readthedocs.io/en/latest/index.html
+PackageLicenseDeclared: MIT
+
+PackageName: altgraph
+PackageHomePage: https://altgraph.readthedocs.io/en/latest/index.html
+PackageLicenseDeclared: MIT

LICENSE-MIT

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2013-2024 LLNS, LLC and other Spack Project Developers.
+Copyright (c) 2013-2020 LLNS, LLC and other Spack Project Developers.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,34 +1,12 @@
-<div align="left">
+# <img src="https://cdn.rawgit.com/spack/spack/develop/share/spack/logo/spack-logo.svg" width="64" valign="middle" alt="Spack"/> Spack
 
-<h2>
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://cdn.rawgit.com/spack/spack/develop/share/spack/logo/spack-logo-white-text.svg" width="250">
-  <source media="(prefers-color-scheme: light)" srcset="https://cdn.rawgit.com/spack/spack/develop/share/spack/logo/spack-logo-text.svg" width="250">
-  <img alt="Spack" src="https://cdn.rawgit.com/spack/spack/develop/share/spack/logo/spack-logo-text.svg" width="250">
-</picture>
-
-<br>
-<br clear="all">
-
-<a href="https://github.com/spack/spack/actions/workflows/ci.yml"><img src="https://github.com/spack/spack/workflows/ci/badge.svg" alt="CI Status"></a>
-<a href="https://github.com/spack/spack/actions/workflows/bootstrapping.yml"><img src="https://github.com/spack/spack/actions/workflows/bootstrap.yml/badge.svg" alt="Bootstrap Status"></a>
-<a href="https://github.com/spack/spack/actions/workflows/build-containers.yml"><img src="https://github.com/spack/spack/actions/workflows/build-containers.yml/badge.svg" alt="Containers Status"></a>
-<a href="https://spack.readthedocs.io"><img src="https://readthedocs.org/projects/spack/badge/?version=latest" alt="Documentation Status"></a>
-<a href="https://codecov.io/gh/spack/spack"><img src="https://codecov.io/gh/spack/spack/branch/develop/graph/badge.svg" alt="Code coverage"/></a>
-<a href="https://slack.spack.io"><img src="https://slack.spack.io/badge.svg" alt="Slack"/></a>
-<a href="https://matrix.to/#/#spack-space:matrix.org"><img src="https://img.shields.io/matrix/spack-space%3Amatrix.org?label=matrix" alt="Matrix"/></a>
-
-</h2>
-
-**[Getting Started] &nbsp; • &nbsp; [Config] &nbsp; • &nbsp; [Community] &nbsp; • &nbsp; [Contributing] &nbsp; • &nbsp; [Packaging Guide]**
-
-[Getting Started]: https://spack.readthedocs.io/en/latest/getting_started.html
-[Config]: https://spack.readthedocs.io/en/latest/configuration.html
-[Community]: #community
-[Contributing]: https://spack.readthedocs.io/en/latest/contribution_guide.html
-[Packaging Guide]: https://spack.readthedocs.io/en/latest/packaging_guide.html
-
-</div>
+[![Unit Tests](https://github.com/spack/spack/workflows/linux%20tests/badge.svg)](https://github.com/spack/spack/actions)
+[![Bootstrapping](https://github.com/spack/spack/actions/workflows/bootstrap.yml/badge.svg)](https://github.com/spack/spack/actions/workflows/bootstrap.yml)
+[![macOS Builds (nightly)](https://github.com/spack/spack/workflows/macOS%20builds%20nightly/badge.svg?branch=develop)](https://github.com/spack/spack/actions?query=workflow%3A%22macOS+builds+nightly%22)
+[![codecov](https://codecov.io/gh/spack/spack/branch/develop/graph/badge.svg)](https://codecov.io/gh/spack/spack)
+[![Containers](https://github.com/spack/spack/actions/workflows/build-containers.yml/badge.svg)](https://github.com/spack/spack/actions/workflows/build-containers.yml)
+[![Read the Docs](https://readthedocs.org/projects/spack/badge/?version=latest)](https://spack.readthedocs.io)
+[![Slack](https://slack.spack.io/badge.svg)](https://slack.spack.io)
 
 Spack is a multi-platform package manager that builds and installs
 multiple versions and configurations of software. It works on Linux,
@@ -84,14 +62,9 @@ Resources:
 
 * **Slack workspace**: [spackpm.slack.com](https://spackpm.slack.com).
   To get an invitation, visit [slack.spack.io](https://slack.spack.io).
-* **Matrix space**: [#spack-space:matrix.org](https://matrix.to/#/#spack-space:matrix.org):
-  [bridged](https://github.com/matrix-org/matrix-appservice-slack#matrix-appservice-slack) to Slack.
-* [**Github Discussions**](https://github.com/spack/spack/discussions):
-  for Q&A and discussions. Note the pinned discussions for announcements.
-* **X**: [@spackpm](https://twitter.com/spackpm). Be sure to
+* **Mailing list**: [groups.google.com/d/forum/spack](https://groups.google.com/d/forum/spack)
+* **Twitter**: [@spackpm](https://twitter.com/spackpm). Be sure to
   `@mention` us!
-* **Mailing list**: [groups.google.com/d/forum/spack](https://groups.google.com/d/forum/spack):
-  only for announcements. Please use other venues for discussions.
 
 Contributing
 ------------------------

SECURITY.md

@@ -2,26 +2,23 @@
 
 ## Supported Versions
 
-We provide security updates for `develop` and for the last two
-stable (`0.x`) release series of Spack. Security updates will be
-made available as patch (`0.x.1`, `0.x.2`, etc.) releases.
-
+We provide security updates for the following releases.
 For more on Spack's release structure, see
 [`README.md`](https://github.com/spack/spack#releases).
 
+
+| Version | Supported          |
+| ------- | ------------------ |
+| develop | :white_check_mark: |
+| 0.16.x  | :white_check_mark: |
+
 ## Reporting a Vulnerability
 
-You can report a vulnerability using GitHub's private reporting
-feature:
+To report a vulnerability or other security
+issue, email maintainers@spack.io.
 
-1. Go to [github.com/spack/spack/security](https://github.com/spack/spack/security).
-2. Click "Report a vulnerability" in the upper right corner of that page.
-3. Fill out the form and submit your draft security advisory.
-
-More details are available in
-[GitHub's docs](https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing/privately-reporting-a-security-vulnerability).
-
-You can expect to hear back about security issues within two days.
-If your security issue is accepted, we will do our best to release
-a fix within a week. If fixing the issue will take longer than
-this, we will discuss timeline options with you.
+You can expect to hear back within two days.
+If your security issue is accepted, we will do
+our best to release a fix within a week. If
+fixing the issue will take longer than this,
+we will discuss timeline options with you.

bin/haspywin.py

@@ -1,19 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import subprocess
-import sys
-
-
-def getpywin():
-    try:
-        import win32con  # noqa: F401
-    except ImportError:
-        print("pyWin32 not installed but is required...\nInstalling via pip:")
-        subprocess.check_call([sys.executable, "-m", "pip", "-q", "install", "--upgrade", "pip"])
-        subprocess.check_call([sys.executable, "-m", "pip", "-q", "install", "pywin32"])
-
-
-if __name__ == "__main__":
-    getpywin()

bin/sbang

@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
 # sbang project developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

bin/spack

@@ -1,7 +1,7 @@
 #!/bin/sh
 # -*- python -*-
 #
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -25,15 +25,19 @@ exit 1
 # Line above is a shell no-op, and ends a python multi-line comment.
 # The code above runs this file with our preferred python interpreter.
 
+from __future__ import print_function
+
 import os
 import os.path
 import sys
 
-min_python3 = (3, 6)
+min_python3 = (3, 5)
 
-if sys.version_info[:2] < min_python3:
+if sys.version_info[:2] < (2, 7) or (
+    sys.version_info[:2] >= (3, 0) and sys.version_info[:2] < min_python3
+):
     v_info = sys.version_info[:3]
-    msg = "Spack requires Python %d.%d or higher " % min_python3
+    msg = "Spack requires Python 2.7 or %d.%d or higher " % min_python3
     msg += "You are running spack with Python %d.%d.%d." % v_info
     sys.exit(msg)
 
@@ -45,8 +49,50 @@ spack_prefix = os.path.dirname(os.path.dirname(spack_file))
 spack_lib_path = os.path.join(spack_prefix, "lib", "spack")
 sys.path.insert(0, spack_lib_path)
 
-from spack_installable.main import main  # noqa: E402
+# Add external libs
+spack_external_libs = os.path.join(spack_lib_path, "external")
+
+if sys.version_info[:2] <= (2, 7):
+    sys.path.insert(0, os.path.join(spack_external_libs, "py2"))
+
+sys.path.insert(0, spack_external_libs)
+
+# Here we delete ruamel.yaml in case it has been already imported from site
+# (see #9206 for a broader description of the issue).
+#
+# Briefly: ruamel.yaml produces a .pth file when installed with pip that
+# makes the site installed package the preferred one, even though sys.path
+# is modified to point to another version of ruamel.yaml.
+if "ruamel.yaml" in sys.modules:
+    del sys.modules["ruamel.yaml"]
+
+if "ruamel" in sys.modules:
+    del sys.modules["ruamel"]
+
+# The following code is here to avoid failures when updating
+# the develop version, due to spurious argparse.pyc files remaining
+# in the libs/spack/external directory, see:
+# https://github.com/spack/spack/pull/25376
+# TODO: Remove in v0.18.0 or later
+try:
+    import argparse
+except ImportError:
+    argparse_pyc = os.path.join(spack_external_libs, 'argparse.pyc')
+    if not os.path.exists(argparse_pyc):
+        raise
+    try:
+        os.remove(argparse_pyc)
+        import argparse  # noqa
+    except Exception:
+        msg = ('The file\n\n\t{0}\n\nis corrupted and cannot be deleted by Spack. '
+               'Either delete it manually or ask some administrator to '
+               'delete it for you.')
+        print(msg.format(argparse_pyc))
+        sys.exit(1)
+
+
+import spack.main  # noqa
 
 # Once we've set up the system path, run the spack main method
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(spack.main.main())

bin/spack-python

@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

bin/spack-tmpconfig

@@ -1,96 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-[[ -n "${TMPCONFIG_DEBUG:=}" ]] && set -x
-DIR="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-mkdir -p "${XDG_RUNTIME_DIR:=/tmp}/spack-tests"
-export TMPDIR="${XDG_RUNTIME_DIR}"
-export TMP_DIR="$(mktemp -d -t spack-test-XXXXX)"
-clean_up() {
-    [[ -n "$TMPCONFIG_DEBUG" ]] && printf "cleaning up: $TMP_DIR\n"
-    rm -rf "$TMP_DIR"
-}
-trap clean_up EXIT
-trap clean_up ERR
-
-[[ -n "$TMPCONFIG_DEBUG" ]] && printf "Redirecting TMP_DIR and spack directories to $TMP_DIR\n"
-
-export BOOTSTRAP="${SPACK_USER_CACHE_PATH:=$HOME/.spack}/bootstrap"
-export SPACK_USER_CACHE_PATH="$TMP_DIR/user_cache"
-mkdir -p "$SPACK_USER_CACHE_PATH"
-
-private_bootstrap="$SPACK_USER_CACHE_PATH/bootstrap"
-use_spack=''
-use_bwrap=''
-# argument handling
-while (($# >= 1)) ; do
-    case "$1" in
-        -b) # privatize bootstrap too, useful for CI but not always cheap
-            shift
-            export BOOTSTRAP="$private_bootstrap"
-            ;;
-        -B) # use specified bootstrap dir
-            export BOOTSTRAP="$2"
-            shift 2
-            ;;
-        -s) # run spack directly with remaining args
-            shift
-            use_spack=1
-            ;;
-        --contain=bwrap)
-            if bwrap --help 2>&1 > /dev/null ; then
-                use_bwrap=1
-            else
-                echo Bubblewrap containment requested, but no bwrap command found
-                exit 1
-            fi
-            shift
-            ;;
-        --)
-            shift
-            break
-            ;;
-        *)
-            break
-            ;;
-    esac
-done
-typeset -a CMD
-if [[ -n "$use_spack" ]] ; then
-    CMD=("$DIR/spack" "$@")
-else
-    CMD=("$@")
-fi
-
-mkdir -p "$BOOTSTRAP"
-
-export SPACK_SYSTEM_CONFIG_PATH="$TMP_DIR/sys_conf"
-export SPACK_USER_CONFIG_PATH="$TMP_DIR/user_conf"
-mkdir -p "$SPACK_USER_CONFIG_PATH"
-cat >"$SPACK_USER_CONFIG_PATH/config.yaml" <<EOF
-config:
-  install_tree:
-    root: $TMP_DIR/install
-  misc_cache: $$user_cache_path/cache
-  source_cache: $$user_cache_path/source
-  environments_root: $TMP_DIR/envs
-EOF
-cat >"$SPACK_USER_CONFIG_PATH/bootstrap.yaml" <<EOF
-bootstrap:
-  root: $BOOTSTRAP
-EOF
-
-if [[ -n "$use_bwrap" ]] ; then
-    CMD=(
-        bwrap
-        --dev-bind / /
-        --ro-bind "$DIR/.." "$DIR/.." # do not touch spack root
-        --ro-bind $HOME/.spack $HOME/.spack # do not touch user config/cache dir
-        --bind "$TMP_DIR" "$TMP_DIR"
-        --bind "$BOOTSTRAP" "$BOOTSTRAP"
-        --die-with-parent
-        "${CMD[@]}"
-    )
-fi
-
-(( ${TMPCONFIG_DEBUG:=0} > 1)) && echo "Running: ${CMD[@]}"
-"${CMD[@]}"

bin/spack.bat

@@ -1,248 +0,0 @@
-:: Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-:: Spack Project Developers. See the top-level COPYRIGHT file for details.
-::
-:: SPDX-License-Identifier: (Apache-2.0 OR MIT)
-::#######################################################################
-::
-:: This file is part of Spack and sets up the spack environment for batch,
-:: This includes environment modules and lmod support,
-:: and it also puts spack in your path. The script also checks that at least
-:: module support exists, and provides suggestions if it doesn't. Source
-:: it like this:
-::
-::    . /path/to/spack/install/spack_cmd.bat
-::
-@echo off
-
-set spack="%SPACK_ROOT%"\bin\spack
-
-::#######################################################################
-:: This is a wrapper around the spack command that forwards calls to
-:: 'spack load' and 'spack unload' to shell functions.  This in turn
-:: allows them to be used to invoke environment modules functions.
-::
-:: 'spack load' is smarter than just 'load' because it converts its
-:: arguments into a unique Spack spec that is then passed to module
-:: commands.  This allows the user to use packages without knowing all
-:: their installation details.
-::
-:: e.g., rather than requiring a full spec for libelf, the user can type:
-::
-::     spack load libelf
-::
-:: This will first find the available libelf module file and use a
-:: matching one.  If there are two versions of libelf, the user would
-:: need to be more specific, e.g.:
-::
-::     spack load libelf@0.8.13
-::
-:: This is very similar to how regular spack commands work and it
-:: avoids the need to come up with a user-friendly naming scheme for
-:: spack module files.
-::#######################################################################
-
-:_sp_shell_wrapper
-set "_sp_flags="
-set "_sp_args="
-set "_sp_subcommand="
-setlocal enabledelayedexpansion
-:: commands have the form '[flags] [subcommand] [args]'
-:: flags will always start with '-', e.g. --help or -V
-:: subcommands will never start with '-'
-:: everything after the subcommand is an arg
-
-
-:process_cl_args
-rem Set first cl argument (denoted by %1) to be processed
-set t=%1
-rem shift moves all cl positional arguments left by one
-rem meaning %2 is now %1, this allows us to iterate over each
-rem argument
-shift
-rem assign next "first" cl argument to cl_args, will be null when
-rem there are now further arguments to process
-set cl_args=%1
-if "!t:~0,1!" == "-" (
-    if defined _sp_subcommand (
-        rem  We already have a subcommand, processing args now
-        if not defined _sp_args (
-            set "_sp_args=!t!"
-        ) else (
-            set "_sp_args=!_sp_args! !t!"
-        )
-    ) else (
-        if not defined _sp_flags (
-            set "_sp_flags=!t!"
-        ) else (
-            set "_sp_flags=!_sp_flags! !t!"
-        )
-    )
-) else if not defined _sp_subcommand (
-    set "_sp_subcommand=!t!"
-) else (
-    if not defined _sp_args (
-        set "_sp_args=!t!"
-    ) else (
-        set "_sp_args=!_sp_args! !t!"
-    )
-)
-
-rem  if this is not nu;ll, we have more tokens to process
-rem  start above process again with remaining unprocessed cl args
-if defined cl_args goto :process_cl_args
-
-
-:: --help, -h and -V flags don't require further output parsing.
-:: If we encounter, execute and exit
-if defined _sp_flags (
-    if NOT "%_sp_flags%"=="%_sp_flags:-h=%" (
-        python "%spack%" %_sp_flags%
-        exit /B 0
-    ) else if NOT "%_sp_flags%"=="%_sp_flags:--help=%" (
-        python "%spack%" %_sp_flags%
-        exit /B 0
-    ) else if NOT "%_sp_flags%"=="%_sp_flags:-V=%" (
-        python "%spack%" %_sp_flags%
-        exit /B 0
-    )
-)
-if not defined _sp_subcommand (
-   if not defined _sp_args (
-      if not defined _sp_flags (
-         python "%spack%" --help
-         exit /B 0
-      )
-   )
-)
-
-
-:: pass parsed variables outside of local scope. Need to do
-:: this because delayedexpansion can only be set by setlocal
-endlocal & (
-    set "_sp_flags=%_sp_flags%"
-    set "_sp_args=%_sp_args%"
-    set "_sp_subcommand=%_sp_subcommand%"
-)
-
-
-:: Filter out some commands. For any others, just run the command.
-if "%_sp_subcommand%" == "cd" (
-    goto :case_cd
-) else if "%_sp_subcommand%" == "env" (
-    goto :case_env
-) else if "%_sp_subcommand%" == "load" (
-    goto :case_load
-) else if "%_sp_subcommand%" == "unload" (
-    goto :case_load
-) else (
-    goto :default_case
-)
-
-::#######################################################################
-
-:case_cd
-:: Check for --help or -h
-:: TODO: This is not exactly the same as setup-env.
-:: In setup-env, '--help' or '-h' must follow the cd
-:: Here, they may be anywhere in the args
-if defined _sp_args (
-    if NOT "%_sp_args%"=="%_sp_args:--help=%" (
-        python "%spack%" cd -h
-        goto :end_switch
-    ) else if NOT "%_sp_args%"=="%_sp_args:-h=%" (
-        python "%spack%" cd -h
-        goto :end_switch
-    )
-)
-
-for /F "tokens=* USEBACKQ" %%F in (
-  `python "%spack%" location %_sp_args%`) do (
-    set "LOC=%%F"
-)
-for %%Z in ("%LOC%") do if EXIST %%~sZ\NUL (cd /d "%LOC%")
-goto :end_switch
-
-:case_env
-:: If no args or args contain --bat or -h/--help: just execute.
-if NOT defined _sp_args (
-    goto :default_case
-)
-
-if NOT "%_sp_args%"=="%_sp_args:--help=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args: -h=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args:--bat=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args:deactivate=%" (
-    for /f "tokens=* USEBACKQ" %%I in (
-        `call python %spack% %_sp_flags% env deactivate --bat %_sp_args:deactivate=%`
-    ) do %%I
-) else if NOT "%_sp_args%"=="%_sp_args:activate=%" (
-    for /f "tokens=* USEBACKQ" %%I in (
-        `python %spack% %_sp_flags% env activate --bat %_sp_args:activate=%`
-    ) do %%I
-) else (
-    goto :default_case
-)
-goto :end_switch
-
-:case_load
-:: If args contain --sh, --csh, or -h/--help: just execute.
-if defined _sp_args (
-    if NOT "%_sp_args%"=="%_sp_args:--help=%" (
-        goto :default_case
-    ) else if NOT "%_sp_args%"=="%_sp_args:-h=%" (
-        goto :default_case
-    ) else if NOT "%_sp_args%"=="%_sp_args:--bat=%" (
-        goto :default_case
-    )
-)
-
-for /f "tokens=* USEBACKQ" %%I in (
-    `python "%spack%" %_sp_flags% %_sp_subcommand% --bat %_sp_args%`) do %%I
-
-goto :end_switch
-
-:case_unload
-goto :case_load
-
-:default_case
-python "%spack%" %_sp_flags% %_sp_subcommand% %_sp_args%
-goto :end_switch
-
-:end_switch
-exit /B %ERRORLEVEL%
-
-
-::########################################################################
-:: Prepends directories to path, if they exist.
-::      pathadd /path/to/dir            # add to PATH
-:: or   pathadd OTHERPATH /path/to/dir  # add to OTHERPATH
-::########################################################################
-
-:_spack_pathadd
-set "_pa_varname=PATH"
-set "_pa_new_path=%~1"
-if NOT "%~2" == "" (
-    set "_pa_varname=%~1"
-    set "_pa_new_path=%~2"
-    )
-set "_pa_oldvalue=%_pa_varname%"
-for %%Z in ("%_pa_new_path%") do if EXIST %%~sZ\NUL (
-    if defined %_pa_oldvalue% (
-        set "_pa_varname=%_pa_new_path%:%_pa_oldvalue%"
-    ) else (
-        set "_pa_varname=%_pa_new_path%"
-    )
-)
-exit /b 0
-
-:: set module system roots
-:_sp_multi_pathadd
-for %%I in (%~2) do (
-    for %%Z in (%_sp_compatible_sys_types%) do (
-        :pathadd "%~1" "%%I\%%Z"
-    )
-)
-exit /B %ERRORLEVEL%

bin/spack.ps1

@@ -1,146 +0,0 @@
-#  Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-#  Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-#  SPDX-License-Identifier: (Apache-2.0 OR MIT)
-# #######################################################################
-
-function Compare-CommonArgs {
-    $CMDArgs = $args[0]
-    # These aruments take precedence and call for no futher parsing of arguments
-    # invoke actual Spack entrypoint with that context and exit after
-    "--help", "-h", "--version", "-V" | ForEach-Object {
-        $arg_opt = $_
-        if(($CMDArgs) -and ([bool]($CMDArgs.Where({$_ -eq $arg_opt})))) {
-            return $true
-        }
-    }
-    return $false
-}
-
-function Read-SpackArgs {
-    $SpackCMD_params = @()
-    $SpackSubCommand = $NULL
-    $SpackSubCommandArgs = @()
-    $args_ = $args[0]
-    $args_ | ForEach-Object {
-        if (!$SpackSubCommand) {
-            if($_.SubString(0,1) -eq "-")
-            {
-                $SpackCMD_params += $_
-            }
-            else{
-                $SpackSubCommand = $_
-            }
-        }
-        else{
-            $SpackSubCommandArgs += $_
-        }
-    }
-    return $SpackCMD_params, $SpackSubCommand, $SpackSubCommandArgs
-}
-
-function Set-SpackEnv {
-    # This method is responsible
-    # for processing the return from $(spack <command>)
-    # which are returned as System.Object[]'s containing
-    # a list of env commands
-    # Invoke-Expression can only handle one command at a time
-    # so we iterate over the list to invoke the env modification
-    # expressions one at a time
-    foreach($envop in $args[0]){
-        Invoke-Expression $envop
-    }
-}
-
-
-function Invoke-SpackCD {
-    if (Compare-CommonArgs $SpackSubCommandArgs) {
-        python "$Env:SPACK_ROOT/bin/spack" cd -h
-    }
-    else {
-        $LOC = $(python "$Env:SPACK_ROOT/bin/spack" location $SpackSubCommandArgs)
-        if (($NULL -ne $LOC)){
-            if ( Test-Path -Path $LOC){
-                Set-Location $LOC
-            }
-            else{
-                exit 1
-            }
-        }
-        else {
-            exit 1
-        }
-    }
-}
-
-function Invoke-SpackEnv {
-    if (Compare-CommonArgs $SpackSubCommandArgs[0]) {
-        python "$Env:SPACK_ROOT/bin/spack" env -h
-    }
-    else {
-        $SubCommandSubCommand = $SpackSubCommandArgs[0]
-        $SubCommandSubCommandArgs = $SpackSubCommandArgs[1..$SpackSubCommandArgs.Count]
-        switch ($SubCommandSubCommand) {
-            "activate" {
-                if (Compare-CommonArgs $SubCommandSubCommandArgs) {
-                    python "$Env:SPACK_ROOT/bin/spack" env activate $SubCommandSubCommandArgs
-                }
-                elseif ([bool]($SubCommandSubCommandArgs.Where({$_ -eq "--pwsh"}))) {
-                    python "$Env:SPACK_ROOT/bin/spack" env activate $SubCommandSubCommandArgs
-                }
-                elseif (!$SubCommandSubCommandArgs) {
-                    python "$Env:SPACK_ROOT/bin/spack" env activate $SubCommandSubCommandArgs
-                }
-                else {
-                    $SpackEnv = $(python "$Env:SPACK_ROOT/bin/spack" $SpackCMD_params env activate "--pwsh" $SubCommandSubCommandArgs)
-                    Set-SpackEnv $SpackEnv
-                }
-            }
-            "deactivate" {
-                if ([bool]($SubCommandSubCommandArgs.Where({$_ -eq "--pwsh"}))) {
-                    python"$Env:SPACK_ROOT/bin/spack" env deactivate $SubCommandSubCommandArgs
-                }
-                elseif($SubCommandSubCommandArgs) {
-                    python "$Env:SPACK_ROOT/bin/spack" env deactivate -h
-                }
-                else {
-                    $SpackEnv = $(python "$Env:SPACK_ROOT/bin/spack" $SpackCMD_params env deactivate "--pwsh")
-                    Set-SpackEnv $SpackEnv
-                }
-            }
-            default {python "$Env:SPACK_ROOT/bin/spack" $SpackCMD_params $SpackSubCommand $SpackSubCommandArgs}
-        }
-    }
-}
-
-function Invoke-SpackLoad {
-    if (Compare-CommonArgs $SpackSubCommandArgs) {
-        python "$Env:SPACK_ROOT/bin/spack" $SpackCMD_params $SpackSubCommand $SpackSubCommandArgs
-    }
-    elseif ([bool]($SpackSubCommandArgs.Where({($_ -eq "--pwsh") -or ($_ -eq "--list")}))) {
-        python "$Env:SPACK_ROOT/bin/spack" $SpackCMD_params $SpackSubCommand $SpackSubCommandArgs
-    }
-    else {
-        $SpackEnv = $(python "$Env:SPACK_ROOT/bin/spack" $SpackCMD_params $SpackSubCommand "--pwsh" $SpackSubCommandArgs)
-        Set-SpackEnv $SpackEnv
-    }
-}
-
-
-$SpackCMD_params, $SpackSubCommand, $SpackSubCommandArgs = Read-SpackArgs $args
-
-if (Compare-CommonArgs $SpackCMD_params) {
-    python "$Env:SPACK_ROOT/bin/spack" $SpackCMD_params $SpackSubCommand $SpackSubCommandArgs
-    exit $LASTEXITCODE
-}
-
-# Process Spack commands with special conditions
-# all other commands are piped directly to Spack
-switch($SpackSubCommand)
-{
-    "cd"     {Invoke-SpackCD}
-    "env"    {Invoke-SpackEnv}
-    "load"   {Invoke-SpackLoad}
-    "unload" {Invoke-SpackLoad}
-    default  {python "$Env:SPACK_ROOT/bin/spack" $SpackCMD_params $SpackSubCommand $SpackSubCommandArgs}
-}

bin/spack_cmd.bat

@@ -1,71 +0,0 @@
-@ECHO OFF
-setlocal EnableDelayedExpansion
-:: (c) 2021 Lawrence Livermore National Laboratory
-:: To use this file independently of Spack's installer, execute this script in its directory, or add the
-:: associated bin directory to your PATH. Invoke to launch Spack Shell.
-::
-:: source_dir/spack/bin/spack_cmd.bat
-::
-pushd %~dp0..
-set SPACK_ROOT=%CD%
-pushd %CD%\..
-set spackinstdir=%CD%
-popd
-
-
-:: Check if Python is on the PATH
-if not defined python_pf_ver (
-(for /f "delims=" %%F in ('where python.exe') do (
-                                                    set "python_pf_ver=%%F"
-                                                    goto :found_python
-                                                  ) ) 2> NUL
-)
-:found_python
-if not defined python_pf_ver (
-    :: If not, look for Python from the Spack installer
-    :get_builtin
-    (for /f "tokens=*" %%g in ('dir /b /a:d "!spackinstdir!\Python*"') do (
-        set "python_ver=%%g")) 2> NUL
-
-    if not defined python_ver (
-        echo Python was not found on your system.
-        echo Please install Python or add Python to your PATH.
-    ) else (
-        set "py_path=!spackinstdir!\!python_ver!"
-        set "py_exe=!py_path!\python.exe"
-    )
-    goto :exitpoint
-) else (
-    :: Python is already on the path
-    set "py_exe=!python_pf_ver!"
-    (for /F "tokens=* USEBACKQ" %%F in (
-        `"!py_exe!" --version`) do (set "output=%%F")) 2>NUL
-    if not "!output:Microsoft Store=!"=="!output!" goto :get_builtin
-    goto :exitpoint
-)
-:exitpoint
-
-set "PATH=%SPACK_ROOT%\bin\;%PATH%"
-if defined py_path (
-    set "PATH=%py_path%;%PATH%"
-)
-
-if defined py_exe (
-    "%py_exe%" "%SPACK_ROOT%\bin\haspywin.py"
-)
-
-set "EDITOR=notepad"
-
-DOSKEY spacktivate=spack env activate $*
-
-@echo **********************************************************************
-@echo ** Spack Package Manager
-@echo **********************************************************************
-
-IF "%1"=="" GOTO CONTINUE
-set
-GOTO:EOF
-
-:continue
-set PROMPT=[spack] %PROMPT%
-%comspec% /k

bin/spack_pwsh.ps1

@@ -1,10 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-$Env:SPACK_PS1_PATH="$PSScriptRoot\..\share\spack\setup-env.ps1"
-& (Get-Process -Id $pid).Path -NoExit {
-     . $Env:SPACK_PS1_PATH ; 
-    Push-Location $ENV:SPACK_ROOT
- }

etc/spack/defaults/bootstrap.yaml

@@ -6,18 +6,27 @@ bootstrap:
   # by Spack is installed in a "store" subfolder of this root directory
   root: $user_cache_path/bootstrap
   # Methods that can be used to bootstrap software. Each method may or
-  # may not be able to bootstrap all the software that Spack needs,
+  # may not be able to bootstrap all of the software that Spack needs,
   # depending on its type.
   sources:
-  - name: 'github-actions-v0.5'
-    metadata: $spack/share/spack/bootstrap/github-actions-v0.5
-  - name: 'github-actions-v0.4'
-    metadata: $spack/share/spack/bootstrap/github-actions-v0.4
-  - name: 'spack-install'
-    metadata: $spack/share/spack/bootstrap/spack-install
+  - name: 'github-actions'
+    type: buildcache
+    description: |
+      Buildcache generated from a public workflow using Github Actions.
+      The sha256 checksum of binaries is checked before installation.
+    info:
+      url: https://mirror.spack.io/bootstrap/github-actions/v0.1
+      homepage: https://github.com/alalazo/spack-bootstrap-mirrors
+      releases: https://github.com/alalazo/spack-bootstrap-mirrors/releases
+  # This method is just Spack bootstrapping the software it needs from sources.
+  # It has been added here so that users can selectively disable bootstrapping
+  # from sources by "untrusting" it.
+  - name: spack-install
+    type: install
+    description: |
+      Specs built from sources by Spack. May take a long time.
   trusted:
     # By default we trust bootstrapping from sources and from binaries
     # produced on Github via the workflow
-    github-actions-v0.5: true
-    github-actions-v0.4: true
+    github-actions: true
     spack-install: true

etc/spack/defaults/concretizer.yaml

@@ -1,49 +0,0 @@
-# -------------------------------------------------------------------------
-# This is the default spack configuration file.
-#
-# Settings here are versioned with Spack and are intended to provide
-# sensible defaults out of the box. Spack maintainers should edit this
-# file to keep it current.
-#
-# Users can override these settings by editing
-# `$SPACK_ROOT/etc/spack/concretizer.yaml`, `~/.spack/concretizer.yaml`,
-# or by adding a `concretizer:` section to an environment.
-# -------------------------------------------------------------------------
-concretizer:
-  # Whether to consider installed packages or packages from buildcaches when
-  # concretizing specs. If `true`, we'll try to use as many installs/binaries
-  # as possible, rather than building. If `false`, we'll always give you a fresh
-  # concretization. If `dependencies`, we'll only reuse dependencies but
-  # give you a fresh concretization for your root specs.
-  reuse: true
-  # Options that tune which targets are considered for concretization. The
-  # concretization process is very sensitive to the number targets, and the time
-  # needed to reach a solution increases noticeably with the number of targets
-  # considered.
-  targets:
-    # Determine whether we want to target specific or generic
-    # microarchitectures. Valid values are: "microarchitectures" or "generic".
-    # An example of "microarchitectures" would be "skylake" or "bulldozer",
-    # while an example of "generic" would be "aarch64" or "x86_64_v4".
-    granularity: microarchitectures
-    # If "false" allow targets that are incompatible with the current host (for
-    # instance concretize with target "icelake" while running on "haswell").
-    # If "true" only allow targets that are compatible with the host.
-    host_compatible: true
-  # When "true" concretize root specs of environments together, so that each unique
-  # package in an environment corresponds to one concrete spec. This ensures
-  # environments can always be activated. When "false" perform concretization separately
-  # on each root spec, allowing different versions and variants of the same package in
-  # an environment.
-  unify: true
-  # Option to deal with possible duplicate nodes (i.e. different nodes from the same package) in the DAG.
-  duplicates:
-    # "none": allows a single node for any package in the DAG.
-    # "minimal": allows the duplication of 'build-tools' nodes only (e.g. py-setuptools, cmake etc.)
-    # "full" (experimental): allows separation of the entire build-tool stack (e.g. the entire "cmake" subDAG)
-    strategy: minimal
-  # Option to specify compatiblity between operating systems for reuse of compilers and packages
-  # Specified as a key: [list] where the key is the os that is being targeted, and the list contains the OS's 
-  # it can reuse. Note this is a directional compatibility so mutual compatibility between two OS's 
-  # requires two entries i.e. os_compatible: {sonoma: [monterey], monterey: [sonoma]}
-  os_compatible: {}

etc/spack/defaults/config.yaml

@@ -19,7 +19,7 @@ config:
   install_tree:
     root: $spack/opt/spack
     projections:
-      all: "{architecture}/{compiler.name}-{compiler.version}/{name}-{version}-{hash}"
+      all: "${ARCHITECTURE}/${COMPILERNAME}-${COMPILERVER}/${PACKAGE}-${VERSION}-${HASH}"
     # install_tree can include an optional padded length (int or boolean)
     # default is False (do not pad)
     # if padded_length is True, Spack will pad as close to the system max path
@@ -33,9 +33,6 @@ config:
   template_dirs:
     - $spack/share/spack/templates
 
-  # Directory where licenses should be located
-  license_dir: $spack/etc/spack/licenses
-
   # Temporary locations Spack can try to use for builds.
   #
   # Recommended options are given below.
@@ -54,11 +51,6 @@ config:
   # are that it precludes its use as a system package and its ability to be
   # pip installable.
   #
-  # In Spack environment files, chaining onto existing system Spack
-  # installations, the $env variable can be used to download, cache and build
-  # into user-writable paths that are relative to the currently active
-  # environment.
-  #
   # In any case, if the username is not already in the path, Spack will append
   # the value of `$user` in an attempt to avoid potential conflicts between
   # users in shared temporary spaces.
@@ -81,10 +73,6 @@ config:
   source_cache: $spack/var/spack/cache
 
 
-  ## Directory where spack managed environments are created and stored
-  # environments_root: $spack/var/spack/environments
-
-
   # Cache directory for miscellaneous files, like the package index.
   # This can be purged with `spack clean --misc-cache`
   misc_cache: $user_cache_path/cache
@@ -101,12 +89,6 @@ config:
   verify_ssl: true
 
 
-  # This is where custom certs for proxy/firewall are stored.
-  # It can be a path or environment variable. To match ssl env configuration
-  # the default is the environment variable SSL_CERT_FILE
-  ssl_certs: $SSL_CERT_FILE
-
-
   # Suppress gpg warnings from binary package verification
   # Only suppresses warnings, gpg failure will still fail the install
   # Potential rationale to set True: users have already explicitly trusted the
@@ -173,17 +155,14 @@ config:
 
   # The concretization algorithm to use in Spack. Options are:
   #
+  #   'original': Spack's original greedy, fixed-point concretizer. This
+  #       algorithm can make decisions too early and will not backtrack
+  #       sufficiently for many specs.
+  #
   #   'clingo': Uses a logic solver under the hood to solve DAGs with full
   #       backtracking and optimization for user preferences. Spack will
   #       try to bootstrap the logic solver, if not already available.
   #
-  #   'original': Spack's original greedy, fixed-point concretizer. This
-  #       algorithm can make decisions too early and will not backtrack
-  #       sufficiently for many specs. This will soon be deprecated in
-  #       favor of clingo.
-  #
-  # See `concretizer.yaml` for more settings you can fine-tune when
-  # using clingo.
   concretizer: clingo
 
 
@@ -191,7 +170,7 @@ config:
   # when Spack needs to manage its own package metadata and all operations are
   # expected to complete within the default time limit. The timeout should
   # therefore generally be left untouched.
-  db_lock_timeout: 60
+  db_lock_timeout: 3
 
 
   # How long to wait when attempting to modify a package (e.g. to install it).
@@ -202,44 +181,17 @@ config:
   package_lock_timeout: null
 
 
-  # Control how shared libraries are located at runtime on Linux. See the
-  # the Spack documentation for details.
-  shared_linking:
-    # Spack automatically embeds runtime search paths in ELF binaries for their
-    # dependencies. Their type can either be "rpath" or "runpath". For glibc, rpath is
-    # inherited and has precedence over LD_LIBRARY_PATH; runpath is not inherited
-    # and of lower precedence. DO NOT MIX these within the same install tree.
-    type: rpath
-
-
-    # (Experimental) Embed absolute paths of dependent libraries directly in ELF
-    # binaries to avoid runtime search. This can improve startup time of
-    # executables with many dependencies, in particular on slow filesystems.
-    bind: false
+  # Control whether Spack embeds RPATH or RUNPATH attributes in ELF binaries.
+  # Has no effect on macOS. DO NOT MIX these within the same install tree.
+  # See the Spack documentation for details.
+  shared_linking: 'rpath'
 
 
   # Set to 'false' to allow installation on filesystems that doesn't allow setgid bit
   # manipulation by unprivileged user (e.g. AFS)
   allow_sgid: true
 
-  # Whether to show status information during building and installing packages.
-  # This gives information about Spack's current progress as well as the current
-  # and total number of packages. Information is shown both in the terminal
-  # title and inline.
-  install_status: true
-
-  # Number of seconds a buildcache's index.json is cached locally before probing
-  # for updates, within a single Spack invocation. Defaults to 10 minutes.
-  binary_index_ttl: 600
-
-  flags:
-    # Whether to keep -Werror flags active in package builds.
-    keep_werror: 'none'
-
-  # A mapping of aliases that can be used to define new commands. For instance,
-  # `sp: spec -I` will define a new command `sp` that will execute `spec` with
-  # the `-I` argument. Aliases cannot override existing commands.
-  aliases:
-    concretise: concretize
-    containerise: containerize
-    rm: remove
+  # Whether to set the terminal title to display status information during
+  # building and installing packages. This gives information about Spack's
+  # current progress as well as the current and total number of packages.
+  terminal_title: false

etc/spack/defaults/cray/modules.yaml

@@ -13,4 +13,9 @@
 # Per-user settings (overrides default and site settings):
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
-modules: {}
+modules:
+  prefix_inspections:
+    lib:
+      - LD_LIBRARY_PATH
+    lib64:
+      - LD_LIBRARY_PATH

etc/spack/defaults/darwin/modules.yaml

@@ -15,7 +15,7 @@
 # -------------------------------------------------------------------------
 modules:
   prefix_inspections:
-    ./lib:
+    lib:
       - DYLD_FALLBACK_LIBRARY_PATH
-    ./lib64:
+    lib64:
       - DYLD_FALLBACK_LIBRARY_PATH

etc/spack/defaults/darwin/packages.yaml

@@ -19,23 +19,12 @@ packages:
     - apple-clang
     - clang
     - gcc
+    - intel
     providers:
       elf: [libelf]
       fuse: [macfuse]
-      gl: [apple-gl]
-      glu: [apple-glu]
       unwind: [apple-libunwind]
       uuid: [apple-libuuid]
-  apple-gl:
-    buildable: false
-    externals:
-    - spec: apple-gl@4.1.0
-      prefix: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
-  apple-glu:
-    buildable: false
-    externals:
-    - spec: apple-glu@1.3.0
-      prefix: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
   apple-libunwind:
     buildable: false
     externals:
@@ -49,4 +38,4 @@ packages:
     # Apple bundles libuuid in libsystem_c version 1353.100.2,
     # although the version number used here isn't critical
     - spec: apple-libuuid@1353.100.2
-      prefix: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
+      prefix: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk

etc/spack/defaults/linux/modules.yaml

@@ -13,4 +13,9 @@
 # Per-user settings (overrides default and site settings):
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
-modules: {}
+modules:
+  prefix_inspections:
+    lib:
+      - LD_LIBRARY_PATH
+    lib64:
+      - LD_LIBRARY_PATH

etc/spack/defaults/mirrors.yaml

@@ -1,4 +1,2 @@
 mirrors:
-  spack-public:
-    binary: false
-    url: https://mirror.spack.io
+  spack-public: https://mirror.spack.io

etc/spack/defaults/modules.yaml

@@ -14,42 +14,39 @@
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
 modules:
-  # This maps paths in the package install prefix to environment variables
-  # they should be added to. For example, <prefix>/bin should be in PATH.
+  # Paths to check when creating modules for all module sets
   prefix_inspections:
-    ./bin:
+    bin:
       - PATH
-    ./man:
+    man:
       - MANPATH
-    ./share/man:
+    share/man:
       - MANPATH
-    ./share/aclocal:
+    share/aclocal:
       - ACLOCAL_PATH
-    ./lib/pkgconfig:
+    lib/pkgconfig:
       - PKG_CONFIG_PATH
-    ./lib64/pkgconfig:
+    lib64/pkgconfig:
       - PKG_CONFIG_PATH
-    ./share/pkgconfig:
+    share/pkgconfig:
       - PKG_CONFIG_PATH
-    ./:
+    '':
       - CMAKE_PREFIX_PATH
 
   # These are configurations for the module set named "default"
   default:
+    # These values are defaulted in the code. They are not defaulted here so
+    # that we can enable backwards compatibility with the old syntax more
+    # easily (old value is in the config yaml, config:module_roots)
     # Where to install modules
-    roots:
-     tcl:    $spack/share/spack/modules
-     lmod:   $spack/share/spack/lmod
-    # What type of modules to use ("tcl" and/or "lmod")
-    enable: []
-
-    tcl:
-      all:
-        autoload: direct
+    # roots:
+    #  tcl:    $spack/share/spack/modules
+    #  lmod:   $spack/share/spack/lmod
+    # What type of modules to use
+    enable:
+      - tcl
 
     # Default configurations if lmod is enabled
     lmod:
-      all:
-        autoload: direct
       hierarchy:
         - mpi

etc/spack/defaults/packages.yaml

@@ -15,45 +15,37 @@
 # -------------------------------------------------------------------------
 packages:
   all:
-    compiler: [gcc, clang, oneapi, xl, nag, fj, aocc]
+    compiler: [gcc, intel, pgi, clang, xl, nag, fj, aocc]
     providers:
       awk: [gawk]
       blas: [openblas, amdblis]
       D: [ldc]
-      daal: [intel-oneapi-daal]
+      daal: [intel-daal]
       elf: [elfutils]
       fftw-api: [fftw, amdfftw]
       flame: [libflame, amdlibflame]
-      fortran-rt: [gcc-runtime, intel-oneapi-runtime]
       fuse: [libfuse]
-      gl: [glx, osmesa]
+      gl: [mesa+opengl, mesa18, opengl]
       glu: [mesa-glu, openglu]
-      golang: [go, gcc]
-      go-or-gccgo-bootstrap: [go-bootstrap, gcc]
+      glx: [mesa+glx, mesa18+glx, opengl]
+      golang: [gcc]
       iconv: [libiconv]
-      ipp: [intel-oneapi-ipp]
+      ipp: [intel-ipp]
       java: [openjdk, jdk, ibm-java]
       jpeg: [libjpeg-turbo, libjpeg]
       lapack: [openblas, amdlibflame]
-      libc: [glibc, musl]
-      libgfortran: [ gcc-runtime ]
-      libglx: [mesa+glx, mesa18+glx]
-      libifcore: [ intel-oneapi-runtime ]
-      libllvm: [llvm]
-      libosmesa: [mesa+osmesa, mesa18+osmesa]
-      lua-lang: [lua, lua-luajit-openresty, lua-luajit]
-      luajit: [lua-luajit-openresty, lua-luajit]
+      lua-lang: [lua, lua-luajit]
       mariadb-client: [mariadb-c-client, mariadb]
-      mkl: [intel-oneapi-mkl]
+      mkl: [intel-mkl]
       mpe: [mpe2]
       mpi: [openmpi, mpich]
       mysql-client: [mysql, mariadb-c-client]
       opencl: [pocl]
       onedal: [intel-oneapi-dal]
+      osmesa: [mesa+osmesa, mesa18+osmesa]
       pbs: [openpbs, torque]
       pil: [py-pillow]
       pkgconfig: [pkgconf, pkg-config]
-      qmake: [qt-base, qt]
       rpc: [libtirpc]
       scalapack: [netlib-scalapack, amdscalapack]
       sycl: [hipsycl]
@@ -64,7 +56,6 @@ packages:
       xxd: [xxd-standalone, vim]
       yacc: [bison, byacc]
       ziglang: [zig]
-      zlib-api: [zlib-ng+compat, zlib]
     permissions:
       read: world
       write: user

etc/spack/defaults/windows/config.yaml

@@ -1,6 +0,0 @@
-config:
-  locks: false
-  concretizer: clingo
-  build_stage::
-    - '$spack/.staging'
-  stage_name: '{name}-{version}-{hash:7}'

etc/spack/defaults/windows/packages.yaml

@@ -1,22 +0,0 @@
-# -------------------------------------------------------------------------
-# This file controls default concretization preferences for Spack.
-#
-# Settings here are versioned with Spack and are intended to provide
-# sensible defaults out of the box. Spack maintainers should edit this
-# file to keep it current.
-#
-# Users can override these settings by editing the following files.
-#
-# Per-spack-instance settings (overrides defaults):
-#   $SPACK_ROOT/etc/spack/packages.yaml
-#
-# Per-user settings (overrides default and site settings):
-#   ~/.spack/packages.yaml
-# -------------------------------------------------------------------------
-packages:
-  all:
-    compiler:
-    - msvc
-    providers:
-      mpi: [msmpi]
-      gl: [wgl]

lib/spack/docs/.gitignore

@@ -1,7 +1,7 @@
+package_list.html
 command_index.rst
 spack*.rst
 llnl*.rst
 _build
 .spack-env
 spack.lock
-_spack_root

lib/spack/docs/_pygments/style.py

@@ -1,16 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-# The name of the Pygments (syntax highlighting) style to use.
-# We use our own extension of the default style with a few modifications
-from pygments.styles.default import DefaultStyle
-from pygments.token import Generic
-
-
-class SpackStyle(DefaultStyle):
-    styles = DefaultStyle.styles.copy()
-    background_color = "#f4f4f8"
-    styles[Generic.Output] = "#355"
-    styles[Generic.Prompt] = "bold #346ec9"

lib/spack/docs/_spack_root

@@ -0,0 +1 @@
+../../..

lib/spack/docs/analyze.rst

@@ -0,0 +1,162 @@
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
+   Spack Project Developers. See the top-level COPYRIGHT file for details.
+
+   SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+.. _analyze:
+
+=======
+Analyze
+=======
+
+
+The analyze command is a front-end to various tools that let us analyze
+package installations. Each analyzer is a module for a different kind
+of analysis that can be done on a package installation, including (but not
+limited to) binary, log, or text analysis. Thus, the analyze command group
+allows you to take an existing package install, choose an analyzer,
+and extract some output for the package using it.
+
+
+-----------------
+Analyzer Metadata
+-----------------
+
+For all analyzers, we write to an ``analyzers`` folder in ``~/.spack``, or the
+value that you specify in your spack config at ``config:analyzers_dir``. 
+For example, here we see the results of running an analysis on zlib:
+
+.. code-block:: console
+
+    $ tree ~/.spack/analyzers/
+    └── linux-ubuntu20.04-skylake
+        └── gcc-9.3.0
+            └── zlib-1.2.11-sl7m27mzkbejtkrajigj3a3m37ygv4u2
+                ├── environment_variables
+                │   └── spack-analyzer-environment-variables.json
+                ├── install_files
+                │   └── spack-analyzer-install-files.json
+                └── libabigail
+                    └── spack-analyzer-libabigail-libz.so.1.2.11.xml
+    
+
+This means that you can always find analyzer output in this folder, and it
+is organized with the same logic as the package install it was run for. 
+If you want to customize this top level folder, simply provide the ``--path``
+argument to ``spack analyze run``. The nested organization will be maintained
+within your custom root.
+
+-----------------
+Listing Analyzers
+-----------------
+
+If you aren't familiar with Spack's analyzers, you can quickly list those that 
+are available:
+
+.. code-block:: console
+
+    $ spack analyze list-analyzers
+    install_files            : install file listing read from install_manifest.json
+    environment_variables    : environment variables parsed from spack-build-env.txt
+    config_args              : config args loaded from spack-configure-args.txt
+    abigail                  : Application Binary Interface (ABI) features for objects
+
+
+In the above, the first three are fairly simple - parsing metadata files from
+a package install directory to save
+
+-------------------
+Analyzing a Package
+-------------------
+
+The analyze command, akin to install, will accept a package spec to perform
+an analysis for. The package must be installed. Let's walk through an example
+with zlib. We first ask to analyze it. However, since we have more than one
+install, we are asked to disambiguate:
+
+.. code-block:: console
+
+    $ spack analyze run zlib
+    ==> Error: zlib matches multiple packages.
+      Matching packages:
+        fz2bs56 zlib@1.2.11%gcc@7.5.0 arch=linux-ubuntu18.04-skylake
+        sl7m27m zlib@1.2.11%gcc@9.3.0 arch=linux-ubuntu20.04-skylake
+      Use a more specific spec.
+
+
+We can then specify the spec version that we want to analyze:
+
+.. code-block:: console
+
+    $ spack analyze run zlib/fz2bs56
+
+If you don't provide any specific analyzer names, by default all analyzers 
+(shown in the ``list-analyzers`` subcommand list) will be run. If an analyzer does not
+have any result, it will be skipped. For example, here is a result running for
+zlib:
+
+.. code-block:: console
+
+    $ ls ~/.spack/analyzers/linux-ubuntu20.04-skylake/gcc-9.3.0/zlib-1.2.11-sl7m27mzkbejtkrajigj3a3m37ygv4u2/
+    spack-analyzer-environment-variables.json
+    spack-analyzer-install-files.json
+    spack-analyzer-libabigail-libz.so.1.2.11.xml
+
+If you want to run a specific analyzer, ask for it with `--analyzer`. Here we run
+spack analyze on libabigail (already installed) _using_ libabigail1
+
+.. code-block:: console
+
+    $ spack analyze run --analyzer abigail libabigail
+
+
+.. _analyze_monitoring:
+
+----------------------
+Monitoring An Analysis
+----------------------
+
+For any kind of analysis, you can
+use a `spack monitor <https://github.com/spack/spack-monitor>`_ "Spackmon"
+as a server to upload the same run metadata to. You can
+follow the instructions in the `spack monitor documentation <https://spack-monitor.readthedocs.org>`_
+to first create a server along with a username and token for yourself.
+You can then use this guide to interact with the server.
+
+You should first export our spack monitor token and username to the environment:
+
+.. code-block:: console
+ 
+    $ export SPACKMON_TOKEN=50445263afd8f67e59bd79bff597836ee6c05438
+    $ export SPACKMON_USER=spacky
+
+
+By default, the host for your server is expected to be at ``http://127.0.0.1``
+with a prefix of ``ms1``, and if this is the case, you can simply add the
+``--monitor`` flag to the install command:
+
+.. code-block:: console
+
+    $ spack analyze run --monitor wget
+
+If you need to customize the host or the prefix, you can do that as well:
+
+.. code-block:: console
+
+    $ spack analyze run --monitor --monitor-prefix monitor --monitor-host https://monitor-service.io wget
+
+If your server doesn't have authentication, you can skip it:
+
+.. code-block:: console
+
+    $ spack analyze run --monitor --monitor-disable-auth wget
+    
+Regardless of your choice, when you run analyze on an installed package (whether
+it was installed with ``--monitor`` or not, you'll see the results generating as they did
+before, and a message that the monitor server was pinged:
+
+.. code-block:: console
+
+    $ spack analyze --monitor wget
+    ...
+    ==> Sending result for wget bin/wget to monitor.

lib/spack/docs/basic_usage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -45,8 +45,7 @@ Listing available packages
 
 To install software with Spack, you need to know what software is
 available.  You can see a list of available package names at the
-`packages.spack.io <https://packages.spack.io>`_ website, or
-using the ``spack list`` command.
+:ref:`package-list` webpage, or using the ``spack list`` command.
 
 .. _cmd-spack-list:
 
@@ -61,7 +60,7 @@ can install:
    :ellipsis: 10
 
 There are thousands of them, so we've truncated the output above, but you
-can find a `full list here <https://packages.spack.io>`_.
+can find a :ref:`full list here <package-list>`.
 Packages are listed by name in alphabetical order.
 A pattern to match with no wildcards, ``*`` or ``?``,
 will be treated as though it started and ended with
@@ -86,7 +85,7 @@ All packages whose names or descriptions contain documentation:
 To get more information on a particular package from `spack list`, use
 `spack info`.  Just supply the name of a package:
 
-.. command-output:: spack info --all mpich
+.. command-output:: spack info mpich
 
 Most of the information is self-explanatory.  The *safe versions* are
 versions that Spack knows the checksum for, and it will use the
@@ -193,33 +192,30 @@ you can use them to customize an installation in :ref:`sec-specs`.
 Reusing installed dependencies
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-By default, when you run ``spack install``, Spack tries hard to reuse existing installations
-as dependencies, either from a local store or from remote buildcaches if configured.
-This minimizes unwanted rebuilds of common dependencies, in particular if
-you update Spack frequently.
+.. warning::
 
-In case you want the latest versions and configurations to be installed instead,
-you can add the ``--fresh`` option:
+   The ``--reuse`` option described here is experimental, and it will
+   likely be replaced with a different option and configuration settings
+   in the next Spack release.
+
+By default, when you run ``spack install``, Spack tries to build a new
+version of the package you asked for, along with updated versions of
+its dependencies.  This gets you the latest versions and configurations,
+but it can result in unwanted rebuilds if you update Spack frequently.
+
+If you want Spack to try hard to reuse existing installations as dependencies,
+you can add the ``--reuse`` option:
 
 .. code-block:: console
 
-   $ spack install --fresh mpich
+   $ spack install --reuse mpich
 
-Reusing installations in this mode is "accidental", and happening only if
-there's a match between existing installations and what Spack would have installed
-anyhow.
-
-You can use the ``spack spec -I mpich`` command to see what
+This will not do anything if ``mpich`` is already installed.  If ``mpich``
+is not installed, but dependencies like ``hwloc`` and ``libfabric`` are,
+the ``mpich`` will be build with the installed versions, if possible.
+You can use the :ref:`spack spec -I <cmd-spack-spec>` command to see what
 will be reused and what will be built before you install.
 
-You can configure Spack to use the ``--fresh`` behavior by default in
-``concretizer.yaml``:
-
-.. code-block:: yaml
-
-   concretizer:
-     reuse: false
-
 .. _cmd-spack-uninstall:
 
 ^^^^^^^^^^^^^^^^^^^
@@ -897,8 +893,8 @@ your path:
    $ which mpicc
    ~/spack/opt/linux-debian7-x86_64/gcc@4.4.7/mpich@3.0.4/bin/mpicc
 
-These commands will add appropriate directories to your ``PATH``
-and ``MANPATH`` according to the
+These commands will add appropriate directories to your ``PATH``,
+``MANPATH``, ``CPATH``, and ``LD_LIBRARY_PATH`` according to the
 :ref:`prefix inspections <customize-env-modifications>` defined in your
 modules configuration.
 When you no longer want to use a package, you can type unload or
@@ -943,7 +939,7 @@ first ``libelf`` above, you would run:
 
    $ spack load /qmm4kso
 
-To see which packages that you have loaded to your environment you would
+To see which packages that you have loaded to your enviornment you would
 use ``spack find --loaded``.
 
 .. code-block:: console
@@ -999,15 +995,11 @@ More formally, a spec consists of the following pieces:
 * ``%`` Optional compiler specifier, with an optional compiler version
   (``gcc`` or ``gcc@4.7.3``)
 * ``+`` or ``-`` or ``~`` Optional variant specifiers (``+debug``,
-  ``-qt``, or ``~qt``) for boolean variants. Use ``++`` or ``--`` or
-  ``~~`` to propagate variants through the dependencies (``++debug``,
-  ``--qt``, or ``~~qt``).
+  ``-qt``, or ``~qt``) for boolean variants
 * ``name=<value>`` Optional variant specifiers that are not restricted to
-  boolean variants. Use ``name==<value>`` to propagate variant through the
-  dependencies.
+  boolean variants
 * ``name=<value>`` Optional compiler flag specifiers. Valid flag names are
   ``cflags``, ``cxxflags``, ``fflags``, ``cppflags``, ``ldflags``, and ``ldlibs``.
-  Use ``name==<value>`` to propagate compiler flags through the dependencies.
 * ``target=<value> os=<value>`` Optional architecture specifier
   (``target=haswell os=CNL10``)
 * ``^`` Dependency specs (``^callpath@1.1``)
@@ -1098,80 +1090,26 @@ could depend on ``mpich@1.2:`` if it can only build with version
 
 Below are more details about the specifiers that you can add to specs.
 
-.. _version-specifier:
-
 ^^^^^^^^^^^^^^^^^
 Version specifier
 ^^^^^^^^^^^^^^^^^
 
-A version specifier ``pkg@<specifier>`` comes after a package name
-and starts with ``@``. It can be something abstract that matches
-multiple known versions, or a specific version. During concretization,
-Spack will pick the optimal version within the spec's constraints
-according to policies set for the particular Spack installation.
+A version specifier comes somewhere after a package name and starts
+with ``@``.  It can be a single version, e.g. ``@1.0``, ``@3``, or
+``@1.2a7``.  Or, it can be a range of versions, such as ``@1.0:1.5``
+(all versions between ``1.0`` and ``1.5``, inclusive).  Version ranges
+can be open, e.g. ``:3`` means any version up to and including ``3``.
+This would include ``3.4`` and ``3.4.2``.  ``4.2:`` means any version
+above and including ``4.2``.  Finally, a version specifier can be a
+set of arbitrary versions, such as ``@1.0,1.5,1.7`` (``1.0``, ``1.5``,
+or ``1.7``).  When you supply such a specifier to ``spack install``,
+it constrains the set of versions that Spack will install.
 
-The version specifier can be *a specific version*, such as ``@=1.0.0`` or
-``@=1.2a7``. Or, it can be *a range of versions*, such as ``@1.0:1.5``.
-Version ranges are inclusive, so this example includes both ``1.0``
-and any ``1.5.x`` version. Version ranges can be unbounded, e.g. ``@:3``
-means any version up to and including ``3``. This would include ``3.4``
-and ``3.4.2``.  Similarly, ``@4.2:`` means any version above and including
-``4.2``.  As a short-hand, ``@3`` is equivalent to the range ``@3:3`` and
-includes any version with major version ``3``.
-
-Versions are ordered lexicograpically by its components. For more details
-on the order, see :ref:`the packaging guide <version-comparison>`.
-
-Notice that you can distinguish between the specific version ``@=3.2`` and
-the range ``@3.2``. This is useful for packages that follow a versioning
-scheme that omits the zero patch version number: ``3.2``, ``3.2.1``,
-``3.2.2``, etc. In general it is preferable to use the range syntax
-``@3.2``, since ranges also match versions with one-off suffixes, such as
-``3.2-custom``.
-
-A version specifier can also be a list of ranges and specific versions,
-separated by commas.  For example, ``@1.0:1.5,=1.7.1`` matches any version
-in the range ``1.0:1.5`` and the specific version ``1.7.1``.
-
-^^^^^^^^^^^^
-Git versions
-^^^^^^^^^^^^
-
-For packages with a ``git`` attribute, ``git`` references
-may be specified instead of a numerical version i.e. branches, tags
-and commits. Spack will stage and build based off the ``git``
-reference provided.  Acceptable syntaxes for this are:
-
-.. code-block:: sh
-
-    # commit hashes
-   foo@abcdef1234abcdef1234abcdef1234abcdef1234    # 40 character hashes are automatically treated as git commits
-   foo@git.abcdef1234abcdef1234abcdef1234abcdef1234
-
-    # branches and tags
-   foo@git.develop # use the develop branch
-   foo@git.0.19 # use the 0.19 tag
-
-Spack always needs to associate a Spack version with the git reference,
-which is used for version comparison. This Spack version is heuristically
-taken from the closest valid git tag among ancestors of the git ref.
-
-Once a Spack version is associated with a git ref, it always printed with
-the git ref.  For example, if the commit ``@git.abcdefg`` is tagged
-``0.19``, then the spec will be shown as ``@git.abcdefg=0.19``.
-
-If the git ref is not exactly a tag, then the distance to the nearest tag
-is also part of the resolved version. ``@git.abcdefg=0.19.git.8`` means
-that the commit is 8 commits away from the ``0.19`` tag.
-
-In cases where Spack cannot resolve a sensible version from a git ref,
-users can specify the Spack version to use for the git ref. This is done
-by appending ``=`` and the Spack version to the git ref. For example:
-
-.. code-block:: sh
-
-   foo@git.my_ref=3.2 # use the my_ref tag or branch, but treat it as version 3.2 for version comparisons
-   foo@git.abcdef1234abcdef1234abcdef1234abcdef1234=develop # use the given commit, but treat it as develop for version comparisons
+If the version spec is not provided, then Spack will choose one
+according to policies set for the particular spack installation.  If
+the spec is ambiguous, i.e. it could match multiple versions, Spack
+will choose a version within the spec's constraints according to
+policies set for the particular Spack installation.
 
 Details about how versions are compared and how Spack determines if
 one version is less than another are discussed in the developer guide.
@@ -1252,23 +1190,6 @@ variants using the backwards compatibility syntax and uses only ``~``
 for disabled boolean variants.  The ``-`` and spaces on the command
 line are provided for convenience and legibility.
 
-Spack allows variants to propagate their value to the package's
-dependency by using ``++``, ``--``, and ``~~`` for boolean variants.
-For example, for a ``debug`` variant:
-
-.. code-block:: sh
-
-    mpileaks ++debug   # enabled debug will be propagated to dependencies
-    mpileaks +debug    # only mpileaks will have debug enabled
-
-To propagate the value of non-boolean variants Spack uses ``name==value``.
-For example, for the ``stackstart`` variant:
-
-.. code-block:: sh
-
-    mpileaks stackstart==4   # variant will be propagated to dependencies
-    mpileaks stackstart=4    # only mpileaks will have this variant value
-
 ^^^^^^^^^^^^^^
 Compiler Flags
 ^^^^^^^^^^^^^^
@@ -1276,15 +1197,10 @@ Compiler Flags
 Compiler flags are specified using the same syntax as non-boolean variants,
 but fulfill a different purpose. While the function of a variant is set by
 the package, compiler flags are used by the compiler wrappers to inject
-flags into the compile line of the build. Additionally, compiler flags can
-be inherited by dependencies by using ``==``.
-``spack install libdwarf cppflags=="-g"`` will install both libdwarf and
-libelf with the ``-g`` flag injected into their compile line.
-
-.. note::
-
-   versions of spack prior to 0.19.0 will propagate compiler flags using
-   the ``=`` syntax.
+flags into the compile line of the build. Additionally, compiler flags are
+inherited by dependencies. ``spack install libdwarf cppflags="-g"`` will
+install both libdwarf and libelf with the ``-g`` flag injected into their
+compile line.
 
 Notice that the value of the compiler flags must be quoted if it
 contains any spaces. Any of ``cppflags=-O3``, ``cppflags="-O3"``,
@@ -1364,7 +1280,7 @@ Normally users don't have to bother specifying the architecture if they
 are installing software for their current host, as in that case the
 values will be detected automatically.  If you need fine-grained control
 over which packages use which targets (or over *all* packages' default
-target), see :ref:`package-preferences`.
+target), see :ref:`concretization-preferences`.
 
 .. admonition:: Cray machines
 
@@ -1486,7 +1402,7 @@ built.
 You can see what virtual packages a particular package provides by
 getting info on it:
 
-.. command-output:: spack info --virtuals mpich
+.. command-output:: spack info mpich
 
 Spack is unique in that its virtual packages can be versioned, just
 like regular packages.  A particular version of a package may provide
@@ -1533,30 +1449,6 @@ any MPI implementation will do.  If another package depends on
 error.  Likewise, if you try to plug in some package that doesn't
 provide MPI, Spack will raise an error.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Explicit binding of virtual dependencies
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-There are packages that provide more than just one virtual dependency. When interacting with them, users
-might want to utilize just a subset of what they could provide, and use other providers for virtuals they
-need.
-
-It is possible to be more explicit and tell Spack which dependency should provide which virtual, using a
-special syntax:
-
-.. code-block:: console
-
-   $ spack spec strumpack ^[virtuals=mpi] intel-parallel-studio+mkl ^[virtuals=lapack] openblas
-
-Concretizing the spec above produces the following DAG:
-
-.. figure:: images/strumpack_virtuals.svg
-   :scale: 60 %
-   :align: center
-
-where ``intel-parallel-studio`` *could* provide ``mpi``, ``lapack``, and ``blas`` but is used only for the former. The ``lapack``
-and ``blas`` dependencies are satisfied by ``openblas``.
-
 ^^^^^^^^^^^^^^^^^^^^^^^^
 Specifying Specs by Hash
 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1718,13 +1610,9 @@ own install prefix.  However, certain packages are typically installed
 `Python <https://www.python.org>`_ packages are typically installed in the
 ``$prefix/lib/python-2.7/site-packages`` directory.
 
-In Spack, installation prefixes are immutable, so this type of installation
-is not directly supported. However, it is possible to create views that
-allow you to merge install prefixes of multiple packages into a single new prefix.
-Views are a convenient way to get a more traditional filesystem structure.
-Using *extensions*, you can ensure that Python packages always share the
-same prefix in the view as Python itself. Suppose you have
-Python installed like so:
+Spack has support for this type of installation as well.  In Spack,
+a package that can live inside the prefix of another package is called
+an *extension*.  Suppose you have Python installed like so:
 
 .. code-block:: console
 
@@ -1762,6 +1650,8 @@ You can find extensions for your Python installation like this:
    py-ipython@2.3.1     py-pygments@2.0.1   py-setuptools@11.3.1
    py-matplotlib@1.4.2  py-pyparsing@2.0.3  py-six@1.9.0
 
+   ==> None activated.
+
 The extensions are a subset of what's returned by ``spack list``, and
 they are packages like any other.  They are installed into their own
 prefixes, and you can see this with ``spack find --paths``:
@@ -1789,72 +1679,32 @@ directly when you run ``python``:
    ImportError: No module named numpy
    >>>
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Using Extensions in Environments
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^
+Using Extensions
+^^^^^^^^^^^^^^^^
 
-The recommended way of working with extensions such as ``py-numpy``
-above is through :ref:`Environments <environments>`. For example,
-the following creates an environment in the current working directory
-with a filesystem view in the ``./view`` directory:
-
-.. code-block:: console
-
-   $ spack env create --with-view view --dir .
-   $ spack -e . add py-numpy
-   $ spack -e . concretize
-   $ spack -e . install
-
-We recommend environments for two reasons. Firstly, environments
-can be activated (requires :ref:`shell-support`):
-
-.. code-block:: console
-
-   $ spack env activate .
-
-which sets all the right environment variables such as ``PATH`` and
-``PYTHONPATH``. This ensures that
-
-.. code-block:: console
-
-   $ python
-   >>> import numpy
-
-works. Secondly, even without shell support, the view ensures
-that Python can locate its extensions:
-
-.. code-block:: console
-
-   $ ./view/bin/python
-   >>> import numpy
-
-See :ref:`environments` for a more in-depth description of Spack
-environments and customizations to views.
-
-^^^^^^^^^^^^^^^^^^^^
-Using ``spack load``
-^^^^^^^^^^^^^^^^^^^^
-
-A more traditional way of using Spack and extensions is ``spack load``
-(requires :ref:`shell-support`). This will add the extension to ``PYTHONPATH``
-in your current shell, and Python itself will be available in the ``PATH``:
+There are four ways to get ``numpy`` working in Python.  The first is
+to use :ref:`shell-support`.  You can simply ``load`` the extension,
+and it will be added to the ``PYTHONPATH`` in your current shell:
 
 .. code-block:: console
 
+   $ spack load python
    $ spack load py-numpy
-   $ python
-   >>> import numpy
 
+Now ``import numpy`` will succeed for as long as you keep your current
+session open.
 The loaded packages can be checked using ``spack find --loaded``
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Loading Extensions via Modules
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Apart from ``spack env activate`` and ``spack load``, you can load numpy
-through your environment modules (using ``environment-modules`` or
-``lmod``). This will also add the extension to the ``PYTHONPATH`` in
-your current shell.
+Instead of using Spack's environment modification capabilities through
+the ``spack load`` command, you can load numpy through your
+environment modules (using ``environment-modules`` or ``lmod``). This
+will also add the extension to the ``PYTHONPATH`` in your current
+shell.
 
 .. code-block:: console
 
@@ -1864,6 +1714,130 @@ If you do not know the name of the specific numpy module you wish to
 load, you can use the ``spack module tcl|lmod loads`` command to get
 the name of the module from the Spack spec.
 
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Activating Extensions in a View
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Another way to use extensions is to create a view, which merges the
+python installation along with the extensions into a single prefix.
+See :ref:`filesystem-views` for a more in-depth description of views and
+:ref:`cmd-spack-view` for usage of the ``spack view`` command.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Activating Extensions Globally
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+As an alternative to creating a merged prefix with Python and its extensions,
+and prior to support for views, Spack has provided a means to install the
+extension into the Spack installation prefix for the extendee. This has
+typically been useful since extendable packages typically search their own
+installation path for addons by default.
+
+Global activations are performed with the ``spack activate`` command:
+
+.. _cmd-spack-activate:
+
+^^^^^^^^^^^^^^^^^^
+``spack activate``
+^^^^^^^^^^^^^^^^^^
+
+.. code-block:: console
+
+   $ spack activate py-numpy
+   ==> Activated extension py-setuptools@11.3.1%gcc@4.4.7 arch=linux-debian7-x86_64-3c74eb69 for python@2.7.8%gcc@4.4.7.
+   ==> Activated extension py-nose@1.3.4%gcc@4.4.7 arch=linux-debian7-x86_64-5f70f816 for python@2.7.8%gcc@4.4.7.
+   ==> Activated extension py-numpy@1.9.1%gcc@4.4.7 arch=linux-debian7-x86_64-66733244 for python@2.7.8%gcc@4.4.7.
+
+Several things have happened here.  The user requested that
+``py-numpy`` be activated in the ``python`` installation it was built
+with.  Spack knows that ``py-numpy`` depends on ``py-nose`` and
+``py-setuptools``, so it activated those packages first.  Finally,
+once all dependencies were activated in the ``python`` installation,
+``py-numpy`` was activated as well.
+
+If we run ``spack extensions`` again, we now see the three new
+packages listed as activated:
+
+.. code-block:: console
+
+   $ spack extensions python
+   ==> python@2.7.8%gcc@4.4.7  arch=linux-debian7-x86_64-703c7a96
+   ==> 36 extensions:
+   geos          py-ipython     py-pexpect    py-pyside            py-sip
+   py-basemap    py-libxml2     py-pil        py-pytz              py-six
+   py-biopython  py-mako        py-pmw        py-rpy2              py-sympy
+   py-cython     py-matplotlib  py-pychecker  py-scientificpython  py-virtualenv
+   py-dateutil   py-mpi4py      py-pygments   py-scikit-learn
+   py-epydoc     py-mx          py-pylint     py-scipy
+   py-gnuplot    py-nose        py-pyparsing  py-setuptools
+   py-h5py       py-numpy       py-pyqt       py-shiboken
+
+   ==> 12 installed:
+   -- linux-debian7-x86_64 / gcc@4.4.7 --------------------------------
+   py-dateutil@2.4.0    py-nose@1.3.4       py-pyside@1.2.2
+   py-dateutil@2.4.0    py-numpy@1.9.1      py-pytz@2014.10
+   py-ipython@2.3.1     py-pygments@2.0.1   py-setuptools@11.3.1
+   py-matplotlib@1.4.2  py-pyparsing@2.0.3  py-six@1.9.0
+
+   ==> 3 currently activated:
+   -- linux-debian7-x86_64 / gcc@4.4.7 --------------------------------
+   py-nose@1.3.4  py-numpy@1.9.1  py-setuptools@11.3.1
+
+Now, when a user runs python, ``numpy`` will be available for import
+*without* the user having to explicitly load it.  ``python@2.7.8`` now
+acts like a system Python installation with ``numpy`` installed inside
+of it.
+
+Spack accomplishes this by symbolically linking the *entire* prefix of
+the ``py-numpy`` package into the prefix of the ``python`` package.  To the
+python interpreter, it looks like ``numpy`` is installed in the
+``site-packages`` directory.
+
+The only limitation of global activation is that you can only have a *single*
+version of an extension activated at a time.  This is because multiple
+versions of the same extension would conflict if symbolically linked
+into the same prefix.  Users who want a different version of a package
+can still get it by using environment modules or views, but they will have to
+explicitly load their preferred version.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+``spack activate --force``
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If, for some reason, you want to activate a package *without* its
+dependencies, you can use ``spack activate --force``:
+
+.. code-block:: console
+
+   $ spack activate --force py-numpy
+   ==> Activated extension py-numpy@1.9.1%gcc@4.4.7 arch=linux-debian7-x86_64-66733244 for python@2.7.8%gcc@4.4.7.
+
+.. _cmd-spack-deactivate:
+
+^^^^^^^^^^^^^^^^^^^^
+``spack deactivate``
+^^^^^^^^^^^^^^^^^^^^
+
+We've seen how activating an extension can be used to set up a default
+version of a Python module.  Obviously, you may want to change that at
+some point.  ``spack deactivate`` is the command for this.  There are
+several variants:
+
+* ``spack deactivate <extension>`` will deactivate a single
+  extension.  If another activated extension depends on this one,
+  Spack will warn you and exit with an error.
+* ``spack deactivate --force <extension>`` deactivates an extension
+  regardless of packages that depend on it.
+* ``spack deactivate --all <extension>`` deactivates an extension and
+  all of its dependencies.  Use ``--force`` to disregard dependents.
+* ``spack deactivate --all <extendee>`` deactivates *all* activated
+  extensions of a package.  For example, to deactivate *all* python
+  extensions, use:
+
+  .. code-block:: console
+
+     $ spack deactivate --all python
+
 -----------------------
 Filesystem requirements
 -----------------------

lib/spack/docs/binary_caches.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -13,47 +13,42 @@ Some sites may encourage users to set up their own test environments
 before carrying out central installations, or some users may prefer to set
 up these environments on their own motivation. To reduce the load of
 recompiling otherwise identical package specs in different installations,
-installed packages can be put into build cache tarballs, pushed to
+installed packages can be put into build cache tarballs, uploaded to
 your Spack mirror and then downloaded and installed by others.
 
-Whenever a mirror provides prebuilt packages, Spack will take these packages
-into account during concretization and installation, making ``spack install``
-significantly faster.
 
+--------------------------
+Creating build cache files
+--------------------------
 
-.. note::
-
-    We use the terms "build cache" and "mirror" often interchangeably. Mirrors
-    are used during installation both for sources and prebuilt packages. Build
-    caches refer to mirrors that provide prebuilt packages.
-
-
-----------------------
-Creating a build cache
-----------------------
+A compressed tarball of an installed package is created. Tarballs are created
+for all of its link and run dependency packages as well. Compressed tarballs are
+signed with gpg and signature and tarball and put in a ``.spack`` file. Optionally,
+the rpaths (and ids and deps on macOS) can be changed to paths relative to
+the Spack install tree before the tarball is created.
 
 Build caches are created via:
 
 .. code-block:: console
 
-    $ spack buildcache push <path/url/mirror name> <spec>
+    $ spack buildcache create <spec>
 
-This command takes the locally installed spec and its dependencies, and
-creates tarballs of their install prefixes. It also generates metadata files,
-signed with GPG. These tarballs and metadata files are then pushed to the
-provided binary cache, which can be a local directory or a remote URL.
 
-Here is an example where a build cache is created in a local directory named
-"spack-cache", to which we push the "ninja" spec:
+If you wanted to create a build cache in a local directory, you would provide
+the ``-d`` argument to target that directory, again also specifying the spec.
+Here is an example creating a local directory, "spack-cache" and creating
+build cache files for the "ninja" spec:
 
 .. code-block:: console
 
-    $ spack buildcache push ./spack-cache ninja
-    ==> Pushing binary packages to file:///home/spackuser/spack/spack-cache/build_cache
+    $ mkdir -p ./spack-cache
+    $ spack buildcache create -d ./spack-cache ninja
+    ==> Buildcache files will be output to file:///home/spackuser/spack/spack-cache/build_cache
+    gpgconf: socketdir is '/run/user/1000/gnupg'
+    gpg: using "E6DF6A8BD43208E4D6F392F23777740B7DBD643D" as default secret key for signing
 
-Note that ``ninja`` must be installed locally for this to work.
-
-Once you have a build cache, you can add it as a mirror, discussed next.
+Note that the targeted spec must already be installed. Once you have a build cache,
+you can add it as a mirror, discussed next.
 
 ---------------------------------------
 Finding or installing build cache files
@@ -64,10 +59,10 @@ with:
 
 .. code-block:: console
 
-    $ spack mirror add <name> <url or path>
+    $ spack mirror add <name> <url>
 
 
-Both web URLs and local paths on the filesystem can be specified. In the previous
+Note that the url can be a web url _or_ a local filesystem location. In the previous
 example, you might add the directory "spack-cache" and call it ``mymirror``:
 
 
@@ -92,7 +87,7 @@ this new build cache as follows:
 
 .. code-block:: console
 
-    $ spack buildcache update-index ./spack-cache
+    $ spack buildcache update-index -d spack-cache/
 
 Now you can use list:
 
@@ -103,38 +98,46 @@ Now you can use list:
     -- linux-ubuntu20.04-skylake / gcc@9.3.0 ------------------------
     ninja@1.10.2
 
-With ``mymirror`` configured and an index available, Spack will automatically
-use it during concretization and installation. That means that you can expect
-``spack install ninja`` to fetch prebuilt packages from the mirror. Let's
-verify by re-installing ninja:
+
+Great! So now let's say you have a different spack installation, or perhaps just
+a different environment for the same one, and you want to install a package from
+that build cache. Let's first uninstall the actual library "ninja" to see if we can
+re-install it from the cache.
 
 .. code-block:: console
 
     $ spack uninstall ninja
-    $ spack install ninja
-    ==> Installing ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
-    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz.spec.json.sig
-    gpg: Signature made Do 12 Jan 2023 16:01:04 CET
-    gpg:                using RSA key 61B82B2B2350E171BD17A1744E3A689061D57BF6
-    gpg: Good signature from "example (GPG created for Spack) <example@example.com>" [ultimate]
-    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.10.2/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz.spack
-    ==> Extracting ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz from binary cache
-    ==> ninja: Successfully installed ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
-    Search: 0.00s.  Fetch: 0.17s.  Install: 0.12s.  Total: 0.29s
-    [+] /home/harmen/spack/opt/spack/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
 
 
-It worked! You've just completed a full example of creating a build cache with
-a spec of interest, adding it as a mirror, updating its index, listing the contents,
-and finally, installing from it.
-
-By default Spack falls back to building from sources when the mirror is not available
-or when the package is simply not already available. To force Spack to only install
-prebuilt packages, you can use
+And now reinstall from the buildcache
 
 .. code-block:: console
 
-   $ spack install --use-buildcache only <package>
+    $ spack buildcache install ninja
+    ==> buildcache spec(s) matching ninja 
+    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.10.2/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-i4e5luour7jxdpc3bkiykd4imke3mkym.spack
+    ####################################################################################################################################### 100.0%
+    ==> Installing buildcache for spec ninja@1.10.2%gcc@9.3.0 arch=linux-ubuntu20.04-skylake
+    gpgconf: socketdir is '/run/user/1000/gnupg'
+    gpg: Signature made Tue 23 Mar 2021 10:16:29 PM MDT
+    gpg:                using RSA key E6DF6A8BD43208E4D6F392F23777740B7DBD643D
+    gpg: Good signature from "spackuser (GPG created for Spack) <spackuser@noreply.users.github.com>" [ultimate]
+
+
+It worked! You've just completed a full example of creating a build cache with
+a spec of interest, adding it as a mirror, updating it's index, listing the contents,
+and finally, installing from it.
+
+
+Note that the above command is intended to install a particular package to a
+build cache you have created, and not to install a package from a build cache.
+For the latter, once a mirror is added, by default when you do ``spack install`` the ``--use-cache``
+flag is set, and you will install a package from a build cache if it is available.
+If you want to always use the cache, you can do:
+
+.. code-block:: console
+
+   $ spack install --cache-only <package>
 
 For example, to combine all of the commands above to add the E4S build cache
 and then install from it exclusively, you would do:
@@ -143,7 +146,7 @@ and then install from it exclusively, you would do:
 
     $ spack mirror add E4S https://cache.e4s.io
     $ spack buildcache keys --install --trust
-    $ spack install --use-buildcache only <package>
+    $ spack install --cache-only <package>
 
 We use ``--install`` and ``--trust`` to say that we are installing keys to our
 keyring, and trusting all downloaded keys.
@@ -153,181 +156,18 @@ keyring, and trusting all downloaded keys.
 List of popular build caches
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-* `Extreme-scale Scientific Software Stack (E4S) <https://e4s-project.github.io/>`_: `build cache <https://oaciss.uoregon.edu/e4s/inventory.html>`_'
+* `Extreme-scale Scientific Software Stack (E4S) <https://e4s-project.github.io/>`_: `build cache <https://oaciss.uoregon.edu/e4s/inventory.html>`_
 
--------------------
-Build cache signing
--------------------
-
-By default, Spack will add a cryptographic signature to each package pushed to
-a build cache, and verifies the signature when installing from a build cache.
-
-Keys for signing can be managed with the :ref:`spack gpg <cmd-spack-gpg>` command,
-as well as ``spack buildcache keys`` as mentioned above.
-
-You can disable signing when pushing with ``spack buildcache push --unsigned``,
-and disable verification when installing from any build cache with
-``spack install --no-check-signature``.
-
-Alternatively, signing and verification can be enabled or disabled on a per build cache
-basis:
-
-.. code-block:: console
-
-    $ spack mirror add --signed <name> <url>  # enable signing and verification
-    $ spack mirror add --unsigned <name> <url>  # disable signing and verification
-
-    $ spack mirror set --signed <name>  # enable signing and verification for an existing mirror
-    $ spack mirror set --unsigned <name>  # disable signing and verification for an existing mirror
-
-Or you can directly edit the ``mirrors.yaml`` configuration file:
-
-.. code-block:: yaml
-
-    mirrors:
-      <name>:
-        url: <url>
-        signed: false # disable signing and verification
-
-See also :ref:`mirrors`.
 
 ----------
 Relocation
 ----------
 
-When using buildcaches across different machines, it is likely that the install
-root will be different from the one used to build the binaries.
-
-To address this issue, Spack automatically relocates all paths encoded in binaries
-and scripts to their new location upon install.
-
-Note that there are some cases where this is not possible: if binaries are built in
-a relatively short path, and then installed to a longer path, there may not be enough
-space in the binary to encode the new path. In this case, Spack will fail to install
-the package from the build cache, and a source build is required.
-
-To reduce the likelihood of this happening, it is highly recommended to add padding to
-the install root during the build, as specified in the :ref:`config <config-yaml>`
-section of the configuration:
-
-.. code-block:: yaml
-
-   config:
-     install_tree:
-       root: /opt/spack
-       padded_length: 128
-
-
-.. _binary_caches_oci:
-
----------------------------------
-Automatic push to a build cache
----------------------------------
-
-Sometimes it is convenient to push packages to a build cache as soon as they are installed. Spack can do this by setting autopush flag when adding a mirror:
-
-.. code-block:: console
-
-    $ spack mirror add --autopush <name> <url or path>
-
-Or the autopush flag can be set for an existing mirror:
-
-.. code-block:: console
-
-    $ spack mirror set --autopush <name>  # enable automatic push for an existing mirror
-    $ spack mirror set --no-autopush <name>  # disable automatic push for an existing mirror
-
-Then after installing a package it is automatically pushed to all mirrors with ``autopush: true``. The command
-
-.. code-block:: console
-
-    $ spack install <package>
-
-will have the same effect as
-
-.. code-block:: console
-
-    $ spack install <package>
-    $ spack buildcache push <cache> <package>  # for all caches with autopush: true
-
-.. note::
-
-    Packages are automatically pushed to a build cache only if they are built from source.
-
------------------------------------------
-OCI / Docker V2 registries as build cache
------------------------------------------
-
-Spack can also use OCI or Docker V2 registries such as Dockerhub, Quay.io,
-Github Packages, GitLab Container Registry, JFrog Artifactory, and others
-as build caches. This is a convenient way to share binaries using public
-infrastructure, or to cache Spack built binaries in Github Actions and
-GitLab CI.
-
-To get started, configure an OCI mirror using ``oci://`` as the scheme,
-and optionally specify a username and password (or personal access token):
-
-.. code-block:: console
-
-    $ spack mirror add --oci-username username --oci-password password my_registry oci://example.com/my_image
-
-Spack follows the naming conventions of Docker, with Dockerhub as the default
-registry. To use Dockerhub, you can omit the registry domain:
-
-.. code-block:: console
-
-    $ spack mirror add --oci-username username --oci-password password my_registry oci://username/my_image
-
-From here, you can use the mirror as any other build cache:
-
-.. code-block:: console
-
-    $ spack buildcache push my_registry <specs...>  # push to the registry
-    $ spack install <specs...> # install from the registry
-
-A unique feature of buildcaches on top of OCI registries is that it's incredibly
-easy to generate get a runnable container image with the binaries installed. This
-is a great way to make applications available to users without requiring them to
-install Spack -- all you need is Docker, Podman or any other OCI-compatible container
-runtime.
-
-To produce container images, all you need to do is add the ``--base-image`` flag
-when pushing to the build cache:
-
-.. code-block:: console
-
-    $ spack buildcache push --base-image ubuntu:20.04 my_registry ninja
-    Pushed to example.com/my_image:ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz.spack
-
-    $ docker run -it example.com/my_image:ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz.spack
-    root@e4c2b6f6b3f4:/# ninja --version
-    1.11.1
-
-If ``--base-image`` is not specified, distroless images are produced. In practice,
-you won't be able to run these as containers, since they don't come with libc and
-other system dependencies. However, they are still compatible with tools like
-``skopeo``, ``podman``, and ``docker`` for pulling and pushing.
-
-.. note::
-    The docker ``overlayfs2`` storage driver is limited to 128 layers, above which a
-    ``max depth exceeded`` error may be produced when pulling the image. There
-    are `alternative drivers <https://docs.docker.com/storage/storagedriver/>`_.
-
-------------------------------------
-Spack build cache for GitHub Actions
-------------------------------------
-
-To significantly speed up Spack in GitHub Actions, binaries can be cached in
-GitHub Packages. This service is an OCI registry that can be linked to a GitHub
-repository.
-
-Spack offers a public build cache for GitHub Actions with a set of common packages,
-which lets you get started quickly. See the following resources for more information:
-
-* `spack/setup-spack <https://github.com/spack/setup-spack>`_ for setting up Spack in GitHub
-  Actions
-* `spack/github-actions-buildcache <https://github.com/spack/github-actions-buildcache>`_ for
-  more details on the public build cache
+Initial build and later installation do not necessarily happen at the same
+location. Spack provides a relocation capability and corrects for RPATHs and
+non-relocatable scripts. However, many packages compile paths into binary
+artifacts directly. In such cases, the build instructions of this package would
+need to be adjusted for better re-locatability.
 
 .. _cmd-spack-buildcache:
 
@@ -336,7 +176,7 @@ which lets you get started quickly. See the following resources for more informa
 --------------------
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-``spack buildcache push``
+``spack buildcache create``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Create tarball of installed Spack package and all dependencies.

lib/spack/docs/bootstrapping.rst

@@ -1,178 +0,0 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _bootstrapping:
-
-=============
-Bootstrapping
-=============
-
-In the :ref:`Getting started <getting_started>` Section we already mentioned that
-Spack can bootstrap some of its dependencies, including ``clingo``. In fact, there
-is an entire command dedicated to the management of every aspect of bootstrapping:
-
-.. command-output:: spack bootstrap --help
-
-Spack is configured to bootstrap its dependencies lazily by default; i.e. the first time they are needed and
-can't be found. You can readily check if any prerequisite for using Spack is missing by running:
-
-.. code-block:: console
-
-   % spack bootstrap status
-   Spack v0.19.0 - python@3.8
-
-   [FAIL] Core Functionalities
-     [B] MISSING "clingo": required to concretize specs
-
-   [FAIL] Binary packages
-     [B] MISSING "gpg2": required to sign/verify buildcaches
-
-
-   Spack will take care of bootstrapping any missing dependency marked as [B]. Dependencies marked as [-] are instead required to be found on the system.
-
-   % echo $?
-   1
-
-In the case of the output shown above Spack detected that both ``clingo`` and ``gnupg``
-are missing and it's giving detailed information on why they are needed and whether
-they can be bootstrapped. The return code of this command summarizes the results, if any
-dependencies are missing the return code is ``1``, otherwise ``0``. Running a command that
-concretizes a spec, like:
-
-.. code-block:: console
-
-   % spack solve zlib
-   ==> Bootstrapping clingo from pre-built binaries
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.1/build_cache/darwin-catalina-x86_64/apple-clang-12.0.0/clingo-bootstrap-spack/darwin-catalina-x86_64-apple-clang-12.0.0-clingo-bootstrap-spack-p5on7i4hejl775ezndzfdkhvwra3hatn.spack
-   ==> Installing "clingo-bootstrap@spack%apple-clang@12.0.0~docs~ipo+python build_type=Release arch=darwin-catalina-x86_64" from a buildcache
-   [ ... ]
-
-automatically triggers the bootstrapping of clingo from pre-built binaries as expected.
-
-Users can also bootstrap all the dependencies needed by Spack in a single command, which
-might be useful to setup containers or other similar environments:
-
-.. code-block:: console
-
-   $ spack bootstrap now
-   ==> Bootstrapping clingo from pre-built binaries
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.3/build_cache/linux-centos7-x86_64-gcc-10.2.1-clingo-bootstrap-spack-shqedxgvjnhiwdcdrvjhbd73jaevv7wt.spec.json
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.3/build_cache/linux-centos7-x86_64/gcc-10.2.1/clingo-bootstrap-spack/linux-centos7-x86_64-gcc-10.2.1-clingo-bootstrap-spack-shqedxgvjnhiwdcdrvjhbd73jaevv7wt.spack
-   ==> Installing "clingo-bootstrap@spack%gcc@10.2.1~docs~ipo+python+static_libstdcpp build_type=Release arch=linux-centos7-x86_64" from a buildcache
-   ==> Bootstrapping patchelf from pre-built binaries
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.3/build_cache/linux-centos7-x86_64-gcc-10.2.1-patchelf-0.15.0-htk62k7efo2z22kh6kmhaselru7bfkuc.spec.json
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.3/build_cache/linux-centos7-x86_64/gcc-10.2.1/patchelf-0.15.0/linux-centos7-x86_64-gcc-10.2.1-patchelf-0.15.0-htk62k7efo2z22kh6kmhaselru7bfkuc.spack
-   ==> Installing "patchelf@0.15.0%gcc@10.2.1 ldflags="-static-libstdc++ -static-libgcc"  arch=linux-centos7-x86_64" from a buildcache
-
------------------------
-The Bootstrapping store
------------------------
-
-The software installed for bootstrapping purposes is deployed in a separate store.
-Its location can be checked with the following command:
-
-.. code-block:: console
-
-   % spack bootstrap root
-
-It can also be changed with the same command by just specifying the newly desired path:
-
-.. code-block:: console
-
-   % spack bootstrap root /opt/spack/bootstrap
-
-You can check what is installed in the bootstrapping store at any time using:
-
-.. code-block:: console
-
-   % spack -b find
-   ==> Showing internal bootstrap store at "/Users/spack/.spack/bootstrap/store"
-   ==> 11 installed packages
-   -- darwin-catalina-x86_64 / apple-clang@12.0.0 ------------------
-   clingo-bootstrap@spack  libassuan@2.5.5  libgpg-error@1.42  libksba@1.5.1  pinentry@1.1.1  zlib@1.2.11
-   gnupg@2.3.1             libgcrypt@1.9.3  libiconv@1.16      npth@1.6       python@3.8
-
-In case it is needed you can remove all the software in the current bootstrapping store with:
-
-.. code-block:: console
-
-   % spack clean -b
-   ==> Removing bootstrapped software and configuration in "/Users/spack/.spack/bootstrap"
-
-   % spack -b find
-   ==> Showing internal bootstrap store at "/Users/spack/.spack/bootstrap/store"
-   ==> 0 installed packages
-
---------------------------------------------
-Enabling and disabling bootstrapping methods
---------------------------------------------
-
-Bootstrapping is always performed by trying the methods listed by:
-
-.. command-output:: spack bootstrap list
-
-in the order they appear, from top to bottom. By default Spack is
-configured to try first bootstrapping from pre-built binaries and to
-fall-back to bootstrapping from sources if that failed.
-
-If need be, you can disable bootstrapping altogether by running:
-
-.. code-block:: console
-
-   % spack bootstrap disable
-
-in which case it's your responsibility to ensure Spack runs in an
-environment where all its prerequisites are installed. You can
-also configure Spack to skip certain bootstrapping methods by disabling
-them specifically:
-
-.. code-block:: console
-
-   % spack bootstrap disable github-actions
-   ==> "github-actions" is now disabled and will not be used for bootstrapping
-
-tells Spack to skip trying to bootstrap from binaries. To add the "github-actions" method back you can:
-
-.. code-block:: console
-
-   % spack bootstrap enable github-actions
-
-There is also an option to reset the bootstrapping configuration to Spack's defaults:
-
-.. code-block:: console
-
-   % spack bootstrap reset
-   ==> Bootstrapping configuration is being reset to Spack's defaults. Current configuration will be lost.
-   Do you want to continue? [Y/n]
-   %
-
-----------------------------------------
-Creating a mirror for air-gapped systems
-----------------------------------------
-
-Spack's default configuration for bootstrapping relies on the user having
-access to the internet, either to fetch pre-compiled binaries or source tarballs.
-Sometimes though Spack is deployed on air-gapped systems where such access is denied.
-
-To help with similar situations Spack has a command that recreates, in a local folder
-of choice, a mirror containing the source tarballs and/or binary packages needed for
-bootstrapping.
-
-.. code-block:: console
-
-   % spack bootstrap mirror --binary-packages /opt/bootstrap
-   ==> Adding "clingo-bootstrap@spack+python %apple-clang target=x86_64" and dependencies to the mirror at /opt/bootstrap/local-mirror
-   ==> Adding "gnupg@2.3: %apple-clang target=x86_64" and dependencies to the mirror at /opt/bootstrap/local-mirror
-   ==> Adding "patchelf@0.13.1:0.13.99 %apple-clang target=x86_64" and dependencies to the mirror at /opt/bootstrap/local-mirror
-   ==> Adding binary packages from "https://github.com/alalazo/spack-bootstrap-mirrors/releases/download/v0.1-rc.2/bootstrap-buildcache.tar.gz" to the mirror at /opt/bootstrap/local-mirror
-
-   To register the mirror on the platform where it's supposed to be used run the following command(s):
-     % spack bootstrap add --trust local-sources /opt/bootstrap/metadata/sources
-     % spack bootstrap add --trust local-binaries /opt/bootstrap/metadata/binaries
-
-
-This command needs to be run on a machine with internet access and the resulting folder
-has to be moved over to the air-gapped system. Once the local sources are added using the
-commands suggested at the prompt, they can be used to bootstrap Spack.

lib/spack/docs/build_settings.rst

@@ -1,105 +1,319 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+.. _build-settings:
 
-.. _concretizer-options:
+===================
+Build Customization
+===================
 
-==========================================
-Concretization Settings (concretizer.yaml)
-==========================================
+Spack allows you to customize how your software is built through the
+``packages.yaml`` file.  Using it, you can make Spack prefer particular
+implementations of virtual dependencies (e.g., MPI or BLAS/LAPACK),
+or you can make it prefer to build with particular compilers.  You can
+also tell Spack to use *external* software installations already
+present on your system.
 
-The ``concretizer.yaml`` configuration file allows to customize aspects of the
-algorithm used to select the dependencies you install. The default configuration
-is the following:
-
-.. literalinclude:: _spack_root/etc/spack/defaults/concretizer.yaml
-   :language: yaml
-
---------------------------------
-Reuse already installed packages
---------------------------------
-
-The ``reuse`` attribute controls whether Spack will prefer to use installed packages (``true``), or
-whether it will do a "fresh" installation and prefer the latest settings from
-``package.py`` files and ``packages.yaml`` (``false``).
-You can use:
-
-.. code-block:: console
-
-   % spack install --reuse <spec>
-
-to enable reuse for a single installation, and you can use:
-
-.. code-block:: console
-
-   spack install --fresh <spec>
-
-to do a fresh install if ``reuse`` is enabled by default.
-``reuse: dependencies`` is the default.
-
-.. seealso::
-
-   FAQ: :ref:`Why does Spack pick particular versions and variants? <faq-concretizer-precedence>`
-
-------------------------------------------
-Selection of the target microarchitectures
-------------------------------------------
-
-The options under the ``targets`` attribute control which targets are considered during a solve.
-Currently the options in this section are only configurable from the ``concretizer.yaml`` file
-and there are no corresponding command line arguments to enable them for a single solve.
-
-The ``granularity`` option can take two possible values: ``microarchitectures`` and ``generic``.
-If set to:
+At a high level, the ``packages.yaml`` file is structured like this:
 
 .. code-block:: yaml
 
-   concretizer:
-     targets:
-       granularity: microarchitectures
+   packages:
+     package1:
+       # settings for package1
+     package2:
+       # settings for package2
+     # ...
+     all:
+       # settings that apply to all packages.
 
-Spack will consider all the microarchitectures known to ``archspec`` to label nodes for
-compatibility. If instead the option is set to:
+So you can either set build preferences specifically for *one* package,
+or you can specify that certain settings should apply to *all* packages.
+The types of settings you can customize are described in detail below.
+
+Spack's build defaults are in the default
+``etc/spack/defaults/packages.yaml`` file.  You can override them in
+``~/.spack/packages.yaml`` or ``etc/spack/packages.yaml``. For more
+details on how this works, see :ref:`configuration-scopes`.
+
+.. _sec-external-packages:
+
+-----------------
+External Packages
+-----------------
+
+Spack can be configured to use externally-installed
+packages rather than building its own packages. This may be desirable
+if machines ship with system packages, such as a customized MPI
+that should be used instead of Spack building its own MPI.
+
+External packages are configured through the ``packages.yaml`` file found
+in a Spack installation's ``etc/spack/`` or a user's ``~/.spack/``
+directory. Here's an example of an external configuration:
 
 .. code-block:: yaml
 
-   concretizer:
-     targets:
-       granularity: generic
+   packages:
+     openmpi:
+       externals:
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.4.3
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
+         prefix: /opt/openmpi-1.4.3-debug
+       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.6.5-intel
 
-Spack will consider only generic microarchitectures. For instance, when running on an
-Haswell node, Spack will consider ``haswell`` as the best target in the former case and
-``x86_64_v3`` as the best target in the latter case.
+This example lists three installations of OpenMPI, one built with GCC,
+one built with GCC and debug information, and another built with Intel.
+If Spack is asked to build a package that uses one of these MPIs as a
+dependency, it will use the pre-installed OpenMPI in
+the given directory. Note that the specified path is the top-level
+install prefix, not the ``bin`` subdirectory.
 
-The ``host_compatible`` option is a Boolean option that determines whether or not the
-microarchitectures considered during the solve are constrained to be compatible with the
-host Spack is currently running on. For instance, if this option is set to ``true``, a
-user cannot concretize for ``target=icelake`` while running on an Haswell node.
+``packages.yaml`` can also be used to specify modules to load instead
+of the installation prefixes.  The following example says that module
+``CMake/3.7.2`` provides cmake version 3.7.2.
 
----------------
-Duplicate nodes
----------------
+.. code-block:: yaml
 
-The ``duplicates`` attribute controls whether the DAG can contain multiple configurations of
-the same package. This is mainly relevant for build dependencies, which may have their version
-pinned by some nodes, and thus be required at different versions by different nodes in the same
-DAG.
+   cmake:
+     externals:
+     - spec: cmake@3.7.2
+       modules:
+       - CMake/3.7.2
 
-The ``strategy`` option controls how the solver deals with duplicates. If the value is ``none``,
-then a single configuration per package is allowed in the DAG. This means, for instance, that only
-a single ``cmake`` or a single ``py-setuptools`` version is allowed. The result would be a slightly
-faster concretization, at the expense of making a few specs unsolvable.
+Each ``packages.yaml`` begins with a ``packages:`` attribute, followed
+by a list of package names.  To specify externals, add an ``externals:``
+attribute under the package name, which lists externals.
+Each external should specify a ``spec:`` string that should be as
+well-defined as reasonably possible.  If a
+package lacks a spec component, such as missing a compiler or
+package version, then Spack will guess the missing component based
+on its most-favored packages, and it may guess incorrectly.
 
-If the value is ``minimal`` Spack will allow packages tagged as ``build-tools`` to have duplicates.
-This allows, for instance, to concretize specs whose nodes require different, and incompatible, ranges
-of some build tool. For instance, in the figure below the latest `py-shapely` requires a newer `py-setuptools`,
-while `py-numpy` still needs an older version:
+Each package version and compiler listed in an external should
+have entries in Spack's packages and compiler configuration, even
+though the package and compiler may not ever be built.
 
-.. figure::  images/shapely_duplicates.svg
-   :scale: 70 %
-   :align: center
+The packages configuration can tell Spack to use an external location
+for certain package versions, but it does not restrict Spack to using
+external packages.  In the above example, since newer versions of OpenMPI
+are available, Spack will choose to start building and linking with the
+latest version rather than continue using the pre-installed OpenMPI versions.
 
-Up to Spack v0.20 ``duplicates:strategy:none`` was the default (and only) behavior. From Spack v0.21 the
-default behavior is ``duplicates:strategy:minimal``.
+To prevent this, the ``packages.yaml`` configuration also allows packages
+to be flagged as non-buildable.  The previous example could be modified to
+be:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       externals:
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.4.3
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
+         prefix: /opt/openmpi-1.4.3-debug
+       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.6.5-intel
+       buildable: False
+
+The addition of the ``buildable`` flag tells Spack that it should never build
+its own version of OpenMPI, and it will instead always rely on a pre-built
+OpenMPI.  Similar to ``paths``, ``buildable`` is specified as a property under
+a package name.
+
+If an external module is specified as not buildable, then Spack will load the
+external module into the build environment which can be used for linking.
+
+The ``buildable`` does not need to be paired with external packages.
+It could also be used alone to forbid packages that may be
+buggy or otherwise undesirable.
+
+Virtual packages in Spack can also be specified as not buildable, and
+external implementations can be provided. In the example above,
+OpenMPI is configured as not buildable, but Spack will often prefer
+other MPI implementations over the externally available OpenMPI. Spack
+can be configured with every MPI provider not buildable individually,
+but more conveniently:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       buildable: False
+     openmpi:
+       externals:
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.4.3
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
+         prefix: /opt/openmpi-1.4.3-debug
+       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.6.5-intel
+
+Implementations can also be listed immediately under the virtual they provide:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       buildable: False
+         openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64: /opt/openmpi-1.4.3
+         openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug: /opt/openmpi-1.4.3-debug
+         openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64: /opt/openmpi-1.6.5-intel
+         mpich@3.3 %clang@9.0.0 arch=linux-debian7-x86_64: /opt/mpich-3.3-intel
+
+Spack can then use any of the listed external implementations of MPI
+to satisfy a dependency, and will choose depending on the compiler and
+architecture.
+
+.. _cmd-spack-external-find:
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Automatically Find External Packages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can run the :ref:`spack external find <spack-external-find>` command
+to search for system-provided packages and add them to ``packages.yaml``.
+After running this command your ``packages.yaml`` may include new entries:
+
+.. code-block:: yaml
+
+   packages:
+     cmake:
+       externals:
+       - spec: cmake@3.17.2
+         prefix: /usr
+
+Generally this is useful for detecting a small set of commonly-used packages;
+for now this is generally limited to finding build-only dependencies.
+Specific limitations include:
+
+* Packages are not discoverable by default: For a package to be
+  discoverable with ``spack external find``, it needs to add special
+  logic. See :ref:`here <make-package-findable>` for more details.
+* The current implementation only collects and examines executable files,
+  so it is typically only useful for build/run dependencies (in some cases
+  if a library package also provides an executable, it may be possible to
+  extract a meaningful Spec by running the executable - for example the
+  compiler wrappers in MPI implementations).
+* The logic does not search through module files, it can only detect
+  packages with executables defined in ``PATH``; you can help Spack locate
+  externals which use module files by loading any associated modules for
+  packages that you want Spack to know about before running
+  ``spack external find``.
+* Spack does not overwrite existing entries in the package configuration:
+  If there is an external defined for a spec at any configuration scope,
+  then Spack will not add a new external entry (``spack config blame packages``
+  can help locate all external entries).
+
+.. _concretization-preferences:
+
+--------------------------
+Concretization Preferences
+--------------------------
+
+Spack can be configured to prefer certain compilers, package
+versions, dependencies, and variants during concretization.
+The preferred configuration can be controlled via the
+``~/.spack/packages.yaml`` file for user configurations, or the
+``etc/spack/packages.yaml`` site configuration.
+
+Here's an example ``packages.yaml`` file that sets preferred packages:
+
+.. code-block:: yaml
+
+   packages:
+     opencv:
+       compiler: [gcc@4.9]
+       variants: +debug
+     gperftools:
+       version: [2.2, 2.4, 2.3]
+     all:
+       compiler: [gcc@4.4.7, 'gcc@4.6:', intel, clang, pgi]
+       target: [sandybridge]
+       providers:
+         mpi: [mvapich2, mpich, openmpi]
+
+At a high level, this example is specifying how packages should be
+concretized.  The opencv package should prefer using GCC 4.9 and
+be built with debug options.  The gperftools package should prefer version
+2.2 over 2.4.  Every package on the system should prefer mvapich2 for
+its MPI and GCC 4.4.7 (except for opencv, which overrides this by preferring GCC 4.9).
+These options are used to fill in implicit defaults.  Any of them can be overwritten
+on the command line if explicitly requested.
+
+Each ``packages.yaml`` file begins with the string ``packages:`` and
+package names are specified on the next level. The special string ``all``
+applies settings to *all* packages. Underneath each package name is one
+or more components: ``compiler``, ``variants``, ``version``,
+``providers``, and ``target``.  Each component has an ordered list of
+spec ``constraints``, with earlier entries in the list being preferred
+over later entries.
+
+Sometimes a package installation may have constraints that forbid
+the first concretization rule, in which case Spack will use the first
+legal concretization rule.  Going back to the example, if a user
+requests gperftools 2.3 or later, then Spack will install version 2.4
+as the 2.4 version of gperftools is preferred over 2.3.
+
+An explicit concretization rule in the preferred section will always
+take preference over unlisted concretizations.  In the above example,
+xlc isn't listed in the compiler list.  Every listed compiler from
+gcc to pgi will thus be preferred over the xlc compiler.
+
+The syntax for the ``provider`` section differs slightly from other
+concretization rules.  A provider lists a value that packages may
+``depend_on`` (e.g, MPI) and a list of rules for fulfilling that
+dependency.
+
+.. _package_permissions:
+
+-------------------
+Package Permissions
+-------------------
+
+Spack can be configured to assign permissions to the files installed
+by a package.
+
+In the ``packages.yaml`` file under ``permissions``, the attributes
+``read``, ``write``, and ``group`` control the package
+permissions. These attributes can be set per-package, or for all
+packages under ``all``. If permissions are set under ``all`` and for a
+specific package, the package-specific settings take precedence.
+
+The ``read`` and ``write`` attributes take one of ``user``, ``group``,
+and ``world``.
+
+.. code-block:: yaml
+
+  packages:
+    all:
+      permissions:
+        write: group
+        group: spack
+    my_app:
+      permissions:
+        read: group
+        group: my_team
+
+The permissions settings describe the broadest level of access to
+installations of the specified packages. The execute permissions of
+the file are set to the same level as read permissions for those files
+that are executable. The default setting for ``read`` is ``world``,
+and for ``write`` is ``user``. In the example above, installations of
+``my_app`` will be installed with user and group permissions but no
+world permissions, and owned by the group ``my_team``. All other
+packages will be installed with user and group write privileges, and
+world read privileges. Those packages will be owned by the group
+``spack``.
+
+The ``group`` attribute assigns a Unix-style group to a package. All
+files installed by the package will be owned by the assigned group,
+and the sticky group bit will be set on the install prefix and all
+directories inside the install prefix. This will ensure that even
+manually placed files within the install prefix are owned by the
+assigned group. If no group is assigned, Spack will allow the OS
+default behavior to go as expected.

lib/spack/docs/build_systems.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -39,7 +39,6 @@ on these ideas for each distinct build system that Spack supports:
 
    build_systems/autotoolspackage
    build_systems/cmakepackage
-   build_systems/cachedcmakepackage
    build_systems/mesonpackage
    build_systems/qmakepackage
    build_systems/sippackage
@@ -48,12 +47,10 @@ on these ideas for each distinct build system that Spack supports:
    :maxdepth: 1
    :caption: Language-specific
 
-   build_systems/luapackage
    build_systems/octavepackage
    build_systems/perlpackage
    build_systems/pythonpackage
    build_systems/rpackage
-   build_systems/racketpackage
    build_systems/rubypackage
 
 .. toctree::
@@ -62,11 +59,11 @@ on these ideas for each distinct build system that Spack supports:
 
    build_systems/bundlepackage
    build_systems/cudapackage
-   build_systems/custompackage
    build_systems/inteloneapipackage
    build_systems/intelpackage
    build_systems/rocmpackage
-   build_systems/sourceforgepackage
+   build_systems/custompackage
+   build_systems/multiplepackage
 
 For reference, the :py:mod:`Build System API docs <spack.build_systems>`
 provide a list of build systems and methods/attributes that can be

lib/spack/docs/build_systems/autotoolspackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _autotoolspackage:
 
----------
-Autotools
----------
+----------------
+AutotoolsPackage
+----------------
 
 Autotools is a GNU build system that provides a build-script generator.
 By running the platform-independent ``./configure`` script that comes
@@ -17,7 +17,7 @@ with the package, you can generate a platform-dependent Makefile.
 Phases
 ^^^^^^
 
-The ``AutotoolsBuilder`` and ``AutotoolsPackage`` base classes come with the following phases:
+The ``AutotoolsPackage`` base class comes with the following phases:
 
 #. ``autoreconf`` - generate the configure script
 #. ``configure`` - generate the Makefiles
@@ -127,9 +127,9 @@ check out a commit from the ``master`` branch, you would want to add:
 
 .. code-block:: python
 
-   depends_on("autoconf", type="build", when="@master")
-   depends_on("automake", type="build", when="@master")
-   depends_on("libtool",  type="build", when="@master")
+   depends_on('autoconf', type='build', when='@master')
+   depends_on('automake', type='build', when='@master')
+   depends_on('libtool',  type='build', when='@master')
 
 It is typically redundant to list the ``m4`` macro processor package as a
 dependency, since ``autoconf`` already depends on it.
@@ -145,7 +145,7 @@ example, the ``bash`` shell is used to run the ``autogen.sh`` script.
 .. code-block:: python
 
    def autoreconf(self, spec, prefix):
-       which("bash")("autogen.sh")
+       which('bash')('autogen.sh')
 
 """""""""""""""""""""""""""""""""""""""
 patching configure or Makefile.in files
@@ -186,9 +186,9 @@ To opt out of this feature, use the following setting:
 To enable it conditionally on different architectures, define a property and
 make the package depend on ``gnuconfig`` as a build dependency:
 
-.. code-block:: python
+.. code-block
 
-   depends_on("gnuconfig", when="@1.0:")
+   depends_on('gnuconfig', when='@1.0:')
 
    @property
    def patch_config_files(self):
@@ -230,7 +230,7 @@ version, this can be done like so:
 
    @property
    def force_autoreconf(self):
-       return self.version == Version("1.2.3")
+       return self.version == Version('1.2.3')
 
 ^^^^^^^^^^^^^^^^^^^^^^^
 Finding configure flags
@@ -278,22 +278,13 @@ function like so:
    def configure_args(self):
        args = []
 
-       if self.spec.satisfies("+mpi"):
-           args.append("--enable-mpi")
+       if '+mpi' in self.spec:
+           args.append('--enable-mpi')
        else:
-           args.append("--disable-mpi")
+           args.append('--disable-mpi')
 
        return args
 
-
-Alternatively, you can use the :ref:`enable_or_disable  <autotools_enable_or_disable>` helper:
-
-.. code-block:: python
-
-   def configure_args(self):
-       return [self.enable_or_disable("mpi")]
-
-
 Note that we are explicitly disabling MPI support if it is not
 requested. This is important, as many Autotools packages will enable
 options by default if the dependencies are found, and disable them
@@ -304,11 +295,9 @@ and `here <https://wiki.gentoo.org/wiki/Project:Quality_Assurance/Automagic_depe
 for a rationale as to why these so-called "automagic" dependencies
 are a problem.
 
-.. note::
-
-   By default, Autotools installs packages to ``/usr``. We don't want this,
-   so Spack automatically adds ``--prefix=/path/to/installation/prefix``
-   to your list of ``configure_args``. You don't need to add this yourself.
+By default, Autotools installs packages to ``/usr``. We don't want this,
+so Spack automatically adds ``--prefix=/path/to/installation/prefix``
+to your list of ``configure_args``. You don't need to add this yourself.
 
 ^^^^^^^^^^^^^^^^
 Helper functions
@@ -319,8 +308,6 @@ You may have noticed that most of the Autotools flags are of the form
 ``--without-baz``. Since these flags are so common, Spack provides a
 couple of helper functions to make your life easier.
 
-.. _autotools_enable_or_disable:
-
 """""""""""""""""
 enable_or_disable
 """""""""""""""""
@@ -332,11 +319,11 @@ typically used to enable or disable some feature within the package.
 .. code-block:: python
 
    variant(
-       "memchecker",
+       'memchecker',
        default=False,
-       description="Memchecker support for debugging [degrades performance]"
+       description='Memchecker support for debugging [degrades performance]'
    )
-   config_args.extend(self.enable_or_disable("memchecker"))
+   config_args.extend(self.enable_or_disable('memchecker'))
 
 In this example, specifying the variant ``+memchecker`` will generate
 the following configuration options:
@@ -356,15 +343,15 @@ the ``with_or_without`` method.
 .. code-block:: python
 
    variant(
-       "schedulers",
+       'schedulers',
        values=disjoint_sets(
-           ("auto",), ("alps", "lsf", "tm", "slurm", "sge", "loadleveler")
-       ).with_non_feature_values("auto", "none"),
+           ('auto',), ('alps', 'lsf', 'tm', 'slurm', 'sge', 'loadleveler')
+       ).with_non_feature_values('auto', 'none'),
        description="List of schedulers for which support is enabled; "
        "'auto' lets openmpi determine",
    )
-   if not spec.satisfies("schedulers=auto"):
-       config_args.extend(self.with_or_without("schedulers"))
+   if 'schedulers=auto' not in spec:
+       config_args.extend(self.with_or_without('schedulers'))
 
 In this example, specifying the variant ``schedulers=slurm,sge`` will
 generate the following configuration options:
@@ -389,16 +376,16 @@ generated, using the ``activation_value`` argument to
 .. code-block:: python
 
    variant(
-      "fabrics",
+      'fabrics',
        values=disjoint_sets(
-           ("auto",), ("psm", "psm2", "verbs", "mxm", "ucx", "libfabric")
-       ).with_non_feature_values("auto", "none"),
+           ('auto',), ('psm', 'psm2', 'verbs', 'mxm', 'ucx', 'libfabric')
+       ).with_non_feature_values('auto', 'none'),
        description="List of fabrics that are enabled; "
        "'auto' lets openmpi determine",
    )
-   if not spec.satisfies("fabrics=auto"):
-       config_args.extend(self.with_or_without("fabrics",
-           activation_value="prefix"))
+   if 'fabrics=auto' not in spec:
+       config_args.extend(self.with_or_without('fabrics',
+           activation_value='prefix'))
 
 ``activation_value`` accepts a callable that generates the configure
 parameter value given the variant value; but the special value
@@ -422,16 +409,16 @@ When Spack variants and configure flags do not correspond one-to-one, the
 
 .. code-block:: python
 
-   variant("debug_tools", default=False)
-   config_args += self.enable_or_disable("debug-tools", variant="debug_tools")
+   variant('debug_tools', default=False)
+   config_args += self.enable_or_disable('debug-tools', variant='debug_tools')
 
 Or when one variant controls multiple flags:
 
 .. code-block:: python
 
-   variant("debug_tools", default=False)
-   config_args += self.with_or_without("memchecker", variant="debug_tools")
-   config_args += self.with_or_without("profiler", variant="debug_tools")
+   variant('debug_tools', default=False)
+   config_args += self.with_or_without('memchecker', variant='debug_tools')
+   config_args += self.with_or_without('profiler', variant='debug_tools')
 
 
 """"""""""""""""""""
@@ -445,8 +432,8 @@ For example:
 
 .. code-block:: python
 
-   variant("profiler", when="@2.0:")
-   config_args += self.with_or_without("profiler")
+   variant('profiler', when='@2.0:')
+   config_args += self.with_or_without('profiler)
 
 will neither add ``--with-profiler`` nor ``--without-profiler`` when the version is
 below ``2.0``.
@@ -465,10 +452,10 @@ the variant values require atypical behavior.
    def with_or_without_verbs(self, activated):
        # Up through version 1.6, this option was named --with-openib.
        # In version 1.7, it was renamed to be --with-verbs.
-       opt = "verbs" if self.spec.satisfies("@1.7:") else "openib"
+       opt = 'verbs' if self.spec.satisfies('@1.7:') else 'openib'
        if not activated:
-           return f"--without-{opt}"
-       return f"--with-{opt}={self.spec['rdma-core'].prefix}"
+           return '--without-{0}'.format(opt)
+       return '--with-{0}={1}'.format(opt, self.spec['rdma-core'].prefix)
 
 Defining ``with_or_without_verbs`` overrides the behavior of a
 ``fabrics=verbs`` variant, changing the configure-time option to
@@ -492,7 +479,7 @@ do this like so:
 
 .. code-block:: python
 
-   configure_directory = "src"
+   configure_directory = 'src'
 
 ^^^^^^^^^^^^^^^^^^^^^^
 Building out of source
@@ -504,7 +491,7 @@ This can be done using the ``build_directory`` variable:
 
 .. code-block:: python
 
-   build_directory = "spack-build"
+   build_directory = 'spack-build'
 
 By default, Spack will build the package in the same directory that
 contains the ``configure`` script
@@ -527,8 +514,8 @@ library or build the documentation, you can add these like so:
 
 .. code-block:: python
 
-   build_targets = ["all", "docs"]
-   install_targets = ["install", "docs"]
+   build_targets = ['all', 'docs']
+   install_targets = ['install', 'docs']
 
 ^^^^^^^
 Testing

lib/spack/docs/build_systems/bundlepackage.rst

@@ -1,40 +1,17 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _bundlepackage:
 
-------
-Bundle
-------
+-------------
+BundlePackage
+-------------
 
-``BundlePackage`` represents a set of packages that are expected to work
-well together, such as a collection of commonly used software libraries.
-The associated software is specified as dependencies.
-
-If it makes sense, variants, conflicts, and requirements can be added to
-the package. :ref:`Variants <variants>` ensure that common build options
-are consistent across the packages supporting them.  :ref:`Conflicts
-and requirements <packaging_conflicts>` prevent attempts to build with known
-bugs or limitations.
-
-For example, if ``MyBundlePackage`` is known to only build on ``linux``,
-it could use the ``require`` directive as follows:
-
-.. code-block:: python
-
-    require("platform=linux", msg="MyBundlePackage only builds on linux")
-
-Spack has a number of built-in bundle packages, such as:
-
-* `AmdAocl <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/amd-aocl/package.py>`_
-* `EcpProxyApps <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/ecp-proxy-apps/package.py>`_
-* `Libc <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/libc/package.py>`_
-* `Xsdk <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/xsdk/package.py>`_
-
-where ``Xsdk`` also inherits from ``CudaPackage`` and ``RocmPackage`` and
-``Libc`` is a virtual bundle package for the C standard library.
+``BundlePackage`` represents a set of packages that are expected to work well
+together, such as a collection of commonly used software libraries.  The
+associated software is specified as bundle dependencies.
 
 
 ^^^^^^^^

lib/spack/docs/build_systems/cachedcmakepackage.rst

@@ -1,123 +0,0 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _cachedcmakepackage:
-
------------
-CachedCMake
------------
-
-The CachedCMakePackage base class is used for CMake-based workflows
-that create a CMake cache file prior to running ``cmake``. This is
-useful for packages with arguments longer than the system limit, and
-for reproducibility.
-
-The documentation for this class assumes that the user is familiar with
-the ``CMakePackage`` class from which it inherits. See the documentation
-for :ref:`CMakePackage <cmakepackage>`.
-
-^^^^^^
-Phases
-^^^^^^
-
-The ``CachedCMakePackage`` base class comes with the following phases:
-
-#. ``initconfig`` - generate the CMake cache file
-#. ``cmake`` - generate the Makefile
-#. ``build`` - build the package
-#. ``install`` - install the package
-
-By default, these phases run:
-
-.. code-block:: console
-
-   $ mkdir spack-build
-   $ cd spack-build
-   $ cat << EOF > name-arch-compiler@version.cmake
-   # Write information on compilers and dependencies
-   # includes information on mpi and cuda if applicable
-   $ cmake .. -DCMAKE_INSTALL_PREFIX=/path/to/installation/prefix -C name-arch-compiler@version.cmake
-   $ make
-   $ make test  # optional
-   $ make install
-
-The ``CachedCMakePackage`` class inherits from the ``CMakePackage``
-class, and accepts all of the same options and adds all of the same
-flags to the ``cmake`` command. Similar to the ``CMakePAckage`` class,
-you may need to add a few arguments yourself, and the
-``CachedCMakePackage`` provides the same interface to add those
-flags.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Adding entries to the CMake cache
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-In addition to adding flags to the ``cmake`` command, you may need to
-add entries to the CMake cache in the ``initconfig`` phase. This can
-be done by overriding one of four methods:
-
-#. ``CachedCMakePackage.initconfig_compiler_entries``
-#. ``CachedCMakePackage.initconfig_mpi_entries``
-#. ``CachedCMakePackage.initconfig_hardware_entries``
-#. ``CachedCMakePackage.initconfig_package_entries``
-
-Each of these methods returns a list of CMake cache strings. The
-distinction between these methods is merely to provide a
-well-structured and legible cmake cache file -- otherwise, entries
-from each of these methods are handled identically.
-
-Spack also provides convenience methods for generating CMake cache
-entries. These methods are available at module scope in every Spack
-package. Because CMake parses boolean options, strings, and paths
-differently, there are three such methods:
-
-#. ``cmake_cache_option``
-#. ``cmake_cache_string``
-#. ``cmake_cache_path``
-
-These methods each accept three parameters -- the name of the CMake
-variable associated with the entry, the value of the entry, and an
-optional comment -- and return strings in the appropriate format to be
-returned from any of the ``initconfig*`` methods. Additionally, these
-methods may return comments beginning with the ``#`` character.
-
-A typical usage of these methods may look something like this:
-
-.. code-block:: python
-
-   def initconfig_mpi_entries(self):
-       # Get existing MPI configurations
-       entries = super(self, Foo).initconfig_mpi_entries()
-
-       # The existing MPI configurations key on whether ``mpi`` is in the spec
-       # This spec has an MPI variant, and we need to enable MPI when it is on.
-       # This hypothetical package controls MPI with the ``FOO_MPI`` option to
-       # cmake.
-       if self.spec.satisfies("+mpi"):
-           entries.append(cmake_cache_option("FOO_MPI", True, "enable mpi"))
-       else:
-           entries.append(cmake_cache_option("FOO_MPI", False, "disable mpi"))
-
-   def initconfig_package_entries(self):
-       # Package specific options
-       entries = []
-
-       entries.append("#Entries for build options")
-
-       bar_on = self.spec.satisfies("+bar")
-       entries.append(cmake_cache_option("FOO_BAR", bar_on, "toggle bar"))
-
-       entries.append("#Entries for dependencies")
-
-       if self.spec["blas"].name == "baz":  # baz is our blas provider
-           entries.append(cmake_cache_string("FOO_BLAS", "baz", "Use baz"))
-           entries.append(cmake_cache_path("BAZ_PREFIX", self.spec["baz"].prefix))
-
-^^^^^^^^^^^^^^^^^^^^^^
-External documentation
-^^^^^^^^^^^^^^^^^^^^^^
-
-For more information on CMake cache files, see:
-https://cmake.org/cmake/help/latest/manual/cmake.1.html

lib/spack/docs/build_systems/cmakepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _cmakepackage:
 
------
-CMake
------
+------------
+CMakePackage
+------------
 
 Like Autotools, CMake is a widely-used build-script generator. Designed
 by Kitware, CMake is the most popular build system for new C, C++, and
@@ -21,7 +21,7 @@ whereas Autotools is Unix-only.
 Phases
 ^^^^^^
 
-The ``CMakeBuilder`` and ``CMakePackage`` base classes come with the following phases:
+The ``CMakePackage`` base class comes with the following phases:
 
 #. ``cmake`` - generate the Makefile
 #. ``build`` - build the package
@@ -82,7 +82,7 @@ class already contains:
 
 .. code-block:: python
 
-   depends_on("cmake", type="build")
+   depends_on('cmake', type='build')
 
 
 If you need to specify a particular version requirement, you can
@@ -90,7 +90,7 @@ override this in your package:
 
 .. code-block:: python
 
-   depends_on("cmake@2.8.12:", type="build")
+   depends_on('cmake@2.8.12:', type='build')
 
 
 ^^^^^^^^^^^^^^^^^^^
@@ -130,17 +130,17 @@ Adding flags to cmake
 To add additional flags to the ``cmake`` call, simply override the
 ``cmake_args`` function. The following example defines values for the flags
 ``WHATEVER``, ``ENABLE_BROKEN_FEATURE``, ``DETECT_HDF5``, and ``THREADS`` with
-and without the :meth:`~spack.build_systems.cmake.CMakeBuilder.define` and
-:meth:`~spack.build_systems.cmake.CMakeBuilder.define_from_variant` helper functions:
+and without the :meth:`~spack.build_systems.cmake.CMakePackage.define` and
+:meth:`~spack.build_systems.cmake.CMakePackage.define_from_variant` helper functions:
 
 .. code-block:: python
 
    def cmake_args(self):
        args = [
-           "-DWHATEVER:STRING=somevalue",
-           self.define("ENABLE_BROKEN_FEATURE", False),
-           self.define_from_variant("DETECT_HDF5", "hdf5"),
-           self.define_from_variant("THREADS"), # True if +threads
+           '-DWHATEVER:STRING=somevalue',
+           self.define('ENABLE_BROKEN_FEATURE', False),
+           self.define_from_variant('DETECT_HDF5', 'hdf5'),
+           self.define_from_variant('THREADS'), # True if +threads
        ]
 
        return args
@@ -151,93 +151,14 @@ and CMake simply ignores the empty command line argument. For example the follow
 
 .. code-block:: python
 
-   variant("example", default=True, when="@2.0:")
+   variant('example', default=True, when='@2.0:')
 
    def cmake_args(self):
-      return [self.define_from_variant("EXAMPLE", "example")]
+      return [self.define_from_variant('EXAMPLE', 'example')]
 
 will generate ``'cmake' '-DEXAMPLE=ON' ...`` when `@2.0: +example` is met, but will
 result in ``'cmake' '' ...`` when the spec version is below ``2.0``.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-CMake arguments provided by Spack
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The following default arguments are controlled by Spack:
-
-
-``CMAKE_INSTALL_PREFIX``
-------------------------
-
-Is set to the the package's install directory.
-
-
-``CMAKE_PREFIX_PATH``
----------------------
-
-CMake finds dependencies through calls to ``find_package()``, ``find_program()``,
-``find_library()``, ``find_file()``, and ``find_path()``, which use a list of search
-paths from ``CMAKE_PREFIX_PATH``. Spack sets this variable to a list of prefixes of the
-spec's transitive dependencies.
-
-For troubleshooting cases where CMake fails to find a dependency, add the
-``--debug-find`` flag to ``cmake_args``.
-
-``CMAKE_BUILD_TYPE``
---------------------
-
-Every CMake-based package accepts a ``-DCMAKE_BUILD_TYPE`` flag to
-dictate which level of optimization to use. In order to ensure
-uniformity across packages, the ``CMakePackage`` base class adds
-a variant to control this:
-
-.. code-block:: python
-
-   variant("build_type", default="RelWithDebInfo",
-           description="CMake build type",
-           values=("Debug", "Release", "RelWithDebInfo", "MinSizeRel"))
-
-However, not every CMake package accepts all four of these options.
-Grep the ``CMakeLists.txt`` file to see if the default values are
-missing or replaced. For example, the
-`dealii <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/dealii/package.py>`_
-package overrides the default variant with:
-
-.. code-block:: python
-
-   variant("build_type", default="DebugRelease",
-           description="The build type to build",
-           values=("Debug", "Release", "DebugRelease"))
-
-For more information on ``CMAKE_BUILD_TYPE``, see:
-https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
-
-
-``CMAKE_INSTALL_RPATH`` and ``CMAKE_INSTALL_RPATH_USE_LINK_PATH=ON``
---------------------------------------------------------------------
-
-CMake uses different RPATHs during the build and after installation, so that executables
-can locate the libraries they're linked to during the build, and installed executables
-do not have RPATHs to build directories. In Spack, we have to make sure that RPATHs are
-set properly after installation.
-
-Spack sets ``CMAKE_INSTALL_RPATH`` to a list of ``<prefix>/lib`` or ``<prefix>/lib64``
-directories of the spec's link-type dependencies. Apart from that, it sets
-``-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=ON``, which should add RPATHs for directories of
-linked libraries not in the directories covered by ``CMAKE_INSTALL_RPATH``.
-
-Usually it's enough to set only ``-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=ON``, but the
-reason to provide both options is that packages may dynamically open shared libraries,
-which CMake cannot detect. In those cases, the RPATHs from ``CMAKE_INSTALL_RPATH`` are
-used as search paths.
-
-.. note::
-
-   Some packages provide stub libraries, which contain an interface for linking without
-   an implementation. When using such libraries, it's best to override the option
-   ``-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=OFF`` in ``cmake_args``, so that stub libraries
-   are not used at runtime.
-
 
 ^^^^^^^^^^
 Generators
@@ -250,7 +171,7 @@ generator is Ninja. To switch to the Ninja generator, simply add:
 
 .. code-block:: python
 
-   generator("ninja")
+   generator = 'Ninja'
 
 
 ``CMakePackage`` defaults to "Unix Makefiles". If you switch to the
@@ -258,7 +179,7 @@ Ninja generator, make sure to add:
 
 .. code-block:: python
 
-   depends_on("ninja", type="build")
+   depends_on('ninja', type='build')
 
 to the package as well. Aside from that, you shouldn't need to do
 anything else. Spack will automatically detect that you are using
@@ -275,6 +196,36 @@ generators, but it should be simple to add support for alternative
 generators. For more information on CMake generators, see:
 https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html
 
+^^^^^^^^^^^^^^^^
+CMAKE_BUILD_TYPE
+^^^^^^^^^^^^^^^^
+
+Every CMake-based package accepts a ``-DCMAKE_BUILD_TYPE`` flag to
+dictate which level of optimization to use. In order to ensure
+uniformity across packages, the ``CMakePackage`` base class adds
+a variant to control this:
+
+.. code-block:: python
+
+   variant('build_type', default='RelWithDebInfo',
+           description='CMake build type',
+           values=('Debug', 'Release', 'RelWithDebInfo', 'MinSizeRel'))
+
+However, not every CMake package accepts all four of these options.
+Grep the ``CMakeLists.txt`` file to see if the default values are
+missing or replaced. For example, the
+`dealii <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/dealii/package.py>`_
+package overrides the default variant with:
+
+.. code-block:: python
+
+   variant('build_type', default='DebugRelease',
+           description='The build type to build',
+           values=('Debug', 'Release', 'DebugRelease'))
+
+For more information on ``CMAKE_BUILD_TYPE``, see:
+https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
+
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 CMakeLists.txt in a sub-directory
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -288,7 +239,7 @@ like so:
 
 .. code-block:: python
 
-   root_cmakelists_dir = "src"
+   root_cmakelists_dir = 'src'
 
 
 Note that this path is relative to the root of the extracted tarball,
@@ -304,7 +255,7 @@ different sub-directory, simply override ``build_directory`` like so:
 
 .. code-block:: python
 
-   build_directory = "my-build"
+   build_directory = 'my-build'
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 Build and install targets
@@ -324,8 +275,8 @@ library or build the documentation, you can add these like so:
 
 .. code-block:: python
 
-   build_targets = ["all", "docs"]
-   install_targets = ["install", "docs"]
+   build_targets = ['all', 'docs']
+   install_targets = ['install', 'docs']
 
 ^^^^^^^
 Testing

lib/spack/docs/build_systems/cudapackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _cudapackage:
 
-----
-Cuda
-----
+-----------
+CudaPackage
+-----------
 
 Different from other packages, ``CudaPackage`` does not represent a build system.
 Instead its goal is to simplify and unify usage of ``CUDA`` in other packages by providing a `mixin-class <https://en.wikipedia.org/wiki/Mixin>`_.
@@ -28,14 +28,11 @@ This package provides the following variants:
 
 * **cuda_arch**
 
-  This variant supports the optional specification of one or multiple architectures.
+  This variant supports the optional specification of the architecture.
   Valid values are maintained in the ``cuda_arch_values`` property and
   are the numeric character equivalent of the compute capability version
   (e.g., '10' for version 1.0). Each provided value affects associated
   ``CUDA`` dependencies and compiler conflicts.
-  
-  The variant builds both PTX code for the _virtual_ architecture
-  (e.g. ``compute_10``) and binary code for the _real_ architecture (e.g. ``sm_10``).
 
   GPUs and their compute capability versions are listed at
   https://developer.nvidia.com/cuda-gpus .
@@ -54,8 +51,8 @@ to terminate such build attempts with a suitable message:
 
 .. code-block:: python
 
-    conflicts("cuda_arch=none", when="+cuda",
-              msg="CUDA architecture is required")
+    conflicts('cuda_arch=none', when='+cuda',
+              msg='CUDA architecture is required')
 
 Similarly, if your software does not support all versions of the property,
 you could add ``conflicts`` to your package for those versions.  For example,
@@ -66,13 +63,13 @@ custom message should a user attempt such a build:
 .. code-block:: python
 
     unsupported_cuda_archs = [
-        "10", "11", "12", "13",
-        "20", "21",
-        "30", "32", "35", "37"
+        '10', '11', '12', '13',
+        '20', '21',
+        '30', '32', '35', '37'
     ]
     for value in unsupported_cuda_archs:
-        conflicts(f"cuda_arch={value}", when="+cuda",
-                  msg=f"CUDA architecture {value} is not supported")
+        conflicts('cuda_arch={0}'.format(value), when='+cuda',
+                  msg='CUDA architecture {0} is not supported'.format(value))
 
 ^^^^^^^
 Methods
@@ -83,7 +80,7 @@ standard CUDA compiler flags.
 
 **cuda_flags**
 
-    This built-in static method returns a list of command line flags
+    This built-in static method returns a list of command line flags 
     for the chosen ``cuda_arch`` value(s).  The flags are intended to
     be passed to the CUDA compiler driver (i.e., ``nvcc``).
 
@@ -107,16 +104,16 @@ class of your package.  For example, you can add it to your
             spec = self.spec
             args = []
             ...
-            if spec.satisfies("+cuda"):
+            if '+cuda' in spec:
                 # Set up the cuda macros needed by the build
-                args.append("-DWITH_CUDA=ON")
-                cuda_arch_list = spec.variants["cuda_arch"].value
+                args.append('-DWITH_CUDA=ON')
+                cuda_arch_list = spec.variants['cuda_arch'].value
                 cuda_arch = cuda_arch_list[0]
-                if cuda_arch != "none":
-                    args.append(f"-DCUDA_FLAGS=-arch=sm_{cuda_arch}")
+                if cuda_arch != 'none':
+                    args.append('-DCUDA_FLAGS=-arch=sm_{0}'.format(cuda_arch))
             else:
                 # Ensure build with cuda is disabled
-                args.append("-DWITH_CUDA=OFF")
+                args.append('-DWITH_CUDA=OFF')
             ...
             return args
 
@@ -125,7 +122,7 @@ You will need to customize options as needed for your build.
 
 This example also illustrates how to check for the ``cuda`` variant using
 ``self.spec`` and how to retrieve the ``cuda_arch`` variant's value, which
-is a list, using ``self.spec.variants["cuda_arch"].value``.
+is a list, using ``self.spec.variants['cuda_arch'].value``.
 
 With over 70 packages using ``CudaPackage`` as of January 2021 there are
 lots of examples to choose from to get more ideas for using this package.

lib/spack/docs/build_systems/custompackage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -57,13 +57,13 @@ If you look at the ``perl`` package, you'll see:
 
 .. code-block:: python
 
-   phases = ["configure", "build", "install"]
+   phases = ['configure', 'build', 'install']
 
 Similarly, ``cmake`` defines:
 
 .. code-block:: python
 
-   phases = ["bootstrap", "build", "install"]
+   phases = ['bootstrap', 'build', 'install']
 
 If we look at the ``cmake`` example, this tells Spack's ``PackageBase``
 class to run the ``bootstrap``, ``build``, and ``install`` functions
@@ -78,7 +78,7 @@ If we look at ``perl``, we see that it defines a ``configure`` method:
 .. code-block:: python
 
    def configure(self, spec, prefix):
-       configure = Executable("./Configure")
+       configure = Executable('./Configure')
        configure(*self.configure_args())
 
 There is also a corresponding ``configure_args`` function that handles
@@ -92,7 +92,7 @@ phases are pretty simple:
        make()
 
    def install(self, spec, prefix):
-       make("install")
+       make('install')
 
 The ``cmake`` package looks very similar, but with a ``bootstrap``
 function instead of ``configure``:
@@ -100,14 +100,14 @@ function instead of ``configure``:
 .. code-block:: python
 
    def bootstrap(self, spec, prefix):
-       bootstrap = Executable("./bootstrap")
+       bootstrap = Executable('./bootstrap')
        bootstrap(*self.bootstrap_args())
 
    def build(self, spec, prefix):
        make()
 
    def install(self, spec, prefix):
-       make("install")
+       make('install')
 
 Again, there is a ``boostrap_args`` function that determines the
 correct bootstrap flags to use.
@@ -128,16 +128,16 @@ before or after a particular phase. For example, in ``perl``, we see:
 
 .. code-block:: python
 
-   @run_after("install")
+   @run_after('install')
    def install_cpanm(self):
        spec = self.spec
 
-       if spec.satisfies("+cpanm"):
-           with working_dir(join_path("cpanm", "cpanm")):
-               perl = spec["perl"].command
-               perl("Makefile.PL")
+       if '+cpanm' in spec:
+           with working_dir(join_path('cpanm', 'cpanm')):
+               perl = spec['perl'].command
+               perl('Makefile.PL')
                make()
-               make("install")
+               make('install')
 
 This extra step automatically installs ``cpanm`` in addition to the
 base Perl installation.
@@ -174,10 +174,10 @@ In the ``perl`` package, we can see:
 
 .. code-block:: python
 
-   @run_after("build")
+   @run_after('build')
    @on_package_attributes(run_tests=True)
    def test(self):
-       make("test")
+       make('test')
 
 As you can guess, this runs ``make test`` *after* building the package,
 if and only if testing is requested. Again, this is not specific to
@@ -189,7 +189,7 @@ custom build systems, it can be added to existing build systems as well.
 
    .. code-block:: python
 
-      @run_after("install")
+      @run_after('install')
       @on_package_attributes(run_tests=True)
 
    works as expected. However, if you reverse the ordering:
@@ -197,7 +197,7 @@ custom build systems, it can be added to existing build systems as well.
    .. code-block:: python
 
       @on_package_attributes(run_tests=True)
-      @run_after("install")
+      @run_after('install')
 
    the tests will always be run regardless of whether or not
    ``--test=root`` is requested. See https://github.com/spack/spack/issues/3833

lib/spack/docs/build_systems/inteloneapipackage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -6,9 +6,9 @@
 .. _inteloneapipackage:
 
 
-===========
-IntelOneapi
-===========
+====================
+ IntelOneapiPackage
+====================
 
 
 .. contents::
@@ -25,18 +25,18 @@ use Spack to build packages with the tools.
 The Spack Python class ``IntelOneapiPackage`` is a base class that is
 used by ``IntelOneapiCompilers``, ``IntelOneapiMkl``,
 ``IntelOneapiTbb`` and other classes to implement the oneAPI
-packages. Search for ``oneAPI`` at `<packages.spack.io>`_ for the full
-list of available oneAPI packages, or use::
+packages. See the :ref:`package-list` for the full list of available
+oneAPI packages or use::
 
   spack list -d oneAPI
 
 For more information on a specific package, do::
 
-  spack info --all <package-name>
+  spack info <package-name>
 
 Intel no longer releases new versions of Parallel Studio, which can be
 used in Spack via the :ref:`intelpackage`. All of its components can
-now be found in oneAPI.
+now be found in oneAPI. 
 
 Examples
 ========
@@ -53,24 +53,18 @@ Install the oneAPI compilers::
 
 Add the compilers to your ``compilers.yaml`` so spack can use them::
 
-  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/bin
+  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/linux/bin/intel64
+  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/linux/bin
 
 Verify that the compilers are available::
 
   spack compiler list
 
-Note that 2024 and later releases do not include ``icc``. Before 2024,
-the package layout was different::
-  
-  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/linux/bin/intel64
-  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/linux/bin
-
 The ``intel-oneapi-compilers`` package includes 2 families of
 compilers:
 
 * ``intel``: ``icc``, ``icpc``, ``ifort``. Intel's *classic*
-  compilers. 2024 and later releases contain ``ifort``, but not
-  ``icc`` and ``icpc``.
+  compilers.
 * ``oneapi``: ``icx``, ``icpx``, ``ifx``. Intel's new generation of
   compilers based on LLVM.
 
@@ -82,55 +76,6 @@ To build with with ``icx``, do ::
 
   spack install patchelf%oneapi
 
-
-Using oneAPI Spack environment
--------------------------------
-
-In this example, we build lammps with ``icx`` using Spack environment for oneAPI packages created by Intel. The
-compilers are installed with Spack like in example above.
-
-Install the oneAPI compilers::
-
-  spack install intel-oneapi-compilers
-
-Add the compilers to your ``compilers.yaml`` so Spack can use them::
-
-  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/bin
-  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/bin
-
-Verify that the compilers are available::
-
-  spack compiler list
-
-Clone `spack-configs <https://github.com/spack/spack-configs>`_ repo and activate Intel oneAPI CPU environment::
-
-  git clone https://github.com/spack/spack-configs
-  spack env activate spack-configs/INTEL/CPU
-  spack concretize -f
-
-`Intel oneAPI CPU environment <https://github.com/spack/spack-configs/blob/main/INTEL/CPU/spack.yaml>`_  contains applications tested and validated by Intel, this list is constantly extended. And currently it supports:
-
-- `Devito <https://www.devitoproject.org/>`_
-- `GROMACS <https://www.gromacs.org/>`_
-- `HPCG <https://www.hpcg-benchmark.org/>`_
-- `HPL <https://netlib.org/benchmark/hpl/>`_
-- `LAMMPS <https://www.lammps.org/#gsc.tab=0>`_
-- `OpenFOAM <https://www.openfoam.com/>`_
-- `Quantum Espresso <https://www.quantum-espresso.org/>`_
-- `STREAM <https://www.cs.virginia.edu/stream/>`_
-- `WRF <https://github.com/wrf-model/WRF>`_
-
-To build lammps with oneAPI compiler from this environment just run::
-
-  spack install lammps
-
-Compiled binaries can be find using::
-
-  spack cd -i lammps
-
-You can do the same for all other applications from this environment.
-
-
 Using oneAPI MPI to Satisfy a Virtual Dependence
 ------------------------------------------------------
 
@@ -139,8 +84,8 @@ build ``hdf5`` with Intel oneAPI MPI do::
 
   spack install hdf5 +mpi ^intel-oneapi-mpi
 
-Using Externally Installed oneAPI Tools
-=======================================
+Using an Externally Installed oneAPI
+====================================
 
 Spack can also use oneAPI tools that are manually installed with
 `Intel Installers`_.  The procedures for configuring Spack to use
@@ -152,7 +97,8 @@ Compilers
 To use the compilers, add some information about the installation to
 ``compilers.yaml``. For most users, it is sufficient to do::
 
-  spack compiler add /opt/intel/oneapi/compiler/latest/bin
+  spack compiler add /opt/intel/oneapi/compiler/latest/linux/bin/intel64
+  spack compiler add /opt/intel/oneapi/compiler/latest/linux/bin
 
 Adapt the paths above if you did not install the tools in the default
 location. After adding the compilers, using them is the same
@@ -161,16 +107,10 @@ Another option is to manually add the configuration to
 ``compilers.yaml`` as described in :ref:`Compiler configuration
 <compiler-config>`.
 
-Before 2024, the directory structure was different::
-  
-  spack compiler add /opt/intel/oneapi/compiler/latest/linux/bin/intel64
-  spack compiler add /opt/intel/oneapi/compiler/latest/linux/bin
-
-
 Libraries
 ---------
 
-If you want Spack to use oneMKL that you have installed without Spack in
+If you want Spack to use MKL that you have installed without Spack in
 the default location, then add the following to
 ``~/.spack/packages.yaml``, adjusting the version as appropriate::
 
@@ -184,7 +124,7 @@ Using oneAPI Tools Installed by Spack
 =====================================
 
 Spack can be a convenient way to install and configure compilers and
-libraries, even if you do not intend to build a Spack package. If you
+libaries, even if you do not intend to build a Spack package. If you
 want to build a Makefile project using Spack-installed oneAPI compilers,
 then use spack to configure your environment::
 
@@ -199,7 +139,7 @@ You can also use Spack-installed libraries. For example::
   spack load intel-oneapi-mkl
 
 Will update your environment CPATH, LIBRARY_PATH, and other
-environment variables for building an application with oneMKL.
+environment variables for building an application with MKL.
 
 More information
 ================

lib/spack/docs/build_systems/intelpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _intelpackage:
 
------
-Intel
------
+------------
+IntelPackage
+------------
 
 .. contents::
 
@@ -15,9 +15,6 @@ Intel
 Intel packages in Spack
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
-This is an earlier version of Intel software development tools and has
-now been replaced by Intel oneAPI Toolkits.
-
 Spack can install and use several software development products offered by Intel.
 Some of these are available under no-cost terms, others require a paid license.
 All share the same basic steps for configuration, installation, and, where
@@ -90,7 +87,7 @@ and optimizers do require a paid license.  In Spack, they are packaged as:
     TODO: Confirm and possible change(!) the scope of MPI components (runtime
     vs. devel) in current (and previous?) *cluster/professional/composer*
     editions, i.e., presence in downloads, possibly subject to license
-    coverage(!); see `discussion in PR #4300
+    coverage(!); see `disussion in PR #4300
     <https://github.com/spack/spack/pull/4300#issuecomment-305582898>`_.  [NB:
     An "mpi" subdirectory is not indicative of the full MPI SDK being present
     (i.e., ``mpicc``, ..., and header files).  The directory may just as well
@@ -392,12 +389,12 @@ See section
 :ref:`Configuration Scopes <configuration-scopes>`
 for an explanation about the different files
 and section
-:ref:`Build customization <packages-config>`
+:ref:`Build customization <build-settings>`
 for specifics and examples for ``packages.yaml`` files.
 
 .. If your system administrator did not provide modules for pre-installed Intel
    tools, you could do well to ask for them, because installing multiple copies
-   of the Intel tools, as is won't to happen once Spack is in the picture, is
+   of the Intel tools, as is wont to happen once Spack is in the picture, is
    bound to stretch disk space and patience thin. If you *are* the system
    administrator and are still new to modules, then perhaps it's best to follow
    the `next section <Installing Intel tools within Spack_>`_ and install the tools
@@ -652,8 +649,8 @@ follow `the next section <intel-install-libs_>`_ instead.
 
    * If you specified a custom variant (for example ``+vtune``) you may want to add this as your
      preferred variant in the packages configuration for the ``intel-parallel-studio`` package
-     as described in :ref:`package-preferences`. Otherwise you will have to specify
-     the variant every time ``intel-parallel-studio`` is being used as ``mkl``, ``fftw`` or ``mpi``
+     as described in :ref:`concretization-preferences`. Otherwise you will have to specify
+     the variant everytime ``intel-parallel-studio`` is being used as ``mkl``, ``fftw`` or ``mpi``
      implementation to avoid pulling in a different variant.
 
    * To set the Intel compilers for default use in Spack, instead of the usual ``%gcc``,
@@ -814,13 +811,13 @@ by one of the following means:
      $ spack install libxc@3.0.0%intel
 
 
-* Alternatively, request Intel compilers implicitly by package preferences.
+* Alternatively, request Intel compilers implicitly by concretization preferences.
   Configure the order of compilers in the appropriate ``packages.yaml`` file,
   under either an ``all:`` or client-package-specific entry, in a
   ``compiler:`` list. Consult the Spack documentation for
   `Configuring Package Preferences <https://spack-tutorial.readthedocs.io/en/latest/tutorial_configuration.html#configuring-package-preferences>`_
   and
-  :ref:`Package Preferences <package-preferences>`.
+  :ref:`Concretization Preferences <concretization-preferences>`.
 
 Example: ``etc/spack/packages.yaml`` might simply contain:
 
@@ -870,7 +867,7 @@ virtual package, in order of decreasing preference.  To learn more about the
 ``providers:`` settings, see the Spack tutorial for
 `Configuring Package Preferences <https://spack-tutorial.readthedocs.io/en/latest/tutorial_configuration.html#configuring-package-preferences>`_
 and the section
-:ref:`Package Preferences <package-preferences>`.
+:ref:`Concretization Preferences <concretization-preferences>`.
 
 Example: The following fairly minimal example for ``packages.yaml`` shows how
 to exclusively use the standalone ``intel-mkl`` package for all the linear
@@ -934,9 +931,9 @@ a *virtual* ``mkl`` package is declared in Spack.
   .. code-block:: python
 
      # Examples for absolute and conditional dependencies:
-     depends_on("mkl")
-     depends_on("mkl", when="+mkl")
-     depends_on("mkl", when="fftw=mkl")
+     depends_on('mkl')
+     depends_on('mkl', when='+mkl')
+     depends_on('mkl', when='fftw=mkl')
 
   The ``MKLROOT`` environment variable (part of the documented API) will be set
   during all stages of client package installation, and is available to both
@@ -972,8 +969,8 @@ a *virtual* ``mkl`` package is declared in Spack.
       def configure_args(self):
           args = []
           ...
-          args.append("--with-blas=%s" % self.spec["blas"].libs.ld_flags)
-          args.append("--with-lapack=%s" % self.spec["lapack"].libs.ld_flags)
+          args.append('--with-blas=%s' % self.spec['blas'].libs.ld_flags)
+          args.append('--with-lapack=%s' % self.spec['lapack'].libs.ld_flags)
           ...
 
   .. tip::
@@ -989,13 +986,13 @@ a *virtual* ``mkl`` package is declared in Spack.
 
   .. code-block:: python
 
-    self.spec["blas"].headers.include_flags
+    self.spec['blas'].headers.include_flags
 
   and to generate linker options (``-L<dir> -llibname ...``), use the same as above,
 
   .. code-block:: python
 
-    self.spec["blas"].libs.ld_flags
+    self.spec['blas'].libs.ld_flags
 
   See
   :ref:`MakefilePackage <makefilepackage>`

lib/spack/docs/build_systems/luapackage.rst

@@ -1,105 +0,0 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _luapackage:
-
----
-Lua
----
-
-The ``Lua`` build-system is a helper for the common case of Lua packages that provide
-a rockspec file.  This is not meant to take a rock archive, but to build
-a source archive or repository that provides a rockspec, which should cover
-most lua packages. In the case a Lua package builds by Make rather than
-luarocks, prefer MakefilePackage.
-
-^^^^^^
-Phases
-^^^^^^
-
-The ``LuaBuilder`` and `LuaPackage`` base classes come with the following phases:
-
-#. ``unpack`` - if using a rock, unpacks the rock and moves into the source directory
-#. ``preprocess`` - adjust sources or rockspec to fix build
-#. ``install`` - install the project
-
-By default, these phases run:
-
-.. code-block:: console
-
-   # If the archive is a source rock
-   $ luarocks unpack <archive>.src.rock
-   $ # preprocess is a noop by default
-   $ luarocks make <name>.rockspec
-
-
-Any of these phases can be overridden in your package as necessary.
-
-^^^^^^^^^^^^^^^
-Important files
-^^^^^^^^^^^^^^^
-
-Packages that use the Lua/LuaRocks build system can be identified by the
-presence of a ``*.rockspec`` file in their sourcetree, or can be fetched as
-a source rock archive (``.src.rock``). This file declares things like build
-instructions and dependencies, the ``.src.rock`` also contains all code.
-
-It is common for the rockspec file to list the lua version required in
-a dependency. The LuaPackage class adds appropriate dependencies on a Lua
-implementation, but it is a good idea to specify the version required with
-a ``depends_on`` statement.  The block normally will be a table definition like
-this:
-
-.. code-block:: lua
-
-   dependencies = {
-      "lua >= 5.1",
-   }
-
-The LuaPackage class supports source repositories and archives containing
-a rockspec and directly downloading source rock files.  It *does not* support
-downloading dependencies listed inside a rockspec, and thus does not support
-directly downloading a rockspec as an archive.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^
-Build system dependencies
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-All base dependencies are added by the build system, but LuaRocks is run to
-avoid downloading extra Lua dependencies during build.  If the package needs
-Lua libraries outside the standard set, they should be added as dependencies.
-
-To specify a Lua version constraint but allow all lua implementations, prefer
-to use ``depends_on("lua-lang@5.1:5.1.99")`` to express any 5.1 compatible
-version. If the package requires LuaJit rather than Lua,
-a ``depends_on("luajit")`` should be used to ensure a LuaJit distribution is
-used instead of the Lua interpreter. Alternately, if only interpreted Lua will
-work ``depends_on("lua")`` will express that.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Passing arguments to luarocks make
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-If you need to pass any arguments to the ``luarocks make`` call, you can
-override the ``luarocks_args`` method like so:
-
-.. code-block:: python
-
-    def luarocks_args(self):
-        return ["flag1", "flag2"]
-
-One common use of this is to override warnings or flags for newer compilers, as in:
-
-.. code-block:: python
-
-    def luarocks_args(self):
-        return ["CFLAGS='-Wno-error=implicit-function-declaration'"]
-
-^^^^^^^^^^^^^^^^^^^^^^
-External documentation
-^^^^^^^^^^^^^^^^^^^^^^
-
-For more information on the LuaRocks build system, see:
-https://luarocks.org/

lib/spack/docs/build_systems/makefilepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _makefilepackage:
 
---------
-Makefile
---------
+---------------
+MakefilePackage
+---------------
 
 The most primitive build system a package can use is a plain Makefile.
 Makefiles are simple to write for small projects, but they usually
@@ -18,7 +18,7 @@ variables.
 Phases
 ^^^^^^
 
-The ``MakefileBuilder`` and ``MakefilePackage`` base classes come with 3 phases:
+The ``MakefilePackage`` base class comes with 3 phases:
 
 #. ``edit`` - edit the Makefile
 #. ``build`` - build the project
@@ -59,7 +59,7 @@ using GNU Make, you should add a dependency on ``gmake``:
 
 .. code-block:: python
 
-   depends_on("gmake", type="build")
+   depends_on('gmake', type='build')
 
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,13 +88,13 @@ command-line. However, Makefiles that use ``?=`` for assignment honor
 environment variables. Since Spack already sets ``CC``, ``CXX``, ``F77``,
 and ``FC``, you won't need to worry about setting these variables. If
 there are any other variables you need to set, you can do this in the
-``setup_build_environment`` method:
+``edit`` method:
 
 .. code-block:: python
 
-   def setup_build_environment(self, env):
-       env.set("PREFIX", prefix)
-       env.set("BLASLIB", spec["blas"].libs.ld_flags)
+   def edit(self, spec, prefix):
+       env['PREFIX'] = prefix
+       env['BLASLIB'] = spec['blas'].libs.ld_flags
 
 
 `cbench <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/cbench/package.py>`_
@@ -113,7 +113,7 @@ you can do this like so:
 
 .. code-block:: python
 
-   build_targets = ["CC=cc"]
+   build_targets = ['CC=cc']
 
 
 If you do need access to the spec, you can create a property like so:
@@ -125,8 +125,8 @@ If you do need access to the spec, you can create a property like so:
        spec = self.spec
 
        return [
-           "CC=cc",
-           f"BLASLIB={spec['blas'].libs.ld_flags}",
+           'CC=cc',
+           'BLASLIB={0}'.format(spec['blas'].libs.ld_flags),
        ]
 
 
@@ -140,17 +140,17 @@ Edit Makefile
 Some Makefiles are just plain stubborn and will ignore command-line
 variables. The only way to ensure that these packages build correctly
 is to directly edit the Makefile. Spack provides a ``FileFilter`` class
-and a ``filter`` method to help with this. For example:
+and a ``filter_file`` method to help with this. For example:
 
 .. code-block:: python
 
    def edit(self, spec, prefix):
-       makefile = FileFilter("Makefile")
+       makefile = FileFilter('Makefile')
 
-       makefile.filter(r"^\s*CC\s*=.*",  f"CC = {spack_cc}")
-       makefile.filter(r"^\s*CXX\s*=.*", f"CXX = {spack_cxx}")
-       makefile.filter(r"^\s*F77\s*=.*", f"F77 = {spack_f77}")
-       makefile.filter(r"^\s*FC\s*=.*",  f"FC = {spack_fc}")
+       makefile.filter(r'^\s*CC\s*=.*',  'CC = '  + spack_cc)
+       makefile.filter(r'^\s*CXX\s*=.*', 'CXX = ' + spack_cxx)
+       makefile.filter(r'^\s*F77\s*=.*', 'F77 = ' + spack_f77)
+       makefile.filter(r'^\s*FC\s*=.*',  'FC = '  + spack_fc)
 
 
 `stream <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/stream/package.py>`_
@@ -181,16 +181,16 @@ well for storing variables:
 
    def edit(self, spec, prefix):
        config = {
-           "CC": "cc",
-           "MAKE": "make",
+           'CC': 'cc',
+           'MAKE': 'make',
        }
 
-       if spec.satisfies("+blas"):
-           config["BLAS_LIBS"] = spec["blas"].libs.joined()
+       if '+blas' in spec:
+           config['BLAS_LIBS'] = spec['blas'].libs.joined()
 
-       with open("make.inc", "w") as inc:
+       with open('make.inc', 'w') as inc:
            for key in config:
-               inc.write(f"{key} = {config[key]}\n")
+               inc.write('{0} = {1}\n'.format(key, config[key]))
 
 
 `elk <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/elk/package.py>`_
@@ -204,14 +204,14 @@ them in a list:
 
    def edit(self, spec, prefix):
        config = [
-           f"INSTALL_DIR = {prefix}",
-           "INCLUDE_DIR = $(INSTALL_DIR)/include",
-           "LIBRARY_DIR = $(INSTALL_DIR)/lib",
+           'INSTALL_DIR = {0}'.format(prefix),
+           'INCLUDE_DIR = $(INSTALL_DIR)/include',
+           'LIBRARY_DIR = $(INSTALL_DIR)/lib',
        ]
 
-       with open("make.inc", "w") as inc:
+       with open('make.inc', 'w') as inc:
            for var in config:
-               inc.write(f"{var}\n")
+               inc.write('{0}\n'.format(var))
 
 
 `hpl <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/hpl/package.py>`_
@@ -284,7 +284,7 @@ can tell Spack where to locate it like so:
 
 .. code-block:: python
 
-   build_directory = "src"
+   build_directory = 'src'
 
 
 ^^^^^^^^^^^^^^^^^^^
@@ -299,8 +299,8 @@ install the package:
 
    def install(self, spec, prefix):
        mkdir(prefix.bin)
-       install("foo", prefix.bin)
-       install_tree("lib", prefix.lib)
+       install('foo', prefix.bin)
+       install_tree('lib', prefix.lib)
 
 
 ^^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/mavenpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _mavenpackage:
 
------
-Maven
------
+------------
+MavenPackage
+------------
 
 Apache Maven is a general-purpose build system that does not rely
 on Makefiles to build software. It is designed for building and
@@ -17,7 +17,7 @@ managing and Java-based project.
 Phases
 ^^^^^^
 
-The ``MavenBuilder`` and ``MavenPackage`` base classes come with the following phases:
+The ``MavenPackage`` base class comes with the following phases:
 
 #. ``build`` - compile code and package into a JAR file
 #. ``install`` - copy to installation prefix
@@ -48,8 +48,8 @@ class automatically adds the following dependencies:
 
 .. code-block:: python
 
-   depends_on("java", type=("build", "run"))
-   depends_on("maven", type="build")
+   depends_on('java', type=('build', 'run'))
+   depends_on('maven', type='build')
 
 
 In the ``pom.xml`` file, you may see sections like:
@@ -72,8 +72,8 @@ should add:
 
 .. code-block:: python
 
-   depends_on("java@7:", type="build")
-   depends_on("maven@3.5.4:", type="build")
+   depends_on('java@7:', type='build')
+   depends_on('maven@3.5.4:', type='build')
 
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,9 +88,9 @@ the build phase. For example:
 
    def build_args(self):
        return [
-           "-Pdist,native",
-           "-Dtar",
-           "-Dmaven.javadoc.skip=true"
+           '-Pdist,native',
+           '-Dtar',
+           '-Dmaven.javadoc.skip=true'
        ]
 
 

lib/spack/docs/build_systems/mesonpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _mesonpackage:
 
------
-Meson
------
+------------
+MesonPackage
+------------
 
 Much like Autotools and CMake, Meson is a build system.  But it is
 meant to be both fast and as user friendly as possible.  GNOME's goal
@@ -17,7 +17,7 @@ is to port modules to use the Meson build system.
 Phases
 ^^^^^^
 
-The ``MesonBuilder`` and ``MesonPackage`` base classes come with the following phases:
+The ``MesonPackage`` base class comes with the following phases:
 
 #. ``meson`` - generate ninja files
 #. ``build`` - build the project
@@ -86,8 +86,8 @@ the ``MesonPackage`` base class already contains:
 
 .. code-block:: python
 
-   depends_on("meson", type="build")
-   depends_on("ninja", type="build")
+   depends_on('meson', type='build')
+   depends_on('ninja', type='build')
 
 
 If you need to specify a particular version requirement, you can
@@ -95,8 +95,8 @@ override this in your package:
 
 .. code-block:: python
 
-   depends_on("meson@0.43.0:", type="build")
-   depends_on("ninja", type="build")
+   depends_on('meson@0.43.0:', type='build')
+   depends_on('ninja', type='build')
 
 
 ^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ override the ``meson_args`` method like so:
 .. code-block:: python
 
    def meson_args(self):
-       return ["--warnlevel=3"]
+       return ['--warnlevel=3']
 
 
 This method can be used to pass flags as well as variables.

lib/spack/docs/build_systems/multiplepackage.rst

@@ -0,0 +1,350 @@
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
+   Spack Project Developers. See the top-level COPYRIGHT file for details.
+
+   SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+.. _multiplepackage:
+
+----------------------
+Multiple Build Systems
+----------------------
+
+Quite frequently, a package will change build systems from one version to the
+next. For example, a small project that once used a single Makefile to build
+may now require Autotools to handle the increased number of files that need to
+be compiled. Or, a package that once used Autotools may switch to CMake for
+Windows support. In this case, it becomes a bit more challenging to write a
+single build recipe for this package in Spack.
+
+There are several ways that this can be handled in Spack:
+
+#. Subclass the new build system, and override phases as needed (preferred)
+#. Subclass ``Package`` and implement ``install`` as needed
+#. Create separate ``*-cmake``, ``*-autotools``, etc. packages for each build system
+#. Rename the old package to ``*-legacy`` and create a new package
+#. Move the old package to a ``legacy`` repository and create a new package
+#. Drop older versions that only support the older build system
+
+Of these options, 1 is preferred, and will be demonstrated in this
+documentation. Options 3-5 have issues with concretization, so shouldn't be
+used. Options 4-5 also don't support more than two build systems. Option 6 only
+works if the old versions are no longer needed. Option 1 is preferred over 2
+because it makes it easier to drop the old build system entirely.
+
+The exact syntax of the package depends on which build systems you need to
+support. Below are a couple of common examples.
+
+^^^^^^^^^^^^^^^^^^^^^
+Makefile -> Autotools
+^^^^^^^^^^^^^^^^^^^^^
+
+Let's say we have the following package:
+
+.. code-block:: python
+
+   class Foo(MakefilePackage):
+       version("1.2.0", sha256="...")
+
+       def edit(self, spec, prefix):
+           filter_file("CC=", "CC=" + spack_cc, "Makefile")
+
+       def install(self, spec, prefix):
+           install_tree(".", prefix)
+
+
+The package subclasses from :ref:`makefilepackage`, which has three phases:
+
+#. ``edit`` (does nothing by default)
+#. ``build`` (runs ``make`` by default)
+#. ``install`` (runs ``make install`` by default)
+
+In this case, the ``install`` phase needed to be overridden because the
+Makefile did not have an install target. We also modify the Makefile to use
+Spack's compiler wrappers. The default ``build`` phase is not changed.
+
+Starting with version 1.3.0, we want to use Autotools to build instead.
+:ref:`autotoolspackage` has four phases:
+
+#. ``autoreconf`` (does not if a configure script already exists)
+#. ``configure`` (runs ``./configure --prefix=...`` by default)
+#. ``build`` (runs ``make`` by default)
+#. ``install`` (runs ``make install`` by default)
+
+If the only version we need to support is 1.3.0, the package would look as
+simple as:
+
+.. code-block:: python
+
+   class Foo(AutotoolsPackage):
+       version("1.3.0", sha256="...")
+
+       def configure_args(self):
+           return ["--enable-shared"]
+
+
+In this case, we use the default methods for each phase and only override
+``configure_args`` to specify additional flags to pass to ``./configure``.
+
+If we wanted to write a single package that supports both versions 1.2.0 and
+1.3.0, it would look something like:
+
+.. code-block:: python
+
+   class Foo(AutotoolsPackage):
+       version("1.3.0", sha256="...")
+       version("1.2.0", sha256="...", deprecated=True)
+
+       def configure_args(self):
+           return ["--enable-shared"]
+
+       # Remove the following once version 1.2.0 is dropped
+       @when("@:1.2")
+       def patch(self):
+           filter_file("CC=", "CC=" + spack_cc, "Makefile")
+
+       @when("@:1.2")
+       def autoreconf(self, spec, prefix):
+           pass
+
+       @when("@:1.2")
+       def configure(self, spec, prefix):
+           pass
+
+       @when("@:1.2")
+       def install(self, spec, prefix):
+           install_tree(".", prefix)
+
+
+There are a few interesting things to note here:
+
+* We added ``deprecated=True`` to version 1.2.0. This signifies that version
+  1.2.0 is deprecated and shouldn't be used. However, if a user still relies
+  on version 1.2.0, it's still there and builds just fine.
+* We moved the contents of the ``edit`` phase to the ``patch`` function. Since
+  ``AutotoolsPackage`` doesn't have an ``edit`` phase, the only way for this
+  step to be executed is to move it to the ``patch`` function, which always
+  gets run.
+* The ``autoreconf`` and ``configure`` phases become no-ops. Since the old
+  Makefile-based build system doesn't use these, we ignore these phases when
+  building ``foo@1.2.0``.
+* The ``@when`` decorator is used to override these phases only for older
+  versions. The default methods are used for ``foo@1.3:``.
+
+Once a new Spack release comes out, version 1.2.0 and everything below the
+comment can be safely deleted. The result is the same as if we had written a
+package for version 1.3.0 from scratch.
+
+^^^^^^^^^^^^^^^^^^
+Autotools -> CMake
+^^^^^^^^^^^^^^^^^^
+
+Let's say we have the following package:
+
+.. code-block:: python
+
+   class Bar(AutotoolsPackage):
+       version("1.2.0", sha256="...")
+
+       def configure_args(self):
+           return ["--enable-shared"]
+
+
+The package subclasses from :ref:`autotoolspackage`, which has four phases:
+
+#. ``autoreconf`` (does not if a configure script already exists)
+#. ``configure`` (runs ``./configure --prefix=...`` by default)
+#. ``build`` (runs ``make`` by default)
+#. ``install`` (runs ``make install`` by default)
+
+In this case, we use the default methods for each phase and only override
+``configure_args`` to specify additional flags to pass to ``./configure``.
+
+Starting with version 1.3.0, we want to use CMake to build instead.
+:ref:`cmakepackage` has three phases:
+
+#. ``cmake`` (runs ``cmake ...`` by default)
+#. ``build`` (runs ``make`` by default)
+#. ``install`` (runs ``make install`` by default)
+
+If the only version we need to support is 1.3.0, the package would look as
+simple as:
+
+.. code-block:: python
+
+   class Bar(CMakePackage):
+       version("1.3.0", sha256="...")
+
+       def cmake_args(self):
+           return [self.define("BUILD_SHARED_LIBS", True)]
+
+
+In this case, we use the default methods for each phase and only override
+``cmake_args`` to specify additional flags to pass to ``cmake``.
+
+If we wanted to write a single package that supports both versions 1.2.0 and
+1.3.0, it would look something like:
+
+.. code-block:: python
+
+   class Bar(CMakePackage):
+       version("1.3.0", sha256="...")
+       version("1.2.0", sha256="...", deprecated=True)
+
+       def cmake_args(self):
+           return [self.define("BUILD_SHARED_LIBS", True)]
+
+       # Remove the following once version 1.2.0 is dropped
+       def configure_args(self):
+           return ["--enable-shared"]
+
+       @when("@:1.2")
+       def cmake(self, spec, prefix):
+           configure("--prefix=" + prefix, *self.configure_args())
+
+
+There are a few interesting things to note here:
+
+* We added ``deprecated=True`` to version 1.2.0. This signifies that version
+  1.2.0 is deprecated and shouldn't be used. However, if a user still relies
+  on version 1.2.0, it's still there and builds just fine.
+* Since CMake and Autotools are so similar, we only need to override the
+  ``cmake`` phase, we can use the default ``build`` and ``install`` phases.
+* We override ``cmake`` to run ``./configure`` for older versions.
+  ``configure_args`` remains the same.
+* The ``@when`` decorator is used to override these phases only for older
+  versions. The default methods are used for ``bar@1.3:``.
+
+Once a new Spack release comes out, version 1.2.0 and everything below the
+comment can be safely deleted. The result is the same as if we had written a
+package for version 1.3.0 from scratch.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multiple build systems for the same version
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+During the transition from one build system to another, developers often
+support multiple build systems at the same time. Spack can only use a single
+build system for a single version. To decide which build system to use for a
+particular version, take the following things into account:
+
+1. If the developers explicitly state that one build system is preferred over
+   another, use that one.
+2. If one build system is considered "experimental" while another is considered
+   "stable", use the stable build system.
+3. Otherwise, use the newer build system.
+
+The developer preference for which build system to use can change over time as
+a newer build system becomes stable/recommended.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Dropping support for old build systems
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When older versions of a package don't support a newer build system, it can be
+tempting to simply delete them from a package. This significantly reduces
+package complexity and makes the build recipe much easier to maintain. However,
+other packages or Spack users may rely on these older versions. The recommended
+approach is to first support both build systems (as demonstrated above),
+:ref:`deprecate <deprecate>` versions that rely on the old build system, and
+remove those versions and any phases that needed to be overridden in the next
+Spack release.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Three or more build systems
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In rare cases, a package may change build systems multiple times. For example,
+a package may start with Makefiles, then switch to Autotools, then switch to
+CMake. The same logic used above can be extended to any number of build systems.
+For example:
+
+.. code-block:: python
+
+   class Baz(CMakePackage):
+       version("1.4.0", sha256="...")  # CMake
+       version("1.3.0", sha256="...")  # Autotools
+       version("1.2.0", sha256="...")  # Makefile
+
+       def cmake_args(self):
+           return [self.define("BUILD_SHARED_LIBS", True)]
+
+       # Remove the following once version 1.3.0 is dropped
+       def configure_args(self):
+           return ["--enable-shared"]
+
+       @when("@1.3")
+       def cmake(self, spec, prefix):
+           configure("--prefix=" + prefix, *self.configure_args())
+
+       # Remove the following once version 1.2.0 is dropped
+       @when("@:1.2")
+       def patch(self):
+           filter_file("CC=", "CC=" + spack_cc, "Makefile")
+
+       @when("@:1.2")
+       def cmake(self, spec, prefix):
+           pass
+
+       @when("@:1.2")
+       def install(self, spec, prefix):
+           install_tree(".", prefix)
+
+
+^^^^^^^^^^^^^^^^^^^
+Additional examples
+^^^^^^^^^^^^^^^^^^^
+
+When writing new packages, it often helps to see examples of existing packages.
+Here is an incomplete list of existing Spack packages that have changed build
+systems before:
+
+================  =====================  ================
+Package           Previous Build System  New Build System
+================  =====================  ================
+amber             custom                 CMake
+arpack-ng         Autotools              CMake
+atk               Autotools              Meson
+blast             None                   Autotools
+dyninst           Autotools              CMake
+evtgen            Autotools              CMake
+fish              Autotools              CMake
+gdk-pixbuf        Autotools              Meson
+glib              Autotools              Meson
+glog              Autotools              CMake
+gmt               Autotools              CMake
+gtkplus           Autotools              Meson
+hpl               Makefile               Autotools
+interproscan      Perl                   Maven
+jasper            Autotools              CMake
+kahip             SCons                  CMake
+kokkos            Makefile               CMake
+kokkos-kernels    Makefile               CMake
+leveldb           Makefile               CMake
+libdrm            Autotools              Meson
+libjpeg-turbo     Autotools              CMake
+mesa              Autotools              Meson
+metis             None                   CMake
+mpifileutils      Autotools              CMake
+muparser          Autotools              CMake
+mxnet             Makefile               CMake
+nest              Autotools              CMake
+neuron            Autotools              CMake
+nsimd             CMake                  nsconfig
+opennurbs         Makefile               CMake
+optional-lite     None                   CMake
+plasma            Makefile               CMake
+preseq            Makefile               Autotools
+protobuf          Autotools              CMake
+py-pygobject      Autotools              Python
+singularity       Autotools              Makefile
+span-lite         None                   CMake
+ssht              Makefile               CMake
+string-view-lite  None                   CMake
+superlu           Makefile               CMake
+superlu-dist      Makefile               CMake
+uncrustify        Autotools              CMake
+================  =====================  ================
+
+Packages that support multiple build systems can be a bit confusing to write.
+Don't hesitate to open an issue or draft pull request and ask for advice from
+other Spack developers!

lib/spack/docs/build_systems/octavepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _octavepackage:
 
-------
-Octave
-------
+-------------
+OctavePackage
+-------------
 
 Octave has its own build system for installing packages.
 
@@ -15,7 +15,7 @@ Octave has its own build system for installing packages.
 Phases
 ^^^^^^
 
-The ``OctaveBuilder`` and ``OctavePackage`` base classes have a single phase:
+The ``OctavePackage`` base class has a single phase:
 
 #. ``install`` - install the package
 

lib/spack/docs/build_systems/perlpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _perlpackage:
 
-----
-Perl
-----
+-----------
+PerlPackage
+-----------
 
 Much like Octave, Perl has its own language-specific
 build system.
@@ -16,7 +16,7 @@ build system.
 Phases
 ^^^^^^
 
-The ``PerlBuilder`` and ``PerlPackage`` base classes come with 3 phases that can be overridden:
+The ``PerlPackage`` base class comes with 3 phases that can be overridden:
 
 #. ``configure`` - configure the package
 #. ``build`` - build the package
@@ -118,7 +118,7 @@ so ``PerlPackage`` contains:
 
 .. code-block:: python
 
-   extends("perl")
+   extends('perl')
 
 
 If your package requires a specific version of Perl, you should
@@ -132,14 +132,14 @@ properly. If your package uses ``Makefile.PL`` to build, add:
 
 .. code-block:: python
 
-   depends_on("perl-extutils-makemaker", type="build")
+   depends_on('perl-extutils-makemaker', type='build')
 
 
 If your package uses ``Build.PL`` to build, add:
 
 .. code-block:: python
 
-   depends_on("perl-module-build", type="build")
+   depends_on('perl-module-build', type='build')
 
 
 ^^^^^^^^^^^^^^^^^
@@ -165,80 +165,14 @@ arguments to ``Makefile.PL`` or ``Build.PL`` by overriding
 .. code-block:: python
 
    def configure_args(self):
-       expat = self.spec["expat"].prefix
+       expat = self.spec['expat'].prefix
 
        return [
-           "EXPATLIBPATH={0}".format(expat.lib),
-           "EXPATINCPATH={0}".format(expat.include),
+           'EXPATLIBPATH={0}'.format(expat.lib),
+           'EXPATINCPATH={0}'.format(expat.include),
        ]
 
 
-^^^^^^^
-Testing
-^^^^^^^
-
-``PerlPackage`` provides a simple stand-alone test of the successfully
-installed package to confirm that installed perl module(s) can be used.
-These tests can be performed any time after the installation using
-``spack -v test run``. (For more information on the command, see 
-:ref:`cmd-spack-test-run`.)
-
-The base class automatically detects perl modules based on the presence
-of ``*.pm`` files under the package's library directory. For example,
-the files under ``perl-bignum``'s perl library are:
-
-.. code-block:: console
-
-   $ find . -name "*.pm"
-   ./bigfloat.pm
-   ./bigrat.pm
-   ./Math/BigFloat/Trace.pm
-   ./Math/BigInt/Trace.pm
-   ./Math/BigRat/Trace.pm
-   ./bigint.pm
-   ./bignum.pm
-
-
-which results in the package having the ``use_modules`` property containing:
-
-.. code-block:: python
-
-   use_modules = [
-       "bigfloat",
-       "bigrat",
-       "Math::BigFloat::Trace",
-       "Math::BigInt::Trace",
-       "Math::BigRat::Trace",
-       "bigint",
-       "bignum",
-   ]
-
-.. note::
-
-   This list can often be used to catch missing dependencies.
-
-If the list is somehow wrong, you can provide the names of the modules
-yourself by overriding ``use_modules`` like so:
-
- .. code-block:: python
-
-    use_modules = ["bigfloat", "bigrat", "bigint", "bignum"]
-
-If you only want a subset of the automatically detected modules to be
-tested, you could instead define the ``skip_modules`` property on the
-package. So, instead of overriding ``use_modules`` as shown above, you
-could define the following:
-
- .. code-block:: python
-
-    skip_modules = [
-        "Math::BigFloat::Trace",
-        "Math::BigInt::Trace",
-        "Math::BigRat::Trace",
-    ]
-
-for the same use tests.
-
 ^^^^^^^^^^^^^^^^^^^^^
 Alternatives to Spack
 ^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/qmakepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _qmakepackage:
 
------
-QMake
------
+------------
+QMakePackage
+------------
 
 Much like Autotools and CMake, QMake is a build-script generator
 designed by the developers of Qt. In its simplest form, Spack's
@@ -29,7 +29,7 @@ variables or edit ``*.pro`` files to get things working properly.
 Phases
 ^^^^^^
 
-The ``QMakeBuilder`` and ``QMakePackage`` base classes come with the following phases:
+The ``QMakePackage`` base class comes with the following phases:
 
 #. ``qmake`` - generate Makefiles
 #. ``build`` - build the project
@@ -83,7 +83,7 @@ base class already contains:
 
 .. code-block:: python
 
-   depends_on("qt", type="build")
+   depends_on('qt', type='build')
 
 
 If you want to specify a particular version requirement, or need to
@@ -91,7 +91,7 @@ link to the ``qt`` libraries, you can override this in your package:
 
 .. code-block:: python
 
-   depends_on("qt@5.6.0:")
+   depends_on('qt@5.6.0:')
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 Passing arguments to qmake
@@ -103,7 +103,7 @@ override the ``qmake_args`` method like so:
 .. code-block:: python
 
    def qmake_args(self):
-       return ["-recursive"]
+       return ['-recursive']
 
 
 This method can be used to pass flags as well as variables.
@@ -118,7 +118,7 @@ sub-directory by adding the following to the package:
 
 .. code-block:: python
 
-   build_directory = "src"
+   build_directory = 'src'
 
 
 ^^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/racketpackage.rst

@@ -1,46 +0,0 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _racketpackage:
-
-------
-Racket
-------
-
-Much like Python, Racket packages and modules have their own special build system.
-To learn more about the specifics of Racket package system, please refer to the
-`Racket Docs <https://docs.racket-lang.org/pkg/cmdline.html>`_.
-
-^^^^^^
-Phases
-^^^^^^
-
-The ``RacketBuilder`` and ``RacketPackage`` base classes provides an ``install`` phase that
-can be overridden, corresponding to the use of:
-
-.. code-block:: console
-
-   $ raco pkg install
-
-^^^^^^^
-Caveats
-^^^^^^^
-
-In principle, ``raco`` supports a second, ``setup`` phase; however, we have not
-implemented this separately, as in normal circumstances, ``install`` also handles
-running ``setup`` automatically.
-
-Unlike Python, Racket currently on supports two installation scopes for packages, user
-or system, and keeps a registry of installed packages at each scope in its configuration files.
-This means we can't simply compose a "``RACKET_PATH``" environment variable listing all of the
-places packages are installed, and update this at will.
-
-Unfortunately this means that all currently installed packages which extend Racket via ``raco pkg install``
-are accessible whenever Racket is accessible.
-
-Additionally, because Spack does not implement uninstall hooks, uninstalling a Spack  ``rkt-`` package
-will have no effect on the ``raco`` installed packages visible to your Racket installation.
-Instead, you must manually run ``raco pkg remove`` to keep the two package managers in a mutually
-consistent state.

lib/spack/docs/build_systems/rocmpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _rocmpackage:
 
-----
-ROCm
-----
+-----------
+ROCmPackage
+-----------
 
 The ``ROCmPackage`` is not a build system but a helper package. Like ``CudaPackage``,
 it provides standard variants, dependencies, and conflicts to facilitate building
@@ -25,7 +25,7 @@ This package provides the following variants:
 
 * **rocm**
 
-  This variant is used to enable/disable building with ``rocm``.
+  This variant is used to enable/disable building with ``rocm``.  
   The default is disabled (or ``False``).
 
 * **amdgpu_target**
@@ -81,27 +81,28 @@ class of your package.  For example, you can add it to your
     class MyRocmPackage(CMakePackage, ROCmPackage):
         ...
         # Ensure +rocm and amdgpu_targets are passed to dependencies
-        depends_on("mydeppackage", when="+rocm")
+        depends_on('mydeppackage', when='+rocm')
         for val in ROCmPackage.amdgpu_targets:
-            depends_on(f"mydeppackage amdgpu_target={val}",
-                       when=f"amdgpu_target={val}")
+            depends_on('mydeppackage amdgpu_target={0}'.format(val),
+                       when='amdgpu_target={0}'.format(val))
         ...
 
         def cmake_args(self):
             spec = self.spec
             args = []
             ...
-            if spec.satisfies("+rocm"):
+            if '+rocm' in spec:
                 # Set up the hip macros needed by the build
                 args.extend([
-                    "-DENABLE_HIP=ON",
-                    f"-DHIP_ROOT_DIR={spec['hip'].prefix}"])
-                rocm_archs = spec.variants["amdgpu_target"].value
-                if "none" not in rocm_archs:
-                    args.append(f"-DHIP_HIPCC_FLAGS=--amdgpu-target={','.join(rocm_archs}")
+                    '-DENABLE_HIP=ON',
+                    '-DHIP_ROOT_DIR={0}'.format(spec['hip'].prefix])
+                rocm_archs = spec.variants['amdgpu_target'].value
+                if 'none' not in rocm_archs:
+                    args.append('-DHIP_HIPCC_FLAGS=--amdgpu-target={0}'
+                                .format(",".join(rocm_archs)))
             else:
                 # Ensure build with hip is disabled
-                args.append("-DENABLE_HIP=OFF")
+                args.append('-DENABLE_HIP=OFF')
             ...
             return args
         ...
@@ -113,7 +114,7 @@ build.
 
 This example also illustrates how to check for the ``rocm`` variant using
 ``self.spec`` and how to retrieve the ``amdgpu_target`` variant's value
-using ``self.spec.variants["amdgpu_target"].value``.
+using ``self.spec.variants['amdgpu_target'].value``.
 
 All five packages using ``ROCmPackage`` as of January 2021 also use the
 :ref:`CudaPackage <cudapackage>`. So it is worth looking at those packages

lib/spack/docs/build_systems/rpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _rpackage:
 
---
-R
---
+--------
+RPackage
+--------
 
 Like Python, R has its own built-in build system.
 
@@ -19,7 +19,7 @@ new Spack packages for.
 Phases
 ^^^^^^
 
-The ``RBuilder`` and ``RPackage`` base classes have a single phase:
+The ``RPackage`` base class has a single phase:
 
 #. ``install`` - install the package
 
@@ -163,28 +163,28 @@ attributes that can be used to set ``homepage``, ``url``, ``list_url``, and
 
 .. code-block:: python
 
-   cran = "caret"
+   cran = 'caret'
 
 is equivalent to:
 
 .. code-block:: python
 
-   homepage = "https://cloud.r-project.org/package=caret"
-   url      = "https://cloud.r-project.org/src/contrib/caret_6.0-86.tar.gz"
-   list_url = "https://cloud.r-project.org/src/contrib/Archive/caret"
+   homepage = 'https://cloud.r-project.org/package=caret'
+   url      = 'https://cloud.r-project.org/src/contrib/caret_6.0-86.tar.gz'
+   list_url = 'https://cloud.r-project.org/src/contrib/Archive/caret'
 
 Likewise, the following ``bioc`` attribute:
 
 .. code-block:: python
 
-   bioc = "BiocVersion"
+   bioc = 'BiocVersion'
 
 is equivalent to:
 
 .. code-block:: python
 
-   homepage = "https://bioconductor.org/packages/BiocVersion/"
-   git      = "https://git.bioconductor.org/packages/BiocVersion"
+   homepage = 'https://bioconductor.org/packages/BiocVersion/'
+   git      = 'https://git.bioconductor.org/packages/BiocVersion'
 
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,14 +193,14 @@ Build system dependencies
 
 As an extension of the R ecosystem, your package will obviously depend
 on R to build and run. Normally, we would use ``depends_on`` to express
-this, but for R packages, we use ``extends``. This implies a special
-dependency on R, which is used to set environment variables such as
-``R_LIBS`` uniformly. Since every R package needs this, the ``RPackage``
-base class contains:
+this, but for R packages, we use ``extends``. ``extends`` is similar to
+``depends_on``, but adds an additional feature: the ability to "activate"
+the package by symlinking it to the R installation directory. Since
+every R package needs this, the ``RPackage`` base class contains:
 
 .. code-block:: python
 
-   extends("r")
+   extends('r')
 
 
 Take a close look at the homepage for ``caret``. If you look at the
@@ -209,7 +209,7 @@ You should add this to your package like so:
 
 .. code-block:: python
 
-   depends_on("r@3.2.0:", type=("build", "run"))
+   depends_on('r@3.2.0:', type=('build', 'run'))
 
 
 ^^^^^^^^^^^^^^
@@ -227,7 +227,7 @@ and list all of their dependencies in the following sections:
 * LinkingTo
 
 As far as Spack is concerned, all 3 of these dependency types
-correspond to ``type=("build", "run")``, so you don't have to worry
+correspond to ``type=('build', 'run')``, so you don't have to worry
 about the details. If you are curious what they mean,
 https://github.com/spack/spack/issues/2951 has a pretty good summary:
 
@@ -330,7 +330,7 @@ the dependency:
 
 .. code-block:: python
 
-   depends_on("r-lattice@0.20:", type=("build", "run"))
+   depends_on('r-lattice@0.20:', type=('build', 'run'))
 
 
 ^^^^^^^^^^^^^^^^^^
@@ -361,20 +361,20 @@ like so:
 .. code-block:: python
 
    def configure_args(self):
-       mpi_name = self.spec["mpi"].name
+       mpi_name = self.spec['mpi'].name
 
        # The type of MPI. Supported values are:
        # OPENMPI, LAM, MPICH, MPICH2, or CRAY
-       if mpi_name == "openmpi":
-           Rmpi_type = "OPENMPI"
-       elif mpi_name == "mpich":
-           Rmpi_type = "MPICH2"
+       if mpi_name == 'openmpi':
+           Rmpi_type = 'OPENMPI'
+       elif mpi_name == 'mpich':
+           Rmpi_type = 'MPICH2'
        else:
-           raise InstallError("Unsupported MPI type")
+           raise InstallError('Unsupported MPI type')
 
        return [
-           "--with-Rmpi-type={0}".format(Rmpi_type),
-           "--with-mpi={0}".format(spec["mpi"].prefix),
+           '--with-Rmpi-type={0}'.format(Rmpi_type),
+           '--with-mpi={0}'.format(spec['mpi'].prefix),
        ]
 
 

lib/spack/docs/build_systems/rubypackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _rubypackage:
 
-----
-Ruby
-----
+-----------
+RubyPackage
+-----------
 
 Like Perl, Python, and R, Ruby has its own build system for
 installing Ruby gems.
@@ -16,7 +16,7 @@ installing Ruby gems.
 Phases
 ^^^^^^
 
-The ``RubyBuilder`` and ``RubyPackage`` base classes provide the following phases that
+The ``RubyPackage`` base class provides the following phases that
 can be overridden:
 
 #. ``build`` - build everything needed to install
@@ -84,8 +84,8 @@ The ``*.gemspec`` file may contain something like:
 
 .. code-block:: ruby
 
-   summary = "An implementation of the AsciiDoc text processor and publishing toolchain"
-   description = "A fast, open source text processor and publishing toolchain for converting AsciiDoc content to HTML 5, DocBook 5, and other formats."
+   summary = 'An implementation of the AsciiDoc text processor and publishing toolchain'
+   description = 'A fast, open source text processor and publishing toolchain for converting AsciiDoc content to HTML 5, DocBook 5, and other formats.'
 
 
 Either of these can be used for the description of the Spack package.
@@ -98,7 +98,7 @@ The ``*.gemspec`` file may contain something like:
 
 .. code-block:: ruby
 
-   homepage = "https://asciidoctor.org"
+   homepage = 'https://asciidoctor.org'
 
 
 This should be used as the official homepage of the Spack package.
@@ -112,21 +112,21 @@ the base class contains:
 
 .. code-block:: python
 
-   extends("ruby")
+   extends('ruby')
 
 
 The ``*.gemspec`` file may contain something like:
 
 .. code-block:: ruby
 
-   required_ruby_version = ">= 2.3.0"
+   required_ruby_version = '>= 2.3.0'
 
 
 This can be added to the Spack package using:
 
 .. code-block:: python
 
-   depends_on("ruby@2.3.0:", type=("build", "run"))
+   depends_on('ruby@2.3.0:', type=('build', 'run'))
 
 
 ^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/sconspackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _sconspackage:
 
------
-SCons
------
+------------
+SConsPackage
+------------
 
 SCons is a general-purpose build system that does not rely on
 Makefiles to build software. SCons is written in Python, and handles
@@ -42,7 +42,7 @@ As previously mentioned, SCons allows developers to add subcommands like
    $ scons install
 
 
-To facilitate this, the ``SConsBuilder`` and ``SconsPackage`` base classes provide the
+To facilitate this, the ``SConsPackage`` base class provides the
 following phases:
 
 #. ``build`` - build the package
@@ -57,7 +57,7 @@ overridden like so:
 .. code-block:: python
 
    def test(self):
-       scons("check")
+       scons('check')
 
 
 ^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ base class already contains:
 
 .. code-block:: python
 
-   depends_on("scons", type="build")
+   depends_on('scons', type='build')
 
 
 If you want to specify a particular version requirement, you can override
@@ -96,7 +96,7 @@ this in your package:
 
 .. code-block:: python
 
-   depends_on("scons@2.3.0:", type="build")
+   depends_on('scons@2.3.0:', type='build')
 
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -238,14 +238,14 @@ the package build phase. This is done by overriding ``build_args`` like so:
 
    def build_args(self, spec, prefix):
        args = [
-         f"PREFIX={prefix}",
-         f"ZLIB={spec['zlib'].prefix}",
+         'PREFIX={0}'.format(prefix),
+         'ZLIB={0}'.format(spec['zlib'].prefix),
        ]
 
-       if spec.satisfies("+debug"):
-           args.append("DEBUG=yes")
+       if '+debug' in spec:
+           args.append('DEBUG=yes')
        else:
-           args.append("DEBUG=no")
+           args.append('DEBUG=no')
 
        return args
 
@@ -275,8 +275,8 @@ environment variables. For example, cantera has the following option:
    * env_vars: [ string ]
        Environment variables to propagate through to SCons. Either the
        string "all" or a comma separated list of variable names, e.g.
-       "LD_LIBRARY_PATH,HOME".
-       - default: "LD_LIBRARY_PATH,PYTHONPATH"
+       'LD_LIBRARY_PATH,HOME'.
+       - default: 'LD_LIBRARY_PATH,PYTHONPATH'
 
 
 In the case of cantera, using ``env_vars=all`` allows us to use

lib/spack/docs/build_systems/sippackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _sippackage:
 
----
-SIP
----
+----------
+SIPPackage
+----------
 
 SIP is a tool that makes it very easy to create Python bindings for C and C++
 libraries. It was originally developed to create PyQt, the Python bindings for
@@ -22,7 +22,7 @@ provides support functions to the automatically generated code.
 Phases
 ^^^^^^
 
-The ``SIPBuilder`` and ``SIPPackage`` base classes come with the following phases:
+The ``SIPPackage`` base class comes with the following phases:
 
 #. ``configure`` - configure the package
 #. ``build`` - build the package
@@ -32,7 +32,7 @@ By default, these phases run:
 
 .. code-block:: console
 
-   $ sip-build --verbose --target-dir ...
+   $ python configure.py --bindir ... --destdir ...
    $ make
    $ make install
 
@@ -41,30 +41,30 @@ By default, these phases run:
 Important files
 ^^^^^^^^^^^^^^^
 
-Each SIP package comes with a custom configuration file written in Python.
-For newer packages, this is called ``project.py``, while in older packages,
-it may be called ``configure.py``. This script contains instructions to build
-the project.
+Each SIP package comes with a custom ``configure.py`` build script,
+written in Python. This script contains instructions to build the project.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 Build system dependencies
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-``SIPPackage`` requires several dependencies. Python and SIP are needed at build-time
-to run the aforementioned configure script. Python is also needed at run-time to
-actually use the installed Python library. And as we are building Python bindings
-for C/C++ libraries, Python is also needed as a link dependency. All of these
-dependencies are automatically added via the base class.
+``SIPPackage`` requires several dependencies. Python is needed to run
+the ``configure.py`` build script, and to run the resulting Python
+libraries. Qt is needed to provide the ``qmake`` command. SIP is also
+needed to build the package. All of these dependencies are automatically
+added via the base class
 
 .. code-block:: python
 
-   extends("python", type=("build", "link", "run"))
-   depends_on("py-sip", type="build")
+   extends('python')
 
+   depends_on('qt', type='build')
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Passing arguments to ``sip-build``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   depends_on('py-sip', type='build')
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Passing arguments to ``configure.py``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Each phase comes with a ``<phase_args>`` function that can be used to pass
 arguments to that particular phase. For example, if you need to pass
@@ -72,11 +72,11 @@ arguments to the configure phase, you can use:
 
 .. code-block:: python
 
-   def configure_args(self):
-       return ["--no-python-dbus"]
+   def configure_args(self, spec, prefix):
+       return ['--no-python-dbus']
 
 
-A list of valid options can be found by running ``sip-build --help``.
+A list of valid options can be found by running ``python configure.py --help``.
 
 ^^^^^^^
 Testing
@@ -124,7 +124,7 @@ are wrong, you can provide the names yourself by overriding
 
 .. code-block:: python
 
-   import_modules = ["PyQt5"]
+   import_modules = ['PyQt5']
 
 
 These tests often catch missing dependencies and non-RPATHed

lib/spack/docs/build_systems/sourceforgepackage.rst

@@ -1,55 +0,0 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _sourceforgepackage:
-
------------
-Sourceforge
------------
-
-``SourceforgePackage`` is a
-`mixin-class <https://en.wikipedia.org/wiki/Mixin>`_. It automatically
-sets the URL based on a list of Sourceforge mirrors listed in
-`sourceforge_mirror_path`, which defaults to a half dozen known mirrors.
-Refer to the package source
-(`<https://github.com/spack/spack/blob/develop/lib/spack/spack/build_systems/sourceforge.py>`__) for the current list of mirrors used by Spack.
-
-
-^^^^^^^
-Methods
-^^^^^^^
-
-This package provides a method for populating mirror URLs.
-
-**urls**
-
-    This method returns a list of possible URLs for package source.
-    It is decorated with `property` so its results are treated as
-    a package attribute.
-
-    Refer to
-    `<https://spack.readthedocs.io/en/latest/packaging_guide.html#mirrors-of-the-main-url>`__
-    for information on how Spack uses the `urls` attribute during
-    fetching.
-
-^^^^^
-Usage
-^^^^^
-
-This helper package can be added to your package by adding it as a base
-class of your package and defining the relative location of an archive
-file for one version of your software.
-
-.. code-block:: python
-   :emphasize-lines: 1,3
-
-    class MyPackage(AutotoolsPackage, SourceforgePackage):
-        ...
-        sourceforge_mirror_path = "my-package/mypackage.1.0.0.tar.gz"
-        ...
-
-Over 40 packages are using ``SourceforcePackage`` this mix-in as of
-July 2022 so there are multiple packages to choose from if you want
-to see a real example.

lib/spack/docs/build_systems/wafpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _wafpackage:
 
----
-Waf
----
+----------
+WafPackage
+----------
 
 Like SCons, Waf is a general-purpose build system that does not rely
 on Makefiles to build software.
@@ -16,7 +16,7 @@ on Makefiles to build software.
 Phases
 ^^^^^^
 
-The ``WafBuilder`` and ``WafPackage`` base classes come with the following phases:
+The ``WafPackage`` base class comes with the following phases:
 
 #. ``configure`` - configure the project
 #. ``build`` - build the project
@@ -58,13 +58,15 @@ Testing
 ``WafPackage`` also provides ``test`` and ``installtest`` methods,
 which are run after the ``build`` and ``install`` phases, respectively.
 By default, these phases do nothing, but you can override them to
-run package-specific unit tests.
+run package-specific unit tests. For example, the
+`py-py2cairo <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/py-py2cairo/package.py>`_
+package uses:
 
 .. code-block:: python
 
    def installtest(self):
-       with working_dir("test"):
-           pytest = which("py.test")
+       with working_dir('test'):
+           pytest = which('py.test')
            pytest()
 
 
@@ -93,7 +95,7 @@ the following dependency automatically:
 
 .. code-block:: python
 
-   depends_on("python@2.5:", type="build")
+   depends_on('python@2.5:', type='build')
 
 
 Waf only supports Python 2.5 and up.
@@ -113,7 +115,7 @@ phase, you can use:
        args = []
 
        if self.run_tests:
-           args.append("--test")
+           args.append('--test')
 
        return args
 

lib/spack/docs/chain.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)

lib/spack/docs/conf.py

@@ -1,4 +1,4 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -23,42 +23,43 @@
 import sys
 from glob import glob
 
-from docutils.statemachine import StringList
-from sphinx.domains.python import PythonDomain
 from sphinx.ext.apidoc import main as sphinx_apidoc
-from sphinx.parsers import RSTParser
 
 # -- Spack customizations -----------------------------------------------------
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-link_name = os.path.abspath("_spack_root")
-if not os.path.exists(link_name):
-    os.symlink(os.path.abspath("../../.."), link_name, target_is_directory=True)
-sys.path.insert(0, os.path.abspath("_spack_root/lib/spack/external"))
-sys.path.insert(0, os.path.abspath("_spack_root/lib/spack/external/_vendoring"))
-sys.path.append(os.path.abspath("_spack_root/lib/spack/"))
+sys.path.insert(0, os.path.abspath('_spack_root/lib/spack/external'))
+sys.path.insert(0, os.path.abspath('_spack_root/lib/spack/external/pytest-fallback'))
+
+if sys.version_info[0] < 3:
+    sys.path.insert(
+        0, os.path.abspath('_spack_root/lib/spack/external/yaml/lib'))
+else:
+    sys.path.insert(
+        0, os.path.abspath('_spack_root/lib/spack/external/yaml/lib3'))
+
+sys.path.append(os.path.abspath('_spack_root/lib/spack/'))
 
 # Add the Spack bin directory to the path so that we can use its output in docs.
-os.environ["SPACK_ROOT"] = os.path.abspath("_spack_root")
-os.environ["PATH"] += "%s%s" % (os.pathsep, os.path.abspath("_spack_root/bin"))
+os.environ['SPACK_ROOT'] = os.path.abspath('_spack_root')
+os.environ['PATH'] += "%s%s" % (os.pathsep, os.path.abspath('_spack_root/bin'))
 
 # Set an environment variable so that colify will print output like it would to
 # a terminal.
-os.environ["COLIFY_SIZE"] = "25x120"
-os.environ["COLUMNS"] = "120"
+os.environ['COLIFY_SIZE'] = '25x120'
+os.environ['COLUMNS'] = '120'
+
+# Generate full package list if needed
+subprocess.call([
+    'spack', 'list', '--format=html', '--update=package_list.html'])
 
 # Generate a command index if an update is needed
-subprocess.call(
-    [
-        "spack",
-        "commands",
-        "--format=rst",
-        "--header=command_index.in",
-        "--update=command_index.rst",
-    ]
-    + glob("*rst")
-)
+subprocess.call([
+    'spack', 'commands',
+    '--format=rst',
+    '--header=command_index.in',
+    '--update=command_index.rst'] + glob('*rst'))
 
 #
 # Run sphinx-apidoc
@@ -68,97 +69,73 @@
 # Without this, the API Docs will never actually update
 #
 apidoc_args = [
-    "--force",  # Overwrite existing files
-    "--no-toc",  # Don't create a table of contents file
-    "--output-dir=.",  # Directory to place all output
-    "--module-first",  # emit module docs before submodule docs
+    '--force',         # Overwrite existing files
+    '--no-toc',        # Don't create a table of contents file
+    '--output-dir=.',  # Directory to place all output
 ]
-sphinx_apidoc(
-    apidoc_args
-    + [
-        "_spack_root/lib/spack/spack",
-        "_spack_root/lib/spack/spack/test/*.py",
-        "_spack_root/lib/spack/spack/test/cmd/*.py",
-    ]
-)
-sphinx_apidoc(apidoc_args + ["_spack_root/lib/spack/llnl"])
+sphinx_apidoc(apidoc_args + ['_spack_root/lib/spack/spack'])
+sphinx_apidoc(apidoc_args + ['_spack_root/lib/spack/llnl'])
 
 # Enable todo items
 todo_include_todos = True
 
-
 #
 # Disable duplicate cross-reference warnings.
 #
+from sphinx.domains.python import PythonDomain
+
+
 class PatchedPythonDomain(PythonDomain):
     def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode):
-        if "refspecific" in node:
-            del node["refspecific"]
-        return super().resolve_xref(env, fromdocname, builder, typ, target, node, contnode)
-
-
-#
-# Disable tabs to space expansion in code blocks
-# since Makefiles require tabs.
-#
-class NoTabExpansionRSTParser(RSTParser):
-    def parse(self, inputstring, document):
-        if isinstance(inputstring, str):
-            lines = inputstring.splitlines()
-            inputstring = StringList(lines, document.current_source)
-        super().parse(inputstring, document)
-
+        if 'refspecific' in node:
+            del node['refspecific']
+        return super(PatchedPythonDomain, self).resolve_xref(
+            env, fromdocname, builder, typ, target, node, contnode)
 
 def setup(sphinx):
     sphinx.add_domain(PatchedPythonDomain, override=True)
-    sphinx.add_source_parser(NoTabExpansionRSTParser, override=True)
-
 
 # -- General configuration -----------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
-needs_sphinx = "3.4"
+needs_sphinx = '3.4'
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.graphviz",
-    "sphinx.ext.intersphinx",
-    "sphinx.ext.napoleon",
-    "sphinx.ext.todo",
-    "sphinx.ext.viewcode",
-    "sphinx_design",
-    "sphinxcontrib.programoutput",
+    'sphinx.ext.autodoc',
+    'sphinx.ext.graphviz',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.todo',
+    'sphinx.ext.viewcode',
+    'sphinxcontrib.programoutput',
 ]
 
 # Set default graphviz options
 graphviz_dot_args = [
-    "-Grankdir=LR",
-    "-Gbgcolor=transparent",
-    "-Nshape=box",
-    "-Nfontname=monaco",
-    "-Nfontsize=10",
-]
+    '-Grankdir=LR', '-Gbgcolor=transparent',
+    '-Nshape=box', '-Nfontname=monaco', '-Nfontsize=10']
 
 # Get nice vector graphics
 graphviz_output_format = "svg"
 
+
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ['_templates']
 
 # The suffix of source filenames.
-source_suffix = ".rst"
+source_suffix = '.rst'
 
 # The encoding of source files.
-source_encoding = "utf-8-sig"
+source_encoding = 'utf-8-sig'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 # General information about the project.
-project = "Spack"
-copyright = "2013-2023, Lawrence Livermore National Laboratory."
+project = u'Spack'
+copyright = u'2013-2021, Lawrence Livermore National Laboratory.'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -167,16 +144,16 @@ def setup(sphinx):
 # The short X.Y version.
 import spack
 
-version = ".".join(str(s) for s in spack.spack_version_info[:2])
+version = '.'.join(str(s) for s in spack.spack_version_info[:2])
 # The full version, including alpha/beta/rc tags.
 release = spack.spack_version
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
-# language = None
+#language = None
 
 # Places to look for .po/.mo files for doc translations
-# locale_dirs = []
+#locale_dirs = []
 
 # Sphinx gettext settings
 gettext_compact = True
@@ -184,184 +161,200 @@ def setup(sphinx):
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
-# today = ''
+#today = ''
 # Else, today_fmt is used as the format for a strftime call.
-# today_fmt = '%B %d, %Y'
+#today_fmt = '%B %d, %Y'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ["_build", "_spack_root", ".spack-env"]
+exclude_patterns = ['_build', '_spack_root', '.spack-env']
 
 nitpicky = True
 nitpick_ignore = [
     # Python classes that intersphinx is unable to resolve
-    ("py:class", "argparse.HelpFormatter"),
-    ("py:class", "contextlib.contextmanager"),
-    ("py:class", "module"),
-    ("py:class", "_io.BufferedReader"),
-    ("py:class", "_io.BytesIO"),
-    ("py:class", "unittest.case.TestCase"),
-    ("py:class", "_frozen_importlib_external.SourceFileLoader"),
-    ("py:class", "clingo.Control"),
-    ("py:class", "six.moves.urllib.parse.ParseResult"),
-    ("py:class", "TextIO"),
-    ("py:class", "hashlib._Hash"),
+    ('py:class', 'argparse.HelpFormatter'),
+    ('py:class', 'contextlib.contextmanager'),
+    ('py:class', 'module'),
+    ('py:class', '_io.BufferedReader'),
+    ('py:class', 'unittest.case.TestCase'),
+    ('py:class', '_frozen_importlib_external.SourceFileLoader'),
     # Spack classes that are private and we don't want to expose
-    ("py:class", "spack.provider_index._IndexBase"),
-    ("py:class", "spack.repo._PrependFileLoader"),
-    ("py:class", "spack.build_systems._checks.BaseBuilder"),
-    # Spack classes that intersphinx is unable to resolve
-    ("py:class", "spack.version.StandardVersion"),
-    ("py:class", "spack.spec.DependencySpec"),
-    ("py:class", "spack.spec.InstallStatus"),
-    ("py:class", "spack.spec.SpecfileReaderBase"),
-    ("py:class", "spack.install_test.Pb"),
-    ("py:class", "spack.filesystem_view.SimpleFilesystemView"),
+    ('py:class', 'spack.provider_index._IndexBase'),
 ]
 
 # The reST default role (used for this markup: `text`) to use for all documents.
-# default_role = None
+#default_role = None
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
-# add_function_parentheses = True
+#add_function_parentheses = True
 
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
-# add_module_names = True
+#add_module_names = True
 
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
-# show_authors = False
-sys.path.append("./_pygments")
-pygments_style = "style.SpackStyle"
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+# We use our own extension of the default style with a few modifications
+from pygments.style import Style
+from pygments.styles.default import DefaultStyle
+from pygments.token import Comment, Generic, Text
+
+
+class SpackStyle(DefaultStyle):
+    styles = DefaultStyle.styles.copy()
+    background_color       = "#f4f4f8"
+    styles[Generic.Output] = "#355"
+    styles[Generic.Prompt] = "bold #346ec9"
+
+import pkg_resources
+
+dist = pkg_resources.Distribution(__file__)
+sys.path.append('.')  # make 'conf' module findable
+ep = pkg_resources.EntryPoint.parse('spack = conf:SpackStyle', dist=dist)
+dist._ep_map = {'pygments.styles': {'plugin1': ep}}
+pkg_resources.working_set.add(dist)
+
+pygments_style = 'spack'
 
 # A list of ignored prefixes for module index sorting.
-# modindex_common_prefix = []
+#modindex_common_prefix = []
 
 
 # -- Options for HTML output ---------------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
-html_theme = "sphinx_rtd_theme"
+html_theme = 'sphinx_rtd_theme'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-html_theme_options = {"logo_only": True}
+html_theme_options = { 'logo_only' : True }
 
 # Add any paths that contain custom themes here, relative to this directory.
 # html_theme_path = ["_themes"]
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
-# html_title = None
+#html_title = None
 
 # A shorter title for the navigation bar.  Default is the same as html_title.
-# html_short_title = None
+#html_short_title = None
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-html_logo = "_spack_root/share/spack/logo/spack-logo-white-text.svg"
+html_logo = '_spack_root/share/spack/logo/spack-logo-white-text.svg'
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-html_favicon = "_spack_root/share/spack/logo/favicon.ico"
+html_favicon = '_spack_root/share/spack/logo/favicon.ico'
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
+html_static_path = ['_static']
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
-html_last_updated_fmt = "%b %d, %Y"
+html_last_updated_fmt = '%b %d, %Y'
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
-# html_use_smartypants = True
+#html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
-# html_sidebars = {}
+#html_sidebars = {}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
-# html_additional_pages = {}
+#html_additional_pages = {}
 
 # If false, no module index is generated.
-# html_domain_indices = True
+#html_domain_indices = True
 
 # If false, no index is generated.
-# html_use_index = True
+#html_use_index = True
 
 # If true, the index is split into individual pages for each letter.
-# html_split_index = False
+#html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
-# html_show_sourcelink = True
+#html_show_sourcelink = True
 
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-# html_show_sphinx = False
+#html_show_sphinx = False
 
 # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-# html_show_copyright = True
+#html_show_copyright = True
 
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
-# html_use_opensearch = ''
+#html_use_opensearch = ''
 
 # This is the file name suffix for HTML files (e.g. ".xhtml").
-# html_file_suffix = None
+#html_file_suffix = None
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "Spackdoc"
+htmlhelp_basename = 'Spackdoc'
+
 
 # -- Options for LaTeX output --------------------------------------------------
 
 latex_elements = {
-    # The paper size ('letterpaper' or 'a4paper').
-    # 'papersize': 'letterpaper',
-    # The font size ('10pt', '11pt' or '12pt').
-    # 'pointsize': '10pt',
-    # Additional stuff for the LaTeX preamble.
-    # 'preamble': '',
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
+
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
+
+# Additional stuff for the LaTeX preamble.
+#'preamble': '',
 }
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
-latex_documents = [("index", "Spack.tex", "Spack Documentation", "Todd Gamblin", "manual")]
+latex_documents = [
+  ('index', 'Spack.tex', u'Spack Documentation',
+   u'Todd Gamblin', 'manual'),
+]
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
-# latex_logo = None
+#latex_logo = None
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
-# latex_use_parts = False
+#latex_use_parts = False
 
 # If true, show page references after internal links.
-# latex_show_pagerefs = False
+#latex_show_pagerefs = False
 
 # If true, show URL addresses after external links.
-# latex_show_urls = False
+#latex_show_urls = False
 
 # Documents to append as an appendix to all manuals.
-# latex_appendices = []
+#latex_appendices = []
 
 # If false, no module index is generated.
-# latex_domain_indices = True
+#latex_domain_indices = True
 
 
 # -- Options for manual page output --------------------------------------------
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [("index", "spack", "Spack Documentation", ["Todd Gamblin"], 1)]
+man_pages = [
+    ('index', 'spack', u'Spack Documentation',
+     [u'Todd Gamblin'], 1)
+]
 
 # If true, show URL addresses after external links.
-# man_show_urls = False
+#man_show_urls = False
 
 
 # -- Options for Texinfo output ------------------------------------------------
@@ -370,28 +363,24 @@ def setup(sphinx):
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (
-        "index",
-        "Spack",
-        "Spack Documentation",
-        "Todd Gamblin",
-        "Spack",
-        "One line description of project.",
-        "Miscellaneous",
-    )
+  ('index', 'Spack', u'Spack Documentation',
+   u'Todd Gamblin', 'Spack', 'One line description of project.',
+   'Miscellaneous'),
 ]
 
 # Documents to append as an appendix to all manuals.
-# texinfo_appendices = []
+#texinfo_appendices = []
 
 # If false, no module index is generated.
-# texinfo_domain_indices = True
+#texinfo_domain_indices = True
 
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
-# texinfo_show_urls = 'footnote'
+#texinfo_show_urls = 'footnote'
 
 
 # -- Extension configuration -------------------------------------------------
 
 # sphinx.ext.intersphinx
-intersphinx_mapping = {"python": ("https://docs.python.org/3", None)}
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3", None),
+}

lib/spack/docs/config_yaml.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _config-yaml:
 
-============================
-Spack Settings (config.yaml)
-============================
+==============
+Basic Settings
+==============
 
 Spack's basic configuration options are set in ``config.yaml``.  You can
 see the default settings by looking at
@@ -19,9 +19,9 @@ see the default settings by looking at
 These settings can be overridden in ``etc/spack/config.yaml`` or
 ``~/.spack/config.yaml``.  See :ref:`configuration-scopes` for details.
 
----------------------
-``install_tree:root``
----------------------
+--------------------
+``install_tree``
+--------------------
 
 The location where Spack will install packages and their dependencies.
 Default is ``$spack/opt/spack``.
@@ -72,6 +72,21 @@ used to configure module names.
    packages have been installed will prevent Spack from being
    able to find the old installation directories.
 
+--------------------
+``module_roots``
+--------------------
+
+Controls where Spack installs generated module files.  You can customize
+the location for each type of module.  e.g.:
+
+.. code-block:: yaml
+
+   module_roots:
+     tcl:    $spack/share/spack/modules
+     lmod:   $spack/share/spack/lmod
+
+See :ref:`modules` for details.
+
 --------------------
 ``build_stage``
 --------------------
@@ -145,22 +160,6 @@ hosts when making ``ssl`` connections.  Set to ``false`` to disable, and
 tools like ``curl`` will use their ``--insecure`` options.  Disabling
 this can expose you to attacks.  Use at your own risk.
 
---------------------
-``ssl_certs``
---------------------
-
-Path to custom certificats for SSL verification. The value can be a 
-filesytem path, or an environment variable that expands to a file path.
-The default value is set to the environment variable ``SSL_CERT_FILE``
-to use the same syntax used by many other applications that automatically
-detect custom certificates.
-When ``url_fetch_method:curl`` the ``config:ssl_certs`` should resolve to
-a single file.  Spack will then set the environment variable ``CURL_CA_BUNDLE``
-in the subprocess calling ``curl``.
-If ``url_fetch_method:urllib`` then files and directories are supported i.e. 
-``config:ssl_certs:$SSL_CERT_FILE`` or ``config:ssl_certs:$SSL_CERT_DIR``
-will work.
-
 --------------------
 ``checksum``
 --------------------
@@ -238,11 +237,11 @@ and location. (See the *Configuration settings* section of ``man
 ccache`` to learn more about the default settings and how to change
 them). Please note that we currently disable ccache's ``hash_dir``
 feature to avoid an issue with the stage directory (see
-https://github.com/spack/spack/pull/3761#issuecomment-294352232).
+https://github.com/LLNL/spack/pull/3761#issuecomment-294352232).
 
------------------------
-``shared_linking:type``
------------------------
+------------------
+``shared_linking``
+------------------
 
 Control whether Spack embeds ``RPATH`` or ``RUNPATH`` attributes in ELF binaries
 so that they can find their dependencies. Has no effect on macOS.
@@ -261,76 +260,15 @@ the loading object.
 
 DO NOT MIX the two options within the same install tree.
 
------------------------
-``shared_linking:bind``
------------------------
-
-This is an *experimental option* that controls whether Spack embeds absolute paths
-to needed shared libraries in ELF executables and shared libraries on Linux. Setting
-this option to ``true`` has two advantages:
-
-1. **Improved startup time**: when running an executable, the dynamic loader does not
-   have to perform a search for needed libraries, they are loaded directly.
-2. **Reliability**: libraries loaded at runtime are those that were linked to. This
-   minimizes the risk of accidentally picking up system libraries.
-
-In the current implementation, Spack sets the soname (shared object name) of
-libraries to their install path upon installation. This has two implications:
-
-1. binding does not apply to libraries installed *before* the option was enabled;
-2. toggling the option off does *not* prevent binding of libraries installed when
-   the option was still enabled.
-
-It is also worth noting that:
-
-1. Applications relying on ``dlopen(3)`` will continue to work, even when they open
-   a library by name. This is because ``RPATH``\s are retained in binaries also
-   when ``bind`` is enabled.
-2. ``LD_PRELOAD`` continues to work for the typical use case of overriding
-   symbols, such as preloading a library with a more efficient ``malloc``.
-   However, the preloaded library will be loaded *additionally to*, instead of
-   *in place of* another library with the same name --- this can be problematic
-   in very rare cases where libraries rely on a particular ``init`` or ``fini``
-   order.
-
-.. note::
-
-   In some cases packages provide *stub libraries* that only contain an interface
-   for linking, but lack an implementation for runtime. An example of this is
-   ``libcuda.so``, provided by the CUDA toolkit; it can be used to link against,
-   but the library needed at runtime is the one installed with the CUDA driver.
-   To avoid binding those libraries, they can be marked as non-bindable using
-   a property in the package:
-
-   .. code-block:: python
-
-      class Example(Package):
-         non_bindable_shared_objects = ["libinterface.so"]
-
 ----------------------
-``install_status``
+``terminal_title``
 ----------------------
 
-When set to ``true``, Spack will show information about its current progress
-as well as the current and total package numbers. Progress is shown both
-in the terminal title and inline. Setting it to ``false`` will not show any
-progress information.
+By setting this option to ``true``, Spack will update the terminal's title to
+provide information about its current progress as well as the current and
+total package numbers.
 
 To work properly, this requires your terminal to reset its title after
 Spack has finished its work, otherwise Spack's status information will
 remain in the terminal's title indefinitely. Most terminals should already
 be set up this way and clear Spack's status information.
-
------------
-``aliases``
------------
-
-Aliases can be used to define new Spack commands. They can be either shortcuts
-for longer commands or include specific arguments for convenience. For instance,
-if users want to use ``spack install``'s ``-v`` argument all the time, they can
-create a new alias called ``inst`` that will always call ``install -v``:
-
-.. code-block:: yaml
-
-   aliases:
-     inst: install -v

lib/spack/docs/configuration.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -13,17 +13,12 @@ Spack has many configuration files.  Here is a quick list of them, in
 case you want to skip directly to specific docs:
 
 * :ref:`compilers.yaml <compiler-config>`
-* :ref:`concretizer.yaml <concretizer-options>`
 * :ref:`config.yaml <config-yaml>`
 * :ref:`mirrors.yaml <mirrors>`
 * :ref:`modules.yaml <modules>`
-* :ref:`packages.yaml <packages-config>`
+* :ref:`packages.yaml <build-settings>`
 * :ref:`repos.yaml <repositories>`
 
-You can also add any of these as inline configuration in the YAML
-manifest file (``spack.yaml``) describing an :ref:`environment
-<environment-configuration>`.
-
 -----------
 YAML Format
 -----------
@@ -38,6 +33,8 @@ Here is an example ``config.yaml`` file:
 
    config:
      install_tree: $spack/opt/spack
+     module_roots:
+       lmod: $spack/share/spack/lmod
      build_stage:
        - $tempdir/$user/spack-stage
        - ~/.spack/stage
@@ -73,12 +70,9 @@ are six configuration scopes. From lowest to highest:
    Spack instance per project) or for site-wide settings on a multi-user
    machine (e.g., for a common Spack instance).
 
-#. **plugin**: Read from a Python project's entry points. Settings here affect
-   all instances of Spack running with the same Python installation.  This scope takes higher precedence than site, system, and default scopes.
-
 #. **user**: Stored in the home directory: ``~/.spack/``. These settings
    affect all instances of Spack and take higher precedence than site,
-   system, plugin, or defaults scopes.
+   system, or defaults scopes.
 
 #. **custom**: Stored in a custom directory specified by ``--config-scope``.
    If multiple scopes are listed on the command line, they are ordered
@@ -199,45 +193,6 @@ with MPICH. You can create different configuration scopes for use with
                mpi: [mpich]
 
 
-.. _plugin-scopes:
-
-^^^^^^^^^^^^^
-Plugin scopes
-^^^^^^^^^^^^^
-
-.. note::
-   Python version >= 3.8 is required to enable plugin configuration.
-
-Spack can be made aware of configuration scopes that are installed as part of a python package.  To do so, register a function that returns the scope's path to the ``"spack.config"`` entry point.  Consider the Python package ``my_package`` that includes Spack configurations:
-
-.. code-block:: console
-
-  my-package/
-  ├── src
-  │   ├── my_package
-  │   │   ├── __init__.py
-  │   │   └── spack/
-  │   │   │   └── config.yaml
-  └── pyproject.toml
-
-adding the following to ``my_package``'s ``pyproject.toml`` will make ``my_package``'s ``spack/`` configurations visible to Spack when ``my_package`` is installed:
-
-.. code-block:: toml
-
-   [project.entry_points."spack.config"]
-   my_package = "my_package:get_config_path"
-
-The function ``my_package.get_extension_path`` in ``my_package/__init__.py`` might look like
-
-.. code-block:: python
-
-   import importlib.resources
-
-   def get_config_path():
-       dirname = importlib.resources.files("my_package").joinpath("spack")
-       if dirname.exists():
-           return str(dirname)
-
 .. _platform-scopes:
 
 ------------------------
@@ -270,9 +225,6 @@ You can get the name to use for ``<platform>`` by running ``spack arch
 --platform``. The system config scope has a ``<platform>`` section for
 sites at which ``/etc`` is mounted on multiple heterogeneous machines.
 
-
-.. _config-scope-precedence:
-
 ----------------
 Scope Precedence
 ----------------
@@ -285,13 +237,6 @@ lower-precedence settings. Completely ignoring higher-level configuration
 options is supported with the ``::`` notation for keys (see
 :ref:`config-overrides` below).
 
-There are also special notations for string concatenation and precendense override:
-
-* ``+:`` will force *prepending* strings or lists. For lists, this is the default behavior.
-* ``-:`` works similarly, but for *appending* values.
-
-:ref:`config-prepend-append`
-
 ^^^^^^^^^^^
 Simple keys
 ^^^^^^^^^^^
@@ -304,6 +249,8 @@ your configurations look like this:
 
    config:
      install_tree: $spack/opt/spack
+     module_roots:
+       lmod: $spack/share/spack/lmod
      build_stage:
        - $tempdir/$user/spack-stage
        - ~/.spack/stage
@@ -327,52 +274,13 @@ command:
    $ spack config get config
    config:
      install_tree: /some/other/directory
+     module_roots:
+       lmod: $spack/share/spack/lmod
      build_stage:
        - $tempdir/$user/spack-stage
        - ~/.spack/stage
 
 
-.. _config-prepend-append:
-
-^^^^^^^^^^^^^^^^^^^^
-String Concatenation
-^^^^^^^^^^^^^^^^^^^^
-
-Above, the user ``config.yaml`` *completely* overrides specific settings in the
-default ``config.yaml``. Sometimes, it is useful to add a suffix/prefix
-to a path or name. To do this, you can use the ``-:`` notation for *append*
-string concatenation at the end of a key in a configuration file. For example:
-
-.. code-block:: yaml
-   :emphasize-lines: 1
-   :caption: ~/.spack/config.yaml
-
-   config:
-     install_tree-: /my/custom/suffix/
-
-Spack will then append to the lower-precedence configuration under the
-``install_tree-:`` section:
-
-.. code-block:: console
-
-   $ spack config get config
-   config:
-     install_tree: /some/other/directory/my/custom/suffix
-     build_stage:
-       - $tempdir/$user/spack-stage
-       - ~/.spack/stage
-
-
-Similarly, ``+:`` can be used to *prepend* to a path or name:
-
-.. code-block:: yaml
-   :emphasize-lines: 1
-   :caption: ~/.spack/config.yaml
-
-   config:
-     install_tree+: /my/custom/suffix/
-
-
 .. _config-overrides:
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -433,11 +341,13 @@ higher-precedence scope is *prepended* to the defaults. ``spack config
 get config`` shows the result:
 
 .. code-block:: console
-   :emphasize-lines: 5-8
+   :emphasize-lines: 7-10
 
    $ spack config get config
    config:
      install_tree: /some/other/directory
+     module_roots:
+       lmod: $spack/share/spack/lmod
      build_stage:
        - /lustre-scratch/$user/spack
        - ~/mystage
@@ -461,11 +371,13 @@ user config looked like this:
 The merged configuration would look like this:
 
 .. code-block:: console
-   :emphasize-lines: 5-6
+   :emphasize-lines: 7-8
 
    $ spack config get config
    config:
      install_tree: /some/other/directory
+     module_roots:
+       lmod: $spack/share/spack/lmod
      build_stage:
        - /lustre-scratch/$user/spack
        - ~/mystage
@@ -488,7 +400,7 @@ are indicated at the start of the path with ``~`` or ``~user``.
 Spack-specific variables
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
-Spack understands over a dozen special variables. These are:
+Spack understands several special variables. These are:
 
 * ``$env``: name of the currently active :ref:`environment <environments>`
 * ``$spack``: path to the prefix of this Spack installation
@@ -499,19 +411,6 @@ Spack understands over a dozen special variables. These are:
 * ``$user``: name of the current user
 * ``$user_cache_path``: user cache directory (``~/.spack`` unless
   :ref:`overridden <local-config-overrides>`)
-* ``$architecture``: the architecture triple of the current host, as
-  detected by Spack.
-* ``$arch``: alias for ``$architecture``.
-* ``$platform``: the platform of the current host, as detected by Spack.
-* ``$operating_system``: the operating system of the current host, as
-  detected by the ``distro`` python module.
-* ``$os``: alias for ``$operating_system``.
-* ``$target``: the ISA target for the current host, as detected by
-  ArchSpec. E.g. ``skylake`` or ``neoverse-n1``.
-* ``$target_family``. The target family for the current host, as
-  detected by ArchSpec. E.g. ``x86_64`` or ``aarch64``.
-* ``$date``: the current date in the format YYYY-MM-DD
-
 
 Note that, as with shell variables, you can write these as ``$varname``
 or with braces to distinguish the variable from surrounding characters:
@@ -599,6 +498,9 @@ account all scopes. For example, to see the fully merged
      template_dirs:
      - $spack/templates
      directory_layout: {architecture}/{compiler.name}-{compiler.version}/{name}-{version}-{hash}
+     module_roots:
+       tcl: $spack/share/spack/modules
+       lmod: $spack/share/spack/lmod
      build_stage:
      - $tempdir/$user/spack-stage
      - ~/.spack/stage
@@ -646,6 +548,9 @@ down the problem:
    /home/myuser/spack/etc/spack/defaults/config.yaml:23    template_dirs:
    /home/myuser/spack/etc/spack/defaults/config.yaml:24    - $spack/templates
    /home/myuser/spack/etc/spack/defaults/config.yaml:28    directory_layout: {architecture}/{compiler.name}-{compiler.version}/{name}-{version}-{hash}
+   /home/myuser/spack/etc/spack/defaults/config.yaml:32    module_roots:
+   /home/myuser/spack/etc/spack/defaults/config.yaml:33      tcl: $spack/share/spack/modules
+   /home/myuser/spack/etc/spack/defaults/config.yaml:34      lmod: $spack/share/spack/lmod
    /home/myuser/spack/etc/spack/defaults/config.yaml:49    build_stage:
    /home/myuser/spack/etc/spack/defaults/config.yaml:50    - $tempdir/$user/spack-stage
    /home/myuser/spack/etc/spack/defaults/config.yaml:51    - ~/.spack/stage
@@ -656,7 +561,7 @@ down the problem:
 
 You can see above that the ``build_jobs`` and ``debug`` settings are
 built in and are not overridden by a configuration file. The
-``verify_ssl`` setting comes from the ``--insecure`` option on the
+``verify_ssl`` setting comes from the ``--insceure`` option on the
 command line. ``dirty`` and ``install_tree`` come from the custom
 scopes ``./my-scope`` and ``./my-scope-2``, and all other configuration
 options come from the default configuration files that ship with Spack.

lib/spack/docs/containers.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -9,96 +9,24 @@
 Container Images
 ================
 
-Spack :ref:`environments` can easily be turned into container images. This page
-outlines two ways in which this can be done:
-
-1. By installing the environment on the host system, and copying the installations
-   into the container image. This approach does not require any tools like Docker
-   or Singularity to be installed.
-2. By generating a Docker or Singularity recipe that can be used to build the
-   container image. In this approach, Spack builds the software inside the
-   container runtime, not on the host system.
-
-The first approach is easiest if you already have an installed environment,
-the second approach gives more control over the container image.
-
----------------------------
-From existing installations
----------------------------
-
-If you already have a Spack environment installed on your system, you can
-share the binaries as an OCI compatible container image. To get started you
-just have to configure and OCI registry and run ``spack buildcache push``.
-
-.. code-block:: console
-  
-   # Create and install an environment in the current directory
-   spack env create -d .
-   spack -e . add pkg-a pkg-b
-   spack -e . install
-
-   # Configure the registry
-   spack -e . mirror add --oci-username ... --oci-password ... container-registry oci://example.com/name/image
-
-   # Push the image
-   spack -e . buildcache push --update-index --base-image ubuntu:22.04 --tag my_env container-registry
-
-The resulting container image can then be run as follows:
-
-.. code-block:: console
-
-   $ docker run -it example.com/name/image:my_env
-
-The image generated by Spack consists of the specified base image with each package from the
-environment as a separate layer on top. The image is minimal by construction, it only contains the
-environment roots and its runtime dependencies.
-
-.. note::
-
-  When using registries like GHCR and Docker Hub, the ``--oci-password`` flag is not
-  the password for your account, but a personal access token you need to generate separately.
-
-The specified ``--base-image`` should have a libc that is compatible with the host system.
-For example if your host system is Ubuntu 20.04, you can use ``ubuntu:20.04``, ``ubuntu:22.04``
-or newer: the libc in the container image must be at least the version of the host system,
-assuming ABI compatibility. It is also perfectly fine to use a completely different
-Linux distribution as long as the libc is compatible.
-
-For convenience, Spack also turns the OCI registry into a :ref:`build cache <binary_caches_oci>`,
-so that future ``spack install`` of the environment will simply pull the binaries from the
-registry instead of doing source builds. The flag ``--update-index`` is needed to make Spack
-take the build cache into account when concretizing.
-
-.. note::
-
-  When generating container images in CI, the approach above is recommended when CI jobs
-  already run in a sandboxed environment. You can simply use ``spack`` directly
-  in the CI job and push the resulting image to a registry. Subsequent CI jobs should
-  run faster because Spack can install from the same registry instead of rebuilding from
-  sources.
-
----------------------------------------------
-Generating recipes for Docker and Singularity
----------------------------------------------
-
-Apart from copying existing installations into container images, Spack can also
-generate recipes for container images. This is useful if you want to run Spack
-itself in a sandboxed environment instead of on the host system.
-
-Since recipes need a little bit more boilerplate than
+Spack :ref:`environments` are a great tool to create container images, but
+preparing one that is suitable for production requires some more boilerplate
+than just:
 
 .. code-block:: docker
 
    COPY spack.yaml /environment
    RUN spack -e /environment install
 
-Spack provides a command to generate customizable recipes for container images. Customizations
-include minimizing the size of the image, installing packages in the base image using the system
-package manager, and setting up a proper entrypoint to run the image.
+Additional actions may be needed to minimize the size of the
+container, or to update the system software that is installed in the base
+image, or to set up a proper entrypoint to run the image. These tasks are
+usually both necessary and repetitive, so Spack comes with a command
+to generate recipes for container images starting from a ``spack.yaml``.
 
-~~~~~~~~~~~~~~~~~~~~
+--------------------
 A Quick Introduction
-~~~~~~~~~~~~~~~~~~~~
+--------------------
 
 Consider having a Spack environment like the following:
 
@@ -109,8 +37,8 @@ Consider having a Spack environment like the following:
      - gromacs+mpi
      - mpich
 
-Producing a ``Dockerfile`` from it is as simple as changing directories to
-where the ``spack.yaml`` file is stored and running the following command:
+Producing a ``Dockerfile`` from it is as simple as moving to the directory
+where the ``spack.yaml`` file is stored and giving the following command:
 
 .. code-block:: console
 
@@ -131,8 +59,7 @@ other techniques to minimize the size of the final image:
    &&   echo "  specs:" \
    &&   echo "  - gromacs+mpi" \
    &&   echo "  - mpich" \
-   &&   echo "  concretizer:" \
-   &&   echo "    unify: true" \
+   &&   echo "  concretization: together" \
    &&   echo "  config:" \
    &&   echo "    install_tree: /opt/software" \
    &&   echo "  view: /opt/view") > /opt/spack-environment/spack.yaml
@@ -176,15 +103,14 @@ configuration are discussed in details in the sections below.
 
 .. _container_spack_images:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------
 Spack Images on Docker Hub
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------
 
 Docker images with Spack preinstalled and ready to be used are
-built when a release is tagged, or nightly on ``develop``. The images
-are then pushed both to `Docker Hub <https://hub.docker.com/u/spack>`_
-and to `GitHub Container Registry <https://github.com/orgs/spack/packages?repo_name=spack>`_.
-The OS that are currently supported are summarized in the table below:
+built on `Docker Hub <https://hub.docker.com/u/spack>`_
+at every push to ``develop`` or to a release branch. The OS that
+are currently supported are summarized in the table below:
 
 .. _containers-supported-os:
 
@@ -194,57 +120,19 @@ The OS that are currently supported are summarized in the table below:
    * - Operating System
      - Base Image
      - Spack Image
+   * - Ubuntu 16.04
+     - ``ubuntu:16.04``
+     - ``spack/ubuntu-xenial``
    * - Ubuntu 18.04
      - ``ubuntu:18.04``
      - ``spack/ubuntu-bionic``
-   * - Ubuntu 20.04
-     - ``ubuntu:20.04``
-     - ``spack/ubuntu-focal``
-   * - Ubuntu 22.04
-     - ``ubuntu:22.04``
-     - ``spack/ubuntu-jammy``
    * - CentOS 7
      - ``centos:7``
      - ``spack/centos7``
-   * - CentOS Stream
-     - ``quay.io/centos/centos:stream``
-     - ``spack/centos-stream``
-   * - openSUSE Leap
-     - ``opensuse/leap``
-     - ``spack/leap15``
-   * - Amazon Linux 2
-     - ``amazonlinux:2``
-     - ``spack/amazon-linux``
-   * - AlmaLinux 8
-     - ``almalinux:8``
-     - ``spack/almalinux8``
-   * - AlmaLinux 9
-     - ``almalinux:9``
-     - ``spack/almalinux9``
-   * - Rocky Linux 8
-     - ``rockylinux:8``
-     - ``spack/rockylinux8``
-   * - Rocky Linux 9
-     - ``rockylinux:9``
-     - ``spack/rockylinux9``
-   * - Fedora Linux 37
-     - ``fedora:37``
-     - ``spack/fedora37``
-   * - Fedora Linux 38
-     - ``fedora:38``
-     - ``spack/fedora38``
-   * - Fedora Linux 39
-     - ``fedora:39``
-     - ``spack/fedora39``
-   * - Fedora Linux 40
-     - ``fedora:40``
-     - ``spack/fedora40``
-
-
 
 All the images are tagged with the corresponding release of Spack:
 
-.. image:: images/ghcr_spack.png
+.. image:: dockerhub_spack.png
 
 with the exception of the ``latest`` tag that points to the HEAD
 of the ``develop`` branch. These images are available for anyone
@@ -254,9 +142,9 @@ by Spack use them as default base images for their ``build`` stage,
 even though handles to use custom base images provided by users are
 available to accommodate complex use cases.
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Configuring the Container Recipe
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------------
+Creating Images From Environments
+---------------------------------
 
 Any Spack Environment can be used for the automatic generation of container
 recipes. Sensible defaults are provided for things like the base image or the
@@ -290,25 +178,31 @@ under the ``container`` attribute of environments:
          final:
          - libgomp
 
+       # Extra instructions
+       extra_instructions:
+         final: |
+           RUN echo 'export PS1="\[$(tput bold)\]\[$(tput setaf 1)\][gromacs]\[$(tput setaf 2)\]\u\[$(tput sgr0)\]:\w $ "' >> ~/.bashrc
+
        # Labels for the image
        labels:
          app: "gromacs"
          mpi: "mpich"
 
-A detailed description of the options available can be found in the :ref:`container_config_options` section.
+A detailed description of the options available can be found in the
+:ref:`container_config_options` section.
 
-~~~~~~~~~~~~~~~~~~~
+-------------------
 Setting Base Images
-~~~~~~~~~~~~~~~~~~~
+-------------------
 
 The ``images`` subsection is used to select both the image where
 Spack builds the software and the image where the built software
 is installed. This attribute can be set in different ways and
 which one to use depends on the use case at hand.
 
-""""""""""""""""""""""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Use Official Spack Images From Dockerhub
-""""""""""""""""""""""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 To generate a recipe that uses an official Docker image from the
 Spack organization to build the software and the corresponding official OS image
@@ -348,8 +242,7 @@ software is respectively built and installed:
    &&   echo "  specs:" \
    &&   echo "  - gromacs+mpi" \
    &&   echo "  - mpich" \
-   &&   echo "  concretizer:" \
-   &&   echo "    unify: true" \
+   &&   echo "  concretization: together" \
    &&   echo "  config:" \
    &&   echo "    install_tree: /opt/software" \
    &&   echo "  view: /opt/view") > /opt/spack-environment/spack.yaml
@@ -470,8 +363,7 @@ produces, for instance, the following ``Dockerfile``:
    &&   echo "      externals:" \
    &&   echo "      - spec: cuda%gcc" \
    &&   echo "        prefix: /usr/local/cuda" \
-   &&   echo "  concretizer:" \
-   &&   echo "    unify: true" \
+   &&   echo "  concretization: together" \
    &&   echo "  config:" \
    &&   echo "    install_tree: /opt/software" \
    &&   echo "  view: /opt/view") > /opt/spack-environment/spack.yaml
@@ -513,9 +405,9 @@ responsibility to ensure that:
 Therefore we don't recommend its use in cases that can be otherwise
 covered by the simplified mode shown first.
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+----------------------------
 Singularity Definition Files
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+----------------------------
 
 In addition to producing recipes in ``Dockerfile`` format Spack can produce
 Singularity Definition Files by just changing the value of the ``format``
@@ -536,132 +428,11 @@ attribute:
 The minimum version of Singularity required to build a SIF (Singularity Image Format)
 image from the recipes generated by Spack is ``3.5.3``.
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Extending the Jinja2 Templates
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The Dockerfile and the Singularity definition file that Spack can generate are based on
-a few Jinja2 templates that are rendered according to the environment being containerized.
-Even though Spack allows a great deal of customization by just setting appropriate values for
-the configuration options, sometimes that is not enough.
-
-In those cases, a user can directly extend the template that Spack uses to render the image
-to e.g. set additional environment variables or perform specific operations either before or
-after a given stage of the build. Let's consider as an example the following structure:
-
-.. code-block:: console
-
-   $ tree /opt/environment
-   /opt/environment
-   ├── data
-   │     └── data.csv
-   ├── spack.yaml
-   ├── data
-   └── templates
-       └── container
-           └── CustomDockerfile
-
-containing both the custom template extension and the environment manifest file. To use a custom
-template, the environment must register the directory containing it, and declare its use under the
-``container`` configuration:
-
-.. code-block:: yaml
-   :emphasize-lines: 7-8,12
-
-   spack:
-     specs:
-     - hdf5~mpi
-     concretizer:
-       unify: true
-     config:
-       template_dirs:
-       - /opt/environment/templates
-     container:
-       format: docker
-       depfile: true
-       template: container/CustomDockerfile
-
-The template extension can override two blocks, named ``build_stage`` and ``final_stage``, similarly to
-the example below:
-
-.. code-block::
-   :emphasize-lines: 3,8
-
-   {% extends "container/Dockerfile" %}
-   {% block build_stage %}
-   RUN echo "Start building"
-   {{ super() }}
-   {% endblock %}
-   {% block final_stage %}
-   {{ super() }}
-   COPY data /share/myapp/data
-   {% endblock %}
-
-The Dockerfile is generated by running:
-
-.. code-block:: console
-
-   $ spack -e /opt/environment containerize
-
-Note that the environment must be active for spack to read the template.
-The recipe that gets generated contains the two extra instruction that we added in our template extension:
-
-.. code-block:: Dockerfile
-   :emphasize-lines: 4,43
-
-   # Build stage with Spack pre-installed and ready to be used
-   FROM spack/ubuntu-jammy:latest as builder
-
-   RUN echo "Start building"
-
-   # What we want to install and how we want to install it
-   # is specified in a manifest file (spack.yaml)
-   RUN mkdir /opt/spack-environment \
-   &&  (echo "spack:" \
-   &&   echo "  specs:" \
-   &&   echo "  - hdf5~mpi" \
-   &&   echo "  concretizer:" \
-   &&   echo "    unify: true" \
-   &&   echo "  config:" \
-   &&   echo "    template_dirs:" \
-   &&   echo "    - /tmp/environment/templates" \
-   &&   echo "    install_tree: /opt/software" \
-   &&   echo "  view: /opt/view") > /opt/spack-environment/spack.yaml
-
-   # Install the software, remove unnecessary deps
-   RUN cd /opt/spack-environment && spack env activate . && spack concretize && spack env depfile -o Makefile && make -j $(nproc) && spack gc -y
-
-   # Strip all the binaries
-   RUN find -L /opt/view/* -type f -exec readlink -f '{}' \; | \
-       xargs file -i | \
-       grep 'charset=binary' | \
-       grep 'x-executable\|x-archive\|x-sharedlib' | \
-       awk -F: '{print $1}' | xargs strip -s
-
-   # Modifications to the environment that are necessary to run
-   RUN cd /opt/spack-environment && \
-       spack env activate --sh -d . >> /etc/profile.d/z10_spack_environment.sh
-
-   # Bare OS image to run the installed executables
-   FROM ubuntu:22.04
-
-   COPY --from=builder /opt/spack-environment /opt/spack-environment
-   COPY --from=builder /opt/software /opt/software
-   COPY --from=builder /opt/._view /opt/._view
-   COPY --from=builder /opt/view /opt/view
-   COPY --from=builder /etc/profile.d/z10_spack_environment.sh /etc/profile.d/z10_spack_environment.sh
-
-   COPY data /share/myapp/data
-
-   ENTRYPOINT ["/bin/bash", "--rcfile", "/etc/profile", "-l", "-c", "$*", "--" ]
-   CMD [ "/bin/bash" ]
-
-
 .. _container_config_options:
 
-~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------
 Configuration Reference
-~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------
 
 The tables below describe all the configuration options that are currently supported
 to customize the generation of container recipes:
@@ -677,10 +448,6 @@ to customize the generation of container recipes:
      - The format of the recipe
      - ``docker`` or ``singularity``
      - Yes
-   * - ``depfile``
-     - Whether to use a depfile for installation, or not
-     - True or False (default)
-     - No
    * - ``images:os``
      - Operating system used as a base for the image
      - See :ref:`containers-supported-os`
@@ -715,7 +482,7 @@ to customize the generation of container recipes:
      - No
    * - ``os_packages:command``
      - Tool used to manage system packages
-     - ``apt``, ``yum``, ``dnf``, ``dnf_epel``, ``zypper``, ``apk``, ``yum_amazon``
+     - ``apt``, ``yum``
      - Only with custom base images
    * - ``os_packages:update``
      - Whether or not to update the list of available packages
@@ -729,6 +496,14 @@ to customize the generation of container recipes:
      - System packages needed at run-time
      - Valid packages for the current OS
      - No
+   * - ``extra_instructions:build``
+     - Extra instructions (e.g. `RUN`, `COPY`, etc.) at the end of the ``build`` stage
+     - Anything understood by the current ``format``
+     - No
+   * - ``extra_instructions:final``
+     - Extra instructions (e.g. `RUN`, `COPY`, etc.) at the end of the ``final`` stage
+     - Anything understood by the current ``format``
+     - No
    * - ``labels``
      - Labels to tag the image
      - Pairs of key-value strings
@@ -758,13 +533,13 @@ to customize the generation of container recipes:
      - Description string
      - No
 
-~~~~~~~~~~~~~~
+--------------
 Best Practices
-~~~~~~~~~~~~~~
+--------------
 
-"""
+^^^
 MPI
-"""
+^^^
 Due to the dependency on Fortran for OpenMPI, which is the spack default
 implementation, consider adding ``gfortran`` to the ``apt-get install`` list.
 
@@ -775,9 +550,9 @@ For execution on HPC clusters, it can be helpful to import the docker
 image into Singularity in order to start a program with an *external*
 MPI. Otherwise, also add ``openssh-server`` to the ``apt-get install`` list.
 
-""""
+^^^^
 CUDA
-""""
+^^^^
 Starting from CUDA 9.0, Nvidia provides minimal CUDA images based on
 Ubuntu. Please see `their instructions <https://hub.docker.com/r/nvidia/cuda/>`_.
 Avoid double-installing CUDA by adding, e.g.
@@ -796,9 +571,9 @@ to your ``spack.yaml``.
 Users will either need ``nvidia-docker`` or e.g. Singularity to *execute*
 device kernels.
 
-"""""""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^^^^
 Docker on Windows and OSX
-"""""""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^^^^
 
 On Mac OS and Windows, docker runs on a hypervisor that is not allocated much
 memory by default, and some spack packages may fail to build due to lack of

lib/spack/docs/contribution_guide.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -71,7 +71,7 @@ locally to speed up the review process.
    new release that is causing problems. If this is the case, please file an issue.
 
 
-We currently test against Python 2.7 and 3.6-3.10 on both macOS and Linux and
+We currently test against Python 2.7 and 3.5-3.9 on both macOS and Linux and
 perform 3 types of tests:
 
 .. _cmd-spack-unit-test:
@@ -118,7 +118,7 @@ make another change, test that change, etc.  We use `pytest
 <http://pytest.org/>`_ as our tests framework, and these types of
 arguments are just passed to the ``pytest`` command underneath. See `the
 pytest docs
-<https://doc.pytest.org/en/latest/how-to/usage.html#specifying-which-tests-to-run>`_
+<http://doc.pytest.org/en/latest/usage.html#specifying-tests-selecting-tests>`_
 for more details on test selection syntax.
 
 ``spack unit-test`` has a few special options that can help you
@@ -147,7 +147,7 @@ you want to know about.  For example, to see just the tests in
 
 You can also combine any of these options with a ``pytest`` keyword
 search.  See the `pytest usage docs
-<https://doc.pytest.org/en/latest/how-to/usage.html#specifying-which-tests-to-run>`_
+<https://docs.pytest.org/en/stable/usage.html#specifying-tests-selecting-tests>`_:
 for more details on test selection syntax. For example, to see the names of all tests that have "spec"
 or "concretize" somewhere in their names:
 
@@ -253,6 +253,27 @@ to update them.
    multiple runs of ``spack style`` just to re-compute line numbers and
    makes it much easier to fix errors directly off of the CI output.
 
+.. warning::
+
+   Flake8 and ``pep8-naming`` require a number of dependencies in order
+   to run.  If you installed ``py-flake8`` and ``py-pep8-naming``, the
+   easiest way to ensure the right packages are on your ``PYTHONPATH`` is
+   to run::
+
+     spack activate py-flake8
+     spack activate pep8-naming
+
+   so that all of the dependencies are symlinked to a central
+   location. If you see an error message like:
+
+   .. code-block:: console
+
+      Traceback (most recent call last):
+        File: "/usr/bin/flake8", line 5, in <module>
+          from pkg_resources import load_entry_point
+      ImportError: No module named pkg_resources
+
+   that means Flake8 couldn't find setuptools in your ``PYTHONPATH``.
 
 ^^^^^^^^^^^^^^^^^^^
 Documentation Tests
@@ -288,9 +309,13 @@ All of these can be installed with Spack, e.g.
 
    .. code-block:: console
 
-      $ spack load py-sphinx py-sphinx-rtd-theme py-sphinxcontrib-programoutput
+      $ spack activate py-sphinx
+      $ spack activate py-sphinx-rtd-theme
+      $ spack activate py-sphinxcontrib-programoutput
 
-   so that all of the dependencies are added to PYTHONPATH.  If you see an error message
+   so that all of the dependencies are symlinked into that Python's
+   tree.  Alternatively, you could arrange for their library
+   directories to be added to PYTHONPATH.  If you see an error message
    like:
 
    .. code-block:: console
@@ -310,11 +335,53 @@ Once all of the dependencies are installed, you can try building the documentati
    $ make clean
    $ make
 
-If you see any warning or error messages, you will have to correct those before your PR
-is accepted. If you are editing the documentation, you should be running the
-documentation tests to make sure there are no errors. Documentation changes can result
-in some obfuscated warning messages. If you don't understand what they mean, feel free
-to ask when you submit your PR.
+If you see any warning or error messages, you will have to correct those before
+your PR is accepted.
+
+If you are editing the documentation, you should obviously be running the
+documentation tests. But even if you are simply adding a new package, your
+changes could cause the documentation tests to fail:
+
+.. code-block:: console
+
+   package_list.rst:8745: WARNING: Block quote ends without a blank line; unexpected unindent.
+
+At first, this error message will mean nothing to you, since you didn't edit
+that file. Until you look at line 8745 of the file in question:
+
+.. code-block:: rst
+
+   Description:
+      NetCDF is a set of software libraries and self-describing, machine-
+     independent data formats that support the creation, access, and sharing
+     of array-oriented scientific data.
+
+Our documentation includes :ref:`a list of all Spack packages <package-list>`.
+If you add a new package, its docstring is added to this page. The problem in
+this case was that the docstring looked like:
+
+.. code-block:: python
+
+   class Netcdf(Package):
+       """
+       NetCDF is a set of software libraries and self-describing,
+       machine-independent data formats that support the creation,
+       access, and sharing of array-oriented scientific data.
+       """
+
+Docstrings cannot start with a newline character, or else Sphinx will complain.
+Instead, they should look like:
+
+.. code-block:: python
+
+   class Netcdf(Package):
+       """NetCDF is a set of software libraries and self-describing,
+       machine-independent data formats that support the creation,
+       access, and sharing of array-oriented scientific data."""
+
+Documentation changes can result in much more obfuscated warning messages.
+If you don't understand what they mean, feel free to ask when you submit
+your PR.
 
 --------
 Coverage

lib/spack/docs/developer_guide.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -107,6 +107,7 @@ with a high level view of Spack's directory structure:
             llnl/          <- some general-use libraries
 
             spack/                <- spack module; contains Python code
+               analyzers/         <- modules to run analysis on installed packages
                build_systems/     <- modules for different build systems
                cmd/               <- each file in here is a spack subcommand
                compilers/         <- compiler description files
@@ -149,9 +150,11 @@ grouped by functionality.
 Package-related modules
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-:mod:`spack.package_base`
-  Contains the :class:`~spack.package_base.PackageBase` class, which
-  is the superclass for all packages in Spack.
+:mod:`spack.package`
+  Contains the :class:`~spack.package.Package` class, which
+  is the superclass for all packages in Spack.  Methods on ``Package``
+  implement all phases of the :ref:`package lifecycle
+  <package-lifecycle>` and manage the build process.
 
 :mod:`spack.util.naming`
   Contains functions for mapping between Spack package names,
@@ -175,11 +178,14 @@ Spec-related modules
 ^^^^^^^^^^^^^^^^^^^^
 
 :mod:`spack.spec`
-  Contains :class:`~spack.spec.Spec`. Also implements most of the logic for concretization
+  Contains :class:`~spack.spec.Spec` and :class:`~spack.spec.SpecParser`.
+  Also implements most of the logic for normalization and concretization
   of specs.
 
-:mod:`spack.parser`
-  Contains :class:`~spack.parser.SpecParser` and functions related to parsing specs.
+:mod:`spack.parse`
+  Contains some base classes for implementing simple recursive descent
+  parsers: :class:`~spack.parse.Parser` and :class:`~spack.parse.Lexer`.
+  Used by :class:`~spack.spec.SpecParser`.
 
 :mod:`spack.concretize`
   Contains :class:`~spack.concretize.Concretizer` implementation,
@@ -232,10 +238,26 @@ Spack Subcommands
 Unit tests
 ^^^^^^^^^^
 
-``spack.test``
+:mod:`spack.test`
   Implements Spack's test suite.  Add a module and put its name in
   the test suite in ``__init__.py`` to add more unit tests.
 
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Research and Monitoring Modules
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:mod:`spack.monitor`
+  Contains :class:`~spack.monitor.SpackMonitorClient`. This is accessed from
+  the ``spack install`` and ``spack analyze`` commands to send build and
+  package metadata up to a `Spack Monitor
+  <https://github.com/spack/spack-monitor>`_ server.
+
+
+:mod:`spack.analyzers`
+  A module folder with a :class:`~spack.analyzers.analyzer_base.AnalyzerBase`
+  that provides base functions to run, save, and (optionally) upload analysis
+  results to a `Spack Monitor <https://github.com/spack/spack-monitor>`_ server.
+
 
 ^^^^^^^^^^^^^
 Other Modules
@@ -279,6 +301,240 @@ Most spack commands look something like this:
 The information in Package files is used at all stages in this
 process.
 
+Conceptually, packages are overloaded.  They contain:
+
+-------------
+Stage objects
+-------------
+
+
+.. _writing-analyzers:
+
+-----------------
+Writing analyzers
+-----------------
+
+To write an analyzer, you should add a new python file to the
+analyzers module directory at ``lib/spack/spack/analyzers`` .
+Your analyzer should be a subclass of the :class:`AnalyzerBase <spack.analyzers.analyzer_base.AnalyzerBase>`. For example, if you want
+to add an analyzer class ``Myanalyzer`` you would write to
+``spack/analyzers/myanalyzer.py`` and import and
+use the base as follows:
+
+.. code-block:: python
+
+    from .analyzer_base import AnalyzerBase
+
+    class Myanalyzer(AnalyzerBase):
+
+
+Note that the class name is your module file name, all lowercase
+except for the first capital letter. You can  look at other analyzers in
+that analyzer directory for examples. The guide here will tell you about the basic functions needed.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^
+Analyzer Output Directory
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+By default, when you run ``spack analyze run`` an analyzer output directory will
+be created in your spack user directory in your ``$HOME``. The reason we output here
+is because the install directory might not always be writable.
+
+.. code-block:: console
+
+    ~/.spack/
+      analyzers
+
+Result files will be written here, organized in subfolders in the same structure
+as the package, with each analyzer owning it's own subfolder. for example:
+
+
+.. code-block:: console
+
+    $ tree ~/.spack/analyzers/
+    /home/spackuser/.spack/analyzers/
+    └── linux-ubuntu20.04-skylake
+        └── gcc-9.3.0
+            └── zlib-1.2.11-sl7m27mzkbejtkrajigj3a3m37ygv4u2
+                ├── environment_variables
+                │   └── spack-analyzer-environment-variables.json
+                ├── install_files
+                │   └── spack-analyzer-install-files.json
+                └── libabigail
+                    └── lib
+                        └── spack-analyzer-libabigail-libz.so.1.2.11.xml
+
+
+Notice that for the libabigail analyzer, since results are generated per object,
+we honor the object's folder in case there are equivalently named files in
+different folders. The result files are typically written as json so they can be easily read and  uploaded in a future interaction with a monitor.
+
+
+^^^^^^^^^^^^^^^^^
+Analyzer Metadata
+^^^^^^^^^^^^^^^^^
+
+Your analyzer is required to have the class attributes ``name``, ``outfile``,
+and ``description``. These are printed to the user with they use the subcommand
+``spack analyze list-analyzers``.  Here is an example.
+As we mentioned above, note that this analyzer would live in a module named
+``libabigail.py`` in the analyzers folder so that the class can be discovered.
+
+
+.. code-block:: python
+
+    class Libabigail(AnalyzerBase):
+
+        name = "libabigail"
+        outfile = "spack-analyzer-libabigail.json"
+        description = "Application Binary Interface (ABI) features for objects"
+
+
+This means that the name and output file should be unique for your analyzer.
+Note that "all" cannot be the name of an analyzer, as this key is used to indicate
+that the user wants to run all analyzers.
+
+.. _analyzer_run_function:
+
+
+^^^^^^^^^^^^^^^^^^^^^^^^
+An analyzer run Function
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+The core of an analyzer is its ``run()`` function, which should accept no
+arguments. You can assume your analyzer has the package spec of interest at ``self.spec``
+and it's up to the run function to generate whatever analysis data you need,
+and then return the object with a key as the analyzer name. The result data
+should be a list of objects, each with a name, ``analyzer_name``, ``install_file``,
+and one of ``value`` or ``binary_value``. The install file should be for a relative
+path, and not the absolute path. For example, let's say we extract a metric called
+``metric`` for ``bin/wget`` using our analyzer ``thebest-analyzer``.
+We might have data that looks like this:
+
+.. code-block:: python
+
+    result = {"name": "metric", "analyzer_name": "thebest-analyzer", "value": "1", "install_file": "bin/wget"}
+
+
+We'd then return it as follows - note that they key is the analyzer name at ``self.name``.
+
+.. code-block:: python
+
+    return {self.name: result}
+
+This will save the complete result to the analyzer metadata folder, as described
+previously. If you want support for adding a different kind of metadata (e.g.,
+not associated with an install file) then the monitor server would need to be updated
+to support this first.
+
+
+^^^^^^^^^^^^^^^^^^^^^^^^^
+An analyzer init Function
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If you don't need any extra dependencies or checks, you can skip defining an analyzer
+init function, as the base class will handle it. Typically, it will accept
+a spec, and an optional output directory (if the user does not want the default
+metadata folder for analyzer results). The analyzer init function should call
+it's parent init, and then do any extra checks or validation that are required to
+work. For example:
+
+.. code-block:: python
+
+    def __init__(self, spec, dirname=None):
+        super(Myanalyzer, self).__init__(spec, dirname)
+
+        # install extra dependencies, do extra preparation and checks here
+
+
+At the end of the init, you will have available to you:
+
+ - **self.spec**: the spec object
+ - **self.dirname**: an optional directory name the user as provided at init to save
+ - **self.output_dir**: the analyzer metadata directory, where we save by default
+ - **self.meta_dir**: the path to the package metadata directory (.spack) if you need it
+
+And can proceed to write your analyzer.
+
+
+^^^^^^^^^^^^^^^^^^^^^^^
+Saving Analyzer Results
+^^^^^^^^^^^^^^^^^^^^^^^
+
+The analyzer will have ``save_result`` called, with the result object generated
+to save it to the filesystem, and if the user has added the ``--monitor`` flag
+to upload it to a monitor server. If your result follows an accepted result
+format and you don't need to parse it further, you don't need to add this
+function to your class. However, if your result data is large or otherwise
+needs additional parsing, you can define it. If you define the function, it
+is useful to know about the ``output_dir`` property, which you can join
+with your output file relative path of choice:
+
+.. code-block:: python
+
+    outfile = os.path.join(self.output_dir, "my-output-file.txt")
+
+
+The directory will be provided by the ``output_dir`` property but it won't exist,
+so you should create it:
+
+
+.. code::block:: python
+
+    # Create the output directory
+    if not os.path.exists(self._output_dir):
+        os.makedirs(self._output_dir)
+
+
+If you are generating results that match to specific files in the package
+install directory, you should try to maintain those paths in the case that
+there are equivalently named files in different directories that would
+overwrite one another. As an example of an analyzer with a custom save,
+the Libabigail analyzer saves ``*.xml`` files to the analyzer metadata
+folder in ``run()``, as they are either binaries, or as xml (text) would
+usually be too big to pass in one request. For this reason, the files
+are saved during ``run()`` and the filenames added to the result object,
+and then when the result object is passed back into ``save_result()``,
+we skip saving to the filesystem, and instead read the file and send
+each one (separately) to the monitor:
+
+
+.. code-block:: python
+
+    def save_result(self, result, monitor=None, overwrite=False):
+        """ABI results are saved to individual files, so each one needs to be
+        read and uploaded. Result here should be the lookup generated in run(),
+        the key is the analyzer name, and each value is the result file.
+        We currently upload the entire xml as text because libabigail can't
+        easily read gzipped xml, but this will be updated when it can.
+        """
+        if not monitor:
+            return
+
+        name = self.spec.package.name
+
+        for obj, filename in result.get(self.name, {}).items():
+
+            # Don't include the prefix
+            rel_path = obj.replace(self.spec.prefix + os.path.sep, "")
+
+            # We've already saved the results to file during run
+            content = spack.monitor.read_file(filename)
+
+            # A result needs an analyzer, value or binary_value, and name
+            data = {"value": content, "install_file": rel_path, "name": "abidw-xml"}
+            tty.info("Sending result for %s %s to monitor." % (name, rel_path))
+            monitor.send_analyze_metadata(self.spec.package, {"libabigail": [data]})
+
+
+
+Notice that this function, if you define it, requires a result object (generated by
+``run()``, a monitor (if you want to send), and a boolean ``overwrite`` to be used
+to check if a result exists first, and not write to it if the result exists and
+overwrite is False. Also notice that since we already saved these files to the analyzer metadata folder, we return early if a monitor isn't defined, because this function serves to send  results to the monitor. If you haven't saved anything to the analyzer metadata folder
+yet, you might want to do that here. You should also use ``tty.info`` to give
+the user a message of "Writing result to $DIRNAME."
+
 
 .. _writing-commands:
 
@@ -357,23 +613,101 @@ If there is a hook that you would like and is missing, you can propose to add a
 ``pre_install(spec)``
 """""""""""""""""""""
 
-A ``pre_install`` hook is run within the install subprocess, directly before the install starts.
-It expects a single argument of a spec.
+A ``pre_install`` hook is run within an install subprocess, directly before
+the install starts. It expects a single argument of a spec, and is run in
+a multiprocessing subprocess. Note that if you see ``pre_install`` functions associated with packages these are not hooks
+as we have defined them here, but rather callback functions associated with
+a package install.
 
 
-"""""""""""""""""""""""""""""""""""""
-``post_install(spec, explicit=None)``
-"""""""""""""""""""""""""""""""""""""
+""""""""""""""""""""""
+``post_install(spec)``
+""""""""""""""""""""""
 
-A ``post_install`` hook is run within the install subprocess, directly after the install finishes,
-but before the build stage is removed and the spec is registered in the database. It expects two
-arguments: spec and an optional boolean indicating whether this spec is being installed explicitly.
+A ``post_install`` hook is run within an install subprocess, directly after
+the install finishes, but before the build stage is removed. If you
+write one of these hooks, you should expect it to accept a spec as the only
+argument. This is run in a multiprocessing subprocess. This ``post_install`` is
+also seen in packages, but in this context not related to the hooks described
+here.
 
-""""""""""""""""""""""""""""""""""""""""""""""""""""
-``pre_uninstall(spec)`` and ``post_uninstall(spec)``
-""""""""""""""""""""""""""""""""""""""""""""""""""""
 
-These hooks are currently used for cleaning up module files after uninstall.
+""""""""""""""""""""""""""
+``on_install_start(spec)``
+""""""""""""""""""""""""""
+
+This hook is run at the beginning of ``lib/spack/spack/installer.py``,
+in the install function of a ``PackageInstaller``,
+and importantly is not part of a build process, but before it. This is when
+we have just newly grabbed the task, and are preparing to install. If you
+write a hook of this type, you should provide the spec to it.
+
+.. code-block:: python
+
+    def on_install_start(spec):
+        """On start of an install, we want to...
+        """
+        print('on_install_start')
+
+
+""""""""""""""""""""""""""""
+``on_install_success(spec)``
+""""""""""""""""""""""""""""
+
+This hook is run on a successful install, and is also run inside the build
+process, akin to ``post_install``. The main difference is that this hook
+is run outside of the context of the stage directory, meaning after the
+build stage has been removed and the user is alerted that the install was
+successful. If you need to write a hook that is run on success of a particular
+phase, you should use ``on_phase_success``.
+
+""""""""""""""""""""""""""""
+``on_install_failure(spec)``
+""""""""""""""""""""""""""""
+
+This hook is run given an install failure that happens outside of the build
+subprocess, but somewhere in ``installer.py`` when something else goes wrong.
+If you need to write a hook that is relevant to a failure within a build
+process, you would want to instead use ``on_phase_failure``.
+
+
+"""""""""""""""""""""""""""""""""""""""""""""""
+``on_phase_success(pkg, phase_name, log_file)``
+"""""""""""""""""""""""""""""""""""""""""""""""
+
+This hook is run within the install subprocess, and specifically when a phase
+successfully finishes. Since we are interested in the package, the name of
+the phase, and any output from it, we require:
+
+ - **pkg**: the package variable, which also has the attached spec at ``pkg.spec``
+ - **phase_name**: the name of the phase that was successful (e.g., configure)
+ - **log_file**: the path to the file with output, in case you need to inspect or otherwise interact with it.
+
+"""""""""""""""""""""""""""""""""""""""""""""
+``on_phase_error(pkg, phase_name, log_file)``
+"""""""""""""""""""""""""""""""""""""""""""""
+
+In the case of an error during a phase, we might want to trigger some event
+with a hook, and this is the purpose of this particular hook. Akin to
+``on_phase_success`` we require the same variables - the package that failed,
+the name of the phase, and the log file where we might find errors.
+
+"""""""""""""""""""""""""""""""""
+``on_analyzer_save(pkg, result)``
+"""""""""""""""""""""""""""""""""
+
+After an analyzer has saved some result for a package, this hook is called,
+and it provides the package that we just ran the analysis for, along with
+the loaded result. Typically, a result is structured to have the name
+of the analyzer as key, and the result object that is defined in detail in
+:ref:`analyzer_run_function`.
+
+.. code-block:: python
+
+    def on_analyzer_save(pkg, result):
+        """given a package and a result...
+        """
+        print('Do something extra with a package analysis result here')
 
 
 ^^^^^^^^^^^^^^^^^^^^^^
@@ -404,7 +738,7 @@ use my new hook as follows:
 .. code-block:: python
 
     def post_log_write(message, level):
-        """Do something custom with the message and level every time we write
+        """Do something custom with the messsage and level every time we write
         to the log
         """
         print('running post_log_write!')
@@ -552,11 +886,11 @@ With either interpreter you can run a single command:
 
 .. code-block:: console
 
-   $ spack python -c 'from spack.spec import Spec; Spec("python").concretized()'
-   ...
+   $ spack python -c 'import distro; distro.linux_distribution()'
+   ('Ubuntu', '18.04', 'Bionic Beaver')
 
-   $ spack python -i ipython -c 'from spack.spec import Spec; Spec("python").concretized()'
-   Out[1]: ...
+   $ spack python -i ipython -c 'import distro; distro.linux_distribution()'
+   Out[1]: ('Ubuntu', '18.04', 'Bionic Beaver')
 
 or a file:
 
@@ -716,39 +1050,39 @@ Release branches
 ^^^^^^^^^^^^^^^^
 
 There are currently two types of Spack releases: :ref:`major releases
-<major-releases>` (``0.17.0``, ``0.18.0``, etc.) and :ref:`point releases
-<point-releases>` (``0.17.1``, ``0.17.2``, ``0.17.3``, etc.). Here is a
+<major-releases>` (``0.13.0``, ``0.14.0``, etc.) and :ref:`point releases
+<point-releases>` (``0.13.1``, ``0.13.2``, ``0.13.3``, etc.). Here is a
 diagram of how Spack release branches work::
 
-    o    branch: develop  (latest version, v0.19.0.dev0)
+    o    branch: develop  (latest version)
     |
-    o
-    | o  branch: releases/v0.18, tag: v0.18.1
-    o |
-    | o  tag: v0.18.0
-    o |
-    | o
+    o    merge v0.14.1 into develop
+    |\
+    | o  branch: releases/v0.14, tag: v0.14.1
+    o |  merge v0.14.0 into develop
+    |\|
+    | o  tag: v0.14.0
     |/
-    o
-    |
-    o
-    | o  branch: releases/v0.17, tag: v0.17.2
-    o |
-    | o  tag: v0.17.1
-    o |
-    | o  tag: v0.17.0
+    o    merge v0.13.2 into develop
+    |\
+    | o  branch: releases/v0.13, tag: v0.13.2
+    o |  merge v0.13.1 into develop
+    |\|
+    | o  tag: v0.13.1
+    o |  merge v0.13.0 into develop
+    |\|
+    | o  tag: v0.13.0
     o |
     | o
     |/
     o
 
 The ``develop`` branch has the latest contributions, and nearly all pull
-requests target ``develop``. The ``develop`` branch will report that its
-version is that of the next **major** release with a ``.dev0`` suffix.
+requests target ``develop``.
 
 Each Spack release series also has a corresponding branch, e.g.
-``releases/v0.18`` has ``0.18.x`` versions of Spack, and
-``releases/v0.17`` has ``0.17.x`` versions. A major release is the first
+``releases/v0.14`` has ``0.14.x`` versions of Spack, and
+``releases/v0.13`` has ``0.13.x`` versions. A major release is the first
 tagged version on a release branch. Minor releases are back-ported from
 develop onto release branches. This is typically done by cherry-picking
 bugfix commits off of ``develop``.
@@ -759,20 +1093,12 @@ packages. They should generally only contain fixes to the Spack core.
 However, sometimes priorities are such that new functionality needs to
 be added to a minor release.
 
-Both major and minor releases are tagged. As a convenience, we also tag
-the latest release as ``releases/latest``, so that users can easily check
-it out to get the latest stable version. See :ref:`updating-latest-release`
-for more details.
-
-.. note::
-
-   Older spack releases were merged **back** into develop so that we could
-   do fancy things with tags, but since tarballs and many git checkouts do
-   not have tags, this proved overly complex and confusing.
-
-   We have since converted to using `PEP 440 <https://peps.python.org/pep-0440/>`_
-   compliant versions.  `See here <https://github.com/spack/spack/pull/25267>`_ for
-   details.
+Both major and minor releases are tagged. After each release, we merge
+the release branch back into ``develop`` so that the version bump and any
+other release-specific changes are visible in the mainline. As a
+convenience, we also tag the latest release as ``releases/latest``,
+so that users can easily check it out to get the latest
+stable version. See :ref:`merging-releases` for more details.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Scheduling work for releases
@@ -830,11 +1156,10 @@ completed, the steps to make the major release are:
    ``releases/vX.Y``. That is, you should create a ``releases/vX.Y``
    branch if you are preparing the ``X.Y.0`` release.
 
-#. Remove the ``dev0`` development release segment from the version tuple in
-   ``lib/spack/spack/__init__.py``.
+#. Bump the version in ``lib/spack/spack/__init__.py``.
 
-   The version number itself should already be correct and should not be
-   modified.
+   See `this example from 0.13.0
+   <https://github.com/spack/spack/commit/8eeb64096c98b8a43d1c587f13ece743c864fba9>`_
 
 #. Update ``CHANGELOG.md`` with major highlights in bullet form.
 
@@ -856,16 +1181,9 @@ completed, the steps to make the major release are:
    is outdated submit pull requests to ``develop`` as normal
    and keep rebasing the release branch on ``develop``.
 
-#. Bump the major version in the ``develop`` branch.
-
-   Create a pull request targeting the ``develop`` branch, bumping the major
-   version in ``lib/spack/spack/__init__.py`` with a ``dev0`` release segment.
-   For instance when you have just released ``v0.15.0``, set the version
-   to ``(0, 16, 0, 'dev0')`` on ``develop``.
-
 #. Follow the steps in :ref:`publishing-releases`.
 
-#. Follow the steps in :ref:`updating-latest-release`.
+#. Follow the steps in :ref:`merging-releases`.
 
 #. Follow the steps in :ref:`announcing-releases`.
 
@@ -892,13 +1210,8 @@ completed, the steps to make the point release are:
 
       $ git checkout releases/v0.15
 
-#. If a pull request to the release branch named ``Backports vX.Y.Z`` is not already
-   in the project, create it. This pull request ought to be created as early as
-   possible when working on a release project, so that we can build the release
-   commits incrementally, and identify potential conflicts at an early stage.
-
 #. Cherry-pick each pull request in the ``Done`` column of the release
-   project board onto the ``Backports vX.Y.Z`` pull request.
+   project board onto the release branch.
 
    This is **usually** fairly simple since we squash the commits from the
    vast majority of pull requests. That means there is only one commit
@@ -923,7 +1236,7 @@ completed, the steps to make the point release are:
 
       It is important to cherry-pick commits in the order they happened,
       otherwise you can get conflicts while cherry-picking. When
-      cherry-picking look at the merge date,
+      cherry-picking onto a point release, look at the merge date,
       **not** the number of the pull request or the date it was opened.
 
       Sometimes you may **still** get merge conflicts even if you have
@@ -944,19 +1257,18 @@ completed, the steps to make the point release are:
          branch if neither of the above options makes sense, but this can
          require a lot of work. It's seldom the right choice.
 
-#. When all the commits from the project board are cherry-picked into
-   the ``Backports vX.Y.Z`` pull request, you can push a commit to:
+#. Bump the version in ``lib/spack/spack/__init__.py``.
 
-   1. Bump the version in ``lib/spack/spack/__init__.py``.
-   2. Update ``CHANGELOG.md`` with a list of the changes.
+   See `this example from 0.14.1
+   <https://github.com/spack/spack/commit/ff0abb9838121522321df2a054d18e54b566b44a>`_.
+
+#. Update ``CHANGELOG.md`` with a list of the changes.
 
    This is typically a summary of the commits you cherry-picked onto the
    release branch. See `the changelog from 0.14.1
    <https://github.com/spack/spack/commit/ff0abb9838121522321df2a054d18e54b566b44a>`_.
 
-#. Merge the ``Backports vX.Y.Z`` PR with the **Rebase and merge** strategy. This
-   is needed to keep track in the release branch of all the commits that were
-   cherry-picked.
+#. Push the release branch to GitHub.
 
 #. Make sure CI passes on the release branch, including:
 
@@ -971,12 +1283,10 @@ completed, the steps to make the point release are:
 
 #. Follow the steps in :ref:`publishing-releases`.
 
-#. Follow the steps in :ref:`updating-latest-release`.
+#. Follow the steps in :ref:`merging-releases`.
 
 #. Follow the steps in :ref:`announcing-releases`.
 
-#. Submit a PR to update the CHANGELOG in the `develop` branch
-   with the addition of this point release.
 
 .. _publishing-releases:
 
@@ -1034,11 +1344,11 @@ Publishing a release on GitHub
    selectable in the versions menu.
 
 
-.. _updating-latest-release:
+.. _merging-releases:
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-Updating `releases/latest`
-^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Updating `releases/latest` and `develop`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 If the new release is the **highest** Spack release yet, you should
 also tag it as ``releases/latest``. For example, suppose the highest
@@ -1062,6 +1372,40 @@ To tag ``releases/latest``, do this:
 The ``--force`` argument to ``git tag`` makes ``git`` overwrite the existing
 ``releases/latest`` tag with the new one.
 
+We also merge each release that we tag as ``releases/latest`` into ``develop``.
+Make sure to do this with a merge commit:
+
+.. code-block:: console
+
+   $ git checkout develop
+   $ git merge --no-ff -s ours vX.Y.Z  # vX.Y.Z is the new release's tag
+   $ git push
+
+We merge back to ``develop`` because it:
+
+  * updates the version and ``CHANGELOG.md`` on ``develop``; and
+  * ensures that your release tag is reachable from the head of
+    ``develop``.
+
+We *must* use a real merge commit (via the ``--no-ff`` option) to
+ensure that the release tag is reachable from the tip of ``develop``.
+This is necessary for ``spack -V`` to work properly -- it uses ``git
+describe --tags`` to find the last reachable tag in the repository and
+reports how far we are from it. For example:
+
+.. code-block:: console
+
+   $ spack -V
+   0.14.2-1486-b80d5e74e5
+
+This says that we are at commit ``b80d5e74e5``, which is 1,486 commits
+ahead of the ``0.14.2`` release.
+
+We put this step last in the process because it's best to do it only once
+the release is complete and tagged. If you do it before you've tagged the
+release and later decide you want to tag some later commit, you'll need
+to merge again.
+
 
 .. _announcing-releases:
 
@@ -1071,9 +1415,9 @@ Announcing a release
 
 We announce releases in all of the major Spack communication channels.
 Publishing the release takes care of GitHub. The remaining channels are
-X, Slack, and the mailing list. Here are the steps:
+Twitter, Slack, and the mailing list. Here are the steps:
 
-#. Announce the release on X.
+#. Announce the release on Twitter.
 
    * Compose the tweet on the ``@spackpm`` account per the
      ``spack-twitter`` slack channel.

lib/spack/docs/environments.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _environments:
 
-=========================
-Environments (spack.yaml)
-=========================
+============
+Environments
+============
 
 An environment is used to group together a set of specs for the
 purpose of building, rebuilding and deploying in a coherent fashion.
@@ -58,9 +58,9 @@ Using Environments
 Here we follow a typical use case of creating, concretizing,
 installing and loading an environment.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Creating a managed Environment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Creating a named Environment
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 An environment is created by:
 
@@ -72,8 +72,7 @@ Spack then creates the directory ``var/spack/environments/myenv``.
 
 .. note::
 
-   All managed environments by default are stored in the ``var/spack/environments`` folder.
-   This location can be changed by setting the ``environments_root`` variable in ``config.yaml``.
+   All named environments are stored in the ``var/spack/environments`` folder.
 
 In the ``var/spack/environments/myenv`` directory, Spack creates the
 file ``spack.yaml`` and the hidden directory ``.spack-env``.
@@ -94,9 +93,9 @@ an Environment, the ``.spack-env`` directory also contains:
   * ``logs/``: A directory containing the build logs for the packages
     in this Environment.
 
-Spack Environments can also be created from either a manifest file
-(usually but not necessarily named, ``spack.yaml``) or a lockfile.
-To create an Environment from a manifest:
+Spack Environments can also be created from either a ``spack.yaml``
+manifest or a ``spack.lock`` lockfile. To create an Environment from a
+``spack.yaml`` manifest:
 
 .. code-block:: console
 
@@ -142,21 +141,6 @@ user's prompt to begin with the environment name in brackets.
    $ spack env activate -p myenv
    [myenv] $ ...
 
-The ``activate`` command can also be used to create a new environment, if it is
-not already defined, by adding the ``--create`` flag. Managed and anonymous
-environments, anonymous environments are explained in the next section,
-can both be created using the same flags that `spack env create` accepts.
-If an environment already exists then spack will simply activate it and ignore the
-create specific flags.
-
-.. code-block:: console
-   
-   $ spack env activate --create -p myenv
-   # ...
-   # [creates if myenv does not exist yet]
-   # ...
-   [myenv] $ ...
-
 To deactivate an environment, use the command:
 
 .. code-block:: console
@@ -189,7 +173,7 @@ Anonymous specs can be created in place using the command:
 
    $ spack env create -d .
 
-In this case Spack simply creates a ``spack.yaml`` file in the requested
+In this case Spack simply creates a spack.yaml file in the requested
 directory.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -249,8 +233,8 @@ packages will be listed as roots of the Environment.
 
 All of the Spack commands that act on the list of installed specs are
 Environment-sensitive in this way, including ``install``,
-``uninstall``, ``find``, ``extensions``, and more. In the
-:ref:`environment-configuration` section we will discuss
+``uninstall``, ``activate``, ``deactivate``, ``find``, ``extensions``,
+and more. In the :ref:`environment-configuration` section we will discuss
 Environment-sensitive commands further.
 
 ^^^^^^^^^^^^^^^^^^^^^
@@ -289,9 +273,19 @@ or
 Concretizing
 ^^^^^^^^^^^^
 
-Once some user specs have been added to an environment, they can be concretized.
-There are at the moment three different modes of operation to concretize an environment,
-which are explained in details in :ref:`environments_concretization_config`.
+Once some user specs have been added to an environment, they can be
+concretized. *By default specs are concretized separately*, one after
+the other. This mode of operation permits to deploy a full
+software stack where multiple configurations of the same package
+need to be installed alongside each other. Central installations done
+at HPC centers by system administrators or user support groups
+are a common case that fits in this behavior.
+Environments *can also be configured to concretize all
+the root specs in a self-consistent way* to ensure that
+each package in the environment comes with a single configuration. This
+mode of operation is usually what is required by software developers that
+want to deploy their development environment.
+
 Regardless of which mode of operation has been chosen, the following
 command will ensure all the root specs are concretized according to the
 constraints that are prescribed in the configuration:
@@ -355,24 +349,6 @@ If the Environment has been concretized, Spack will install the
 concretized specs. Otherwise, ``spack install`` will first concretize
 the Environment and then install the concretized specs.
 
-.. note::
-
-   Every ``spack install`` process builds one package at a time with multiple build
-   jobs, controlled by the ``-j`` flag and the ``config:build_jobs`` option
-   (see :ref:`build-jobs`). To speed up environment builds further, independent
-   packages can be installed in parallel by launching more Spack instances. For
-   example, the following will build at most four packages in parallel using
-   three background jobs:
-
-   .. code-block:: console
-
-      [myenv]$ spack install & spack install & spack install & spack install
-
-   Another option is to generate a ``Makefile`` and run ``make -j<N>`` to control
-   the number of parallel install processes. See :ref:`env-generate-depfile`
-   for details.
-
-
 As it installs, ``spack install`` creates symbolic links in the
 ``logs/`` directory in the Environment, allowing for easy inspection
 of build logs related to that environment. The ``spack install``
@@ -392,47 +368,6 @@ from being added again.  At the same time, a spec that already exists in the
 environment, but only as a dependency, will be added to the environment as a
 root spec without the ``--no-add`` option.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Developing Packages in a Spack Environment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The ``spack develop`` command allows one to develop Spack packages in
-an environment. It requires a spec containing a concrete version, and
-will configure Spack to install the package from local source. By
-default, it will also clone the package to a subdirectory in the
-environment. This package will have a special variant ``dev_path``
-set, and Spack will ensure the package and its dependents are rebuilt
-any time the environment is installed if the package's local source
-code has been modified. Spack ensures that all instances of a
-developed package in the environment are concretized to match the
-version (and other constraints) passed as the spec argument to the
-``spack develop`` command.
-
-For packages with ``git`` attributes, git branches, tags, and commits can
-also be used as valid concrete versions (see :ref:`version-specifier`).
-This means that for a package ``foo``, ``spack develop foo@git.main`` will clone
-the ``main`` branch of the package, and ``spack install`` will install from
-that git clone if ``foo`` is in the environment.
-Further development on ``foo`` can be tested by reinstalling the environment,
-and eventually committed and pushed to the upstream git repo.
-
-If the package being developed supports out-of-source builds then users can use the
-``--build_directory`` flag to control the location and name of the build directory. 
-This is a shortcut to set the ``package_attributes:build_directory`` in the
-``packages`` configuration (see :ref:`assigning-package-attributes`).
-The supplied location will become the build-directory for that package in all future builds.
-
-.. warning::
-   Potential pitfalls of setting the build directory
-    Spack does not check for out-of-source build compatibility with the packages and
-    so the onerous of making sure the package supports out-of-source builds is on
-    the user.
-    For example, most ``autotool`` and ``makefile`` packages do not support out-of-source builds
-    while all ``CMake`` packages do.
-    Understanding these nuances are on the software developers and we strongly encourage
-    developers to only redirect the build directory if they understand their package's
-    build-system.
-
 ^^^^^^^
 Loading
 ^^^^^^^
@@ -449,11 +384,18 @@ Sourcing that file in Bash will make the environment available to the
 user; and can be included in ``.bashrc`` files, etc.  The ``loads``
 file may also be copied out of the environment, renamed, etc.
 
+----------
+spack.yaml
+----------
+
+Spack environments can be customized at finer granularity by editing
+the ``spack.yaml`` manifest file directly.
+
 .. _environment-configuration:
 
-------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^
 Configuring Environments
-------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^
 
 A variety of Spack behaviors are changed through Spack configuration
 files, covered in more detail in the :ref:`configuration`
@@ -475,9 +417,9 @@ environment can be specified by ``env:NAME`` (to affect environment
 ``foo``, set ``--scope env:foo``). These commands will automatically
 manipulate configuration inline in the ``spack.yaml`` file.
 
-^^^^^^^^^^^^^^^^^^^^^
+"""""""""""""""""""""
 Inline configurations
-^^^^^^^^^^^^^^^^^^^^^
+"""""""""""""""""""""
 
 Inline Environment-scope configuration is done using the same yaml
 format as standard Spack configuration scopes, covered in the
@@ -489,18 +431,18 @@ a ``packages.yaml`` file) could contain:
 .. code-block:: yaml
 
    spack:
-     # ...
+     ...
      packages:
        all:
          compiler: [intel]
-     # ...
+     ...
 
 This configuration sets the default compiler for all packages to
 ``intel``.
 
-^^^^^^^^^^^^^^^^^^^^^^^
+"""""""""""""""""""""""
 Included configurations
-^^^^^^^^^^^^^^^^^^^^^^^
+"""""""""""""""""""""""
 
 Spack environments allow an ``include`` heading in their yaml
 schema. This heading pulls in external configuration files and applies
@@ -511,25 +453,18 @@ them to the Environment.
    spack:
      include:
      - relative/path/to/config.yaml
-     - https://github.com/path/to/raw/config/compilers.yaml
      - /absolute/path/to/packages.yaml
 
-Environments can include files or URLs. File paths can be relative or
-absolute. URLs include the path to the text for individual files or
-can be the path to a directory containing configuration files.
+Environments can include files with either relative or absolute
+paths. Inline configurations take precedence over included
+configurations, so you don't have to change shared configuration files
+to make small changes to an individual Environment. Included configs
+listed earlier will have higher precedence, as the included configs are
+applied in reverse order.
 
-^^^^^^^^^^^^^^^^^^^^^^^^
-Configuration precedence
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-Inline configurations take precedence over included configurations, so
-you don't have to change shared configuration files to make small changes
-to an individual environment. Included configurations listed earlier will
-have higher precedence, as the included configs are applied in reverse order.
-
--------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Manually Editing the Specs List
--------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The list of abstract/root specs in the Environment is maintained in
 the ``spack.yaml`` manifest under the heading ``specs``.
@@ -547,89 +482,37 @@ Appending to this list in the yaml is identical to using the ``spack
 add`` command from the command line. However, there is more power
 available from the yaml file.
 
-.. _environments_concretization_config:
-
-^^^^^^^^^^^^^^^^^^^
+"""""""""""""""""""
 Spec concretization
-^^^^^^^^^^^^^^^^^^^
-An environment can be concretized in three different modes and the behavior active under
-any environment is determined by the ``concretizer:unify`` configuration option.
+"""""""""""""""""""
 
-The *default* mode is to unify all specs:
+Specs can be concretized separately or together, as already
+explained in :ref:`environments_concretization`. The behavior active
+under any environment is determined by the ``concretization`` property:
 
 .. code-block:: yaml
 
    spack:
        specs:
-         - hdf5+mpi
-         - zlib@1.2.8
-       concretizer:
-         unify: true
+         - ncview
+         - netcdf
+         - nco
+         - py-sphinx
+       concretization: together
 
-This means that any package in the environment corresponds to a single concrete spec. In
-the above example, when ``hdf5`` depends down the line of ``zlib``, it is required to
-take ``zlib@1.2.8`` instead of a newer version. This mode of concretization is
-particularly useful when environment views are used: if every package occurs in
-only one flavor, it is usually possible to merge all install directories into a view.
-
-A downside of unified concretization is that it can be overly strict. For example, a
-concretization error would happen when both ``hdf5+mpi`` and ``hdf5~mpi`` are specified
-in an environment.
-
-The second mode is to *unify when possible*: this makes concretization of root specs
-more independendent. Instead of requiring reuse of dependencies across different root
-specs, it is only maximized:
-
-.. code-block:: yaml
-
-   spack:
-       specs:
-         - hdf5~mpi
-         - hdf5+mpi
-         - zlib@1.2.8
-       concretizer:
-         unify: when_possible
-
-This means that both ``hdf5`` installations will use ``zlib@1.2.8`` as a dependency even
-if newer versions of that library are available.
-
-The third mode of operation is to concretize root specs entirely independently by
-disabling unified concretization:
-
-.. code-block:: yaml
-
-   spack:
-       specs:
-         - hdf5~mpi
-         - hdf5+mpi
-         - zlib@1.2.8
-       concretizer:
-         unify: false
-
-In this example ``hdf5`` is concretized separately, and does not consider ``zlib@1.2.8``
-as a constraint or preference. Instead, it will take the latest possible version.
-
-The last two concretization options are typically useful for system administrators and
-user support groups providing a large software stack for their HPC center.
-
-.. note::
-
-   The ``concretizer:unify`` config option was introduced in Spack 0.18 to
-   replace the ``concretization`` property. For reference,
-   ``concretization: together`` is replaced by ``concretizer:unify:true``,
-   and ``concretization: separately`` is replaced by ``concretizer:unify:false``.
+which can currently take either one of the two allowed values ``together`` or ``separately``
+(the default).
 
 .. admonition:: Re-concretization of user specs
 
-   The ``spack concretize`` command without additional arguments will *not* change any
-   previously concretized specs. This may prevent it from finding a solution when using
-   ``unify: true``, and it may prevent it from finding a minimal solution when using
-   ``unify: when_possible``. You can force Spack to ignore the existing concrete environment
-   with ``spack concretize -f``.
+   When concretizing specs together the entire set of specs will be
+   re-concretized after any addition of new user specs, to ensure that
+   the environment remains consistent. When instead the specs are concretized
+   separately only the new specs will be re-concretized after any addition.
 
-^^^^^^^^^^^^^
+"""""""""""""
 Spec Matrices
-^^^^^^^^^^^^^
+"""""""""""""
 
 Entries in the ``specs`` list can be individual abstract specs or a
 spec matrix.
@@ -664,9 +547,34 @@ The following two Environment manifests are identical:
 Spec matrices can be used to install swaths of software across various
 toolchains.
 
-^^^^^^^^^^^^^^^^^^^^
+The concretization logic for spec matrices differs slightly from the
+rest of Spack. If a variant or dependency constraint from a matrix is
+invalid, Spack will reject the constraint and try again without
+it. For example, the following two Environment manifests will produce
+the same specs:
+
+.. code-block:: yaml
+
+   spack:
+     specs:
+       - matrix:
+           - [zlib, libelf, hdf5+mpi]
+           - [^mvapich2@2.2, ^openmpi@3.1.0]
+
+   spack:
+     specs:
+       - zlib
+       - libelf
+       - hdf5+mpi ^mvapich2@2.2
+       - hdf5+mpi ^openmpi@3.1.0
+
+This allows one to create toolchains out of combinations of
+constraints and apply them somewhat indiscriminately to packages,
+without regard for the applicability of the constraint.
+
+""""""""""""""""""""
 Spec List References
-^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""
 
 The last type of possible entry in the specs list is a reference.
 
@@ -766,9 +674,9 @@ The valid variables for a ``when`` clause are:
 #. ``hostname``. The hostname of the system (if ``hostname`` is an
    executable in the user's PATH).
 
-^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""
 SpecLists as Constraints
-^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""
 
 Dependencies and compilers in Spack can be both packages in an
 environment and constraints on other packages. References to SpecLists
@@ -800,76 +708,66 @@ For example, the following environment has three root packages:
 This allows for a much-needed reduction in redundancy between packages
 and constraints.
 
-----------------
-Filesystem Views
-----------------
+^^^^^^^^^^^^^^^^^^^^^^^^^
+Environment-managed Views
+^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Spack Environments can define filesystem views, which provide a direct access point
-for software similar to the directory hierarchy that might exist under ``/usr/local``.
-Filesystem views are updated every time the environment is written out to the lock
-file ``spack.lock``, so the concrete environment and the view are always compatible.
-The files of the view's installed packages are brought into the view by symbolic or
-hard links, referencing the original Spack installation, or by copy.
+Spack Environments can define filesystem views of their software,
+which are maintained as packages and can be installed and uninstalled from
+the Environment. Filesystem views provide an access point for packages
+from the filesystem for users who want to access those packages
+directly. For more information on filesystem views, see the section
+:ref:`filesystem-views`.
+
+Spack Environment managed views are updated every time the environment
+is written out to the lock file ``spack.lock``, so the concrete
+environment and the view are always compatible.
 
 .. _configuring_environment_views:
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Configuration in ``spack.yaml``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+"""""""""""""""""""""""""""""
+Configuring environment views
+"""""""""""""""""""""""""""""
 
 The Spack Environment manifest file has a top-level keyword
-``view``. Each entry under that heading is a **view descriptor**, headed
-by a name. Any number of views may be defined under the ``view`` heading.
-The view descriptor contains the root of the view, and
+``view``. Each entry under that heading is a view descriptor, headed
+by a name. The view descriptor contains the root of the view, and
 optionally the projections for the view, ``select`` and
 ``exclude`` lists for the view and link information via ``link`` and
-``link_type``.
-
-For example, in the following manifest
+``link_type``. For example, in the following manifest
 file snippet we define a view named ``mpis``, rooted at
 ``/path/to/view`` in which all projections use the package name,
 version, and compiler name to determine the path for a given
 package. This view selects all packages that depend on MPI, and
 excludes those built with the PGI compiler at version 18.5.
-The root specs with their (transitive) link and run type dependencies
-will be put in the view due to the  ``link: all`` option,
-and the files in the view will be symlinks to the spack install
-directories.
+All the dependencies of each root spec in the environment will be linked
+in the view due to the command ``link: all`` and the files in the view will
+be symlinks to the spack install directories.
 
 .. code-block:: yaml
 
    spack:
-     # ...
+     ...
      view:
        mpis:
          root: /path/to/view
          select: [^mpi]
          exclude: ['%pgi@18.5']
          projections:
-           all: '{name}/{version}-{compiler.name}'
+           all: {name}/{version}-{compiler.name}
          link: all
          link_type: symlink
 
-The default for the ``select`` and
+For more information on using view projections, see the section on
+:ref:`adding_projections_to_views`. The default for the ``select`` and
 ``exclude`` values is to select everything and exclude nothing. The
 default projection is the default view projection (``{}``). The ``link``
-attribute allows the following values:
-
-#. ``link: all`` include root specs with their transitive run and link type
-   dependencies (default);
-#. ``link: run`` include root specs with their transitive run type dependencies;
-#. ``link: roots`` include root specs without their dependencies.
-
-The ``link_type`` defaults to ``symlink`` but can also take the value
-of ``hardlink`` or ``copy``.
-
-.. tip::
-
-   The option ``link: run`` can be used to create small environment views for
-   Python packages. Python will be able to import packages *inside* of the view even
-   when the environment is not activated, and linked libraries will be located
-   *outside* of the view thanks to rpaths.
+defaults to ``all`` but can also be ``roots`` when only the root specs
+in the environment are desired in the view. The ``link_type`` defaults
+to ``symlink`` but can also take the value of ``hardlink`` or ``copy``.
 
+Any number of views may be defined under the ``view`` heading in a
+Spack Environment.
 
 There are two shorthands for environments with a single view. If the
 environment at ``/path/to/env`` has a single view, with a root at
@@ -883,7 +781,7 @@ automatically named ``default``, so that
 .. code-block:: yaml
 
    spack:
-     # ...
+     ...
      view: True
 
 is equivalent to
@@ -891,7 +789,7 @@ is equivalent to
 .. code-block:: yaml
 
    spack:
-     # ...
+     ...
      view:
        default:
          root: .spack-env/view
@@ -901,7 +799,7 @@ and
 .. code-block:: yaml
 
    spack:
-     # ...
+     ...
      view: /path/to/view
 
 is equivalent to
@@ -909,7 +807,7 @@ is equivalent to
 .. code-block:: yaml
 
    spack:
-     # ...
+     ...
      view:
        default:
          root: /path/to/view
@@ -935,58 +833,9 @@ regenerate`` will regenerate the views for the environment. This will
 apply any updates in the environment configuration that have not yet
 been applied.
 
-.. _view_projections:
-
-""""""""""""""""
-View Projections
-""""""""""""""""
-The default projection into a view is to link every package into the
-root of the view. The projections attribute is a mapping of partial specs to
-spec format strings, defined by the :meth:`~spack.spec.Spec.format`
-function, as shown in the example below:
-
-.. code-block:: yaml
-
-   projections:
-     zlib: "{name}-{version}"
-     ^mpi: "{name}-{version}/{^mpi.name}-{^mpi.version}-{compiler.name}-{compiler.version}"
-     all: "{name}-{version}/{compiler.name}-{compiler.version}"
-
-Projections also permit environment and spack configuration variable
-expansions as shown below:
-
-.. code-block:: yaml
-
-   projections:
-     all: "{name}-{version}/{compiler.name}-{compiler.version}/$date/$SYSTEM_ENV_VARIBLE"
-
-where ``$date`` is the spack configuration variable that will expand with the ``YYYY-MM-DD``
-format and ``$SYSTEM_ENV_VARIABLE`` is an environment variable defined in the shell.
-
-The entries in the projections configuration file must all be either
-specs or the keyword ``all``. For each spec, the projection used will
-be the first non-``all`` entry that the spec satisfies, or ``all`` if
-there is an entry for ``all`` and no other entry is satisfied by the
-spec. Where the keyword ``all`` appears in the file does not
-matter.
-
-Given the example above, the spec ``zlib@1.2.8``
-will be linked into ``/my/view/zlib-1.2.8/``, the spec
-``hdf5@1.8.10+mpi %gcc@4.9.3 ^mvapich2@2.2`` will be linked into
-``/my/view/hdf5-1.8.10/mvapich2-2.2-gcc-4.9.3``, and the spec
-``hdf5@1.8.10~mpi %gcc@4.9.3`` will be linked into
-``/my/view/hdf5-1.8.10/gcc-4.9.3``.
-
-If the keyword ``all`` does not appear in the projections
-configuration file, any spec that does not satisfy any entry in the
-file will be linked into the root of the view as in a single-prefix
-view. Any entries that appear below the keyword ``all`` in the
-projections configuration file will not be used, as all specs will use
-the projection under ``all`` before reaching those entries.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""""""
 Activating environment views
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""""""
 
 The ``spack env activate`` command will put the default view for the
 environment into the user's path, in addition to activating the
@@ -1006,6 +855,9 @@ Variable            Paths
 PATH                bin
 MANPATH             man, share/man
 ACLOCAL_PATH        share/aclocal
+LD_LIBRARY_PATH     lib, lib64
+LIBRARY_PATH        lib, lib64
+CPATH               include
 PKG_CONFIG_PATH     lib/pkgconfig, lib64/pkgconfig, share/pkgconfig
 CMAKE_PREFIX_PATH   .
 =================== =========
@@ -1017,169 +869,3 @@ environment.
 
 The ``spack env deactivate`` command will remove the default view of
 the environment from the user's path.
-
-
-.. _env-generate-depfile:
-
-
-------------------------------------------
-Generating Depfiles from Environments
-------------------------------------------
-
-Spack can generate ``Makefile``\s to make it easier to build multiple
-packages in an environment in parallel. Generated ``Makefile``\s expose
-targets that can be included in existing ``Makefile``\s, to allow
-other targets to depend on the environment installation.
-
-A typical workflow is as follows:
-
-.. code:: console
-
-   spack env create -d .
-   spack -e . add perl
-   spack -e . concretize
-   spack -e . env depfile -o Makefile
-   make -j64
-
-This generates a ``Makefile`` from a concretized environment in the
-current working directory, and ``make -j64`` installs the environment,
-exploiting parallelism across packages as much as possible. Spack
-respects the Make jobserver and forwards it to the build environment
-of packages, meaning that a single ``-j`` flag is enough to control the
-load, even when packages are built in parallel.
-
-By default the following phony convenience targets are available:
-
-- ``make all``: installs the environment (default target);
-- ``make clean``: cleans files used by make, but does not uninstall packages.
-
-.. tip::
-
-   GNU Make version 4.3 and above have great support for output synchronization
-   through the ``-O`` and ``--output-sync`` flags, which ensure that output is
-   printed orderly per package install. To get synchronized output with colors,
-   use ``make -j<N> SPACK_COLOR=always --output-sync=recurse``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Specifying dependencies on generated ``make`` targets
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-An interesting question is how to include generated ``Makefile``\s in your own
-``Makefile``\s. This comes up when you want to install an environment that provides
-executables required in a command for a make target of your own.
-
-The example below shows how to accomplish this: the ``env`` target specifies
-the generated ``spack/env`` target as a prerequisite, meaning that the environment
-gets installed and is available for use in the ``env`` target.
-
-.. code:: Makefile
-
-   SPACK ?= spack
-
-   .PHONY: all clean env
-
-   all: env
-
-   spack.lock: spack.yaml
-   	$(SPACK) -e . concretize -f
-
-   env.mk: spack.lock
-   	$(SPACK) -e . env depfile -o $@ --make-prefix spack
-
-   env: spack/env
-   	$(info Environment installed!)
-
-   clean:
-   	rm -rf spack.lock env.mk spack/
-
-   ifeq (,$(filter clean,$(MAKECMDGOALS)))
-   include env.mk
-   endif
-
-This works as follows: when ``make`` is invoked, it first "remakes" the missing
-include ``env.mk`` as there is a target for it. This triggers concretization of
-the environment and makes spack output ``env.mk``. At that point the
-generated target ``spack/env`` becomes available through ``include env.mk``.
-
-As it is typically undesirable to remake ``env.mk`` as part of ``make clean``,
-the include is conditional.
-
-.. note::
-
-   When including generated ``Makefile``\s, it is important to use
-   the ``--make-prefix`` flag and use the non-phony target
-   ``<prefix>/env`` as prerequisite, instead of the phony target
-   ``<prefix>/all``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Building a subset of the environment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The generated ``Makefile``\s contain install targets for each spec, identified
-by ``<name>-<version>-<hash>``. This allows you to install only a subset of the
-packages in the environment. When packages are unique in the environment, it's
-enough to know the name and let tab-completion fill out the version and hash.
-
-The following phony targets are available: ``install/<spec>`` to install the
-spec with its dependencies, and ``install-deps/<spec>`` to *only* install
-its dependencies. This can be useful when certain flags should only apply to
-dependencies. Below we show a use case where a spec is installed with verbose
-output (``spack install --verbose``) while its dependencies are installed silently:
-
-.. code:: console
-
-   $ spack env depfile -o Makefile
-
-   # Install dependencies in parallel, only show a log on error.
-   $ make -j16 install-deps/python-3.11.0-<hash> SPACK_INSTALL_FLAGS=--show-log-on-error
-
-   # Install the root spec with verbose output.
-   $ make -j16 install/python-3.11.0-<hash> SPACK_INSTALL_FLAGS=--verbose
-
-^^^^^^^^^^^^^^^^^^^^^^^^^
-Adding post-install hooks
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Another advanced use-case of generated ``Makefile``\s is running a post-install
-command for each package. These "hooks" could be anything from printing a
-post-install message, running tests, or pushing just-built binaries to a buildcache.
-
-This can be accomplished through the generated ``[<prefix>/]SPACK_PACKAGE_IDS``
-variable. Assuming we have an active and concrete environment, we generate the
-associated ``Makefile`` with a prefix ``example``:
-
-.. code:: console
-
-   $ spack env depfile -o env.mk --make-prefix example
-
-And we now include it in a different ``Makefile``, in which we create a target
-``example/push/%`` with ``%`` referring to a package identifier. This target
-depends on the particular package installation. In this target we automatically
-have the target-specific ``HASH`` and ``SPEC`` variables at our disposal. They
-are respectively the spec hash (excluding leading ``/``), and a human-readable spec.
-Finally, we have an entrypoint target ``push`` that will update the buildcache
-index once every package is pushed. Note how this target uses the generated
-``example/SPACK_PACKAGE_IDS`` variable to define its prerequisites.
-
-.. code:: Makefile
-
-   SPACK ?= spack
-   BUILDCACHE_DIR = $(CURDIR)/tarballs
-
-   .PHONY: all
-
-   all: push
-
-   include env.mk
-
-   example/push/%: example/install/%
-   	@mkdir -p $(dir $@)
-   	$(info About to push $(SPEC) to a buildcache)
-   	$(SPACK) -e . buildcache push --allow-root --only=package $(BUILDCACHE_DIR) /$(HASH)
-   	@touch $@
-
-   push: $(addprefix example/push/,$(example/SPACK_PACKAGE_IDS))
-   	$(info Updating the buildcache index)
-   	$(SPACK) -e . buildcache update-index $(BUILDCACHE_DIR)
-   	$(info Done!)
-   	@touch $@

lib/spack/docs/extensions.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -9,42 +9,47 @@
 Custom Extensions
 =================
 
-*Spack extensions* allow you to extend Spack capabilities by deploying your
+*Spack extensions* permit you to extend Spack capabilities by deploying your
 own custom commands or logic in an arbitrary location on your filesystem.
 This might be extremely useful e.g. to develop and maintain a command whose purpose is
 too specific to be considered for reintegration into the mainline or to
 evolve a command through its early stages before starting a discussion to merge
 it upstream.
-
 From Spack's point of view an extension is any path in your filesystem which
-respects the following naming and layout for files:
+respects a prescribed naming and layout for files:
 
 .. code-block:: console
 
   spack-scripting/ # The top level directory must match the format 'spack-{extension_name}'
   ├── pytest.ini # Optional file if the extension ships its own tests
   ├── scripting # Folder that may contain modules that are needed for the extension commands
-  │   ├── cmd # Folder containing extension commands
-  │   │   └── filter.py # A new command that will be available
-  │   └── functions.py # Module with internal details
-  └── tests # Tests for this extension
+  │   └── cmd # Folder containing extension commands
+  │       └── filter.py # A new command that will be available
+  ├── tests # Tests for this extension
   │   ├── conftest.py
   │   └── test_filter.py
   └── templates # Templates that may be needed by the extension
 
-In the example above, the extension is named *scripting*. It adds an additional command
-(``spack filter``) and unit tests to verify its behavior.
+In the example above the extension named *scripting* adds an additional command (``filter``)
+and unit tests to verify its behavior. The code for this example can be
+obtained by cloning the corresponding git repository:
 
-The extension can import any core Spack module in its implementation. When loaded by
-the ``spack`` command, the extension itself is imported as a Python package in the
-``spack.extensions`` namespace. In the example above, since the extension is named
-"scripting", the corresponding Python module is ``spack.extensions.scripting``.
-
-The code for this example extension can be obtained by cloning the corresponding git repository:
+.. TODO: write an ad-hoc "hello world" extension and make it part of the spack organization
 
 .. code-block:: console
 
-   $ git -C /tmp clone https://github.com/spack/spack-scripting.git
+   $ pwd
+   /home/user
+   $ mkdir tmp && cd tmp
+   $ git clone https://github.com/alalazo/spack-scripting.git
+   Cloning into 'spack-scripting'...
+   remote: Counting objects: 11, done.
+   remote: Compressing objects: 100% (7/7), done.
+   remote: Total 11 (delta 0), reused 11 (delta 0), pack-reused 0
+   Receiving objects: 100% (11/11), done.
+
+As you can see by inspecting the sources, Python modules that are part of the extension
+can import any core Spack module.
 
 ---------------------------------
 Configure Spack to Use Extensions
@@ -57,7 +62,7 @@ paths to ``config.yaml``. In the case of our example this means ensuring that:
 
    config:
      extensions:
-     - /tmp/spack-scripting
+     - /home/user/tmp/spack-scripting
 
 is part of your configuration file. Once this is setup any command that the extension provides
 will be available from the command line:
@@ -82,68 +87,37 @@ will be available from the command line:
      --implicit       select specs that are not installed or were installed implicitly
      --output OUTPUT  where to dump the result
 
-The corresponding unit tests can be run giving the appropriate options to ``spack unit-test``:
+The corresponding unit tests can be run giving the appropriate options
+to ``spack unit-test``:
 
 .. code-block:: console
 
    $ spack unit-test --extension=scripting
-   ========================================== test session starts ===========================================
-   platform linux -- Python 3.11.5, pytest-7.4.3, pluggy-1.3.0
-   rootdir: /home/culpo/github/spack-scripting
-   configfile: pytest.ini
-   testpaths: tests
-   plugins: xdist-3.5.0
+
+   ============================================================== test session starts ===============================================================
+   platform linux2 -- Python 2.7.15rc1, pytest-3.2.5, py-1.4.34, pluggy-0.4.0
+   rootdir: /home/mculpo/tmp/spack-scripting, inifile: pytest.ini
    collected 5 items
 
-   tests/test_filter.py .....                                                                         [100%]
+   tests/test_filter.py ...XX
+   ============================================================ short test summary info =============================================================
+   XPASS tests/test_filter.py::test_filtering_specs[flags3-specs3-expected3]
+   XPASS tests/test_filter.py::test_filtering_specs[flags4-specs4-expected4]
 
-   ========================================== slowest 30 durations ==========================================
-   2.31s setup    tests/test_filter.py::test_filtering_specs[kwargs0-specs0-expected0]
-   0.57s call     tests/test_filter.py::test_filtering_specs[kwargs2-specs2-expected2]
-   0.56s call     tests/test_filter.py::test_filtering_specs[kwargs4-specs4-expected4]
-   0.54s call     tests/test_filter.py::test_filtering_specs[kwargs3-specs3-expected3]
-   0.54s call     tests/test_filter.py::test_filtering_specs[kwargs1-specs1-expected1]
-   0.48s call     tests/test_filter.py::test_filtering_specs[kwargs0-specs0-expected0]
-   0.01s setup    tests/test_filter.py::test_filtering_specs[kwargs4-specs4-expected4]
-   0.01s setup    tests/test_filter.py::test_filtering_specs[kwargs2-specs2-expected2]
-   0.01s setup    tests/test_filter.py::test_filtering_specs[kwargs1-specs1-expected1]
-   0.01s setup    tests/test_filter.py::test_filtering_specs[kwargs3-specs3-expected3]
-
-   (5 durations < 0.005s hidden.  Use -vv to show these durations.)
-   =========================================== 5 passed in 5.06s ============================================
-
----------------------------------------
-Registering Extensions via Entry Points
----------------------------------------
-
-.. note::
-   Python version >= 3.8 is required to register extensions via entry points.
-
-Spack can be made aware of extensions that are installed as part of a python package.  To do so, register a function that returns the extension path, or paths, to the ``"spack.extensions"`` entry point.  Consider the Python package ``my_package`` that includes a Spack extension:
-
-.. code-block:: console
-
-  my-package/
-  ├── src
-  │   ├── my_package
-  │   │   └── __init__.py
-  │   └── spack-scripting/  # the spack extensions
-  └── pyproject.toml
-
-adding the following to ``my_package``'s ``pyproject.toml`` will make the ``spack-scripting`` extension visible to Spack when ``my_package`` is installed:
-
-.. code-block:: toml
-
-   [project.entry_points."spack.extenions"]
-   my_package = "my_package:get_extension_path"
-
-The function ``my_package.get_extension_path`` in ``my_package/__init__.py`` might look like
-
-.. code-block:: python
-
-   import importlib.resources
-
-   def get_extension_path():
-       dirname = importlib.resources.files("my_package").joinpath("spack-scripting")
-       if dirname.exists():
-           return str(dirname)
+   =========================================================== slowest 20 test durations ============================================================
+   3.74s setup    tests/test_filter.py::test_filtering_specs[flags0-specs0-expected0]
+   0.17s call     tests/test_filter.py::test_filtering_specs[flags3-specs3-expected3]
+   0.16s call     tests/test_filter.py::test_filtering_specs[flags2-specs2-expected2]
+   0.15s call     tests/test_filter.py::test_filtering_specs[flags1-specs1-expected1]
+   0.13s call     tests/test_filter.py::test_filtering_specs[flags4-specs4-expected4]
+   0.08s call     tests/test_filter.py::test_filtering_specs[flags0-specs0-expected0]
+   0.04s teardown tests/test_filter.py::test_filtering_specs[flags4-specs4-expected4]
+   0.00s setup    tests/test_filter.py::test_filtering_specs[flags4-specs4-expected4]
+   0.00s setup    tests/test_filter.py::test_filtering_specs[flags3-specs3-expected3]
+   0.00s setup    tests/test_filter.py::test_filtering_specs[flags1-specs1-expected1]
+   0.00s setup    tests/test_filter.py::test_filtering_specs[flags2-specs2-expected2]
+   0.00s teardown tests/test_filter.py::test_filtering_specs[flags2-specs2-expected2]
+   0.00s teardown tests/test_filter.py::test_filtering_specs[flags1-specs1-expected1]
+   0.00s teardown tests/test_filter.py::test_filtering_specs[flags0-specs0-expected0]
+   0.00s teardown tests/test_filter.py::test_filtering_specs[flags3-specs3-expected3]
+   ====================================================== 3 passed, 2 xpassed in 4.51 seconds =======================================================

lib/spack/docs/features.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -98,42 +98,40 @@ For example, this command:
 
 .. code-block:: console
 
-   $ spack create https://ftp.osuosl.org/pub/blfs/conglomeration/libelf/libelf-0.8.13.tar.gz
+   $ spack create http://www.mr511.de/software/libelf-0.8.13.tar.gz
 
 creates a simple python file:
 
 .. code-block:: python
 
-   from spack.package import *
+   from spack import *
 
 
-   class Libelf(AutotoolsPackage):
+   class Libelf(Package):
        """FIXME: Put a proper description of your package here."""
 
        # FIXME: Add a proper url for your package's homepage here.
-       homepage = "https://www.example.com"
-       url = "https://ftp.osuosl.org/pub/blfs/conglomeration/libelf/libelf-0.8.13.tar.gz"
+       homepage = "http://www.example.com"
+       url      = "http://www.mr511.de/software/libelf-0.8.13.tar.gz"
 
-       # FIXME: Add a list of GitHub accounts to
-       # notify when the package is updated.
-       # maintainers("github_user1", "github_user2")
-
-       version("0.8.13", sha256="591a9b4ec81c1f2042a97aa60564e0cb79d041c52faa7416acb38bc95bd2c76d")
+       version('0.8.13', '4136d7b4c04df68b686570afa26988ac')
 
        # FIXME: Add dependencies if required.
-       # depends_on("foo")
+       # depends_on('foo')
 
-       def configure_args(self):
-           # FIXME: Add arguments other than --prefix
-           # FIXME: If not needed delete this function
-           args = []
-           return args
+       def install(self, spec, prefix):
+           # FIXME: Modify the configure line to suit your build system here.
+           configure('--prefix={0}'.format(prefix))
+
+           # FIXME: Add logic to build and install here.
+           make()
+           make('install')
 
 It doesn't take much python coding to get from there to a working
 package:
 
 .. literalinclude:: _spack_root/var/spack/repos/builtin/packages/libelf/package.py
-   :lines: 5-
+   :lines: 6-
 
 Spack also provides wrapper functions around common commands like
 ``configure``, ``make``, and ``cmake`` to make writing packages

lib/spack/docs/frequently_asked_questions.rst

@@ -1,77 +0,0 @@
-.. Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-==========================
-Frequently Asked Questions
-==========================
-
-This page contains answers to frequently asked questions about Spack.
-If you have questions that are not answered here, feel free to ask on
-`Slack <https://slack.spack.io>`_ or `GitHub Discussions
-<https://github.com/spack/spack/discussions>`_. If you've learned the
-answer to a question that you think should be here, please consider
-contributing to this page.
-
-.. _faq-concretizer-precedence:
-
------------------------------------------------------
-Why does Spack pick particular versions and variants?
------------------------------------------------------
-
-This question comes up in a variety of forms:
-
- 1. Why does Spack seem to ignore my package preferences from ``packages.yaml`` config?
- 2. Why does Spack toggle a variant instead of using the default from the ``package.py`` file?
-
-The short answer is that Spack always picks an optimal configuration
-based on a complex set of criteria\ [#f1]_. These criteria are more nuanced
-than always choosing the latest versions or default variants.
-
-.. note::
-
-    As a rule of thumb: requirements + constraints > reuse > preferences > defaults.
-
-The following set of criteria (from lowest to highest precedence) explain
-common cases where concretization output may seem surprising at first.
-
-1. :ref:`Package preferences <package-preferences>` configured in ``packages.yaml``
-   override variant defaults from ``package.py`` files, and influence the optimal
-   ordering of versions. Preferences are specified as follows:
-
-   .. code-block:: yaml
-
-      packages:
-        foo:
-          version: [1.0, 1.1]
-          variants: ~mpi
-
-2. :ref:`Reuse concretization <concretizer-options>` configured in ``concretizer.yaml``
-   overrides preferences, since it's typically faster to reuse an existing spec than to
-   build a preferred one from sources. When build caches are enabled, specs may be reused
-   from a remote location too. Reuse concretization is configured as follows:
-
-   .. code-block:: yaml
-
-      concretizer:
-        reuse: dependencies  # other options are 'true' and 'false'
-
-3. :ref:`Package requirements <package-requirements>` configured in ``packages.yaml``,
-   and constraints from the command line as well as ``package.py`` files override all
-   of the above. Requirements are specified as follows:
-
-   .. code-block:: yaml
-
-      packages:
-        foo:
-          require:
-          - "@1.2: +mpi"
-
-Requirements and constraints restrict the set of possible solutions, while reuse
-behavior and preferences influence what an optimal solution looks like.
-
-
-.. rubric:: Footnotes
-
-.. [#f1] The exact list of criteria can be retrieved with the ``spack solve`` command