Update commands auto completion

.codecov.yml

@@ -5,7 +5,7 @@ coverage:
   status:
     project:
       default:
-        threshold: 2.0%
+        threshold: 0.3%
 
 ignore:
   - lib/spack/spack/test/.*
@@ -14,21 +14,3 @@ ignore:
   - share/spack/qa/.*
 
 comment: off
-
-# Inline codecov annotations make the code hard to read, and they add
-# annotations in files that seemingly have nothing to do with the PR.
-github_checks:
-    annotations: false
-
-# Attempt to fix "Missing base commit" messages in the codecov UI.
-# Because we do not run full tests on package PRs, package PRs' merge
-# commits on `develop` don't have coverage info.  It appears that
-# codecov will give you an error if the pseudo-base's coverage data
-# doesn't all apply properly to the real PR base.
-#
-# See here for docs:
-#   https://docs.codecov.com/docs/comparing-commits#pseudo-comparison
-# See here for another potential solution:
-#   https://community.codecov.com/t/2480/15
-codecov:
-  allow_coverage_offsets: true

.coveragerc

@@ -0,0 +1,36 @@
+# -*- conf -*-
+# .coveragerc to control coverage.py
+[run]
+parallel = True
+concurrency = multiprocessing
+branch = True
+source = lib
+omit =
+     lib/spack/spack/test/*
+     lib/spack/docs/*
+     lib/spack/external/*
+     share/spack/qa/*
+
+[report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if self\.debug
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if False:
+    if __name__ == .__main__.:
+
+ignore_errors = True
+
+[html]
+directory = htmlcov

.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

.devcontainer/ubuntu20.04/devcontainer.json

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

.devcontainer/ubuntu22.04/devcontainer.json

@@ -1,5 +0,0 @@
-{
-  "name": "Ubuntu 22.04",
-  "image": "ghcr.io/spack/ubuntu-22.04:v2024-05-07",
-  "postCreateCommand": "./.devcontainer/postCreateCommand.sh"
-}

.dockerignore

@@ -8,4 +8,4 @@ share/spack/dotkit/*
 share/spack/lmod/*
 share/spack/modules/*
 lib/spack/spack/test/*
-var/spack/cache/*
+

.flake8

@@ -1,56 +1,32 @@
 # -*- 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
-# - F405: undefined name or from *
-# - F821: undefined name (needed with from/import *)
+# 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
 #
 [flake8]
-#ignore = E129,,W503,W504,F999,N801,N813,N814,F403,F405,E203
-extend-ignore = E731,E203
-max-line-length = 99
-
-# F4: Import
-# - F405: `name` may be undefined, or undefined from star imports: `module`
-#
-# F8: Name
-# - F821: undefined name `name`
-#
-per-file-ignores =
-  var/spack/repos/*/package.py:F403,F405,F821
-  *-ci-package.py:F403,F405,F821
-
-# exclude things we usually do not want linting for.
-# These still get linted when passed explicitly, as when spack flake8 passes
-# them on the command line.
-exclude =
-  .git
-  etc/
-  opt/
-  share/
-  var/spack/cache/
-  var/spack/gpg*/
-  var/spack/junit-report/
-  var/spack/mock-configs/
-  lib/spack/external
-  __pycache__
-  var
-
-format = spack
-
-[flake8:local-plugins]
-report =
-  spack = flake8_formatter:SpackFormatter
-paths =
-  ./share/spack/qa/
+ignore = E129,E221,E241,E272,E731,W503,W504,F999,N801,N813,N814
+max-line-length = 79

.flake8_packages

@@ -0,0 +1,24 @@
+# -*- conf -*-
+# flake8 settings for Spack package files.
+#
+# This should include all the same exceptions that we use for core files.
+#
+# In Spack packages, we also allow the single `from spack import *`
+# wildcard import and dependencies can set globals for their
+# dependents. So we add exceptions for checks related to undefined names.
+#
+# Note that we also add *per-line* exemptions for certain patterns in the
+# `spack flake8` command.  This is where F403 for `from spack import *`
+# is added (beause we *only* allow that wildcard).
+#
+# See .flake8 for regular exceptions.
+#
+# F4: Import
+# - F405: `name` may be undefined, or undefined from star imports: `module`
+#
+# F8: Name
+# - F821: undefined name `name`
+#
+[flake8]
+ignore = E129,E221,E241,E272,E731,W503,W504,F405,F821,F999,N801,N813,N814
+max-line-length = 79

.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 @@
 *.py diff=python
-*.lp linguist-language=Prolog
-lib/spack/external/* linguist-vendored
-*.bat text eol=crlf

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,49 @@
+---
+name: Bug report 
+about: Report a bug in the core of Spack (command not working as expected, etc.) 
+labels: bug
+---
+
+
+*Explain, in a clear and concise way, the command you ran and the result you were trying to achieve.
+Example: "I ran Spack find to list all the installed packages and..."*
+
+
+
+### Steps to reproduce the issue
+
+```console
+$ spack <command1> <spec>
+$ spack <command2> <spec>
+...
+```
+
+### Error Message
+
+If Spack reported an error, provide the error message. If it did not report an error
+but the output appears incorrect, provide the incorrect output. If there was no error
+message and no output but the result is incorrect, describe how it does not match
+what you expect. To provide more information you might re-run the commands with 
+the additional -d/--stacktrace flags:
+```console
+$ spack -d --stacktrace <command1> <spec>
+$ spack -d --stacktrace <command2> <spec>
+...
+```
+that activate the full debug output. 
+
+
+### Information on your system
+
+This includes:
+
+ 1. which platform you are using
+ 2. any relevant configuration detail (custom `packages.yaml` or `modules.yaml`, etc.)
+
+-----
+
+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!
+
+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 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/bug_report.yml

@@ -1,58 +0,0 @@
-name: "\U0001F41E Bug report"
-description: Report a bug in the core of Spack (command not working as expected, etc.)
-labels: [bug, triage]
-body:
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: Steps to reproduce
-      description: |
-        Explain, in a clear and concise way, the command you ran and the result you were trying to achieve.
-        Example: "I ran `spack find` to list all the installed packages and ..."
-      placeholder: |
-        ```console
-        $ spack <command1> <spec>
-        $ spack <command2> <spec>
-        ...
-        ```
-    validations:
-      required: true
-  - type: textarea
-    id: error
-    attributes:
-      label: Error message
-      description: |
-        If Spack reported an error, provide the error message. If it did not report an error but the output appears incorrect, provide the incorrect output. If there was no error message and no output but the result is incorrect, describe how it does not match what you expect.
-      placeholder: |
-        ```console
-        $ spack --debug --stacktrace <command>
-        ```
-  - type: textarea
-    id: information
-    attributes:
-      label: Information on your system
-      description: Please include the output of `spack debug report`
-    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: checkboxes
-    id: checks
-    attributes:
-      label: General information
-      options:
-        - label: I have run `spack debug report` and reported the version of Spack/Python/Platform
-          required: true
-        - label: I have searched the issues of this repo and believe this is not a duplicate
-          required: true
-        - label: I have run the failing commands in debug mode and reported the output
-          required: true
-  - type: markdown
-    attributes:
-      value: |
-        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!
-        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/build_error.md

@@ -0,0 +1,78 @@
+---
+name: Build error 
+about: Some package in Spack didn't build correctly  
+labels: "build-error"
+---
+
+*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.
+3. Remove the template instructions before posting the issue.
+
+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!
+
+
+---
+
+### Steps to reproduce the issue
+
+```console
+$ spack install <spec> # Fill in the exact spec you are using
+... # and the relevant part of the error message
+```
+
+### Platform and user environment
+
+Please report your OS here:
+```commandline
+$ uname -a 
+Linux nuvolari 4.15.0-29-generic #31-Ubuntu SMP Tue Jul 17 15:39:52 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
+$ lsb_release -d
+Description:	Ubuntu 18.04.1 LTS
+``` 
+and, if relevant, post or attach:
+
+- `packages.yaml`
+- `compilers.yaml`
+
+to the issue
+
+### Additional information
+
+Sometimes the issue benefits from additional details. In these cases there are
+a few things we can suggest doing. First of all, you can post the full output of:
+```console
+$ spack spec --install-status <spec>
+...
+```
+to show people whether Spack installed a faulty software or if it was not able to
+build it at all. 
+
+If your build didn't make it past the configure stage, Spack as also commands to parse 
+logs and report error and warning messages:
+```console
+$ spack log-parse --show=errors,warnings <file-to-parse>
+```
+You might want to run this command on the `config.log` or any other similar file
+found in the stage directory: 
+```console
+$ spack location -s <spec>
+```
+In case in `config.log` there are other settings that you think might be the cause 
+of the build failure, you can consider attaching the file to this issue.
+
+Rebuilding the package with the following options:
+```console
+$ spack -d install -j 1 <spec>
+...
+```
+will provide additional debug information. After the failure you will find two files in the current directory:
+
+1. `spack-cc-<spec>.in`, which contains details on the command given in input 
+    to Spack's compiler wrapper  
+1. `spack-cc-<spec>.out`, which contains the command used to compile / link the 
+    failed object after Spack's compiler wrapper did its processing 
+
+You can post or attach those files to provide maintainers with more information on what
+is causing the failure.

.github/ISSUE_TEMPLATE/build_error.yml

@@ -1,76 +0,0 @@
-name: "\U0001F4A5 Build error"
-description: Some package in Spack didn't build correctly
-title: "Installation issue: "
-labels: [build-error]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        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: |
-        ```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
-      description: Please include the output of `spack debug report`.
-    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 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:
-      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 run `spack debug report` and reported the version of Spack/Python/Platform
-          required: true
-        - label: I have run `spack maintainers <name-of-the-package>` and **@mentioned** any maintainers
-          required: true
-        - label: I have uploaded the build log and environment files
-          required: true
-        - label: I have searched the issues of this repo and believe this is not a duplicate
-          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +0,0 @@
-blank_issues_enabled: true

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,28 @@
+---
+name: Feature request 
+about: Suggest adding a feature that is not yet in Spack  
+labels: feature
+
+---
+
+*Please add a concise summary of your suggestion here.*
+
+### Rationale
+
+*Is your feature request related to a problem? Please describe it!*
+
+### Description
+
+*Describe the solution you'd like and the alternatives you have considered.*
+
+
+### Additional information
+*Add any other context about the feature request here.*
+
+
+-----
+
+
+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 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/feature_request.yml

@@ -1,39 +0,0 @@
-name: "\U0001F38A Feature request"
-description: Suggest adding a feature that is not yet in Spack
-labels: [feature]
-body:
-  - type: textarea
-    id: summary
-    attributes:
-      label: Summary
-      description: Please add a concise summary of your suggestion here.
-    validations:
-      required: true
-  - type: textarea
-    id: rationale
-    attributes:
-      label: Rationale
-      description: Is your feature request related to a problem? Please describe it!
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: Describe the solution you'd like and the alternatives you have considered.
-  - type: textarea
-    id: additional_information
-    attributes:
-      label: Additional information
-      description: Add any other context about the feature request here.
-  - type: checkboxes
-    id: checks
-    attributes:
-      label: General information
-      options:
-        - 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/actions/add-maintainers-as-reviewers/Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.7-alpine
+
+RUN pip install pygithub
+
+ADD entrypoint.py /entrypoint.py
+ENTRYPOINT ["/entrypoint.py"]

.github/actions/add-maintainers-as-reviewers/entrypoint.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+#
+# Copyright 2013-2020 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)
+
+"""Maintainer review action.
+
+This action checks which packages have changed in a PR, and adds their
+maintainers to the pull request for review.
+"""
+
+import json
+import os
+import re
+import subprocess
+
+from github import Github
+
+
+def spack(*args):
+    """Run the spack executable with arguments, and return the output split.
+
+    This does just enough to run `spack pkg` and `spack maintainers`, the
+    two commands used by this action.
+    """
+    github_workspace = os.environ['GITHUB_WORKSPACE']
+    spack = os.path.join(github_workspace, 'bin', 'spack')
+    output = subprocess.check_output([spack] + list(args))
+    split = re.split(r'\s*', output.decode('utf-8').strip())
+    return [s for s in split if s]
+
+
+def main():
+    # get these first so that we'll fail early
+    token = os.environ['GITHUB_TOKEN']
+    event_path = os.environ['GITHUB_EVENT_PATH']
+
+    with open(event_path) as file:
+        data = json.load(file)
+
+    # make sure it's a pull_request event
+    assert 'pull_request' in data
+
+    # only request reviews on open, edit, or reopen
+    action = data['action']
+    if action not in ('opened', 'edited', 'reopened'):
+        return
+
+    # get data from the event payload
+    pr_data             = data['pull_request']
+    base_branch_name    = pr_data['base']['ref']
+    full_repo_name      = pr_data['base']['repo']['full_name']
+    pr_number           = pr_data['number']
+    requested_reviewers = pr_data['requested_reviewers']
+    author              = pr_data['user']['login']
+
+    # get a list of packages that this PR modified
+    changed_pkgs = spack(
+        'pkg', 'changed', '--type', 'ac', '%s...' % base_branch_name)
+
+    # get maintainers for all modified packages
+    maintainers = set()
+    for pkg in changed_pkgs:
+        pkg_maintainers = set(spack('maintainers', pkg))
+        maintainers |= pkg_maintainers
+
+    # remove any maintainers who are already on the PR, and the author,
+    # as you can't review your own PR)
+    maintainers -= set(requested_reviewers)
+    maintainers -= set([author])
+
+    if not maintainers:
+        return
+
+    # request reviews from each maintainer
+    gh = Github(token)
+    repo = gh.get_repo(full_repo_name)
+    pr = repo.get_pull(pr_number)
+    pr.create_review_request(list(maintainers))
+
+
+if __name__ == "__main__":
+    main()

.github/dependabot.yml

@@ -1,14 +0,0 @@
-version: 2
-updates:
-  # Maintain dependencies for GitHub Actions
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "daily"
-  # Requirements to run style checks and build documentation
-  - package-ecosystem: "pip"
-    directories:
-     - "/.github/workflows/requirements/style/*"
-     - "/lib/spack/docs"
-    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,74 +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.system.os }}
-    strategy:
-      matrix:
-        system:
-        - { os: windows-latest, shell: 'powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}' }
-        - { os: ubuntu-latest, shell: bash }
-        - { os: macos-latest, shell: bash }
-    defaults:
-      run:
-        shell: ${{ matrix.system.shell }}
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      with:
-        python-version: ${{inputs.python_version}}
-    - name: Install Python packages
-      run: |
-        pip install --upgrade pip setuptools pytest coverage[toml]
-    - name: Setup for Windows run
-      if: runner.os == 'Windows'
-      run: |
-        python -m pip install --upgrade pywin32
-    - name: Package audits (with coverage)
-      env:
-          COVERAGE_FILE: coverage/.coverage-audits-${{ matrix.system.os }}
-      if: ${{ inputs.with_coverage == 'true' && runner.os != 'Windows' }}
-      run: |
-          . share/spack/setup-env.sh
-          coverage run $(which spack) audit packages
-          coverage run $(which spack) audit configs
-          coverage run $(which spack) -d audit externals
-          coverage combine
-    - name: Package audits (without coverage)
-      if: ${{ inputs.with_coverage == 'false' && runner.os != 'Windows' }}
-      run: |
-          . share/spack/setup-env.sh
-          spack -d audit packages
-          spack -d audit configs
-          spack -d audit externals
-    - name: Package audits (without coverage)
-      if: ${{ runner.os == 'Windows' }}
-      run: |
-          . share/spack/setup-env.sh
-          spack -d audit packages
-          ./share/spack/qa/validate_last_exit.ps1
-          spack -d audit configs
-          ./share/spack/qa/validate_last_exit.ps1
-          spack -d audit externals
-          ./share/spack/qa/validate_last_exit.ps1
-    - uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b
-      if: ${{ inputs.with_coverage == 'true' && runner.os != 'Windows' }}
-      with:
-        name: coverage-audits-${{ matrix.system.os }}
-        path: coverage
-        include-hidden-files: true

.github/workflows/bin/bootstrap-test.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-set -e
-source share/spack/setup-env.sh
-$PYTHON bin/spack bootstrap disable github-actions-v0.5
-$PYTHON bin/spack bootstrap disable spack-install
-$PYTHON bin/spack $SPACK_FLAGS solve zlib
-tree $BOOTSTRAP/store
-exit 0

.github/workflows/bin/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/bin/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/bin/setup_git.ps1

@@ -1,8 +0,0 @@
-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/bin/setup_git.sh

@@ -1,8 +0,0 @@
-#!/bin/bash -e
-git config --global user.email "spack@example.com"
-git config --global user.name "Test User"
-
-# create a local pr base branch
-if [[ -n $GITHUB_BASE_REF ]]; then
-    git fetch origin "${GITHUB_BASE_REF}:${GITHUB_BASE_REF}"
-fi

.github/workflows/bin/system_shortcut_check.ps1

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

.github/workflows/bootstrap.yml

@@ -1,194 +0,0 @@
-name: Bootstrapping
-
-on:
-  # This Workflow can be triggered manually
-  workflow_dispatch:
-  workflow_call:
-  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:
-  distros-clingo-sources:
-    runs-on: ubuntu-latest
-    container: ${{ matrix.image }}
-    strategy:
-      matrix:
-        image: ["fedora:latest", "opensuse/leap:latest"]
-    steps:
-      - name: Setup Fedora
-        if: ${{ matrix.image == 'fedora:latest' }}
-        run: |
-          dnf install -y \
-              bzip2 curl file gcc-c++ gcc gcc-gfortran git gzip \
-              make patch unzip which xz python3 python3-devel tree \
-              cmake bison bison-devel libstdc++-static
-      - name: Setup OpenSUSE
-        if: ${{ matrix.image == 'opensuse/leap:latest' }}
-        run: |
-          # Harden CI by applying the workaround described here: https://www.suse.com/support/kb/doc/?id=000019505
-          zypper update -y || zypper update -y
-          zypper install -y \
-              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@11bd71901bbe5b1630ceea73d27597364c9af683
-        with:
-          fetch-depth: 0
-      - name: Bootstrap clingo
-        run: |
-          source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.6
-          spack bootstrap disable github-actions-v0.5
-          spack external find cmake bison
-          spack -d solve zlib
-          tree ~/.spack/bootstrap/store/
-
-  clingo-sources:
-    runs-on: ${{ matrix.runner }}
-    strategy:
-      matrix:
-        runner: ['macos-13', 'macos-14', "ubuntu-latest"]
-    steps:
-      - name: Setup macOS
-        if: ${{ matrix.runner != 'ubuntu-latest' }}
-        run: |
-          brew install cmake bison tree
-      - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-        with:
-          python-version: "3.12"
-      - name: Bootstrap clingo
-        run: |
-          source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.6
-          spack bootstrap disable github-actions-v0.5
-          spack external find --not-buildable cmake bison
-          spack -d solve zlib
-          tree $HOME/.spack/bootstrap/store/
-
-  gnupg-sources:
-    runs-on: ${{ matrix.runner }}
-    strategy:
-      matrix:
-        runner: [ 'macos-13', 'macos-14', "ubuntu-latest" ]
-    steps:
-      - name: Setup macOS
-        if: ${{ matrix.runner != 'ubuntu-latest' }}
-        run: brew install tree gawk
-      - name: Remove system executables
-        run: |
-          while [ -n "$(command -v gpg gpg2 patchelf)" ]; do
-            sudo rm $(command -v gpg gpg2 patchelf)
-          done
-      - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-        with:
-          fetch-depth: 0
-      - name: Bootstrap GnuPG
-        run: |
-          source share/spack/setup-env.sh
-          spack solve zlib
-          spack bootstrap disable github-actions-v0.6
-          spack bootstrap disable github-actions-v0.5
-          spack -d gpg list
-          tree ~/.spack/bootstrap/store/
-
-  from-binaries:
-    runs-on: ${{ matrix.runner }}
-    strategy:
-      matrix:
-        runner: ['macos-13', 'macos-14', "ubuntu-latest"]
-    steps:
-      - name: Setup macOS
-        if: ${{ matrix.runner != 'ubuntu-latest' }}
-        run: brew install tree
-      - name: Remove system executables
-        run: |
-          while [ -n "$(command -v gpg gpg2 patchelf)" ]; do
-            sudo rm $(command -v gpg gpg2 patchelf)
-          done
-      - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-        with:
-          python-version: |
-            3.8
-            3.9
-            3.10
-            3.11
-            3.12
-            3.13
-      - name: Set bootstrap sources
-        run: |
-          source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.5
-          spack bootstrap disable spack-install
-      - name: Bootstrap clingo
-        run: |
-          set -e
-          for ver in '3.8' '3.9' '3.10' '3.11' '3.12' '3.13'; do
-            not_found=1
-            ver_dir="$(find $RUNNER_TOOL_CACHE/Python -wholename "*/${ver}.*/*/bin" | grep . || true)"
-            if [[ -d "$ver_dir" ]] ; then
-              echo "Testing $ver_dir"
-              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/bin/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
-      - name: Bootstrap GnuPG
-        run: |
-          source share/spack/setup-env.sh
-          spack -d gpg list
-          tree $HOME/.spack/bootstrap/store/
-
-
-  windows:
-    runs-on: "windows-latest"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-        with:
-          python-version: "3.12"
-      - name: Setup Windows
-        run: |
-          Remove-Item -Path (Get-Command gpg).Path
-          Remove-Item -Path (Get-Command file).Path
-      - name: Bootstrap clingo
-        run: |
-          ./share/spack/setup-env.ps1
-          spack bootstrap disable github-actions-v0.6
-          spack bootstrap disable github-actions-v0.5
-          spack external find --not-buildable cmake bison
-          spack -d solve zlib
-          ./share/spack/qa/validate_last_exit.ps1
-          tree $env:userprofile/.spack/bootstrap/store/
-      - name: Bootstrap GnuPG
-        run: |
-          ./share/spack/setup-env.ps1
-          spack -d gpg list
-          ./share/spack/qa/validate_last_exit.ps1
-          tree $env:userprofile/.spack/bootstrap/store/

.github/workflows/build-containers.yml

@@ -1,140 +0,0 @@
-name: Containers
-
-on:
-  # This Workflow can be triggered manually
-  workflow_dispatch:
-  # Build new Spack develop containers nightly.
-  schedule:
-    - cron: '34 0 * * *'
-  # Run on pull requests that modify this file
-  pull_request:
-    branches:
-      - 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
-    permissions:
-      packages: write
-    strategy:
-      # Even if one container fails to build we still want the others
-      # to continue their builds.
-      fail-fast: false
-      # 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'],
-                     [centos-stream9, 'linux/amd64,linux/arm64', 'centos:stream9'],
-                     [leap15, 'linux/amd64,linux/arm64', 'opensuse/leap:15'],
-                     [ubuntu-focal, 'linux/amd64,linux/arm64', 'ubuntu:20.04'],
-                     [ubuntu-jammy, 'linux/amd64,linux/arm64', 'ubuntu:22.04'],
-                     [ubuntu-noble, 'linux/amd64,linux/arm64', 'ubuntu:24.04'],
-                     [almalinux8, 'linux/amd64,linux/arm64', 'almalinux:8'],
-                     [almalinux9, 'linux/amd64,linux/arm64', 'almalinux:9'],
-                     [rockylinux8, 'linux/amd64,linux/arm64', 'rockylinux:8'],
-                     [rockylinux9, 'linux/amd64,linux/arm64', 'rockylinux:9'],
-                     [fedora39, 'linux/amd64,linux/arm64', 'fedora:39'],
-                     [fedora40, 'linux/amd64,linux/arm64', 'fedora:40']]
-    name: Build ${{ matrix.dockerfile[0] }}
-    if: github.repository == 'spack/spack'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-
-      - name: Determine latest release tag
-        id: latest
-        run: |
-          git fetch --quiet --tags
-          echo "tag=$(git tag --list --sort=-v:refname | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | head -n 1)" | tee -a $GITHUB_OUTPUT
-
-      - uses: docker/metadata-action@369eb591f429131d6889c46b94e711f089e6ca96
-        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
-              type=raw,value=latest,enable=${{ github.ref == format('refs/tags/{0}', steps.latest.outputs.tag) }}
-
-      - name: Generate the Dockerfile
-        env:
-          SPACK_YAML_OS: "${{ matrix.dockerfile[2] }}"
-        run: |
-          .github/workflows/bin/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"
-              exit 1;
-          fi
-
-      - name: Upload Dockerfile
-        uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b
-        with:
-          name: dockerfiles_${{ matrix.dockerfile[0] }}
-          path: dockerfiles
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@49b3bc8e6bdd4a60e6116a5414239cba5943d3cf
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@6524bf65af31da8d45b59e8c27de4bd072b392f5
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
-        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@9780b0c442fbb1117ed29e0efdff1e18412f7567
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Build & Deploy ${{ matrix.dockerfile[0] }}
-        uses: docker/build-push-action@48aba3b46d1b1fec4febb7c5d0c644b249a11355
-        with:
-          context: dockerfiles/${{ matrix.dockerfile[0] }}
-          platforms: ${{ matrix.dockerfile[1] }}
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.docker_meta.outputs.tags }}
-          labels: ${{ steps.docker_meta.outputs.labels }}
-
-  merge-dockerfiles:
-    runs-on: ubuntu-latest
-    needs: deploy-images
-    steps:
-      - name: Merge Artifacts
-        uses: actions/upload-artifact/merge@6f51ac03b9356f520e9adb1b1b7802705f340c2b
-        with:
-          name: dockerfiles
-          pattern: dockerfiles_*
-          delete-merged: true

.github/workflows/ci.yaml

@@ -1,123 +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:
-  # 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@11bd71901bbe5b1630ceea73d27597364c9af683
-        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/**'
-            - 'var/spack/repos/builtin/packages/gnupg/**'
-            - 'var/spack/repos/builtin/packages/libassuan/**'
-            - 'var/spack/repos/builtin/packages/libgcrypt/**'
-            - 'var/spack/repos/builtin/packages/libgpg-error/**'
-            - 'var/spack/repos/builtin/packages/libksba/**'
-            - 'var/spack/repos/builtin/packages/npth/**'
-            - 'var/spack/repos/builtin/packages/pinentry/**'
-            - '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
-
-  prechecks:
-    needs: [ changes ]
-    uses: ./.github/workflows/valid-style.yml
-    secrets: inherit
-    with:
-      with_coverage: ${{ needs.changes.outputs.core }}
-
-  import-check:
-    needs: [ changes ]
-    uses: ./.github/workflows/import-check.yaml
-
-  all-prechecks:
-    needs: [ prechecks ]
-    if: ${{ always() }}
-    runs-on: ubuntu-latest
-    steps:
-    - name: Success
-      run: |
-        if [ "${{ needs.prechecks.result }}" == "failure" ] || [ "${{ needs.prechecks.result }}" == "canceled" ]; then
-          echo "Unit tests failed." 
-          exit 1
-        else
-          exit 0
-        fi
-
-  coverage:
-    needs: [ unit-tests, prechecks ]
-    uses: ./.github/workflows/coverage.yml
-    secrets: inherit
-
-  all:
-    needs: [ unit-tests, coverage, bootstrap ]
-    if: ${{ always() }}
-    runs-on: ubuntu-latest
-    # See https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/accessing-contextual-information-about-workflow-runs#needs-context
-    steps:
-    - name: Status summary
-      run: |
-        if [ "${{ needs.unit-tests.result }}" == "failure" ] || [ "${{ needs.unit-tests.result }}" == "canceled" ]; then
-          echo "Unit tests failed." 
-          exit 1
-        elif [ "${{ needs.bootstrap.result }}" == "failure" ] || [ "${{ needs.bootstrap.result }}" == "canceled" ]; then
-          echo "Bootstrap tests failed." 
-          exit 1
-        else
-          exit 0
-        fi

.github/workflows/coverage.yml

@@ -1,36 +0,0 @@
-name: coverage
-
-on:
-  workflow_call:
-
-jobs:
-  # Upload coverage reports to codecov once as a single bundle
-  upload:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      with:
-        python-version: '3.11'
-        cache: 'pip'
-
-    - name: Install python dependencies
-      run: pip install -r .github/workflows/requirements/coverage/requirements.txt
-
-    - name: Download coverage artifact files
-      uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16
-      with:
-        pattern: coverage-*
-        path: coverage
-        merge-multiple: true
-
-    - run: ls -la coverage
-    - run: coverage combine -a coverage/.coverage*
-    - run: coverage xml
-
-    - name: "Upload coverage report to CodeCov"
-      uses: codecov/codecov-action@1e68e06f1dbfde0e4cefc87efeba9e4643565303
-      with:
-        verbose: true
-        fail_ci_if_error: false
-        token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/import-check.yaml

@@ -1,49 +0,0 @@
-name: import-check
-
-on:
-  workflow_call:
-
-jobs:
-  # Check we don't make the situation with circular imports worse
-  import-check:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: julia-actions/setup-julia@v2
-      with:
-        version: '1.10'
-    - uses: julia-actions/cache@v2
-
-    # PR: use the base of the PR as the old commit
-    - name: Checkout PR base commit
-      if: github.event_name == 'pull_request'
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        ref: ${{ github.event.pull_request.base.sha }}
-        path: old
-    # not a PR: use the previous commit as the old commit
-    - name: Checkout previous commit
-      if: github.event_name != 'pull_request'
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        fetch-depth: 2
-        path: old
-    - name: Checkout previous commit
-      if: github.event_name != 'pull_request'
-      run: git -C old reset --hard HEAD^
-
-    - name: Checkout new commit
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        path: new
-    - name: Install circular import checker
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        repository: haampie/circular-import-fighter
-        ref: e38bcd0aa46368e30648b61b7f0d8c1ca68aadff
-        path: circular-import-fighter
-    - name: Install dependencies
-      working-directory: circular-import-fighter
-      run: make -j dependencies
-    - name: Circular import check
-      working-directory: circular-import-fighter
-      run: make -j compare "SPACK_ROOT=../old ../new"

.github/workflows/linux_build_tests.yaml

@@ -0,0 +1,57 @@
+name: linux builds
+
+on:
+  push:
+    branches:
+    - master
+    - develop
+  pull_request:
+    branches:
+    - master
+    - develop
+    paths-ignore:
+      # Don't run if we only modified packages in the built-in repository
+      - 'var/spack/repos/builtin/**'
+      - '!var/spack/repos/builtin/packages/lz4/**'
+      - '!var/spack/repos/builtin/packages/mpich/**'
+      - '!var/spack/repos/builtin/packages/tut/**'
+      - '!var/spack/repos/builtin/packages/py-setuptools/**'
+      - '!var/spack/repos/builtin/packages/openjpeg/**'
+      - '!var/spack/repos/builtin/packages/r-rcpp/**'
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 4
+      matrix:
+        package: [lz4, mpich, tut, py-setuptools, openjpeg, r-rcpp]
+    steps:
+    - uses: actions/checkout@v1
+    - name: Cache ccache's store
+      uses: actions/cache@v1
+      with:
+        path: ~/.ccache
+        key: ccache-build-${{ matrix.package }}
+        restore-keys: |
+          ccache-build-${{ matrix.package }}
+    - name: Setup Python
+      uses: actions/setup-python@v1
+      with:
+        python-version: 3.8
+    - name: Install System Packages
+      run: |
+        sudo apt-get -yqq install ccache gfortran perl perl-base r-base r-base-core r-base-dev findutils openssl libssl-dev libpciaccess-dev
+        R --version
+        perl --version
+    - name: Copy Configuration
+      run: |
+        ccache -M 300M && ccache -z
+        # Set up external deps for build tests, b/c they take too long to compile
+        cp share/spack/qa/configuration/*.yaml etc/spack/
+    - name: Run the build test
+      run: |
+        . share/spack/setup-env.sh
+        SPEC=${{ matrix.package }} share/spack/qa/run-build-tests
+        ccache -s

.github/workflows/minimum_python_versions.yaml

@@ -0,0 +1,30 @@
+name: python version check
+
+on:
+  push:
+    branches:
+      - master
+      - develop
+  pull_request:
+    branches:
+      - master
+      - develop
+jobs:
+  validate:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Setup Python
+      uses: actions/setup-python@v1
+      with:
+        python-version: 3.7
+    - name: Install Python Packages
+      run: |
+        pip install --upgrade pip
+        pip install --upgrade vermin
+    - name: Minimum Version (Spack's Core)
+      run: vermin --backport argparse -t=2.6- -t=3.5- -v lib/spack/spack/ lib/spack/llnl/ bin/
+    - name: Minimum Version (Repositories)
+      run: vermin --backport argparse -t=2.6- -t=3.5- -v var/spack/repos

.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@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      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/requirements/coverage/requirements.txt

@@ -1 +0,0 @@
-coverage==7.6.1

.github/workflows/requirements/style/requirements.txt

@@ -1,7 +0,0 @@
-black==24.10.0
-clingo==5.7.1
-flake8==7.1.1
-isort==5.13.2
-mypy==1.11.2
-types-six==1.17.0.20241205
-vermin==1.6.0

.github/workflows/unit_tests.yaml

@@ -1,263 +0,0 @@
-name: unit tests
-
-on:
-  workflow_dispatch:
-  workflow_call:
-
-concurrency:
-  group: unit_tests-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-jobs:
-  # Run unit tests with different configurations on linux
-  ubuntu:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
-        on_develop:
-        - ${{ github.ref == 'refs/heads/develop' }}
-        include:
-        - python-version: '3.6'
-          os: ubuntu-20.04
-          on_develop: ${{ github.ref == 'refs/heads/develop' }}
-        - python-version: '3.7'
-          os: ubuntu-22.04
-          on_develop: ${{ github.ref == 'refs/heads/develop' }}
-        exclude:
-        - python-version: '3.8'
-          os: ubuntu-latest
-          on_develop: false
-        - python-version: '3.9'
-          os: ubuntu-latest
-          on_develop: false
-        - python-version: '3.10'
-          os: ubuntu-latest
-          on_develop: false
-        - python-version: '3.11'
-          os: ubuntu-latest
-          on_develop: false
-
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install System packages
-      run: |
-          sudo apt-get -y update
-          # Needed for unit tests
-          sudo apt-get -y install \
-              coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build \
-              cmake bison libbison-dev subversion
-    # On ubuntu 24.04, kcov was removed. It may come back in some future Ubuntu
-    - name: Set up Homebrew
-      id: set-up-homebrew
-      uses: Homebrew/actions/setup-homebrew@40e9946c182a64b3db1bf51be0dcb915f7802aa9
-    - name: Install kcov with brew
-      run: "brew install 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"
-    - name: Setup git configuration
-      run: |
-          # Need this for the git tests to succeed.
-          git --version
-          . .github/workflows/bin/setup_git.sh
-    - name: Bootstrap clingo
-      if: ${{ matrix.concretizer == 'clingo' }}
-      env:
-          SPACK_PYTHON: python
-      run: |
-          . share/spack/setup-env.sh
-          spack bootstrap disable spack-install
-          spack bootstrap now
-          spack -v solve zlib
-    - name: Run unit tests
-      env:
-          SPACK_PYTHON: python
-          SPACK_TEST_PARALLEL: 2
-          COVERAGE: true
-          COVERAGE_FILE: coverage/.coverage-${{ matrix.os }}-python${{ matrix.python-version }}
-          UNIT_TEST_COVERAGE: ${{ matrix.python-version == '3.11' }}
-      run: |
-          share/spack/qa/run-unit-tests
-    - uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b
-      with:
-        name: coverage-${{ matrix.os }}-python${{ matrix.python-version }}
-        path: coverage
-        include-hidden-files: true
-  # Test shell integration
-  shell:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      with:
-        python-version: '3.11'
-    - name: Install System packages
-      run: |
-          sudo apt-get -y update
-          # Needed for shell tests
-          sudo apt-get install -y coreutils csh zsh tcsh fish dash bash subversion
-    # On ubuntu 24.04, kcov was removed. It may come back in some future Ubuntu
-    - name: Set up Homebrew
-      id: set-up-homebrew
-      uses: Homebrew/actions/setup-homebrew@40e9946c182a64b3db1bf51be0dcb915f7802aa9
-    - name: Install kcov with brew
-      run: "brew install kcov"
-    - name: Install Python packages
-      run: |
-          pip install --upgrade pip setuptools pytest coverage[toml] pytest-xdist
-    - name: Setup git configuration
-      run: |
-          # Need this for the git tests to succeed.
-          git --version
-          . .github/workflows/bin/setup_git.sh
-    - name: Run shell tests
-      env:
-          COVERAGE: true
-      run: |
-          share/spack/qa/run-shell-tests
-    - uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b
-      with:
-        name: coverage-shell
-        path: coverage
-        include-hidden-files: true
-
-  # Test RHEL8 UBI with platform Python. This job is run
-  # only on PRs modifying core Spack
-  rhel8-platform-python:
-    runs-on: ubuntu-latest
-    container: registry.access.redhat.com/ubi8/ubi
-    steps:
-    - name: Install dependencies
-      run: |
-          dnf install -y \
-              bzip2 curl gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
-              make patch tcl unzip which xz
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-    - name: Setup repo and non-root user
-      run: |
-          git --version
-          git config --global --add safe.directory '*'
-          git fetch --unshallow
-          . .github/workflows/bin/setup_git.sh
-          useradd spack-test
-          chown -R spack-test .
-    - name: Run unit tests
-      shell: runuser -u spack-test -- bash {0}
-      run: |
-          source share/spack/setup-env.sh
-          spack -d bootstrap now --dev
-          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:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      with:
-        python-version: '3.13'
-    - name: Install System packages
-      run: |
-          sudo apt-get -y update
-          sudo apt-get -y install coreutils gfortran graphviz gnupg2
-    - name: Install Python packages
-      run: |
-          pip install --upgrade pip setuptools pytest coverage[toml] pytest-cov clingo
-          pip install --upgrade flake8 "isort>=4.3.5" "mypy>=0.900" "click" "black"
-    - name: Run unit tests (full suite with coverage)
-      env:
-          COVERAGE: true
-          COVERAGE_FILE: coverage/.coverage-clingo-cffi
-      run: |
-        . share/spack/setup-env.sh
-        spack bootstrap disable spack-install
-        spack bootstrap disable github-actions-v0.5
-        spack bootstrap disable github-actions-v0.6
-        spack bootstrap status
-        spack solve zlib
-        spack unit-test --verbose --cov --cov-config=pyproject.toml --cov-report=xml:coverage.xml lib/spack/spack/test/concretization/core.py
-    - uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b
-      with:
-        name: coverage-clingo-cffi
-        path: coverage
-        include-hidden-files: true
-  # Run unit tests on MacOS
-  macos:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [macos-13, macos-14]
-        python-version: ["3.11"]
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      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
-    - name: Setup Homebrew packages
-      run: |
-        brew install dash fish gcc gnupg kcov
-    - name: Run unit tests
-      env:
-        SPACK_TEST_PARALLEL: 4
-        COVERAGE_FILE: coverage/.coverage-${{ matrix.os }}-python${{ matrix.python-version }}
-      run: |
-        git --version
-        . .github/workflows/bin/setup_git.sh
-        . share/spack/setup-env.sh
-        $(which spack) bootstrap disable 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: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b
-      with:
-        name: coverage-${{ matrix.os }}-python${{ matrix.python-version }}
-        path: coverage
-        include-hidden-files: true
-  # Run unit tests on Windows
-  windows:
-    defaults:
-      run:
-        shell:
-          powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      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/bin/setup_git.ps1
-    - name: Unit Test
-      env:
-        COVERAGE_FILE: coverage/.coverage-windows
-      run: |
-        spack unit-test -x --verbose --cov --cov-config=pyproject.toml
-        ./share/spack/qa/validate_last_exit.ps1
-    - uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b
-      with:
-        name: coverage-windows
-        path: coverage
-        include-hidden-files: true

.github/workflows/valid-style.yml

@@ -1,106 +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@11bd71901bbe5b1630ceea73d27597364c9af683
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      with:
-        python-version: '3.13'
-        cache: 'pip'
-    - name: Install Python Packages
-      run: |
-        pip install --upgrade pip setuptools
-        pip install -r .github/workflows/requirements/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@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-      with:
-        python-version: '3.13'
-        cache: 'pip'
-    - name: Install Python packages
-      run: |
-        pip install --upgrade pip setuptools
-        pip install -r .github/workflows/requirements/style/requirements.txt
-    - name: Setup git configuration
-      run: |
-        # Need this for the git tests to succeed.
-        git --version
-        . .github/workflows/bin/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.13'
-  # 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@11bd71901bbe5b1630ceea73d27597364c9af683
-      - name: Setup repo and non-root user
-        run: |
-          git --version
-          git config --global --add safe.directory '*'
-          git fetch --unshallow
-          . .github/workflows/bin/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 -d style -t black
-          spack unit-test -V
-
-  # Further style checks from pylint
-  pylint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b
-        with:
-          python-version: '3.13'
-          cache: 'pip'
-      - name: Install Python packages
-        run: |
-          pip install --upgrade pip setuptools pylint
-      - name: Pylint (Spack Core)
-        run: |
-          pylint -j 4 --disable=all --enable=unspecified-encoding --ignore-paths=lib/spack/external lib

.gitignore

@@ -1,515 +1,29 @@
-##########################
-# Spack-specific ignores #
-##########################
-
+/db
 /var/spack/stage
 /var/spack/cache
 /var/spack/environments
 /var/spack/repos/*/index.yaml
 /var/spack/repos/*/lock
+*.pyc
 /opt
+*~
+.DS_Store
+.idea
 # Ignore everything in /etc/spack except /etc/spack/defaults
 /etc/spack/*
 !/etc/spack/defaults
+/etc/spackconfig
+/share/spack/dotkit
 /share/spack/modules
 /share/spack/lmod
-# Debug logs
-spack-db.*
+/TAGS
+*.swp
+/htmlcov
+.coverage
+\#*
+.#*
+lib/spack/spack/test/.cache
+/bin/spackc
 *.in.log
 *.out.log
-
-###########################
-# Python-specific ignores #
-###########################
-
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-#lib/
-#lib64/
-parts/
-sdist/
-#var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-!/lib/spack/env
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-########################
-# Vim-specific ignores #
-########################
-
-# Swap
-[._]*.s[a-v][a-z]
-!*.svg  # comment out if you don't need vector files
-[._]*.sw[a-p]
-[._]s[a-rt-v][a-z]
-[._]ss[a-gi-z]
-[._]sw[a-p]
-
-# Session
-Session.vim
-Sessionx.vim
-
-# Temporary
-.netrwhist
-*~
-# Auto-generated tag files
-tags
-# Persistent undo
-[._]*.un~
-
-##########################
-# Emacs-specific ignores #
-##########################
-
-*~
-\#*\#
-/.emacs.desktop
-/.emacs.desktop.lock
-*.elc
-auto-save-list
-tramp
-.\#*
-
-# Org-mode
-.org-id-locations
-*_archive
-
-# flymake-mode
-*_flymake.*
-
-# eshell files
-/eshell/history
-/eshell/lastdir
-
-# zsh byte-compiled files
-*.zwc
-
-# elpa packages
-/elpa/
-
-# reftex files
-*.rel
-
-# AUCTeX auto folder
-/auto/
-
-# cask packages
-.cask/
-dist/
-
-# Flycheck
-flycheck_*.el
-
-# server auth directory
-/server/
-
-# projectiles files
-.projectile
-
-# directory configuration
-.dir-locals.el
-
-# network security
-/network-security.data
-
-############################
-# Eclipse-specific ignores #
-############################
-
-.metadata
-#bin/
-tmp/
-*.tmp
-*.bak
-*.swp
-*~.nib
-local.properties
-.settings/
-.loadpath
-.recommenders
-
-# External tool builders
-.externalToolBuilders/
-
-# Locally stored "Eclipse launch configurations"
-*.launch
-
-# PyDev specific (Python IDE for Eclipse)
-*.pydevproject
-
-# CDT-specific (C/C++ Development Tooling)
-.cproject
-
-# CDT- autotools
-.autotools
-
-# Java annotation processor (APT)
-.factorypath
-
-# PDT-specific (PHP Development Tools)
-.buildpath
-
-# sbteclipse plugin
-.target
-
-# Tern plugin
-.tern-project
-
-# TeXlipse plugin
-.texlipse
-
-# STS (Spring Tool Suite)
-.springBeans
-
-# Code Recommenders
-.recommenders/
-
-# Annotation Processing
-.apt_generated/
-.apt_generated_test/
-
-# Scala IDE specific (Scala & Java development for Eclipse)
-.cache-main
-.scala_dependencies
-.worksheet
-
-# Uncomment this line if you wish to ignore the project description file.
-# Typically, this file would be tracked if it contains build/dependency configurations:
-#.project
-
-##################################
-# Visual Studio-specific ignores #
-##################################
-
-.vscode/*
-!.vscode/settings.json
-!.vscode/tasks.json
-!.vscode/launch.json
-!.vscode/extensions.json
-*.code-workspace
-
-# Local History for Visual Studio Code
-.history/
-
-#################################
-# Sublime Text-specific ignores #
-#################################
-
-# Cache files for Sublime Text
-*.tmlanguage.cache
-*.tmPreferences.cache
-*.stTheme.cache
-
-# Workspace files are user-specific
-*.sublime-workspace
-
-# Project files should be checked into the repository, unless a significant
-# proportion of contributors will probably not be using Sublime Text
-# *.sublime-project
-
-# SFTP configuration file
-sftp-config.json
-sftp-config-alt*.json
-
-# Package control specific files
-Package Control.last-run
-Package Control.ca-list
-Package Control.ca-bundle
-Package Control.system-ca-bundle
-Package Control.cache/
-Package Control.ca-certs/
-Package Control.merged-ca-bundle
-Package Control.user-ca-bundle
-oscrypto-ca-bundle.crt
-bh_unicode_properties.cache
-
-# Sublime-github package stores a github token in this file
-# https://packagecontrol.io/packages/sublime-github
-GitHub.sublime-settings
-
-##############################
-# JetBrains-specific ignores #
-##############################
-
-# Ignore the entire folder since it may conatin more files than
-# just the ones listed below
-.idea/
-
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
-# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
-
-# User-specific stuff
-.idea/**/workspace.xml
-.idea/**/tasks.xml
-.idea/**/usage.statistics.xml
-.idea/**/dictionaries
-.idea/**/shelf
-
-# Generated files
-.idea/**/contentModel.xml
-
-# Sensitive or high-churn files
-.idea/**/dataSources/
-.idea/**/dataSources.ids
-.idea/**/dataSources.local.xml
-.idea/**/sqlDataSources.xml
-.idea/**/dynamic.xml
-.idea/**/uiDesigner.xml
-.idea/**/dbnavigator.xml
-
-# Gradle
-.idea/**/gradle.xml
-.idea/**/libraries
-
-# Gradle and Maven with auto-import
-# When using Gradle or Maven with auto-import, you should exclude module files,
-# since they will be recreated, and may cause churn.  Uncomment if using
-# auto-import.
-# .idea/artifacts
-# .idea/compiler.xml
-# .idea/jarRepositories.xml
-# .idea/modules.xml
-# .idea/*.iml
-# .idea/modules
-# *.iml
-# *.ipr
-
-# CMake
-cmake-build-*/
-
-# Mongo Explorer plugin
-.idea/**/mongoSettings.xml
-
-# File-based project format
-*.iws
-
-# IntelliJ
-out/
-
-# mpeltonen/sbt-idea plugin
-.idea_modules/
-
-# JIRA plugin
-atlassian-ide-plugin.xml
-
-# Cursive Clojure plugin
-.idea/replstate.xml
-
-# Crashlytics plugin (for Android Studio and IntelliJ)
-com_crashlytics_export_strings.xml
-crashlytics.properties
-crashlytics-build.properties
-fabric.properties
-
-# Editor-based Rest Client
-.idea/httpRequests
-
-# Android studio 3.1+ serialized cache file
-.idea/caches/build_file_checksums.ser
-
-##########################
-# macOS-specific ignores #
-##########################
-
-# General
-.DS_Store
-.AppleDouble
-.LSOverride
-
-# Icon must end with two \r
-Icon
-
-# Thumbnails
-._*
-
-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-.com.apple.timemachine.donotpresent
-
-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
-
-##########################
-# Linux-specific ignores #
-##########################
-
-*~
-
-# temporary files which can be created if a process still has a handle open of a deleted file
-.fuse_hidden*
-
-# KDE directory preferences
-.directory
-
-# Linux trash folder which might appear on any partition or disk
-.Trash-*
-
-# .nfs files are created when an open file is removed but is still being accessed
-.nfs*
-
-############################
-# Windows-specific ignores #
-############################
-
-# Windows thumbnail cache files
-Thumbs.db
-Thumbs.db:encryptable
-ehthumbs.db
-ehthumbs_vista.db
-
-# Dump file
-*.stackdump
-
-# Folder config file
-[Dd]esktop.ini
-
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
-
-# Windows Installer files
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
-# Windows shortcuts
-*.lnk
+*.orig

.mailmap

@@ -3,8 +3,7 @@ Adam Moody            <moody20@llnl.gov>                Adam T. Moody
 Alfredo Gimenez       <gimenez1@llnl.gov>               Alfredo Gimenez         <alfredo.gimenez@gmail.com>
 Alfredo Gimenez       <gimenez1@llnl.gov>               Alfredo Adolfo Gimenez  <alfredo.gimenez@gmail.com>
 Andrew Williams       <williamsa89@cardiff.ac.uk>       Andrew Williams         <andrew@alshain.org.uk>
-Axel Huebl            <axelhuebl@lbl.gov>               Axel Huebl              <a.huebl@hzdr.de>
-Axel Huebl            <axelhuebl@lbl.gov>               Axel Huebl              <axel.huebl@plasma.ninja>
+Axel Huebl            <a.huebl@hzdr.de>                 Axel Huebl              <axel.huebl@plasma.ninja>
 Ben Boeckel           <ben.boeckel@kitware.com>         Ben Boeckel             <mathstuf@gmail.com>
 Ben Boeckel           <ben.boeckel@kitware.com>         Ben Boeckel             <mathstuf@users.noreply.github.com>
 Benedikt Hegner       <hegner@cern.ch>                  Benedikt Hegner         <benedikt.hegner@cern.ch>
@@ -21,8 +20,8 @@ Geoffrey Oxberry      <oxberry1@llnl.gov>               Geoffrey Oxberry
 Glenn Johnson         <glenn-johnson@uiowa.edu>         Glenn Johnson           <gjohnson@argon-ohpc.hpc.uiowa.edu>
 Glenn Johnson         <glenn-johnson@uiowa.edu>         Glenn Johnson           <glennpj@gmail.com>
 Gregory Becker        <becker33@llnl.gov>               Gregory Becker          <becker33.llnl.gov>
-Gregory Becker        <becker33@llnl.gov>               Gregory Becker          <becker33.llnl.gov>
-Gregory Becker        <becker33@llnl.gov>               Gregory Becker          <becker33@llnl.gov>
+Gregory Becker        <becker33@llnl.gov>               becker33                <becker33.llnl.gov>
+Gregory Becker        <becker33@llnl.gov>               becker33                <becker33@llnl.gov>
 Gregory L. Lee        <lee218@llnl.gov>                 Greg Lee                <lee218@llnl.gov>
 Gregory L. Lee        <lee218@llnl.gov>                 Gregory L. Lee          <lee218@cab687.llnl.gov>
 Gregory L. Lee        <lee218@llnl.gov>                 Gregory L. Lee          <lee218@cab690.llnl.gov>

.readthedocs.yml

@@ -1,39 +1,9 @@
 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
-
-search:
-  ranking:
-    spack.html: -10
-    spack.*.html: -10
-    llnl.html: -10
-    llnl.*.html: -10
-    _modules/*: -10
-    command_index.html: -9
-    basic_usage.html: 5
-    configuration.html: 5
-    config_yaml.html: 5
-    packages_yaml.html: 5
-    build_settings.html: 5
-    environments.html: 5
-    containers.html: 5
-    mirrors.html: 5
-    module_file_support.html: 5
-    repositories.html: 5
-    binary_caches.html: 5
-    chain.html: 5
-    pipelines.html: 5
-    packaging_guide.html: 5

.travis.yml

@@ -0,0 +1,168 @@
+#=============================================================================
+# Project settings
+#=============================================================================
+# Only build master and develop on push; do not build every branch.
+branches:
+  only:
+    - master
+    - develop
+    - /^releases\/.*$/
+
+#=============================================================================
+# Build matrix
+#=============================================================================
+
+dist: xenial
+
+jobs:
+  fast_finish: true
+  include:
+    - stage: 'style checks'
+      python: '3.8'
+      os: linux
+      language: python
+      env: TEST_SUITE=flake8
+# Shell integration with module files
+    - python: '3.8'
+      os: linux
+      language: python
+      env: [ TEST_SUITE=bootstrap ]
+    - stage: 'unit tests + documentation'
+      python: '2.6'
+      dist: trusty
+      os: linux
+      language: python
+      env: [ TEST_SUITE=unit, COVERAGE=true ]
+    - python: '2.7'
+      os: linux
+      language: python
+      env: [ TEST_SUITE=unit, COVERAGE=true ]
+    - python: '3.5'
+      os: linux
+      language: python
+      env: TEST_SUITE=unit
+    - python: '3.6'
+      os: linux
+      language: python
+      env: TEST_SUITE=unit
+    - python: '3.7'
+      os: linux
+      language: python
+      env: TEST_SUITE=unit
+    - python: '3.8'
+      os: linux
+      language: python
+      env: [ TEST_SUITE=unit, COVERAGE=true ]
+    - python: '3.8'
+      os: linux
+      language: python
+      env: TEST_SUITE=doc
+    - os: osx
+      language: generic
+      env: [ TEST_SUITE=unit, PYTHON_VERSION=2.7, COVERAGE=true ]
+      if: type != pull_request
+
+stages:
+  - 'style checks'
+  - 'unit tests + documentation'
+
+
+#=============================================================================
+# Environment
+#=============================================================================
+
+# Docs need graphviz to build
+addons:
+  # for Linux builds, we use APT
+  apt:
+    packages:
+      - ccache
+      - cmake
+      - gfortran
+      - graphviz
+      - gnupg2
+      - kcov
+      - mercurial
+      - ninja-build
+      - perl
+      - perl-base
+      - realpath
+      - r-base
+      - r-base-core
+      - r-base-dev
+      - zsh
+  # for Mac builds, we use Homebrew
+  homebrew:
+    packages:
+      - python@2
+      - gcc
+      - gnupg2
+      - ccache
+      - dash
+      - kcov
+    update: true
+
+# ~/.ccache needs to be cached directly as Travis is not taking care of it
+# (possibly because we use 'language: python' and not 'language: c')
+cache:
+  pip: true
+  ccache: true
+  directories:
+    - ~/.ccache
+
+# Work around Travis's lack of support for Python on OSX
+before_install:
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
+        pip2 install --upgrade pip;
+        pip2 install virtualenv;
+        virtualenv venv;
+        source venv/bin/activate;
+    fi
+  - ccache -M 2G && ccache -z
+
+# Install various dependencies
+install:
+  - pip install --upgrade pip
+  - pip install --upgrade six
+  - pip install --upgrade setuptools
+  - pip install --upgrade codecov coverage==4.5.4
+  - pip install --upgrade flake8
+  - pip install --upgrade pep8-naming
+  - if [[ "$TEST_SUITE" == "doc" ]]; then
+        pip install --upgrade -r lib/spack/docs/requirements.txt;
+    fi
+
+before_script:
+  # Need this for the git tests to succeed.
+  - git config --global user.email "spack@example.com"
+  - git config --global user.name "Test User"
+
+  # Need this to be able to compute the list of changed files
+  - git fetch origin ${TRAVIS_BRANCH}:${TRAVIS_BRANCH}
+
+#=============================================================================
+# Building
+#=============================================================================
+script:
+  - share/spack/qa/run-$TEST_SUITE-tests
+
+after_success:
+  - ccache -s
+  - case "$TEST_SUITE" in
+        unit)
+            if [[ "$COVERAGE" == "true" ]]; then
+                codecov --env PYTHON_VERSION
+                        --required
+                        --flags "${TEST_SUITE}${TRAVIS_OS_NAME}";
+            fi
+            ;;
+    esac
+
+#=============================================================================
+# Notifications
+#=============================================================================
+notifications:
+  email:
+    recipients: tgamblin@llnl.gov
+    on_success: change
+    on_failure: always

CITATION.cff

@@ -1,94 +0,0 @@
-# If you are referencing Spack in a publication, please cite the SC'15 paper
-# described here.
-#
-# Here's the raw citation:
-#
-#   Todd Gamblin, Matthew P. LeGendre, Michael R. Collette, Gregory L. Lee,
-#   Adam Moody, Bronis R. de Supinski, and W. Scott Futral.
-#   The Spack Package Manager: Bringing Order to HPC Software Chaos.
-#   In Supercomputing 2015 (SC’15), Austin, Texas, November 15-20 2015. LLNL-CONF-669890.
-#
-# Or, in BibTeX:
-#
-# @inproceedings{Gamblin_The_Spack_Package_2015,
-#     address = {Austin, Texas, USA},
-#     author = {Gamblin, Todd and LeGendre, Matthew and
-#               Collette, Michael R. and Lee, Gregory L. and
-#               Moody, Adam and de Supinski, Bronis R. and Futral, Scott},
-#     doi = {10.1145/2807591.2807623},
-#     month = {November 15-20},
-#     note = {LLNL-CONF-669890},
-#     series = {Supercomputing 2015 (SC’15)},
-#     title = {{The Spack Package Manager: Bringing Order to HPC Software Chaos}},
-#     url = {https://github.com/spack/spack},
-#     year = {2015}
-# }
-#
-# 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"
-  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"
-    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"

COPYRIGHT

@@ -8,9 +8,8 @@ or http://www.apache.org/licenses/LICENSE-2.0) or the MIT license,
 Copyrights and patents in the Spack project are retained by contributors.
 No copyright assignment is required to contribute to Spack.
 
-Spack was originally developed in 2013 by Lawrence Livermore National
-Security, LLC. It was originally distributed under the LGPL-2.1 license.
-Consent from contributors to relicense to Apache-2.0/MIT is documented at
+Spack was originally distributed under the LGPL-2.1 license. Consent from
+contributors to relicense to Apache-2.0/MIT is documented at
 https://github.com/spack/spack/issues/9137.
 
 
@@ -29,28 +28,14 @@ text in the license header:
 
 External Packages
 -------------------
-
-Spack bundles most external dependencies in lib/spack/external. It also
-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
+Spack bundles its external dependencies in lib/spack/external.  These
+packages are covered by various permissive licenses.  A summary listing
+follows.  See the license included with each package for full details.
 
 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
@@ -59,8 +44,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
@@ -71,10 +56,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
@@ -87,10 +68,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
@@ -99,10 +76,14 @@ PackageName: ruamel.yaml
 PackageHomePage: https://yaml.readthedocs.io/
 PackageLicenseDeclared: MIT
 
-PackageName: sbang
-PackageHomePage: https://github.com/spack/sbang
-PackageLicenseDeclared: Apache-2.0 OR MIT
+PackageName: six
+PackageHomePage: https://pypi.python.org/pypi/six
+PackageLicenseDeclared: MIT
 
-PackageName: typing_extensions
-PackageHomePage: https://pypi.org/project/typing-extensions/
-PackageLicenseDeclared: Python-2.0
+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,21 +1,20 @@
-MIT License
+Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
+Spack Project Developers. See the top-level COPYRIGHT file for details.
 
-Copyright (c) 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 in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -1,38 +1,14 @@
-<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>
+[![Build Status](https://travis-ci.org/spack/spack.svg?branch=develop)](https://travis-ci.org/spack/spack)
+[![Linux Builds](https://github.com/spack/spack/workflows/linux%20builds/badge.svg)](https://github.com/spack/spack/actions)
+[![codecov](https://codecov.io/gh/spack/spack/branch/develop/graph/badge.svg)](https://codecov.io/gh/spack/spack)
+[![Read the Docs](https://readthedocs.org/projects/spack/badge/?version=latest)](https://spack.readthedocs.io)
+[![Slack](https://spackpm.herokuapp.com/badge.svg)](https://spackpm.herokuapp.com)
 
 Spack is a multi-platform package manager that builds and installs
 multiple versions and configurations of software. It works on Linux,
-macOS, Windows, and many supercomputers. Spack is non-destructive: installing a
+macOS, and many supercomputers. Spack is non-destructive: installing a
 new version of a package does not break existing installations, so many
 configurations of the same package can coexist.
 
@@ -43,34 +19,27 @@ builds of the same package.  With Spack, you can build your software
 *all* the ways you want to.
 
 See the
-[Feature Overview](https://spack.readthedocs.io/en/latest/features.html)
+[Feature Overview](http://spack.readthedocs.io/en/latest/features.html)
 for examples and highlights.
 
-To install spack and your first package, make sure you have Python & Git.
+To install spack and your first package, make sure you have Python.
 Then:
 
-    $ git clone -c feature.manyFiles=true --depth=2 https://github.com/spack/spack.git
+    $ git clone https://github.com/spack/spack.git
     $ cd spack/bin
     $ ./spack install zlib
 
-> [!TIP]
-> `-c feature.manyFiles=true` improves git's performance on repositories with 1,000+ files.
->
-> `--depth=2` prunes the git history to reduce the size of the Spack installation.
-
 Documentation
 ----------------
 
-[**Full documentation**](https://spack.readthedocs.io/) is available, or
+[**Full documentation**](http://spack.readthedocs.io/) is available, or
 run `spack help` or `spack help --all`.
 
-For a cheat sheet on Spack syntax, run `spack help --spec`.
-
 Tutorial
 ----------------
 
 We maintain a
-[**hands-on tutorial**](https://spack-tutorial.readthedocs.io/).
+[**hands-on tutorial**](http://spack.readthedocs.io/en/latest/tutorial.html).
 It covers basic to advanced usage, packaging, developer features, and large HPC
 deployments.  You can do all of the exercises on your own laptop using a
 Docker container.
@@ -88,15 +57,10 @@ packages to bugfixes, documentation, or even new core features.
 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
+  To get an invitation, [**click here**](https://spackpm.herokuapp.com).
+* **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
 ------------------------
@@ -107,33 +71,15 @@ When you send your request, make ``develop`` the destination branch on the
 
 Your PR must pass Spack's unit tests and documentation tests, and must be
 [PEP 8](https://www.python.org/dev/peps/pep-0008/) compliant.  We enforce
-these guidelines with our CI process. To run these tests locally, and for
-helpful tips on git, see our
-[Contribution Guide](https://spack.readthedocs.io/en/latest/contribution_guide.html).
+these guidelines with [Travis CI](https://travis-ci.org/spack/spack).  To
+run these tests locally, and for helpful tips on git, see our
+[Contribution Guide](http://spack.readthedocs.io/en/latest/contribution_guide.html).
 
-Spack's `develop` branch has the latest contributions. Pull requests
-should target `develop`, and users who want the latest package versions,
-features, etc. can use `develop`.
-
-Releases
---------
-
-For multi-user site deployments or other use cases that need very stable
-software installations, we recommend using Spack's
-[stable releases](https://github.com/spack/spack/releases).
-
-Each Spack release series also has a corresponding branch, e.g.
-`releases/v0.14` has `0.14.x` versions of Spack, and `releases/v0.13` has
-`0.13.x` versions. We backport important bug fixes to these branches but
-we do not advance the package versions or make other changes that would
-change the way Spack concretizes dependencies within a release branch.
-So, you can base your Spack deployment on a release branch and `git pull`
-to get fixes, without the package churn that comes with `develop`.
-
-The latest release is always available with the `releases/latest` tag.
-
-See the [docs on releases](https://spack.readthedocs.io/en/latest/developer_guide.html#releases)
-for more details.
+Spack uses a rough approximation of the
+[Git Flow](http://nvie.com/posts/a-successful-git-branching-model/)
+branching model.  The ``develop`` branch contains the latest
+contributions, and ``master`` is always tagged and points to the latest
+stable release.
 
 Code of Conduct
 ------------------------
@@ -154,12 +100,9 @@ If you are referencing Spack in a publication, please cite the following paper:
 
  * Todd Gamblin, Matthew P. LeGendre, Michael R. Collette, Gregory L. Lee,
    Adam Moody, Bronis R. de Supinski, and W. Scott Futral.
-   [**The Spack Package Manager: Bringing Order to HPC Software Chaos**](https://www.computer.org/csdl/proceedings/sc/2015/3723/00/2807623.pdf).
+   [**The Spack Package Manager: Bringing Order to HPC Software Chaos**](http://www.computer.org/csdl/proceedings/sc/2015/3723/00/2807623.pdf).
    In *Supercomputing 2015 (SC’15)*, Austin, Texas, November 15-20 2015. LLNL-CONF-669890.
 
-On GitHub, you can copy this citation in APA or BibTeX format via the "Cite this repository"
-button. Or, see the comments in `CITATION.cff` for the raw BibTeX.
-
 License
 ----------------
 
@@ -177,4 +120,4 @@ See [LICENSE-MIT](https://github.com/spack/spack/blob/develop/LICENSE-MIT),
 
 SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-LLNL-CODE-811652
+LLNL-CODE-647188

SECURITY.md

@@ -1,27 +0,0 @@
-# Security Policy
-
-## 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.
-
-For more on Spack's release structure, see
-[`README.md`](https://github.com/spack/spack#releases).
-
-## Reporting a Vulnerability
-
-You can report a vulnerability using GitHub's private reporting
-feature:
-
-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.

bin/haspywin.py

@@ -1,18 +0,0 @@
-# Copyright Spack Project Developers. See 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,102 +1,114 @@
-#!/bin/sh
+#!/bin/bash
 #
-# Copyright sbang project developers. See COPYRIGHT file for details.
+# Copyright 2013-2020 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)
 
 #
 # `sbang`: Run scripts with long shebang lines.
 #
-# Many operating systems limit the length and number of possible
-# arguments in shebang lines, making it hard to use interpreters that are
-# deep in the directory hierarchy or require special arguments.
+# Many operating systems limit the length of shebang lines, making it
+# hard to use interpreters that are deep in the directory hierarchy.
+# `sbang` can run such scripts, either as a shebang interpreter, or
+# directly on the command line.
 #
-# To use, put the long shebang on the second line of your script, and
-# make sbang the interpreter, like this:
+# Usage
+# -----------------------------
+# Suppose you have a script, long-shebang.sh, like this:
 #
-#     #!/bin/sh /path/to/sbang
-#     #!/long/path/to/real/interpreter with arguments
+#     1    #!/very/long/path/to/some/interpreter
+#     2
+#     3    echo "success!"
 #
-# `sbang` will run the real interpreter with the script as its argument.
+# Invoking this script will result in an error on some OS's.  On
+# Linux, you get this:
 #
-# See https://github.com/spack/sbang for more details.
+#     $ ./long-shebang.sh
+#     -bash: ./long: /very/long/path/to/some/interp: bad interpreter:
+#            No such file or directory
+#
+# On Mac OS X, the system simply assumes the interpreter is the shell
+# and tries to run with it, which is likely not what you want.
+#
+#
+# `sbang` on the command line
+# -----------------------------
+# You can use `sbang` in two ways.  The first is to use it directly,
+# from the command line, like this:
+#
+#     $ sbang ./long-shebang.sh
+#     success!
+#
+#
+# `sbang` as the interpreter
+# -----------------------------
+# You can also use `sbang` *as* the interpreter for your script. Put
+# `#!/bin/bash /path/to/sbang` on line 1, and move the original
+# shebang to line 2 of the script:
+#
+#     1    #!/bin/bash /path/to/sbang
+#     2    #!/long/path/to/real/interpreter with arguments
+#     3
+#     4    echo "success!"
+#
+#     $ ./long-shebang.sh
+#     success!
+#
+# On Linux, you could shorten line 1 to `#!/path/to/sbang`, but other
+# operating systems like Mac OS X require the interpreter to be a
+# binary, so it's best to use `sbang` as a `bash` argument.
+# Obviously, for this to work, `sbang` needs to have a short enough
+# path that *it* will run without hitting OS limits.
+#
+# For Lua, scripts the second line can't start with #!, as # is not
+# the comment character in lua (even though lua ignores #! on the
+# *first* line of a script).  So, instrument a lua script like this,
+# using -- instead of # on the second line:
+#
+#     1    #!/bin/bash /path/to/sbang
+#     2    --!/long/path/to/lua with arguments
+#     3
+#     4    print "success!"
+#
+# How it works
+# -----------------------------
+# `sbang` is a very simple bash script. It looks at the first two
+# lines of a script argument and runs the last line starting with
+# `#!`, with the script as an argument. It also forwards arguments.
 #
-
-# Generic error handling
-die() {
-    echo "$@" 1>&2;
-    exit 1
-}
-
-# set SBANG_DEBUG to make the script print what would normally be executed.
-exec="exec"
-if [ -n "${SBANG_DEBUG}" ]; then
-    exec="echo "
-fi
 
 # First argument is the script we want to actually run.
 script="$1"
 
-# ensure that the script actually exists
-if [ -z "$script" ]; then
-    die "error: sbang requires exactly one argument"
-elif [ ! -f "$script" ]; then
-    die "$script: no such file or directory"
-fi
-
 # Search the first two lines of script for interpreters.
 lines=0
-while read -r line && [ $lines -ne 2 ]; do
-    if [ "${line#\#!}" != "$line" ]; then
-        shebang_line="${line#\#!}"
-    elif [ "${line#//!}" != "$line" ]; then      # // comments
-        shebang_line="${line#//!}"
-    elif [ "${line#--!}" != "$line" ]; then      # -- lua comments
-        shebang_line="${line#--!}"
-    elif [ "${line#<?php\ }" != "$line" ]; then  # php comments
-        shebang_line="${line#<?php\ \#!}"
-        shebang_line="${shebang_line%\ ?>}"
+while read line && ((lines < 2)) ; do
+    if [[ "$line" = '#!'* ]]; then
+        interpreter="${line#\#!}"
+    elif [[ "$line" = '//!'*node* ]]; then
+        interpreter="${line#//!}"
+    elif [[ "$line" = '--!'*lua* ]]; then
+        interpreter="${line#--!}"
     fi
     lines=$((lines+1))
 done < "$script"
+# this is ineeded for scripts with sbang parameter
+# like ones in intltool
+# #!/<spack-long-path>/perl -w
+# this is the interpreter line with all the parameters as a vector
+interpreter_v=(${interpreter})
+# this is the single interpreter path 
+interpreter_f="${interpreter_v[0]}"
 
-# error if we did not find any interpreter
-if [ -z "$shebang_line"  ]; then
-    die "error: sbang found no interpreter in $script"
-fi
-
-# parse out the interpreter and first argument
-IFS=' ' read -r interpreter arg1 rest <<EOF
-$shebang_line
-EOF
-
-# Determine if the interpreter is a particular program, accounting for the
-# '#!/usr/bin/env PROGRAM' convention. So:
-#
-#     interpreter_is perl
-#
-# will be true for '#!/usr/bin/perl' and '#!/usr/bin/env perl'
-interpreter_is() {
-    if [ "${interpreter##*/}" = "$1" ]; then
-        return 0
-    elif [ "$interpreter" = "/usr/bin/env" ] && [ "$arg1" = "$1" ]; then
-        return 0
+# Invoke any interpreter found, or raise an error if none was found.
+if [[ -n "$interpreter_f" ]]; then
+    if [[ "${interpreter_f##*/}" = "perl"* ]]; then
+        exec $interpreter -x "$@"
     else
-        return 1
+        exec $interpreter "$@"
     fi
-}
-
-if interpreter_is "sbang"; then
-    die "error: refusing to re-execute sbang to avoid infinite loop."
-fi
-
-# Finally invoke the real shebang line
-# ruby and perl need -x to ignore the first line of input (the sbang line)
-#
-if interpreter_is perl || interpreter_is ruby; then
-    # shellcheck disable=SC2086
-    $exec $shebang_line -x "$@"
 else
-    # shellcheck disable=SC2086
-    $exec $shebang_line "$@"
+    echo "error: sbang found no interpreter in $script"
+    exit 1
 fi

bin/spack

@@ -1,7 +1,8 @@
 #!/bin/sh
 # -*- python -*-
 #
-# Copyright Spack Project Developers. See COPYRIGHT file for details.
+# Copyright 2013-2020 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,13 +10,9 @@
 # Following line is a shell no-op, and starts a multi-line Python comment.
 # See https://stackoverflow.com/a/47886254
 """:"
-# prefer SPACK_PYTHON environment variable, python3, python, then python2
-SPACK_PREFERRED_PYTHONS="python3 python python2 /usr/libexec/platform-python"
-for cmd in "${SPACK_PYTHON:-}" ${SPACK_PREFERRED_PYTHONS}; do
-    if command -v > /dev/null "$cmd"; then
-        export SPACK_PYTHON="$(command -v "$cmd")"
-        exec "${SPACK_PYTHON}" "$0" "$@"
-    fi
+# prefer python3, then python, then python2
+for cmd in python3 python python2; do
+   command -v > /dev/null $cmd && exec $cmd $0 "$@"
 done
 
 echo "==> Error: spack could not find a python interpreter!" >&2
@@ -24,16 +21,15 @@ 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 sys
 
-min_python3 = (3, 6)
-
-if sys.version_info[:2] < min_python3:
+if sys.version_info[:2] < (2, 6):
     v_info = sys.version_info[:3]
-    msg = "Spack requires Python %d.%d or higher " % min_python3
-    msg += "You are running spack with Python %d.%d.%d." % v_info
-    sys.exit(msg)
+    sys.exit("Spack requires Python 2.6 or higher."
+             "This is Python %d.%d.%d." % v_info)
 
 # Find spack's location and its prefix.
 spack_file = os.path.realpath(os.path.expanduser(__file__))
@@ -43,8 +39,26 @@ 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, 6):
+    sys.path.insert(0, os.path.join(spack_external_libs, 'py26'))
+
+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']
 
 # Once we've set up the system path, run the spack main method
-if __name__ == "__main__":
-    sys.exit(main())
+import spack.main  # noqa
+sys.exit(spack.main.main())

bin/spack-python

@@ -1,6 +1,7 @@
 #!/bin/sh
 #
-# Copyright Spack Project Developers. See COPYRIGHT file for details.
+# Copyright 2013-2020 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)
 
@@ -21,4 +22,4 @@
 #
 # This is compatible across platforms.
 #
-exec spack python "$@"
+/usr/bin/env spack python "$@"

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,249 +0,0 @@
-:: Copyright Spack Project Developers. See 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 NOT defined _sp_args (
-   exit /B 0
-)
-
-:: If args contain --bat, or -h/--help: just execute.
-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:--list=%" (
-    goto :default_case
-)
-
-for /f "tokens=* USEBACKQ" %%I in (
-    `python "%spack%" %_sp_flags% %_sp_subcommand% --bat %_sp_args%`
-    ) do %%I
-
-goto :end_switch
-
-: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,147 +0,0 @@
-#  Copyright Spack Project Developers. See 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}
-}
-
-exit $LASTEXITCODE

bin/spack_cmd.bat

@@ -1,11 +0,0 @@
-@ECHO OFF
-:: (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
-::
-
-call "%~dp0..\share\spack\setup-env.bat"
-pushd %SPACK_ROOT%
-%comspec% /K

bin/spack_pwsh.ps1

@@ -1,9 +0,0 @@
-# Copyright Spack Project Developers. See 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

@@ -1,23 +0,0 @@
-bootstrap:
-  # If set to false Spack will not bootstrap missing software,
-  # but will instead raise an error.
-  enable: true
-  # Root directory for bootstrapping work. The software bootstrapped
-  # 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,
-  # depending on its type.
-  sources:
-  - name: github-actions-v0.6
-    metadata: $spack/share/spack/bootstrap/github-actions-v0.6
-  - name: github-actions-v0.5
-    metadata: $spack/share/spack/bootstrap/github-actions-v0.5
-  - name: spack-install
-    metadata: $spack/share/spack/bootstrap/spack-install
-  trusted:
-    # By default we trust bootstrapping from sources and from binaries
-    # produced on Github via the workflow
-    github-actions-v0.6: true
-    github-actions-v0.5: true
-    spack-install: true

etc/spack/defaults/concretizer.yaml

@@ -1,65 +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 compatibility 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: {}
-
-  # Option to specify whether to support splicing. Splicing allows for
-  # the relinking of concrete package dependencies in order to better
-  # reuse already built packages with ABI compatible dependencies
-  splice:
-    explicit: []
-    automatic: false
-  # Maximum time, in seconds, allowed for the 'solve' phase. If set to 0, there is no time limit.
-  timeout: 0
-  # If set to true, exceeding the timeout will always result in a concretization error. If false,
-  # the best (suboptimal) model computed before the timeout is used.
-  #
-  # Setting this to false yields unreproducible results, so we advise to use that value only
-  # for debugging purposes (e.g. check which constraints can help Spack concretize faster).
-  error_on_timeout: true

etc/spack/defaults/config.yaml

@@ -16,25 +16,23 @@
 config:
   # This is the path to the root of the Spack install tree.
   # You can use $spack here to refer to the root of the spack instance.
-  install_tree:
-    root: $spack/opt/spack
-    projections:
-      all: "{architecture}/{compiler.name}-{compiler.version}/{name}-{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
-    # length as possible
-    # if padded_length is an integer, Spack will pad to that many characters,
-    # assuming it is higher than the length of the install_tree root.
-    # padded_length: 128
+  install_tree: ~/.spack/opt/spack
 
 
   # Locations where templates should be found
   template_dirs:
     - $spack/share/spack/templates
 
-  # Directory where licenses should be located
-  license_dir: $spack/etc/spack/licenses
+
+  # Default directory layout
+  install_path_scheme: "${ARCHITECTURE}/${COMPILERNAME}-${COMPILERVER}/${PACKAGE}-${VERSION}-${HASH}"
+
+
+  # Locations where different types of modules should be installed.
+  module_roots:
+    tcl:    ~/.spack/share/spack/modules
+    lmod:   ~/.spack/share/spack/lmod
+
 
   # Temporary locations Spack can try to use for builds.
   #
@@ -45,8 +43,8 @@ config:
   # (i.e., ``$TMP` or ``$TMPDIR``).
   #
   # Another option that prevents conflicts and potential permission issues is
-  # to specify `$user_cache_path/stage`, which ensures each user builds in their
-  # home directory.
+  # to specify `~/.spack/stage`, which ensures each user builds in their home
+  # directory.
   #
   # A more traditional path uses the value of `$spack/var/spack/stage`, which
   # builds directly inside Spack's instance without staging them in a
@@ -54,11 +52,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.
@@ -68,32 +61,18 @@ config:
   # identifies Spack staging to avoid accidentally wiping out non-Spack work.
   build_stage:
     - $tempdir/$user/spack-stage
-    - $user_cache_path/stage
+    - ~/.spack/stage
   # - $spack/var/spack/stage
 
-  # Directory in which to run tests and store test results.
-  # Tests will be stored in directories named by date/time and package
-  # name/hash.
-  test_stage: $user_cache_path/test
 
   # Cache directory for already downloaded source tarballs and archived
   # repositories. This can be purged with `spack clean --downloads`.
-  source_cache: $spack/var/spack/cache
-
-
-  ## Directory where spack managed environments are created and stored
-  # environments_root: $spack/var/spack/environments
+  source_cache: ~/.spack/var/spack/cache
 
 
   # Cache directory for miscellaneous files, like the package index.
   # This can be purged with `spack clean --misc-cache`
-  misc_cache: $user_cache_path/cache
-
-
-  # Timeout in seconds used for downloading sources etc. This only applies
-  # to the connection phase and can be increased for slow connections or
-  # servers. 0 means no timeout.
-  connect_timeout: 10
+  misc_cache: ~/.spack/cache
 
 
   # If this is false, tools like curl that use SSL will not verify
@@ -101,12 +80,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
@@ -115,16 +88,17 @@ config:
   suppress_gpg_warnings: false
 
 
+  # If set to true, Spack will attempt to build any compiler on the spec
+  # that is not already available. If set to False, Spack will only use
+  # compilers already configured in compilers.yaml
+  install_missing_compilers: False
+
+
   # If set to true, Spack will always check checksums after downloading
   # archives. If false, Spack skips the checksum step.
   checksum: true
 
 
-  # If set to true, Spack will fetch deprecated versions without warning.
-  # If false, Spack will raise an error when trying to install a deprecated version.
-  deprecated: false
-
-
   # If set to true, `spack install` and friends will NOT clean
   # potentially harmful variables from the build environment. Use wisely.
   dirty: false
@@ -146,29 +120,24 @@ config:
   # enabling locks.
   locks: true
 
-  # The default url fetch method to use.
-  # If set to 'curl', Spack will require curl on the user's system
-  # If set to 'urllib', Spack will use python built-in libs to fetch
-  url_fetch_method: urllib
 
-  # The maximum number of jobs to use for the build system (e.g. `make`), when
-  # the -j flag is not given on the command line. Defaults to 16 when not set.
-  # Note that the maximum number of jobs is limited by the number of cores
-  # available, taking thread affinity into account when supported. For instance:
-  # - With `build_jobs: 16` and 4 cores available `spack install` will run `make -j4`
-  # - With `build_jobs: 16` and 32 cores available `spack install` will run `make -j16`
-  # - With `build_jobs: 2` and 4 cores available `spack install -j6` will run `make -j6`
+  # The maximum number of jobs to use when running `make` in parallel,
+  # always limited by the number of cores available. For instance:
+  # - If set to 16 on a 4 cores machine `spack install` will run `make -j4`
+  # - If set to 16 on a 18 cores machine `spack install` will run `make -j16`
+  # If not set, Spack will use all available cores up to 16.
   # build_jobs: 16
 
 
   # If set to true, Spack will use ccache to cache C compiles.
   ccache: false
 
+
   # How long to wait to lock the Spack installation database. This lock is used
   # 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).
@@ -178,51 +147,7 @@ config:
   # never succeed.
   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
-
-    # Controls the handling of missing dynamic libraries after installation.
-    # Options are ignore (default), warn, or error. If set to error, the
-    # installation fails if installed binaries reference dynamic libraries that
-    # are not found in their specified rpaths.
-    missing_library_policy: ignore
-
-
-  # 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
+  # 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'

etc/spack/defaults/darwin/modules.yaml

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

etc/spack/defaults/darwin/packages.yaml

@@ -15,38 +15,13 @@
 # -------------------------------------------------------------------------
 packages:
   all:
-    compiler:
-    - apple-clang
-    - clang
-    - gcc
+    compiler: [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:
+    paths:
     # Apple bundles libunwind version 35.3 with macOS 10.9 and later,
     # although the version number used here isn't critical
-    - spec: apple-libunwind@35.3
-      prefix: /usr
-  apple-libuuid:
-    buildable: false
-    externals:
-    # 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
+      apple-libunwind@35.3: /usr
+    buildable: False

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 +0,0 @@
-mirrors:
-  spack-public:
-    binary: false
-    url: https://mirror.spack.io

etc/spack/defaults/modules.yaml

@@ -14,42 +14,32 @@
 #   ~/.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.
+  enable:
+    - tcl
   prefix_inspections:
-    ./bin:
+    bin:
       - PATH
-    ./man:
+    man:
       - MANPATH
-    ./share/man:
+    share/man:
       - MANPATH
-    ./share/aclocal:
+    share/aclocal:
       - ACLOCAL_PATH
-    ./lib/pkgconfig:
+    lib:
+      - LIBRARY_PATH
+    lib64:
+      - LIBRARY_PATH
+    include:
+      - CPATH
+    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:
-    # 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
-
-    # Default configurations if lmod is enabled
-    lmod:
-      all:
-        autoload: direct
-      hierarchy:
-        - mpi
+  lmod:
+    hierarchy:
+      - mpi

etc/spack/defaults/packages.yaml

@@ -15,85 +15,36 @@
 # -------------------------------------------------------------------------
 packages:
   all:
-    compiler: [gcc, clang, oneapi, xl, nag, fj, aocc]
+    compiler: [gcc, intel, pgi, clang, xl, nag, fj]
     providers:
-      awk: [gawk]
-      armci: [armcimpi]
-      blas: [openblas, amdblis]
-      c: [gcc]
-      cxx: [gcc]
       D: [ldc]
-      daal: [intel-oneapi-daal]
+      awk: [gawk]
+      blas: [openblas]
+      daal: [intel-daal]
       elf: [elfutils]
-      fftw-api: [fftw, amdfftw]
-      flame: [libflame, amdlibflame]
-      fortran: [gcc]
-      fortran-rt: [gcc-runtime, intel-oneapi-runtime]
-      fuse: [libfuse]
-      gl: [glx, osmesa]
+      fftw-api: [fftw]
+      gl: [mesa+opengl, opengl]
+      glx: [mesa+glx, opengl]
       glu: [mesa-glu, openglu]
-      golang: [go, gcc]
-      go-or-gccgo-bootstrap: [go-bootstrap, gcc]
-      iconv: [libiconv]
-      ipp: [intel-oneapi-ipp]
-      java: [openjdk, jdk]
+      golang: [gcc]
+      ipp: [intel-ipp]
+      java: [openjdk, jdk, ibm-java]
       jpeg: [libjpeg-turbo, libjpeg]
-      lapack: [openblas, amdlibflame]
-      libc: [glibc, musl]
-      libgfortran: [gcc-runtime]
-      libglx: [mesa+glx]
-      libifcore: [intel-oneapi-runtime]
-      libllvm: [llvm]
-      lua-lang: [lua, lua-luajit-openresty, lua-luajit]
-      luajit: [lua-luajit-openresty, lua-luajit]
+      lapack: [openblas]
       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]
-      pbs: [openpbs, torque]
       pil: [py-pillow]
       pkgconfig: [pkgconf, pkg-config]
-      qmake: [qt-base, qt]
-      rpc: [libtirpc]
-      scalapack: [netlib-scalapack, amdscalapack]
+      scalapack: [netlib-scalapack]
       sycl: [hipsycl]
-      szip: [libaec, libszip]
+      szip: [libszip, libaec]
       tbb: [intel-tbb]
       unwind: [libunwind]
-      uuid: [util-linux-uuid, libuuid]
-      wasi-sdk: [wasi-sdk-prebuilt]
-      xkbdata-api: [xkeyboard-config, xkbdata]
-      xxd: [xxd-standalone, vim]
-      yacc: [bison, byacc]
-      ziglang: [zig]
-      zlib-api: [zlib-ng+compat, zlib]
+      sycl: [hipsycl]
     permissions:
       read: world
       write: user
-  cray-fftw:
-    buildable: false
-  cray-libsci:
-    buildable: false
-  cray-mpich:
-    buildable: false
-  cray-mvapich2:
-    buildable: false
-  cray-pmi:
-    buildable: false
-  egl:
-    buildable: false
-  essl:
-    buildable: false
-  fujitsu-mpi:
-    buildable: false
-  fujitsu-ssl2:
-    buildable: false
-  hpcx-mpi:
-    buildable: false
-  mpt:
-    buildable: false
-  spectrum-mpi:
-    buildable: false

etc/spack/defaults/upstreams.yaml

@@ -0,0 +1,7 @@
+upstreams:
+   global:
+     install_tree: $spack/opt/spack
+     modules:
+       tcl:    $spack/share/spack/modules
+       lmod:   $spack/share/spack/lmod
+       dotkit: $spack/share/spack/dotkit

etc/spack/defaults/windows/config.yaml

@@ -1,5 +0,0 @@
-config:
-  locks: false
-  build_stage::
-    - '$user_cache_path/stage'
-  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/Makefile

@@ -2,7 +2,7 @@
 #
 
 # You can set these variables from the command line.
-SPHINXOPTS    = -W --keep-going
+SPHINXOPTS    = -W
 SPHINXBUILD   = sphinx-build
 PAPER         =
 BUILDDIR      = _build

lib/spack/docs/_gh_pages_redirect/index.html

@@ -1,10 +1,10 @@
 <html>
   <head>
-    <meta http-equiv="refresh" content="0; url=https://spack.readthedocs.io/" />
+    <meta http-equiv="refresh" content="0; url=http://spack.readthedocs.io/" />
   </head>
   <body>
     <p>
-      This page has moved to <a href="https://spack.readthedocs.io/">https://spack.readthedocs.io/</a>
+      This page has moved to <a href="http://spack.readthedocs.io/">http://spack.readthedocs.io/</a>
     </p>
   </body>
 </html>

lib/spack/docs/_pygments/style.py

@@ -1,15 +0,0 @@
-# Copyright Spack Project Developers. See 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/_templates/layout.html

@@ -1,12 +0,0 @@
-{% extends "!layout.html" %}
-
-{%- block extrahead %} 
-  <!-- Google tag (gtag.js) -->
-  <script async src="https://www.googletagmanager.com/gtag/js?id=G-S0PQ7WV75K"></script>
-  <script>
-    window.dataLayer = window.dataLayer || [];
-    function gtag(){dataLayer.push(arguments);}
-    gtag('js', new Date());
-    gtag('config', 'G-S0PQ7WV75K');
-  </script>
-{% endblock %}

lib/spack/docs/binary_caches.rst

@@ -1,4 +1,5 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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)
 
@@ -12,47 +13,26 @@ 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:
-
-.. code-block:: console
-
-    $ spack buildcache push ./spack-cache ninja
-    ==> Pushing binary packages to file:///home/spackuser/spack/spack-cache/build_cache
-
-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.
 
 ---------------------------------------
 Finding or installing build cache files
@@ -63,275 +43,30 @@ with:
 
 .. code-block:: console
 
-    $ spack mirror add <name> <url or path>
-
-
-Both web URLs and local paths on the filesystem can be specified. In the previous
-example, you might add the directory "spack-cache" and call it ``mymirror``:
+   $ spack mirror add <name> <url>
 
+Build caches are found via:
 
 .. code-block:: console
 
-    $ spack mirror add mymirror ./spack-cache
+   $ spack buildcache list
 
-
-You can see that the mirror is added with ``spack mirror list`` as follows:
+Build caches are installed via:
 
 .. code-block:: console
 
+   $ spack buildcache install
 
-    $ spack mirror list
-    mymirror           file:///home/spackuser/spack/spack-cache
-    spack-public       https://spack-llnl-mirror.s3-us-west-2.amazonaws.com/
-
-
-At this point, you've create a buildcache, but spack hasn't indexed it, so if
-you run ``spack buildcache list`` you won't see any results. You need to index
-this new build cache as follows:
-
-.. code-block:: console
-
-    $ spack buildcache update-index ./spack-cache
-
-Now you can use list:
-
-.. code-block:: console
-
-    $  spack buildcache list
-    ==> 1 cached build.
-    -- 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:
-
-.. 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
-
-.. code-block:: console
-
-   $ spack install --use-buildcache 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:
-
-.. code-block:: console
-
-    $ spack mirror add E4S https://cache.e4s.io
-    $ spack buildcache keys --install --trust
-    $ spack install --use-buildcache only <package>
-
-We use ``--install`` and ``--trust`` to say that we are installing keys to our
-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>`_'
-
--------------------
-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 variables that hold the username and password (or
-personal access token) for the registry:
-
-.. code-block:: console
-
-    $ spack mirror add --oci-username-variable REGISTRY_USER \
-                       --oci-password-variable REGISTRY_TOKEN \
-                       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 ... my_registry oci://username/my_image
-
-From here, you can use the mirror as any other build cache:
-
-.. code-block:: console
-
-    $ export REGISTRY_USER=...
-    $ export REGISTRY_TOKEN=...
-    $ spack buildcache push my_registry <specs...>  # push to the registry
-    $ spack install <specs...>  # or 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:
 
@@ -340,7 +75,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,177 +0,0 @@
-.. Copyright Spack Project Developers. See 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
-     % spack buildcache update-index /opt/bootstrap/bootstrap_cache
-
-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,273 +1,235 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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 how aggressively Spack reuses binary packages during concretization. The
-attribute can either be a single value, or an object for more complex configurations.
-
-In the former case ("single value") it allows Spack to:
-
-1. Reuse installed packages and buildcaches for all the specs to be concretized, when ``true``
-2. Reuse installed packages and buildcaches only for the dependencies of the root specs, when ``dependencies``
-3. Disregard reusing installed packages and buildcaches, when ``false``
-
-In case a finer control over which specs are reused is needed, then the value of this attribute can be
-an object, with the following keys:
-
-1. ``roots``: if ``true`` root specs are reused, if ``false`` only dependencies of root specs are reused
-2. ``from``: list of sources from which reused specs are taken
-3. ``namespaces``: list of namespaces from which to reuse specs, or the string ``"any"``.
-
-Each source in ``from`` is itself an object:
-
-.. list-table:: Attributes for a source or reusable specs
-   :header-rows: 1
-
-   * - Attribute name
-     - Description
-   * - type (mandatory, string)
-     - Can be ``local``, ``buildcache``, or ``external``
-   * - include (optional, list of specs)
-     - If present, reusable specs must match at least one of the constraint in the list
-   * - exclude (optional, list of specs)
-     - If present, reusable specs must not match any of the constraint in the list.
-
-For instance, the following configuration:
+At a high level, the ``packages.yaml`` file is structured like this:
 
 .. code-block:: yaml
 
-   concretizer:
-     reuse:
-       roots: true
-       namespaces: [builtin]
-       from:
-       - type: local
-         include:
-         - "%gcc"
-         - "%clang"
+   packages:
+     package1:
+       # settings for package1
+     package2:
+       # settings for package2
+     # ...
+     all:
+       # settings that apply to all packages.
 
-tells the concretizer to reuse all specs compiled with either ``gcc`` or ``clang``, that are installed
-in the local store. Any spec from remote buildcaches is disregarded. Any spec from a namespace other than
-Spack's builtin repo is disregarded.
+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.
 
-To reduce the boilerplate in configuration files, default values for the ``include`` and
-``exclude`` options can be pushed up one level:
+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:
-     reuse:
-       roots: true
-       include:
-       - "%gcc"
-       from:
-       - type: local
-       - type: buildcache
-       - type: local
-         include:
-         - "foo %oneapi"
+   packages:
+     openmpi:
+       paths:
+         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
 
-In the example above we reuse all specs compiled with ``gcc`` from the local store
-and remote buildcaches, and we also reuse ``foo %oneapi``. Note that the last source of
-specs override the default ``include`` attribute.
+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.
 
-For one-off concretizations, the are command line arguments for each of the simple "single value"
-configurations. This means a user can:
-
-.. code-block:: console
-
-   % spack install --reuse <spec>
-
-to enable reuse for a single installation, or:
-
-.. code-block:: console
-
-   spack install --fresh <spec>
-
-to do a fresh install if ``reuse`` is enabled by 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:
+``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.
 
 .. code-block:: yaml
 
-   concretizer:
-     targets:
-       granularity: microarchitectures
+   cmake:
+     modules:
+       cmake@3.7.2: CMake/3.7.2
 
-Spack will consider all the microarchitectures known to ``archspec`` to label nodes for
-compatibility. If instead the option is set to:
+Each ``packages.yaml`` begins with a ``packages:`` token, followed
+by a list of package names.  To specify externals, add a ``paths`` or ``modules``
+token under the package name, which lists externals in a
+``spec: /path`` or ``spec: module-name`` format.  Each spec 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.
+
+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.
+
+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.
+
+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
 
-   concretizer:
-     targets:
-       granularity: generic
+   packages:
+     openmpi:
+       paths:
+         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
+       buildable: False
 
-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.
+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.
 
-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.
+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.
 
----------------
-Duplicate nodes
----------------
+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.
 
-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.
 
-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.
+.. _concretization-preferences:
 
-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:
+--------------------------
+Concretization Preferences
+--------------------------
 
-.. figure::  images/shapely_duplicates.svg
-   :scale: 70 %
-   :align: center
+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.
 
-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``.
-
---------
-Splicing
---------
-
-The ``splice`` key covers config attributes for splicing specs in the solver.
-
-"Splicing" is a method for replacing a dependency with another spec
-that provides the same package or virtual. There are two types of
-splices, referring to different behaviors for shared dependencies
-between the root spec and the new spec replacing a dependency:
-"transitive" and "intransitive". A "transitive" splice is one that
-resolves all conflicts by taking the dependency from the new node. An
-"intransitive" splice is one that resolves all conflicts by taking the
-dependency from the original root. From a theory perspective, hybrid
-splices are possible but are not modeled by Spack.
-
-All spliced specs retain a ``build_spec`` attribute that points to the
-original Spec before any splice occurred. The ``build_spec`` for a
-non-spliced spec is itself.
-
-The figure below shows examples of transitive and intransitive splices:
-
-.. figure:: images/splices.png
-   :align: center
-
-The concretizer can be configured to explicitly splice particular
-replacements for a target spec. Splicing will allow the user to make
-use of generically built public binary caches, while swapping in
-highly optimized local builds for performance critical components
-and/or components that interact closely with the specific hardware
-details of the system. The most prominent candidate for splicing is
-MPI providers. MPI packages have relatively well-understood ABI
-characteristics, and most High Performance Computing facilities deploy
-highly optimized MPI packages tailored to their particular
-hardware. The following config block configures Spack to replace
-whatever MPI provider each spec was concretized to use with the
-particular package of ``mpich`` with the hash that begins ``abcdef``.
+Here's an example ``packages.yaml`` file that sets preferred packages:
 
 .. code-block:: yaml
 
-   concretizer:
-     splice:
-       explicit:
-       - target: mpi
-         replacement: mpich/abcdef
-         transitive: false
+   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]
 
-.. warning::
+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.
 
-   When configuring an explicit splice, you as the user take on the
-   responsibility for ensuring ABI compatibility between the specs
-   matched by the target and the replacement you provide. If they are
-   not compatible, Spack will not warn you and your application will
-   fail to run.
+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.
 
-The ``target`` field of an explicit splice can be any abstract
-spec. The ``replacement`` field must be a spec that includes the hash
-of a concrete spec, and the replacement must either be the same
-package as the target, provide the virtual that is the target, or
-provide a virtual that the target provides. The ``transitive`` field
-is optional -- by default, splices will be transitive.
+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.
 
-.. note::
+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.
 
-   With explicit splices configured, it is possible for Spack to
-   concretize to a spec that does not satisfy the input. For example,
-   with the config above ``hdf5 ^mvapich2`` will concretize to user
-   ``mpich/abcdef`` instead of ``mvapich2`` as the MPI provider. Spack
-   will warn the user in this case, but will not fail the
-   concretization.
+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.
 
-.. _automatic_splicing:
+.. _package_permissions:
 
-^^^^^^^^^^^^^^^^^^
-Automatic Splicing
-^^^^^^^^^^^^^^^^^^
+-------------------
+Package Permissions
+-------------------
 
-The Spack solver can be configured to do automatic splicing for
-ABI-compatible packages. Automatic splices are enabled in the concretizer
-config section
+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
 
-   concretizer:
-     splice:
-       automatic: True
+  packages:
+    all:
+      permissions:
+        write: group
+        group: spack
+    my_app:
+      permissions:
+        read: group
+        group: my_team
 
-Packages can include ABI-compatibility information using the
-``can_splice`` directive. See :ref:`the packaging
-guide<abi_compatibility>` for instructions on specifying ABI
-compatibility using the ``can_splice`` directive.
+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``.
 
-.. note::
-
-   The ``can_splice`` directive is experimental and may be changed in
-   future versions.
-
-When automatic splicing is enabled, the concretizer will combine any
-number of ABI-compatible specs if possible to reuse installed packages
-and packages available from binary caches. The end result of these
-specs is equivalent to a series of transitive/intransitive splices,
-but the series may be non-obvious.
+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,5 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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)
 
@@ -28,7 +29,6 @@ on these ideas for each distinct build system that Spack supports:
    :maxdepth: 1
    :caption: Make-incompatible
 
-   build_systems/mavenpackage
    build_systems/sconspackage
    build_systems/wafpackage
 
@@ -38,7 +38,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
@@ -47,12 +46,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::
@@ -61,11 +58,8 @@ 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
 
 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,12 +1,13 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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
@@ -16,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
@@ -111,53 +112,20 @@ phase runs:
 
 .. code-block:: console
 
-   $ autoreconf --install --verbose --force -I <aclocal-prefix>/share/aclocal
-
-In case you need to add more arguments, override ``autoreconf_extra_args``
-in your ``package.py`` on class scope like this:
-
-.. code-block:: python
-
-   autoreconf_extra_args = ["-Im4"]
+   $ libtoolize
+   $ aclocal
+   $ autoreconf --install --verbose --force
 
 All you need to do is add a few Autotools dependencies to the package.
 Most stable releases will come with a ``configure`` script, but if you
-check out a commit from the ``master`` branch, you would want to add:
+check out a commit from the ``develop`` 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")
-
-It is typically redundant to list the ``m4`` macro processor package as a
-dependency, since ``autoconf`` already depends on it.
-
-"""""""""""""""""""""""""""""""
-Using a custom autoreconf phase
-"""""""""""""""""""""""""""""""
-
-In some cases, it might be needed to replace the default implementation
-of the autoreconf phase with one running a script interpreter. In this
-example, the ``bash`` shell is used to run the ``autogen.sh`` script.
-
-.. code-block:: python
-
-   def autoreconf(self, spec, prefix):
-       which("bash")("autogen.sh")
-
-If the ``package.py`` has build instructions in a separate
-:ref:`builder class <multiple_build_systems>`, the signature for a phase changes slightly:
-
-.. code-block:: python
-
-   class AutotoolsBuilder(AutotoolsBuilder):
-      def autoreconf(self, pkg, spec, prefix):
-         which("bash")("autogen.sh")
-
-"""""""""""""""""""""""""""""""""""""""
-patching configure or Makefile.in files
-"""""""""""""""""""""""""""""""""""""""
+   depends_on('autoconf', type='build', when='@develop')
+   depends_on('automake', type='build', when='@develop')
+   depends_on('libtool',  type='build', when='@develop')
+   depends_on('m4',       type='build', when='@develop')
 
 In some cases, developers might need to distribute a patch that modifies
 one of the files used to generate ``configure`` or ``Makefile.in``.
@@ -167,57 +135,6 @@ create a new patch that directly modifies ``configure``. That way,
 Spack can use the secondary patch and additional build system
 dependencies aren't necessary.
 
-""""""""""""""""""""""""""""
-Old Autotools helper scripts
-""""""""""""""""""""""""""""
-
-Autotools based tarballs come with helper scripts such as ``config.sub`` and
-``config.guess``. It is the responsibility of the developers to keep these files
-up to date so that they run on every platform, but for very old software
-releases this is impossible. In these cases Spack can help to replace these
-files with newer ones, without having to add the heavy dependency on
-``automake``.
-
-Automatic helper script replacement is currently enabled by default on
-``ppc64le`` and ``aarch64``, as these are the known cases where old scripts fail.
-On these targets, ``AutotoolsPackage`` adds a build dependency on ``gnuconfig``,
-which is a very light-weight package with newer versions of the helper files.
-Spack then tries to run all the helper scripts it can find in the release, and
-replaces them on failure with the helper scripts from ``gnuconfig``.
-
-To opt out of this feature, use the following setting:
-
-.. code-block:: python
-
-   patch_config_files = False
-
-To enable it conditionally on different architectures, define a property and
-make the package depend on ``gnuconfig`` as a build dependency:
-
-.. code-block:: python
-
-   depends_on("gnuconfig", when="@1.0:")
-
-   @property
-   def patch_config_files(self):
-      return self.spec.satisfies("@1.0:")
-
-.. note::
-
-    On some exotic architectures it is necessary to use system provided
-    ``config.sub`` and ``config.guess`` files. In this case, the most
-    transparent solution is to mark the ``gnuconfig`` package as external and
-    non-buildable, with a prefix set to the directory containing the files:
-
-   .. code-block:: yaml
-
-       gnuconfig:
-         buildable: false
-         externals:
-         - spec: gnuconfig@master
-           prefix: /usr/share/configure_files/
-
-
 """"""""""""""""
 force_autoreconf
 """"""""""""""""
@@ -238,7 +155,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
@@ -272,9 +189,9 @@ often lists dependencies and the flags needed to locate them. The
 "environment variables" section lists environment variables that the
 build system uses to pass flags to the compiler and linker.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^
-Adding flags to configure
-^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+Addings flags to configure
+^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 For most of the flags you encounter, you will want a variant to
 optionally enable/disable them. You can then optionally pass these
@@ -285,26 +202,14 @@ 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):
-       args = []
-       ...
-       args.extend(self.enable_or_disable("mpi"))
-       return args
-
-
 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
@@ -315,11 +220,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
@@ -330,172 +233,7 @@ 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
-"""""""""""""""""
-
-Autotools flags for simple boolean variants can be automatically
-generated by calling the ``enable_or_disable`` method. This is
-typically used to enable or disable some feature within the package.
-
-.. code-block:: python
-
-   variant(
-       "memchecker",
-       default=False,
-       description="Memchecker support for debugging [degrades performance]"
-   )
-   ...
-
-   def configure_args(self):
-       args = []
-       ...
-       args.extend(self.enable_or_disable("memchecker"))
-
-       return args
-
-In this example, specifying the variant ``+memchecker`` will generate
-the following configuration options:
-
-.. code-block:: console
-
-   --enable-memchecker
-
-"""""""""""""""
-with_or_without
-"""""""""""""""
-
-Autotools flags for more complex variants, including boolean variants
-and multi-valued variants, can be automatically generated by calling
-the ``with_or_without`` method.
-
-.. code-block:: python
-
-   variant(
-       "schedulers",
-       values=disjoint_sets(
-           ("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"))
-
-In this example, specifying the variant ``schedulers=slurm,sge`` will
-generate the following configuration options:
-
-.. code-block:: console
-
-   --with-slurm --with-sge
-
-``enable_or_disable`` is actually functionally equivalent with
-``with_or_without``, and accepts the same arguments and variant types;
-but idiomatic autotools packages often follow these naming
-conventions.
-
-""""""""""""""""
-activation_value
-""""""""""""""""
-
-Autotools parameters that require an option can still be automatically
-generated, using the ``activation_value`` argument to
-``with_or_without`` (or, rarely, ``enable_or_disable``).
-
-.. code-block:: python
-
-   variant(
-      "fabrics",
-       values=disjoint_sets(
-           ("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"))
-
-``activation_value`` accepts a callable that generates the configure
-parameter value given the variant value; but the special value
-``prefix`` tells Spack to automatically use the dependenency's
-installation prefix, which is the most common use for such
-parameters. In this example, specifying the variant
-``fabrics=libfabric`` will generate the following configuration
-options:
-
-.. code-block:: console
-
-   --with-libfabric=</path/to/libfabric>
-
-"""""""""""""""""""""""
-The ``variant`` keyword
-"""""""""""""""""""""""
-
-When Spack variants and configure flags do not correspond one-to-one, the
-``variant`` keyword can be passed to ``with_or_without`` and
-``enable_or_disable``. For example:
-
-.. code-block:: python
-
-   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")
-
-
-""""""""""""""""""""
-Conditional variants
-""""""""""""""""""""
-
-When a variant is conditional and its condition is not met on the concrete spec, the
-``with_or_without`` and ``enable_or_disable`` methods will simply return an empty list.
-
-For example:
-
-.. code-block:: python
-
-   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``.
-
-""""""""""""""""""""
-Activation overrides
-""""""""""""""""""""
-
-Finally, the behavior of either ``with_or_without`` or
-``enable_or_disable`` can be overridden for specific variant
-values. This is most useful for multi-values variants where some of
-the variant values require atypical behavior.
-
-.. code-block:: python
-
-   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"
-       if not activated:
-           return f"--without-{opt}"
-       return f"--with-{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
-``--with-openib`` for older versions of the package and specifying an
-alternative dependency name:
-
-.. code-block::
-
-   --with-openib=</path/to/rdma-core>
+TODO: document ``with_or_without`` and ``enable_or_disable``.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Configure script in a sub-directory
@@ -510,7 +248,7 @@ do this like so:
 
 .. code-block:: python
 
-   configure_directory = "src"
+   configure_directory = 'src'
 
 ^^^^^^^^^^^^^^^^^^^^^^
 Building out of source
@@ -522,7 +260,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
@@ -545,8 +283,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,39 +1,17 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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,122 +0,0 @@
-.. Copyright Spack Project Developers. See 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,12 +1,13 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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
@@ -20,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
@@ -81,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
@@ -89,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')
 
 
 ^^^^^^^^^^^^^^^^^^^
@@ -127,116 +128,20 @@ 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:
+``cmake_args`` function:
 
 .. 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
-       ]
+       args = []
+
+       if '+hdf5' in self.spec:
+           args.append('-DDETECT_HDF5=ON')
+       else:
+           args.append('-DDETECT_HDF5=OFF')
 
        return args
 
-Spack supports CMake defines from conditional variants too. Whenever the condition on
-the variant is not met, ``define_from_variant()`` will simply return an empty string,
-and CMake simply ignores the empty command line argument. For example the following
-
-.. code-block:: python
-
-   variant("example", default=True, when="@2.0:")
-
-   def cmake_args(self):
-      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
@@ -249,7 +154,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
@@ -257,7 +162,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
@@ -274,6 +179,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
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -287,7 +222,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,
@@ -303,7 +238,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
@@ -323,8 +258,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,130 +1,43 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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>`_.
+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.
 
-You can find source for the package at
-`<https://github.com/spack/spack/blob/develop/lib/spack/spack/build_systems/cuda.py>`__.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Provided variants and dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-^^^^^^^^
-Variants
-^^^^^^^^
-
-This package provides the following variants:
-
-* **cuda**
-
-  This variant is used to enable/disable building with ``CUDA``. The default
-  is disabled (or ``False``).
-
-* **cuda_arch**
-
-  This variant supports the optional specification of one or multiple architectures.
-  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 .
-
-^^^^^^^^^
-Conflicts
-^^^^^^^^^
-
-Conflicts are used to prevent builds with known bugs or issues. While
-base ``CUDA`` conflicts have been included with this package, you may
-want to add more for your software.
-
-For example, if your package requires ``cuda_arch`` to be specified when
-``cuda`` is enabled, you can add the following conflict to your package
-to terminate such build attempts with a suitable message:
-
-.. code-block:: python
-
-    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,
-suppose your software does not work with CUDA compute capability versions
-prior to SM 5.0 (``50``).  You can add the following code to display a
-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"
-    ]
-    for value in unsupported_cuda_archs:
-        conflicts(f"cuda_arch={value}", when="+cuda",
-                  msg=f"CUDA architecture {value} is not supported")
-
-^^^^^^^
-Methods
-^^^^^^^
-
-This package provides one custom helper method, which is used to build
-standard CUDA compiler flags.
-
-**cuda_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``).
-
-    This method must be explicitly called when you are creating the
-    arguments for your build in order to use the values.
+``CudaPackage`` provides ``cuda`` variant (default to ``off``) to enable/disable
+``CUDA``, and ``cuda_arch`` variant to optionally specify the architecture.
+It also declares dependencies on the ``CUDA`` package ``depends_on('cuda@...')``
+based on the architecture as well as specifies conflicts for certain compiler versions.
 
 ^^^^^
 Usage
 ^^^^^
 
-This helper package can be added to your package by adding it as a base
-class of your package.  For example, you can add it to your
-:ref:`CMakePackage <cmakepackage>`-based package as follows:
+In order to use it, just add another base class to your package, for example:
 
 .. code-block:: python
-   :emphasize-lines: 1,7-16
 
-    class MyCudaPackage(CMakePackage, CudaPackage):
+    class MyPackage(CMakePackage, CudaPackage):
         ...
         def cmake_args(self):
             spec = self.spec
-            args = []
-            ...
-            if spec.satisfies("+cuda"):
-                # Set up the cuda macros needed by the build
-                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' in spec:
+                options.append('-DWITH_CUDA=ON')
+                cuda_arch = spec.variants['cuda_arch'].value
+                if cuda_arch is not None:
+                    options.append('-DCUDA_FLAGS=-arch=sm_{0}'.format(cuda_arch[0]))
             else:
-                # Ensure build with cuda is disabled
-                args.append("-DWITH_CUDA=OFF")
-            ...
-            return args
-
-assuming only the ``WITH_CUDA`` and ``CUDA_FLAGS`` flags are required.
-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``.
-
-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.
+                options.append('-DWITH_CUDA=OFF')

lib/spack/docs/build_systems/custompackage.rst

@@ -1,4 +1,5 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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)
 
@@ -8,7 +9,7 @@
 Custom Build Systems
 --------------------
 
-While the built-in build systems should meet your needs for the
+While the build systems listed above should meet your needs for the
 vast majority of packages, some packages provide custom build scripts.
 This guide is intended for the following use cases:
 
@@ -30,7 +31,7 @@ installation. Both of these packages require custom build systems.
 Base class
 ^^^^^^^^^^
 
-If your package does not belong to any of the built-in build
+If your package does not belong to any of the aforementioned build
 systems that Spack already supports, you should inherit from the
 ``Package`` base class. ``Package`` is a simple base class with a
 single phase: ``install``. If your package is simple, you may be able
@@ -56,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
@@ -77,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
@@ -91,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``:
@@ -99,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.
@@ -127,21 +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
-        maker = make
-        cpan_dir = join_path("cpanm", "cpanm")
-        if sys.platform == "win32":
-            maker = nmake
-            cpan_dir = join_path(self.stage.source_path, cpan_dir)
-            cpan_dir = windows_sfn(cpan_dir)
-        if "+cpanm" in spec:
-            with working_dir(cpan_dir):
-                perl = spec["perl"].command
-                perl("Makefile.PL")
-                maker()
-                maker("install")
+       spec = self.spec
+
+       if '+cpanm' in spec:
+           with working_dir(join_path('cpanm', 'cpanm')):
+               perl = spec['perl'].command
+               perl('Makefile.PL')
+               make()
+               make('install')
 
 This extra step automatically installs ``cpanm`` in addition to the
 base Perl installation.
@@ -172,52 +168,42 @@ if and only if this flag is set, we would use the following line:
 Testing
 ^^^^^^^
 
-Let's put everything together and add unit tests to be optionally run
-during the installation of our package.
+Let's put everything together and add unit tests to our package.
 In the ``perl`` package, we can see:
 
 .. code-block:: python
 
-   @run_after("build")
+   @run_after('build')
    @on_package_attributes(run_tests=True)
-   def build_test(self):
-        if sys.platform == "win32":
-            win32_dir = os.path.join(self.stage.source_path, "win32")
-            win32_dir = windows_sfn(win32_dir)
-            with working_dir(win32_dir):
-                nmake("test", ignore_quotes=True)
-        else:
-            make("test")
+   def test(self):
+       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
 custom build systems, it can be added to existing build systems as well.
 
-.. warning::
-
-   The order of decorators matters. The following ordering:
-
-   .. code-block:: python
-
-      @run_after("install")
-      @on_package_attributes(run_tests=True)
-
-   works as expected. However, if you reverse the ordering:
-
-   .. code-block:: python
-
-      @on_package_attributes(run_tests=True)
-      @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
-   for more information
-
 Ideally, every package in Spack will have some sort of test to ensure
 that it was built correctly. It is up to the package authors to make
 sure this happens. If you are adding a package for some software and
 the developers list commands to test the installation, please add these
 tests to your ``package.py``.
 
-For more information on other forms of package testing, refer to
-:ref:`Checking an installation <checking_an_installation>`.
+.. warning::
+
+   The order of decorators matters. The following ordering:
+
+   .. code-block:: python
+
+      @run_after('install')
+      @on_package_attributes(run_tests=True)
+
+   works as expected. However, if you reverse the ordering:
+
+   .. code-block:: python
+
+      @on_package_attributes(run_tests=True)
+      @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
+   for more information

lib/spack/docs/build_systems/inteloneapipackage.rst

@@ -1,214 +0,0 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _inteloneapipackage:
-
-
-===========
-IntelOneapi
-===========
-
-
-.. contents::
-
-
-oneAPI packages in Spack
-========================
-
-Spack can install and use the Intel oneAPI products. You may either
-use spack to install the oneAPI tools or use the `Intel
-installers`_. After installation, you may use the tools directly, or
-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 <https://packages.spack.io>`_ 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>
-
-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.
-
-Examples
-========
-
-Building a Package With icx
----------------------------
-
-In this example, we build patchelf with ``icc`` and ``icx``. The
-compilers are installed with spack.
-
-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
-
-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``.
-* ``oneapi``: ``icx``, ``icpx``, ``ifx``. Intel's new generation of
-  compilers based on LLVM.
-
-To build the ``patchelf`` Spack package with ``icc``, do::
-
-  spack install patchelf%intel
-
-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
-------------------------------------------------------
-
-The ``hdf5`` package works with any compatible MPI implementation. To
-build ``hdf5`` with Intel oneAPI MPI do::
-
-  spack install hdf5 +mpi ^intel-oneapi-mpi
-
-Using Externally Installed oneAPI Tools
-=======================================
-
-Spack can also use oneAPI tools that are manually installed with
-`Intel Installers`_.  The procedures for configuring Spack to use
-external compilers and libraries are different.
-
-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
-
-Adapt the paths above if you did not install the tools in the default
-location. After adding the compilers, using them is the same
-as if you had installed the ``intel-oneapi-compilers`` package.
-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
-the default location, then add the following to
-``~/.spack/packages.yaml``, adjusting the version as appropriate::
-
-  intel-oneapi-mkl:
-    externals:
-    - spec: intel-oneapi-mkl@2021.1.1
-      prefix: /opt/intel/oneapi/
-
-
-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
-want to build a Makefile project using Spack-installed oneAPI compilers,
-then use spack to configure your environment::
-
-  spack load intel-oneapi-compilers
-
-And then you can build with::
-
-  CXX=icpx make
-
-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.
-
-More information
-================
-
-This section describes basic use of oneAPI, especially if it has
-changed compared to Parallel Studio. See :ref:`intelpackage` for more
-information on :ref:`intel-virtual-packages`,
-:ref:`intel-unrelated-packages`,
-:ref:`intel-integrating-external-libraries`, and
-:ref:`using-mkl-tips`.
-
-
-.. _`Intel installers`: https://software.intel.com/content/www/us/en/develop/documentation/installation-guide-for-intel-oneapi-toolkits-linux/top.html

lib/spack/docs/build_systems/intelpackage.rst

@@ -1,12 +1,13 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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::
 
@@ -14,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
@@ -89,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
@@ -139,7 +137,6 @@ If you need to save disk space or installation time, you could install the
 ``intel`` compilers-only subset (0.6 GB) and just the library packages you
 need, for example ``intel-mpi`` (0.5 GB) and ``intel-mkl`` (2.5 GB).
 
-.. _intel-unrelated-packages:
 
 """"""""""""""""""""
 Unrelated packages
@@ -361,8 +358,6 @@ affected by an advanced third method:
 Next, visit section `Selecting Intel Compilers`_ to learn how to tell
 Spack to use the newly configured compilers.
 
-.. _intel-integrating-external-libraries:
-
 """"""""""""""""""""""""""""""""""
 Integrating external libraries
 """"""""""""""""""""""""""""""""""
@@ -391,12 +386,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
@@ -423,13 +418,9 @@ Adapt the following example. Be sure to maintain the indentation:
    # other content ...
 
      intel-mkl:
-       externals:
-       - spec: "intel-mkl@2018.2.199  arch=linux-centos6-x86_64"
-         modules:
-         -  intel-mkl/18/18.0.2
-       - spec: "intel-mkl@2018.3.222  arch=linux-centos6-x86_64"
-         modules:
-         -  intel-mkl/18/18.0.3
+       modules:
+         intel-mkl@2018.2.199  arch=linux-centos6-x86_64:  intel-mkl/18/18.0.2
+         intel-mkl@2018.3.222  arch=linux-centos6-x86_64:  intel-mkl/18/18.0.3
 
 The version numbers for the ``intel-mkl`` specs defined here correspond to file
 and directory names that Intel uses for its products because they were adopted
@@ -460,16 +451,12 @@ mechanism.
 
    packages:
      intel-parallel-studio:
-       externals:
-       - spec: "intel-parallel-studio@cluster.2018.2.199 +mkl+mpi+ipp+tbb+daal  arch=linux-centos6-x86_64"
-         modules:
-         -  intel/18/18.0.2
-       - spec: "intel-parallel-studio@cluster.2018.3.222 +mkl+mpi+ipp+tbb+daal  arch=linux-centos6-x86_64"
-         modules:
-         -  intel/18/18.0.3
+       modules:
+         intel-parallel-studio@cluster.2018.2.199 +mkl+mpi+ipp+tbb+daal  arch=linux-centos6-x86_64:  intel/18/18.0.2
+         intel-parallel-studio@cluster.2018.3.222 +mkl+mpi+ipp+tbb+daal  arch=linux-centos6-x86_64:  intel/18/18.0.3
        buildable: False
 
-One additional example illustrates the use of ``prefix:`` instead of
+One additional example illustrates the use of ``paths:`` instead of
 ``modules:``, useful when external modulefiles are not available or not
 suitable:
 
@@ -477,15 +464,13 @@ suitable:
 
    packages:
      intel-parallel-studio:
-       externals:
-       - spec: "intel-parallel-studio@cluster.2018.2.199 +mkl+mpi+ipp+tbb+daal"
-         prefix: /opt/intel
-       - spec: "intel-parallel-studio@cluster.2018.3.222 +mkl+mpi+ipp+tbb+daal"
-         prefix: /opt/intel
+       paths:
+         intel-parallel-studio@cluster.2018.2.199 +mkl+mpi+ipp+tbb+daal: /opt/intel
+         intel-parallel-studio@cluster.2018.3.222 +mkl+mpi+ipp+tbb+daal: /opt/intel
        buildable: False
 
 Note that for the Intel packages discussed here, the directory values in the
-``prefix:`` entries must be the high-level and typically version-less
+``paths:`` entries must be the high-level and typically version-less
 "installation directory" that has been used by Intel's product installer.
 Such a directory will typically accumulate various product versions.  Amongst
 them, Spack will select the correct version-specific product directory based on
@@ -563,29 +548,43 @@ follow `the next section <intel-install-libs_>`_ instead.
              modules:    []
              spec:       intel@18.0.3
              paths:
-               cc:       /usr/bin/true
-               cxx:      /usr/bin/true
-               f77:      /usr/bin/true
-               fc:       /usr/bin/true
+               cc:       stub
+               cxx:      stub
+               f77:      stub
+               fc:       stub
 
-      Replace ``18.0.3`` with the version that you determined in the preceding
-      step. The exact contents under ``paths:`` do not matter yet, but the paths must exist.
+      Replace ``18.0.3`` with the version that you determined in the preceeding
+      step. The contents under ``paths:`` do not matter yet.
 
-   This temporary stub is required such that the ``intel-parallel-studio`` package
-   can be installed for the ``intel`` compiler (which the package itself is going
-   to provide after the installation) rather than an arbitrary system compiler.
-   The paths given in ``cc``, ``cxx``, ``f77``, ``fc`` must exist, but will
-   never be used to build anything during the installation of ``intel-parallel-studio``.
+   You are right to ask: "Why on earth is that necessary?" [fn8]_.
+   The answer lies in Spack striving for strict compiler consistency.
+   Consider what happens without such a pre-declared compiler stub:
+   Say, you ask Spack to install a particular version
+   ``intel-parallel-studio@edition.V``.  Spack will apply an unrelated compiler
+   spec to concretize and install your request, resulting in
+   ``intel-parallel-studio@edition.V %X``. That compiler ``%X`` is not going to
+   be the version that this new package itself provides. Rather, it would
+   typically be ``%gcc@...`` in a default Spack installation or possibly indeed
+   ``%intel@...``, but at a version that precedes ``V``.
 
-   The reason for this stub is that ``intel-parallel-studio`` also provides the
-   ``mpi`` and ``mkl`` packages and when concretizing a spec, Spack ensures
-   strong consistency of the used compiler across all dependencies:  [fn8]_.
-   Installing a package ``foo +mkl %intel`` will make Spack look for a package
-   ``mkl %intel``, which can be provided by ``intel-parallel-studio+mkl %intel``,
-   but not by ``intel-parallel-studio+mkl %gcc``.
+   The problem comes to the fore as soon as you try to use any virtual ``mkl``
+   or ``mpi`` packages that you would expect to now be provided by
+   ``intel-parallel-studio@edition.V``.  Spack will indeed see those virtual
+   packages, but only as being tied to the compiler that the package
+   ``intel-parallel-studio@edition.V`` was concretized with *at installation*.
+   If you were to install a client package with the new compilers now available
+   to you, you would naturally run ``spack install foo +mkl %intel@V``, yet
+   Spack will either complain about ``mkl%intel@V`` being missing (because it
+   only knows about ``mkl%X``) or it will go and attempt to install *another
+   instance* of ``intel-parallel-studio@edition.V %intel@V`` so as to match the
+   compiler spec ``%intel@V`` that you gave for your client package ``foo``.
+   This will be unexpected and will quickly get annoying because each
+   reinstallation takes up time and extra disk space.
 
-   Failure to do so may result in additional installations of ``mkl``, ``intel-mpi`` or
-   even ``intel-parallel-studio`` as dependencies for other packages.
+   To escape this trap, put the compiler stub declaration shown here in place,
+   then use that pre-declared compiler spec to install the actual package, as
+   shown next.  This approach works because during installation only the
+   package's own self-sufficient installer will be used, not any compiler.
 
    .. _`verify-compiler-anticipated`:
 
@@ -636,25 +635,11 @@ follow `the next section <intel-install-libs_>`_ instead.
      want to use the ``intel64`` variant.  The ``icpc`` and ``ifort`` compilers
      will be located in the same directory as ``icc``.
 
-   * Make sure to specify ``modules: ['intel-parallel-studio-cluster2018.3-intel-18.0.3-HASH']``
-     (with ``HASH`` being the short hash as displayed when running
-     ``spack find -l intel-parallel-studio@cluster.2018.3`` and the versions adapted accordingly)
-     to ensure that the correct and complete environment for the Intel compilers gets
-     loaded when running them. With modern versions of the Intel compiler you may otherwise see
-     issues about missing libraries. Please also note that module name must exactly match
-     the name as returned by ``module avail`` (and shown in the example above).
-
-   * Use the ``modules:`` and/or ``cflags:`` tokens to further specify a suitable accompanying
+   * Use the ``modules:`` and/or ``cflags:`` tokens to specify a suitable accompanying
      ``gcc`` version to help pacify picky client packages that ask for C++
      standards more recent than supported by your system-provided ``gcc`` and its
      ``libstdc++.so``.
 
-   * 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``
-     implementation to avoid pulling in a different variant.
-
    * To set the Intel compilers for default use in Spack, instead of the usual ``%gcc``,
      follow section `Selecting Intel compilers`_.
 
@@ -711,7 +696,7 @@ follow `the next section <intel-install-libs_>`_ instead.
              - /home/$user/spack-stage
 
         Do not duplicate the ``config:`` line if it already is present.
-        Adapt the location, which here is the same as in the preceding example.
+        Adapt the location, which here is the same as in the preceeding example.
 
    3. Retry installing the large package.
 
@@ -813,13 +798,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:
 
@@ -839,7 +824,6 @@ for example:
       compiler: [ intel@18, intel@17, gcc@4.4.7, gcc@4.9.3, gcc@7.3.0, ]
 
 
-.. _intel-virtual-packages:
 
 """"""""""""""""""""""""""""""""""""""""""""""""
 Selecting libraries to satisfy virtual packages
@@ -869,7 +853,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
@@ -913,7 +897,6 @@ With the proper installation as detailed above, no special steps should be
 required when a client package specifically (and thus deliberately) requests an
 Intel package as dependency, this being one of the target use cases for Spack.
 
-.. _using-mkl-tips:
 
 """""""""""""""""""""""""""""""""""""""""""""""
 Tips for configuring client packages to use MKL
@@ -933,9 +916,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
@@ -971,8 +954,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::
@@ -982,19 +965,19 @@ a *virtual* ``mkl`` package is declared in Spack.
 
   Likewise, in a
   :ref:`MakefilePackage <makefilepackage>`
-  or similar package that does not use AutoTools you may need to provide include
+  or similiar package that does not use AutoTools you may need to provide include
   and link options for use on command lines or in environment variables.
   For example, to generate an option string of the form ``-I<dir>``, use:
 
   .. 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>`
@@ -1072,6 +1055,6 @@ Footnotes
    2. Set the hash length in ``install-path-scheme``, also in ``config.yaml``
       (:ref:`q.v. <config-yaml>`).
    3. You will want to set the *same* hash length for
-      :ref:`module files <modules-projections>`
-      if you have Spack produce them for you, under ``projections`` in
-      ``modules.yaml``.
+      :ref:`tcl module files <modules-naming-scheme>`
+      if you have Spack produce them for you, under ``naming_scheme`` in
+      ``modules.yaml``.  Other module dialects cannot be altered in this manner.

lib/spack/docs/build_systems/luapackage.rst

@@ -1,104 +0,0 @@
-.. Copyright Spack Project Developers. See 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,12 +1,13 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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
@@ -17,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
@@ -58,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')
 
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -87,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>`_
@@ -112,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:
@@ -124,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),
        ]
 
 
@@ -139,17 +140,15 @@ 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('CC = gcc',  'CC = cc')
+       makefile.filter('CXX = g++', 'CC = c++')
 
 
 `stream <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/stream/package.py>`_
@@ -180,16 +179,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>`_
@@ -203,14 +202,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>`_
@@ -283,7 +282,7 @@ can tell Spack where to locate it like so:
 
 .. code-block:: python
 
-   build_directory = "src"
+   build_directory = 'src'
 
 
 ^^^^^^^^^^^^^^^^^^^
@@ -298,8 +297,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,101 +0,0 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _mavenpackage:
-
------
-Maven
------
-
-Apache Maven is a general-purpose build system that does not rely
-on Makefiles to build software. It is designed for building and
-managing and Java-based project.
-
-^^^^^^
-Phases
-^^^^^^
-
-The ``MavenBuilder`` and ``MavenPackage`` base classes come with the following phases:
-
-#. ``build`` - compile code and package into a JAR file
-#. ``install`` - copy to installation prefix
-
-By default, these phases run:
-
-.. code-block:: console
-
-   $ mvn package
-   $ install . <prefix>
-
-
-^^^^^^^^^^^^^^^
-Important files
-^^^^^^^^^^^^^^^
-
-Maven packages can be identified by the presence of a ``pom.xml`` file.
-This file lists dependencies and other metadata about the project.
-There may also be configuration files in the ``.mvn`` directory.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^
-Build system dependencies
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Maven requires the ``mvn`` executable to build the project. It also
-requires Java at both build- and run-time. Because of this, the base
-class automatically adds the following dependencies:
-
-.. code-block:: python
-
-   depends_on("java", type=("build", "run"))
-   depends_on("maven", type="build")
-
-
-In the ``pom.xml`` file, you may see sections like:
-
-.. code-block:: xml
-
-   <requireJavaVersion>
-      <version>[1.7,)</version>
-   </requireJavaVersion>
-   <requireMavenVersion>
-      <version>[3.5.4,)</version>
-   </requireMavenVersion>
-
-
-This specifies the versions of Java and Maven that are required to
-build the package. See
-https://docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm#MAVEN402
-for a description of this version range syntax. In this case, you
-should add:
-
-.. code-block:: python
-
-   depends_on("java@7:", type="build")
-   depends_on("maven@3.5.4:", type="build")
-
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Passing arguments to the build phase
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The default build and install phases should be sufficient to install
-most packages. However, you may want to pass additional flags to
-the build phase. For example:
-
-.. code-block:: python
-
-   def build_args(self):
-       return [
-           "-Pdist,native",
-           "-Dtar",
-           "-Dmaven.javadoc.skip=true"
-       ]
-
-
-^^^^^^^^^^^^^^^^^^^^^^
-External documentation
-^^^^^^^^^^^^^^^^^^^^^^
-
-For more information on the Maven build system, see:
-https://maven.apache.org/index.html

lib/spack/docs/build_systems/mesonpackage.rst

@@ -1,12 +1,13 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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
@@ -16,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
@@ -85,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
@@ -94,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')
 
 
 ^^^^^^^^^^^^^^^^^^^
@@ -120,15 +121,11 @@ override the ``meson_args`` method like so:
 .. code-block:: python
 
    def meson_args(self):
-       return ["--warnlevel=3"]
+       return ['--default-library=both']
 
 
 This method can be used to pass flags as well as variables.
 
-Note that the ``MesonPackage`` base class already defines variants for
-``buildtype``, ``default_library`` and ``strip``, which are mapped to default
-Meson arguments, meaning that you don't have to specify these.
-
 ^^^^^^^^^^^^^^^^^^^^^^
 External documentation
 ^^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/octavepackage.rst

@@ -1,12 +1,13 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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.
 
@@ -14,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,12 +1,13 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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.
@@ -15,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
@@ -117,7 +118,9 @@ so ``PerlPackage`` contains:
 
 .. code-block:: python
 
-   extends("perl")
+   extends('perl')
+
+   depends_on('perl', type=('build', 'run'))
 
 
 If your package requires a specific version of Perl, you should
@@ -131,14 +134,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')
 
 
 ^^^^^^^^^^^^^^^^^
@@ -164,80 +167,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,12 +1,13 @@
-.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+.. Copyright 2013-2020 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
@@ -24,19 +25,11 @@ QMake does not appear to have a standardized way of specifying
 the installation directory, so you may have to set environment
 variables or edit ``*.pro`` files to get things working properly.
 
-QMake packages will depend on the virtual ``qmake`` package which
-is provided by multiple versions of Qt: ``qt`` provides Qt up to
-Qt5, and ``qt-base`` provides Qt from version Qt6 onwards. This
-split was motivated by the desire to split the single Qt package
-into its components to allow for more fine-grained installation.
-To depend on a specific version, refer to the documentation on
-:ref:`virtual-dependencies`.
-
 ^^^^^^
 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
@@ -90,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
@@ -98,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
@@ -110,24 +103,11 @@ 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.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-``*.pro`` file in a sub-directory
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-If the ``*.pro`` file used to tell QMake how to build the package is
-found in a sub-directory, you can tell Spack to run all phases in this
-sub-directory by adding the following to the package:
-
-.. code-block:: python
-
-   build_directory = "src"
-
-
 ^^^^^^^^^^^^^^^^^^^^^^
 External documentation
 ^^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/racketpackage.rst

@@ -1,45 +0,0 @@
-.. Copyright Spack Project Developers. See 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.