pax_global_header00006660000000000000000000000064151726572000014517gustar00rootroot0000000000000052 comment=d7f73ceb0e7c3cc5ed1aa106bf1cac61eaf3917c Homebrew-brew-d7f73ce/000077500000000000000000000000001517265720000147305ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.claude/000077500000000000000000000000001517265720000162435ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.claude/settings.json000066400000000000000000000010361517265720000207760ustar00rootroot00000000000000{ "hooks": { "PostToolUse": [ { "matcher": "Edit|Write", "hooks": [ { "type": "command", "command": "./bin/brew style --changed --fix" }, { "type": "command", "command": "./bin/brew typecheck" } ] } ], "Stop": [ { "hooks": [ { "type": "command", "command": "./bin/brew tests --changed", "timeout": 360 } ] } ] } } Homebrew-brew-d7f73ce/.cursor/000077500000000000000000000000001517265720000163235ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.cursor/hooks.json000066400000000000000000000004301517265720000203360ustar00rootroot00000000000000{ "version": 1, "hooks": { "afterFileEdit": [ { "command": "./bin/brew style --changed --fix" }, { "command": "./bin/brew typecheck" } ], "stop": [ { "command": "./bin/brew tests --changed" } ] } } Homebrew-brew-d7f73ce/.devcontainer/000077500000000000000000000000001517265720000174675ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.devcontainer/devcontainer.json000066400000000000000000000021241517265720000230420ustar00rootroot00000000000000// For format details, see https://aka.ms/devcontainer.json. { "name": "Homebrew/brew", "image": "ghcr.io/homebrew/brew:main", "workspaceFolder": "/home/linuxbrew/.linuxbrew/Homebrew", "workspaceMount": "source=${localWorkspaceFolder},target=/home/linuxbrew/.linuxbrew/Homebrew,type=bind,consistency=cached", "onCreateCommand": ".devcontainer/on-create-command.sh", "customizations": { "vscode": { // Installing all necessary extensions for vscode // Taken from: .vscode/extensions.json "extensions": [ "Shopify.ruby-lsp", "sorbet.sorbet-vscode-extension", "github.vscode-github-actions", "anykeyh.simplecov-vscode", "ms-azuretools.vscode-docker", "github.vscode-pull-request-github", "davidanson.vscode-markdownlint", "foxundermoon.shell-format", "timonwong.shellcheck", "ban.spellright", "redhat.vscode-yaml", "koichisasada.vscode-rdbg", "editorconfig.editorconfig" ] } }, "remoteEnv": { "HOMEBREW_GITHUB_API_TOKEN": "${localEnv:GITHUB_TOKEN}" } } Homebrew-brew-d7f73ce/.devcontainer/on-create-command.sh000077500000000000000000000020541517265720000233200ustar00rootroot00000000000000#!/bin/bash set -e # fix permissions so Homebrew and Bundler don't complain sudo chmod -R g-w,o-w /home/linuxbrew sudo chmod +t -R /home/linuxbrew/ # everything below is too slow to do unless prebuilding so skip it CODESPACES_ACTION_NAME="$(jq --raw-output '.ACTION_NAME' /workspaces/.codespaces/shared/environment-variables.json)" if [[ "${CODESPACES_ACTION_NAME}" != "createPrebuildTemplate" ]] then echo "Skipping slow items, not prebuilding." exit 0 fi # install Homebrew's development gems brew install-bundler-gems --groups=all # install Homebrew formulae we might need brew install shellcheck shfmt gh gnu-tar # cleanup any mess brew cleanup # actually tap homebrew/core, no longer done by default brew tap --force homebrew/core # install some useful development things sudo apt-get update apt_get_install() { sudo apt-get install -y \ -o Dpkg::Options::=--force-confdef \ -o Dpkg::Options::=--force-confnew \ "$@" } apt_get_install \ openssh-server \ zsh # Start the SSH server so that `gh cs ssh` works. sudo service ssh start Homebrew-brew-d7f73ce/.dockerignore000066400000000000000000000000631517265720000174030ustar00rootroot00000000000000Library/Homebrew/vendor/portable-ruby Library/Taps Homebrew-brew-d7f73ce/.editorconfig000066400000000000000000000005741517265720000174130ustar00rootroot00000000000000# https://editorconfig.org/ root = true [*] charset = utf-8 end_of_line = lf indent_style = space indent_size = 2 insert_final_newline = true [{Library/Homebrew/**.rb,.simplecov}] trim_trailing_whitespace = true [Library/Taps/**.rb] # trailing whitespace is crucial for patches trim_trailing_whitespace = false [**.md] trim_trailing_whitespace = true x-soft-wrap-text = true Homebrew-brew-d7f73ce/.github/000077500000000000000000000000001517265720000162705ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.github/ISSUE_TEMPLATE.md000066400000000000000000000002101517265720000207660ustar00rootroot00000000000000Please fill out one of the templates on https://github.com/Homebrew/brew/issues/new/choose or we will close your issue without comment. Homebrew-brew-d7f73ce/.github/ISSUE_TEMPLATE/000077500000000000000000000000001517265720000204535ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.github/ISSUE_TEMPLATE/bug.yml000066400000000000000000000040371517265720000217570ustar00rootroot00000000000000name: New issue for Reproducible Bug description: "If you're sure it's reproducible and not just your machine: submit an issue so we can investigate." type: "Bug" body: - type: markdown attributes: value: Please note we may close your issue without comment if you do not fill out the issue checklist below and provide ALL the requested information (even if you consider them irrelevant). If you are unwilling to use the issue template, we may block you from ever submitting future issues to Homebrew. - type: textarea attributes: render: shell label: "`brew doctor` output" validations: required: true - type: checkboxes attributes: label: Verification description: Please verify that you've followed these steps. If you cannot truthfully check these boxes, open a discussion at https://github.com/orgs/Homebrew/discussions instead. options: - label: I ran `brew update` twice and am still able to reproduce my issue. required: true - label: My "`brew doctor` output" above says `Your system is ready to brew` or a definitely unrelated `Tier` message. required: true - label: This issue's title and/or description do not reference a single formula e.g. `brew install wget`. If they do, open an issue at https://github.com/Homebrew/homebrew-core/issues/new/choose instead. required: true - type: textarea attributes: render: shell label: "`brew config` output" validations: required: true - type: textarea attributes: label: What were you trying to do (and why)? validations: required: true - type: textarea attributes: label: What happened (include all command output)? validations: required: true - type: textarea attributes: label: What did you expect to happen? validations: required: true - type: textarea attributes: render: shell label: Step-by-step reproduction instructions (by running `brew` commands) validations: required: true Homebrew-brew-d7f73ce/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000023611517265720000224450ustar00rootroot00000000000000blank_issues_enabled: false contact_links: - name: Get help in GitHub Discussions url: https://github.com/orgs/Homebrew/discussions about: Have a question? Not sure if your issue affects everyone reproducibly? The quickest way to get help is on Homebrew's GitHub Discussions! - name: New issue on Homebrew/homebrew-core url: https://github.com/Homebrew/homebrew-core/issues/new/choose about: Having a `brew` problem with a `brew install` or `brew upgrade` of a single formula/package? Report it to Homebrew/homebrew-core (the core tap/repository). - name: New issue on Homebrew/homebrew-cask url: https://github.com/Homebrew/homebrew-cask/issues/new/choose about: Having a `brew --cask` problem? Report it to Homebrew/homebrew-cask (the cask tap/repository). - name: New issue on Homebrew/install url: https://github.com/Homebrew/install/issues/new/choose about: Having a problem installing Homebrew? Report it to Homebrew/install (the installer repository). - name: Get help from Homebrew mirror maintainers url: https://github.com/orgs/Homebrew/discussions/1917 about: Slow download speed? Homebrew mirror not working as expected? Please take a look at the mirror list and contact respective mirror maintainers. Homebrew-brew-d7f73ce/.github/ISSUE_TEMPLATE/feature.yml000066400000000000000000000030541517265720000226330ustar00rootroot00000000000000name: New issue for Feature Suggestion description: Request our thoughts on your suggestion for a new feature for Homebrew. type: "Feature" body: - type: markdown attributes: value: Please note we will close your issue without comment if you do not fill out the issue checklist below and provide ALL the requested information. If you repeatedly fail to use the issue template, we will block you from ever submitting issues to Homebrew again. - type: checkboxes attributes: label: Verification description: Please verify that you've followed these steps. options: - label: This issue's title and/or description do not reference a single formula e.g. `brew install wget`. If they do, open an issue at https://github.com/Homebrew/homebrew-core/issues/new/choose instead. required: true - type: textarea attributes: label: Provide a detailed description of the proposed feature validations: required: true - type: textarea attributes: label: What is the motivation for the feature? validations: required: true - type: textarea attributes: label: How will the feature be relevant to at least 90% of Homebrew users? validations: required: true - type: textarea attributes: label: What alternatives to the feature have been considered? validations: required: true - type: markdown attributes: value: We will close this issue or ask you to create a pull-request if it's something the maintainers are not actively planning to work on. Homebrew-brew-d7f73ce/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000024041517265720000220710ustar00rootroot00000000000000----- - [ ] Have you followed the guidelines in our [Contributing](https://github.com/Homebrew/brew/blob/HEAD/CONTRIBUTING.md) document? - [ ] Have you checked to ensure there aren't other open [Pull Requests](https://github.com/Homebrew/brew/pulls) for the same change? - [ ] Have you added an explanation of what your changes do and why you'd like us to include them? Performance claims (e.g. "this is faster") must include [Hyperfine](https://github.com/sharkdp/hyperfine) benchmarks. - [ ] Have you written new tests (excluding integration tests) for your changes? [Here's an example](https://github.com/Homebrew/brew/blob/HEAD/Library/Homebrew/test/PATH_spec.rb). - [ ] Have you successfully run `brew lgtm` (style, typechecking and tests) with your changes locally? ----- - [ ] AI was used to generate or assist with generating this PR. *Please specify below how you used AI to help you, and what steps you have taken to manually verify the changes*. Non-maintainers may only have one AI-assisted/generated PR open at a time. ----- Homebrew-brew-d7f73ce/.github/actionlint-matcher.json000066400000000000000000000006631517265720000227550ustar00rootroot00000000000000{ "problemMatcher": [ { "owner": "actionlint", "pattern": [ { "regexp": "^(?:\\x1b\\[\\d+m)?(.+?)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*: (?:\\x1b\\[\\d+m)*(.+?)(?:\\x1b\\[\\d+m)* \\[(.+?)\\]$", "file": 1, "line": 2, "column": 3, "message": 4, "code": 5 } ] } ] } Homebrew-brew-d7f73ce/.github/actionlint.yaml000066400000000000000000000005461517265720000213250ustar00rootroot00000000000000self-hosted-runner: # Labels of self-hosted or not-yet-known-upstream runner in array of strings. labels: [] # Configuration variables in array of strings defined in your repository or # organization. `null` means disabling configuration variables check. # Empty array means no configuration variable is allowed. config-variables: - BREW_COMMIT_APP_ID Homebrew-brew-d7f73ce/.github/codecov.yml000066400000000000000000000002541517265720000204360ustar00rootroot00000000000000coverage: round: nearest status: project: default: informational: true threshold: 0.05% patch: default: informational: true Homebrew-brew-d7f73ce/.github/codeql/000077500000000000000000000000001517265720000175375ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.github/codeql/extensions/000077500000000000000000000000001517265720000217365ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.github/codeql/extensions/homebrew-actions.yml000066400000000000000000000003251517265720000257270ustar00rootroot00000000000000# This file is synced from the `.github` repository, do not modify it directly. extensions: - addsTo: pack: codeql/actions-all extensible: trustedActionsOwnerDataModel data: - ["Homebrew"] Homebrew-brew-d7f73ce/.github/dependabot.yml000066400000000000000000000026661517265720000211320ustar00rootroot00000000000000# This file is synced from the `.github` repository, do not modify it directly. --- version: 2 updates: - package-ecosystem: bundler directories: - "/docs" - "/Library/Homebrew" schedule: interval: weekly day: friday time: '08:00' timezone: Etc/UTC groups: bundler: patterns: - "*" allow: - dependency-type: all cooldown: default-days: 7 - package-ecosystem: devcontainers directory: "/" schedule: interval: weekly day: friday time: '08:00' timezone: Etc/UTC groups: devcontainers: patterns: - "*" allow: - dependency-type: all cooldown: default-days: 7 - package-ecosystem: docker directory: "/" schedule: interval: weekly day: friday time: '08:00' timezone: Etc/UTC groups: docker: patterns: - "*" allow: - dependency-type: all cooldown: default-days: 7 - package-ecosystem: github-actions directories: - "/" schedule: interval: weekly day: friday time: '08:00' timezone: Etc/UTC groups: github-actions: patterns: - "*" allow: - dependency-type: all cooldown: default-days: 7 - package-ecosystem: pip directories: - "/Library/Homebrew/formula-analytics/" schedule: interval: weekly day: friday time: '08:00' timezone: Etc/UTC groups: pip: patterns: - "*" allow: - dependency-type: all cooldown: default-days: 7 Homebrew-brew-d7f73ce/.github/release.yml000066400000000000000000000001121517265720000204250ustar00rootroot00000000000000changelog: exclude: authors: - dependabot - BrewTestBot Homebrew-brew-d7f73ce/.github/workflows/000077500000000000000000000000001517265720000203255ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.github/workflows/actionlint.yml000066400000000000000000000065631517265720000232260ustar00rootroot00000000000000# This file is synced from the `.github` repository, do not modify it directly. name: Actionlint on: push: branches: - main - master pull_request: defaults: run: shell: bash -xeuo pipefail {0} concurrency: group: "actionlint-${{ github.ref }}" cancel-in-progress: ${{ github.event_name == 'pull_request' }} env: HOMEBREW_DEVELOPER: 1 HOMEBREW_NO_AUTO_UPDATE: 1 HOMEBREW_NO_ENV_HINTS: 1 permissions: {} jobs: workflow_syntax: if: github.repository_owner == 'Homebrew' runs-on: ubuntu-latest permissions: contents: read container: image: ghcr.io/homebrew/brew:main steps: - name: Set up Homebrew id: setup-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - uses: Homebrew/actions/cache-homebrew-prefix@main # Don't cache the prefix for the formulae.brew.sh repository as it won't download its own JSON API files if: github.repository != 'Homebrew/formulae.brew.sh' with: install: actionlint shellcheck zizmor # Not needed in .github but required for other repositories with multiple uses of cache-homebrew-prefix. workflow-key: actionlint - name: Install tools if: github.repository == 'Homebrew/formulae.brew.sh' run: brew install actionlint shellcheck zizmor - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - run: zizmor --format sarif . > results.sarif env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: Upload SARIF file uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 # We can't use the SARIF file when triggered by `merge_group` so we don't upload it. if: always() && github.event_name != 'merge_group' with: name: results.sarif path: results.sarif - name: Set up actionlint run: | # In homebrew-core, setting `shell: /bin/bash` prevents shellcheck from running on # those steps, so let's change them to `shell: bash` temporarily for better linting. sed -i 's|shell: /bin/bash -x|shell: bash -x|' .github/workflows/*.y*ml # In homebrew-core, the JSON matcher needs to be accessible to the container host. cp "$(brew --repository)/.github/actionlint-matcher.json" "$HOME" echo "::add-matcher::$HOME/actionlint-matcher.json" - run: actionlint upload_sarif: needs: workflow_syntax # We want to always upload this even if `actionlint` failed. # This is only available on public repositories. if: > always() && !contains(fromJSON('["cancelled", "skipped"]'), needs.workflow_syntax.result) && !github.event.repository.private && github.event_name != 'merge_group' runs-on: ubuntu-slim permissions: contents: read security-events: write steps: - name: Download SARIF file uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: results.sarif path: results.sarif - name: Upload SARIF file uses: github/codeql-action/upload-sarif@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2 with: sarif_file: results.sarif category: zizmor Homebrew-brew-d7f73ce/.github/workflows/autogenerated-files.yml000066400000000000000000000025261517265720000250040ustar00rootroot00000000000000name: Autogenerated files check on: pull_request: paths: - .github/workflows/autogenerated-files.yml - README.md - completions/** - docs/Manpage.md - manpages/brew.1 permissions: contents: read env: HOMEBREW_DEVELOPER: 1 HOMEBREW_NO_AUTO_UPDATE: 1 defaults: run: shell: bash -xeuo pipefail {0} jobs: autogenerated: runs-on: ubuntu-latest if: github.repository == 'Homebrew/brew' steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Cache Bundler RubyGems uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ${{ steps.set-up-homebrew.outputs.gems-path }} key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }} restore-keys: ${{ runner.os }}-rubygems- - name: Check for changes to autogenerated files id: check run: | if brew generate-man-completions then echo "This PR modifies autogenerated files!" >&2 echo "Please ensure their source files are updated and then run the following: brew generate-man-completions" >&2 exit 1 else exit 0 fi Homebrew-brew-d7f73ce/.github/workflows/codeql-analysis.yml000066400000000000000000000015201517265720000241360ustar00rootroot00000000000000name: "CodeQL" on: push: branches: - main - master pull_request: defaults: run: shell: bash -xeuo pipefail {0} jobs: analyze: name: Analyze runs-on: ubuntu-slim permissions: actions: read contents: read security-events: write steps: - name: Checkout repository uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Initialize CodeQL uses: github/codeql-action/init@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2 with: languages: ruby config: | paths-ignore: - Library/Homebrew/vendor - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2 Homebrew-brew-d7f73ce/.github/workflows/command-not-found-db-update.yml000066400000000000000000000062131517265720000262420ustar00rootroot00000000000000name: Command-not-found scheduled database updates on: pull_request: paths: - .github/workflows/command-not-found-db-update.yml - Library/Homebrew/dev-cmd/which-update.rb - Library/Homebrew/executables_db.rb schedule: - cron: "0 0 * * *" workflow_dispatch: inputs: max-downloads: description: Maximum number of formulae to download when updating required: false jobs: update-database: if: startsWith( github.repository, 'Homebrew/' ) runs-on: macos-latest permissions: packages: write steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main - name: Install oras for interacting with GitHub Packages uses: Homebrew/actions/cache-homebrew-prefix@main with: install: oras workflow-key: command-not-found-db-update uninstall: true - name: Pull executables.txt from GitHub Packages run: oras pull ghcr.io/homebrew/command-not-found/executables:latest - name: Update database env: MAX_DOWNLOADS: ${{ github.event.inputs.max-downloads }} run: | set -eo pipefail if [[ -n "$MAX_DOWNLOADS" ]] then MAX_DOWNLOADS_ARGS="--max-downloads $MAX_DOWNLOADS" fi # Need to intentionally leave MAX_DOWNLOADS_ARGS unquoted. # shellcheck disable=SC2086 brew which-update --update-existing --install-missing $MAX_DOWNLOADS_ARGS executables.txt --summary-file=$GITHUB_STEP_SUMMARY - name: Output database stats run: brew which-update --stats executables.txt - name: Log in to GitHub Packages if: github.ref == 'refs/heads/main' run: echo "${{ secrets.GITHUB_TOKEN }}" | oras login ghcr.io --username brewtestbot --password-stdin - name: Push to GitHub Packages if: github.ref == 'refs/heads/main' run: | oras push --artifact-type application/vnd.homebrew.command-not-found.executables \ ghcr.io/homebrew/command-not-found/executables:latest \ executables.txt:text/plain - name: Check upload if: github.ref == 'refs/heads/main' run: | shasum --algorithm=256 executables.txt > executables.txt.sha256 rm -f executables.txt oras pull ghcr.io/homebrew/command-not-found/executables:latest shasum --algorithm=256 --check executables.txt.sha256 - name: Upload database artifact uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: executables-database path: executables.txt delete-old-versions: needs: update-database runs-on: ubuntu-slim if: github.ref == 'refs/heads/main' permissions: packages: write steps: - name: Delete old versions from GitHub Packages uses: actions/delete-package-versions@e5bc658cc4c965c472efe991f8beea3981499c55 # v5.0.0 with: package-name: command-not-found/executables package-type: container min-versions-to-keep: 0 delete-only-untagged-versions: true Homebrew-brew-d7f73ce/.github/workflows/copilot-setup-steps.yml000066400000000000000000000016071517265720000250170ustar00rootroot00000000000000name: Copilot Setup Steps on: workflow_dispatch: pull_request: paths: - .github/workflows/copilot-setup-steps.yml jobs: # The job MUST be called `copilot-setup-steps` or it will not be picked up by Copilot. copilot-setup-steps: runs-on: ubuntu-latest permissions: contents: read steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: true cask: true - run: brew install-bundler-gems --groups=all # install Homebrew formulae we might need - uses: Homebrew/actions/cache-homebrew-prefix@main with: install: shellcheck shfmt gh gnu-tar subversion curl workflow-key: copilot-setup-steps # brew tests doesn't like world writable directories - run: sudo chmod -R g-w,o-w /home/linuxbrew/.linuxbrew/Homebrew Homebrew-brew-d7f73ce/.github/workflows/docker.yml000066400000000000000000000236271517265720000223310ustar00rootroot00000000000000name: Docker on: pull_request: push: branches: - main merge_group: release: types: - published permissions: contents: read defaults: run: shell: bash -xeuo pipefail {0} env: VERSIONS: '["22.04", "24.04"]' jobs: generate-tags: if: github.repository_owner == 'Homebrew' runs-on: ubuntu-latest outputs: matrix: ${{ steps.attributes.outputs.matrix }} tags: ${{ steps.attributes.outputs.tags }} labels: ${{ steps.attributes.outputs.labels }} push: ${{ steps.attributes.outputs.push }} merge: ${{ steps.attributes.outputs.merge }} steps: - name: Checkout uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: fetch-depth: 0 persist-credentials: false - name: Fetch origin/HEAD from Git run: git fetch origin HEAD - name: Determine build attributes id: attributes run: | date="$(date --rfc-3339=seconds --utc)" brew_version="$(git describe --tags --dirty --abbrev=7)" DELIMITER="END_LABELS_$(uuidgen)" cat <>"${GITHUB_OUTPUT}" echo "merge=${merge}" >>"${GITHUB_OUTPUT}" { DELIMITER="END_TAGS_$(uuidgen)" has_previous= echo "tags<<${DELIMITER}" printf '{' for version in "${!tag_hash[@]}"; do [[ -n "${has_previous:-}" ]] && printf ',' printf '"%s": %s' "${version}" "${tag_hash[$version]}" has_previous=1 done echo '}' echo "${DELIMITER}" } | tee -a "${GITHUB_OUTPUT}" { DELIMITER="END_PUSH_$(uuidgen)" has_previous= echo "push<<${DELIMITER}" printf '{' for version in "${!push_hash[@]}"; do [[ -n "${has_previous:-}" ]] && printf ',' printf '"%s": %s' "${version}" "${push_hash[$version]}" has_previous=1 done echo '}' echo "${DELIMITER}" } | tee -a "${GITHUB_OUTPUT}" build: needs: generate-tags if: github.repository_owner == 'Homebrew' name: docker (${{ matrix.arch }} Ubuntu ${{ matrix.version }}) runs-on: ${{ matrix.arch == 'arm64' && 'ubuntu-24.04-arm' || 'ubuntu-latest' }} strategy: fail-fast: false matrix: version: ["22.04", "24.04"] arch: ["x86_64", "arm64"] steps: - name: Checkout uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: fetch-depth: 0 persist-credentials: false - name: Fetch origin/HEAD from Git run: git fetch origin HEAD - name: Set up Docker Buildx uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0 with: cache-binary: false - name: Retrieve build attributes id: attributes env: VERSION: ${{ matrix.version }} PUSH: ${{ needs.generate-tags.outputs.push }} run: | filter="$(printf '.["%s"]' "${VERSION}")" echo "push=$(jq --raw-output "${filter}" <<<"${PUSH}")" >>"${GITHUB_OUTPUT}" - name: Log in to GitHub Packages (github-actions[bot]) uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0 with: registry: ghcr.io username: github-actions[bot] password: ${{ secrets.GITHUB_TOKEN }} - name: Build Docker image uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0 with: context: . load: true tags: brew cache-from: type=registry,ref=ghcr.io/homebrew/ubuntu${{ matrix.version }}:cache build-args: version=${{ matrix.version }} labels: ${{ needs.generate-tags.outputs.labels }} - name: Run brew test-bot --only-setup run: docker run --rm brew brew test-bot --only-setup - name: Log in to GitHub Packages (BrewTestBot) if: fromJSON(steps.attributes.outputs.push) uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0 with: registry: ghcr.io username: BrewTestBot password: ${{ secrets.HOMEBREW_BREW_GITHUB_PACKAGES_TOKEN }} - name: Deploy the Docker image by digest id: digest if: fromJSON(steps.attributes.outputs.push) uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0 with: context: . cache-from: type=registry,ref=ghcr.io/homebrew/ubuntu${{ matrix.version }}:cache cache-to: type=registry,ref=ghcr.io/homebrew/ubuntu${{ matrix.version }}:cache,mode=max build-args: version=${{ matrix.version }} labels: ${{ needs.generate-tags.outputs.labels }} outputs: type=image,name=ghcr.io/homebrew/ubuntu${{ matrix.version }},name-canonical=true,push=true,push-by-digest=true - name: Export the Docker image digest if: fromJSON(steps.attributes.outputs.push) run: | mkdir -p "${RUNNER_TEMP}"/digests echo "${DIGEST#sha256:}" >"${RUNNER_TEMP}/digests/${VERSION}-${ARCH}" env: DIGEST: ${{ steps.digest.outputs.digest }} VERSION: ${{ matrix.version }} ARCH: ${{ matrix.arch }} - name: Upload the Docker image digest if: fromJSON(steps.attributes.outputs.push) uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: digest-${{ matrix.version }}-${{ matrix.arch }} path: ${{ runner.temp }}/digests/* merge: needs: [generate-tags, build] if: github.repository_owner == 'Homebrew' && fromJSON(needs.generate-tags.outputs.merge) runs-on: ubuntu-latest strategy: fail-fast: false matrix: version: ${{ fromJSON(needs.generate-tags.outputs.matrix) }} steps: - name: Set up Docker Buildx uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0 with: cache-binary: false - name: Download Docker image digests uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: path: ${{ runner.temp }}/digests pattern: digest-${{ matrix.version }}-* merge-multiple: true - name: Log in to GitHub Packages (BrewTestBot) uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0 with: registry: ghcr.io username: BrewTestBot password: ${{ secrets.HOMEBREW_BREW_GITHUB_PACKAGES_TOKEN }} - name: Merge and push Docker image env: TAGS: ${{ needs.generate-tags.outputs.tags }} VERSION: ${{ matrix.version }} run: | filter="$(printf '.["%s"].[]' "${VERSION}")" tag_args=() while IFS=$'\n' read -r tag; do [[ -n "${tag}" ]] || continue tag_args+=("--tag=${tag}") done <<<"$(jq --raw-output "${filter}" <<<"${TAGS}")" image_args=("ghcr.io/homebrew/ubuntu${VERSION}@sha256:$(<"${RUNNER_TEMP}/digests/${VERSION}-x86_64")") image_args+=("ghcr.io/homebrew/ubuntu${VERSION}@sha256:$(<"${RUNNER_TEMP}/digests/${VERSION}-arm64")") attempts=0 until docker buildx imagetools create "${tag_args[@]}" "${image_args[@]}"; do attempts=$((attempts + 1)) if [[ $attempts -ge 3 ]]; then echo "[$(date -u)] ERROR: Failed after 3 attempts." >&2 exit 1 fi delay=$((2 ** attempts)) if [[ $delay -gt 15 ]]; then delay=15; fi echo "Push failed (attempt $attempts). Retrying in ${delay} seconds..." sleep ${delay} done Homebrew-brew-d7f73ce/.github/workflows/docs.yml000066400000000000000000000111511517265720000217770ustar00rootroot00000000000000name: Documentation on: push: branches: - main pull_request: merge_group: permissions: contents: read pages: read env: HOMEBREW_DEVELOPER: 1 HOMEBREW_NO_AUTO_UPDATE: 1 HOMEBREW_NO_ENV_HINTS: 1 HOMEBREW_NO_INSTALL_CLEANUP: 1 defaults: run: shell: bash -xeuo pipefail {0} jobs: docs: runs-on: ubuntu-latest steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Checkout repository uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Install Vale and Ruby # Don't cache the prefix for the formulae.brew.sh repository as it won't download its own JSON API files if: github.repository != 'Homebrew/formulae.brew.sh' uses: Homebrew/actions/cache-homebrew-prefix@main with: install: vale ruby workflow-key: docs - name: Install Vale and Ruby for formulae.brew.sh if: github.repository == 'Homebrew/formulae.brew.sh' run: brew install vale ruby - name: Cleanup Homebrew/brew docs if: github.repository == 'Homebrew/brew' run: | # No ignore support (https://github.com/errata-ai/vale/issues/131). rm -r Library/Homebrew/vendor # Generate latest manpage brew generate-man-completions --no-exit-code - name: Run Vale run: vale docs/ - name: Setup Ruby uses: Homebrew/actions/setup-ruby@main with: bundler-cache: true portable-ruby: true working-directory: docs - name: Check Markdown syntax working-directory: docs run: bundle exec rake lint - name: Check code blocks conform to our Ruby style guide run: brew style docs - name: Generate formulae.brew.sh API samples if: github.repository == 'Homebrew/formulae.brew.sh' working-directory: docs run: ../script/generate-api-samples.rb --template - name: Cache HTML Proofer uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: tmp/.htmlproofer key: ${{ runner.os }}-htmlproofer - name: Build the site working-directory: docs run: bundle exec rake build - name: Check for broken links if: github.event_name == 'pull_request' working-directory: docs run: bundle exec rake test || bundle exec rake test - name: Rebuild the site with YARD if: github.repository == 'Homebrew/brew' working-directory: docs run: bundle exec rake yard build - name: Upload pages artifact if: github.repository == 'Homebrew/brew' uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0 with: path: docs/_site/ deploy: needs: docs if: ${{ github.repository == 'Homebrew/brew' && github.ref_name == 'main' }} permissions: pages: write id-token: write environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} outputs: deploy_url: ${{ steps.deployment.outputs.page_url }} runs-on: ubuntu-slim timeout-minutes: 10 steps: - name: Deploy to GitHub Pages id: deployment uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0 deploy-issue: name: Open/close deploy issue needs: [docs, deploy] if: ${{ github.repository == 'Homebrew/brew' && always() && github.ref_name == 'main' }} env: RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} runs-on: ubuntu-slim timeout-minutes: 5 permissions: issues: write # for Homebrew/actions/create-or-update-issue steps: - name: Open, update, or close deploy issue uses: Homebrew/actions/create-or-update-issue@main with: token: ${{ github.token }} repository: ${{ github.repository }} title: docs.brew.sh deployment failed! body: The most recent [docs.brew.sh deployment failed](${{ env.RUN_URL }}). labels: deploy failure update-existing: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }} close-existing: ${{ needs.deploy.result == 'success' }} close-from-author: github-actions[bot] close-comment: The most recent [docs.brew.sh deployment succeeded](${{ env.RUN_URL }}). Closing issue. Homebrew-brew-d7f73ce/.github/workflows/doctor.yml000066400000000000000000000031541517265720000223450ustar00rootroot00000000000000name: brew doctor on: pull_request: paths: - .github/workflows/doctor.yml - Library/Homebrew/cmd/doctor.rb - Library/Homebrew/diagnostic.rb - Library/Homebrew/extend/os/diagnostic.rb - Library/Homebrew/extend/os/mac/diagnostic.rb - Library/Homebrew/os/mac/xcode.rb permissions: contents: read env: HOMEBREW_DEVELOPER: 1 HOMEBREW_NO_AUTO_UPDATE: 1 defaults: run: shell: bash -xeuo pipefail {0} jobs: determine-runners: runs-on: ubuntu-latest outputs: runners: ${{ steps.determine-runners.outputs.runners }} steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Determine runners to use for this job id: determine-runners env: HOMEBREW_MACOS_TIMEOUT: 30 run: brew determine-test-runners --all-supported tests: needs: determine-runners strategy: matrix: include: ${{ fromJson(needs.determine-runners.outputs.runners) }} fail-fast: false name: ${{ matrix.name }} runs-on: ${{ matrix.runner }} timeout-minutes: ${{ matrix.timeout }} defaults: run: working-directory: /tmp steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - run: brew test-bot --only-cleanup-before if: matrix.cleanup - run: brew doctor - run: brew test-bot --only-cleanup-after if: always() && matrix.cleanup Homebrew-brew-d7f73ce/.github/workflows/release.yml000066400000000000000000000245621517265720000225010ustar00rootroot00000000000000name: Release on: push: branches: - "**" tags-ignore: - "**" paths: - .github/workflows/release.yml - package/**/* workflow_dispatch: inputs: tag: description: "Git tag for the release" required: true type: string env: PKG_APPLE_DEVELOPER_TEAM_ID: ${{ secrets.PKG_APPLE_DEVELOPER_TEAM_ID }} HOMEBREW_NO_ANALYTICS_THIS_RUN: 1 HOMEBREW_NO_ANALYTICS_MESSAGE_OUTPUT: 1 permissions: {} defaults: run: shell: bash -xeuo pipefail {0} jobs: build: if: github.repository_owner == 'Homebrew' && github.actor != 'dependabot[bot]' runs-on: macos-26 outputs: installer_path: "Homebrew-${{ steps.homebrew-version.outputs.version }}.pkg" env: TEMPORARY_CERTIFICATE_FILE: "homebrew_developer_id_installer_certificate.p12" TEMPORARY_KEYCHAIN_FILE: "homebrew_installer_signing.keychain-db" # Set to the oldest supported version of macOS HOMEBREW_MACOS_OLDEST_SUPPORTED: "14.0" permissions: contents: write # for creating tags and releases attestations: write # for actions/attest id-token: write # for actions/attest steps: - name: Remove existing API cache (to force update) run: rm -rvf ~/Library/Caches/Homebrew/api - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Install Pandoc uses: Homebrew/actions/cache-homebrew-prefix@main with: install: pandoc workflow-key: release uninstall: true - name: Create and unlock temporary macOS keychain run: | TEMPORARY_KEYCHAIN_PASSWORD="$(openssl rand -base64 20)" TEMPORARY_KEYCHAIN_PATH="${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}" security create-keychain -p "${TEMPORARY_KEYCHAIN_PASSWORD}" "${TEMPORARY_KEYCHAIN_PATH}" security set-keychain-settings -l -u -t 21600 "${TEMPORARY_KEYCHAIN_PATH}" security unlock-keychain -p "${TEMPORARY_KEYCHAIN_PASSWORD}" "${TEMPORARY_KEYCHAIN_PATH}" - name: Create temporary certificate file env: PKG_APPLE_SIGNING_CERTIFICATE_BASE64: ${{ secrets.PKG_APPLE_SIGNING_CERTIFICATE_BASE64 }} run: echo -n "${PKG_APPLE_SIGNING_CERTIFICATE_BASE64}" | base64 --decode --output="${RUNNER_TEMP}/${TEMPORARY_CERTIFICATE_FILE}" - name: Import certificate file into macOS keychain env: PKG_APPLE_SIGNING_CERTIFICATE_PASSWORD: ${{ secrets.PKG_APPLE_SIGNING_CERTIFICATE_PASSWORD }} run: security import "${RUNNER_TEMP}/${TEMPORARY_CERTIFICATE_FILE}" -k "${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}" -P "${PKG_APPLE_SIGNING_CERTIFICATE_PASSWORD}" -t cert -f pkcs12 -A - name: Clean up temporary certificate file if: ${{ always() }} run: rm -f "${RUNNER_TEMP}/${TEMPORARY_CERTIFICATE_FILE}" - name: Checkout another Homebrew to brew subdirectory uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: path: brew fetch-depth: 0 persist-credentials: false - name: Create tag if needed, check and get Homebrew version from Git id: homebrew-version env: TAG: ${{ inputs.tag }} run: | if [ -n "${TAG}" ]; then git -C brew tag "${TAG}" fi homebrew_version=$(git -C brew describe --tags --always) if [ -n "${TAG}" ] && [ "${homebrew_version}" != "${TAG}" ]; then echo "Homebrew version ${homebrew_version} does not match tag ${TAG}" exit 1 fi echo "version=${homebrew_version}" >> "${GITHUB_OUTPUT}" - name: Copy Homebrew API cache to brew subdirectory run: cp -vR ~/Library/Caches/Homebrew/api brew/cache_api - name: Open macOS keychain run: security list-keychain -d user -s "${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}" - name: Build Homebrew installer component package env: HOMEBREW_VERSION: ${{ steps.homebrew-version.outputs.version }} # Note: `Library/Homebrew/test/support/fixtures/` contains unsigned # binaries so it needs to be excluded from notarization. run: pkgbuild --root brew --scripts brew/package/scripts --identifier sh.brew.homebrew --version "${HOMEBREW_VERSION}" --install-location /opt/homebrew --filter .DS_Store --filter "(.*)/Library/Homebrew/test/support/fixtures/" --min-os-version "${HOMEBREW_MACOS_OLDEST_SUPPORTED}" --sign "${PKG_APPLE_DEVELOPER_TEAM_ID}" Homebrew.pkg - name: Convert Homebrew license file to RTF run: (printf "### " && cat brew/LICENSE.txt) | pandoc --from markdown --standalone --output brew/package/resources/LICENSE.rtf - name: Build Homebrew installer product package env: HOMEBREW_VERSION: ${{ steps.homebrew-version.outputs.version }} run: productbuild --resources brew/package/resources --distribution brew/package/Distribution.xml --package-path Homebrew.pkg --sign "${PKG_APPLE_DEVELOPER_TEAM_ID}" "Homebrew-${HOMEBREW_VERSION}.pkg" - name: Clean up temporary macOS keychain if: ${{ always() }} run: | if [[ -f "${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}" ]] then security delete-keychain "${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}" fi - name: Generate build provenance uses: actions/attest@59d89421af93a897026c735860bf21b6eb4f7b26 # v4.1.0 with: subject-path: Homebrew-${{ steps.homebrew-version.outputs.version }}.pkg - name: Upload installer to GitHub Actions uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: Homebrew-${{ steps.homebrew-version.outputs.version }}.pkg path: Homebrew-${{ steps.homebrew-version.outputs.version }}.pkg test: needs: build name: "test (${{matrix.name}})" runs-on: ${{ matrix.runner }} strategy: fail-fast: false matrix: include: # Intel - runner: macos-15-intel name: macos-15-x86_64 # Apple Silicon - runner: macos-15 name: macos-15-arm64 - runner: macos-26 name: macos-26-arm64 steps: - name: Download installer from GitHub Actions uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: "${{ needs.build.outputs.installer_path }}" - name: Unset global Git safe directory setting run: git config --global --unset-all safe.directory - name: Remove existing Homebrew installations run: | sudo rm -rf brew /{usr/local,opt/homebrew}/{Cellar,Caskroom,Homebrew/Library/Taps} brew cleanup --prune-prefix sudo rm -rf /usr/local/{bin/brew,Homebrew} /opt/homebrew /home/linuxbrew - name: Zero existing installer logs run: echo | sudo tee /var/log/install.log - name: Install Homebrew from installer package env: INSTALLER_PATH: ${{ needs.build.outputs.installer_path }} run: sudo installer -verbose -pkg "${INSTALLER_PATH}" -target / - name: Output installer logs if: ${{ always() }} run: sudo cat /var/log/install.log - name: Check Homebrew version matches tag env: TAG: ${{ inputs.tag }} run: | homebrew_version=$(brew --version) if [ -n "${TAG}" ] && [ "${homebrew_version}" != "Homebrew ${TAG}" ]; then echo "Homebrew version ${homebrew_version} does not match tag ${TAG}" exit 1 fi - run: brew config - run: brew doctor - name: Zero existing installer logs (again) run: echo | sudo tee /var/log/install.log - name: Reinstall Homebrew from installer package env: INSTALLER_PATH: ${{ needs.build.outputs.installer_path }} run: sudo installer -verbose -pkg "${INSTALLER_PATH}" -target / - name: Output installer logs (again) if: ${{ always() }} run: sudo cat /var/log/install.log - run: brew config - run: brew doctor upload: needs: [build, test] runs-on: macos-26 permissions: # To write assets to GitHub release contents: write steps: - name: Checkout Homebrew/brew if: github.event_name == 'workflow_dispatch' uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: fetch-depth: 0 persist-credentials: false - name: Download installer from GitHub Actions uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: "${{ needs.build.outputs.installer_path }}" - name: Notarize Homebrew installer package env: PKG_APPLE_ID_EMAIL: ${{ secrets.PKG_APPLE_ID_EMAIL }} PKG_APPLE_ID_APP_SPECIFIC_PASSWORD: ${{ secrets.PKG_APPLE_ID_APP_SPECIFIC_PASSWORD }} INSTALLER_PATH: ${{ needs.build.outputs.installer_path }} run: xcrun notarytool submit "${INSTALLER_PATH}" --team-id "${PKG_APPLE_DEVELOPER_TEAM_ID}" --apple-id "${PKG_APPLE_ID_EMAIL}" --password "${PKG_APPLE_ID_APP_SPECIFIC_PASSWORD}" --wait - name: Create draft release if: github.event_name == 'workflow_dispatch' env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} TAG: ${{ inputs.tag }} run: | gh release create "${TAG}" \ --repo Homebrew/brew \ --title "${TAG}" \ --draft \ --generate-notes \ --fail-on-no-commits - name: Rename installer to unversioned path env: INSTALLER_PATH: ${{ needs.build.outputs.installer_path }} run: mv "${INSTALLER_PATH}" Homebrew.pkg - name: Upload installer to GitHub release if: github.event_name == 'workflow_dispatch' env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} INSTALLER_PATH: ${{ needs.build.outputs.installer_path }} run: | VERSION="${INSTALLER_PATH#Homebrew-}" VERSION="${VERSION%.pkg}" gh release upload --repo Homebrew/brew "${VERSION}" Homebrew.pkg Homebrew-brew-d7f73ce/.github/workflows/sbom.yml000066400000000000000000000103271517265720000220130ustar00rootroot00000000000000name: Update SBOM schema on: push: paths: - .github/workflows/sbom.yml branches-ignore: - main - master schedule: - cron: "0 0 * * *" workflow_dispatch: permissions: contents: read defaults: run: shell: bash -xeuo pipefail {0} jobs: sbom: if: github.repository == 'Homebrew/brew' runs-on: ubuntu-latest steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Configure Git user uses: Homebrew/actions/git-user-config@main with: username: BrewTestBot - name: Set up commit signing uses: Homebrew/actions/setup-commit-signing@main with: signing_key: ${{ secrets.BREWTESTBOT_SSH_SIGNING_KEY }} - name: Update schema data id: update env: GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: | git fetch origin BRANCH="schema-update" echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT" if git ls-remote --exit-code --heads origin "${BRANCH}" then git checkout "${BRANCH}" git checkout "Library/Homebrew/data/schemas" else git checkout --no-track -B "${BRANCH}" origin/HEAD fi # Intentionally tracking 2.3.x to match what we output in sbom.rb. 3.0 also doesn't have a JSON Schema. # Note: this is a 2.3.1 development branch - not a 2.3.1 tag. It contains bugfixes compared to 2.3.0. curl --location --output Library/Homebrew/data/schemas/sbom.json https://raw.githubusercontent.com/spdx/spdx-spec/support/v2.3.1/schemas/spdx-schema.json # https://github.com/spdx/spdx-spec/pull/1029 sed -i -e 's|\(2019-09/schema\)#|\1|' Library/Homebrew/data/schemas/sbom.json if ! git diff --exit-code Library/Homebrew/data/schemas then git add "Library/Homebrew/data/schemas" git commit -m "data/schemas: update schema data." -m "Autogenerated by [a scheduled GitHub Action](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sbom.yml)." echo "committed=true" >> "$GITHUB_OUTPUT" PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state" || true)" if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]] then echo "pull_request=true" >> "$GITHUB_OUTPUT" fi fi - name: Push commits if: steps.update.outputs.committed == 'true' uses: Homebrew/actions/git-try-push@main with: token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} directory: ${{ steps.set-up-homebrew.outputs.repository-path }} branch: ${{ steps.update.outputs.branch }} force: true origin_branch: "HEAD" - name: Open a pull request if: steps.update.outputs.pull_request == 'true' run: gh pr create --fill env: GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} issue: needs: sbom if: always() && github.event_name == 'schedule' && github.repository == 'Homebrew/brew' runs-on: ubuntu-slim env: RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} permissions: # To create or update issues issues: write steps: - name: Open, update, or close schema issue uses: Homebrew/actions/create-or-update-issue@main with: title: Failed to update SBOM schema body: > The SBOM schema workflow [failed](${{ env.RUN_URL }}). No SBOM schema was updated. labels: bug update-existing: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }} close-existing: ${{ needs.sbom.result == 'success' }} close-from-author: github-actions[bot] close-comment: > The SBOM schema workflow [succeeded](${{ env.RUN_URL }}). Closing this issue. Homebrew-brew-d7f73ce/.github/workflows/sorbet.yml000066400000000000000000000111631517265720000223500ustar00rootroot00000000000000name: Update Sorbet files on: pull_request: paths: - Library/Homebrew/dev-cmd/typecheck.rb - Library/Homebrew/sorbet/** - "!Library/Homebrew/sorbet/rbi/**" push: paths: - .github/workflows/sorbet.yml branches-ignore: - main - master schedule: - cron: "0 0 * * *" workflow_dispatch: permissions: contents: read defaults: run: shell: bash -xeuo pipefail {0} jobs: tapioca: if: github.repository == 'Homebrew/brew' runs-on: macos-26 steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Configure Git user if: github.event_name != 'pull_request' uses: Homebrew/actions/git-user-config@main with: username: BrewTestBot - name: Set up commit signing if: github.event_name != 'pull_request' uses: Homebrew/actions/setup-commit-signing@main with: signing_key: ${{ secrets.BREWTESTBOT_SSH_SIGNING_KEY }} - name: Update RBI files id: update working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: | if [[ "${GITHUB_EVENT_NAME}" != "pull_request" ]] then git fetch origin BRANCH="sorbet-files-update" echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT" if git ls-remote --exit-code --heads origin "${BRANCH}" then git checkout "${BRANCH}" git checkout "Library/Homebrew/sorbet" else git checkout --no-track -B "${BRANCH}" origin/HEAD fi fi brew typecheck --update --suggest-typed - name: Commit changes id: commit if: github.event_name != 'pull_request' env: GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: | if ! git diff --stat --exit-code "Library/Homebrew/sorbet" then git add "Library/Homebrew/sorbet" git commit -m "sorbet: Update RBI files." \ -m "Autogenerated by the [sorbet](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sorbet.yml) workflow." if ! git diff --stat --exit-code "Library/Homebrew" then git add "Library/Homebrew/" git commit -m "sorbet: Autobump sigils via Spoom" \ -m "Autogenerated by the [sorbet](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sorbet.yml) workflow." fi echo "committed=true" >> "$GITHUB_OUTPUT" PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state" || true)" if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]] then echo "pull_request=true" >> "$GITHUB_OUTPUT" fi fi - name: Push commits if: steps.commit.outputs.committed == 'true' uses: Homebrew/actions/git-try-push@main with: token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} directory: ${{ steps.set-up-homebrew.outputs.repository-path }} branch: ${{ steps.update.outputs.branch }} force: true origin_branch: "HEAD" - name: Open a pull request if: steps.commit.outputs.pull_request == 'true' run: gh pr create --fill env: GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} issue: needs: tapioca if: always() && github.event_name == 'schedule' && github.repository == 'Homebrew/brew' runs-on: ubuntu-slim env: RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} permissions: # To create or update issues issues: write steps: - name: Open, update, or close Sorbet issue uses: Homebrew/actions/create-or-update-issue@main with: title: Failed to update RBI files body: > The Sorbet workflow [failed](${{ env.RUN_URL }}). No RBI files were updated. labels: bug update-existing: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }} close-existing: ${{ needs.tapioca.result == 'success' }} close-from-author: github-actions[bot] close-comment: > The Sorbet workflow [succeeded](${{ env.RUN_URL }}). Closing this issue. Homebrew-brew-d7f73ce/.github/workflows/spdx.yml000066400000000000000000000072671517265720000220420ustar00rootroot00000000000000name: Update SPDX license data on: push: paths: - .github/workflows/spdx.yml branches-ignore: - main - master schedule: - cron: "0 0 * * *" workflow_dispatch: permissions: contents: read defaults: run: shell: bash -xeuo pipefail {0} jobs: spdx: if: github.repository == 'Homebrew/brew' runs-on: ubuntu-latest steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Configure Git user uses: Homebrew/actions/git-user-config@main with: username: BrewTestBot - name: Set up commit signing uses: Homebrew/actions/setup-commit-signing@main with: signing_key: ${{ secrets.BREWTESTBOT_SSH_SIGNING_KEY }} - name: Update SPDX license data id: update env: GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: | git fetch origin BRANCH="spdx-update" echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT" if git ls-remote --exit-code --heads origin "${BRANCH}" then git checkout "${BRANCH}" git checkout "Library/Homebrew/data/spdx" else git checkout --no-track -B "${BRANCH}" origin/HEAD fi if brew update-license-data then git add "Library/Homebrew/data/spdx" git commit -m "spdx: update license data." -m "Autogenerated by [a scheduled GitHub Action](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/spdx.yml)." echo "committed=true" >> "$GITHUB_OUTPUT" PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state" || true)" if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]] then echo "pull_request=true" >> "$GITHUB_OUTPUT" fi fi - name: Push commits if: steps.update.outputs.committed == 'true' uses: Homebrew/actions/git-try-push@main with: token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} directory: ${{ steps.set-up-homebrew.outputs.repository-path }} branch: ${{ steps.update.outputs.branch }} force: true origin_branch: "HEAD" - name: Open a pull request if: steps.update.outputs.pull_request == 'true' run: gh pr create --fill env: GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} issue: needs: spdx if: always() && github.event_name == 'schedule' && github.repository == 'Homebrew/brew' runs-on: ubuntu-slim env: RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} permissions: # To create or update issues issues: write steps: - name: Open, update, or close SPDX issue uses: Homebrew/actions/create-or-update-issue@main with: title: Failed to update SPDX license data body: > The SPDX license data workflow [failed](${{ env.RUN_URL }}). No SPDX license data was updated. labels: bug update-existing: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }} close-existing: ${{ needs.spdx.result == 'success' }} close-from-author: github-actions[bot] close-comment: > The SPDX license data workflow [succeeded](${{ env.RUN_URL }}). Closing this issue. Homebrew-brew-d7f73ce/.github/workflows/sponsors-maintainers-man-completions.yml000066400000000000000000000140071517265720000303530ustar00rootroot00000000000000name: Update sponsors, maintainers, manpage and completions on: push: branches: - main - master paths: - .github/workflows/sponsors-maintainers-man-completions.yml - README.md - Library/Homebrew/cmd/** - Library/Homebrew/dev-cmd/** - Library/Homebrew/completions/** - Library/Homebrew/manpages/** - Library/Homebrew/cli/parser.rb - Library/Homebrew/completions.rb - Library/Homebrew/env_config.rb schedule: - cron: "0 0 * * *" workflow_dispatch: permissions: contents: read defaults: run: shell: bash -xeuo pipefail {0} jobs: updates: runs-on: ubuntu-latest if: github.repository == 'Homebrew/brew' steps: - name: Setup Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Configure Git user uses: Homebrew/actions/git-user-config@main with: username: BrewTestBot - name: Set up commit signing uses: Homebrew/actions/setup-commit-signing@main with: signing_key: ${{ secrets.BREWTESTBOT_SSH_SIGNING_KEY }} - name: Cache Bundler RubyGems uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ${{ steps.set-up-homebrew.outputs.gems-path }} key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }} restore-keys: ${{ runner.os }}-rubygems- - name: Update sponsors, maintainers, manpage and completions id: update run: | git fetch origin if [[ -n "$GITHUB_REF_NAME" && "$GITHUB_REF_NAME" != "master" && "$GITHUB_REF_NAME" != "main" ]] then BRANCH="$GITHUB_REF_NAME" else BRANCH=sponsors-maintainers-man-completions fi echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT" if git ls-remote --exit-code --heads origin "${BRANCH}" then git checkout --force "${BRANCH}" git checkout "README.md" \ "docs/Manpage.md" \ "manpages/brew.1" \ "completions" else git checkout --force --no-track -B "${BRANCH}" origin/HEAD fi if brew update-sponsors then git add "README.md" git commit -m "Update sponsors." \ -m "Autogenerated by the [sponsors-maintainers-man-completions](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sponsors-maintainers-man-completions.yml) workflow." COMMITTED=true fi if brew update-maintainers then git add "README.md" \ "docs/Manpage.md" \ "manpages/brew.1" git commit -m "Update maintainers." \ -m "Autogenerated by the [sponsors-maintainers-man-completions](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sponsors-maintainers-man-completions.yml) workflow." COMMITTED=true fi if brew generate-man-completions then git add "README.md" \ "docs/Manpage.md" \ "manpages/brew.1" \ "completions" git commit -m "Update manpage and completions." \ -m "Autogenerated by the [sponsors-maintainers-man-completions](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sponsors-maintainers-man-completions.yml) workflow." COMMITTED=true fi if [[ -n "${COMMITTED-}" ]] then echo "committed=true" >> "$GITHUB_OUTPUT" PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state" || true)" if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]] then echo "pull_request=true" >> "$GITHUB_OUTPUT" fi fi env: GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} HOMEBREW_GITHUB_API_TOKEN: ${{ secrets.HOMEBREW_BREW_UPDATE_SPONSORS_MAINTAINERS_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} - name: Push commits if: steps.update.outputs.committed == 'true' uses: Homebrew/actions/git-try-push@main with: token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} directory: ${{ steps.set-up-homebrew.outputs.repository-path }} branch: ${{ steps.update.outputs.branch }} force: true - name: Open a pull request if: steps.update.outputs.pull_request == 'true' run: gh pr create --fill env: GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} issue: needs: updates if: always() && github.event_name == 'schedule' && github.repository == 'Homebrew/brew' runs-on: ubuntu-slim env: RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} permissions: # To create or update issues issues: write steps: - name: Open, update, or close sponsors, maintainers, manpage and completions issue uses: Homebrew/actions/create-or-update-issue@main with: title: Failed to update sponsors, maintainers, manpage and completions body: > The sponsors, maintainers, manpage and completions workflow [failed](${{ env.RUN_URL }}). No sponsors, maintainers, manpage and completions were updated. labels: bug update-existing: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }} close-existing: ${{ needs.updates.result == 'success' }} close-from-author: github-actions[bot] close-comment: > The sponsors, maintainers, manpage and completions workflow [succeeded](${{ env.RUN_URL }}). Closing this issue. Homebrew-brew-d7f73ce/.github/workflows/stale-issues.yml000066400000000000000000000054061517265720000234760ustar00rootroot00000000000000# This file is synced from the `.github` repository, do not modify it directly. name: Manage stale issues on: push: paths: - .github/workflows/stale-issues.yml branches-ignore: - dependabot/** schedule: # Once every day at midnight UTC - cron: "0 0 * * *" issue_comment: permissions: {} defaults: run: shell: bash -xeuo pipefail {0} concurrency: group: stale-issues cancel-in-progress: ${{ github.event_name != 'issue_comment' }} jobs: stale: if: > github.repository_owner == 'Homebrew' && ( github.event_name != 'issue_comment' || ( contains(github.event.issue.labels.*.name, 'stale') || contains(github.event.pull_request.labels.*.name, 'stale') ) ) runs-on: ubuntu-slim permissions: contents: write issues: write pull-requests: write steps: - name: Mark/Close Stale Issues and Pull Requests uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0 with: repo-token: ${{ secrets.GITHUB_TOKEN }} days-before-stale: 21 days-before-close: 7 stale-issue-message: > This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. stale-pr-message: > This pull request has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. exempt-issue-labels: "gsoc-outreachy,help wanted,in progress" exempt-pr-labels: "gsoc-outreachy,help wanted,in progress" delete-branch: true bump-pr-stale: if: > github.repository_owner == 'Homebrew' && ( github.event_name != 'issue_comment' || ( contains(github.event.issue.labels.*.name, 'stale') || contains(github.event.pull_request.labels.*.name, 'stale') ) ) runs-on: ubuntu-slim permissions: contents: write issues: write pull-requests: write steps: - name: Mark/Close Stale `bump-formula-pr` and `bump-cask-pr` Pull Requests uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0 with: repo-token: ${{ secrets.GITHUB_TOKEN }} days-before-stale: 2 days-before-close: 1 stale-pr-message: > This pull request has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. To keep this pull request open, add a `help wanted` or `in progress` label. exempt-pr-labels: "help wanted,in progress" any-of-labels: "bump-formula-pr,bump-cask-pr" delete-branch: true Homebrew-brew-d7f73ce/.github/workflows/sync-default-branches.yml000066400000000000000000000032461517265720000252360ustar00rootroot00000000000000name: Sync default branches on: push: branches: - main - master pull_request: paths: - .github/workflows/sync-default-branches.yml permissions: {} defaults: run: shell: bash -xeuo pipefail {0} concurrency: group: "sync-default-branches-${{ github.ref }}" cancel-in-progress: true jobs: sync: runs-on: ubuntu-slim permissions: contents: write steps: - name: Configure Git user uses: Homebrew/actions/git-user-config@main with: username: github-actions[bot] - name: Determine source and target branches id: branches run: | if [[ "${GITHUB_REF_NAME}" == "main" ]]; then target="master" source="main" else target="main" source="master" fi echo "target=${target}" >> "$GITHUB_OUTPUT" echo "source=${source}" >> "$GITHUB_OUTPUT" - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: fetch-depth: 1 persist-credentials: true - name: Get target SHA id: sha run: | TARGET_SHA=$(git ls-remote origin "refs/heads/${SOURCE_BRANCH}" | cut -f1) echo "target=${TARGET_SHA}" >> "$GITHUB_OUTPUT" env: SOURCE_BRANCH: ${{ steps.branches.outputs.source }} - name: Push target branch if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master' run: git push origin "${TARGET_SHA}:refs/heads/${TARGET_BRANCH}" --force env: TARGET_SHA: ${{ steps.sha.outputs.target }} TARGET_BRANCH: ${{ steps.branches.outputs.target }} Homebrew-brew-d7f73ce/.github/workflows/tests.yml000066400000000000000000000407141517265720000222200ustar00rootroot00000000000000name: CI on: push: branches: - main - master pull_request: merge_group: permissions: contents: read env: HOMEBREW_DEVELOPER: 1 HOMEBREW_NO_AUTO_UPDATE: 1 HOMEBREW_NO_ENV_HINTS: 1 HOMEBREW_NO_INSTALL_CLEANUP: 1 HOMEBREW_VERIFY_ATTESTATIONS: 1 defaults: run: shell: bash -xeuo pipefail {0} concurrency: group: "${{ github.ref }}" cancel-in-progress: ${{ github.event_name == 'pull_request' }} jobs: syntax: if: github.repository_owner == 'Homebrew' runs-on: ubuntu-latest steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Cache Bundler RubyGems uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ${{ steps.set-up-homebrew.outputs.gems-path }} key: ${{ runner.os }}-rubygems-syntax-${{ steps.set-up-homebrew.outputs.gems-hash }} restore-keys: ${{ runner.os }}-rubygems-syntax- - name: Install Bundler RubyGems run: brew install-bundler-gems --groups=style,typecheck - name: Install shellcheck and shfmt uses: Homebrew/actions/cache-homebrew-prefix@main with: install: shellcheck shfmt workflow-key: tests-syntax - name: Cache style cache uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ~/.cache/Homebrew/style key: syntax-style-cache-${{ github.sha }} restore-keys: syntax-style-cache- - run: brew style - run: brew typecheck - name: Check public API lists are in sync working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: brew ruby Library/Homebrew/github_actions_utils/public_api_check.rb tap-syntax: name: tap syntax needs: syntax if: github.repository_owner == 'Homebrew' runs-on: macos-26 steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: true cask: true - name: Cache Bundler RubyGems uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ${{ steps.set-up-homebrew.outputs.gems-path }} key: ${{ runner.os }}-rubygems-tap-syntax-${{ steps.set-up-homebrew.outputs.gems-hash }} restore-keys: ${{ runner.os }}-rubygems-tap-syntax- - name: Install Bundler RubyGems run: brew install-bundler-gems --groups=style,typecheck - name: Cache style cache uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ~/Library/Caches/Homebrew/style key: tap-syntax-style-cache-${{ github.sha }} restore-keys: tap-syntax-style-cache- - name: Run brew style on official taps run: brew style homebrew/core homebrew/cask - name: Run brew typecheck on official taps run: brew typecheck homebrew/core homebrew/cask formula-audit: name: formula audit needs: syntax if: github.repository_owner == 'Homebrew' && github.event_name != 'push' runs-on: ubuntu-latest container: image: ghcr.io/homebrew/brew:main steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: true cask: false - name: Run brew readall on homebrew/core run: brew readall --os=all --arch=all --aliases homebrew/core - name: Run brew audit --skip-style on homebrew/core run: brew audit --skip-style --except=version --tap=homebrew/core - name: Generate formula API run: brew generate-formula-api --dry-run cask-audit: name: cask audit needs: syntax if: github.repository_owner == 'Homebrew' && github.event_name != 'push' runs-on: macos-26 steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: true cask: true - name: Run brew readall on all casks run: brew readall --os=all --arch=all homebrew/cask - name: Run brew audit --skip-style on homebrew/cask run: | brew audit --skip-style --except=version --tap=homebrew/cask - name: Generate cask API run: brew generate-cask-api --dry-run vendored-gems: name: vendored gems needs: syntax runs-on: ubuntu-latest steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Configure Git user uses: Homebrew/actions/git-user-config@main with: username: BrewTestBot # Can't cache this because we need to check that it doesn't fail the # "uncommitted RubyGems" step with a cold cache. - name: Install Bundler RubyGems run: brew install-bundler-gems --groups=all - name: Check for uncommitted RubyGems working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: | git diff --stat --exit-code Library/Homebrew/vendor/bundle if [ -n "$(git status --porcelain -- Library/Homebrew/vendor/bundle)" ]; then echo "Untracked or unstaged files found:" git status --porcelain -- Library/Homebrew/vendor/bundle exit 1 fi update-test: name: ${{ matrix.name }} runs-on: ${{ matrix.runs-on }} needs: syntax if: github.event_name != 'push' strategy: matrix: include: - name: update-test (Linux) runs-on: ubuntu-latest - name: update-test (macOS) runs-on: macos-latest steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Run brew update-tests run: | brew update-test brew update-test --to-tag brew update-test --commit=HEAD tests: name: ${{ matrix.name }} needs: syntax runs-on: ${{ matrix.runs-on }} timeout-minutes: 30 strategy: matrix: include: - name: tests (online) test-flags: --online --coverage --profile 3 runs-on: ubuntu-latest - name: tests (generic OS) test-flags: --generic --coverage --profile 3 runs-on: ubuntu-latest - name: tests (Linux) test-flags: --coverage --profile 3 runs-on: ubuntu-24.04 - name: tests (macOS) test-flags: --coverage --profile 3 runs-on: macos-26 steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: # We only test needs_homebrew_core tests on macOS because # homebrew/core is not available by default on GitHub-hosted Ubuntu # runners, and it's expensive to tap it. core: ${{ runner.os == 'macOS' }} cask: false - name: Cache Bundler RubyGems uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ${{ steps.set-up-homebrew.outputs.gems-path }} key: ${{ matrix.runs-on }}-tests-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }} restore-keys: ${{ matrix.runs-on }}-tests-rubygems- - run: brew config - name: Install Bundler RubyGems run: brew install-bundler-gems --groups=all - name: Create parallel test log directory run: mkdir tests - name: Cache parallel tests log uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: tests key: ${{ runner.os }}-${{ matrix.test-flags }}-parallel_runtime_rspec-${{ github.sha }} restore-keys: ${{ runner.os }}-${{ matrix.test-flags }}-parallel_runtime_rspec- - name: Install brew tests --online dependencies if: matrix.name == 'tests (online)' uses: Homebrew/actions/cache-homebrew-prefix@main with: install: subversion curl workflow-key: tests-tests-online - name: Install brew tests macOS dependencies if: runner.os != 'Linux' uses: Homebrew/actions/cache-homebrew-prefix@main with: install: subversion gnupg workflow-key: tests-tests-macos uninstall: true # brew tests doesn't like world writable directories - name: Cleanup permissions if: runner.os == 'Linux' run: sudo chmod -R g-w,o-w /home/linuxbrew/.linuxbrew/Homebrew - name: Run brew tests if: github.event_name == 'pull_request' || matrix.name != 'tests (online)' run: brew tests ${{ matrix.test-flags }} env: HOMEBREW_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }} # These cannot be queried at the macOS level on GitHub Actions. HOMEBREW_LANGUAGES: en-GB CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - name: Get RSpec JUnit XML filenames id: junit_xml working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: | mkdir -p Library/Homebrew/test/junit filenames=$(find Library/Homebrew/test/junit -name 'rspec*.xml' -print | tr '\n' ',') echo "filenames=${filenames%,}" >> "$GITHUB_OUTPUT" - uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0 with: working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} files: ${{ steps.junit_xml.outputs.filenames }} disable_search: true token: ${{ secrets.CODECOV_TOKEN }} report_type: test_results - uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0 with: working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} files: Library/Homebrew/test/coverage/coverage.xml disable_search: true token: ${{ secrets.CODECOV_TOKEN }} test-bot: name: ${{ matrix.name }} needs: syntax if: github.repository_owner == 'Homebrew' && github.event_name != 'push' runs-on: ${{ matrix.runs-on }} container: ${{ matrix.container }} strategy: matrix: include: - name: test-bot (Linux arm64) runs-on: ubuntu-24.04-arm container: ghcr.io/homebrew/ubuntu24.04:latest - name: test-bot (Linux x86_64) runs-on: ubuntu-latest container: ghcr.io/homebrew/brew:main # Use Debian Old Stable for testing Homebrew's glibc support. - name: test-bot (Linux Homebrew glibc) runs-on: ubuntu-latest container: debian:oldstable - name: test-bot (macOS x86_64) runs-on: macos-15-intel - name: test-bot (macOS arm64) runs-on: macos-26 env: HOMEBREW_TEST_BOT_ANALYTICS: 1 steps: - name: Install Homebrew and Homebrew's dependencies # All other images are built from our Homebrew Dockerfile. # This is the only one that needs to be set up manually. if: matrix.container == 'debian:oldstable' run: | # Slimmed down version from the Homebrew Dockerfile apt-get update apt-get install -y --no-install-recommends \ bzip2 \ ca-certificates \ curl \ file \ g++ \ git-core \ jq \ less \ locales \ make \ netbase \ patch \ procps \ sudo \ uuid-runtime \ tzdata # Install Homebrew mkdir -p /home/linuxbrew/.linuxbrew/bin # Don't do shallow clone or it's unshallowed by "Set up Homebrew" git clone https://github.com/Homebrew/brew.git /home/linuxbrew/.linuxbrew/Homebrew cd /home/linuxbrew/.linuxbrew/bin ln -s ../Homebrew/bin/brew brew echo "/home/linuxbrew/.linuxbrew/bin" >>"$GITHUB_PATH" - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: true cask: false - uses: Homebrew/actions/cache-homebrew-prefix@main with: install: gnu-tar workflow-key: test-bot uninstall: true - name: Setup environment variables run: | # Set environment variables to bypass `brew doctor` failures on Tier >=2 configurations if [[ "${MATRIX_NAME}" == "test-bot (Linux Homebrew glibc)" ]]; then echo "HOMEBREW_GLIBC_TESTING=1" >> "$GITHUB_ENV" fi env: MATRIX_NAME: ${{ matrix.name }} - run: brew test-bot --only-cleanup-before - run: brew test-bot --only-setup - run: brew test-bot --only-formulae --only-json-tab --test-default-formula bundle-and-services: name: ${{ matrix.name }} needs: syntax if: github.repository_owner == 'Homebrew' && github.event_name != 'push' runs-on: ${{ matrix.runs-on }} strategy: matrix: include: - name: bundle and services (Linux) runs-on: ubuntu-latest - name: bundle and services (macOS) runs-on: macos-latest steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - run: brew test-bot --only-cleanup-before - name: Run brew bundle and brew services integration tests run: | cat <> Brewfile brew "git" brew "memcached", restart_service: true brew "postgresql@15", restart_service: true cask "1password" cask "1password-cli" cask "google-chrome" # VSCode cask is not available on Linux. vscode "shopify.ruby-lsp" if OS.mac? EOS brew bundle check && exit 1 brew bundle check --verbose && exit 1 brew bundle list brew bundle --verbose brew bundle --upgrade-formulae=memcached,postgresql@15 brew bundle upgrade brew bundle env | grep PATH | grep git brew bundle env --install brew bundle exec --services true brew bundle dump --force --describe brew services list brew services info memcached postgresql@15 brew services info --json memcached postgresql@15 brew services cleanup brew bundle cleanup --force analytics: name: ${{ matrix.name }} runs-on: ${{ matrix.runs-on }} strategy: matrix: include: - name: analytics (Linux) runs-on: ubuntu-latest - name: analytics (macOS) runs-on: macos-latest needs: syntax if: github.repository_owner == 'Homebrew' && github.event_name != 'push' steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main - name: Setup Python uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0 with: python-version-file: ${{ steps.set-up-homebrew.outputs.repository-path }}/Library/Homebrew/formula-analytics/.python-version - name: Cache Homebrew Bundler RubyGems id: cache uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ${{ steps.set-up-homebrew.outputs.gems-path }} key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }} restore-keys: ${{ runner.os }}-rubygems- - name: Install Homebrew Bundler RubyGems if: steps.cache.outputs.cache-hit != 'true' run: brew install-bundler-gems - run: brew formula-analytics --setup - run: brew formula-analytics --install --json --days-ago=2 if: github.event.pull_request.head.repo.fork == false && (github.event_name == 'pull_request' && github.event.pull_request.user.login != 'dependabot[bot]') env: HOMEBREW_INFLUXDB_TOKEN: ${{ secrets.HOMEBREW_INFLUXDB_READ_TOKEN }} - run: brew generate-analytics-api if: github.event.pull_request.head.repo.fork == false && (github.event_name == 'pull_request' && github.event.pull_request.user.login != 'dependabot[bot]') env: HOMEBREW_INFLUXDB_TOKEN: ${{ secrets.HOMEBREW_INFLUXDB_READ_TOKEN }} Homebrew-brew-d7f73ce/.github/workflows/vendor-gems.yml000066400000000000000000000105421517265720000233000ustar00rootroot00000000000000name: Vendor Gems on: pull_request: paths: - Library/Homebrew/dev-cmd/vendor-gems.rb - Library/Homebrew/Gemfile* push: paths: - .github/workflows/vendor-gems.yml branches-ignore: - main - master workflow_dispatch: inputs: pull_request: description: Pull request number required: true permissions: contents: write pull-requests: read defaults: run: shell: bash -xeuo pipefail {0} jobs: vendor-gems: if: github.repository_owner == 'Homebrew' runs-on: macos-26 steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Configure Git user if: github.event_name == 'workflow_dispatch' uses: Homebrew/actions/git-user-config@main with: username: BrewTestBot - name: Set up commit signing if: github.event_name == 'workflow_dispatch' uses: Homebrew/actions/setup-commit-signing@main with: signing_key: ${{ secrets.BREWTESTBOT_SSH_SIGNING_KEY }} - name: Check out pull request id: checkout if: github.event_name == 'workflow_dispatch' || (github.event_name == 'pull_request' && github.event.pull_request.user.login == 'dependabot[bot]') run: | gh pr checkout "${PR}" branch="$(git branch --show-current)" echo "branch=${branch}" >> "$GITHUB_OUTPUT" gem_name="$(echo "${branch}" | sed -E 's|.*/||;s|(.*)-.*$|\1|')" echo "gem_name=${gem_name}" >> "$GITHUB_OUTPUT" env: PR: ${{ github.event.pull_request.number || github.event.inputs.pull_request }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} - name: Vendor Gems run: | if [[ "${GITHUB_EVENT_NAME}" == "workflow_dispatch" || ("${GITHUB_EVENT_NAME}" == "pull_request" && "${GITHUB_ACTOR}" == "dependabot[bot]") ]] then brew vendor-gems --non-bundler-gems else brew vendor-gems --non-bundler-gems --no-commit fi - name: Update RBI files run: brew typecheck --update - name: Commit RBI changes if: github.event_name == 'workflow_dispatch' || (github.event_name == 'pull_request' && github.event.pull_request.user.login == 'dependabot[bot]') env: GEM_NAME: ${{ steps.checkout.outputs.gem_name }} working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: | if ! git diff --stat --exit-code "Library/Homebrew/sorbet" then git add "Library/Homebrew/sorbet" git commit -m "Update RBI files for ${GEM_NAME}." \ -m "Autogenerated by the [vendor-gems](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/vendor-gems.yml) workflow." fi - name: Generate push token uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1 id: app-token if: github.event_name == 'workflow_dispatch' with: app-id: ${{ vars.BREW_COMMIT_APP_ID }} private-key: ${{ secrets.BREW_COMMIT_APP_KEY }} - name: Push to pull request if: github.event_name == 'workflow_dispatch' || (github.event_name == 'pull_request' && github.event.pull_request.user.login == 'dependabot[bot]') uses: Homebrew/actions/git-try-push@main with: token: ${{ steps.app-token.outputs.token || secrets.GITHUB_TOKEN }} directory: ${{ steps.set-up-homebrew.outputs.repository-path }} branch: ${{ steps.checkout.outputs.branch }} force: true - name: Check vendored gems are in sync if: github.event_name == 'pull_request' working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }} run: | status="$(git status --porcelain -- Library/Homebrew/vendor/bundle Library/Homebrew/sorbet)" if [ -n "${status}" ] then { echo "::error::Vendored gems are out of sync with Gemfile.lock." echo "Run 'brew vendor-gems' and 'brew typecheck --update' and commit the changes." echo echo "${status}" } >&2 exit 1 fi Homebrew-brew-d7f73ce/.github/workflows/vendor-version.yml000066400000000000000000000045121517265720000240320ustar00rootroot00000000000000name: Check Vendor Version on: pull_request: paths: - .github/workflows/vendor-version.yml - Library/Homebrew/vendor/bundle/ruby/** permissions: contents: read defaults: run: shell: bash -xeuo pipefail {0} jobs: check-vendor-version: runs-on: ubuntu-latest steps: - name: Set up Homebrew id: set-up-homebrew uses: Homebrew/actions/setup-homebrew@main with: core: false cask: false - name: Install Bundler RubyGems run: brew install-bundler-gems --groups=all - name: Get Ruby ABI version id: ruby-abi run: echo "version=$(brew ruby -e "puts Gem.ruby_api_version")" >> "${GITHUB_OUTPUT}" - name: Get gem info id: gem-info working-directory: ${{ steps.set-up-homebrew.outputs.gems-path }}/${{ steps.ruby-abi.outputs.version }}/gems run: | { echo "vendor-version=$(<../.homebrew_vendor_version)" echo "ignored<> "${GITHUB_OUTPUT}" - name: Compare to base ref working-directory: ${{ steps.set-up-homebrew.outputs.gems-path }}/${{ steps.ruby-abi.outputs.version }} env: ABI_VERSION: ${{ steps.ruby-abi.outputs.version }} VENDOR_VERSION: ${{ steps.gem-info.outputs.vendor-version }} IGNORED_GEMS: ${{ steps.gem-info.outputs.ignored }} run: | git checkout "origin/${GITHUB_BASE_REF}" rm .homebrew_vendor_version brew install-bundler-gems --groups=all if [[ "$(brew ruby -e "puts Gem.ruby_api_version")" == "${ABI_VERSION}" && \ "$(<.homebrew_vendor_version)" == "${VENDOR_VERSION}" ]] then while IFS= read -r gem; do gem_dir="./gems/${gem}" [[ -d "${gem_dir}" ]] || continue exit_code=0 git check-ignore --quiet "${gem_dir}" || exit_code=$? if (( exit_code != 0 )); then if (( exit_code == 1 )); then echo "::error::VENDOR_VERSION needs bumping in utils/gems.rb" >&2 else echo "::error::git check-ignore failed" >&2 fi exit "${exit_code}" fi done <<< "${IGNORED_GEMS}" fi Homebrew-brew-d7f73ce/.github/zizmor.yml000066400000000000000000000002501517265720000203420ustar00rootroot00000000000000# This file is synced from the `.github` repository, do not modify it directly. rules: unpinned-uses: config: policies: Homebrew/actions/*: ref-pin Homebrew-brew-d7f73ce/.gitignore000066400000000000000000000154241517265720000167260ustar00rootroot00000000000000# First, ignore everything. /* # Explicitly ignore OS X Finder thumbnail files. .DS_Store # Unignore the contents of `Library` as that's where our code lives. !/Library # Ignore files within `Library` (again). /Library/Homebrew/.npmignore /Library/Homebrew/bin /Library/Homebrew/doc /Library/Homebrew/prof /Library/Homebrew/test/.gem /Library/Homebrew/test/.cargo/ /Library/Homebrew/test/.subversion /Library/Homebrew/test/coverage /Library/Homebrew/test/junit /Library/Homebrew/test/fs_leak_log /Library/Homebrew/vendor/portable-ruby /Library/Homebrew/vendor/brew-rs/ /Library/Homebrew/rust/brew-rs/target /Library/Taps /Library/PinnedTaps /Library/Homebrew/.byebug_history /Library/Homebrew/test/.rdbg_history # Ignore Bundler files **/.bundle/bin **/.bundle/cache **/vendor/bundle/ruby/.homebrew_gem_groups **/vendor/bundle/ruby/*/.homebrew_vendor_version **/vendor/bundle/ruby/*/bundler.lock **/vendor/bundle/ruby/*/bin **/vendor/bundle/ruby/*/build_info/ **/vendor/bundle/ruby/*/cache **/vendor/bundle/ruby/*/extensions **/vendor/bundle/ruby/*/gems/*/* **/vendor/bundle/ruby/*/plugins **/vendor/bundle/ruby/*/specifications # Ignore Ruby gems for versions other than we explicitly vendor. # Keep this in sync with the list in standalone/init.rb. **/vendor/bundle/ruby/*/ !**/vendor/bundle/ruby/4.0.0/ # Ignore Bundler binary files **/vendor/bundle/ruby/*/gems/**/*.bundle # Ignore YARD files **/.yardoc # Unignore vendored gems !**/vendor/bundle/ruby/*/gems/*/*COPYING* !**/vendor/bundle/ruby/*/gems/*/*LICENSE* !**/vendor/bundle/ruby/*/gems/*/lib !**/vendor/bundle/ruby/*/gems/addressable-*/data !**/vendor/bundle/ruby/*/gems/public_suffix-*/data # Ignore partially included gems where we don't need all files **/vendor/gems/mechanize-*/.* **/vendor/gems/mechanize-*/*.md **/vendor/gems/mechanize-*/*.rdoc **/vendor/gems/mechanize-*/*.gemspec **/vendor/gems/mechanize-*/Gemfile **/vendor/gems/mechanize-*/Rakefile **/vendor/gems/mechanize-*/examples/ **/vendor/gems/mechanize-*/lib/**/* !**/vendor/gems/mechanize-*/lib/mechanize/ !**/vendor/gems/mechanize-*/lib/mechanize/http/ !**/vendor/gems/mechanize-*/lib/mechanize/http/content_disposition_parser.rb !**/vendor/gems/mechanize-*/lib/mechanize/version.rb **/vendor/gems/mechanize-*/test/ # Ignore dependencies we don't wish to vendor **/vendor/bundle/ruby/*/gems/ast-*/ **/vendor/bundle/ruby/*/gems/benchmark-*/ **/vendor/bundle/ruby/*/gems/bigdecimal-*/ **/vendor/bundle/ruby/*/gems/bootsnap-*/ **/vendor/bundle/ruby/*/gems/bundler-*/ **/vendor/bundle/ruby/*/gems/byebug-*/ **/vendor/bundle/ruby/*/gems/coderay-*/ **/vendor/bundle/ruby/*/gems/colorize-*/ **/vendor/bundle/ruby/*/gems/commander-*/ **/vendor/bundle/ruby/*/gems/csv-*/ **/vendor/bundle/ruby/*/gems/diff-lcs-*/ **/vendor/bundle/ruby/*/gems/docile-*/ **/vendor/bundle/ruby/*/gems/drb-*/ **/vendor/bundle/ruby/*/gems/ecma-re-validator-*/ **/vendor/bundle/ruby/*/gems/erubi-*/ **/vendor/bundle/ruby/*/gems/hana-*/ **/vendor/bundle/ruby/*/gems/highline-*/ **/vendor/bundle/ruby/*/gems/io-console-*/ **/vendor/bundle/ruby/*/gems/jaro_winkler-*/ **/vendor/bundle/ruby/*/gems/json-*/ **/vendor/bundle/ruby/*/gems/json_schemer-*/ **/vendor/bundle/ruby/*/gems/kramdown-*/ **/vendor/bundle/ruby/*/gems/language_server-protocol-*/ **/vendor/bundle/ruby/*/gems/lint_roller-*/ **/vendor/bundle/ruby/*/gems/mcp-*/ **/vendor/bundle/ruby/*/gems/method_source-*/ **/vendor/bundle/ruby/*/gems/mini_portile2-*/ **/vendor/bundle/ruby/*/gems/minitest-*/ **/vendor/bundle/ruby/*/gems/msgpack-*/ **/vendor/bundle/ruby/*/gems/netrc-*/ **/vendor/bundle/ruby/*/gems/ntlm-http-*/ **/vendor/bundle/ruby/*/gems/ostruct-*/ **/vendor/bundle/ruby/*/gems/parallel-*/ **/vendor/bundle/ruby/*/gems/parallel_tests-*/ **/vendor/bundle/ruby/*/gems/parlour-*/ **/vendor/bundle/ruby/*/gems/parser-*/ **/vendor/bundle/ruby/*/gems/powerpack-*/ **/vendor/bundle/ruby/*/gems/prettier_print-*/ **/vendor/bundle/ruby/*/gems/prism-*/ **/vendor/bundle/ruby/*/gems/psych-*/ **/vendor/bundle/ruby/*/gems/pry-*/ **/vendor/bundle/ruby/*/gems/pycall-*/ **/vendor/bundle/ruby/*/gems/racc-*/ **/vendor/bundle/ruby/*/gems/rainbow-*/ **/vendor/bundle/ruby/*/gems/rbi-*/ **/vendor/bundle/ruby/*/gems/rbs-*/ **/vendor/bundle/ruby/*/gems/rdoc-*/ **/vendor/bundle/ruby/*/gems/redcarpet-*/ **/vendor/bundle/ruby/*/gems/regexp_parser-*/ **/vendor/bundle/ruby/*/gems/reline-*/ **/vendor/bundle/ruby/*/gems/require-hooks-*/ **/vendor/bundle/ruby/*/gems/rexml-*/ **/vendor/bundle/ruby/*/gems/rspec-*/ **/vendor/bundle/ruby/*/gems/rspec-core-*/ **/vendor/bundle/ruby/*/gems/rspec-expectations-*/ **/vendor/bundle/ruby/*/gems/rspec_junit_formatter-*/ **/vendor/bundle/ruby/*/gems/rspec-mocks-*/ **/vendor/bundle/ruby/*/gems/rspec-retry-*/ **/vendor/bundle/ruby/*/gems/rspec-support-*/ **/vendor/bundle/ruby/*/gems/rspec-sorbet-*/ **/vendor/bundle/ruby/*/gems/rubocop-*/ **/vendor/bundle/ruby/*/gems/rubydex-*/ **/vendor/bundle/ruby/*/gems/ruby-lsp-*/ **/vendor/bundle/ruby/*/gems/ruby-prof-*/ **/vendor/bundle/ruby/*/gems/ruby-progressbar-*/ **/vendor/bundle/ruby/*/gems/simplecov-*/ **/vendor/bundle/ruby/*/gems/simplecov-html-*/ **/vendor/bundle/ruby/*/gems/simplecov_json_formatter-*/ **/vendor/bundle/ruby/*/gems/simpleidn-*/ **/vendor/bundle/ruby/*/gems/sorbet-*/ !**/vendor/bundle/ruby/*/gems/sorbet-runtime-*/ **/vendor/bundle/ruby/*/gems/spoom-*/ **/vendor/bundle/ruby/*/gems/stackprof-*/ **/vendor/bundle/ruby/*/gems/strscan-*/ **/vendor/bundle/ruby/*/gems/syntax_tree-*/ **/vendor/bundle/ruby/*/gems/tapioca-*/ **/vendor/bundle/ruby/*/gems/test-prof-*/ **/vendor/bundle/ruby/*/gems/thor-*/ **/vendor/bundle/ruby/*/gems/tsort-*/ **/vendor/bundle/ruby/*/gems/unicode-display_width-*/ **/vendor/bundle/ruby/*/gems/unicode-emoji-*/ **/vendor/bundle/ruby/*/gems/unparser-*/ **/vendor/bundle/ruby/*/gems/uri_template-*/ **/vendor/bundle/ruby/*/gems/vernier-*/ **/vendor/bundle/ruby/*/gems/webrobots-*/ **/vendor/bundle/ruby/*/gems/yard-*/ **/vendor/bundle/ruby/*/gems/yard-sorbet-*/ **/vendor/cache/ **/vendor/specifications/ # Ignore `bin` contents (again). /bin # Unignore our `brew` script. !/bin/brew # Unignore our configuration/completions/documentation. !/.devcontainer !/.github !/completions !/docs !/manpages !/CODEOWNERS # Unignore our packaging files !/package /package/resources/LICENSE.rtf # Ignore generated documentation site /docs/_site /docs/.jekyll-metadata /docs/vendor /docs/rubydoc # Unignore our root-level metadata files. !/.dockerignore !/.editorconfig !/.gitignore !/.irb_config !/.ruby-version !/.shellcheckrc !/.vale.ini !/.yardopts !/CHANGELOG.md !/CONTRIBUTING.md !/Dockerfile !/Dockerfile.test.yml !/LICENSE.txt !/README.md # Unignore tests' bundle config !/Library/Homebrew/test/.bundle/config # Unignore editor configuration !/.sublime /.sublime/homebrew.sublime-workspace !/.vscode # Unignore AI configuration !/.cursor !/.claude # Ignore local AI configuration /.claude/settings.local.json # Ignore tmp files **/tmp/ Homebrew-brew-d7f73ce/.shellcheckrc000066400000000000000000000024761517265720000173740ustar00rootroot00000000000000# Look for 'source'd files relative to the current working directory where the # shellcheck command is invoked. source-path=Library # Allow opening any 'source'd file, even if not specified as input external-sources=true # SC2310: This function is invoked in an 'if' / ! condition so set -e will be # disabled. Invoke separately if failures should cause the script to exit. # See: https://github.com/koalaman/shellcheck/wiki/SC2310 # # We don't use the `set -e` feature in Bash scripts yet. # We do need the return status as condition for if switches. # Allow `if command` and `if ! command`. disable=SC2310 # SC2311: Bash implicitly disabled set -e for this function invocation because # it's inside a command substitution. Add set -e; before it or enable inherit_errexit. # See: https://github.com/koalaman/shellcheck/wiki/SC2311 # # We don't use the `set -e` feature in Bash scripts yet. # We don't need return codes for "$(command)", only stdout is needed. # Allow `var="$(command)"`, etc. disable=SC2311 # SC2312: Consider invoking this command separately to avoid masking its return # value (or use '|| true' to ignore). # See: https://github.com/koalaman/shellcheck/wiki/SC2312 # # We don't need return codes for "$(command)", only stdout is needed. # Allow `[[ -n "$(command)" ]]`, `func "$(command)"`, pipes, etc. disable=SC2312 Homebrew-brew-d7f73ce/.sublime/000077500000000000000000000000001517265720000164465ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.sublime/homebrew.sublime-project000066400000000000000000000006561517265720000233130ustar00rootroot00000000000000{ "folders": [ { "//": "Generated based on the contents of our .gitignore", "path": "..", "folder_exclude_patterns": [ "Caskroom", "Cellar", "Frameworks", "bin", "etc", "include", "lib", "opt", "sbin", "share", "var", "Library/Homebrew/LinkedKegs", "Library/Homebrew/Aliases" ], "follow_symlinks": true } ], "settings": { "tab_size": 2 } } Homebrew-brew-d7f73ce/.vale.ini000066400000000000000000000001311517265720000164310ustar00rootroot00000000000000StylesPath = ./docs/vale-styles [formats] rb = md [*.{md,rb}] BasedOnStyles = Homebrew Homebrew-brew-d7f73ce/.vscode/000077500000000000000000000000001517265720000162715ustar00rootroot00000000000000Homebrew-brew-d7f73ce/.vscode/extensions.json000066400000000000000000000007001517265720000213600ustar00rootroot00000000000000{ "recommendations": [ "Shopify.ruby-lsp", "sorbet.sorbet-vscode-extension", "github.vscode-github-actions", "anykeyh.simplecov-vscode", "ms-azuretools.vscode-docker", "github.vscode-pull-request-github", "davidanson.vscode-markdownlint", "foxundermoon.shell-format", "timonwong.shellcheck", "ban.spellright", "redhat.vscode-yaml", "koichisasada.vscode-rdbg", "editorconfig.editorconfig" ] } Homebrew-brew-d7f73ce/.vscode/launch.json000066400000000000000000000010771517265720000204430ustar00rootroot00000000000000{ "version": "0.2.0", "configurations": [ { "type": "rdbg", "name": "Debug Homebrew command", "request": "launch", "rdbgPath": "${workspaceFolder}/Library/Homebrew/shims/gems/rdbg", "command": "brew debugger --", "script": "${fileBasenameNoExtension}", "askParameters": true }, { "type": "rdbg", "name": "Attach to Homebrew debugger", "request": "attach", "rdbgPath": "${workspaceFolder}/Library/Homebrew/shims/gems/rdbg", "env": { "TMPDIR": "/private/tmp/", } } ] } Homebrew-brew-d7f73ce/.vscode/mcp.json000066400000000000000000000002141517265720000177400ustar00rootroot00000000000000{ "servers": { "Homebrew": { "type": "stdio", "command": "brew", "args": [ "mcp-server" ] } } } Homebrew-brew-d7f73ce/.vscode/ruby-lsp-activate.sh000077500000000000000000000016261517265720000222100ustar00rootroot00000000000000#!/bin/bash # This might be sourced from zsh, so support both if [[ -n "${BASH_SOURCE[0]}" ]]; then SCRIPT_PATH="${BASH_SOURCE[0]}" elif [[ -n "${ZSH_VERSION}" ]]; then # This is zsh-specific syntax. # shellcheck disable=SC2296 SCRIPT_PATH="${(%):-%x}" else SCRIPT_PATH="$0" fi HOMEBREW_PREFIX="$(cd "$(dirname "${SCRIPT_PATH}")"/../ && pwd)" # These are used by the functions needed from utils/ruby.sh export HOMEBREW_BREW_FILE="${HOMEBREW_PREFIX}/bin/brew" export HOMEBREW_LIBRARY="${HOMEBREW_PREFIX}/Library" export BUNDLE_WITH="style:typecheck:vscode" # shellcheck source=../Library/Homebrew/utils/ruby.sh source "${HOMEBREW_PREFIX}/Library/Homebrew/utils/ruby.sh" setup-ruby-path setup-gem-home-bundle-gemfile ensure-bundle-dependencies # setup-ruby-path doesn't add Homebrew's ruby to PATH homebrew_ruby_bin="$(dirname "${HOMEBREW_RUBY_PATH}")" export PATH="${homebrew_ruby_bin}:${PATH}" Homebrew-brew-d7f73ce/.vscode/settings.json000066400000000000000000000035271517265720000210330ustar00rootroot00000000000000{ "search.exclude": { "Library/Homebrew/vendor/bundle/ruby/": true, "Library/Homebrew/vendor/gems/": true, "Library/Homebrew/vendor/portable-ruby/": true }, "editor.insertSpaces": true, "editor.tabSize": 2, "editor.rulers": [ 80, 118 ], "files.encoding": "utf8", "files.eol": "\n", "files.trimTrailingWhitespace": true, "files.insertFinalNewline": true, "files.trimFinalNewlines": true, "rubyLsp.rubyVersionManager": { "identifier": "custom" }, "spellright.language": [ "en_GB", "en_US" ], "spellright.documentTypes": [ "markdown", ], "rubyLsp.customRubyCommand": "source ../../.vscode/ruby-lsp-activate.sh", "rubyLsp.bundleGemfile": "Library/Homebrew/Gemfile", "rubyLsp.formatter": "rubocop", "[ruby]": { "editor.defaultFormatter": "Shopify.ruby-lsp", "editor.formatOnSave": true, "editor.formatOnType": true, "editor.semanticHighlighting.enabled": true, }, "sorbet.enabled": true, "sorbet.lspConfigs": [ { "id": "default", "name": "Brew Typecheck", "description": "Default configuration", "command": [ "./bin/brew", "typecheck", "--lsp", ] } ], "sorbet.selectedLspConfigId": "default", "shellcheck.customArgs": [ "--shell=bash", "--enable=all", "--external-sources", "--source-path=${workspaceFolder}/Library" ], "shellformat.effectLanguages": [ "shellscript" ], "shellformat.path": "${workspaceFolder}/Library/Homebrew/utils/shfmt.sh", "shellformat.flag": "-i 2 -ci -ln bash", "[shellscript]": { "editor.formatOnSave": true, "editor.codeActionsOnSave": { "source.fixAll.shellcheck": "explicit" } }, "simplecov-vscode.path": "Library/Homebrew/test/coverage/.resultset.json", "simplecov-vscode.enabled": false, "specstory.cloudSync.enabled": "never" } Homebrew-brew-d7f73ce/AGENTS.md000066400000000000000000000074741517265720000162470ustar00rootroot00000000000000# Agent Instructions for Homebrew/brew Most importantly, run `./bin/brew lgtm` to verify any file edits before prompting for input to run all style checks and tests. This is a Ruby based repository with Bash scripts for faster execution. It is primarily responsible for providing the `brew` command for the Homebrew package manager. Please follow these guidelines when contributing: When running commands in this repository, use `./bin/brew` (not a system `brew` on `PATH`). ## Code Standards ### Required Before Each Commit - Run `./bin/brew typecheck` to verify types are declared correctly using Sorbet. Individual files/directories cannot be checked. `./bin/brew typecheck` is fast enough to just be run globally every time. - Run `./bin/brew style --fix --changed` to lint code formatting using RuboCop. Individual files can be checked/fixed by passing them as arguments e.g. `./bin/brew style --fix Library/Homebrew/cmd/reinstall.rb` - Run `./bin/brew tests --online --changed` to ensure that RSpec unit tests are passing (although some online tests may be flaky so can be ignored if they pass on a rerun). Individual test files can be passed with `--only` e.g. to test `Library/Homebrew/cmd/reinstall.rb` with `Library/Homebrew/test/cmd/reinstall_spec.rb` run `./bin/brew tests --only=cmd/reinstall`. - Shortcut: `./bin/brew lgtm --online` runs all of the required checks above in one command. - All of the above can be run via the Homebrew MCP Server (launch with `./bin/brew mcp-server`). ### Development Flow - Write new code (using Sorbet `sig` type signatures and `typed: strict` for new files, but never for RSpec/test/`*_spec.rb` files) - Write new tests (avoid more than one `:integration_test` per file for speed). Write fast tests by preferring a single `expect` per unit test and combine expectations in a single test when it is an integration test or has non-trivial `before` for test setup. - When adding or tightening tests, verify them with a red/green cycle using the exact `--only=file:line` target for the example you changed. - Formula classes created in specs may be frozen; avoid stubbing class methods on them with RSpec mocks and prefer instance-level stubs or test setup that does not require class-method stubbing. - Keep comments minimal; prefer self-documenting code through strings, variable names, etc. over more comments. ## Repository Structure - `bin/brew`: Homebrew's `brew` command main Bash entry point script - `completions/`: Generated shell (`bash`/`fish`/`zsh`) completion files. Don't edit directly, regenerate with `./bin/brew generate-man-completions` - `Library/Homebrew/`: Homebrew's core Ruby (with a little bash) logic. - `Library/Homebrew/bundle/`: Homebrew's `brew bundle` command. - `Library/Homebrew/cask/`: Homebrew's Cask classes and DSL. - `Library/Homebrew/extend/os/`: Homebrew's OS-specific (i.e. macOS or Linux) class extension logic. - `Library/Homebrew/formula.rb`: Homebrew's Formula class and DSL. - `docs/`: Documentation for Homebrew users, contributors and maintainers. Consult these for best practices and help. - `manpages/`: Generated `man` documentation files. Don't edit directly, regenerate with `./bin/brew generate-man-completions` - `package/`: Files to generate the macOS `.pkg` file. ## Key Guidelines 1. Follow Ruby and Bash best practices and idiomatic patterns. 2. Maintain existing code structure and organisation. 3. Write unit tests for new functionality. 4. Document public APIs and complex logic. 5. Suggest changes to the `docs/` folder when appropriate 6. Follow software principles such as DRY and YAGNI. 7. Keep diffs as minimal as possible. 8. Prefer shelling out via `HOMEBREW_BREW_FILE` instead of requiring `cmd/` or `dev-cmd` when composing brew commands. 9. Inline new or existing methods as methods or local variables unless they are reused 2+ times or needed for unit tests. Homebrew-brew-d7f73ce/CHANGELOG.md000066400000000000000000000003171517265720000165420ustar00rootroot00000000000000See Homebrew's [releases on GitHub](https://github.com/Homebrew/brew/releases) for the changelog. Release notes for major and minor releases can also be found in the [Homebrew blog](https://brew.sh/blog/). Homebrew-brew-d7f73ce/CLAUDE.md000066400000000000000000000000131517265720000162010ustar00rootroot00000000000000@AGENTS.md Homebrew-brew-d7f73ce/CODEOWNERS000066400000000000000000000012351517265720000163240ustar00rootroot00000000000000# Note that the naming of this file is incorrect for our case: these people do not "own" the provided files but are # people with write-access to this repository who wish to approve changes to these files. # # Their review is required to merge PRs that change these files. # # To be explicit: we will never accept changes to this file adding people from outside the Homebrew GitHub # organisation. If you are not a Homebrew maintainer: you do not personally "own" or "maintain" any files. # # Note: @Homebrew/plc does not have write-access to this repository, and therefore cannot be listed in this file. docs/Support-Tiers.md @Homebrew/lead-maintainers @MikeMcQuaid Homebrew-brew-d7f73ce/CONTRIBUTING.md000066400000000000000000000046031517265720000171640ustar00rootroot00000000000000# Contributing to Homebrew First time contributing to Homebrew? Read our [Code of Conduct](https://github.com/Homebrew/.github/blob/HEAD/CODE_OF_CONDUCT.md#code-of-conduct) and review [How to Open a Homebrew Pull Request](https://docs.brew.sh/How-To-Open-a-Homebrew-Pull-Request). ### Discuss, ask questions about or disagree with changes in Homebrew * [Homebrew/discussions](https://github.com/orgs/Homebrew/discussions) is the place for community discussions around Homebrew. * Our issues and pull requests are for maintainers and contributors to discuss work to be done, not users or contributors asking questions about Homebrew usage or disagreeing with changes already made. ### Report a bug * Run `brew update` (twice). * Run and read `brew doctor`. * Read the [Troubleshooting checklist](https://docs.brew.sh/Troubleshooting). * Ideally, open a pull request to fix it, describing both your problem and your proposed solution. * If not, open an issue on the formula's repository or on Homebrew/brew if it's not a formula-specific issue, but do not open both an issue and a pull request. ### Propose a feature * Ideally, open a pull request to implement it, describing both the problem it solves for you and your proposed solution. * If not, open an issue with a detailed description of your proposed feature, the motivation for it and alternatives considered. * Please note we may close this issue or ask you to create a pull request if this is not something we see as sufficiently high priority. * Any pull request claiming performance improvements (e.g. "this is faster") must include [Hyperfine](https://github.com/sharkdp/hyperfine) benchmark results demonstrating the improvement. ### "Artificial Intelligence"/Large Language Model (AI/LLM) usage We allow you to create issues and pull requests with AI/LLM with the following requirements: * You must disclose in the initial issue or pull request that you used AI/LLM and what tool/model/etc. you used. * You must review all AI/LLM generated code, prose, etc. content before you ask anyone in Homebrew to review it for you. * You must be able to address all pull request review comments, manually if the AI/LLM cannot do so for you. * Unless you are a maintainer, you may only have one AI-assisted/generated pull request open at a time. * If you reach the point where you feel unwilling or unable to do the above, please close your issue or pull request. Thanks! Homebrew-brew-d7f73ce/Dockerfile000066400000000000000000000101461517265720000167240ustar00rootroot00000000000000ARG version=22.04 # version is passed through by Docker. # shellcheck disable=SC2154 FROM ubuntu:"${version}" ARG DEBIAN_FRONTEND=noninteractive # Deterministic UID (first user). Helps with docker build cache ENV USER_ID=1000 # Delete the default ubuntu user & group UID=1000 GID=1000 in Ubuntu 23.04+ # that conflicts with the linuxbrew user RUN touch /var/mail/ubuntu && chown ubuntu /var/mail/ubuntu && userdel -r ubuntu; true # We don't want to manually pin versions, happy to use whatever # Ubuntu thinks is best. # hadolint ignore=DL3008 # `gh` installation taken from https://github.com/cli/cli/blob/trunk/docs/install_linux.md#debian-ubuntu-linux-raspberry-pi-os-apt # /etc/lsb-release is checked inside the container and sets DISTRIB_RELEASE. # We need `[` instead of `[[` because the shell is `/bin/sh`. # shellcheck disable=SC1091,SC2154,SC2292 RUN bash -c "for i in {1..5}; do apt-get update && break || sleep \$((i)); done" \ && apt-get install -y --no-install-recommends software-properties-common gnupg-agent \ && if [ "$(uname -m)" != aarch64 ]; then add-apt-repository -y ppa:git-core/ppa; fi \ && apt-get update \ && apt-get install -y --no-install-recommends \ acl \ bzip2 \ ca-certificates \ curl \ file \ fonts-dejavu-core \ g++ \ gawk \ git \ gpg \ less \ locales \ make \ netbase \ openssh-client \ patch \ skopeo \ sudo \ unzip \ uuid-runtime \ tzdata \ jq \ && if [ "$(. /etc/lsb-release; echo "${DISTRIB_RELEASE}" | cut -d. -f1)" -eq 22 ]; then apt-get install -y --no-install-recommends g++-12; fi \ && mkdir -p /etc/apt/keyrings \ && chmod 0755 /etc /etc/apt /etc/apt/keyrings \ && curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | tee /etc/apt/keyrings/githubcli-archive-keyring.gpg >/dev/null \ && chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \ && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list >/dev/null \ && apt-get update \ && apt-get install -y --no-install-recommends gh \ && apt-get remove --purge -y software-properties-common \ && apt-get autoremove --purge -y \ && rm -rf /var/lib/apt/lists/* \ && sed -i -E 's/^(USERGROUPS_ENAB\s+)yes$/\1no/' /etc/login.defs \ && localedef -i en_US -f UTF-8 en_US.UTF-8 \ && useradd -u "${USER_ID}" --create-home --shell /bin/bash --user-group linuxbrew \ && echo 'linuxbrew ALL=(ALL) NOPASSWD:ALL' >>/etc/sudoers \ && su - linuxbrew -c 'mkdir ~/.linuxbrew' USER linuxbrew COPY --chown=linuxbrew:linuxbrew . /home/linuxbrew/.linuxbrew/Homebrew ENV PATH="/home/linuxbrew/.linuxbrew/bin:/home/linuxbrew/.linuxbrew/sbin:${PATH}" \ XDG_CACHE_HOME=/home/linuxbrew/.cache WORKDIR /home/linuxbrew RUN --mount=type=cache,target=/tmp/homebrew-core,uid="${USER_ID}",sharing=locked \ # Clone the homebrew-core repo into /tmp/homebrew-core or pull latest changes if it exists git clone https://github.com/homebrew/homebrew-core /tmp/homebrew-core || { cd /tmp/homebrew-core && git pull; } \ && mkdir -p /home/linuxbrew/.linuxbrew/Homebrew/Library/Taps/homebrew/homebrew-core \ && cp -r /tmp/homebrew-core /home/linuxbrew/.linuxbrew/Homebrew/Library/Taps/homebrew/ RUN --mount=type=cache,target=/home/linuxbrew/.cache,uid="${USER_ID}" \ --mount=type=cache,target=/home/linuxbrew/.bundle,uid="${USER_ID}" \ mkdir -p \ .linuxbrew/bin \ .linuxbrew/etc \ .linuxbrew/include \ .linuxbrew/lib \ .linuxbrew/opt \ .linuxbrew/sbin \ .linuxbrew/share \ .linuxbrew/var/homebrew/linked \ .linuxbrew/Cellar \ && ln -s ../Homebrew/bin/brew .linuxbrew/bin/brew \ && git -C .linuxbrew/Homebrew remote set-url origin https://github.com/Homebrew/brew \ && git -C .linuxbrew/Homebrew fetch origin \ && HOMEBREW_NO_ANALYTICS=1 HOMEBREW_NO_AUTO_UPDATE=1 brew tap --force homebrew/core \ && brew install-bundler-gems --groups=all \ && brew cleanup \ && { git -C .linuxbrew/Homebrew config --unset gc.auto; true; } \ && { git -C .linuxbrew/Homebrew config --unset homebrew.devcmdrun; true; } \ && touch .linuxbrew/.homebrewdocker Homebrew-brew-d7f73ce/LICENSE.txt000066400000000000000000000024661517265720000165630ustar00rootroot00000000000000BSD 2-Clause License Copyright (c) 2009-present, Homebrew contributors All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Homebrew-brew-d7f73ce/Library/000077500000000000000000000000001517265720000163345ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/.rubocop.yml000066400000000000000000000317701517265720000206160ustar00rootroot00000000000000--- plugins: - rubocop-md: plugin_class_name: RuboCop::Markdown::Plugin - rubocop-performance: plugin_class_name: RuboCop::Performance::Plugin - rubocop-rspec: plugin_class_name: RuboCop::RSpec::Plugin - rubocop-sorbet: plugin_class_name: RuboCop::Sorbet::Plugin - test-prof: plugin_class_name: RuboCop::TestProf::Plugin require: - ./Homebrew/rubocops.rb inherit_mode: merge: - Include - Exclude AllCops: # Only bump this after the first tagged brew release with a new Ruby version, # otherwise taps will be prompted to use newer Ruby syntax too early. TargetRubyVersion: 4.0 NewCops: enable Include: - "**/*.rbi" Exclude: - "Homebrew/sorbet/rbi/{annotations,dsl,gems}/**/*.rbi" - "Homebrew/sorbet/rbi/parser*.rbi" - "Homebrew/bin/*" - "Homebrew/vendor/**/*" - "Taps/*/*/vendor/**/*" - "**/.github/copilot-instructions.md" # This should be treated the same as the `docs/` files. SuggestExtensions: rubocop-minitest: false Cask/Desc: Description: "Ensure that the desc stanza conforms to various content and style checks." Enabled: true Cask/HomepageUrlStyling: Description: "Ensure that the homepage url has the correct format and styling." Enabled: true Cask/StanzaGrouping: Description: "Ensure that cask stanzas are grouped correctly. More info at https://docs.brew.sh/Cask-Cookbook#stanza-order" Enabled: true Cask/StanzaOrder: Description: "Ensure that cask stanzas are sorted correctly. More info at https://docs.brew.sh/Cask-Cookbook#stanza-order" Enabled: true FormulaAudit: Enabled: true FormulaAuditStrict: Enabled: true Homebrew: Enabled: true Homebrew/Blank: Exclude: # Core extensions are not available here: - "Homebrew/startup/bootsnap.rb" Homebrew/CompactBlank: Exclude: # `blank?` is not necessarily available here: - "Homebrew/extend/enumerable.rb" Homebrew/NoFileutilsRmrf: Include: - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" # only used internally Homebrew/MoveToExtendOS: Enabled: false Homebrew/NegateInclude: Exclude: # `exclude?` is not available here: - "Homebrew/standalone/init.rb" - "Homebrew/rubocops/**/*" - "Homebrew/sorbet/tapioca/**/*" # `system` is a special case and aligns on second argument, so allow this for formulae. Layout/ArgumentAlignment: Exclude: - "Taps/*/*/*.rb" - "/**/Formula/**/*.rb" - "**/Formula/**/*.rb" # this is a bit less "floaty" Layout/CaseIndentation: EnforcedStyle: end # significantly less indentation involved; more consistent Layout/FirstArrayElementIndentation: EnforcedStyle: consistent Layout/FirstHashElementIndentation: EnforcedStyle: consistent # this is a bit less "floaty" Layout/EndAlignment: EnforcedStyleAlignWith: start_of_line # make our hashes consistent Layout/HashAlignment: EnforcedHashRocketStyle: table EnforcedColonStyle: table # Need to allow #: for external commands. Layout/LeadingCommentSpace: Exclude: - "Taps/*/*/cmd/*.rb" # GitHub diff UI wraps beyond 118 characters Layout/LineLength: Max: 118 # ignore manpage comments and long single-line strings AllowedPatterns: [ "#: ", ' url "', ' mirror "', " plist_options ", ' executable: "', ' font "', ' homepage "', ' name "', ' pkg "', ' pkgutil: "', " sha256 cellar: ", " sha256 ", "#{language}", "#{version.", ' "/Library/Application Support/', '"/Library/Caches/', '"/Library/PreferencePanes/', ' "~/Library/Application Support/', '"~/Library/Caches/', '"~/Library/Containers', '"~/Application Support', " was verified as official when first introduced to the cask", ] # conflicts with DSL-style path concatenation with `/` Layout/SpaceAroundOperators: Enabled: false # makes DSL usage ugly. Layout/SpaceBeforeBrackets: Exclude: - "**/*_spec.rb" - "Taps/*/*/*.rb" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" # favour parens-less DSL-style arguments Lint/AmbiguousBlockAssociation: Enabled: false Lint/DuplicateBranch: Exclude: - "Taps/*/*/*.rb" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" # so many of these in formulae and can't be autocorrected Lint/ParenthesesAsGroupedExpression: Exclude: - "Taps/*/*/*.rb" - "/**/Formula/**/*.rb" - "**/Formula/**/*.rb" # unused keyword arguments improve APIs Lint/UnusedMethodArgument: AllowUnusedKeywordArguments: true # These metrics didn't end up helping. Metrics: Enabled: false # Disabled because it breaks Sorbet: "The declaration for `with` is missing parameter(s): & (RuntimeError)" Naming/BlockForwarding: Enabled: false # Allow dashes in filenames. Naming/FileName: Regex: !ruby/regexp /^[\w\@\-\+\.]+(\.rb)?$/ # Implicitly allow EOS as we use it everywhere. Naming/HeredocDelimiterNaming: ForbiddenDelimiters: - END, EOD, EOF Naming/InclusiveLanguage: CheckStrings: true FlaggedTerms: slave: AllowedRegex: - "gitslave" # Used in formula `gitslave` - "log_slave" # Used in formula `ssdb` - "ssdb_slave" # Used in formula `ssdb` - "var_slave" # Used in formula `ssdb` - "patches/13_fix_scope_for_show_slave_status_data.patch" # Used in formula `mytop` Naming/MethodName: AllowedPatterns: - '\A(fetch_)?HEAD\?\Z' Naming/MethodParameterName: inherit_mode: merge: - AllowedNames # Allows a nicer API for boolean methods with side effects. Naming/PredicateMethod: AllowBangMethods: true # Both styles are used depending on context, # e.g. `sha256` and `something_countable_1`. Naming/VariableNumber: Enabled: false # Makes code less readable for minor performance increases. Performance/Caller: Enabled: false # Does not hinder readability, so might as well enable it. Performance/CaseWhenSplat: Enabled: true # Makes code less readable for minor performance increases. Performance/MethodObjectAsBlock: Enabled: false RSpec: Include: - "Homebrew/test/**/*" # Intentionally disabled as it doesn't fit with our code style. RSpec/AnyInstance: Enabled: false RSpec/IncludeExamples: Enabled: false RSpec/SpecFilePathFormat: Enabled: false RSpec/StubbedMock: Enabled: false RSpec/SubjectStub: Enabled: false # These were ever-growing numbers, not useful. RSpec/ExampleLength: Enabled: false RSpec/MultipleExpectations: Enabled: false RSpec/NestedGroups: Enabled: false RSpec/MultipleMemoizedHelpers: Enabled: false RSpec/DescribedClassModuleWrapping: Enabled: true # Annoying to have these autoremoved. RSpec/Focus: AutoCorrect: false # We use `allow(:foo).to receive(:bar)` everywhere. RSpec/MessageSpies: EnforcedStyle: receive RSpec/Output: Exclude: - "**/fixtures/**/*.rb" # These are legacy violations that we should try to fix. Sorbet/AllowIncompatibleOverride: Exclude: - "Homebrew/livecheck/strategy/*.rb" # Try getting rid of these. Sorbet/ConstantsFromStrings: Enabled: false # This is already the default Sorbet/FalseSigil: Enabled: false # We generally prefer to colo rbi files with the Ruby files they describe. Sorbet/ForbidRBIOutsideOfAllowedPaths: Enabled: false # T::Sig is monkey-patched into Module Sorbet/RedundantExtendTSig: Enabled: true Sorbet/StrictSigil: Enabled: true Exclude: - "Taps/**/*" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" - "Homebrew/bundle/{formula_dumper,checker,commands/exec}.rb" # These aren't typed: true yet. - "Homebrew/formula-analytics/pycall-setup.rbi" # Type stubs for external PyCall/InfluxDB dependencies. - "Homebrew/ignorable.rbi" # Workaround for Sorbet to allow aliasing `raise`. - "Homebrew/{standalone,startup}/*.rb" # These are loaded before sorbet-runtime - "Homebrew/test/**/*.rb" - "Homebrew/test/support/fixtures/rubocop@x.x.x.rbi" # Autogenerated test fixture for RuboCop types. - "Homebrew/utils/ruby_check_version_script.rb" # A standalone script. Sorbet/TrueSigil: Enabled: true Exclude: - "Taps/**/*" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" - "Homebrew/test/**/*.rb" # Require &&/|| instead of and/or Style/AndOr: EnforcedStyle: always # Disabled because it breaks Sorbet: "The declaration for `with` is missing parameter(s): & (RuntimeError)" Style/ArgumentsForwarding: Enabled: false # Avoid leaking resources. Style/AutoResourceCleanup: Enabled: true # This makes these a little more obvious. Style/BarePercentLiterals: EnforcedStyle: percent_q Style/BlockDelimiters: BracesRequiredMethods: - "sig" Style/ClassAndModuleChildren: Exclude: - "**/*.rbi" # Use consistent style for better readability. Style/CollectionMethods: Enabled: true # Don't allow cops to be disabled in casks and formulae. Style/DisableCopsWithinSourceCodeDirective: Enabled: true Include: - "Taps/*/*/*.rb" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" # The files actually scanned in this cop are in `Library/Homebrew/.rubocop.yml`. Style/Documentation: Exclude: - "Taps/**/*" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" - "**/*.rbi" # This is impossible to fix if the line exceeds the maximum length. Style/EmptyMethod: Exclude: - "**/*.rbi" # This is quite a large change, so don't enforce this yet for formulae. # We should consider doing so in the future, but be aware of the impact on third-party taps. Style/FetchEnvVar: Exclude: - "Taps/*/*/*.rb" - "/**/Formula/**/*.rb" - "**/Formula/**/*.rb" # Doesn't make sense for formulae with e.g. requirements. Style/OneClassPerFile: Exclude: - "**/*.rbi" - "Taps/*/*/*.rb" - "/**/Abstract/**/*.rb" - "**/Abstract/**/*.rb" - "/**/Formula/**/*.rb" - "**/Formula/**/*.rb" - "/**/developer/bin/*" - "**/developer/bin/*" # Not used for casks and formulae. Style/FrozenStringLiteralComment: EnforcedStyle: always Exclude: - "Taps/*/*/*.rb" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" - "Homebrew/test/**/Casks/**/*.rb" - "**/*.rbi" - "**/Brewfile" # potential for errors in formulae too high with this Style/GuardClause: Exclude: - "Taps/*/*/*.rb" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" # Allow for license expressions Style/HashAsLastArrayItem: Exclude: - "Taps/*/*/*.rb" - "/**/Formula/**/*.rb" - "**/Formula/**/*.rb" Style/InverseMethods: InverseMethods: :blank?: :present? Style/InvertibleUnlessCondition: Enabled: true InverseMethods: # Favor `if a != b` over `unless a == b` :==: :!= # Unset this (prefer `unless a.zero?` over `if a.nonzero?`) :zero?: :blank?: :present? # It's confusing to the ruby novice to support both `it` and `_1` Style/ItBlockParameter: EnforcedStyle: only_numbered_parameters Style/MutableConstant: # would rather freeze too much than too little EnforcedStyle: strict # Zero-prefixed octal literals are widely used and understood. Style/NumericLiteralPrefix: EnforcedOctalStyle: zero_only # Only require this for numbers >= `10_000_000_000`. Style/NumericLiterals: MinDigits: 11 Strict: true Style/OpenStructUse: Exclude: - "Taps/**/*" Style/OptionalBooleanParameter: AllowedMethods: # These are overrides of core library methods # see https://ruby-doc.org/3.3.4/Object.html#method-i-respond_to-3F - respond_to? - respond_to_missing? # Rescuing `StandardError` is an understood default. Style/RescueStandardError: EnforcedStyle: implicit # Returning `nil` is unnecessary. Style/ReturnNil: Enabled: true # We have no use for using `warn` because we # are calling Ruby with warnings disabled. Style/StderrPuts: Enabled: false # so many of these in formulae and can't be autocorrected Style/StringConcatenation: Exclude: - "Taps/*/*/*.rb" - "/**/{Formula,Casks}/**/*.rb" - "**/{Formula,Casks}/**/*.rb" # ruby style guide favorite Style/StringLiterals: EnforcedStyle: double_quotes # consistency with above Style/StringLiteralsInInterpolation: EnforcedStyle: double_quotes # Use consistent method names. Style/StringMethods: Enabled: true # Treating this the same as Style/MethodCallWithArgsParentheses Style/SuperWithArgsParentheses: Enabled: false # An array of symbols is more readable than a symbol array # and also allows for easier grepping. Style/SymbolArray: EnforcedStyle: brackets # make things a bit easier to read Style/TernaryParentheses: EnforcedStyle: require_parentheses_when_complex Style/TopLevelMethodDefinition: Enabled: true Exclude: - "Taps/**/*" # Trailing commas make diffs nicer. Style/TrailingCommaInArguments: EnforcedStyleForMultiline: comma Style/TrailingCommaInArrayLiteral: EnforcedStyleForMultiline: comma Style/TrailingCommaInHashLiteral: EnforcedStyleForMultiline: comma # `unless ... ||` and `unless ... &&` are hard to mentally parse Style/UnlessLogicalOperators: Enabled: true EnforcedStyle: forbid_logical_operators # a bit confusing to non-Rubyists but useful for longer arrays Style/WordArray: MinSize: 4 Homebrew-brew-d7f73ce/Library/Homebrew/000077500000000000000000000000001517265720000201045ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/.bundle/000077500000000000000000000000001517265720000214335ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/.bundle/config000066400000000000000000000003261517265720000226240ustar00rootroot00000000000000--- BUNDLE_BIN: "false" BUNDLE_CLEAN: "true" BUNDLE_DISABLE_SHARED_GEMS: "true" BUNDLE_FORCE_RUBY_PLATFORM: "false" BUNDLE_FORGET_CLI_OPTIONS: "true" BUNDLE_JOBS: "4" BUNDLE_PATH: "vendor/bundle" BUNDLE_RETRY: "3" Homebrew-brew-d7f73ce/Library/Homebrew/.rspec_parallel000066400000000000000000000004221517265720000230730ustar00rootroot00000000000000--format QuietProgressFormatter --format ParallelTests::RSpec::RuntimeLogger --out <%= ENV["PARALLEL_RSPEC_LOG_PATH"] %> --format RspecJunitFormatter --out test/junit/rspec<%= ENV["TEST_ENV_NUMBER"] %>.xml <%= "--format RSpec::Github::Formatter" if ENV["GITHUB_ACTIONS"] %> Homebrew-brew-d7f73ce/Library/Homebrew/.rubocop.yml000066400000000000000000000055241517265720000223640ustar00rootroot00000000000000inherit_from: - ../.rubocop.yml Bundler/GemFilename: Enabled: false Homebrew/MoveToExtendOS: Enabled: true Exclude: - "{test,requirements}/**/*" - "os.rb" # We don't use Sorbet for RSpec tests so let's disable this there. Sorbet/BlockMethodDefinition: Exclude: - test/**/* # Want to preserve our own API for these methods for now. Naming/PredicatePrefix: inherit_mode: merge: - AllowedMethods AllowedMethods: - is_32_bit? - is_64_bit? Naming/PredicateMethod: inherit_mode: merge: - WaywardPredicates WaywardPredicates: - size? Naming/MethodParameterName: AllowedNames: - go - uv # Only enforce documentation for public APIs. # Checked by the tests.yml syntax job Style/Documentation: AllowedConstants: - Homebrew Include: - abstract_command.rb - autobump_constants.rb - cask/cask.rb - cask/dsl.rb - cask/dsl/version.rb - cask/url.rb - development_tools.rb - download_strategy.rb - extend/ENV/super.rb - extend/kernel.rb - extend/pathname.rb - formula.rb - formula_assertions.rb - formula_free_port.rb - language/java.rb - language/node.rb - language/perl.rb - language/php.rb - language/python.rb - livecheck/strategy/apache.rb - livecheck/strategy/bitbucket.rb - livecheck/strategy/cpan.rb - livecheck/strategy/crate.rb - livecheck/strategy/extract_plist.rb - livecheck/strategy/git.rb - livecheck/strategy/github_latest.rb - livecheck/strategy/github_releases.rb - livecheck/strategy/gnome.rb - livecheck/strategy/gnu.rb - livecheck/strategy/hackage.rb - livecheck/strategy/json.rb - livecheck/strategy/launchpad.rb - livecheck/strategy/npm.rb - livecheck/strategy/page_match.rb - livecheck/strategy/pypi.rb - livecheck/strategy/sourceforge.rb - livecheck/strategy/sparkle.rb - livecheck/strategy/xml.rb - livecheck/strategy/xorg.rb - livecheck/strategy/yaml.rb - os.rb - os/mac.rb - resource.rb - startup/config.rb - utils/inreplace.rb - utils/output.rb - utils/shebang.rb - utils/string_inreplace_extension.rb - version.rb - tap.rb Homebrew/NegateInclude: Exclude: # YARD runs stand-alone. - yard/docstring_parser.rb Style/DocumentationMethod: Include: - "formula.rb" # Ensure @api public methods have proper YARD documentation. # No Include needed: the cop self-selects by finding @api public comments. Homebrew/PublicApiDocumentation: Enabled: true Exclude: - "vendor/**/*" # Ensure cookbook-referenced methods are annotated @api public. # No Include needed: the cop self-selects from cookbook rubydoc links. Homebrew/PublicApiCookbook: Enabled: true # Ensure official tap formulae don't use @api internal/@api private methods. FormulaAudit/NonPublicApiUsage: Enabled: true Homebrew-brew-d7f73ce/Library/Homebrew/.ruby-version000066400000000000000000000000061517265720000225450ustar00rootroot000000000000004.0.3 Homebrew-brew-d7f73ce/Library/Homebrew/.simplecov000077500000000000000000000066361517265720000221240ustar00rootroot00000000000000#!/usr/bin/env ruby # frozen_string_literal: true require "English" SimpleCov.enable_for_subprocesses true SimpleCov.start do coverage_dir File.expand_path("../test/coverage", File.realpath(__FILE__)) root File.expand_path("..", File.realpath(__FILE__)) command_name "brew" # enables branch coverage as well as, the default, line coverage enable_coverage :branch # enables coverage for `eval`ed code enable_coverage_for_eval # ensure that we always default to line coverage primary_coverage :line # We manage the result cache ourselves and the default of 10 minutes can be # too low causing results from some integration tests to be dropped. This # causes random fluctuations in test coverage. merge_timeout 86400 at_fork do # be quiet, the parent process will be in charge of output and checking coverage totals SimpleCov.print_error_status = false end excludes = ["test", "vendor"] subdirs = Dir.chdir(SimpleCov.root) { Pathname.glob("*") } .reject { |p| p.extname == ".rb" || excludes.include?(p.to_s) } .map { |p| "#{p}/**/*.rb" }.join(",") files = "#{SimpleCov.root}/{#{subdirs},*.rb}" if (integration_test_number = ENV.fetch("HOMEBREW_INTEGRATION_TEST", nil)) # This needs a unique name so it won't be overwritten command_name "brew_i:#{integration_test_number}" # be quiet, the parent process will be in charge of output and checking coverage totals SimpleCov.print_error_status = false SimpleCov.at_exit do # Just save result, but don't write formatted output. coverage_result = Coverage.result.dup Dir[files].each do |file| absolute_path = File.expand_path(file) coverage_result[absolute_path] ||= SimpleCov::SimulateCoverage.call(absolute_path) end simplecov_result = SimpleCov::Result.new(coverage_result) SimpleCov::ResultMerger.store_result(simplecov_result) # If an integration test raises a `SystemExit` exception on exit, # exit immediately using the same status code to avoid reporting # an error when expecting a non-successful exit status. raise if $ERROR_INFO.is_a?(SystemExit) end else command_name "brew:#{ENV.fetch("TEST_ENV_NUMBER", $PROCESS_ID)}" # Not using this during integration tests makes the tests 4x times faster # without changing the coverage. track_files files end add_filter %r{^/build\.rb$} add_filter %r{^/config\.rb$} add_filter %r{^/constants\.rb$} add_filter %r{^/postinstall\.rb$} add_filter %r{^/test\.rb$} add_filter %r{^/dev-cmd/tests\.rb$} add_filter %r{^/sorbet/} add_filter %r{^/test/} add_filter %r{^/vendor/} add_filter %r{^/yard/} require "rbconfig" host_os = RbConfig::CONFIG["host_os"] add_filter %r{/os/mac} unless host_os.include?("darwin") add_filter %r{/os/linux} unless host_os.include?("linux") # Add groups and the proper project name to the output. project_name "Homebrew" add_group "Cask", %r{^/cask(/|\.rb$)} add_group "Commands", [%r{/cmd/}, %r{^/dev-cmd/}] add_group "Extensions", %r{^/extend/} add_group "Livecheck", %r{^/livecheck(/|\.rb$)} add_group "OS", [%r{^/extend/os/}, %r{^/os/}] add_group "Requirements", %r{^/requirements/} add_group "RuboCops", %r{^/rubocops/} add_group "Unpack Strategies", %r{^/unpack_strategy(/|\.rb$)} add_group "Scripts", [ %r{^/brew\.rb$}, %r{^/build\.rb$}, %r{^/postinstall\.rb$}, %r{^/test\.rb$}, ] end Homebrew-brew-d7f73ce/Library/Homebrew/.yardopts000066400000000000000000000004241517265720000217520ustar00rootroot00000000000000--title "Homebrew Ruby API" --main README.md --markup markdown --no-private --plugin sorbet --load ./yard/docstring_parser.rb --template-path yard/templates --exclude sorbet/rbi/gems/ --exclude test/ --exclude vendor/ --exclude yard/ extend/os/**/*.rb **/*.rb **/*.rbi - *.md Homebrew-brew-d7f73ce/Library/Homebrew/Gemfile000066400000000000000000000053021517265720000213770ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" # The default case (no envs), should always be a restrictive bound on the lowest supported minor version. # This is the branch that Dependabot will use. if ENV.fetch("HOMEBREW_USE_RUBY_FROM_PATH", "").empty? ruby "~> 4.0.0" else ruby ">= 4.0.0" end # disallowed gems (should not be used) # * nokogiri - use rexml instead for XML parsing # installed gems (should all be require: false) # ALL gems that are not vendored should be in a group group :doc, optional: true do gem "redcarpet", require: false gem "yard", require: false gem "yard-sorbet", require: false end group :ast, optional: true do gem "rubocop-ast", require: false end group :formula_test, optional: true do gem "minitest", require: false end group :livecheck, optional: true do gem "ruby-progressbar", require: false end group :man, optional: true do gem "kramdown", require: false end group :pr_upload, :bottle, optional: true do gem "json_schemer", require: false end group :prof, optional: true do gem "ruby-prof", require: false gem "stackprof", require: false gem "vernier", require: false end group :pry, optional: true do gem "pry", require: false end group :style, optional: true do gem "rubocop", require: false gem "rubocop-md", require: false gem "rubocop-performance", require: false gem "rubocop-rspec", require: false gem "rubocop-sorbet", require: false end group :style, :tests, optional: true do gem "test-prof", require: false end group :tests, optional: true do gem "parallel_tests", require: false gem "rspec", require: false gem "rspec-core", require: false gem "rspec-expectations", require: false gem "rspec-github", require: false gem "rspec_junit_formatter", require: false gem "rspec-retry", require: false gem "rspec-sorbet", require: false gem "simplecov", require: false gem "simplecov-cobertura", require: false end group :typecheck, optional: true do gem "method_source", require: false gem "sorbet-static-and-runtime", require: false gem "spoom", require: false # TODO: remove < 0.19.0 when https://github.com/Shopify/rubydex/pull/725 is in a release gem "tapioca", "< 0.20.0", require: false end group :vscode, optional: true do gem "ruby-lsp", require: false end group :formula_analytics, optional: true do gem "pycall", require: false end group :contributions, optional: true do gem "csv", require: false end # shared gems (used by multiple groups) group :audit, :bump_unversioned_casks, :livecheck, optional: true do gem "rexml", require: false end # vendored gems (no group) gem "addressable" gem "base64" gem "concurrent-ruby" gem "patchelf" gem "plist" gem "ruby-macho" gem "sorbet-runtime" gem "warning" Homebrew-brew-d7f73ce/Library/Homebrew/Gemfile.lock000066400000000000000000000330411517265720000223270ustar00rootroot00000000000000GEM remote: https://rubygems.org/ specs: addressable (2.9.0) public_suffix (>= 2.0.2, < 8.0) ast (2.4.3) base64 (0.3.0) benchmark (0.5.0) bigdecimal (4.1.1) bindata (2.5.1) coderay (1.1.3) concurrent-ruby (1.3.6) csv (3.3.5) diff-lcs (1.6.2) docile (1.4.1) drb (2.2.3) elftools (1.3.1) bindata (~> 2) erubi (1.13.1) hana (1.3.7) io-console (0.8.2) json (2.19.3) json_schemer (2.5.0) bigdecimal hana (~> 1.3) regexp_parser (~> 2.0) simpleidn (~> 0.2) kramdown (2.5.2) rexml (>= 3.4.4) language_server-protocol (3.17.0.5) lint_roller (1.1.0) logger (1.7.0) method_source (1.1.0) minitest (6.0.4) drb (~> 2.0) prism (~> 1.5) netrc (0.11.0) ostruct (0.6.3) parallel (2.0.1) parallel_tests (5.7.0) parallel parser (3.3.11.1) ast (~> 2.4.1) racc patchelf (1.5.2) elftools (>= 1.3) logger (~> 1) plist (3.7.2) prism (1.9.0) pry (0.16.0) coderay (~> 1.1) method_source (~> 1.0) reline (>= 0.6.0) public_suffix (7.0.5) pycall (1.5.2) racc (1.8.1) rainbow (3.1.1) rbi (0.3.10) prism (~> 1.0) rbs (>= 4.0.1) rbs (4.0.2) logger prism (>= 1.6.0) tsort redcarpet (3.6.1) regexp_parser (2.12.0) reline (0.6.3) io-console (~> 0.5) require-hooks (0.2.3) rexml (3.4.4) rspec (3.13.2) rspec-core (~> 3.13.0) rspec-expectations (~> 3.13.0) rspec-mocks (~> 3.13.0) rspec-core (3.13.6) rspec-support (~> 3.13.0) rspec-expectations (3.13.5) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.13.0) rspec-github (3.0.0) rspec-core (~> 3.0) rspec-mocks (3.13.8) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.13.0) rspec-retry (0.6.2) rspec-core (> 3.3) rspec-sorbet (1.9.2) sorbet-runtime rspec-support (3.13.7) rspec_junit_formatter (0.6.0) rspec-core (>= 2, < 4, != 2.12.0) rubocop (1.86.1) json (~> 2.3) language_server-protocol (~> 3.17.0.2) lint_roller (~> 1.1.0) parallel (>= 1.10) parser (>= 3.3.0.2) rainbow (>= 2.2.2, < 4.0) regexp_parser (>= 2.9.3, < 3.0) rubocop-ast (>= 1.49.0, < 2.0) ruby-progressbar (~> 1.7) unicode-display_width (>= 2.4.0, < 4.0) rubocop-ast (1.49.1) parser (>= 3.3.7.2) prism (~> 1.7) rubocop-md (2.0.4) lint_roller (~> 1.1) rubocop (>= 1.72.1) rubocop-performance (1.26.1) lint_roller (~> 1.1) rubocop (>= 1.75.0, < 2.0) rubocop-ast (>= 1.47.1, < 2.0) rubocop-rspec (3.9.0) lint_roller (~> 1.1) rubocop (~> 1.81) rubocop-sorbet (0.12.0) lint_roller rubocop (>= 1.75.2) ruby-lsp (0.26.9) language_server-protocol (~> 3.17.0) prism (>= 1.2, < 2.0) rbs (>= 3, < 5) ruby-macho (5.0.0) ruby-prof (2.0.4) base64 ostruct ruby-progressbar (1.13.0) rubydex (0.1.0.beta12) rubydex (0.1.0.beta12-aarch64-linux) rubydex (0.1.0.beta12-arm64-darwin) rubydex (0.1.0.beta12-x86_64-linux) simplecov (0.22.0) docile (~> 1.1) simplecov-html (~> 0.11) simplecov_json_formatter (~> 0.1) simplecov-cobertura (3.1.0) rexml simplecov (~> 0.19) simplecov-html (0.13.2) simplecov_json_formatter (0.1.4) simpleidn (0.2.3) sorbet (0.6.13133) sorbet-static (= 0.6.13133) sorbet-runtime (0.6.13133) sorbet-static (0.6.13133-aarch64-linux) sorbet-static (0.6.13133-universal-darwin) sorbet-static (0.6.13133-x86_64-linux) sorbet-static-and-runtime (0.6.13133) sorbet (= 0.6.13133) sorbet-runtime (= 0.6.13133) spoom (1.7.12) erubi (>= 1.10.0) prism (>= 0.28.0) rbi (>= 0.3.3) rbs (>= 4.0.0.dev.5) rexml (>= 3.2.6) sorbet-static-and-runtime (>= 0.5.10187) thor (>= 0.19.2) stackprof (0.2.28) tapioca (0.19.0) benchmark bundler (>= 2.2.25) netrc (>= 0.11.0) parallel (>= 1.21.0) rbi (>= 0.3.7) require-hooks (>= 0.2.2) rubydex (>= 0.1.0.beta10) sorbet-static-and-runtime (>= 0.5.11087) spoom (>= 1.7.9) thor (>= 1.2.0) tsort test-prof (1.6.1) thor (1.5.0) tsort (0.2.0) unicode-display_width (3.2.0) unicode-emoji (~> 4.1) unicode-emoji (4.2.0) vernier (1.10.0) warning (1.5.0) yard (0.9.42) yard-sorbet (0.9.0) sorbet-runtime yard PLATFORMS aarch64-linux arm64-darwin x86_64-darwin x86_64-linux DEPENDENCIES addressable base64 concurrent-ruby csv json_schemer kramdown method_source minitest parallel_tests patchelf plist pry pycall redcarpet rexml rspec rspec-core rspec-expectations rspec-github rspec-retry rspec-sorbet rspec_junit_formatter rubocop rubocop-ast rubocop-md rubocop-performance rubocop-rspec rubocop-sorbet ruby-lsp ruby-macho ruby-prof ruby-progressbar simplecov simplecov-cobertura sorbet-runtime sorbet-static-and-runtime spoom stackprof tapioca (< 0.20.0) test-prof vernier warning yard yard-sorbet CHECKSUMS addressable (2.9.0) sha256=7fdf6ac3660f7f4e867a0838be3f6cf722ace541dd97767fa42bc6cfa980c7af ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383 base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b benchmark (0.5.0) sha256=465df122341aedcb81a2a24b4d3bd19b6c67c1530713fd533f3ff034e419236c bigdecimal (4.1.1) sha256=1c09efab961da45203c8316b0cdaec0ff391dfadb952dd459584b63ebf8054ca bindata (2.5.1) sha256=53186a1ec2da943d4cb413583d680644eb810aacbf8902497aac8f191fad9e58 coderay (1.1.3) sha256=dc530018a4684512f8f38143cd2a096c9f02a1fc2459edcfe534787a7fc77d4b concurrent-ruby (1.3.6) sha256=6b56837e1e7e5292f9864f34b69c5a2cbc75c0cf5338f1ce9903d10fa762d5ab csv (3.3.5) sha256=6e5134ac3383ef728b7f02725d9872934f523cb40b961479f69cf3afa6c8e73f diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962 docile (1.4.1) sha256=96159be799bfa73cdb721b840e9802126e4e03dfc26863db73647204c727f21e drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373 elftools (1.3.1) sha256=9d46fca49a7d5e821b9c80127b19d59e8ce578bfaa17b99c8ff259222686aaf8 erubi (1.13.1) sha256=a082103b0885dbc5ecf1172fede897f9ebdb745a4b97a5e8dc63953db1ee4ad9 hana (1.3.7) sha256=5425db42d651fea08859811c29d20446f16af196308162894db208cac5ce9b0d io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc json (2.19.3) sha256=289b0bb53052a1fa8c34ab33cc750b659ba14a5c45f3fcf4b18762dc67c78646 json_schemer (2.5.0) sha256=2f01fb4cce721a4e08dd068fc2030cffd0702a7f333f1ea2be6e8991f00ae396 kramdown (2.5.2) sha256=1ba542204c66b6f9111ff00dcc26075b95b220b07f2905d8261740c82f7f02fa language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87 logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203 method_source (1.1.0) sha256=181301c9c45b731b4769bc81e8860e72f9161ad7d66dd99103c9ab84f560f5c5 minitest (6.0.4) sha256=df1304664589d40f46089247fdc451f866b0ce0d7cae1457a15fc1eb7d48dca1 netrc (0.11.0) sha256=de1ce33da8c99ab1d97871726cba75151113f117146becbe45aa85cb3dabee3f ostruct (0.6.3) sha256=95a2ed4a4bd1d190784e666b47b2d3f078e4a9efda2fccf18f84ddc6538ed912 parallel (2.0.1) sha256=337782d3e39f4121e67563bf91dd8ece67f48923d90698614773a0ec9a5b2c7d parallel_tests (5.7.0) sha256=3f1762c46ca2c223b8af8ef877217f9d76974e191bfa934f2580b58bcf1d005c parser (3.3.11.1) sha256=d17ace7aabe3e72c3cc94043714be27cc6f852f104d81aa284c2281aecc65d54 patchelf (1.5.2) sha256=7efd746a52344be18c44b2fafeb80517c2c12e18dc24ac65d328b7c0609bc386 plist (3.7.2) sha256=d37a4527cc1116064393df4b40e1dbbc94c65fa9ca2eec52edf9a13616718a42 prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85 pry (0.16.0) sha256=d76c69065698ed1f85e717bd33d7942c38a50868f6b0673c636192b3d1b6054e public_suffix (7.0.5) sha256=1a8bb08f1bbea19228d3bed6e5ed908d1cb4f7c2726d18bd9cadf60bc676f623 pycall (1.5.2) sha256=759ece7b08007a20cf610fcfeb91b86cb77864f37ac343cc4fe25f14cca65ff3 racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a rbi (0.3.10) sha256=a4fd8e7786845ffd6533c512da2bda8722ce8565071ee4ad489b403f77c61d2b rbs (4.0.2) sha256=af75671e66cd03434cc546622741ebf83f6197ec4328375805306330bf78ef25 redcarpet (3.6.1) sha256=d444910e6aa55480c6bcdc0cdb057626e8a32c054c29e793fa642ba2f155f445 regexp_parser (2.12.0) sha256=35a916a1d63190ab5c9009457136ae5f3c0c7512d60291d0d1378ba18ce08ebb reline (0.6.3) sha256=1198b04973565b36ec0f11542ab3f5cfeeec34823f4e54cebde90968092b1835 require-hooks (0.2.3) sha256=224be5b4be0fd2a47cb73286c500da366704a54ec195b6627366380c950efac8 rexml (3.4.4) sha256=19e0a2c3425dfbf2d4fc1189747bdb2f849b6c5e74180401b15734bc97b5d142 rspec (3.13.2) sha256=206284a08ad798e61f86d7ca3e376718d52c0bc944626b2349266f239f820587 rspec-core (3.13.6) sha256=a8823c6411667b60a8bca135364351dda34cd55e44ff94c4be4633b37d828b2d rspec-expectations (3.13.5) sha256=33a4d3a1d95060aea4c94e9f237030a8f9eae5615e9bd85718fe3a09e4b58836 rspec-github (3.0.0) sha256=46af3cd8cad3e4434c20598752b6e721c5325e73d7e36e256379f0d3a85968af rspec-mocks (3.13.8) sha256=086ad3d3d17533f4237643de0b5c42f04b66348c28bf6b9c2d3f4a3b01af1d47 rspec-retry (0.6.2) sha256=6101ba23a38809811ae3484acde4ab481c54d846ac66d5037ccb40131a60d858 rspec-sorbet (1.9.2) sha256=28bf3969fa136ed22edd05b00d23aab52c276f2fcc89fccbb16b8fd0c48931c8 rspec-support (3.13.7) sha256=0640e5570872aafefd79867901deeeeb40b0c9875a36b983d85f54fb7381c47c rspec_junit_formatter (0.6.0) sha256=40dde674e6ae4e6cc0ff560da25497677e34fefd2338cc467a8972f602b62b15 rubocop (1.86.1) sha256=44415f3f01d01a21e01132248d2fd0867572475b566ca188a0a42133a08d4531 rubocop-ast (1.49.1) sha256=4412f3ee70f6fe4546cc489548e0f6fcf76cafcfa80fa03af67098ffed755035 rubocop-md (2.0.4) sha256=0d076b6b5e99dea2ddc928c4bd702497decb9a8400da7808091e02ebcafcfb93 rubocop-performance (1.26.1) sha256=cd19b936ff196df85829d264b522fd4f98b6c89ad271fa52744a8c11b8f71834 rubocop-rspec (3.9.0) sha256=8fa70a3619408237d789aeecfb9beef40576acc855173e60939d63332fdb55e2 rubocop-sorbet (0.12.0) sha256=195521e132500555819313df5accaaf56bf721a63de3e5b7b1d0b25f696b1f39 ruby-lsp (0.26.9) sha256=33a01c001c00a76b4e821efc04ed7572983430f31ca5d6f3e343d0b6ccab4129 ruby-macho (5.0.0) sha256=b894c3d9e8fb1abca03cb1d3a0e57e493e0315074bc51c128bce822a8a09a327 ruby-prof (2.0.4) sha256=42190ff6870e055a9d58b39df63e83442113ef7169c0e27b599942c3f15d1435 ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33 rubydex (0.1.0.beta12) sha256=3c08753ce69ab17999c3e65209180fc2801e5b6e85a2d0064ceda881a9a85d17 rubydex (0.1.0.beta12-aarch64-linux) sha256=4ec09c4ecf710a1b522e63d6e5c1506f945719b452dad23db48ece28d911ab25 rubydex (0.1.0.beta12-arm64-darwin) sha256=d565632fa825db57191cef3865bf361339a0f82fc465e46aec3793fd858beeb1 rubydex (0.1.0.beta12-x86_64-linux) sha256=9034afc1ddb612a74c4242f566facc910e16bbde010e5855d6ca45b60d3ef757 simplecov (0.22.0) sha256=fe2622c7834ff23b98066bb0a854284b2729a569ac659f82621fc22ef36213a5 simplecov-cobertura (3.1.0) sha256=6d7f38aa32c965ca2174b2e5bd88cb17138eaf629518854976ac50e628925dc5 simplecov-html (0.13.2) sha256=bd0b8e54e7c2d7685927e8d6286466359b6f16b18cb0df47b508e8d73c777246 simplecov_json_formatter (0.1.4) sha256=529418fbe8de1713ac2b2d612aa3daa56d316975d307244399fa4838c601b428 simpleidn (0.2.3) sha256=08ce96f03fa1605286be22651ba0fc9c0b2d6272c9b27a260bc88be05b0d2c29 sorbet (0.6.13133) sha256=007adb46ffb81b4ef1ae27b2df7688b9e75c546eaa29e911222e9741dec8f932 sorbet-runtime (0.6.13133) sha256=f910fa20b6cdbe2437e22f897cba6cd89b4bc766dcb1eecc5eefccb2b7fc2c08 sorbet-static (0.6.13133-aarch64-linux) sha256=82744a76887941bf763d0a71a3f77f017cb18fa4ebae2003561e3db6dd1ef074 sorbet-static (0.6.13133-universal-darwin) sha256=b4bd4dcd23f3067772105587c4844ac7851b6e30248df8372852b14fcc50ade8 sorbet-static (0.6.13133-x86_64-linux) sha256=fb240e31420522011edb693e88b2b19afe7ae4cf709c51eeb3626808a0a186c9 sorbet-static-and-runtime (0.6.13133) sha256=10d0a77ce4205b62b2b4c92c0adb71f8d849bf8fc5f01c17191a6df04e14985d spoom (1.7.12) sha256=67f0b1f835158dba4f19c03ff75b7b7e285dce9165b7b77c2c78cbf54ebf3013 stackprof (0.2.28) sha256=4ec2ace02f386012b40ca20ef80c030ad711831f59511da12e83b34efb0f9a04 tapioca (0.19.0) sha256=c519b09d4a0a61c550955bd007afac09fd8a7d5096557cb8ca6ef330393e4a5d test-prof (1.6.1) sha256=0332d9c39a7c118ed942b2db582f055d9f24964d150004ec6b964d2fa262499e thor (1.5.0) sha256=e3a9e55fe857e44859ce104a84675ab6e8cd59c650a49106a05f55f136425e73 tsort (0.2.0) sha256=9650a793f6859a43b6641671278f79cfead60ac714148aabe4e3f0060480089f unicode-display_width (3.2.0) sha256=0cdd96b5681a5949cdbc2c55e7b420facae74c4aaf9a9815eee1087cb1853c42 unicode-emoji (4.2.0) sha256=519e69150f75652e40bf736106cfbc8f0f73aa3fb6a65afe62fefa7f80b0f80f vernier (1.10.0) sha256=5b1dc57012e08ed23e14f4d2943540140d454aa8434c7c35e7eb97befd4969bf warning (1.5.0) sha256=0f12c49fea0c06757778eefdcc7771e4fd99308901e3d55c504d87afdd718c53 yard (0.9.42) sha256=4e2be01f8623556093497731d44c801e600d7c9759ec7a35a2dd5dd83bbbba68 yard-sorbet (0.9.0) sha256=03d1aa461b9e9c82b886919a13aa3e09fcf4d1852239d2967ed97e92723ffe21 RUBY VERSION ruby 4.0.3 BUNDLED WITH 4.0.6 Homebrew-brew-d7f73ce/Library/Homebrew/PATH.rb000066400000000000000000000043551517265720000211740ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "forwardable" # Representation of a `*PATH` environment variable. class PATH include Enumerable extend Forwardable extend T::Generic delegate each: :@paths Elem = type_member(:out) { { fixed: String } } Element = T.type_alias { T.nilable(T.any(Pathname, String, PATH)) } private_constant :Element Elements = T.type_alias { T.any(Element, T::Array[Element]) } sig { params(paths: Elements).void } def initialize(*paths) @paths = T.let(parse(paths), T::Array[String]) end sig { params(paths: Elements).returns(T.self_type) } def prepend(*paths) @paths = parse(paths + @paths) self end sig { params(paths: Elements).returns(T.self_type) } def append(*paths) @paths = parse(@paths + paths) self end sig { params(index: Integer, paths: Elements).returns(T.self_type) } def insert(index, *paths) @paths = parse(@paths.insert(index, *paths)) self end sig { params(block: T.proc.params(arg0: String).returns(BasicObject)).returns(T.self_type) } def select(&block) self.class.new(@paths.select(&block)) end sig { params(block: T.proc.params(arg0: String).returns(BasicObject)).returns(T.self_type) } def reject(&block) self.class.new(@paths.reject(&block)) end sig { returns(T::Array[String]) } def to_ary @paths.dup.to_ary end alias to_a to_ary sig { returns(String) } def to_str @paths.join(File::PATH_SEPARATOR) end sig { returns(String) } def to_s = to_str sig { params(other: T.untyped).returns(T::Boolean) } def ==(other) (other.respond_to?(:to_ary) && to_ary == other.to_ary) || (other.respond_to?(:to_str) && to_str == other.to_str) || false end sig { returns(T::Boolean) } def empty? @paths.empty? end sig { returns(T.nilable(T.self_type)) } def existing existing_path = select { File.directory?(it) } # return nil instead of empty PATH, to unset environment variables existing_path unless existing_path.empty? end private sig { params(paths: T::Array[Elements]).returns(T::Array[String]) } def parse(paths) paths.flatten .compact .flat_map { |p| Pathname(p).to_path.split(File::PATH_SEPARATOR) } .uniq end end Homebrew-brew-d7f73ce/Library/Homebrew/README.md000066400000000000000000000007401517265720000213640ustar00rootroot00000000000000# Homebrew Ruby API This is the API for [Homebrew](https://github.com/Homebrew). The main class you should look at is the {Formula} class (and classes linked from there). That's the class that's used to create Homebrew formulae (i.e. package descriptions). Assume anything else you stumble upon is private. You may also find the [Formula Cookbook](https://docs.brew.sh/Formula-Cookbook) and [Ruby Style Guide](https://rubystyle.guide) helpful in creating formulae. Good luck! Homebrew-brew-d7f73ce/Library/Homebrew/abstract_command.rb000066400000000000000000000051701517265720000237350ustar00rootroot00000000000000# typed: strong # frozen_string_literal: true require "cli/parser" require "shell_command" require "utils/output" module Homebrew # Subclass this to implement a `brew` command. This is preferred to declaring a named function in the `Homebrew` # module, because: # # - Each Command lives in an isolated namespace. # - Each Command implements a defined interface. # - `args` is available as an instance method and thus does not need to be passed as an argument to helper methods. # - Subclasses no longer need to reference `CLI::Parser` or parse args explicitly. # # To subclass, implement a `run` method and provide a `cmd_args` block to document the command and its allowed args. # To generate method signatures for command args, run `brew typecheck --update`. # # @api public class AbstractCommand extend T::Helpers include Utils::Output::Mixin abstract! class << self sig { returns(T.nilable(T.class_of(CLI::Args))) } attr_reader :args_class sig { returns(String) } def command_name require "utils" Utils.underscore(T.must(name).split("::").fetch(-1)) .tr("_", "-") .delete_suffix("-cmd") end # @return the AbstractCommand subclass associated with the brew CLI command name. sig { params(name: String).returns(T.nilable(T.class_of(AbstractCommand))) } def command(name) = subclasses.find { it.command_name == name } sig { returns(T::Boolean) } def dev_cmd? = T.must(name).start_with?("Homebrew::DevCmd") sig { returns(T::Boolean) } def ruby_cmd? = !include?(Homebrew::ShellCommand) sig { returns(CLI::Parser) } def parser = CLI::Parser.new(self, &@parser_block) private # The description and arguments of the command should be defined within this block. # # @api public sig { params(block: T.proc.bind(CLI::Parser).void).void } def cmd_args(&block) @parser_block = T.let(block, T.nilable(T.proc.void)) @args_class = T.let(const_set(:Args, Class.new(CLI::Args)), T.nilable(T.class_of(CLI::Args))) end end sig { returns(CLI::Args) } attr_reader :args sig { params(argv: T::Array[String]).void } def initialize(argv = ARGV.freeze) @args = T.let(self.class.parser.parse(argv), CLI::Args) end # This method will be invoked when the command is run. # # @api public sig { abstract.void } def run; end end module Cmd # The command class for `brew` itself, allowing its args to be parsed. class Brew < AbstractCommand sig { override.void } def run; end end end end Homebrew-brew-d7f73ce/Library/Homebrew/aliases/000077500000000000000000000000001517265720000215255ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/aliases/alias.rb000066400000000000000000000062101517265720000231420ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "fileutils" require "utils/output" module Homebrew module Aliases class Alias include ::Utils::Output::Mixin sig { returns(String) } attr_accessor :name sig { returns(T.nilable(String)) } attr_accessor :command sig { params(name: String, command: T.nilable(String)).void } def initialize(name, command = nil) @name = T.let(name.strip, String) @command = T.let(nil, T.nilable(String)) @script = T.let(nil, T.nilable(Pathname)) @symlink = T.let(nil, T.nilable(Pathname)) @command = if command&.start_with?("!", "%") command[1..] elsif command "brew #{command}" end end sig { returns(T::Boolean) } def reserved? RESERVED.include? name end sig { returns(T::Boolean) } def cmd_exists? path = which("brew-#{name}.rb") || which("brew-#{name}") !path.nil? && path.realpath.parent != HOMEBREW_ALIASES end sig { returns(Pathname) } def script @script ||= Pathname.new("#{HOMEBREW_ALIASES}/#{name.gsub(/\W/, "_")}") end sig { returns(Pathname) } def symlink @symlink ||= Pathname.new("#{HOMEBREW_PREFIX}/bin/brew-#{name}") end sig { returns(T::Boolean) } def valid_symlink? symlink.realpath.parent == HOMEBREW_ALIASES.realpath rescue NameError false end sig { void } def link FileUtils.rm symlink if File.symlink? symlink FileUtils.ln_s script, symlink end sig { params(opts: T::Hash[Symbol, T::Boolean]).void } def write(opts = {}) odie "'#{name}' is a reserved command. Sorry." if reserved? odie "'brew #{name}' already exists. Sorry." if cmd_exists? return if !opts[:override] && script.exist? content = if command <<~EOS #: * `#{name}` [args...] #: `brew #{name}` is an alias for `#{command}` #{command} $* EOS else <<~EOS #: * `#{name}` [args...] #: `brew #{name}` is an alias for *command* # This is a Homebrew alias script. It'll be called when the user # types `brew #{name}`. Any remaining arguments are passed to # this script. You can retrieve those with $*, or only the first # one with $1. Please keep your script on one line. # TODO: Replace the line below with your script echo "Hello I'm 'brew "#{name}"' and my args are:" $* EOS end script.open("w") do |f| f.write <<~EOS #! #{`which bash`.chomp} # alias: brew #{name} #{content} EOS end script.chmod 0744 link end sig { void } def remove odie "'brew #{name}' is not aliased to anything." if !symlink.exist? || !valid_symlink? script.unlink symlink.unlink end sig { void } def edit write(override: false) exec_editor script.to_s end end end end Homebrew-brew-d7f73ce/Library/Homebrew/aliases/aliases.rb000066400000000000000000000043161517265720000234770ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "aliases/alias" require "utils/output" module Homebrew module Aliases extend Utils::Output::Mixin RESERVED = T.let(( Commands.internal_commands + Commands.internal_developer_commands + Commands.internal_commands_aliases + %w[alias unalias] ).freeze, T::Array[String]) sig { void } def self.init FileUtils.mkdir_p HOMEBREW_ALIASES end sig { params(name: String, command: String).void } def self.add(name, command) new_alias = Alias.new(name, command) odie "alias 'brew #{name}' already exists!" if new_alias.script.exist? new_alias.write end sig { params(name: String).void } def self.remove(name) Alias.new(name).remove end sig { params(only: T::Array[String], block: T.proc.params(name: String, command: String).void).void } def self.each(only, &block) Dir["#{HOMEBREW_ALIASES}/*"].each do |path| next if path.end_with? "~" # skip Emacs-like backup files next if File.directory?(path) _shebang, meta, *lines = File.readlines(path) name = T.must(meta)[/alias: brew (\S+)/, 1] || File.basename(path) next if !only.empty? && only.exclude?(name) lines.reject! { |line| line.start_with?("#") || line =~ /^\s*$/ } first_line = lines.fetch(0) command = first_line.chomp command.sub!(/ \$\*$/, "") if command.start_with? "brew " command.sub!(/^brew /, "") else command = "!#{command}" end yield name, command if block.present? end end sig { params(aliases: String).void } def self.show(*aliases) each([*aliases]) do |name, command| puts "brew alias #{name}='#{command}'" existing_alias = Alias.new(name, command) existing_alias.link unless existing_alias.symlink.exist? end end sig { params(name: String, command: T.nilable(String)).void } def self.edit(name, command = nil) Alias.new(name, command).write unless command.nil? Alias.new(name, command).edit end sig { void } def self.edit_all exec_editor(*Dir[HOMEBREW_ALIASES]) end end end Homebrew-brew-d7f73ce/Library/Homebrew/api.rb000066400000000000000000000326071517265720000212120ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "api/analytics" require "api/cask" require "api/formula" require "api/internal" require "api/formula_struct" require "api/cask_struct" require "base64" require "download_queue" require "utils/output" module Homebrew # Helper functions for using Homebrew's formulae.brew.sh API. module API extend Utils::Output::Mixin extend T::Generic extend Cachable # Sorbet type members are mutable by design and cannot be frozen. # rubocop:disable Style/MutableConstant Cache = type_template { { fixed: T::Hash[String, T.untyped] } } # rubocop:enable Style/MutableConstant HOMEBREW_CACHE_API = T.let((HOMEBREW_CACHE/"api").freeze, Pathname) HOMEBREW_CACHE_API_SOURCE = T.let((HOMEBREW_CACHE/"api-source").freeze, Pathname) DEFAULT_API_STALE_SECONDS = T.let(7 * 24 * 60 * 60, Integer) # 7 days sig { params(endpoint: String).returns(T::Hash[String, T.untyped]) } def self.fetch(endpoint) return cache[endpoint] if cache.present? && cache.key?(endpoint) api_url = "#{Homebrew::EnvConfig.api_domain}/#{endpoint}" output = Utils::Curl.curl_output("--fail", api_url) if !output.success? && Homebrew::EnvConfig.api_domain != HOMEBREW_API_DEFAULT_DOMAIN # Fall back to the default API domain and try again api_url = "#{HOMEBREW_API_DEFAULT_DOMAIN}/#{endpoint}" output = Utils::Curl.curl_output("--fail", api_url) end raise ArgumentError, "No file found at: #{Tty.underline}#{api_url}#{Tty.reset}" unless output.success? cache[endpoint] = JSON.parse(output.stdout, freeze: true) rescue JSON::ParserError raise ArgumentError, "Invalid JSON file: #{Tty.underline}#{api_url}#{Tty.reset}" end sig { params(target: Pathname, stale_seconds: T.nilable(Integer)).returns(T::Boolean) } def self.skip_download?(target:, stale_seconds:) return true if Homebrew.running_as_root_but_not_owned_by_root? return false if !target.exist? || target.empty? return true unless stale_seconds (Time.now - stale_seconds) < target.mtime end sig { params( endpoint: String, target: Pathname, stale_seconds: T.nilable(Integer), download_queue: DownloadQueue, enqueue: T::Boolean, ).returns([T.any(T::Array[T.untyped], T::Hash[String, T.untyped]), T::Boolean]) } def self.fetch_json_api_file(endpoint, target: HOMEBREW_CACHE_API/endpoint, stale_seconds: nil, download_queue: Homebrew.default_download_queue, enqueue: false) # Lazy-load dependency. require "development_tools" retry_count = 0 url = "#{Homebrew::EnvConfig.api_domain}/#{endpoint}" default_url = "#{HOMEBREW_API_DEFAULT_DOMAIN}/#{endpoint}" if Homebrew.running_as_root_but_not_owned_by_root? && (!target.exist? || target.empty?) odie "Need to download #{url} but cannot as root! Run `brew update` without `sudo` first then try again." end curl_args = Utils::Curl.curl_args(retries: 0) + %W[ --compressed --speed-limit #{ENV.fetch("HOMEBREW_CURL_SPEED_LIMIT")} --speed-time #{ENV.fetch("HOMEBREW_CURL_SPEED_TIME")} ] insecure_download = DevelopmentTools.ca_file_substitution_required? || DevelopmentTools.curl_substitution_required? skip_download = skip_download?(target:, stale_seconds:) if enqueue unless skip_download require "api/json_download" download = Homebrew::API::JSONDownload.new(endpoint, target:, stale_seconds:) download_queue.enqueue(download) end return [{}, false] end json_data = begin begin args = curl_args.dup args.prepend("--time-cond", target.to_s) if target.exist? && !target.empty? if insecure_download opoo DevelopmentTools.insecure_download_warning(endpoint) args.append("--insecure") end unless skip_download ohai "Downloading #{url}" if $stdout.tty? && !Context.current.quiet? # Disable retries here, we handle them ourselves below. Utils::Curl.curl_download(*args, url, to: target, retries: 0, show_error: false) end rescue ErrorDuringExecution if url == default_url raise unless target.exist? raise if target.empty? elsif retry_count.zero? || !target.exist? || target.empty? # Fall back to the default API domain and try again # This block will be executed only once, because we set `url` to `default_url` url = default_url target.unlink if target.exist? && target.empty? skip_download = false retry end opoo "#{target.basename}: update failed, falling back to cached version." end mtime = insecure_download ? Time.new(1970, 1, 1) : Time.now FileUtils.touch(target, mtime:) unless skip_download # Can use `target.read` again when/if https://github.com/sorbet/sorbet/pull/8999 is merged/released. JSON.parse(File.read(target, encoding: Encoding::UTF_8), freeze: true) rescue JSON::ParserError target.unlink retry_count += 1 skip_download = false odie "Cannot download non-corrupt #{url}!" if retry_count > Homebrew::EnvConfig.curl_retries.to_i retry end if endpoint.end_with?(".jws.json") success, data = verify_and_parse_jws(json_data) unless success target.unlink odie <<~EOS Failed to verify integrity (#{data}) of: #{url} Potential MITM attempt detected. Please run `brew update` and try again. EOS end [data, !skip_download] else [json_data, !skip_download] end end sig { params(json: T::Hash[String, T.untyped], bottle_tag: ::Utils::Bottles::Tag).returns(T::Hash[String, T.untyped]) } def self.merge_variations(json, bottle_tag: T.unsafe(nil)) return json unless json.key?("variations") bottle_tag ||= Homebrew::SimulateSystem.current_tag if (variation = json.dig("variations", bottle_tag.to_s).presence) || (variation = json.dig("variations", bottle_tag.to_sym).presence) json = json.merge(variation) end json.except("variations") end sig { void } def self.fetch_api_files! download_queue = Homebrew::DownloadQueue.new stale_seconds = if ENV["HOMEBREW_API_UPDATED"].present? || (Homebrew::EnvConfig.no_auto_update? && !Homebrew::EnvConfig.force_api_auto_update?) nil elsif Homebrew.auto_update_command? Homebrew::EnvConfig.api_auto_update_secs.to_i else DEFAULT_API_STALE_SECONDS end if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.fetch_packages_api!(download_queue:, stale_seconds:, enqueue: true) else Homebrew::API::Formula.fetch_api!(download_queue:, stale_seconds:, enqueue: true) Homebrew::API::Formula.fetch_tap_migrations!(download_queue:, stale_seconds: DEFAULT_API_STALE_SECONDS, enqueue: true) Homebrew::API::Cask.fetch_api!(download_queue:, stale_seconds:, enqueue: true) Homebrew::API::Cask.fetch_tap_migrations!(download_queue:, stale_seconds: DEFAULT_API_STALE_SECONDS, enqueue: true) end ENV["HOMEBREW_API_UPDATED"] = "1" begin download_queue.fetch ensure download_queue.shutdown end end sig { void } def self.write_names_and_aliases if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.write_formula_names_and_aliases Homebrew::API::Internal.write_cask_names else Homebrew::API::Formula.write_names_and_aliases Homebrew::API::Cask.write_names end end sig { params(names: T::Array[String], type: String, regenerate: T::Boolean).returns(T::Boolean) } def self.write_names_file!(names, type, regenerate:) names_path = HOMEBREW_CACHE_API/"#{type}_names.txt" if !names_path.exist? || regenerate names_path.unlink if names_path.exist? names_path.write(names.sort.join("\n")) return true end false end sig { params(aliases: T::Hash[String, String], type: String, regenerate: T::Boolean).returns(T::Boolean) } def self.write_aliases_file!(aliases, type, regenerate:) aliases_path = HOMEBREW_CACHE_API/"#{type}_aliases.txt" if !aliases_path.exist? || regenerate aliases_text = aliases.map do |alias_name, real_name| "#{alias_name}|#{real_name}" end aliases_path.unlink if aliases_path.exist? aliases_path.write(aliases_text.sort.join("\n")) return true end false end sig { params(json_data: T::Hash[String, T.untyped]) .returns([T::Boolean, T.any(String, T::Array[T.untyped], T::Hash[String, T.untyped])]) } private_class_method def self.verify_and_parse_jws(json_data) signatures = json_data["signatures"] homebrew_signature = signatures&.find { |sig| sig.dig("header", "kid") == "homebrew-1" } return false, "key not found" if homebrew_signature.nil? header = JSON.parse(Base64.urlsafe_decode64(homebrew_signature["protected"])) if header["alg"] != "PS512" || header["b64"] != false # NOTE: nil has a meaning of true return false, "invalid algorithm" end require "openssl" pubkey = OpenSSL::PKey::RSA.new((HOMEBREW_LIBRARY_PATH/"api/homebrew-1.pem").read) signing_input = "#{homebrew_signature["protected"]}.#{json_data["payload"]}" unless pubkey.verify_pss("SHA512", Base64.urlsafe_decode64(homebrew_signature["signature"]), signing_input, salt_length: :digest, mgf1_hash: "SHA512") return false, "signature mismatch" end [true, JSON.parse(json_data["payload"], freeze: true)] end sig { params(path: Pathname).returns(T.nilable(Tap)) } def self.tap_from_source_download(path) path = path.expand_path source_relative_path = path.relative_path_from(Homebrew::API::HOMEBREW_CACHE_API_SOURCE) return if source_relative_path.to_s.start_with?("../") org, repo = source_relative_path.each_filename.first(2) return if org.blank? || repo.blank? Tap.fetch(org, repo) end sig { returns(T::Array[String]) } def self.formula_names if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.formula_hashes.keys else Homebrew::API::Formula.all_formulae.keys end end sig { returns(T::Hash[String, String]) } def self.formula_aliases if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.formula_aliases else Homebrew::API::Formula.all_aliases end end sig { returns(T::Hash[String, String]) } def self.formula_renames if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.formula_renames else Homebrew::API::Formula.all_renames end end sig { returns(T::Hash[String, String]) } def self.formula_tap_migrations if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.formula_tap_migrations else Homebrew::API::Formula.tap_migrations end end sig { returns(Pathname) } def self.cached_formula_json_file_path if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.cached_packages_json_file_path else Homebrew::API::Formula.cached_json_file_path end end sig { returns(T::Array[String]) } def self.cask_tokens if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.cask_hashes.keys else Homebrew::API::Cask.all_casks.keys end end sig { returns(T::Hash[String, String]) } def self.cask_renames if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.cask_renames else Homebrew::API::Cask.all_renames end end sig { returns(T::Hash[String, String]) } def self.cask_tap_migrations if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.cask_tap_migrations else Homebrew::API::Cask.tap_migrations end end sig { returns(Pathname) } def self.cached_cask_json_file_path if Homebrew::EnvConfig.use_internal_api? Homebrew::API::Internal.cached_packages_json_file_path else Homebrew::API::Cask.cached_json_file_path end end end sig { type_parameters(:U).params(block: T.proc.returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) } def self.with_no_api_env(&block) return yield if Homebrew::EnvConfig.no_install_from_api? with_env(HOMEBREW_NO_INSTALL_FROM_API: "1", HOMEBREW_AUTOMATICALLY_SET_NO_INSTALL_FROM_API: "1", &block) end sig { type_parameters(:U).params( condition: T::Boolean, block: T.proc.returns(T.type_parameter(:U)), ).returns(T.type_parameter(:U)) } def self.with_no_api_env_if_needed(condition, &block) return yield unless condition with_no_api_env(&block) end end Homebrew-brew-d7f73ce/Library/Homebrew/api/000077500000000000000000000000001517265720000206555ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/api/analytics.rb000066400000000000000000000010251517265720000231670ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Homebrew module API # Helper functions for using the analytics JSON API. module Analytics class << self sig { returns(String) } def analytics_api_path "analytics" end sig { params(category: String, days: T.any(Integer, String)).returns(T::Hash[String, T.untyped]) } def fetch(category, days) Homebrew::API.fetch "#{analytics_api_path}/#{category}/#{days}d.json" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/cask.rb000066400000000000000000000123271517265720000221300ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cachable" require "api" require "api/source_download" require "download_queue" require "api/cask/cask_struct_generator" module Homebrew module API # Helper functions for using the cask JSON API. module Cask extend T::Generic extend Cachable # Sorbet type members are mutable by design and cannot be frozen. # rubocop:disable Style/MutableConstant Cache = type_template { { fixed: T::Hash[String, T.untyped] } } # rubocop:enable Style/MutableConstant DEFAULT_API_FILENAME = "cask.jws.json" private_class_method :cache sig { params(name: String).returns(T::Hash[String, T.untyped]) } def self.cask_json(name) fetch_cask_json! name if !cache.key?("cask_json") || !cache.fetch("cask_json").key?(name) cache.fetch("cask_json").fetch(name) end sig { params(name: String).void } def self.fetch_cask_json!(name) endpoint = "cask/#{name}.json" json_cask, updated = Homebrew::API.fetch_json_api_file endpoint json_cask = JSON.parse((HOMEBREW_CACHE_API/endpoint).read) unless updated cache["cask_json"] ||= {} cache["cask_json"][name] = json_cask end sig { params( cask: ::Cask::Cask, download_queue: Homebrew::DownloadQueue, enqueue: T::Boolean, ).returns(Homebrew::API::SourceDownload) } def self.source_download(cask, download_queue: Homebrew.default_download_queue, enqueue: false) path = cask.ruby_source_path.to_s sha256 = cask.ruby_source_checksum[:sha256] checksum = Checksum.new(sha256) if sha256 git_head = cask.tap_git_head || "HEAD" tap = cask.tap&.full_name || "Homebrew/homebrew-cask" download = Homebrew::API::SourceDownload.new( "https://raw.githubusercontent.com/#{tap}/#{git_head}/#{path}", checksum, mirrors: [ "#{HOMEBREW_API_DEFAULT_DOMAIN}/cask-source/#{File.basename(path)}", ], cache: HOMEBREW_CACHE_API_SOURCE/"#{tap}/#{git_head}/Cask", ) if enqueue download_queue.enqueue(download) elsif !download.symlink_location.exist? download.fetch end download end sig { params(cask: ::Cask::Cask).returns(::Cask::Cask) } def self.source_download_cask(cask) download = source_download(cask) ::Cask::CaskLoader::FromPathLoader.new(download.symlink_location) .load(config: cask.config) end sig { returns(Pathname) } def self.cached_json_file_path HOMEBREW_CACHE_API/DEFAULT_API_FILENAME end sig { params(download_queue: ::Homebrew::DownloadQueue, stale_seconds: T.nilable(Integer), enqueue: T::Boolean) .returns([T.any(T::Array[T.untyped], T::Hash[String, T.untyped]), T::Boolean]) } def self.fetch_api!(download_queue: Homebrew.default_download_queue, stale_seconds: nil, enqueue: false) Homebrew::API.fetch_json_api_file DEFAULT_API_FILENAME, stale_seconds:, download_queue:, enqueue: end sig { params(download_queue: ::Homebrew::DownloadQueue, stale_seconds: T.nilable(Integer), enqueue: T::Boolean) .returns([T.any(T::Array[T.untyped], T::Hash[String, T.untyped]), T::Boolean]) } def self.fetch_tap_migrations!(download_queue: Homebrew.default_download_queue, stale_seconds: nil, enqueue: false) Homebrew::API.fetch_json_api_file "cask_tap_migrations.jws.json", stale_seconds:, download_queue:, enqueue: end sig { returns(T::Boolean) } def self.download_and_cache_data! json_casks, updated = fetch_api! cache["renames"] = {} cache["casks"] = json_casks.to_h do |json_cask| token = json_cask["token"] json_cask.fetch("old_tokens", []).each do |old_token| cache["renames"][old_token] = token end [token, json_cask.except("token")] end updated end private_class_method :download_and_cache_data! sig { returns(T::Hash[String, T::Hash[String, T.untyped]]) } def self.all_casks unless cache.key?("casks") json_updated = download_and_cache_data! write_names(regenerate: json_updated) end cache.fetch("casks") end sig { returns(T::Hash[String, String]) } def self.all_renames unless cache.key?("renames") json_updated = download_and_cache_data! write_names(regenerate: json_updated) end cache.fetch("renames") end sig { returns(T::Hash[String, T.untyped]) } def self.tap_migrations unless cache.key?("tap_migrations") json_migrations, = fetch_tap_migrations! cache["tap_migrations"] = json_migrations end cache.fetch("tap_migrations") end sig { params(regenerate: T::Boolean).void } def self.write_names(regenerate: false) download_and_cache_data! unless cache.key?("casks") Homebrew::API.write_names_file!(all_casks.keys, "cask", regenerate:) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/cask/000077500000000000000000000000001517265720000215765ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/api/cask/cask_struct_generator.rb000066400000000000000000000127131517265720000265220ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Homebrew module API module Cask # Methods for generating CaskStruct instances from API data. module CaskStructGenerator module_function # NOTE: this will be used to load installed cask JSON files, # so it must never fail with older JSON API versions sig { params(hash: T::Hash[String, T.untyped], bottle_tag: Utils::Bottles::Tag, ignore_types: T::Boolean).returns(CaskStruct) } def generate_cask_struct_hash(hash, bottle_tag: Homebrew::SimulateSystem.current_tag, ignore_types: false) hash = Homebrew::API.merge_variations(hash, bottle_tag:).dup.deep_symbolize_keys.transform_keys(&:to_s) hash["conflicts_with_args"] = hash["conflicts_with"]&.to_h hash["container_args"] = hash["container"]&.to_h do |key, value| next [key, value.to_sym] if key == :type [key, value] end if (depends_on = hash["depends_on"]) hash["depends_on_args"] = process_depends_on(depends_on) end if (deprecate_args = hash["deprecate_args"]) deprecate_args = deprecate_args.dup deprecate_args[:because] = DeprecateDisable.to_reason_string_or_symbol(deprecate_args[:because], type: :cask) hash["deprecate_args"] = deprecate_args end if (disable_args = hash["disable_args"]) disable_args = disable_args.dup disable_args[:because] = DeprecateDisable.to_reason_string_or_symbol(disable_args[:because], type: :cask) hash["disable_args"] = disable_args end hash["names"] = hash["name"] if (artifacts = hash["artifacts"]) hash["raw_artifacts"] = process_artifacts(artifacts) end hash["raw_caveats"] = hash["caveats"] hash["renames"] = hash["rename"]&.map do |operation| [operation[:from], operation[:to]] end hash["ruby_source_checksum"] = { sha256: hash.dig("ruby_source_checksum", :sha256), }.compact hash["ruby_source_path"] = hash["ruby_source_path"]&.to_s hash["sha256"] = hash["sha256"].to_s hash["sha256"] = :no_check if hash["sha256"] == "no_check" hash["tap_string"] = hash["tap"] hash["url_args"] = [hash["url"].to_s] if (url_specs = hash["url_specs"]) hash["url_kwargs"] = process_url_specs(url_specs) end # Should match CaskStruct::PREDICATES hash["auto_updates_present"] = hash["auto_updates"].present? hash["caveats_present"] = hash["caveats"].present? hash["conflicts_present"] = hash["conflicts_with"].present? hash["container_present"] = hash["container"].present? hash["depends_on_present"] = hash["depends_on_args"].present? hash["deprecate_present"] = hash["deprecate_args"].present? hash["desc_present"] = hash["desc"].present? hash["disable_present"] = hash["disable_args"].present? hash["homepage_present"] = hash["homepage"].present? CaskStruct.from_hash(hash, ignore_types:) end sig { params(depends_on: T::Hash[Symbol, T.untyped]).returns(CaskStruct::DependsOnArgs) } def process_depends_on(depends_on) depends_on.to_h do |key, value| # Arch dependencies are encoded like `{ type: :intel, bits: 64 }` # but `depends_on arch:` only accepts `:intel` or `:arm64` if key == :arch next [:arch, :intel] if value.first[:type].to_sym == :intel next [:arch, :arm64] end next [key, value] if key != :macos value = value.to_h if value.is_a?(MacOSRequirement) dep_type = value.keys.first if dep_type.to_sym == :== version_symbols = value[dep_type].filter_map do |version| MacOSVersion::SYMBOLS.key(version) end next [key, version_symbols.presence] end version_symbol = value[dep_type].first version_symbol = MacOSVersion::SYMBOLS.key(version_symbol) version_dep = "#{dep_type} :#{version_symbol}" if version_symbol [key, version_dep] end.compact end sig { params(artifacts: T::Array[T::Hash[Symbol, T.untyped]]).returns(T::Array[CaskStruct::ArtifactArgs]) } def process_artifacts(artifacts) artifacts.map do |artifact| key = T.must(artifact.keys.first) # Pass an empty block to artifacts like postflight that can't be loaded from the API, # but need to be set to something. next [key, [], {}, Homebrew::API::CaskStruct::EMPTY_BLOCK] if artifact[key].nil? args = artifact[key] kwargs = if args.last.is_a?(Hash) args.pop else {} end [key, args, kwargs, nil] end end sig { params(url_specs: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.anything]) } def process_url_specs(url_specs) url_specs.to_h do |key, value| value = case key when :user_agent Utils.convert_to_string_or_symbol(value) when :using value.to_sym else value end [key, value] end.compact_blank end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/cask_struct.rb000066400000000000000000000200511517265720000235250ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Homebrew module API class CaskStruct < T::Struct sig { params(cask_hash: T::Hash[String, T.untyped], ignore_types: T::Boolean).returns(CaskStruct) } def self.from_hash(cask_hash, ignore_types: false) return super(cask_hash) if ignore_types cask_hash = ::Cask::Cask.deep_remove_placeholders(cask_hash) cask_hash = cask_hash.transform_keys(&:to_sym) .slice(*decorator.all_props) .compact_blank new(**cask_hash) end PREDICATES = [ :auto_updates, :caveats, :conflicts, :container, :depends_on, :deprecate, :desc, :disable, :homepage, ].freeze EMPTY_BLOCK = T.let(-> {}.freeze, T.proc.void) EMPTY_BLOCK_PLACEHOLDER = :empty_block ArtifactArgs = T.type_alias do [ Symbol, T::Array[T.anything], T::Hash[Symbol, T.anything], T.nilable(T.proc.void), ] end PREDICATES.each do |predicate_name| present_method_name = :"#{predicate_name}_present" predicate_method_name = :"#{predicate_name}?" const present_method_name, T::Boolean, default: false define_method(predicate_method_name) do send(present_method_name) end end DependsOnArgs = T.type_alias do T::Hash[ # Keys are dependency types like :macos, :arch, :cask, :formula Symbol, # Values can be any of: T.any( # Strings like ">= :catalina" for :macos String, # Symbols like :intel or :arm64 for :arch Symbol, # Array of strings or symbols for :cask and :formula T::Array[T.any(String, Symbol)], ), ] end # Changes to this struct must be mirrored in Homebrew::API::Cask.generate_cask_struct_hash const :auto_updates, T::Boolean, default: false const :caveats_rosetta, T::Boolean, default: false const :conflicts_with_args, T::Hash[Symbol, T::Array[String]], default: {} const :container_args, { nested: T.nilable(String), type: T.nilable(Symbol) }, default: { nested: nil, type: nil } const :depends_on_args, DependsOnArgs, default: {} const :deprecate_args, T::Hash[Symbol, T.nilable(T.any(String, Symbol))], default: {} const :desc, T.nilable(String) const :disable_args, T::Hash[Symbol, T.nilable(T.any(String, Symbol))], default: {} const :homepage, T.nilable(String) const :languages, T::Array[String], default: [] const :names, T::Array[String], default: [] const :renames, T::Array[[String, String]], default: [] const :ruby_source_checksum, T::Hash[Symbol, T.nilable(String)], default: { sha256: nil } const :ruby_source_path, T.nilable(String) const :sha256, T.any(String, Symbol) const :tap_string, T.nilable(String) const :url_args, T::Array[String], default: [] const :url_kwargs, T::Hash[Symbol, T.anything], default: {} const :version, T.any(String, Symbol) sig { params(other: T.anything).returns(T::Boolean) } def ==(other) case other when CaskStruct serialize == other.serialize else false end end sig { params(appdir: T.any(Pathname, String)).returns(T::Array[ArtifactArgs]) } def artifacts(appdir:) deep_remove_placeholders(raw_artifacts, appdir.to_s) end sig { params(appdir: T.any(Pathname, String)).returns(T.nilable(String)) } def caveats(appdir:) deep_remove_placeholders(raw_caveats, appdir.to_s) end sig { returns(T::Hash[String, T.untyped]) } def serialize hash = self.class.decorator.all_props.filter_map do |prop| next if PREDICATES.any? { |predicate| prop == :"#{predicate}_present" } [prop.to_s, send(prop)] end.to_h hash["raw_artifacts"] = raw_artifacts.map do |artifact| serialize_artifact_args(artifact) end hash = ::Utils.deep_stringify_symbols(hash) ::Utils.deep_compact_blank(hash) end sig { params(hash: T::Hash[String, T.untyped]).returns(CaskStruct) } def self.deserialize(hash) hash = ::Utils.deep_unstringify_symbols(hash) PREDICATES.each do |name| source_value = case name when :auto_updates then hash["auto_updates"] when :caveats then hash["raw_caveats"] when :conflicts then hash["conflicts_with_args"] when :desc then hash["desc"] when :homepage then hash["homepage"] else hash["#{name}_args"] end hash["#{name}_present"] = source_value.present? end hash["raw_artifacts"] = if (raw_artifacts = hash["raw_artifacts"]) raw_artifacts.map { |artifact| deserialize_artifact_args(artifact) } end from_hash(hash) end sig { params(artifact: ArtifactArgs).returns(T::Array[T.untyped]) } def serialize_artifact_args(artifact) key, args, kwargs, block = artifact # We can't serialize Procs, so always use an empty block placeholder to be deserialized as `-> {}`. block = EMPTY_BLOCK_PLACEHOLDER unless block.nil? [key, args, kwargs, block] end # Format artifact args pairs into proper [key, args, kwargs, block] format since serialization removed blanks. sig { params( args: T.any( [Symbol], [Symbol, T::Array[T.anything]], [Symbol, T::Hash[Symbol, T.anything]], [Symbol, Symbol], [Symbol, T::Array[T.anything], T::Hash[Symbol, T.anything]], [Symbol, T::Array[T.anything], Symbol], [Symbol, T::Hash[Symbol, T.anything], Symbol], [Symbol, T::Array[T.anything], T::Hash[Symbol, T.anything], Symbol], ), ).returns(ArtifactArgs) } def self.deserialize_artifact_args(args) case args in [key] then [key, [], {}, nil] in [key, Array => array] then [key, array, {}, nil] in [key, Hash => hash] then [key, [], hash, nil] in [key, EMPTY_BLOCK_PLACEHOLDER] then [key, [], {}, EMPTY_BLOCK] in [key, Array => array, Hash => hash] then [key, array, hash, nil] in [key, Array => array, EMPTY_BLOCK_PLACEHOLDER] then [key, array, {}, EMPTY_BLOCK] in [key, Hash => hash, EMPTY_BLOCK_PLACEHOLDER] then [key, [], hash, EMPTY_BLOCK] in [key, Array => array, Hash => hash, EMPTY_BLOCK_PLACEHOLDER] then [key, array, hash, EMPTY_BLOCK] else # The block argument should only ever be EMPTY_BLOCK_PLACEHOLDER or nil, so we should never reach this case. raise "Invalid artifact args: #{args.inspect}" end end private const :raw_artifacts, T::Array[ArtifactArgs], default: [] const :raw_caveats, T.nilable(String) sig { type_parameters(:U) .params( value: T.type_parameter(:U), appdir: String, ) .returns(T.type_parameter(:U)) } def deep_remove_placeholders(value, appdir) value = case value when Hash value.transform_values do |v| deep_remove_placeholders(v, appdir) end when Array value.map do |v| deep_remove_placeholders(v, appdir) end when String value.gsub(HOMEBREW_HOME_PLACEHOLDER, Dir.home) .gsub(HOMEBREW_PREFIX_PLACEHOLDER, HOMEBREW_PREFIX) .gsub(HOMEBREW_CELLAR_PLACEHOLDER, HOMEBREW_CELLAR) .gsub(HOMEBREW_CASK_APPDIR_PLACEHOLDER, appdir) else value end T.cast(value, T.type_parameter(:U)) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/formula.rb000066400000000000000000000142401517265720000226500ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cachable" require "api" require "api/source_download" require "download_queue" require "api/formula/formula_struct_generator" module Homebrew module API # Helper functions for using the formula JSON API. module Formula extend T::Generic extend Cachable # Sorbet type members are mutable by design and cannot be frozen. # rubocop:disable Style/MutableConstant Cache = type_template { { fixed: T::Hash[String, T.untyped] } } # rubocop:enable Style/MutableConstant DEFAULT_API_FILENAME = "formula.jws.json" private_class_method :cache sig { params(name: String).returns(T::Hash[String, T.untyped]) } def self.formula_json(name) fetch_formula_json! name if !cache.key?("formula_json") || !cache.fetch("formula_json").key?(name) cache.fetch("formula_json").fetch(name) end sig { params(name: String).void } def self.fetch_formula_json!(name) endpoint = "formula/#{name}.json" json_formula, updated = Homebrew::API.fetch_json_api_file endpoint json_formula = JSON.parse((HOMEBREW_CACHE_API/endpoint).read) unless updated cache["formula_json"] ||= {} cache["formula_json"][name] = json_formula end sig { params( formula: ::Formula, download_queue: Homebrew::DownloadQueue, enqueue: T::Boolean, ).returns(Homebrew::API::SourceDownload) } def self.source_download(formula, download_queue: Homebrew.default_download_queue, enqueue: false) path = formula.ruby_source_path || "Formula/#{formula.name}.rb" git_head = formula.tap_git_head || "HEAD" tap = formula.tap&.full_name || "Homebrew/homebrew-core" download = Homebrew::API::SourceDownload.new( "https://raw.githubusercontent.com/#{tap}/#{git_head}/#{path}", formula.ruby_source_checksum, cache: HOMEBREW_CACHE_API_SOURCE/"#{tap}/#{git_head}/Formula", ) if enqueue download_queue.enqueue(download) elsif !download.symlink_location.exist? || !download.symlink_location.symlink? download.fetch end download end sig { params(formula: ::Formula).returns(::Formula) } def self.source_download_formula(formula) download = source_download(formula) unless download.symlink_location.exist? raise CannotInstallFormulaError, "#{formula.full_name} source code not found at #{download.symlink_location}. " \ "Try `rm -rf $(brew --cache)/api-source` and retrying." end with_env(HOMEBREW_INTERNAL_ALLOW_PACKAGES_FROM_PATHS: "1") do Formulary.factory(download.symlink_location, formula.active_spec_sym, alias_path: formula.alias_path, flags: formula.class.build_flags) end end sig { returns(Pathname) } def self.cached_json_file_path HOMEBREW_CACHE_API/DEFAULT_API_FILENAME end sig { params(download_queue: Homebrew::DownloadQueue, stale_seconds: T.nilable(Integer), enqueue: T::Boolean) .returns([T.any(T::Array[T.untyped], T::Hash[String, T.untyped]), T::Boolean]) } def self.fetch_api!(download_queue: Homebrew.default_download_queue, stale_seconds: nil, enqueue: false) Homebrew::API.fetch_json_api_file DEFAULT_API_FILENAME, stale_seconds:, download_queue:, enqueue: end sig { params(download_queue: Homebrew::DownloadQueue, stale_seconds: T.nilable(Integer), enqueue: T::Boolean) .returns([T.any(T::Array[T.untyped], T::Hash[String, T.untyped]), T::Boolean]) } def self.fetch_tap_migrations!(download_queue: Homebrew.default_download_queue, stale_seconds: nil, enqueue: false) Homebrew::API.fetch_json_api_file "formula_tap_migrations.jws.json", stale_seconds:, download_queue:, enqueue: end sig { returns(T::Boolean) } def self.download_and_cache_data! json_formulae, updated = fetch_api! cache["aliases"] = {} cache["renames"] = {} cache["formulae"] = json_formulae.to_h do |json_formula| json_formula["aliases"].each do |alias_name| cache["aliases"][alias_name] = json_formula["name"] end (json_formula["oldnames"] || [json_formula["oldname"]].compact).each do |oldname| cache["renames"][oldname] = json_formula["name"] end [json_formula["name"], json_formula.except("name")] end updated end private_class_method :download_and_cache_data! sig { returns(T::Hash[String, T.untyped]) } def self.all_formulae unless cache.key?("formulae") json_updated = download_and_cache_data! write_names_and_aliases(regenerate: json_updated) end cache.fetch("formulae") end sig { returns(T::Hash[String, String]) } def self.all_aliases unless cache.key?("aliases") json_updated = download_and_cache_data! write_names_and_aliases(regenerate: json_updated) end cache.fetch("aliases") end sig { returns(T::Hash[String, String]) } def self.all_renames unless cache.key?("renames") json_updated = download_and_cache_data! write_names_and_aliases(regenerate: json_updated) end cache.fetch("renames") end sig { returns(T::Hash[String, T.untyped]) } def self.tap_migrations unless cache.key?("tap_migrations") json_migrations, = fetch_tap_migrations! cache["tap_migrations"] = json_migrations end cache.fetch("tap_migrations") end sig { params(regenerate: T::Boolean).void } def self.write_names_and_aliases(regenerate: false) download_and_cache_data! unless cache.key?("formulae") Homebrew::API.write_names_file!(all_formulae.keys, "formula", regenerate:) Homebrew::API.write_aliases_file!(all_aliases, "formula", regenerate:) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/formula/000077500000000000000000000000001517265720000223225ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/api/formula/formula_struct_generator.rb000066400000000000000000000304121517265720000277660ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "deprecate_disable" module Homebrew module API module Formula # Methods for generating FormulaStruct instances from API data. module FormulaStructGenerator module_function # `:codesign` and custom requirement classes are not supported. API_SUPPORTED_REQUIREMENTS = [:arch, :linux, :macos, :maximum_macos, :xcode].freeze private_constant :API_SUPPORTED_REQUIREMENTS DependencyHash = T.type_alias do T::Hash[ # Keys are strings of the dependency type (e.g. "dependencies", "build_dependencies") String, # Values are arrays of either: T::Array[ T.any( # Formula name: "foo" String, # Hash like { "foo" => :build } or { "foo" => [:build, :test] } T::Hash[ String, T.any(Symbol, T::Array[Symbol]), ], # Hash like { since: :catalina } for uses_from_macos_bounds T::Hash[Symbol, Symbol], ), ], ] end RequirementsArray = T.type_alias do T::Array[T::Hash[String, T.untyped]] end sig { params(hash: T::Hash[String, T.untyped], bottle_tag: Utils::Bottles::Tag).returns(FormulaStruct) } def generate_formula_struct_hash(hash, bottle_tag: Homebrew::SimulateSystem.current_tag) hash = Homebrew::API.merge_variations(hash, bottle_tag:).dup.deep_stringify_keys if (caveats = hash["caveats"]) hash["caveats"] = Formulary.replace_placeholders(caveats) end hash["bottle_checksums"] = begin files = hash.dig("bottle", "stable", "files") || {} files.map do |tag, bottle_spec| { cellar: Utils.convert_to_string_or_symbol(bottle_spec.fetch("cellar")), tag.to_sym => bottle_spec.fetch("sha256"), } end end hash["bottle_rebuild"] = hash.dig("bottle", "stable", "rebuild") conflicts_with = hash["conflicts_with"] || [] conflicts_with_reasons = hash["conflicts_with_reasons"] || [] hash["conflicts"] = conflicts_with.zip(conflicts_with_reasons).map do |name, reason| if reason.present? [name, { because: reason }] else [name, {}] end end if (deprecate_args = hash["deprecate_args"]) deprecate_args = deprecate_args.dup.transform_keys(&:to_sym) deprecate_args[:because] = DeprecateDisable.to_reason_string_or_symbol(deprecate_args[:because], type: :formula) hash["deprecate_args"] = deprecate_args end if (disable_args = hash["disable_args"]) disable_args = disable_args.dup.transform_keys(&:to_sym) disable_args[:because] = DeprecateDisable.to_reason_string_or_symbol(disable_args[:because], type: :formula) hash["disable_args"] = disable_args end hash["head_url_args"] = begin # Fall back to "" to satisfy the type checker. If the head URL is missing, head_present will be false. url = hash.dig("urls", "head", "url") || "" specs = { branch: hash.dig("urls", "head", "branch"), using: hash.dig("urls", "head", "using")&.to_sym, }.compact_blank [url, specs] end if (keg_only_hash = hash["keg_only_reason"]) reason = Utils.convert_to_string_or_symbol(keg_only_hash.fetch("reason")) explanation = keg_only_hash["explanation"] hash["keg_only_args"] = [reason, explanation].compact end hash["license"] = SPDX.string_to_license_expression(hash["license"]) hash["link_overwrite_paths"] = hash["link_overwrite"] if (reason = hash["no_autobump_message"]) reason = reason.to_sym if NO_AUTOBUMP_REASONS_LIST.key?(reason.to_sym) hash["no_autobump_args"] = { because: reason } end if (condition = hash["pour_bottle_only_if"]) hash["pour_bottle_args"] = { only_if: condition.to_sym } end hash["ruby_source_checksum"] = hash.dig("ruby_source_checksum", "sha256") if (service_hash = hash["service"]) service_hash = Homebrew::Service.from_hash(service_hash) hash["service_run_args"], hash["service_run_kwargs"] = case (run = service_hash[:run]) when Hash [[], run] when Array, String [[run], {}] else [[], {}] end hash["service_name_args"] = service_hash[:name] hash["service_args"] = service_hash.filter_map do |key, arg| [key.to_sym, arg] if key != :name && key != :run end end hash["stable_checksum"] = hash.dig("urls", "stable", "checksum") hash["stable_url_args"] = begin url = hash.dig("urls", "stable", "url") specs = { tag: hash.dig("urls", "stable", "tag"), revision: hash.dig("urls", "stable", "revision"), using: hash.dig("urls", "stable", "using")&.to_sym, }.compact_blank [url, specs] end hash["stable_version"] = hash.dig("versions", "stable") # Do dependency processing last because it's more involved and depends on other fields hash["requirements_array"] = hash["requirements"] stable_dependency_hash = { "dependencies" => hash["dependencies"] || [], "build_dependencies" => hash["build_dependencies"] || [], "test_dependencies" => hash["test_dependencies"] || [], "recommended_dependencies" => hash["recommended_dependencies"] || [], "optional_dependencies" => hash["optional_dependencies"] || [], "uses_from_macos" => hash["uses_from_macos"] || [], "uses_from_macos_bounds" => hash["uses_from_macos_bounds"] || [], } stable_dependencies, stable_uses_from_macos = process_dependencies_and_requirements( stable_dependency_hash, hash["requirements_array"], :stable, ) # hash["head_dependencies"] is always present unless the stable and head deps are identical head_dependency_hash = hash["head_dependencies"] || stable_dependency_hash head_dependencies, head_uses_from_macos = process_dependencies_and_requirements( head_dependency_hash, hash["requirements_array"], :head, ) hash["stable_dependencies"] = stable_dependencies hash["stable_uses_from_macos"] = stable_uses_from_macos hash["head_dependencies"] = head_dependencies hash["head_uses_from_macos"] = head_uses_from_macos # Should match FormulaStruct::PREDICATES hash["bottle_present"] = hash["bottle"].present? hash["deprecate_present"] = hash["deprecate_args"].present? hash["disable_present"] = hash["disable_args"].present? hash["head_present"] = hash.dig("urls", "head").present? hash["keg_only_present"] = hash["keg_only_reason"].present? hash["no_autobump_present"] = hash["no_autobump_message"].present? hash["pour_bottle_present"] = hash["pour_bottle_only_if"].present? hash["service_present"] = hash["service"].present? hash["service_run_present"] = hash.dig("service", "run").present? hash["service_name_present"] = hash.dig("service", "name").present? hash["stable_present"] = hash.dig("urls", "stable").present? FormulaStruct.from_hash(hash) end sig { params(deps_hash: T.nilable(DependencyHash), requirements_array: T.nilable(RequirementsArray), spec: Symbol) .returns([T::Array[FormulaStruct::DependsOnArgs], T::Array[FormulaStruct::UsesFromMacOSArgs]]) } def process_dependencies_and_requirements(deps_hash, requirements_array, spec) deps, uses_from_macos = if deps_hash.present? deps_hash = symbolize_dependency_hash(deps_hash) [process_dependencies(deps_hash), process_uses_from_macos(deps_hash)] else [[], []] end requirements = if requirements_array.present? process_requirements(requirements_array, spec) else [] end [deps + requirements, uses_from_macos] end # Convert from { "dependencies" => ["foo", { "bar" => "build" }, { "baz" => ["build", "test"] }] } # to { "dependencies" => ["foo", { "bar" => :build }, { "baz" => [:build, :test] }] } sig { params(hash: DependencyHash).returns(DependencyHash) } def symbolize_dependency_hash(hash) hash = hash.dup if (uses_from_macos_bounds = hash["uses_from_macos_bounds"]) uses_from_macos_bounds = T.cast(uses_from_macos_bounds, T::Array[T::Hash[Symbol, Symbol]]) hash["uses_from_macos_bounds"] = uses_from_macos_bounds.map(&:deep_symbolize_keys) end hash.transform_values do |deps| deps.map do |dep| next dep unless dep.is_a?(Hash) dep.transform_values do |types| case types when Array types.map(&:to_sym) else types.to_sym end end end end end sig { params(deps_hash: DependencyHash).returns(T::Array[FormulaStruct::DependsOnArgs]) } def process_dependencies(deps_hash) dependencies = deps_hash.fetch("dependencies", []) dependencies + [:build, :test, :recommended, :optional].filter_map do |type| deps_hash["#{type}_dependencies"]&.map do |dep| { dep => type } end end.flatten(1) end sig { params(requirements_array: RequirementsArray, spec: Symbol).returns(T::Array[FormulaStruct::DependsOnArgs]) } def process_requirements(requirements_array, spec) requirements_array.filter_map do |req| next unless req["specs"].include?(spec.to_s) req_name = req["name"].to_sym next if API_SUPPORTED_REQUIREMENTS.exclude?(req_name) req_version = case req_name when :arch req["version"]&.to_sym when :macos, :maximum_macos MacOSVersion::SYMBOLS.key(req["version"]) else req["version"] end req_tags = [] req_tags << req_version if req_version.present? req_tags += req.fetch("contexts", []).map do |tag| case tag when String tag.to_sym when Hash tag.deep_transform_keys(&:to_sym) else tag end end if req_tags.empty? req_name else { req_name => req_tags } end end end sig { params(deps_hash: DependencyHash).returns(T::Array[FormulaStruct::UsesFromMacOSArgs]) } def process_uses_from_macos(deps_hash) uses_from_macos = deps_hash.fetch("uses_from_macos", []) uses_from_macos_bounds = deps_hash.fetch("uses_from_macos_bounds", []) uses_from_macos_bounds = T.cast(uses_from_macos_bounds, T::Array[T::Hash[Symbol, Symbol]]) uses_from_macos.zip(uses_from_macos_bounds).map do |entry, bounds| bounds ||= {} bounds = bounds.transform_keys(&:to_sym).transform_values(&:to_sym) if entry.is_a?(Hash) # The key is the dependency name, the value is the dep type. Only the type should be a symbol entry = entry.deep_transform_values(&:to_sym) # When passing both a dep type and bounds, uses_from_macos expects them both in the first argument entry = entry.merge(bounds) [entry, {}] else [entry, bounds] end end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/formula_struct.rb000066400000000000000000000224331517265720000242570ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "service" require "utils/spdx" module Homebrew module API class FormulaStruct < T::Struct sig { params(formula_hash: T::Hash[String, T.untyped]).returns(FormulaStruct) } def self.from_hash(formula_hash) formula_hash = ::Formula.deep_remove_placeholders(formula_hash) formula_hash = formula_hash.transform_keys(&:to_sym) .slice(*decorator.all_props) .compact_blank new(**formula_hash) end PREDICATES = [ :bottle, :deprecate, :disable, :head, :keg_only, :no_autobump, :pour_bottle, :service, :service_run, :service_name, :stable, ].freeze SKIP_SERIALIZATION = [ # Bottle checksums have special serialization done by the serialize_bottle method :bottle_checksums, ].freeze SPECS = [:head, :stable].freeze # :any_skip_relocation is the most common in homebrew/core DEFAULT_CELLAR = :any_skip_relocation DependsOnArgs = T.type_alias do T.any( # Dependencies T.any( # Formula name: "foo" String, # Formula name and dependency type: { "foo" => :build } T::Hash[String, Symbol], ), # Requirements T.any( # Requirement name: :macos Symbol, # Requirement name and other info: { macos: :build } T::Hash[Symbol, T::Array[T.anything]], ), ) end UsesFromMacOSArgs = T.type_alias do [ T.any( # Formula name: "foo" String, # Formula name and dependency type: { "foo" => :build } # Formula name, dependency type, and version bounds: { "foo" => :build, since: :catalina } T::Hash[T.any(String, Symbol), T.any(Symbol, T::Array[Symbol])], ), # If the first argument is only a name, this argument contains the version bounds: { since: :catalina } T::Hash[Symbol, Symbol], ] end PREDICATES.each do |predicate_name| present_method_name = :"#{predicate_name}_present" predicate_method_name = :"#{predicate_name}?" const present_method_name, T::Boolean, default: false define_method(predicate_method_name) do send(present_method_name) end end # Changes to this struct must be mirrored in Homebrew::API::Formula.generate_formula_struct_hash const :aliases, T::Array[String], default: [] const :bottle_checksums, T::Array[T::Hash[Symbol, T.any(String, Symbol)]], default: [] const :bottle_rebuild, Integer, default: 0 const :caveats, T.nilable(String) const :conflicts, T::Array[[String, T::Hash[Symbol, String]]], default: [] const :deprecate_args, T::Hash[Symbol, T.nilable(T.any(String, Symbol))], default: {} const :desc, String const :disable_args, T::Hash[Symbol, T.nilable(T.any(String, Symbol))], default: {} const :head_dependencies, T::Array[DependsOnArgs], default: [] const :head_url_args, [String, T::Hash[Symbol, T.anything]], default: ["", {}] const :head_uses_from_macos, T::Array[UsesFromMacOSArgs], default: [] const :homepage, String const :keg_only_args, T::Array[T.any(String, Symbol)], default: [] const :license, SPDX::LicenseExpression const :link_overwrite_paths, T::Array[String], default: [] const :no_autobump_args, T::Hash[Symbol, T.any(String, Symbol)], default: {} const :oldnames, T::Array[String], default: [] const :post_install_defined, T::Boolean, default: true const :pour_bottle_args, T::Hash[Symbol, Symbol], default: {} const :revision, Integer, default: 0 const :ruby_source_checksum, String const :service_args, T::Array[[Symbol, BasicObject]], default: [] const :service_name_args, T::Hash[Symbol, String], default: {} const :service_run_args, T::Array[Homebrew::Service::RunParam], default: [] const :service_run_kwargs, T::Hash[Symbol, Homebrew::Service::RunParam], default: {} const :stable_dependencies, T::Array[DependsOnArgs], default: [] const :stable_checksum, T.nilable(String) const :stable_url_args, [String, T::Hash[Symbol, T.anything]], default: ["", {}] const :stable_uses_from_macos, T::Array[UsesFromMacOSArgs], default: [] const :stable_version, String const :version_scheme, Integer, default: 0 const :versioned_formulae, T::Array[String], default: [] sig { params(other: T.anything).returns(T::Boolean) } def ==(other) case other when FormulaStruct serialize == other.serialize else false end end sig { params(bottle_tag: ::Utils::Bottles::Tag).returns(T.nilable(T::Hash[String, T.untyped])) } def serialize_bottle(bottle_tag: ::Utils::Bottles.tag) bottle_collector = ::Utils::Bottles::Collector.new bottle_checksums.each do |bottle_info| bottle_info = bottle_info.dup cellar = bottle_info.delete(:cellar) || :any tag = T.must(bottle_info.keys.first) checksum = T.cast(bottle_info.values.first, String) bottle_collector.add( ::Utils::Bottles::Tag.from_symbol(tag), checksum: Checksum.new(checksum), cellar:, ) end return unless (bottle_spec = bottle_collector.specification_for(bottle_tag)) tag = (bottle_spec.tag if bottle_spec.tag != bottle_tag) cellar = (bottle_spec.cellar if bottle_spec.cellar != DEFAULT_CELLAR) { "bottle_tag" => tag&.to_sym, "bottle_cellar" => cellar, "bottle_checksum" => bottle_spec.checksum.to_s, } end sig { params(bottle_tag: ::Utils::Bottles::Tag).returns(T::Hash[String, T.untyped]) } def serialize(bottle_tag: ::Utils::Bottles.tag) hash = self.class.decorator.all_props.filter_map do |prop| next if PREDICATES.any? { |predicate| prop == :"#{predicate}_present" } next if SKIP_SERIALIZATION.include?(prop) [prop.to_s, send(prop)] end.to_h if (bottle_hash = serialize_bottle(bottle_tag:)) hash = hash.merge(bottle_hash) end hash = ::Utils.deep_stringify_symbols(hash) service_args = hash["service_args"] hash = ::Utils.deep_compact_blank(hash) # service_args may have falsey values that we don't want to remove, like `keep_alive successful_exit: false` hash["service_args"] = service_args if service_args&.any? hash end sig { params(hash: T::Hash[String, T.untyped], bottle_tag: ::Utils::Bottles::Tag).returns(FormulaStruct) } def self.deserialize(hash, bottle_tag: ::Utils::Bottles.tag) hash = ::Utils.deep_unstringify_symbols(hash) # Items that don't follow the `hash["foo_present"] = hash["foo_args"].present?` pattern are overridden below PREDICATES.each do |name| hash["#{name}_present"] = hash["#{name}_args"].present? end if (bottle_checksum = hash["bottle_checksum"]) tag = hash.fetch("bottle_tag", bottle_tag.to_sym) cellar = hash.fetch("bottle_cellar", DEFAULT_CELLAR) hash["bottle_present"] = true hash["bottle_checksums"] = [{ cellar: cellar, tag => bottle_checksum }] else hash["bottle_present"] = false end # *_url_args need to be in [String, Hash] format, but the hash may have been dropped if empty SPECS.each do |key| if (url_args = hash["#{key}_url_args"]) hash["#{key}_present"] = true hash["#{key}_url_args"] = format_arg_pair(url_args, last: {}) else hash["#{key}_present"] = false end next unless (uses_from_macos = hash["#{key}_uses_from_macos"]) hash["#{key}_uses_from_macos"] = uses_from_macos.map do |args| format_arg_pair(args, last: {}) end end hash["conflicts"] = if (conflicts = hash["conflicts"]) conflicts.map { |conflict| format_arg_pair(conflict, last: {}) } end from_hash(hash) end # Format argument pairs into proper [first, last] format if serialization has removed some elements. # Pass a default value for last to be used when only one element is present. # # format_arg_pair(["foo"], last: {}) # => ["foo", {}] # format_arg_pair([{ "foo" => :build }], last: {}) # => [{ "foo" => :build }, {}] # format_arg_pair(["foo", { since: :catalina }], last: {}) # => ["foo", { since: :catalina }] sig { type_parameters(:U, :V) .params( args: T.any([T.type_parameter(:U)], [T.type_parameter(:U), T.type_parameter(:V)]), last: T.type_parameter(:V), ).returns([T.type_parameter(:U), T.type_parameter(:V)]) } def self.format_arg_pair(args, last:) args = case args in [elem] [elem, last] in [elem1, elem2] [elem1, elem2] end # The case above is exhaustive so args will never be nil, but sorbet cannot infer that. T.must(args) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/homebrew-1.pem000066400000000000000000000014401517265720000233250ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAyKoOYzp1rhwXISRi61BY XBEr2PalSK8lEVOL2USy7mpy0OubOlFyujawyQcBcCn+uPOJ/WaK+POhNWcLLoiK L2m8GViaQm7SMwdLKUXFgKSPHcG/1m6Vu+TNBKTfQqT60PjEYIrn5NW9ZrM0cUhK REmsbeAMBevdSaW9UwY9iIhprrgovvT8SzKhF8ZOIZKXfJX4VNk0y/7VJYNuGGqH 3npxV7OKd4yTGRGqFcC9kJ84me3thiu0yqlOjASmfWIwIwcfp4j6BEM2LuqKd7yX h51/O+MTthkuxV36moDKfdgdOFsvlCFkziaYLScCX9lOlmZHtOfJTAOXxTmM7qGr wTGK0vhvTi8k9dBmH/dccredQBtPOfM/FEdeyakGLoTcDguiBS/4El3I2KtF6B2h OGoBumR915/cI4drr5yPMduZ7gjs7ZEZnVkeVzic24TfUHpnOYzrhucNJtHMBDj9 6d1Gk82AhtuF9KlusLmCb6qXCWQSp/A4RZpN37E/p9q8rLp/7B/zp8X2TVvecPNy BdMagdktdEqK7WPlYMcUp56JaOph8vqYoU+oGyCpWoLvcXFb75o4eefuu6Rs5SyM c9JCCJ0DDFPjCRFnGPkvsKxFCzMFqH1jpWH0RQIrgmNVM5PO84iRH9YJsSPQzpMj KvK/ZH4YgR9wNkBNagFo7lsCAwEAAQ== -----END PUBLIC KEY----- Homebrew-brew-d7f73ce/Library/Homebrew/api/internal.rb000066400000000000000000000146631517265720000230300ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cachable" require "api" require "api/source_download" require "download_queue" module Homebrew module API # Helper functions for using the JSON internal API. module Internal extend T::Generic extend Cachable # Sorbet type members are mutable by design and cannot be frozen. # rubocop:disable Style/MutableConstant Cache = type_template { { fixed: T::Hash[String, T.untyped] } } # rubocop:enable Style/MutableConstant private_class_method :cache sig { returns(String) } def self.packages_endpoint "internal/packages.#{SimulateSystem.current_tag}.jws.json" end sig { params(name: String).returns(Homebrew::API::FormulaStruct) } def self.formula_struct(name) return cache["formula_structs"][name] if cache.key?("formula_structs") && cache["formula_structs"].key?(name) hash = formula_hashes[name] raise "No formula found for #{name}" unless hash struct = Homebrew::API::FormulaStruct.deserialize(hash, bottle_tag: SimulateSystem.current_tag) cache["formula_structs"] ||= {} cache["formula_structs"][name] = struct struct end sig { params(name: String).returns(Homebrew::API::CaskStruct) } def self.cask_struct(name) return cache["cask_structs"][name] if cache.key?("cask_structs") && cache["cask_structs"].key?(name) hash = cask_hashes[name] raise "No cask found for #{name}" unless hash struct = Homebrew::API::CaskStruct.deserialize(hash) cache["cask_structs"] ||= {} cache["cask_structs"][name] = struct struct end sig { returns(Pathname) } def self.cached_packages_json_file_path HOMEBREW_CACHE_API/packages_endpoint end sig { params(download_queue: Homebrew::DownloadQueue, stale_seconds: T.nilable(Integer), enqueue: T::Boolean) .returns([T::Hash[String, T.untyped], T::Boolean]) } def self.fetch_packages_api!(download_queue: Homebrew.default_download_queue, stale_seconds: nil, enqueue: false) json_contents, updated = Homebrew::API.fetch_json_api_file(packages_endpoint, stale_seconds:, download_queue:, enqueue:) [T.cast(json_contents, T::Hash[String, T.untyped]), updated] end sig { returns(T::Boolean) } def self.download_and_cache_data! json_contents, updated = fetch_packages_api! cache["formula_structs"] = {} cache["cask_structs"] = {} cache["formula_aliases"] = json_contents["formula_aliases"] cache["formula_renames"] = json_contents["formula_renames"] cache["cask_renames"] = json_contents["cask_renames"] cache["formula_tap_git_head"] = json_contents["formula_tap_git_head"] cache["cask_tap_git_head"] = json_contents["cask_tap_git_head"] cache["formula_tap_migrations"] = json_contents["formula_tap_migrations"] cache["cask_tap_migrations"] = json_contents["cask_tap_migrations"] cache["formula_hashes"] = json_contents["formulae"] cache["cask_hashes"] = json_contents["casks"] updated end private_class_method :download_and_cache_data! sig { params(regenerate: T::Boolean).void } def self.write_formula_names_and_aliases(regenerate: false) download_and_cache_data! unless cache.key?("formula_hashes") Homebrew::API.write_names_file!(formula_hashes.keys, "formula", regenerate:) Homebrew::API.write_aliases_file!(formula_aliases, "formula", regenerate:) end sig { params(regenerate: T::Boolean).void } def self.write_cask_names(regenerate: false) download_and_cache_data! unless cache.key?("cask_hashes") Homebrew::API.write_names_file!(cask_hashes.keys, "cask", regenerate:) end sig { returns(T::Hash[String, T::Hash[String, T.untyped]]) } def self.formula_hashes unless cache.key?("formula_hashes") updated = download_and_cache_data! write_formula_names_and_aliases(regenerate: updated) end cache["formula_hashes"] end sig { returns(T::Hash[String, String]) } def self.formula_aliases unless cache.key?("formula_aliases") updated = download_and_cache_data! write_formula_names_and_aliases(regenerate: updated) end cache["formula_aliases"] end sig { returns(T::Hash[String, String]) } def self.formula_renames unless cache.key?("formula_renames") updated = download_and_cache_data! write_formula_names_and_aliases(regenerate: updated) end cache["formula_renames"] end sig { returns(T::Hash[String, String]) } def self.formula_tap_migrations unless cache.key?("formula_tap_migrations") updated = download_and_cache_data! write_formula_names_and_aliases(regenerate: updated) end cache["formula_tap_migrations"] end sig { returns(String) } def self.formula_tap_git_head unless cache.key?("formula_tap_git_head") updated = download_and_cache_data! write_formula_names_and_aliases(regenerate: updated) end cache["formula_tap_git_head"] end sig { returns(T::Hash[String, T::Hash[String, T.untyped]]) } def self.cask_hashes unless cache.key?("cask_hashes") updated = download_and_cache_data! write_cask_names(regenerate: updated) end cache["cask_hashes"] end sig { returns(T::Hash[String, String]) } def self.cask_renames unless cache.key?("cask_renames") updated = download_and_cache_data! write_cask_names(regenerate: updated) end cache["cask_renames"] end sig { returns(T::Hash[String, String]) } def self.cask_tap_migrations unless cache.key?("cask_tap_migrations") updated = download_and_cache_data! write_cask_names(regenerate: updated) end cache["cask_tap_migrations"] end sig { returns(String) } def self.cask_tap_git_head unless cache.key?("cask_tap_git_head") updated = download_and_cache_data! write_cask_names(regenerate: updated) end cache["cask_tap_git_head"] end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/json_download.rb000066400000000000000000000031611517265720000240430ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "downloadable" module Homebrew module API class JSONDownloadStrategy < AbstractDownloadStrategy sig { params(url: String, name: String, version: T.nilable(T.any(String, Version)), meta: T.untyped).void } def initialize(url, name, version, **meta) super @target = T.let(meta.fetch(:target), Pathname) @stale_seconds = T.let(meta[:stale_seconds], T.nilable(Integer)) end sig { override.params(timeout: T.nilable(T.any(Integer, Float))).returns(Pathname) } def fetch(timeout: nil) with_context quiet: quiet? do Homebrew::API.fetch_json_api_file(url, target: cached_location, stale_seconds: meta[:stale_seconds]) end cached_location end sig { override.returns(T.nilable(Integer)) } def fetched_size File.size?(cached_location) end sig { override.returns(Pathname) } def cached_location meta.fetch(:target) end end class JSONDownload include Downloadable sig { params(url: String, target: Pathname, stale_seconds: T.nilable(Integer)).void } def initialize(url, target:, stale_seconds:) super() @url = T.let(URL.new(url, using: API::JSONDownloadStrategy, target:, stale_seconds:), URL) @target = target @stale_seconds = stale_seconds end sig { override.returns(API::JSONDownloadStrategy) } def downloader T.cast(super, API::JSONDownloadStrategy) end sig { override.returns(String) } def download_queue_type = "JSON API" end end end Homebrew-brew-d7f73ce/Library/Homebrew/api/source_download.rb000066400000000000000000000022601517265720000243710ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "downloadable" module Homebrew module API class SourceDownloadStrategy < CurlDownloadStrategy sig { override.returns(Pathname) } def symlink_location cache/name end end class SourceDownload include Downloadable sig { params( url: String, checksum: T.nilable(Checksum), mirrors: T::Array[String], cache: T.nilable(Pathname), ).void } def initialize(url, checksum, mirrors: [], cache: nil) super() @url = T.let(URL.new(url, using: API::SourceDownloadStrategy), URL) @checksum = checksum @mirrors = mirrors @cache = cache end sig { override.returns(API::SourceDownloadStrategy) } def downloader T.cast(super, API::SourceDownloadStrategy) end sig { override.returns(String) } def download_queue_type = "API Source" sig { override.returns(Pathname) } def cache @cache || super end sig { returns(Pathname) } def symlink_location downloader.symlink_location end end end end Homebrew-brew-d7f73ce/Library/Homebrew/api_hashable.rb000066400000000000000000000036371517265720000230420ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # Used to substitute common paths with generic placeholders when generating JSON for the API. module APIHashable sig { void } def generating_hash! return if generating_hash? # Apply monkeypatches for API generation @old_homebrew_prefix = T.let(HOMEBREW_PREFIX, T.nilable(Pathname)) @old_homebrew_cellar = T.let(HOMEBREW_CELLAR, T.nilable(Pathname)) @old_home = T.let(Dir.home, T.nilable(String)) @old_git_config_global = T.let(ENV.fetch("GIT_CONFIG_GLOBAL", nil), T.nilable(String)) Object.send(:remove_const, :HOMEBREW_PREFIX) Object.const_set(:HOMEBREW_PREFIX, Pathname.new(HOMEBREW_PREFIX_PLACEHOLDER)) ENV["HOME"] = HOMEBREW_HOME_PLACEHOLDER ENV["GIT_CONFIG_GLOBAL"] = File.join(@old_home, ".gitconfig") @generating_hash = T.let(true, T.nilable(T::Boolean)) end sig { void } def generated_hash! return unless generating_hash? # Revert monkeypatches for API generation Object.send(:remove_const, :HOMEBREW_PREFIX) Object.const_set(:HOMEBREW_PREFIX, @old_homebrew_prefix) ENV["HOME"] = @old_home ENV["GIT_CONFIG_GLOBAL"] = @old_git_config_global @generating_hash = false end sig { returns(T::Boolean) } def generating_hash? @generating_hash ||= false @generating_hash == true end sig { type_parameters(:U).params(value: T.type_parameter(:U)).returns(T.type_parameter(:U)) } def deep_remove_placeholders(value) return value if generating_hash? value = case value when Hash value.transform_values { |v| deep_remove_placeholders(v) } when Array value.map { |v| deep_remove_placeholders(v) } when String value.gsub(HOMEBREW_HOME_PLACEHOLDER, Dir.home) .gsub(HOMEBREW_PREFIX_PLACEHOLDER, HOMEBREW_PREFIX) .gsub(HOMEBREW_CELLAR_PLACEHOLDER, HOMEBREW_CELLAR) else value end T.cast(value, T.type_parameter(:U)) end end Homebrew-brew-d7f73ce/Library/Homebrew/ast_constants.rb000066400000000000000000000051761517265720000233250ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "macos_version" FORMULA_COMPONENT_PRECEDENCE_LIST = T.let([ [{ name: :include, type: :method_call }], [{ name: :desc, type: :method_call }], [{ name: :homepage, type: :method_call }], [{ name: :url, type: :method_call }], [{ name: :mirror, type: :method_call }], [{ name: :version, type: :method_call }], [{ name: :sha256, type: :method_call }], [{ name: :license, type: :method_call }], [{ name: :revision, type: :method_call }], [{ name: :version_scheme, type: :method_call }], [{ name: :compatibility_version, type: :method_call }], [{ name: :head, type: :method_call }], [{ name: :stable, type: :block_call }], [{ name: :livecheck, type: :block_call }], [{ name: :no_autobump!, type: :method_call }], [{ name: :bottle, type: :block_call }], [{ name: :pour_bottle?, type: :block_call }], [{ name: :head, type: :block_call }], [{ name: :bottle, type: :method_call }], [{ name: :keg_only, type: :method_call }], [{ name: :option, type: :method_call }], [{ name: :deprecated_option, type: :method_call }], [{ name: :deprecate!, type: :method_call }], [{ name: :disable!, type: :method_call }], [{ name: :depends_on, type: :method_call }], [{ name: :uses_from_macos, type: :method_call }], [{ name: :on_macos, type: :block_call }], *MacOSVersion::SYMBOLS.keys.map do |os_name| [{ name: :"on_#{os_name}", type: :block_call }] end, [{ name: :on_system, type: :block_call }], [{ name: :on_linux, type: :block_call }], [{ name: :on_arm, type: :block_call }], [{ name: :on_intel, type: :block_call }], [{ name: :conflicts_with, type: :method_call }], [{ name: :preserve_rpath, type: :method_call }], [{ name: :skip_clean, type: :method_call }], [{ name: :cxxstdlib_check, type: :method_call }], [{ name: :link_overwrite, type: :method_call }], [{ name: :fails_with, type: :method_call }, { name: :fails_with, type: :block_call }], [{ name: :pypi_packages, type: :method_call }], [{ name: :resource, type: :block_call }], [{ name: :patch, type: :method_call }, { name: :patch, type: :block_call }], [{ name: :needs, type: :method_call }], [{ name: :allow_network_access!, type: :method_call }], [{ name: :deny_network_access!, type: :method_call }], [{ name: :install, type: :method_definition }], [{ name: :post_install, type: :method_definition }], [{ name: :caveats, type: :method_definition }], [{ name: :plist_options, type: :method_call }, { name: :plist, type: :method_definition }], [{ name: :test, type: :block_call }], ].freeze, T::Array[T::Array[{ name: Symbol, type: Symbol }]]) Homebrew-brew-d7f73ce/Library/Homebrew/attestation.rb000066400000000000000000000275021517265720000227760ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "date" require "json" require "utils/popen" require "utils/github/api" require "exceptions" require "system_command" require "utils/output" module Homebrew module Attestation extend SystemCommand::Mixin extend Utils::Output::Mixin # @api private HOMEBREW_CORE_REPO = "Homebrew/homebrew-core" # @api private BACKFILL_REPO = "trailofbits/homebrew-brew-verify" # No backfill attestations after this date are considered valid. # # This date is shortly after the backfill operation for homebrew-core # completed, as can be seen here: . # # In effect, this means that, even if an attacker is able to compromise the backfill # signing workflow, they will be unable to convince a verifier to accept their newer, # malicious backfilled signatures. # # @api private BACKFILL_CUTOFF = T.let(DateTime.new(2024, 3, 14).freeze, DateTime) # Raised when the attestation was not found. # # @api private class MissingAttestationError < RuntimeError; end # Raised when attestation verification fails. # # @api private class InvalidAttestationError < RuntimeError; end # Raised if attestation verification cannot continue due to missing # credentials. # # @api private class GhAuthNeeded < RuntimeError; end # Raised if attestation verification cannot continue due to invalid # credentials. # # @api private class GhAuthInvalid < RuntimeError; end # Raised if attestation verification cannot continue due to `gh` # being incompatible with attestations, typically because it's too old. # # @api private class GhIncompatible < RuntimeError; end # Returns whether attestation verification is enabled. # # @api private sig { returns(T::Boolean) } def self.enabled? return false if Homebrew::EnvConfig.no_verify_attestations? Homebrew::EnvConfig.verify_attestations? end # Returns a path to a suitable `gh` executable for attestation verification. # # @api private sig { returns(Pathname) } def self.gh_executable @gh_executable ||= T.let(nil, T.nilable(Pathname)) return @gh_executable if @gh_executable.present? # NOTE: We set HOMEBREW_NO_VERIFY_ATTESTATIONS when installing `gh` itself, # to prevent a cycle during bootstrapping. This can eventually be resolved # by vendoring a pure-Ruby Sigstore verifier client. @gh_executable = with_env(HOMEBREW_NO_VERIFY_ATTESTATIONS: "1") do ensure_executable!("gh", reason: "verifying attestations", latest: true) end end # Prioritize installing `gh` first if it's in the formula list # or check for the existence of the `gh` executable elsewhere. # # This ensures that a valid version of `gh` is installed before # we use it to check the attestations of any other formulae we # want to install. # # @api private sig { params(formulae: T::Array[Formula]).returns(T::Array[Formula]) } def self.sort_formulae_for_install(formulae) if (gh = formulae.find { |f| f.full_name == "gh" }) [gh] | formulae else Homebrew::Attestation.gh_executable formulae end end # Verifies the given bottle against a cryptographic attestation of build provenance. # # The provenance is verified as originating from `signing_repository`, which is a `String` # that should be formatted as a GitHub `owner/repository`. # # Callers may additionally pass in `signing_workflow`, which will scope the attestation # down to an exact GitHub Actions workflow, in # `https://github/OWNER/REPO/.github/workflows/WORKFLOW.yml@REF` format. # # @return [Hash] the JSON-decoded response. # @raise [GhAuthNeeded] on any authentication failures # @raise [InvalidAttestationError] on any verification failures # # @api private sig { params(bottle: Bottle, signing_repo: String, signing_workflow: T.nilable(String), subject: T.nilable(String)).returns(T::Hash[String, T.untyped]) } def self.check_attestation(bottle, signing_repo, signing_workflow = nil, subject = nil) cmd = ["attestation", "verify", bottle.cached_download, "--repo", signing_repo, "--format", "json"] cmd += ["--cert-identity", signing_workflow] if signing_workflow.present? # Fail early if we have no credentials. The command below invariably # fails without them, so this saves us an unnecessary subshell. credentials = GitHub::API.credentials raise GhAuthNeeded, "missing credentials" if credentials.blank? begin result = system_command!(gh_executable, args: cmd, env: { "GH_TOKEN" => credentials, "GH_HOST" => "github.com" }, secrets: [credentials], print_stderr: false, chdir: HOMEBREW_TEMP) rescue ErrorDuringExecution => e if e.exitstatus == 1 && e.stderr.include?("unknown command") raise GhIncompatible, "gh CLI is incompatible with attestations" end # Even if we have credentials, they may be invalid or malformed. if e.exitstatus == 4 || e.stderr.include?("HTTP 401: Bad credentials") raise GhAuthInvalid, "invalid credentials" end raise MissingAttestationError, "attestation not found: #{e}" if e.stderr.include?("HTTP 404: Not Found") raise InvalidAttestationError, "attestation verification failed: #{e}" end begin attestations = JSON.parse(result.stdout) rescue JSON::ParserError raise InvalidAttestationError, "attestation verification returned malformed JSON" end # `gh attestation verify` returns a JSON array of one or more results, # for all attestations that match the input's digest. We want to additionally # filter these down to just the attestation whose subject(s) contain the bottle's name. # As of 2024-12-04 GitHub's Artifact Attestation feature can put multiple subjects # in a single attestation, so we check every subject in each attestation # and select the first attestation with a matching subject. # In particular, this happens with v2.0.0 and later of the # `actions/attest` action. subject = bottle.filename.to_s if subject.blank? attestation = if bottle.tag.to_sym == :all # :all-tagged bottles are created by `brew bottle --merge`, and are not directly # bound to their own filename (since they're created by deduplicating other filenames). # To verify these, we parse each attestation subject and look for one with a matching # formula (name, version), but not an exact tag match. # This is sound insofar as the signature has already been verified. However, # longer term, we should also directly attest to `:all`-tagged bottles. attestations.find do |a| candidate_subjects = a.dig("verificationResult", "statement", "subject") candidate_subjects.any? do |candidate| candidate["name"].start_with? "#{bottle.filename.name}--#{bottle.filename.version}" end end else attestations.find do |a| candidate_subjects = a.dig("verificationResult", "statement", "subject") candidate_subjects.any? { |candidate| candidate["name"] == subject } end end raise InvalidAttestationError, "no attestation matches subject: #{subject}" if attestation.blank? attestation end ATTESTATION_MAX_RETRIES = 5 # Verifies the given bottle against a cryptographic attestation of build provenance # from homebrew-core's CI, falling back on a "backfill" attestation for older bottles. # # This is a specialization of `check_attestation` for homebrew-core. # # @return [Hash] the JSON-decoded response # @raise [GhAuthNeeded] on any authentication failures # @raise [InvalidAttestationError] on any verification failures # # @api private sig { params(bottle: Bottle).returns(T::Hash[String, T.untyped]) } def self.check_core_attestation(bottle) begin # Ideally, we would also constrain the signing workflow here, but homebrew-core # currently uses multiple signing workflows to produce bottles # (e.g. `dispatch-build-bottle.yml`, `dispatch-rebottle.yml`, etc.). # # We could check each of these (1) explicitly (slow), (2) by generating a pattern # to pass into `--cert-identity-regex` (requires us to build up a Go-style regex), # or (3) by checking the resulting JSON for the expected signing workflow. # # Long term, we should probably either do (3) *or* switch to a single reusable # workflow, which would then be our sole identity. However, GitHub's # attestations currently do not include reusable workflow state by default. attestation = check_attestation bottle, HOMEBREW_CORE_REPO return attestation rescue MissingAttestationError odebug "falling back on backfilled attestation for #{bottle.filename}" # Our backfilled attestation is a little unique: the subject is not just the bottle # filename, but also has the bottle's hosted URL hash prepended to it. # This was originally unintentional, but has a virtuous side effect of further # limiting domain separation on the backfilled signatures (by committing them to # their original bottle URLs). url_sha256 = if EnvConfig.bottle_domain == HOMEBREW_BOTTLE_DEFAULT_DOMAIN Digest::SHA256.hexdigest(bottle.url) else # If our bottle is coming from a mirror, we need to recompute the expected # non-mirror URL to make the hash match. checksum = bottle.resource.checksum odie "#{bottle.resource.name} checksum is nil" if checksum.nil? path, = Utils::Bottles.path_resolved_basename HOMEBREW_BOTTLE_DEFAULT_DOMAIN, bottle.name, checksum, bottle.filename url = "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}/#{path}" Digest::SHA256.hexdigest(url) end subject = "#{url_sha256}--#{bottle.filename}" # We don't pass in a signing workflow for backfill signatures because # some backfilled bottle signatures were signed from the 'backfill' # branch, and others from 'main' of trailofbits/homebrew-brew-verify # so the signing workflow is slightly different which causes some bottles to incorrectly # fail when checking their attestation. This shouldn't meaningfully affect security # because if somehow someone could generate false backfill attestations # from a different workflow we will still catch it because the # attestation would have been generated after our cutoff date. backfill_attestation = check_attestation bottle, BACKFILL_REPO, nil, subject timestamp = backfill_attestation.dig("verificationResult", "verifiedTimestamps", 0, "timestamp") raise InvalidAttestationError, "backfill attestation is missing verified timestamp" if timestamp.nil? if DateTime.parse(timestamp) > BACKFILL_CUTOFF raise InvalidAttestationError, "backfill attestation post-dates cutoff" end end backfill_attestation rescue InvalidAttestationError @attestation_retry_count ||= T.let(Hash.new(0), T.nilable(T::Hash[Bottle, Integer])) raise if @attestation_retry_count[bottle] >= ATTESTATION_MAX_RETRIES sleep_time = 3 ** @attestation_retry_count[bottle] opoo "Failed to verify attestation. Retrying in #{sleep_time}s..." sleep sleep_time if ENV["HOMEBREW_TESTS"].blank? @attestation_retry_count[bottle] += 1 retry end end end Homebrew-brew-d7f73ce/Library/Homebrew/autobump_constants.rb000066400000000000000000000015461517265720000243670ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true NO_AUTOBUMP_REASONS_INTERNAL = T.let({ extract_plist: "livecheck uses `:extract_plist` strategy", latest_version: "`version` is set to `:latest`", }.freeze, T::Hash[Symbol, String]) NO_AUTOBUMP_REASONS_DEPRECATED = T.let({ requires_manual_review: "a manual review of this package is required for inclusion in autobump", }.freeze, T::Hash[Symbol, String]) # The valid symbols for passing to `no_autobump!` in a `Formula` or `Cask`. # @api public NO_AUTOBUMP_REASONS_LIST = T.let( { incompatible_version_format: "the package has a version format that can only be updated manually", bumped_by_upstream: "updates to the package are handled by the upstream developers", } .merge(NO_AUTOBUMP_REASONS_INTERNAL) .merge(NO_AUTOBUMP_REASONS_DEPRECATED) .freeze, T::Hash[Symbol, String], ) Homebrew-brew-d7f73ce/Library/Homebrew/bottle.rb000066400000000000000000000172031517265720000217250ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true class Bottle include Downloadable class Filename sig { returns(String) } attr_reader :name, :tag sig { returns(PkgVersion) } attr_reader :version sig { returns(Integer) } attr_reader :rebuild sig { params(formula: Formula, tag: Utils::Bottles::Tag, rebuild: Integer).returns(T.attached_class) } def self.create(formula, tag, rebuild) new(formula.name, formula.pkg_version, tag, rebuild) end sig { params(name: String, version: PkgVersion, tag: Utils::Bottles::Tag, rebuild: Integer).void } def initialize(name, version, tag, rebuild) @name = T.let(File.basename(name), String) raise ArgumentError, "Invalid bottle name" unless Utils.safe_filename?(@name) raise ArgumentError, "Invalid bottle version" unless Utils.safe_filename?(version.to_s) @version = version @tag = T.let(tag.to_unstandardized_sym.to_s, String) @rebuild = rebuild end sig { returns(String) } def to_str "#{name}--#{version}#{extname}" end sig { returns(String) } def to_s = to_str sig { returns(String) } def json "#{name}--#{version}.#{tag}.bottle.json" end sig { returns(String) } def url_encode ERB::Util.url_encode("#{name}-#{version}#{extname}") end sig { returns(String) } def github_packages "#{name}--#{version}#{extname}" end sig { returns(String) } def extname s = rebuild.positive? ? ".#{rebuild}" : "" ".#{tag}.bottle#{s}.tar.gz" end end extend Forwardable sig { returns(String) } attr_reader :name sig { returns(Resource) } attr_reader :resource sig { returns(Utils::Bottles::Tag) } attr_reader :tag sig { returns(T.any(String, Symbol)) } attr_reader :cellar sig { returns(Integer) } attr_reader :rebuild def_delegators :resource, :url, :verify_download_integrity def_delegators :resource, :cached_download, :downloader sig { params(formula: Formula, spec: BottleSpecification, tag: T.nilable(Utils::Bottles::Tag)).void } def initialize(formula, spec, tag = nil) super() @name = T.let(formula.name, String) @resource = T.let(Resource.new, Resource) @resource.owner = formula @spec = spec tag_spec = spec.tag_specification_for(Utils::Bottles.tag(tag)) odie "#{formula.name} tag specification for tag #{tag} is nil" if tag_spec.nil? @tag = T.let(tag_spec.tag, Utils::Bottles::Tag) @cellar = T.let(tag_spec.cellar, T.any(String, Symbol)) @rebuild = T.let(spec.rebuild, Integer) @resource.version(formula.pkg_version.to_s) @resource.checksum = tag_spec.checksum @fetch_tab_retried = T.let(false, T::Boolean) root_url(spec.root_url, spec.root_url_specs) end sig { override.params( verify_download_integrity: T::Boolean, timeout: T.nilable(T.any(Integer, Float)), quiet: T::Boolean, ).returns(Pathname) } def fetch(verify_download_integrity: true, timeout: nil, quiet: false) resource.fetch(verify_download_integrity:, timeout:, quiet:) rescue DownloadError raise unless fallback_on_error? fetch_tab retry end sig { override.returns(T.nilable(Integer)) } def total_size bottle_size || super end sig { override.void } def clear_cache @resource.clear_cache github_packages_manifest_resource&.clear_cache @fetch_tab_retried = false end sig { returns(T::Boolean) } def compatible_locations? @spec.compatible_locations?(tag: @tag) end # Does the bottle need to be relocated? sig { returns(T::Boolean) } def skip_relocation? @spec.skip_relocation?(tag: @tag) end sig { void } def stage = downloader.stage sig { params(timeout: T.nilable(T.any(Integer, Float)), quiet: T::Boolean).void } def fetch_tab(timeout: nil, quiet: false) return unless (resource = github_packages_manifest_resource) begin resource.fetch(timeout:, quiet:) rescue DownloadError raise unless fallback_on_error? retry rescue Resource::BottleManifest::Error raise if @fetch_tab_retried @fetch_tab_retried = true resource.clear_cache retry end end sig { returns(T::Hash[String, T.untyped]) } def tab_attributes if (resource = github_packages_manifest_resource) && resource.downloaded? return resource.tab end {} end sig { returns(T.nilable(Integer)) } def bottle_size resource = github_packages_manifest_resource return unless resource&.downloaded? resource.bottle_size end sig { returns(T.nilable(Integer)) } def installed_size resource = github_packages_manifest_resource return unless resource&.downloaded? resource.installed_size end sig { returns(Filename) } def filename Filename.create(T.cast(resource.owner, Formula), @tag, @spec.rebuild) end sig { returns(T.nilable(Resource::BottleManifest)) } def github_packages_manifest_resource return if @resource.download_strategy != CurlGitHubPackagesDownloadStrategy @github_packages_manifest_resource ||= T.let( begin resource = Resource::BottleManifest.new(self) version_rebuild = GitHubPackages.version_rebuild(T.must(@resource.version), rebuild) resource.version(version_rebuild) image_name = GitHubPackages.image_formula_name(@name) image_tag = GitHubPackages.image_version_rebuild(version_rebuild) resource.url( "#{root_url}/#{image_name}/manifests/#{image_tag}", using: CurlGitHubPackagesDownloadStrategy, headers: ["Accept: application/vnd.oci.image.index.v1+json"], ) T.cast(resource.downloader, CurlGitHubPackagesDownloadStrategy).resolved_basename = "#{name}-#{version_rebuild}.bottle_manifest.json" resource end, T.nilable(Resource::BottleManifest), ) end sig { override.returns(String) } def download_queue_type = "Bottle" sig { override.returns(String) } def download_queue_name = "#{name} (#{resource.version})" private sig { params(specs: T::Hash[Symbol, T.anything]).returns(T::Hash[Symbol, T.anything]) } def select_download_strategy(specs) odie "cannot select download strategy for #{name} because root_url is nil" if @root_url.nil? specs[:using] ||= DownloadStrategyDetector.detect(@root_url) specs[:bottle] = true specs end sig { returns(T::Boolean) } def fallback_on_error? # Use the default bottle domain as a fallback mirror if @resource.url&.start_with?(Homebrew::EnvConfig.bottle_domain) && Homebrew::EnvConfig.bottle_domain != HOMEBREW_BOTTLE_DEFAULT_DOMAIN opoo "Bottle missing, falling back to the default domain..." root_url(HOMEBREW_BOTTLE_DEFAULT_DOMAIN) @github_packages_manifest_resource = T.let(nil, T.nilable(Resource::BottleManifest)) true else false end end sig { params(val: T.nilable(String), specs: T::Hash[Symbol, T.anything]).returns(T.nilable(String)) } def root_url(val = nil, specs = {}) return @root_url if val.nil? @root_url = T.let(val, T.nilable(String)) filename = Filename.create(T.cast(resource.owner, Formula), @tag, @spec.rebuild) resource_checksum = resource.checksum odie "resource checksum is nil" if resource_checksum.nil? path, resolved_basename = Utils::Bottles.path_resolved_basename(val, name, resource_checksum, filename) @resource.url("#{val}/#{path}", **select_download_strategy(specs)) return unless resolved_basename.present? downloader = @resource.downloader return unless downloader.is_a?(CurlGitHubPackagesDownloadStrategy) downloader.resolved_basename = resolved_basename end end Homebrew-brew-d7f73ce/Library/Homebrew/bottle_specification.rb000066400000000000000000000125431517265720000246270ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true class BottleSpecification include Utils::Output::Mixin RELOCATABLE_CELLARS = [:any, :any_skip_relocation].freeze sig { returns(T.nilable(Tap)) } attr_accessor :tap sig { returns(Utils::Bottles::Collector) } attr_reader :collector sig { returns(T::Hash[Symbol, T.untyped]) } attr_reader :root_url_specs sig { returns(String) } attr_reader :repository sig { void } def initialize @rebuild = T.let(0, Integer) @repository = T.let(Homebrew::DEFAULT_REPOSITORY, String) @collector = T.let(Utils::Bottles::Collector.new, Utils::Bottles::Collector) @root_url_specs = T.let({}, T::Hash[Symbol, T.untyped]) @root_url = T.let(nil, T.nilable(String)) end sig { params(val: Integer).returns(Integer) } def rebuild(val = T.unsafe(nil)) val.nil? ? @rebuild : @rebuild = val end sig { params(var: T.nilable(String), specs: T::Hash[Symbol, T.untyped]).returns(String) } def root_url(var = nil, specs = {}) if var.nil? @root_url ||= if (github_packages_url = GitHubPackages.root_url_if_match(Homebrew::EnvConfig.bottle_domain)) github_packages_url else Homebrew::EnvConfig.bottle_domain end else @root_url = if (github_packages_url = GitHubPackages.root_url_if_match(var)) github_packages_url else var end @root_url_specs.merge!(specs) @root_url end end sig { override.params(other: BasicObject).returns(T::Boolean) } def ==(other) case other when self.class rebuild == other.rebuild && collector == other.collector && root_url == other.root_url && root_url_specs == other.root_url_specs && tap == other.tap else false end end alias eql? == sig { params(tag: Utils::Bottles::Tag).returns(T.any(Symbol, String)) } def tag_to_cellar(tag = Utils::Bottles.tag) spec = collector.specification_for(tag) if spec.present? spec.cellar else tag.default_cellar end end sig { params(tag: Utils::Bottles::Tag).returns(T::Boolean) } def compatible_locations?(tag: Utils::Bottles.tag) cellar = tag_to_cellar(tag) return true if RELOCATABLE_CELLARS.include?(cellar) prefix = Pathname(cellar.to_s).parent.to_s cellar_relocatable = cellar.size >= HOMEBREW_CELLAR.to_s.size && ENV["HOMEBREW_RELOCATE_BUILD_PREFIX"].present? prefix_relocatable = prefix.size >= HOMEBREW_PREFIX.to_s.size && ENV["HOMEBREW_RELOCATE_BUILD_PREFIX"].present? compatible_cellar = cellar == HOMEBREW_CELLAR.to_s || cellar_relocatable compatible_prefix = prefix == HOMEBREW_PREFIX.to_s || prefix_relocatable compatible_cellar && compatible_prefix end # Does the {Bottle} this {BottleSpecification} belongs to need to be relocated? sig { params(tag: Utils::Bottles::Tag).returns(T::Boolean) } def skip_relocation?(tag: Utils::Bottles.tag) spec = collector.specification_for(tag) spec&.cellar == :any_skip_relocation end sig { params(tag: Utils::Bottles::Tag, no_older_versions: T::Boolean).returns(T::Boolean) } def tag?(tag, no_older_versions: false) collector.tag?(tag, no_older_versions:) end # Checksum methods in the DSL's bottle block take # a Hash, which indicates the platform the checksum applies on. # Example bottle block syntax: # bottle do # sha256 cellar: :any_skip_relocation, big_sur: "69489ae397e4645..." # sha256 cellar: :any, catalina: "449de5ea35d0e94..." # end sig { params(hash: T::Hash[T.any(Symbol, String), T.any(String, Symbol)]).void } def sha256(hash) sha256_regex = /^[a-f0-9]{64}$/i # find new `sha256 big_sur: "69489ae397e4645..."` format tag, digest = hash.find do |key, value| # Don't use `odie` in this case. We want to be able to catch this exception # in runtime when getting committed version info in formula auditor raise LegacyDSLError.new(:sha256, hash) if key.is_a?(String) && key.match?(sha256_regex) && value.is_a?(Symbol) key.is_a?(Symbol) && value.is_a?(String) && value.match?(sha256_regex) end odie "Invalid sha256 hash: #{digest}" if !tag || !digest tag = Utils::Bottles::Tag.from_symbol(T.cast(tag, Symbol)) cellar = hash[:cellar] || tag.default_cellar collector.add(tag, checksum: Checksum.new(digest.to_s), cellar:) end sig { params(tag: Utils::Bottles::Tag, no_older_versions: T::Boolean) .returns(T.nilable(Utils::Bottles::TagSpecification)) } def tag_specification_for(tag, no_older_versions: false) collector.specification_for(tag, no_older_versions:) end sig { returns(T::Array[{ "tag" => Symbol, "digest" => Checksum, "cellar" => T.any(Symbol, String) }]) } def checksums tags = collector.tags.sort_by do |tag| version = tag.to_macos_version # Give `arm64` bottles a higher priority so they are first. priority = (tag.arch == :arm64) ? 3 : 2 "#{priority}.#{version}_#{tag}" rescue MacOSVersion::Error # Sort non-macOS tags below macOS tags, and arm64 tags before other tags. priority = (tag.arch == :arm64) ? 1 : 0 "#{priority}.#{tag}" end tags.reverse.map do |tag| spec = collector.specification_for(tag) odie "Specification for tag #{tag} is nil" if spec.nil? { "tag" => spec.tag.to_sym, "digest" => spec.checksum, "cellar" => spec.cellar, } end end end require "extend/os/bottle_specification" Homebrew-brew-d7f73ce/Library/Homebrew/brew.rb000066400000000000000000000175471517265720000214060ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # `HOMEBREW_STACKPROF` should be set via `brew prof --stackprof`, not manually. if ENV["HOMEBREW_STACKPROF"] require "rubygems" require "stackprof" StackProf.start(mode: :wall, raw: true) end raise "HOMEBREW_BREW_FILE was not exported! Please call bin/brew directly!" unless ENV["HOMEBREW_BREW_FILE"] if $PROGRAM_NAME != __FILE__ && !$PROGRAM_NAME.end_with?("/bin/ruby-prof") raise "#{__FILE__} must not be loaded via `require`." end std_trap = trap("INT") { exit! 130 } # no backtrace thanks require_relative "global" require "utils/output" begin trap("INT", std_trap) # restore default CTRL-C handler if ENV["CI"] $stdout.sync = true $stderr.sync = true end empty_argv = ARGV.empty? help_flag_list = %w[-h --help --usage -?] help_flag = !ENV["HOMEBREW_HELP"].nil? help_cmd_index = T.let(nil, T.nilable(Integer)) cmd = T.let(nil, T.nilable(String)) ARGV.each_with_index do |arg, i| break if help_flag && cmd if arg == "help" && !cmd # Command-style help: `help ` is fine, but ` help` is not. help_flag = true help_cmd_index = i elsif !cmd && help_flag_list.exclude?(arg) cmd = ARGV.delete_at(i) end end ARGV.delete_at(help_cmd_index) if help_cmd_index require "cli/parser" args = Homebrew::CLI::Parser.new(Homebrew::Cmd::Brew).parse(ARGV.dup.freeze, ignore_invalid_options: true) Context.current = args.context path = PATH.new(ENV.fetch("PATH")) homebrew_path = PATH.new(ENV.fetch("HOMEBREW_PATH")) # Add shared wrappers. path.prepend(HOMEBREW_SHIMS_PATH/"shared") homebrew_path.prepend(HOMEBREW_SHIMS_PATH/"shared") ENV["PATH"] = path.to_s require "commands" internal_cmd = T.let(false, T::Boolean) external_ruby_v2_cmd = T.let(false, T::Boolean) external_ruby_cmd_path = T.let(nil, T.nilable(Pathname)) external_cmd_path = T.let(nil, T.nilable(Pathname)) if cmd cmd = Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.fetch(cmd, cmd) internal_cmd = Commands.valid_internal_cmd?(cmd) || Commands.valid_internal_dev_cmd?(cmd) unless internal_cmd # Add contributed commands to PATH before checking. homebrew_path.append(Commands.tap_cmd_directories) # External commands expect a normal PATH ENV["PATH"] = homebrew_path.to_s external_ruby_v2_cmd = Commands.external_ruby_v2_cmd_path(cmd).present? external_ruby_cmd_path = Commands.external_ruby_cmd_path(cmd) unless external_ruby_v2_cmd external_cmd_path = Commands.external_cmd_path(cmd) if !external_ruby_v2_cmd && external_ruby_cmd_path.nil? end end # Usage instructions should be displayed if and only if one of: # - a help flag is passed AND a command is matched # - a help flag is passed AND there is no command specified # - no arguments are passed if empty_argv || help_flag require "help" Homebrew::Help.help cmd, remaining_args: args.remaining, empty_argv: # `Homebrew::Help.help` never returns, except for unknown commands. end if cmd.nil? raise UsageError, "Unknown command: brew #{ARGV.join(" ")}" elsif internal_cmd || external_ruby_v2_cmd cmd_class = Homebrew::AbstractCommand.command(cmd) if cmd_class&.include?(Homebrew::ShellCommand) exec (HOMEBREW_LIBRARY_PATH.parent.parent/"bin/brew").to_s, cmd, *ARGV end Homebrew.running_command = cmd if cmd_class unless Homebrew::EnvConfig.no_install_from_api? require "api" Homebrew::API.fetch_api_files! end command_instance = cmd_class.new require "utils/analytics" Utils::Analytics.report_command_run(command_instance) command_instance.run else Utils::Output.odeprecated "Calling `brew #{cmd}` without subclassing `AbstractCommand`", "subclassing of `Homebrew::AbstractCommand` " \ "(see https://docs.brew.sh/External-Commands)" begin Homebrew.public_send Commands.method_name(cmd) rescue NoMethodError => e converted_cmd = cmd.downcase.tr("-", "_") case_error = "undefined method `#{converted_cmd}' for module Homebrew" private_method_error = "private method `#{converted_cmd}' called for module Homebrew" Utils::Output.odie "Unknown command: brew #{cmd}" if [case_error, private_method_error].include?(e.message) raise end end elsif external_ruby_cmd_path Homebrew.running_command = cmd Homebrew.require?(external_ruby_cmd_path) exit Homebrew.failed? ? 1 : 0 elsif external_cmd_path %w[CACHE LIBRARY_PATH].each do |env| ENV["HOMEBREW_#{env}"] = Object.const_get(:"HOMEBREW_#{env}").to_s end exec external_cmd_path.to_s, *ARGV else raise UsageError, "Unknown command: brew #{cmd}" end rescue UsageError => e require "help" Homebrew::Help.help cmd, remaining_args: args&.remaining || [], usage_error: e.message rescue SystemExit => e Utils::Output.onoe "Kernel.exit" if args&.debug? && !e.success? if args&.debug? || ARGV.include?("--debug") require "utils/backtrace" $stderr.puts Utils::Backtrace.clean(e) end raise rescue Interrupt $stderr.puts # seemingly a newline is typical exit 130 rescue BuildError => e Utils::Analytics.report_build_error(e) e.dump(verbose: args&.verbose? || false) if OS.not_tier_one_configuration? $stderr.puts <<~EOS This build failure was expected, as this is not a Tier 1 configuration: #{Formatter.url("https://docs.brew.sh/Support-Tiers")} #{Formatter.bold("Do not report any issues to Homebrew/* repositories!")} Read the above document instead before opening any issues or PRs. EOS elsif (formula = e.formula) && (formula.head? || formula.deprecated? || formula.disabled?) reason = if formula.head? "was built from an unstable upstream --HEAD" elsif formula.deprecated? "is deprecated" elsif formula.disabled? "is disabled" end $stderr.puts <<~EOS #{formula.name}'s formula #{reason}. This build failure is expected behaviour. EOS end exit 1 rescue RuntimeError, SystemCallError => e raise if e.message.empty? Utils::Output.onoe e if args&.debug? || ARGV.include?("--debug") require "utils/backtrace" $stderr.puts Utils::Backtrace.clean(e) end exit 1 # Catch any other types of exceptions. rescue Exception => e # rubocop:disable Lint/RescueException Utils::Output.onoe e method_deprecated_error = e.is_a?(MethodDeprecatedError) require "utils/backtrace" $stderr.puts Utils::Backtrace.clean(e) if args&.debug? || ARGV.include?("--debug") || !method_deprecated_error if OS.not_tier_one_configuration? $stderr.puts <<~EOS This error was expected, as this is not a Tier 1 configuration: #{Formatter.url("https://docs.brew.sh/Support-Tiers")} #{Formatter.bold("Do not report any issues to Homebrew/* repositories!")} Read the above document instead before opening any issues or PRs. EOS elsif Homebrew::EnvConfig.no_auto_update? && (fetch_head = HOMEBREW_REPOSITORY/".git/FETCH_HEAD") && (!fetch_head.exist? || (fetch_head.mtime.to_date < Date.today)) $stderr.puts "#{Tty.bold}You have disabled automatic updates and have not updated today.#{Tty.reset}" $stderr.puts "#{Tty.bold}Do not report this issue until you've run `brew update` and tried again.#{Tty.reset}" elsif (issues_url = (method_deprecated_error && e.issues_url) || Utils::Backtrace.tap_error_url(e)) $stderr.puts "If reporting this issue please do so at (not Homebrew/* repositories):" $stderr.puts " #{Formatter.url(issues_url)}" elsif internal_cmd && !method_deprecated_error $stderr.puts "#{Tty.bold}Please report this issue:#{Tty.reset}" $stderr.puts " #{Formatter.url(OS::ISSUES_URL)}" end exit 1 else exit 1 if Homebrew.failed? ensure if ENV["HOMEBREW_STACKPROF"] StackProf.stop StackProf.results("prof/stackprof.dump") end end Homebrew-brew-d7f73ce/Library/Homebrew/brew.sh000066400000000000000000001121231517265720000213770ustar00rootroot00000000000000##### ##### First do the essential, fast things to ensure commands like `brew --prefix` and others that we want ##### to be able to `source` in shell configurations run quickly. ##### case "${MACHTYPE}" in arm64-* | aarch64-*) HOMEBREW_PROCESSOR="arm64" ;; x86_64-*) HOMEBREW_PROCESSOR="x86_64" ;; *) HOMEBREW_PROCESSOR="$(uname -m)" ;; esac case "${OSTYPE}" in darwin*) HOMEBREW_SYSTEM="Darwin" HOMEBREW_MACOS="1" ;; linux*) HOMEBREW_SYSTEM="Linux" HOMEBREW_LINUX="1" ;; *) HOMEBREW_SYSTEM="$(uname -s)" ;; esac HOMEBREW_PHYSICAL_PROCESSOR="${HOMEBREW_PROCESSOR}" HOMEBREW_MACOS_ARM_DEFAULT_PREFIX="/opt/homebrew" HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY="${HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}" HOMEBREW_LINUX_DEFAULT_PREFIX="/home/linuxbrew/.linuxbrew" HOMEBREW_LINUX_DEFAULT_REPOSITORY="${HOMEBREW_LINUX_DEFAULT_PREFIX}/Homebrew" HOMEBREW_GENERIC_DEFAULT_PREFIX="/usr/local" HOMEBREW_GENERIC_DEFAULT_REPOSITORY="${HOMEBREW_GENERIC_DEFAULT_PREFIX}/Homebrew" if [[ -n "${HOMEBREW_MACOS}" && "${HOMEBREW_PROCESSOR}" == "arm64" ]] then HOMEBREW_DEFAULT_PREFIX="${HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}" HOMEBREW_DEFAULT_REPOSITORY="${HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY}" elif [[ -n "${HOMEBREW_LINUX}" ]] then HOMEBREW_DEFAULT_PREFIX="${HOMEBREW_LINUX_DEFAULT_PREFIX}" HOMEBREW_DEFAULT_REPOSITORY="${HOMEBREW_LINUX_DEFAULT_REPOSITORY}" else HOMEBREW_DEFAULT_PREFIX="${HOMEBREW_GENERIC_DEFAULT_PREFIX}" HOMEBREW_DEFAULT_REPOSITORY="${HOMEBREW_GENERIC_DEFAULT_REPOSITORY}" fi if [[ -n "${HOMEBREW_MACOS}" ]] then HOMEBREW_DEFAULT_CACHE="${HOME}/Library/Caches/Homebrew" HOMEBREW_DEFAULT_LOGS="${HOME}/Library/Logs/Homebrew" HOMEBREW_DEFAULT_TEMP="/private/tmp" else CACHE_HOME="${HOMEBREW_XDG_CACHE_HOME:-${HOME}/.cache}" HOMEBREW_DEFAULT_CACHE="${CACHE_HOME}/Homebrew" HOMEBREW_DEFAULT_LOGS="${CACHE_HOME}/Homebrew/Logs" if [[ -r "/var/tmp" && -w "/var/tmp" ]] then HOMEBREW_DEFAULT_TEMP="/var/tmp" else HOMEBREW_DEFAULT_TEMP="/tmp" fi fi realpath() { (cd "$1" &>/dev/null && pwd -P) } # Support systems where HOMEBREW_PREFIX is the default, # but a parent directory is a symlink. # Example: Fedora Silverblue symlinks /home -> /var/home if [[ "${HOMEBREW_PREFIX}" != "${HOMEBREW_DEFAULT_PREFIX}" && "$(realpath "${HOMEBREW_DEFAULT_PREFIX}")" == "${HOMEBREW_PREFIX}" ]] then HOMEBREW_PREFIX="${HOMEBREW_DEFAULT_PREFIX}" fi # Support systems where HOMEBREW_REPOSITORY is the default, # but a parent directory is a symlink. # Example: Fedora Silverblue symlinks /home -> var/home if [[ "${HOMEBREW_REPOSITORY}" != "${HOMEBREW_DEFAULT_REPOSITORY}" && "$(realpath "${HOMEBREW_DEFAULT_REPOSITORY}")" == "${HOMEBREW_REPOSITORY}" ]] then HOMEBREW_REPOSITORY="${HOMEBREW_DEFAULT_REPOSITORY}" fi # Where we store built products; a Cellar in HOMEBREW_PREFIX (often /usr/local # for bottles) unless there's already a Cellar in HOMEBREW_REPOSITORY. # These variables are set by bin/brew # shellcheck disable=SC2154 if [[ -d "${HOMEBREW_REPOSITORY}/Cellar" ]] then HOMEBREW_CELLAR="${HOMEBREW_REPOSITORY}/Cellar" else HOMEBREW_CELLAR="${HOMEBREW_PREFIX}/Cellar" fi # Support systems where HOMEBREW_CELLAR's parent directory is a symlink. # Example: Fedora Silverblue symlinks /home -> /var/home HOMEBREW_CELLAR_DEFAULT_PREFIX="${HOMEBREW_DEFAULT_PREFIX}/Cellar" if [[ "${HOMEBREW_CELLAR}" != "${HOMEBREW_CELLAR_DEFAULT_PREFIX}" && "$(realpath "${HOMEBREW_CELLAR_DEFAULT_PREFIX}")" == "${HOMEBREW_CELLAR}" ]] then HOMEBREW_CELLAR="${HOMEBREW_CELLAR_DEFAULT_PREFIX}" fi HOMEBREW_CASKROOM="${HOMEBREW_PREFIX}/Caskroom" HOMEBREW_CACHE="${HOMEBREW_CACHE:-${HOMEBREW_DEFAULT_CACHE}}" HOMEBREW_LOGS="${HOMEBREW_LOGS:-${HOMEBREW_DEFAULT_LOGS}}" HOMEBREW_TEMP="${HOMEBREW_TEMP:-${HOMEBREW_DEFAULT_TEMP}}" if [[ ! -w "${HOMEBREW_TEMP}" ]] then HOMEBREW_TEMP="${HOMEBREW_DEFAULT_TEMP}" fi # brew shellenv needs HOMEBREW_MACOS_VERSION_NUMERIC if [[ -n "${HOMEBREW_MACOS}" ]] then HOMEBREW_MACOS_VERSION="$(/usr/bin/sw_vers -productVersion)" IFS=. read -r -a MACOS_VERSION_ARRAY < <(printf '%s' "${HOMEBREW_MACOS_VERSION}") printf -v HOMEBREW_MACOS_VERSION_NUMERIC "%02d%02d%02d" "${MACOS_VERSION_ARRAY[@]}" unset MACOS_VERSION_ARRAY fi # commands that take a single or no arguments. # HOMEBREW_LIBRARY set by bin/brew # shellcheck disable=SC2154 # doesn't need a default case as other arguments handled elsewhere. # shellcheck disable=SC2249 case "$1" in formulae) source "${HOMEBREW_LIBRARY}/Homebrew/cmd/formulae.sh" homebrew-formulae exit 0 ;; casks) source "${HOMEBREW_LIBRARY}/Homebrew/cmd/casks.sh" homebrew-casks exit 0 ;; shellenv) source "${HOMEBREW_LIBRARY}/Homebrew/cmd/shellenv.sh" shift homebrew-shellenv "$1" exit 0 ;; esac source "${HOMEBREW_LIBRARY}/Homebrew/help.sh" # functions that take multiple arguments or handle multiple commands. # doesn't need a default case as other arguments handled elsewhere. # shellcheck disable=SC2249 case "$@" in --cellar) echo "${HOMEBREW_CELLAR}" exit 0 ;; --repository | --repo) echo "${HOMEBREW_REPOSITORY}" exit 0 ;; --caskroom) echo "${HOMEBREW_CASKROOM}" exit 0 ;; --cache) echo "${HOMEBREW_CACHE}" exit 0 ;; --taps) source "${HOMEBREW_LIBRARY}/Homebrew/cmd/--taps.sh" homebrew---taps "$@" && exit 0 ;; # falls back to cmd/--prefix.rb and cmd/--cellar.rb on a non-zero return --prefix* | --cellar*) source "${HOMEBREW_LIBRARY}/Homebrew/formula_path.sh" homebrew-formula-path "$@" && exit 0 ;; # falls back to cmd/command.rb on a non-zero return command*) source "${HOMEBREW_LIBRARY}/Homebrew/command_path.sh" homebrew-command-path "$@" && exit 0 ;; # falls back to cmd/list.rb on a non-zero return list* | ls*) source "${HOMEBREW_LIBRARY}/Homebrew/list.sh" homebrew-list "$@" && exit 0 ;; # homebrew-tap only handles invocations with no arguments tap) source "${HOMEBREW_LIBRARY}/Homebrew/tap.sh" homebrew-tap "$@" exit 0 ;; # falls back to cmd/help.rb on a non-zero return help | --help | -h | --usage | "-?" | "") homebrew-help "$@" && exit 0 ;; esac # Check `HOMEBREW_FORCE_BREW_WRAPPER` for all non-trivial commands # (i.e. not defined above this line e.g. formulae or --cellar). if [[ -n "${HOMEBREW_FORCE_BREW_WRAPPER:-}" ]] then source "${HOMEBREW_LIBRARY}/Homebrew/utils/wrapper.sh" check-brew-wrapper "$1" fi # commands that take a single or no arguments and need to write to HOMEBREW_PREFIX. # HOMEBREW_LIBRARY set by bin/brew # shellcheck disable=SC2154 # doesn't need a default case as other arguments handled elsewhere. # shellcheck disable=SC2249 case "$1" in setup-ruby) source "${HOMEBREW_LIBRARY}/Homebrew/cmd/setup-ruby.sh" shift homebrew-setup-ruby "$1" exit 0 ;; esac ##### ##### Next, define all other helper functions. ##### source "${HOMEBREW_LIBRARY}/Homebrew/utils/helpers.sh" check-run-command-as-root() { [[ "${EUID}" == 0 || "${UID}" == 0 ]] || return # Allow Azure Pipelines/GitHub Actions/Docker/Podman/Concourse/Kubernetes to do everything as root (as it's normal there) [[ -f /.dockerenv ]] && return [[ -f /run/.containerenv ]] && return [[ -f /proc/1/cgroup ]] && grep -E "azpl_job|actions_job|docker|garden|kubepods" -q /proc/1/cgroup && return # `brew services` may need `sudo` for system-wide daemons. if [[ "${HOMEBREW_COMMAND}" == "services" ]] then # Need to disable Bootsnap when running as root to avoid permission errors: # https://github.com/Homebrew/brew/issues/19904 export HOMEBREW_NO_BOOTSNAP="1" return fi # It's fine to run this as root as it's not changing anything. [[ "${HOMEBREW_COMMAND}" == "--prefix" ]] && return odie </dev/null)" ]] then needs_auto_update=1 break fi done if [[ -z "${needs_auto_update}" ]] then return fi brew update --auto-update unset HOMEBREW_AUTO_UPDATING unset HOMEBREW_AUTO_UPDATE_TAP if [[ $# -gt 0 ]] then # exec a new process to set any new environment variables. exec "${HOMEBREW_BREW_FILE}" "$@" fi fi unset AUTO_UPDATE_COMMANDS unset AUTO_UPDATE_CORE_TAP_COMMANDS unset AUTO_UPDATE_CASK_TAP_COMMANDS unset HOMEBREW_AUTO_UPDATE_CORE_TAP unset HOMEBREW_AUTO_UPDATE_CASK_TAP } # Only `brew update-if-needed` should be handled here. # We want it as fast as possible but it needs auto-update() defined above. # HOMEBREW_LIBRARY set by bin/brew # shellcheck disable=SC2154 # doesn't need a default case as other arguments handled elsewhere. # shellcheck disable=SC2249 # Don't need to pass through any arguments. # shellcheck disable=SC2119 case "$@" in update-if-needed) source "${HOMEBREW_LIBRARY}/Homebrew/cmd/update-if-needed.sh" homebrew-update-if-needed exit 0 ;; esac ##### ##### Setup output so e.g. odie looks as nice as possible. ##### # Colorize output on GitHub Actions. # This is set by the user environment. # shellcheck disable=SC2154 if [[ -n "${GITHUB_ACTIONS}" ]] then export HOMEBREW_COLOR="1" fi # Force UTF-8 to avoid encoding issues for users with broken locale settings. if [[ -n "${HOMEBREW_MACOS}" ]] then if [[ "$(locale charmap)" != "UTF-8" ]] then export LC_ALL="en_US.UTF-8" fi else if ! command -v locale >/dev/null then export LC_ALL=C elif [[ "$(locale charmap)" != "UTF-8" ]] then locales="$(locale -a)" c_utf_regex='\bC\.(utf8|UTF-8)\b' en_us_regex='\ben_US\.(utf8|UTF-8)\b' utf_regex='\b[a-z][a-z]_[A-Z][A-Z]\.(utf8|UTF-8)\b' if [[ ${locales} =~ ${c_utf_regex} || ${locales} =~ ${en_us_regex} || ${locales} =~ ${utf_regex} ]] then export LC_ALL="${BASH_REMATCH[0]}" else export LC_ALL=C fi fi fi ##### ##### odie as quickly as possible. ##### if [[ "${HOMEBREW_PREFIX}" == "/" || "${HOMEBREW_PREFIX}" == "/usr" ]] then # it may work, but I only see pain this route and don't want to support it odie "Cowardly refusing to continue at this prefix: ${HOMEBREW_PREFIX}" fi ##### ##### Now, do everything else (that may be a bit slower). ##### # Docker image deprecation if [[ -f "${HOMEBREW_REPOSITORY}/.docker-deprecate" && -z "${HOMEBREW_TESTS}" ]] then read -r DOCKER_DEPRECATION_MESSAGE <"${HOMEBREW_REPOSITORY}/.docker-deprecate" if [[ -n "${GITHUB_ACTIONS}" ]] then echo "::warning::${DOCKER_DEPRECATION_MESSAGE}" >&2 else opoo "${DOCKER_DEPRECATION_MESSAGE}" fi fi # USER isn't always set so provide a fall back for `brew` and subprocesses. export USER="${USER:-$(id -un)}" # A depth of 1 means this command was directly invoked by a user. # Higher depths mean this command was invoked by another Homebrew command. export HOMEBREW_COMMAND_DEPTH="$((HOMEBREW_COMMAND_DEPTH + 1))" setup_curl() { # This is set by the user environment. # shellcheck disable=SC2154 HOMEBREW_BREWED_CURL_PATH="${HOMEBREW_PREFIX}/opt/curl/bin/curl" if [[ -n "${HOMEBREW_FORCE_BREWED_CURL}" && -x "${HOMEBREW_BREWED_CURL_PATH}" ]] && "${HOMEBREW_BREWED_CURL_PATH}" --version &>/dev/null then HOMEBREW_CURL="${HOMEBREW_BREWED_CURL_PATH}" elif [[ -n "${HOMEBREW_CURL_PATH}" ]] then HOMEBREW_CURL="${HOMEBREW_CURL_PATH}" else HOMEBREW_CURL="curl" fi } setup_git() { # This is set by the user environment. # shellcheck disable=SC2154 if [[ -n "${HOMEBREW_FORCE_BREWED_GIT}" && -x "${HOMEBREW_PREFIX}/opt/git/bin/git" ]] && "${HOMEBREW_PREFIX}/opt/git/bin/git" --version &>/dev/null then HOMEBREW_GIT="${HOMEBREW_PREFIX}/opt/git/bin/git" elif [[ -n "${HOMEBREW_GIT_PATH}" ]] then HOMEBREW_GIT="${HOMEBREW_GIT_PATH}" else HOMEBREW_GIT="git" fi } setup_git GIT_DESCRIBE_CACHE="${HOMEBREW_REPOSITORY}/.git/describe-cache" GIT_REVISION=$("${HOMEBREW_GIT}" -C "${HOMEBREW_REPOSITORY}" rev-parse HEAD 2>/dev/null) # safe fallback in case git rev-parse fails e.g. if this is not considered a safe git directory if [[ -z "${GIT_REVISION}" ]] then read -r GIT_HEAD 2>/dev/null <"${HOMEBREW_REPOSITORY}/.git/HEAD" if [[ "${GIT_HEAD}" == "ref: refs/heads/main" ]] then read -r GIT_REVISION 2>/dev/null <"${HOMEBREW_REPOSITORY}/.git/refs/heads/main" elif [[ "${GIT_HEAD}" == "ref: refs/heads/stable" ]] then read -r GIT_REVISION 2>/dev/null <"${HOMEBREW_REPOSITORY}/.git/refs/heads/stable" fi unset GIT_HEAD fi if [[ -n "${GIT_REVISION}" ]] then GIT_DESCRIBE_CACHE_FILE="${GIT_DESCRIBE_CACHE}/${GIT_REVISION}" if [[ -r "${GIT_DESCRIBE_CACHE_FILE}" ]] && "${HOMEBREW_GIT}" -C "${HOMEBREW_REPOSITORY}" diff --quiet --no-ext-diff 2>/dev/null then read -r GIT_DESCRIBE_CACHE_HOMEBREW_VERSION <"${GIT_DESCRIBE_CACHE_FILE}" if [[ -n "${GIT_DESCRIBE_CACHE_HOMEBREW_VERSION}" && "${GIT_DESCRIBE_CACHE_HOMEBREW_VERSION}" != *"-dirty" ]] then HOMEBREW_VERSION="${GIT_DESCRIBE_CACHE_HOMEBREW_VERSION}" fi unset GIT_DESCRIBE_CACHE_HOMEBREW_VERSION fi if [[ -z "${HOMEBREW_VERSION}" ]] then HOMEBREW_VERSION="$("${HOMEBREW_GIT}" -C "${HOMEBREW_REPOSITORY}" describe --tags --dirty --abbrev=7 2>/dev/null)" # Don't output any permissions errors here. The user may not have write # permissions to the cache but we don't care because it's an optional # performance improvement. rm -rf "${GIT_DESCRIBE_CACHE}" 2>/dev/null mkdir -p "${GIT_DESCRIBE_CACHE}" 2>/dev/null echo "${HOMEBREW_VERSION}" | tee "${GIT_DESCRIBE_CACHE_FILE}" &>/dev/null fi unset GIT_DESCRIBE_CACHE_FILE else # Don't care about permission errors here either. rm -rf "${GIT_DESCRIBE_CACHE}" 2>/dev/null fi unset GIT_REVISION unset GIT_DESCRIBE_CACHE HOMEBREW_USER_AGENT_VERSION="${HOMEBREW_VERSION}" if [[ -z "${HOMEBREW_VERSION}" ]] then HOMEBREW_VERSION=">=4.3.0 (shallow or no git repository)" HOMEBREW_USER_AGENT_VERSION="4.X.Y" fi HOMEBREW_CORE_REPOSITORY="${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core" # Used in --version.sh # shellcheck disable=SC2034 HOMEBREW_CASK_REPOSITORY="${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-cask" # Shift the -v to the end of the parameter list if [[ "$1" == "-v" ]] then shift set -- "$@" -v fi # commands that take a single or no arguments. # doesn't need a default case as other arguments handled elsewhere. # shellcheck disable=SC2249 case "$1" in --version | -v) source "${HOMEBREW_LIBRARY}/Homebrew/cmd/--version.sh" homebrew-version exit 0 ;; mcp-server) source "${HOMEBREW_LIBRARY}/Homebrew/cmd/mcp-server.sh" homebrew-mcp-server "$@" exit 0 ;; esac setup_curl HOMEBREW_API_DEFAULT_DOMAIN="https://formulae.brew.sh/api" HOMEBREW_BOTTLE_DEFAULT_DOMAIN="https://ghcr.io/v2/homebrew/core" # TODO: bump version when new macOS is released or announced and update references in: # - docs/Installation.md # - https://github.com/Homebrew/install/blob/HEAD/install.sh # - Library/Homebrew/os/mac.rb (latest_sdk_version) # - Library/Homebrew/os/mac/xcode.rb (latest_version), (minimum_version) # and, if needed: # - MacOSVersion::SYMBOLS HOMEBREW_MACOS_NEWEST_UNSUPPORTED="27" # TODO: bump version when new macOS is released HOMEBREW_MACOS_NEWEST_SUPPORTED="26" # TODO: bump version when new macOS is released and update references in: # - docs/Installation.md # - HOMEBREW_MACOS_OLDEST_SUPPORTED in .github/workflows/release.yml # - `os-version min` in package/Distribution.xml # - https://github.com/Homebrew/install/blob/HEAD/install.sh HOMEBREW_MACOS_OLDEST_SUPPORTED="14" HOMEBREW_MACOS_OLDEST_ALLOWED="10.15" if [[ -n "${HOMEBREW_MACOS}" ]] then HOMEBREW_PRODUCT="Homebrew" HOMEBREW_SYSTEM="Macintosh" [[ "${HOMEBREW_PROCESSOR}" == "x86_64" ]] && HOMEBREW_PROCESSOR="Intel" # Don't change this from Mac OS X to match what macOS itself does in Safari HOMEBREW_OS_USER_AGENT_VERSION="Mac OS X ${HOMEBREW_MACOS_VERSION}" if [[ "$(sysctl -n hw.optional.arm64 2>/dev/null)" == "1" ]] then # used in vendor-install.sh and update.sh # shellcheck disable=SC2034 HOMEBREW_PHYSICAL_PROCESSOR="arm64" fi IFS=. read -r -a MACOS_VERSION_ARRAY < <(printf '%s' "${HOMEBREW_MACOS_OLDEST_ALLOWED}") printf -v HOMEBREW_MACOS_OLDEST_ALLOWED_NUMERIC "%02d%02d%02d" "${MACOS_VERSION_ARRAY[@]}" unset MACOS_VERSION_ARRAY # Don't include minor versions for Big Sur and later. if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -gt "110000" ]] then HOMEBREW_OS_VERSION="macOS ${HOMEBREW_MACOS_VERSION%.*}" else HOMEBREW_OS_VERSION="macOS ${HOMEBREW_MACOS_VERSION}" fi # Refuse to run on pre-Catalina # odisabled: remove support for Catalina September (or later) 2026 if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "${HOMEBREW_MACOS_OLDEST_ALLOWED_NUMERIC}" ]] then printf "ERROR: Your version of macOS (%s) is too old to run Homebrew!\\n" "${HOMEBREW_MACOS_VERSION}" >&2 if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "100700" ]] then printf " For 10.4 - 10.6 support see: https://github.com/mistydemeo/tigerbrew\\n" >&2 else printf " For 10.5 - %s support see: https://www.macports.org\\n" "${HOMEBREW_MACOS_VERSION}" >&2 fi printf "\\n" >&2 fi # The system libressl has a bug before macOS 10.15.6 where it incorrectly handles expired roots. if [[ -z "${HOMEBREW_SYSTEM_CURL_TOO_OLD}" && "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "101506" ]] then HOMEBREW_SYSTEM_CA_CERTIFICATES_TOO_OLD="1" HOMEBREW_FORCE_BREWED_CA_CERTIFICATES="1" fi # Some Git versions are too old for some Homebrew functionality we rely on. HOMEBREW_MINIMUM_GIT_VERSION="2.14.3" else if [[ -r "/proc/cpuinfo" ]] && [[ "${HOMEBREW_PROCESSOR}" == "x86_64" ]] then if ! grep -qE '^(flags|Features).*\bssse3\b' /proc/cpuinfo then odie "Homebrew's x86_64 support on Linux requires a CPU with SSSE3 support!" fi fi HOMEBREW_PRODUCT="${HOMEBREW_SYSTEM}brew" # Don't try to follow /etc/os-release # shellcheck disable=SC1091,SC2154 [[ -n "${HOMEBREW_LINUX}" ]] && HOMEBREW_OS_VERSION="$(source /etc/os-release && echo "${PRETTY_NAME}")" : "${HOMEBREW_OS_VERSION:=$(uname -r)}" HOMEBREW_OS_USER_AGENT_VERSION="${HOMEBREW_OS_VERSION}" # Ensure the system Curl is a version that supports modern HTTPS certificates. HOMEBREW_MINIMUM_CURL_VERSION="7.41.0" curl_version_output="$(${HOMEBREW_CURL} --version 2>/dev/null)" curl_name_and_version="${curl_version_output%% (*}" if [[ "$(numeric "${curl_name_and_version##* }")" -lt "$(numeric "${HOMEBREW_MINIMUM_CURL_VERSION}")" ]] then message="Please update your system curl or set HOMEBREW_CURL_PATH to a newer version. Minimum required version: ${HOMEBREW_MINIMUM_CURL_VERSION} Your curl version: ${curl_name_and_version##* } Your curl executable: $(type -p "${HOMEBREW_CURL}")" if [[ -z ${HOMEBREW_CURL_PATH} ]] then HOMEBREW_SYSTEM_CURL_TOO_OLD=1 HOMEBREW_FORCE_BREWED_CURL=1 if [[ -z ${HOMEBREW_CURL_WARNING} ]] then onoe "${message}" HOMEBREW_CURL_WARNING=1 fi else odie "${message}" fi fi # Ensure the system Git is at or newer than the minimum required version. # Git 2.7.4 is the version of git on Ubuntu 16.04 LTS (Xenial Xerus). HOMEBREW_MINIMUM_GIT_VERSION="2.7.0" git_version_output="$(${HOMEBREW_GIT} --version 2>/dev/null)" # $extra is intentionally discarded. # shellcheck disable=SC2034 IFS='.' read -r major minor micro build extra < <(printf '%s' "${git_version_output##* }") if [[ "$(numeric "${major}.${minor}.${micro}.${build}")" -lt "$(numeric "${HOMEBREW_MINIMUM_GIT_VERSION}")" ]] then message="Please update your system Git or set HOMEBREW_GIT_PATH to a newer version. Minimum required version: ${HOMEBREW_MINIMUM_GIT_VERSION} Your Git version: ${major}.${minor}.${micro}.${build} Your Git executable: $(unset git && type -p "${HOMEBREW_GIT}")" if [[ -z ${HOMEBREW_GIT_PATH} ]] then HOMEBREW_FORCE_BREWED_GIT="1" if [[ -z ${HOMEBREW_GIT_WARNING} ]] then onoe "${message}" HOMEBREW_GIT_WARNING=1 fi else odie "${message}" fi fi HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION="2.13" fi setup_ca_certificates() { if [[ -n "${HOMEBREW_FORCE_BREWED_CA_CERTIFICATES}" && -f "${HOMEBREW_PREFIX}/etc/ca-certificates/cert.pem" ]] then export SSL_CERT_FILE="${HOMEBREW_PREFIX}/etc/ca-certificates/cert.pem" export GIT_SSL_CAINFO="${HOMEBREW_PREFIX}/etc/ca-certificates/cert.pem" export GIT_SSL_CAPATH="${HOMEBREW_PREFIX}/etc/ca-certificates" fi } setup_ca_certificates # Redetermine curl and git paths as we may have forced some options above. setup_curl setup_git # A bug in the auto-update process prior to 3.1.2 means $HOMEBREW_BOTTLE_DOMAIN # could be passed down with the default domain. # This is problematic as this is will be the old bottle domain. # This workaround is necessary for many CI images starting on old version, # and will only be unnecessary when updating from <3.1.2 is not a concern. # That will be when macOS 12 is the minimum required version. # HOMEBREW_BOTTLE_DOMAIN is set from the user environment # shellcheck disable=SC2154 if [[ -n "${HOMEBREW_BOTTLE_DEFAULT_DOMAIN}" ]] && [[ "${HOMEBREW_BOTTLE_DOMAIN}" == "${HOMEBREW_BOTTLE_DEFAULT_DOMAIN}" ]] then unset HOMEBREW_BOTTLE_DOMAIN fi HOMEBREW_USER_AGENT="${HOMEBREW_PRODUCT}/${HOMEBREW_USER_AGENT_VERSION} (${HOMEBREW_SYSTEM}; ${HOMEBREW_PROCESSOR} ${HOMEBREW_OS_USER_AGENT_VERSION})" curl_version_output="$(curl --version 2>/dev/null)" curl_name_and_version="${curl_version_output%% (*}" HOMEBREW_USER_AGENT_CURL="${HOMEBREW_USER_AGENT} ${curl_name_and_version// //}" # Timeout values to check for dead connections # We don't use --max-time to support slow connections HOMEBREW_CURL_SPEED_LIMIT=100 HOMEBREW_CURL_SPEED_TIME=5 export HOMEBREW_HELP_MESSAGE export HOMEBREW_VERSION export HOMEBREW_MACOS_ARM_DEFAULT_PREFIX export HOMEBREW_LINUX_DEFAULT_PREFIX export HOMEBREW_GENERIC_DEFAULT_PREFIX export HOMEBREW_DEFAULT_PREFIX export HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY export HOMEBREW_LINUX_DEFAULT_REPOSITORY export HOMEBREW_GENERIC_DEFAULT_REPOSITORY export HOMEBREW_DEFAULT_REPOSITORY export HOMEBREW_DEFAULT_CACHE export HOMEBREW_CACHE export HOMEBREW_DEFAULT_LOGS export HOMEBREW_LOGS export HOMEBREW_DEFAULT_TEMP export HOMEBREW_TEMP export HOMEBREW_CELLAR export HOMEBREW_CASKROOM export HOMEBREW_SYSTEM export HOMEBREW_SYSTEM_CA_CERTIFICATES_TOO_OLD export HOMEBREW_CURL export HOMEBREW_BREWED_CURL_PATH export HOMEBREW_CURL_WARNING export HOMEBREW_SYSTEM_CURL_TOO_OLD export HOMEBREW_GIT export HOMEBREW_GIT_WARNING export HOMEBREW_MINIMUM_GIT_VERSION export HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION export HOMEBREW_PHYSICAL_PROCESSOR export HOMEBREW_PROCESSOR export HOMEBREW_PRODUCT export HOMEBREW_OS_VERSION export HOMEBREW_MACOS_VERSION export HOMEBREW_MACOS_VERSION_NUMERIC export HOMEBREW_MACOS_NEWEST_UNSUPPORTED export HOMEBREW_MACOS_NEWEST_SUPPORTED export HOMEBREW_MACOS_OLDEST_SUPPORTED export HOMEBREW_MACOS_OLDEST_ALLOWED export HOMEBREW_USER_AGENT export HOMEBREW_USER_AGENT_CURL export HOMEBREW_API_DEFAULT_DOMAIN export HOMEBREW_BOTTLE_DEFAULT_DOMAIN export HOMEBREW_CURL_SPEED_LIMIT export HOMEBREW_CURL_SPEED_TIME if [[ -n "${HOMEBREW_MACOS}" && -x "/usr/bin/xcode-select" ]] then XCODE_SELECT_PATH="$('/usr/bin/xcode-select' --print-path 2>/dev/null)" if [[ "${XCODE_SELECT_PATH}" == "/" ]] then odie <&2 mkdir -p "${HOMEBREW_CACHE}/api" if [[ -d "${original_cache}/api" ]] then cp -R "${original_cache}/api/." "${HOMEBREW_CACHE}/api/" &>/dev/null || true fi export HOMEBREW_CACHE fi fi # Set HOMEBREW_DEV_CMD_RUN for users who have run a development command. # This makes them behave like HOMEBREW_DEVELOPERs for brew update. if [[ -z "${HOMEBREW_DEVELOPER}" ]] then export HOMEBREW_GIT_CONFIG_FILE="${HOMEBREW_REPOSITORY}/.git/config" HOMEBREW_GIT_CONFIG_DEVELOPERMODE="$(git config --file="${HOMEBREW_GIT_CONFIG_FILE}" --get homebrew.devcmdrun 2>/dev/null)" if [[ "${HOMEBREW_GIT_CONFIG_DEVELOPERMODE}" == "true" ]] then export HOMEBREW_DEV_CMD_RUN="1" fi # Don't allow non-developers to customise Ruby warnings. unset HOMEBREW_RUBY_WARNINGS fi unset HOMEBREW_AUTO_UPDATE_COMMAND # Check for commands that should call `brew update --auto-update` first. AUTO_UPDATE_COMMANDS=( install outdated upgrade bundle release ) if check-array-membership "${HOMEBREW_COMMAND}" "${AUTO_UPDATE_COMMANDS[@]}" || [[ "${HOMEBREW_COMMAND}" == "tap" && "${HOMEBREW_ARG_COUNT}" -gt 1 ]] then export HOMEBREW_AUTO_UPDATE_COMMAND="1" fi # Check for commands that should auto-update the homebrew-core tap. AUTO_UPDATE_CORE_TAP_COMMANDS=( bump bump-formula-pr ) if check-array-membership "${HOMEBREW_COMMAND}" "${AUTO_UPDATE_CORE_TAP_COMMANDS[@]}" then export HOMEBREW_AUTO_UPDATE_COMMAND="1" export HOMEBREW_AUTO_UPDATE_CORE_TAP="1" elif [[ -z "${HOMEBREW_AUTO_UPDATING}" ]] then unset HOMEBREW_AUTO_UPDATE_CORE_TAP fi # Check for commands that should auto-update the homebrew-cask tap. AUTO_UPDATE_CASK_TAP_COMMANDS=( bump bump-cask-pr bump-unversioned-casks ) if check-array-membership "${HOMEBREW_COMMAND}" "${AUTO_UPDATE_CASK_TAP_COMMANDS[@]}" then export HOMEBREW_AUTO_UPDATE_COMMAND="1" export HOMEBREW_AUTO_UPDATE_CASK_TAP="1" elif [[ -z "${HOMEBREW_AUTO_UPDATING}" ]] then unset HOMEBREW_AUTO_UPDATE_CASK_TAP fi if [[ -z "${HOMEBREW_RUBY_WARNINGS}" ]] then export HOMEBREW_RUBY_WARNINGS="-W1" fi export HOMEBREW_BREW_DEFAULT_GIT_REMOTE="https://github.com/Homebrew/brew" if [[ -z "${HOMEBREW_BREW_GIT_REMOTE}" ]] then HOMEBREW_BREW_GIT_REMOTE="${HOMEBREW_BREW_DEFAULT_GIT_REMOTE}" fi export HOMEBREW_BREW_GIT_REMOTE export HOMEBREW_CORE_DEFAULT_GIT_REMOTE="https://github.com/Homebrew/homebrew-core" if [[ -z "${HOMEBREW_CORE_GIT_REMOTE}" ]] then HOMEBREW_CORE_GIT_REMOTE="${HOMEBREW_CORE_DEFAULT_GIT_REMOTE}" fi export HOMEBREW_CORE_GIT_REMOTE # Set HOMEBREW_DEVELOPER_COMMAND if the command being run is a developer command unset HOMEBREW_DEVELOPER_COMMAND if [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${HOMEBREW_COMMAND}.sh" ]] || [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${HOMEBREW_COMMAND}.rb" ]] then export HOMEBREW_DEVELOPER_COMMAND="1" fi if [[ -n "${HOMEBREW_DEVELOPER_COMMAND}" && -z "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_DEV_CMD_RUN}" ]] then opoo </dev/null export HOMEBREW_DEV_CMD_RUN="1" fi if [[ -n "${HOMEBREW_DEVELOPER}" || -n "${HOMEBREW_DEV_CMD_RUN}" ]] then # Always run with Sorbet for Homebrew developers or when a Homebrew developer command has been run. export HOMEBREW_SORBET_RUNTIME="1" fi # Provide a (temporary, undocumented) way to disable Sorbet globally if needed # to avoid reverting the above. if [[ -n "${HOMEBREW_NO_SORBET_RUNTIME}" ]] then unset HOMEBREW_SORBET_RUNTIME fi if [[ -f "${HOMEBREW_LIBRARY}/Homebrew/cmd/${HOMEBREW_COMMAND}.sh" ]] then HOMEBREW_BASH_COMMAND="${HOMEBREW_LIBRARY}/Homebrew/cmd/${HOMEBREW_COMMAND}.sh" elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${HOMEBREW_COMMAND}.sh" ]] then HOMEBREW_BASH_COMMAND="${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${HOMEBREW_COMMAND}.sh" fi check-run-command-as-root check-prefix-is-not-tmpdir if [[ "${HOMEBREW_PREFIX}" == "/usr/local" ]] && [[ "${HOMEBREW_PREFIX}" != "${HOMEBREW_REPOSITORY}" ]] && [[ "${HOMEBREW_CELLAR}" == "${HOMEBREW_REPOSITORY}/Cellar" ]] then cat >&2 </dev/null || true fi unset SUDO # Remove internal variables unset HOMEBREW_INTERNAL_ALLOW_PACKAGES_FROM_PATHS if rust-frontend-enabled then HOMEBREW_RUST_BREW_FILE="${HOMEBREW_LIBRARY}/Homebrew/vendor/brew-rs/brew-rs" source "${HOMEBREW_LIBRARY}/Homebrew/cmd/vendor-install.sh" if ! brew-rs-vendor-up-to-date then cargo_path="$(PATH="${HOMEBREW_PATH:-${PATH}}" command -v cargo)" if [[ ! -x "${cargo_path}" ]] then opoo "HOMEBREW_EXPERIMENTAL_RUST_FRONTEND is set but cargo from the rust formula was not found; falling back to the Ruby frontend." else homebrew-vendor-install brew-rs || exit $? # Close the vendor-install lock FD opened by the sourced helper. exec 200>&- fi fi if [[ -x "${HOMEBREW_RUST_BREW_FILE}" ]] then [[ "${HOMEBREW_ARG_COUNT}" -gt 0 ]] && set -- "${HOMEBREW_COMMAND}" "$@" auto-update "$@" opoo "using the experimental brew-rs Rust frontend." exec "${HOMEBREW_RUST_BREW_FILE}" "$@" fi fi if [[ -n "${HOMEBREW_BASH_COMMAND}" ]] then # source rather than executing directly to ensure the entire file is read into # memory before it is run. This makes running a Bash script behave more like # a Ruby script and avoids hard-to-debug issues if the Bash script is updated # at the same time as being run. # # Shellcheck can't follow this dynamic `source`. # shellcheck disable=SC1090 source "${HOMEBREW_BASH_COMMAND}" { auto-update "$@" "homebrew-${HOMEBREW_COMMAND}" "$@" exit $? } else source "${HOMEBREW_LIBRARY}/Homebrew/utils/ruby.sh" setup-ruby-path # Unshift command back into argument list (unless argument list was empty). [[ "${HOMEBREW_ARG_COUNT}" -gt 0 ]] && set -- "${HOMEBREW_COMMAND}" "$@" # HOMEBREW_RUBY_PATH set by utils/ruby.sh # shellcheck disable=SC2154 { auto-update "$@" exec "${HOMEBREW_RUBY_PATH}" "${HOMEBREW_RUBY_WARNINGS}" "${HOMEBREW_RUBY_DISABLE_OPTIONS}" \ "${HOMEBREW_LIBRARY}/Homebrew/brew.rb" "$@" } fi Homebrew-brew-d7f73ce/Library/Homebrew/brew_irb_helpers.rb000066400000000000000000000015311517265720000237460ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # Helper methods for the Homebrew IRB/PRY shell run by `brew irb` require "formula" require "formulary" require "cask/cask_loader" class String # @!visibility private sig { params(args: Integer).returns(Formula) } def f(*args) Formulary.factory(self, *args) end # @!visibility private sig { params(config: T.nilable(T::Hash[Symbol, T.untyped])).returns(Cask::Cask) } def c(config: nil) Cask::CaskLoader.load(self, config: Cask::Config.new(**config)) end end class Symbol # rubocop:todo Style/OneClassPerFile # @!visibility private sig { params(args: Integer).returns(Formula) } def f(*args) to_s.f(*args) end # @!visibility private sig { params(config: T.nilable(T::Hash[Symbol, T.untyped])).returns(Cask::Cask) } def c(config: nil) to_s.c(config:) end end Homebrew-brew-d7f73ce/Library/Homebrew/brew_irbrc000066400000000000000000000005621517265720000221520ustar00rootroot00000000000000# NOTE: We use a non-standard config file name to reduce name clashes with # other IRB config files like `.irbrc`. # NOTE: This doesn't work with system Ruby for some reason. require_relative "global" require_relative "brew_irb_helpers" require "irb/completion" IRB.conf[:HISTORY_FILE] = "#{Dir.home}/.brew_irb_history" IRB.conf[:IRB_NAME] = "brew" H = Homebrew Homebrew-brew-d7f73ce/Library/Homebrew/build.rb000066400000000000000000000235721517265720000215410ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # This script is loaded by formula_installer as a separate instance. # Thrown exceptions are propagated back to the parent process over a pipe raise "#{__FILE__} must not be loaded via `require`." if $PROGRAM_NAME != __FILE__ old_trap = trap("INT") { exit! 130 } require_relative "global" require "build_options" require "keg" require "extend/ENV" require "fcntl" require "utils/socket" require "cmd/install" require "json/add/exception" require "utils/output" require "extend/pathname/write_mkpath_extension" # A formula build. class Build include Utils::Output::Mixin sig { returns(Formula) } attr_reader :formula sig { returns(T::Array[Dependency]) } attr_reader :deps sig { returns(Requirements) } attr_reader :reqs sig { returns(Homebrew::Cmd::InstallCmd::Args) } attr_reader :args sig { params(formula: Formula, options: Options, args: Homebrew::Cmd::InstallCmd::Args).void } def initialize(formula, options, args:) @formula = formula @formula.build = BuildOptions.new(options, formula.options) @args = args @deps = T.let([], T::Array[Dependency]) @reqs = T.let(Requirements.new, Requirements) return if args.ignore_dependencies? @deps = expand_deps @reqs = expand_reqs end sig { params(dependent: Formula).returns(BuildOptions) } def effective_build_options_for(dependent) args = dependent.build.used_options args |= Tab.for_formula(dependent).used_options BuildOptions.new(args, dependent.options) end sig { returns(Requirements) } def expand_reqs formula.recursive_requirements do |dependent, req| dependent = T.cast(dependent, Formula) build = effective_build_options_for(dependent) if req.prune_from_option?(build) || req.prune_if_build_and_not_dependent?(dependent, formula) || req.test? next Dependable::PRUNE end end end sig { returns(T::Array[Dependency]) } def expand_deps formula.recursive_dependencies do |dependent, dep| build = effective_build_options_for(T.cast(dependent, Formula)) if dep.prune_from_option?(build) || dep.prune_if_build_and_not_dependent?(T.cast(dependent, Formula), formula) || (dep.test? && !dep.build?) || dep.implicit? next Dependable::PRUNE elsif dep.build? next Dependable::KEEP_BUT_PRUNE_RECURSIVE_DEPS end end end sig { void } def install formula_deps = deps.map(&:to_formula) keg_only_deps = formula_deps.select(&:keg_only?) run_time_deps = deps.reject(&:build?).map(&:to_formula) formula_deps.each do |dep| fixopt(dep) unless dep.opt_prefix.directory? end ENV.activate_extensions!(env: args.env) if superenv?(args.env) superenv = ENV superenv.keg_only_deps = keg_only_deps superenv.deps = formula_deps superenv.run_time_deps = run_time_deps ENV.setup_build_environment( formula:, cc: args.cc, build_bottle: args.build_bottle?, bottle_arch: args.bottle_arch, debug_symbols: args.debug_symbols?, ) reqs.each do |req| req.modify_build_environment( env: args.env, cc: args.cc, build_bottle: args.build_bottle?, bottle_arch: args.bottle_arch, ) end else ENV.setup_build_environment( formula:, cc: args.cc, build_bottle: args.build_bottle?, bottle_arch: args.bottle_arch, debug_symbols: args.debug_symbols?, ) reqs.each do |req| req.modify_build_environment( env: args.env, cc: args.cc, build_bottle: args.build_bottle?, bottle_arch: args.bottle_arch, ) end keg_only_deps.each do |dep| ENV.prepend_path "PATH", dep.opt_bin.to_s ENV.prepend_path "PKG_CONFIG_PATH", "#{dep.opt_lib}/pkgconfig" ENV.prepend_path "PKG_CONFIG_PATH", "#{dep.opt_share}/pkgconfig" ENV.prepend_path "ACLOCAL_PATH", "#{dep.opt_share}/aclocal" ENV.prepend_path "CMAKE_PREFIX_PATH", dep.opt_prefix.to_s ENV.prepend "LDFLAGS", "-L#{dep.opt_lib}" if dep.opt_lib.directory? ENV.prepend "CPPFLAGS", "-I#{dep.opt_include}" if dep.opt_include.directory? end end new_env = { "TMPDIR" => HOMEBREW_TEMP.to_s, "TEMP" => HOMEBREW_TEMP.to_s, "TMP" => HOMEBREW_TEMP.to_s, } with_env(new_env) do if args.debug? && !Homebrew::EnvConfig.disable_debrew? require "debrew" formula.extend(Debrew::Formula) end formula.update_head_version formula.brew( fetch: false, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, interactive: args.interactive?, ) do with_env( # For head builds, HOMEBREW_FORMULA_PREFIX should include the commit, # which is not known until after the formula has been staged. HOMEBREW_FORMULA_PREFIX: formula.prefix, # https://reproducible-builds.org/docs/build-path/ HOMEBREW_FORMULA_BUILDPATH: formula.buildpath, # https://reproducible-builds.org/docs/source-date-epoch/ SOURCE_DATE_EPOCH: formula.source_modified_time.to_i.to_s, # Avoid make getting confused about timestamps. # https://github.com/Homebrew/homebrew-core/pull/87470 TZ: "UTC0", ) do if args.git? formula.selective_patch(is_data: false) system "git", "init" system "git", "add", "-A" formula.selective_patch(is_data: true) else formula.patch end if args.interactive? ohai "Entering interactive mode..." puts <<~EOS Type `exit` to return and finalize the installation. Install to this prefix: #{formula.prefix} EOS if args.git? puts <<~EOS This directory is now a Git repository. Make your changes and then use: git diff | pbcopy to copy the diff to the clipboard. EOS end interactive_shell(formula) else formula.prefix.mkpath formula.logs.mkpath (formula.logs/"00.options.out").write \ "#{formula.full_name} #{formula.build.used_options.sort.join(" ")}".strip Pathname.activate_extensions! formula.install stdlibs = detect_stdlibs tab = Tab.create(formula, ENV.compiler, stdlibs.first) tab.write # Find and link metafiles formula.prefix.install_metafiles T.must(formula.buildpath) if formula.libexec.exist? require "metafiles" no_metafiles = formula.prefix.children.none? { |p| p.file? && Metafiles.copy?(p.basename.to_s) } formula.prefix.install_metafiles formula.libexec if no_metafiles end normalize_pod2man_outputs!(formula) end end end end end sig { returns(T::Array[Symbol]) } def detect_stdlibs keg = Keg.new(formula.prefix) # The stdlib recorded in the install receipt is used during dependency # compatibility checks, so we only care about the stdlib that libraries # link against. keg.detect_cxx_stdlibs(skip_executables: true) end sig { params(formula: Formula).void } def fixopt(formula) path = if formula.linked_keg.directory? && formula.linked_keg.symlink? formula.linked_keg.resolved_path elsif formula.prefix.directory? formula.prefix elsif (children = formula.rack.children.presence) && children.size == 1 && (first_child = children.first.presence) && first_child.directory? first_child else raise end Keg.new(path).optlink(verbose: args.verbose?) rescue raise "#{formula.opt_prefix} not present or broken\nPlease reinstall #{formula.full_name}. Sorry :(" end sig { params(formula: Formula).void } def normalize_pod2man_outputs!(formula) keg = Keg.new(formula.prefix) keg.normalize_pod2man_outputs! end end begin # Undocumented opt-out for internal use. # We need to allow formulae from paths here due to how we pass them through. ENV["HOMEBREW_INTERNAL_ALLOW_PACKAGES_FROM_PATHS"] = "1" args = Homebrew::Cmd::InstallCmd.new.args Context.current = args.context error_pipe = Utils::UNIXSocketExt.open(ENV.fetch("HOMEBREW_ERROR_PIPE"), &:recv_io) error_pipe.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) trap("INT", old_trap) formula_path = ARGV.first if formula_path&.end_with?(".json") raise "build.rb received an API JSON file as the formula path: #{formula_path}. " \ "This usually means the formula source was not downloaded from the API. " \ "Try clearing the cache: rm -rf $(brew --cache)/api-source" end formula = args.named.to_formulae.fetch(0) options = Options.create(args.flags_only) build = Build.new(formula, options, args:) build.install # Any exception means the build did not complete. # The `case` for what to do per-exception class is further down. rescue Exception => e # rubocop:disable Lint/RescueException error_hash = JSON.parse e.to_json # Special case: need to recreate BuildErrors in full # for proper analytics reporting and error messages. # BuildErrors are specific to build processes and not other # children, which is why we create the necessary state here # and not in Utils.safe_fork. case e when BuildError error_hash["cmd"] = e.cmd error_hash["args"] = e.args error_hash["env"] = e.env when ErrorDuringExecution error_hash["cmd"] = e.cmd error_hash["status"] = if e.status.is_a?(Process::Status) { exitstatus: e.exitstatus, termsig: e.termsig, } else e.status end error_hash["output"] = e.output end error_pipe&.puts error_hash.to_json error_pipe&.close exit! 1 end Homebrew-brew-d7f73ce/Library/Homebrew/build_environment.rb000066400000000000000000000050041517265720000241530ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # Settings for the build environment. class BuildEnvironment sig { params(settings: Symbol).void } def initialize(*settings) @settings = T.let(Set.new(settings), T::Set[Symbol]) end sig { params(args: T::Enumerable[Symbol]).returns(T.self_type) } def merge(*args) @settings.merge(*args) self end sig { params(option: Symbol).returns(T.self_type) } def <<(option) @settings << option self end sig { returns(T::Boolean) } def std? @settings.include? :std end # DSL for specifying build environment settings. module DSL # Initialise @env for each class which may use this DSL (e.g. each formula subclass). # `env` may never be called and it needs to be initialised before the class is frozen. sig { params(child: T.untyped).void } def inherited(child) super child.instance_eval do @env = T.let(BuildEnvironment.new, T.nilable(BuildEnvironment)) end end sig { overridable.params(settings: Symbol).returns(T.nilable(BuildEnvironment)) } def env(*settings) env = @env Kernel.raise ArgumentError, "#{self} has not been initialized with a BuildEnvironment" if env.nil? env.merge(settings) end end KEYS = %w[ CC CXX LD OBJC OBJCXX HOMEBREW_CC HOMEBREW_CXX CFLAGS CXXFLAGS CPPFLAGS LDFLAGS SDKROOT MAKEFLAGS CMAKE_PREFIX_PATH CMAKE_INCLUDE_PATH CMAKE_LIBRARY_PATH CMAKE_FRAMEWORK_PATH MACOSX_DEPLOYMENT_TARGET PKG_CONFIG_PATH PKG_CONFIG_LIBDIR HOMEBREW_DEBUG HOMEBREW_MAKE_JOBS HOMEBREW_VERBOSE all_proxy ftp_proxy http_proxy https_proxy no_proxy HOMEBREW_SVN HOMEBREW_GIT HOMEBREW_SDKROOT MAKE GIT CPP ACLOCAL_PATH PATH CPATH LD_LIBRARY_PATH LD_RUN_PATH LD_PRELOAD LIBRARY_PATH ].freeze private_constant :KEYS sig { params(env: T::Hash[String, T.nilable(T.any(String, T::Boolean, PATH))]).returns(T::Array[String]) } def self.keys(env) KEYS & env.keys end sig { params(env: T::Hash[String, T.nilable(T.any(String, T::Boolean, PATH))], out: IO).void } def self.dump(env, out = $stdout) keys = self.keys(env) keys -= %w[CC CXX OBJC OBJCXX] if env["CC"] == env["HOMEBREW_CC"] keys.each do |key| value = env.fetch(key) string = "#{key}: #{value}" case key when "CC", "CXX", "LD" value = T.cast(value, String) string << " => #{Pathname.new(value).realpath}" if value.present? && File.symlink?(value) end string.freeze out.puts string end end end Homebrew-brew-d7f73ce/Library/Homebrew/build_options.rb000066400000000000000000000054351517265720000233120ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # Options for a formula build. class BuildOptions sig { params(args: Options, options: Options).void } def initialize(args, options) @args = args @options = options end # True if a {Formula} is being built with a specific option. # # ### Examples # # ```ruby # args << "--i-want-spam" if build.with? "spam" # ``` # # ```ruby # args << "--qt-gui" if build.with? "qt" # "--with-qt" ==> build.with? "qt" # ``` # # If a formula presents a user with a choice, but the choice must be fulfilled: # # ```ruby # if build.with? "example2" # args << "--with-example2" # else # args << "--with-example1" # end # ``` sig { params(val: T.any(String, Dependable)).returns(T::Boolean) } def with?(val) option_names = if val.is_a?(String) [val] else val.option_names end option_names.any? do |name| if option_defined? "with-#{name}" include? "with-#{name}" elsif option_defined? "without-#{name}" !include? "without-#{name}" else false end end end # True if a {Formula} is being built without a specific option. # # ### Example # # ```ruby # args << "--no-spam-plz" if build.without? "spam" # ``` sig { params(val: T.any(String, Dependable)).returns(T::Boolean) } def without?(val) !with?(val) end # True if a {Formula} is being built as a bottle (i.e. binary package). sig { returns(T::Boolean) } def bottle? include? "build-bottle" end # True if a {Formula} is being built with {Formula.head} instead of {Formula.stable}. # # ### Examples # # ```ruby # args << "--some-new-stuff" if build.head? # ``` # # If there are multiple conditional arguments use a block instead of lines. # # ```ruby # if build.head? # args << "--i-want-pizza" # args << "--and-a-cold-beer" if build.with? "cold-beer" # end # ``` sig { returns(T::Boolean) } def head? include? "HEAD" end # True if a {Formula} is being built with {Formula.stable} instead of {Formula.head}. # This is the default. # # ### Example # # ```ruby # args << "--some-feature" if build.stable? # ``` sig { returns(T::Boolean) } def stable? !head? end # True if the build has any arguments or options specified. sig { returns(T::Boolean) } def any_args_or_options? !@args.empty? || !@options.empty? end sig { returns(Options) } def used_options @options & @args end sig { returns(Options) } def unused_options @options - @args end private sig { params(name: String).returns(T::Boolean) } def include?(name) @args.include?("--#{name}") end sig { params(name: String).returns(T::Boolean) } def option_defined?(name) @options.include? name end end Homebrew-brew-d7f73ce/Library/Homebrew/bump.rb000066400000000000000000000135021517265720000213750ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "system_command" require "tap" require "utils/git" require "utils/github" require "utils/output" require "utils/popen" module Homebrew # @api internal module Bump extend SystemCommand::Mixin extend Utils::Output::Mixin class Commit < T::Struct const :sourcefile_path, Pathname const :old_contents, String const :commit_message, String const :additional_files, T::Array[Pathname], default: [] end class BumpInfo < T::Struct const :package_tap, Tap const :branch_name, String const :pr_title, String const :pr_message, String const :commits, T::Array[Commit] end sig { params(command: String, user_message: T.nilable(String)).returns(String) } def self.pr_message(command, user_message:) pr_message = "" if user_message.present? pr_message += <<~EOS #{user_message} --- EOS end pr_message += "Created with `brew #{command}`." pr_message end sig { params(info: BumpInfo, dry_run: T::Boolean, no_fork: T::Boolean, fork_org: T.nilable(String), commit: T::Boolean).returns(T.nilable(String)) } def self.create_pr(info, dry_run: false, no_fork: false, fork_org: nil, commit: false) tap = info.package_tap branch = info.branch_name pr_message = info.pr_message pr_title = info.pr_title commits = info.commits tap_remote_repo = tap.remote_repository raise ArgumentError, "The tap #{tap.name} does not have a remote repository!" unless tap_remote_repo remote_branch = tap.git_repository.origin_branch_name raise "The tap #{tap.name} does not have a default branch!" if remote_branch.blank? remote_url = T.let(nil, T.nilable(String)) username = T.let(nil, T.nilable(String)) tap.path.cd do if no_fork remote_url = Utils.popen_read("git", "remote", "get-url", "--push", "origin").chomp username = tap.user add_auth_token_to_url!(remote_url) else begin remote_url, username = forked_repo_info!(tap_remote_repo, org: fork_org) rescue *GitHub::API::ERRORS => e commits.each do |commit| commit.sourcefile_path.atomic_write(commit.old_contents) end odie "Unable to fork: #{e.message}!" end end next if dry_run git_dir = Utils.popen_read("git", "rev-parse", "--git-dir").chomp shallow = !git_dir.empty? && File.exist?("#{git_dir}/shallow") safe_system "git", "fetch", "--unshallow", "origin" if !commit && shallow safe_system "git", "checkout", "--no-track", "-b", branch, "origin/#{remote_branch}" unless commit Utils::Git.set_name_email! end commits.each do |commit| sourcefile_path = commit.sourcefile_path commit_message = commit.commit_message additional_files = commit.additional_files sourcefile_path.parent.cd do git_dir = Utils.popen_read("git", "rev-parse", "--git-dir").chomp shallow = !git_dir.empty? && File.exist?("#{git_dir}/shallow") changed_files = [sourcefile_path] changed_files += additional_files if additional_files.present? if dry_run ohai "git checkout --no-track -b #{branch} origin/#{remote_branch}" ohai "git fetch --unshallow origin" if shallow ohai "git add #{changed_files.join(" ")}" ohai "git commit --no-edit --verbose --message='#{commit_message}' " \ "-- #{changed_files.join(" ")}" ohai "git push --set-upstream #{remote_url} #{branch}:#{branch}" ohai "git checkout --quiet -" ohai "create pull request with GitHub API (base branch: #{remote_branch})" else safe_system "git", "add", *changed_files Utils::Git.set_name_email! safe_system "git", "commit", "--no-edit", "--verbose", "--message=#{commit_message}", "--", *changed_files end end end return if commit || dry_run return unless remote_url tap.path.cd do system_command!("git", args: ["push", "--set-upstream", remote_url, "#{branch}:#{branch}"], print_stdout: true) safe_system "git", "checkout", "--quiet", "-" begin return GitHub.create_pull_request(tap_remote_repo, pr_title, "#{username}:#{branch}", remote_branch, pr_message)["html_url"] rescue *GitHub::API::ERRORS => e commits.each do |commit| commit.sourcefile_path.atomic_write(commit.old_contents) end odie "Unable to open pull request for #{tap_remote_repo}: #{e.message}!" end end end sig { params(url: String).returns(String) } private_class_method def self.add_auth_token_to_url!(url) if GitHub::API.credentials_type == :env_token url.sub!(%r{^https://github\.com/}, "https://x-access-token:#{GitHub::API.credentials}@github.com/") end url end sig { params(tap_remote_repo: String, org: T.nilable(String)).returns([String, String]) } private_class_method def self.forked_repo_info!(tap_remote_repo, org: nil) response = GitHub.create_fork(tap_remote_repo, org:) # GitHub API responds immediately but fork takes a few seconds to be ready. sleep 1 until GitHub.fork_exists?(tap_remote_repo, org:) remote_url = if system("git", "config", "--local", "--get-regexp", "remote..*.url", "git@github.com:.*") response.fetch("ssh_url") else add_auth_token_to_url!(response.fetch("clone_url")) end username = response.fetch("owner").fetch("login") [remote_url, username] end end end Homebrew-brew-d7f73ce/Library/Homebrew/bump_version_parser.rb000066400000000000000000000037201517265720000245170ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Homebrew # Class handling architecture-specific version information. class BumpVersionParser VERSION_SYMBOLS = [:general, :arm, :intel].freeze sig { returns(T.nilable(T.any(Version, Cask::DSL::Version))) } attr_reader :arm, :general, :intel sig { params(general: T.nilable(T.any(Version, String)), arm: T.nilable(T.any(Version, String)), intel: T.nilable(T.any(Version, String))).void } def initialize(general: nil, arm: nil, intel: nil) @general = T.let(parse_version(general), T.nilable(T.any(Version, Cask::DSL::Version))) if general.present? @arm = T.let(parse_version(arm), T.nilable(T.any(Version, Cask::DSL::Version))) if arm.present? @intel = T.let(parse_version(intel), T.nilable(T.any(Version, Cask::DSL::Version))) if intel.present? return if @general.present? raise UsageError, "`--version` must not be empty." if arm.blank? && intel.blank? end sig { params(version: T.any(Version, String)) .returns(T.nilable(T.any(Version, Cask::DSL::Version))) } def parse_version(version) if version.is_a?(Version) version elsif version.is_a?(String) parse_cask_version(version) else # :nocov: T.absurd(version) # :nocov: end end sig { params(version: String).returns(T.nilable(Cask::DSL::Version)) } def parse_cask_version(version) if version == "latest" Cask::DSL::Version.new(:latest) else Cask::DSL::Version.new(version) end end sig { returns(T::Boolean) } def blank? @general.blank? && @arm.blank? && @intel.blank? end sig { params(other: T.anything).returns(T::Boolean) } def ==(other) case other when BumpVersionParser (general == other.general) && (arm == other.arm) && (intel == other.intel) else false end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle.rb000066400000000000000000000127071517265720000217110ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "English" module Homebrew module Bundle class << self sig { params(args_upgrade_formula: T.nilable(String)).void } def upgrade_formulae=(args_upgrade_formula) @upgrade_formulae = args_upgrade_formula.to_s.split(",") end sig { returns(T::Array[String]) } def upgrade_formulae @upgrade_formulae || [] end sig { params(cmd: T.any(String, Pathname), args: T.anything, verbose: T::Boolean).returns(T::Boolean) } def system(cmd, *args, verbose: false) return super cmd, *args if verbose env = {} # Make sure node's bin opt path is part of the PATH # This is essential for the npm bundle extension that calls node directly if Npm.package_manager_executable && cmd.to_s == Npm.package_manager_executable.to_s node_bin = "#{HOMEBREW_PREFIX}/opt/node/bin" env["PATH"] = "#{ENV.fetch("PATH")}:#{node_bin}" end logs = [] success = T.let(false, T::Boolean) IO.popen(env, [cmd, *args], err: [:child, :out]) do |pipe| while (buf = pipe.gets) logs << buf end Process.wait(pipe.pid) success = $CHILD_STATUS.success? pipe.close end puts logs.join unless success success end sig { params(args: T.anything, verbose: T::Boolean).returns(T::Boolean) } def brew(*args, verbose: false) system(HOMEBREW_BREW_FILE, *args, verbose:) end sig { returns(T::Boolean) } def cask_installed? @cask_installed ||= File.directory?("#{HOMEBREW_PREFIX}/Caskroom") && (File.directory?("#{HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-cask") || !Homebrew::EnvConfig.no_install_from_api?) end sig { params(block: T.proc.returns(T.anything)).returns(T.untyped) } def exchange_uid_if_needed!(&block) euid = Process.euid uid = Process.uid return yield if euid == uid old_euid = euid process_reexchangeable = Process::UID.re_exchangeable? if process_reexchangeable Process::UID.re_exchange else Process::Sys.seteuid(uid) end home = T.must(Etc.getpwuid(Process.uid)).dir return_value = with_env("HOME" => home, &block) if process_reexchangeable Process::UID.re_exchange else Process::Sys.seteuid(old_euid) end return_value end sig { params(formula_name: String).returns(T.nilable(String)) } def formula_versions_from_env(formula_name) @formula_versions_from_env ||= begin formula_versions = {} ENV.each do |key, value| match = key.match(/^HOMEBREW_BUNDLE_FORMULA_VERSION_(.+)$/) next if match.blank? env_formula_name = match[1] next if env_formula_name.blank? ENV.delete(key) formula_versions[env_formula_name] = value end formula_versions end # Fix up formula name for a valid environment variable name. formula_env_name = formula_name.upcase .gsub("@", "AT") .tr("+", "X") .tr("-", "_") @formula_versions_from_env[formula_env_name] end sig { returns(T.nilable(T::Hash[String, String])) } def formula_versions_from_env_cache @formula_versions_from_env end sig { params(formula_versions: T.nilable(T::Hash[String, String])).void } def formula_versions_from_env_cache=(formula_versions) @formula_versions_from_env = formula_versions end sig { void } def prepend_pkgconf_path_if_needed!; end sig { void } def reset! @cask_installed = T.let(nil, T.nilable(T::Boolean)) @formula_versions_from_env = T.let(nil, T.nilable(T::Hash[String, String])) @upgrade_formulae = T.let(nil, T.nilable(T::Array[String])) end # Marks Brewfile formulae as installed_on_request to prevent autoremove # from removing them when their dependents are uninstalled. sig { params(entries: T::Array[Dsl::Entry]).void } def mark_as_installed_on_request!(entries) return if entries.empty? require "tab" installed_formulae = Formula.installed_formula_names return if installed_formulae.empty? use_brew_tab = T.let(false, T::Boolean) formulae_to_update = entries.filter_map do |entry| next if entry.type != :brew name = entry.name next if installed_formulae.exclude?(name) tab = Tab.for_name(name) tabfile = tab.tabfile next if tabfile.blank? || !tabfile.exist? next if tab.installed_on_request next name if use_brew_tab tab.installed_on_request = true begin tab.write nil rescue Errno::EACCES # Some wrappers might treat `brew bundle` with lower permissions due to its execution of user code. # Running through `brew tab` ensures proper privilege escalation by going through the wrapper again. use_brew_tab = true name end end brew "tab", "--installed-on-request", *formulae_to_update if use_brew_tab end end end end require "extend/os/bundle/bundle" Homebrew-brew-d7f73ce/Library/Homebrew/bundle/000077500000000000000000000000001517265720000213555ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/bundle/adder.rb000066400000000000000000000021421517265720000227600ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/brewfile" require "bundle/dumper" module Homebrew module Bundle module Adder module_function sig { params(args: String, type: Symbol, global: T::Boolean, file: String, describe: T::Boolean).void } def add(*args, type:, global:, file:, describe: false) brewfile_path = Brewfile.path(global:, file:) brewfile_path.write("") unless brewfile_path.exist? brewfile = Brewfile.read(global:, file:) content = brewfile.input new_content = args.map do |arg| desc = case type when :brew Formulary.factory(arg).desc when :cask ::Cask::CaskLoader.load(arg).desc end entry = "#{type} \"#{arg}\"" if describe && desc.present? desc.split("\n").map { |s| "# #{s}\n" }.join + entry else entry end end content << new_content.join("\n") << "\n" path = Dumper.brewfile_path(global:, file:) Dumper.write_file path, content end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/brew.rb000066400000000000000000000625371517265720000226560ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "json" require "tsort" require "utils" require "utils/output" require "bundle/package_type" module Homebrew module Bundle class Brew < Homebrew::Bundle::PackageType extend Utils::Output::Mixin PACKAGE_TYPE = :brew PACKAGE_TYPE_NAME = "Formula" class << self sig { override.params(subclass: T.class_of(Homebrew::Bundle::PackageType)).void } def inherited(subclass) return if subclass.name == "Homebrew::Bundle::Brew::Services" super end sig { override.void } def reset! require "bundle/brew_services" Homebrew::Bundle::Brew::Services.reset! @installed_formulae = T.let(nil, T.nilable(T::Array[String])) @outdated_formulae = T.let(nil, T.nilable(T::Array[String])) @pinned_formulae = T.let(nil, T.nilable(T::Array[String])) @formulae = T.let(nil, T.nilable(T::Array[T::Hash[Symbol, T.untyped]])) @formulae_by_full_name = T.let(nil, T.nilable(T::Hash[String, T::Hash[Symbol, T.untyped]])) @formulae_by_name = T.let(nil, T.nilable(T::Hash[String, T::Hash[Symbol, T.untyped]])) @formula_aliases = T.let(nil, T.nilable(T::Hash[String, String])) @formula_oldnames = T.let(nil, T.nilable(T::Hash[String, String])) end sig { override.params(name: String, no_upgrade: T::Boolean, verbose: T::Boolean, options: T.untyped).returns(T::Boolean) } def preinstall!(name, no_upgrade: false, verbose: false, **options) new(name, options).preinstall!(no_upgrade:, verbose:) end sig { override.params(name: String, preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, options: T.untyped).returns(T::Boolean) } def install!(name, preinstall: true, no_upgrade: false, verbose: false, force: false, **options) new(name, options).install!(preinstall:, no_upgrade:, verbose:, force:) end # Override makes `name` a required argument unlike the parent's default-argument signature. # rubocop:disable Sorbet/AllowIncompatibleOverride sig { override(allow_incompatible: true).params(name: String, options: Homebrew::Bundle::EntryOptions).returns(String) } # rubocop:enable Sorbet/AllowIncompatibleOverride def install_verb(name, options = {}) _ = options return "Installing" unless formula_upgradable?(name) "Upgrading" end sig { params(formula: String, no_upgrade: T::Boolean).returns(T::Boolean) } def formula_installed_and_up_to_date?(formula, no_upgrade: false) return false unless formula_installed?(formula) return true if no_upgrade_with_args?(no_upgrade, formula) !formula_upgradable?(formula) end sig { params(no_upgrade: T::Boolean, formula_name: String).returns(T::Boolean) } def no_upgrade_with_args?(no_upgrade, formula_name) no_upgrade && Bundle.upgrade_formulae.exclude?(formula_name) end sig { params(formula: String, array: T::Array[String]).returns(T::Boolean) } def formula_in_array?(formula, array) return true if array.include?(formula) return true if array.include?(Utils.name_from_full_name(formula)) old_name = formula_oldnames[formula] old_name ||= formula_oldnames[Utils.name_from_full_name(formula)] return true if old_name && array.include?(old_name) resolved_full_name = formula_aliases[formula] return false unless resolved_full_name return true if array.include?(resolved_full_name) return true if array.include?(Utils.name_from_full_name(resolved_full_name)) false end sig { params(formula: String).returns(T::Boolean) } def formula_installed?(formula) formula_in_array?(formula, installed_formulae) end sig { params(formula: String).returns(T::Boolean) } def formula_upgradable?(formula) # Check local cache first and then authoritative Homebrew source. (formula_in_array?(formula, upgradable_formulae) && Formula[formula].outdated?) || false end sig { returns(T::Array[String]) } def installed_formulae @installed_formulae ||= formulae.map { |f| f[:name] } end sig { returns(T::Array[String]) } def upgradable_formulae outdated_formulae - pinned_formulae end sig { returns(T::Array[String]) } def outdated_formulae @outdated_formulae ||= formulae.filter_map { |f| f[:name] if f[:outdated?] } end sig { returns(T::Array[String]) } def pinned_formulae @pinned_formulae ||= formulae.filter_map { |f| f[:name] if f[:pinned?] } end sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) } def find_formula(name) formula = T.cast(formulae_by_full_name(name), T.nilable(T::Hash[Symbol, T.untyped])) formula.presence || formulae_by_name(name) end sig { params(name: String).returns(T::Array[String]) } def formula_dep_names(name) find_formula(name)&.fetch(:dependencies, []) || [] end # Returns recursive dependency names for lock conflict detection. # When pouring bottles, only runtime deps acquire keg locks so build # deps like cmake don't serialize unrelated bottle pours. When # building from source all deps (including build) must be considered. sig { params(name: String, include_build: T::Boolean).returns(T::Set[String]) } def recursive_dep_names(name, include_build: true) require "formula" f = Formula[name] if include_build f.recursive_dependencies else f.runtime_dependencies end.to_set(&:name) rescue FormulaUnavailableError Set.new end sig { params(name: String).returns(T::Boolean) } def formula_bottled?(name) formula = find_formula(name) return false if formula.blank? formula.fetch(:bottled, false) end sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) } def formulae return @formulae if @formulae formulae_by_full_name # formulae_by_full_name sets @formulae as a side effect of calling sort! T.cast(@formulae, T::Array[T::Hash[Symbol, T.untyped]]) end # Returns the full `@formulae_by_full_name` map when called without a name, # or a single formula's attribute hash when called with a name. sig { params(name: T.nilable(String)).returns( T.nilable(T.any(T::Hash[Symbol, T.untyped], T::Hash[String, T::Hash[Symbol, T.untyped]])), ) } def formulae_by_full_name(name = nil) return @formulae_by_full_name[name] if name.present? && @formulae_by_full_name&.key?(name) require "formula" require "formulary" Formulary.enable_factory_cache! @formulae_by_name ||= {} @formulae_by_full_name ||= {} if name.nil? formulae = Formula.installed.map { add_formula(it) } sort!(formulae) return @formulae_by_full_name end formula = Formula[name] add_formula(formula) rescue FormulaUnavailableError => e opoo "'#{name}' formula is unreadable: #{e}" {} end sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) } def formulae_by_name(name) T.cast(formulae_by_full_name(name), T.nilable(T::Hash[Symbol, T.untyped])) || @formulae_by_name&.[](name) end sig { override.params(describe: T::Boolean, no_restart: T::Boolean).returns(String) } def dump(describe: false, no_restart: false) require "bundle/brew_services" requested_formula = formulae.select do |f| f[:installed_on_request?] || !f[:installed_as_dependency?] end requested_formula.map do |f| brewline = if describe && f[:desc].present? f[:desc].split("\n").map { |s| "# #{s}\n" }.join else "" end brewline += "brew \"#{f[:full_name]}\"" args = f[:args].map { |arg| "\"#{arg}\"" }.sort.join(", ") brewline += ", args: [#{args}]" unless f[:args].empty? brewline += ", restart_service: :changed" if !no_restart && Services.started?(f[:full_name]) brewline += ", link: #{f[:link?]}" unless f[:link?].nil? brewline end.join("\n") end sig { override.params(describe: T::Boolean, no_restart: T::Boolean).returns(String) } def dump_output(describe: false, no_restart: false) dump(describe:, no_restart:) end sig { override.params(name: String, options: T::Hash[Symbol, T.untyped], no_upgrade: T::Boolean).returns(T.nilable(String)) } def fetchable_name(name, options = {}, no_upgrade: false) _ = options return if (tap_name = Utils.tap_from_full_name(name)) && Homebrew::Bundle::Tap.installed_taps.exclude?(tap_name) return if formula_installed_and_up_to_date?(name, no_upgrade:) name end sig { returns(T::Hash[String, String]) } def formula_aliases return @formula_aliases if @formula_aliases @formula_aliases = {} formulae.each do |f| aliases = f[:aliases] next if aliases.blank? aliases.each do |a| @formula_aliases[a] = f[:full_name] if (tap_name = Utils.tap_from_full_name(f[:full_name])) @formula_aliases["#{tap_name}/#{a}"] = f[:full_name] end end end @formula_aliases end sig { returns(T::Hash[String, String]) } def formula_oldnames return @formula_oldnames if @formula_oldnames @formula_oldnames = {} formulae.each do |f| oldnames = f[:oldnames] next if oldnames.blank? oldnames.each do |oldname| @formula_oldnames[oldname] = f[:full_name] if (tap_name = Utils.tap_from_full_name(f[:full_name])) @formula_oldnames["#{tap_name}/#{oldname}"] = f[:full_name] end end end @formula_oldnames end private sig { params(formula: Formula).returns(T::Hash[Symbol, T.untyped]) } def add_formula(formula) hash = formula_to_hash formula raise "formulae_by_name is nil" if @formulae_by_name.nil? raise "formulae_by_full_name is nil" if @formulae_by_full_name.nil? @formulae_by_name[hash[:name]] = hash @formulae_by_full_name[hash[:full_name]] = hash hash end sig { params(formula: Formula).returns(T::Hash[Symbol, T.untyped]) } def formula_to_hash(formula) keg = if formula.linked? link = true if formula.keg_only? formula.linked_keg else link = false unless formula.keg_only? formula.any_installed_prefix end if keg require "tab" tab = Tab.for_keg(keg) args = tab.used_options.map(&:name) version = begin keg.realpath.basename rescue # silently handle broken symlinks nil end.to_s args << "HEAD" if version.start_with?("HEAD") installed_as_dependency = tab.installed_as_dependency installed_on_request = tab.installed_on_request runtime_dependencies = if (runtime_deps = tab.runtime_dependencies) T.cast(runtime_deps, T::Array[T::Hash[String, T.untyped]]).filter_map { |d| d["full_name"] } end poured_from_bottle = tab.poured_from_bottle end runtime_dependencies ||= formula.runtime_dependencies.map(&:name) bottled = if (stable = formula.stable) && stable.bottle_defined? bottle_hash = formula.bottle_hash.deep_symbolize_keys stable.bottled? end { name: formula.name, desc: formula.desc, oldnames: formula.oldnames, full_name: formula.full_name, aliases: formula.aliases, any_version_installed?: formula.any_version_installed?, args: Array(args).uniq, version:, installed_as_dependency?: installed_as_dependency || false, installed_on_request?: installed_on_request || false, dependencies: runtime_dependencies, build_dependencies: formula.deps.select(&:build?).map(&:name).uniq, conflicts_with: formula.conflicts.map(&:name), pinned?: formula.pinned? || false, outdated?: formula.outdated? || false, link?: link, poured_from_bottle?: poured_from_bottle || false, bottle: bottle_hash || false, bottled: bottled || false, official_tap: formula.tap&.official? || false, } end sig { params(formulae: T::Array[T::Hash[Symbol, T.untyped]]).void } def sort!(formulae) # Step 1: Sort by formula full name while putting tap formulae behind core formulae. # So we can have a nicer output. formulae = formulae.sort do |a, b| if a[:full_name].exclude?("/") && b[:full_name].include?("/") -1 elsif a[:full_name].include?("/") && b[:full_name].exclude?("/") 1 else a[:full_name] <=> b[:full_name] end end # Step 2: Sort by formula dependency topology. topo = Topo.new formulae.each do |f| topo[f[:name]] = topo[f[:full_name]] = f[:dependencies].filter_map do |dep| ff = formulae_by_name(dep) next if ff.blank? next unless ff[:any_version_installed?] ff[:full_name] end end raise "formulae_by_full_name is nil" if @formulae_by_full_name.nil? raise "formulae_by_name is nil" if @formulae_by_name.nil? @formulae = topo.tsort .map { |name| @formulae_by_full_name[name] || @formulae_by_name[name] } .uniq { |f| f[:full_name] } rescue TSort::Cyclic => e e.message =~ /\["([^"]*)".*"([^"]*)"\]/ cycle_first = Regexp.last_match(1) cycle_last = Regexp.last_match(2) odie e.message if !cycle_first || !cycle_last odie <<~EOS Formulae dependency graph sorting failed (likely due to a circular dependency): #{cycle_first}: #{topo[cycle_first] if topo} #{cycle_last}: #{topo[cycle_last] if topo} Please run the following commands and try again: brew update brew uninstall --ignore-dependencies --force #{cycle_first} #{cycle_last} brew install #{cycle_first} #{cycle_last} EOS end end sig { params(name: String, options: T::Hash[Symbol, T.untyped]).void } def initialize(name = "", options = {}) super() @full_name = name @name = T.let(Utils.name_from_full_name(name), String) @args = T.let(options.fetch(:args, []).map { |arg| "--#{arg}" }, T::Array[String]) @conflicts_with_arg = T.let(options.fetch(:conflicts_with, []), T::Array[String]) @restart_service = T.let(options[:restart_service], T.nilable(T.any(Symbol, T::Boolean))) @start_service = T.let(options.fetch(:start_service, @restart_service), T.nilable(T.any(Symbol, T::Boolean))) @link = T.let(options.fetch(:link, nil), T.nilable(T.any(Symbol, T::Boolean))) @postinstall = T.let(options.fetch(:postinstall, nil), T.nilable(String)) @version_file = T.let(options.fetch(:version_file, nil), T.nilable(String)) @changed = T.let(nil, T.nilable(T::Boolean)) end sig { override.params(formula: Object, no_upgrade: T::Boolean).returns(T::Boolean) } def installed_and_up_to_date?(formula, no_upgrade: false) raise "formula must be a String, got #{formula.class}: #{formula}" unless formula.is_a?(String) self.class.formula_installed_and_up_to_date?(formula, no_upgrade:) end sig { params(no_upgrade: T::Boolean, verbose: T::Boolean).returns(T::Boolean) } def preinstall!(no_upgrade: false, verbose: false) if installed? && (self.class.no_upgrade_with_args?(no_upgrade, @name) || !upgradable?) puts "Skipping install of #{@name} formula. It is already installed." if verbose @changed = nil return false end true end sig { params(preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean).returns(T::Boolean) } def install!(preinstall: true, no_upgrade: false, verbose: false, force: false) install_result = if preinstall install_change_state!(no_upgrade:, verbose:, force:) else true end result = install_result if installed? service_result = service_change_state!(verbose:) result &&= service_result link_result = link_change_state!(verbose:) result &&= link_result postinstall_result = postinstall_change_state!(verbose:) result &&= postinstall_result if result && @version_file.present? # Use the version from the environment if it hasn't changed. # Strip the revision number because it's not part of the non-Homebrew version. version = if !changed? && (env_version = Bundle.formula_versions_from_env(@name)) PkgVersion.parse(env_version).version else Formula[@full_name].version end.to_s File.write(@version_file, "#{version}\n") puts "Wrote #{@name} version #{version} to #{@version_file}" if verbose end end result end sig { params(no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean).returns(T::Boolean) } def install_change_state!(no_upgrade:, verbose:, force:) require "tap" if (tap_with_name = ::Tap.with_formula_name(@full_name)) tap, = tap_with_name tap.ensure_installed! end return false unless resolve_conflicts!(verbose:) if installed? upgrade_formula!(verbose:, force:) else install_formula!(verbose:, force:) end end sig { returns(T::Boolean) } def start_service? @start_service.present? end sig { returns(T::Boolean) } def start_service_needed? require "bundle/brew_services" start_service? && !Services.started?(@full_name) end sig { returns(T::Boolean) } def restart_service? @restart_service.present? end sig { returns(T::Boolean) } def restart_service_needed? return false unless restart_service? # Restart if `restart_service: :always`, or if the formula was installed or upgraded @restart_service.to_s == "always" || changed? end sig { returns(T::Boolean) } def changed? @changed.present? end sig { params(verbose: T::Boolean).returns(T::Boolean) } def service_change_state!(verbose:) require "bundle/brew_services" file = Services.versioned_service_file(@name)&.to_s if restart_service_needed? puts "Restarting #{@name} service." if verbose Services.restart(@full_name, file:, verbose:) elsif start_service_needed? puts "Starting #{@name} service." if verbose Services.start(@full_name, file:, verbose:) else true end end sig { params(verbose: T::Boolean).returns(T::Boolean) } def link_change_state!(verbose: false) link_args = [] link_args << "--force" if unlinked_and_keg_only? cmd = case @link when :overwrite link_args << "--overwrite" "link" unless linked? when true "link" unless linked? when false "unlink" if linked? when nil if keg_only? "unlink" if linked? else "link" unless linked? end end if cmd.present? verb = "#{cmd}ing".capitalize with_args = " with #{link_args.join(" ")}" if link_args.present? puts "#{verb} #{@name} formula#{with_args}." if verbose return Bundle.brew(cmd, *link_args, @name, verbose:) end true end sig { params(verbose: T::Boolean).returns(T::Boolean) } def postinstall_change_state!(verbose:) return true if @postinstall.blank? return true unless changed? puts "Running postinstall for #{@name}: #{@postinstall}" if verbose Kernel.system(@postinstall) || false end private sig { returns(T::Boolean) } def installed? self.class.formula_installed?(@name) end sig { returns(T::Boolean) } def linked? Formula[@full_name].linked? end sig { returns(T::Boolean) } def keg_only? Formula[@full_name].keg_only? end sig { returns(T::Boolean) } def unlinked_and_keg_only? !linked? && keg_only? end sig { returns(T::Boolean) } def upgradable? self.class.formula_upgradable?(@full_name) end sig { returns(T::Array[String]) } def conflicts_with @conflicts_with ||= T.let( begin conflicts_with = Set.new conflicts_with += @conflicts_with_arg if (formula = T.cast(self.class.formulae_by_full_name(@full_name), T.nilable(T::Hash[Symbol, T.untyped]))) && (formula_conflicts_with = formula[:conflicts_with]) conflicts_with += formula_conflicts_with end conflicts_with.to_a end, T.nilable(T::Array[String]), ) end sig { params(verbose: T::Boolean).returns(T::Boolean) } def resolve_conflicts!(verbose:) conflicts_with.each do |conflict| next unless self.class.formula_installed?(conflict) if verbose puts <<~EOS Unlinking #{conflict} formula. It is currently installed and conflicts with #{@name}. EOS end return false unless Bundle.brew("unlink", conflict, verbose:) next unless restart_service? require "bundle/brew_services" puts "Stopping #{conflict} service (if it is running)." if verbose Services.stop(conflict, verbose:) end true end sig { params(verbose: T::Boolean, force: T::Boolean).returns(T::Boolean) } def install_formula!(verbose:, force:) install_args = @args.dup install_args << "--force" << "--overwrite" if force install_args << "--skip-link" if @link == false with_args = " with #{install_args.join(" ")}" if install_args.present? puts "Installing #{@name} formula#{with_args}. It is not currently installed." if verbose unless Bundle.brew("install", "--formula", @full_name, *install_args, verbose:) @changed = nil return false end self.class.installed_formulae << @name @changed = true true end sig { params(verbose: T::Boolean, force: T::Boolean).returns(T::Boolean) } def upgrade_formula!(verbose:, force:) upgrade_args = [] upgrade_args << "--force" if force with_args = " with #{upgrade_args.join(" ")}" if upgrade_args.present? puts "Upgrading #{@name} formula#{with_args}. It is installed but not up-to-date." if verbose unless Bundle.brew("upgrade", "--formula", @name, *upgrade_args, verbose:) @changed = nil return false end @changed = true true end class Topo < Hash extend T::Generic include TSort K = type_member { { fixed: String } } V = type_member { { fixed: T::Array[String] } } Elem = type_member(:out) { { fixed: [String, T::Array[String]] } } # TSort interface requires a broader block return type than our implementation. # rubocop:disable Sorbet/AllowIncompatibleOverride sig { override(allow_incompatible: true).params(block: T.proc.params(arg0: String).returns(BasicObject)).void } # rubocop:enable Sorbet/AllowIncompatibleOverride def each_key(&block) keys.each(&block) end alias tsort_each_node each_key sig { override.params(node: String, block: T.proc.params(arg0: String).void).void } def tsort_each_child(node, &block) fetch(node.downcase).sort.each(&block) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/brew_services.rb000066400000000000000000000131331517265720000245450ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "services/system" require "utils/output" require "bundle/brew" require "bundle/dsl" module Homebrew module Bundle class Brew class Services < Homebrew::Bundle::Brew extend Utils::Output::Mixin class << self sig { override.void } def reset! @started_services = nil end # Action methods that return a success/failure boolean, not predicate methods. # rubocop:disable Naming/PredicateMethod sig { params(name: String, keep: T::Boolean, verbose: T::Boolean).returns(T::Boolean) } def stop(name, keep: false, verbose: false) return true unless started?(name) args = ["services", "stop", name] args << "--keep" if keep return false unless Bundle.brew(*args, verbose:) started_services.delete(name) true end sig { params(name: String, file: T.nilable(String), verbose: T::Boolean).returns(T::Boolean) } def start(name, file: nil, verbose: false) args = ["services", "start", name] args << "--file=#{file}" if file return false unless Bundle.brew(*args, verbose:) started_services << name true end sig { params(name: String, file: T.nilable(T.any(Pathname, String)), verbose: T::Boolean).returns(T::Boolean) } def run(name, file: nil, verbose: false) args = ["services", "run", name] args << "--file=#{file}" if file return false unless Bundle.brew(*args, verbose:) started_services << name true end sig { params(name: String, file: T.nilable(String), verbose: T::Boolean).returns(T::Boolean) } def restart(name, file: nil, verbose: false) args = ["services", "restart", name] args << "--file=#{file}" if file return false unless Bundle.brew(*args, verbose:) started_services << name true end # rubocop:enable Naming/PredicateMethod sig { params(name: String).returns(T::Boolean) } def started?(name) started_services.include? name end sig { returns(T::Array[String]) } def started_services @started_services ||= T.let( begin if !Homebrew::Services::System.launchctl? && !Homebrew::Services::System.systemctl? odie Homebrew::Services::System::MISSING_DAEMON_MANAGER_EXCEPTION_MESSAGE end states_to_skip = %w[stopped none] services_list = JSON.parse(Utils.safe_popen_read(HOMEBREW_BREW_FILE, "services", "list", "--json")) services_list.filter_map do |hash| hash.fetch("name") if states_to_skip.exclude?(hash.fetch("status")) end end, T.nilable(T::Array[String]), ) end sig { params(name: String).returns(T.nilable(Pathname)) } def versioned_service_file(name) env_version = Bundle.formula_versions_from_env(name) return if env_version.nil? formula = Formula[name] prefix = formula.rack/env_version return unless prefix.directory? service_file = if Homebrew::Services::System.launchctl? prefix/"#{formula.plist_name}.plist" else prefix/"#{formula.service_name}.service" end service_file if service_file.file? end end sig { override.params(name: Object, no_upgrade: T::Boolean).returns(String) } def failure_reason(name, no_upgrade:) _ = no_upgrade "Service #{name} needs to be started." end sig { override.params(formula: Object, no_upgrade: T::Boolean).returns(T::Boolean) } def installed_and_up_to_date?(formula, no_upgrade: false) _ = no_upgrade entry = T.cast(formula, Homebrew::Bundle::Dsl::Entry) return true unless formula_needs_to_start?(entry_to_formula(entry)) name = entry.name return true if self.class.started?(name) # `brew services list` returns base names, so fall back to the last # path component for tap-qualified entries (e.g., "user/tap/formula"). base_name = Utils.name_from_full_name(name) return true if base_name != name && self.class.started?(base_name) old_name = lookup_old_name(name) return true if old_name && self.class.started?(old_name) false end sig { params(entry: Homebrew::Bundle::Dsl::Entry).returns(Homebrew::Bundle::Brew) } def entry_to_formula(entry) Homebrew::Bundle::Brew.new(entry.name, entry.options) end sig { params(formula: Homebrew::Bundle::Brew).returns(T::Boolean) } def formula_needs_to_start?(formula) formula.start_service? || formula.restart_service? end sig { params(service_name: String).returns(T.nilable(String)) } def lookup_old_name(service_name) @old_names ||= T.let(Homebrew::Bundle::Brew.formula_oldnames, T.nilable(T::Hash[String, String])) old_name = @old_names[service_name] old_name ||= @old_names[Utils.name_from_full_name(service_name)] old_name end sig { params(entries: T::Array[Object]).returns(T::Array[Object]) } def format_checkable(entries) checkable_entries(entries) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/brewfile.rb000066400000000000000000000043201517265720000235000ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/dsl" module Homebrew module Bundle module Brewfile sig { params( dash_writes_to_stdout: T::Boolean, global: T::Boolean, file: T.nilable(String), ).returns(Pathname) } def self.path(dash_writes_to_stdout: false, global: false, file: nil) env_bundle_file_global = ENV.fetch("HOMEBREW_BUNDLE_FILE_GLOBAL", nil) env_bundle_file = ENV.fetch("HOMEBREW_BUNDLE_FILE", nil) user_config_home = ENV.fetch("HOMEBREW_USER_CONFIG_HOME", nil) filename = if global if env_bundle_file_global.present? env_bundle_file_global else raise "'HOMEBREW_BUNDLE_FILE' cannot be specified with '--global'" if env_bundle_file.present? home_brewfile = Bundle.exchange_uid_if_needed! do "#{Dir.home}/.Brewfile" end user_config_home_brewfile = "#{user_config_home}/Brewfile" if user_config_home.present? && Dir.exist?(user_config_home) && (File.exist?(user_config_home_brewfile) || !File.exist?(home_brewfile)) user_config_home_brewfile else home_brewfile end end elsif file.present? handle_file_value(file, dash_writes_to_stdout) elsif env_bundle_file.present? env_bundle_file else "Brewfile" end Pathname.new(filename).expand_path(Dir.pwd) end sig { params(global: T::Boolean, file: T.nilable(String)).returns(Dsl) } def self.read(global: false, file: nil) Homebrew::Bundle::Dsl.new(Brewfile.path(global:, file:)) rescue Errno::ENOENT raise "No Brewfile found" end sig { params( filename: String, dash_writes_to_stdout: T::Boolean, ).returns(String) } private_class_method def self.handle_file_value(filename, dash_writes_to_stdout) if filename != "-" filename elsif dash_writes_to_stdout "/dev/stdout" else "/dev/stdin" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/cask.rb000066400000000000000000000231201517265720000226210ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils" require "utils/output" require "bundle/package_type" module Homebrew module Bundle class Cask < Homebrew::Bundle::PackageType extend ::Utils::Output::Mixin PACKAGE_TYPE = :cask PACKAGE_TYPE_NAME = "Cask" class << self sig { override.void } def reset! @casks = T.let(nil, T.nilable(T::Array[::Cask::Cask])) @cask_names = T.let(nil, T.nilable(T::Array[String])) @cask_oldnames = T.let(nil, T.nilable(T::Hash[String, String])) @installed_casks = T.let(nil, T.nilable(T::Array[String])) @outdated_casks = T.let(nil, T.nilable(T::Array[String])) end private sig { params(no_upgrade: T::Boolean, name: String, options: Homebrew::Bundle::EntryOptions).returns(T::Boolean) } def upgrading?(no_upgrade, name, options) return false if no_upgrade return true if cask_upgradable?(name) return false unless options[:greedy] cask_is_outdated_using_greedy?(name) end sig { params(name: String, options: Homebrew::Bundle::EntryOptions, verbose: T::Boolean).returns(T::Boolean) } def postinstall_change_state!(name:, options:, verbose:) postinstall = T.cast(options.fetch(:postinstall, nil), T.nilable(String)) return true if postinstall.blank? puts "Running postinstall for #{name}: #{postinstall}" if verbose Kernel.system(postinstall) || false end sig { returns(T::Array[::Cask::Cask]) } def casks return [] unless Bundle.cask_installed? require "cask/caskroom" @casks ||= T.let(::Cask::Caskroom.casks, T.nilable(T::Array[::Cask::Cask])) end sig { params(cask_config: ::Cask::Config).returns(String) } def explicit_s(cask_config) cask_config.explicit.map do |key, value| # inverse of #env - converts :languages config key back to --language flag if key == :languages key = "language" value = Array(cask_config.explicit.fetch(:languages, [])).join(",") end "#{key}: \"#{value.to_s.sub(/^#{Dir.home}/, "~")}\"" end.join(", ") end public # Override makes `name` a required argument unlike the parent's default-argument signature. # rubocop:disable Sorbet/AllowIncompatibleOverride sig { override(allow_incompatible: true).params(name: String, options: Homebrew::Bundle::EntryOptions).returns(String) } # rubocop:enable Sorbet/AllowIncompatibleOverride def install_verb(name, options = {}) return "Installing" if !cask_installed?(name) || !upgrading?(false, name, options) "Upgrading" end sig { override.params(name: String, no_upgrade: T::Boolean, verbose: T::Boolean, options: T.untyped).returns(T::Boolean) } def preinstall!(name, no_upgrade: false, verbose: false, **options) if cask_installed?(name) && !upgrading?(no_upgrade, name, options) puts "Skipping install of #{name} cask. It is already installed." if verbose return false end true end sig { override.params(name: String, preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, options: T.untyped).returns(T::Boolean) } def install!(name, preinstall: true, no_upgrade: false, verbose: false, force: false, **options) return true unless preinstall full_name = options.fetch(:full_name, name) install_result = if cask_installed?(name) && upgrading?(no_upgrade, name, options) status = "#{options[:greedy] ? "may not be" : "not"} up-to-date" puts "Upgrading #{name} cask. It is installed but #{status}." if verbose Bundle.brew("upgrade", "--cask", full_name, verbose:) else args = options.fetch(:args, []).filter_map do |k, v| case v when TrueClass "--#{k}" when FalseClass, NilClass nil else "--#{k}=#{v}" end end args << "--force" if force args << "--adopt" unless args.include?("--force") args.uniq! with_args = " with #{args.join(" ")}" if args.present? puts "Installing #{name} cask#{with_args}. It is not currently installed." if verbose if Bundle.brew("install", "--cask", full_name, *args, verbose:) installed_casks << name true else false end end result = install_result if cask_installed?(name) postinstall_result = postinstall_change_state!(name:, options:, verbose:) result &&= postinstall_result end result end sig { params(name: String, no_upgrade: T::Boolean, options: T.untyped).returns(T::Boolean) } def installable_or_upgradable?(name, no_upgrade: false, **options) !cask_installed?(name) || upgrading?(no_upgrade, name, options) end sig { params(name: String, options: Homebrew::Bundle::EntryOptions, no_upgrade: T::Boolean).returns(T.nilable(String)) } def fetchable_name(name, options = {}, no_upgrade: false) full_name = T.cast(options.fetch(:full_name, name), String) return if (tap_name = Utils.tap_from_full_name(full_name)) && Homebrew::Bundle::Tap.installed_taps.exclude?(tap_name) return unless installable_or_upgradable?(name, no_upgrade:, **options) full_name end sig { params(cask: String, no_upgrade: T::Boolean).returns(T::Boolean) } def cask_installed_and_up_to_date?(cask, no_upgrade: false) return false unless cask_installed?(cask) return true if no_upgrade !cask_upgradable?(cask) end sig { params(cask: String, array: T::Array[String]).returns(T::Boolean) } def cask_in_array?(cask, array) return true if array.include?(cask) array.include?(Utils.name_from_full_name(cask)) end sig { params(cask: String).returns(T::Boolean) } def cask_installed?(cask) return true if cask_in_array?(cask, installed_casks) old_name = cask_oldnames[cask] old_name ||= cask_oldnames[Utils.name_from_full_name(cask)] return false unless old_name return false unless cask_in_array?(old_name, installed_casks) opoo "#{cask} was renamed to #{old_name}" true end sig { params(cask: String).returns(T::Boolean) } def cask_upgradable?(cask) cask_in_array?(cask, outdated_casks) end sig { returns(T::Array[String]) } def installed_casks @installed_casks ||= cask_names end sig { returns(T::Array[String]) } def outdated_casks @outdated_casks ||= outdated_cask_names end sig { returns(T::Array[String]) } def cask_names @cask_names ||= casks.map(&:to_s) end sig { returns(T::Array[String]) } def outdated_cask_names return [] unless Bundle.cask_installed? casks.select { |c| c.outdated?(greedy: false) } .map(&:to_s) end sig { params(cask_name: String).returns(T::Boolean) } def cask_is_outdated_using_greedy?(cask_name) return false unless Bundle.cask_installed? cask = casks.find { |installed_cask| installed_cask.to_s == cask_name } return false if cask.nil? cask.outdated?(greedy: true) end sig { override.params(describe: T::Boolean).returns(String) } def dump(describe: false) casks.map do |cask| description = "# #{cask.desc}\n" if describe && cask.desc.present? config = ", args: { #{explicit_s(cask.config)} }" if cask.config.present? && cask.config.explicit.present? "#{description}cask \"#{cask.full_name}\"#{config}" end.join("\n") end sig { override.params(describe: T::Boolean, no_restart: T::Boolean).returns(String) } def dump_output(describe: false, no_restart: false) _ = no_restart dump(describe:) end sig { returns(T::Hash[String, String]) } def cask_oldnames @cask_oldnames ||= casks.each_with_object({}) do |c, hash| oldnames = c.old_tokens next if oldnames.blank? oldnames.each do |oldname| hash[oldname] = c.full_name if (tap_name = Utils.tap_from_full_name(c.full_name)) hash["#{tap_name}/#{oldname}"] = c.full_name end end end end sig { params(cask_list: T::Array[String]).returns(T::Array[String]) } def formula_dependencies(cask_list) return [] unless Bundle.cask_installed? return [] if cask_list.blank? casks.flat_map do |cask| next unless cask_list.include?(cask.to_s) cask.depends_on[:formula] end.compact end end sig { override.params(cask: Object, no_upgrade: T::Boolean).returns(T::Boolean) } def installed_and_up_to_date?(cask, no_upgrade: false) raise "cask must be a String, got #{cask.class}: #{cask}" unless cask.is_a?(String) self.class.cask_installed_and_up_to_date?(cask, no_upgrade:) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/checker.rb000066400000000000000000000076161517265720000233200ustar00rootroot00000000000000# typed: true # frozen_string_literal: true require "bundle/dsl" require "bundle/package_types" require "bundle/brew_services" module Homebrew module Bundle module Checker CheckResult = Struct.new :work_to_be_done, :errors CheckStep = T.type_alias { Symbol } CORE_CHECKS = T.let([ :taps_to_tap, :casks_to_install, :registered_extensions_to_install, :apps_to_install, :formulae_to_install, :formulae_to_start, ].freeze, T::Array[CheckStep]) def self.check(global: false, file: nil, exit_on_first_error: false, no_upgrade: false, verbose: false) require "bundle/brewfile" @dsl ||= Brewfile.read(global:, file:) errors = [] enumerator = exit_on_first_error ? :find : :map work_to_be_done = CORE_CHECKS.public_send(enumerator) do |check_step| check_errors = public_send(check_step, exit_on_first_error:, no_upgrade:, verbose:) any_errors = check_errors.any? errors.concat(check_errors) if any_errors any_errors end work_to_be_done = Array(work_to_be_done).flatten.any? CheckResult.new work_to_be_done, errors end def self.apps_to_install(exit_on_first_error: false, no_upgrade: false, verbose: false) extension_errors(:apps_to_install, exit_on_first_error:, no_upgrade:, verbose:) end def self.formulae_to_start(exit_on_first_error: false, no_upgrade: false, verbose: false) Homebrew::Bundle::Brew::Services.new.find_actionable( @dsl.entries, exit_on_first_error:, no_upgrade:, verbose:, ) end def self.taps_to_tap(exit_on_first_error: false, no_upgrade: false, verbose: false) package_type_errors(:tap, exit_on_first_error:, no_upgrade:, verbose:) end def self.casks_to_install(exit_on_first_error: false, no_upgrade: false, verbose: false) package_type_errors(:cask, exit_on_first_error:, no_upgrade:, verbose:) end def self.formulae_to_install(exit_on_first_error: false, no_upgrade: false, verbose: false) package_type_errors(:brew, exit_on_first_error:, no_upgrade:, verbose:) end def self.registered_extensions_to_install(exit_on_first_error: false, no_upgrade: false, verbose: false) extension_errors(:registered_extensions_to_install, exit_on_first_error:, no_upgrade:, verbose:) end sig { params( step: Symbol, exit_on_first_error: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, ).returns(T::Array[Object]) } def self.extension_errors(step, exit_on_first_error:, no_upgrade:, verbose:) matching_extensions = Homebrew::Bundle.extensions.select { |extension| extension.legacy_check_step == step } errors = T.let([], T::Array[Object]) matching_extensions.each do |extension| check_errors = extension.check( @dsl.entries, exit_on_first_error:, no_upgrade:, verbose:, ) next if check_errors.empty? return check_errors if exit_on_first_error errors.concat(check_errors) end errors end def self.reset! @dsl = nil Homebrew::Bundle.package_types.each(&:reset!) Homebrew::Bundle.extensions.each(&:reset!) end sig { params( type: Symbol, exit_on_first_error: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, ).returns(T::Array[Object]) } def self.package_type_errors(type, exit_on_first_error:, no_upgrade:, verbose:) package_type = Homebrew::Bundle.package_type(type) return [] if package_type.nil? package_type.check(@dsl.entries, exit_on_first_error:, no_upgrade:, verbose:) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/000077500000000000000000000000001517265720000231565ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/add.rb000066400000000000000000000007451517265720000242410ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/adder" module Homebrew module Bundle module Commands module Add sig { params(args: String, type: Symbol, global: T::Boolean, file: T.nilable(String), describe: T::Boolean).void } def self.run(*args, type:, global:, file:, describe: false) Homebrew::Bundle::Adder.add(*args, type:, global:, file:, describe:) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/check.rb000066400000000000000000000032101517265720000245540ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/checker" module Homebrew module Bundle module Commands module Check sig { params(global: T::Boolean, file: T.nilable(String), no_upgrade: T::Boolean, verbose: T::Boolean, quiet: T::Boolean).void } def self.run(global: false, file: nil, no_upgrade: false, verbose: false, quiet: false) output_errors = verbose exit_on_first_error = !verbose check_result = Homebrew::Bundle::Checker.check( global:, file:, exit_on_first_error:, no_upgrade:, verbose: ) # Allow callers of `brew bundle check` to specify when they've already # output some formulae errors. check_missing_formulae = ENV.fetch("HOMEBREW_BUNDLE_CHECK_ALREADY_OUTPUT_FORMULAE_ERRORS", "") .strip .split if check_result.work_to_be_done puts "brew bundle can't satisfy your Brewfile's dependencies." if check_missing_formulae.blank? if output_errors check_result.errors.each do |error| if (match = error.match(/^Formula (.+) needs to be installed/)) && check_missing_formulae.include?(match[1]) next end puts "→ #{error}" end end puts "Satisfy missing dependencies with `brew bundle install`." exit 1 end puts "The Brewfile's dependencies are satisfied." unless quiet end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/cleanup.rb000066400000000000000000000236211517265720000251360ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/formatter" require "bundle/dsl" require "bundle/extensions" module Homebrew module Bundle module Commands # Uninstalls formulae, casks, taps, VSCode extensions and Flatpak packages not listed in the Brewfile. module Cleanup sig { void } def self.reset! require "bundle/cask" require "bundle/brew" require "bundle/tap" require "bundle/brew_services" @dsl = T.let(nil, T.nilable(Homebrew::Bundle::Dsl)) @kept_casks = nil @kept_formulae = nil Homebrew::Bundle::Cask.reset! Homebrew::Bundle::Brew.reset! Homebrew::Bundle::Tap.reset! Homebrew::Bundle::Brew::Services.reset! Homebrew::Bundle.extensions.each(&:reset!) end sig { params(global: T::Boolean, file: T.nilable(String), force: T::Boolean, zap: T::Boolean, dsl: T.nilable(Homebrew::Bundle::Dsl), formulae: T::Boolean, casks: T::Boolean, taps: T::Boolean, extension_types: Homebrew::Bundle::ExtensionTypes).void } def self.run(global: false, file: nil, force: false, zap: false, dsl: nil, formulae: true, casks: true, taps: true, extension_types: {}) read_dsl_from_brewfile!(global:, file:, dsl:) extension_types = Homebrew::Bundle.extensions.select(&:cleanup_supported?).to_h do |extension| [extension.type, true] end.merge(extension_types) casks = casks ? casks_to_uninstall(global:, file:) : [] formulae = formulae ? formulae_to_uninstall(global:, file:) : [] taps = taps ? taps_to_untap(global:, file:) : [] cleanup_extensions = Homebrew::Bundle.extensions.select(&:cleanup_supported?).filter_map do |extension| next unless extension_types.fetch(extension.type, false) raise ArgumentError, "dsl is unset!" unless @dsl [extension, extension.cleanup_items(@dsl.entries)] end if force if casks.any? args = zap ? ["--zap"] : [] Kernel.system HOMEBREW_BREW_FILE, "uninstall", "--cask", *args, "--force", *casks puts "Uninstalled #{casks.size} cask#{"s" if casks.size != 1}" end if formulae.any? raise ArgumentError, "dsl is unset!" unless @dsl # Mark Brewfile formulae as installed_on_request to prevent autoremove # from removing them when their dependents are uninstalled Homebrew::Bundle.mark_as_installed_on_request!(@dsl.entries) Kernel.system HOMEBREW_BREW_FILE, "uninstall", "--formula", "--force", *formulae puts "Uninstalled #{formulae.size} formula#{"e" if formulae.size != 1}" end Kernel.system HOMEBREW_BREW_FILE, "untap", *taps if taps.any? cleanup_extensions.each do |extension, items| next if items.empty? extension.cleanup!(items) end cleanup = system_output_no_stderr(HOMEBREW_BREW_FILE, "cleanup") puts cleanup unless cleanup.empty? else would_uninstall = false if casks.any? puts "Would uninstall casks:" puts Formatter.columns casks would_uninstall = true end if formulae.any? puts "Would uninstall formulae:" puts Formatter.columns formulae would_uninstall = true end if taps.any? puts "Would untap:" puts Formatter.columns taps would_uninstall = true end cleanup_extensions.each do |extension, items| next if items.empty? puts "Would uninstall #{extension.cleanup_heading}:" puts Formatter.columns items would_uninstall = true end cleanup = system_output_no_stderr(HOMEBREW_BREW_FILE, "cleanup", "--dry-run") unless cleanup.empty? puts "Would `brew cleanup`:" puts cleanup end puts "Run `brew bundle cleanup --force` to make these changes." if would_uninstall || !cleanup.empty? exit 1 if would_uninstall end end sig { params(global: T::Boolean, file: T.nilable(String), dsl: T.nilable(Homebrew::Bundle::Dsl)).void } def self.read_dsl_from_brewfile!(global: false, file: nil, dsl: nil) @dsl = T.let( if dsl dsl else require "bundle/brewfile" Brewfile.read(global:, file:) end, T.nilable(Homebrew::Bundle::Dsl), ) end sig { returns(T.nilable(Homebrew::Bundle::Dsl)) } def self.dsl @dsl end sig { params(global: T::Boolean, file: T.nilable(String)).returns(T::Array[String]) } def self.casks_to_uninstall(global: false, file: nil) raise ArgumentError, "@dsl is unset!" unless @dsl require "bundle/cask" Homebrew::Bundle::Cask.cask_names - kept_casks(global:, file:) end sig { params(global: T::Boolean, file: T.nilable(String)).returns(T::Array[String]) } def self.formulae_to_uninstall(global: false, file: nil) raise ArgumentError, "@dsl is unset!" unless @dsl kept_formulae = self.kept_formulae(global:, file:) require "bundle/brew" current_formulae = Homebrew::Bundle::Brew.formulae current_formulae.reject! do |f| Homebrew::Bundle::Brew.formula_in_array?(f[:full_name], kept_formulae) end # Don't try to uninstall formulae with keepme references current_formulae.reject! do |f| Formula[f[:full_name]].installed_kegs.any? do |keg| keg.keepme_refs.present? end end current_formulae.map { |f| f[:full_name] } end sig { params(global: T::Boolean, file: T.nilable(String)).returns(T::Array[String]) } private_class_method def self.kept_formulae(global: false, file: nil) require "bundle/brew" require "bundle/cask" @kept_formulae ||= T.let( begin raise ArgumentError, "dsl is unset!" unless @dsl kept_formulae = @dsl.entries.select { |e| e.type == :brew }.map(&:name) kept_formulae += Homebrew::Bundle::Cask.formula_dependencies(kept_casks) kept_formulae.map! do |f| Homebrew::Bundle::Brew.formula_aliases.fetch( f, Homebrew::Bundle::Brew.formula_oldnames.fetch(f, f), ) end kept_formulae + recursive_dependencies(Homebrew::Bundle::Brew.formulae, kept_formulae) end, T.nilable(T::Array[String]), ) end sig { params(global: T::Boolean, file: T.nilable(String)).returns(T::Array[String]) } private_class_method def self.kept_casks(global: false, file: nil) return @kept_casks if @kept_casks raise ArgumentError, "dsl is unset!" unless @dsl kept_casks = @dsl.entries.select { |e| e.type == :cask }.flat_map(&:name) kept_casks.map! do |c| Homebrew::Bundle::Cask.cask_oldnames.fetch(c, c) end @kept_casks = T.let(kept_casks, T.nilable(T::Array[String])) raise "kept_casks is nil" unless @kept_casks @kept_casks end sig { params(current_formulae: T::Array[T::Hash[Symbol, T.untyped]], formulae_names: T::Array[String], top_level: T::Boolean).returns(T::Array[String]) } private_class_method def self.recursive_dependencies(current_formulae, formulae_names, top_level: true) @checked_formulae_names = T.let([], T.nilable(T::Array[String])) if top_level dependencies = T.let([], T::Array[String]) formulae_names.each do |name| raise "checked_formulae_names is unset!" unless @checked_formulae_names next if @checked_formulae_names.include?(name) formula = current_formulae.find { |f| f[:full_name] == name } next unless formula f_deps = formula[:dependencies] unless formula[:poured_from_bottle?] f_deps += formula[:build_dependencies] f_deps.uniq! end next unless f_deps next if f_deps.empty? @checked_formulae_names << name f_deps += recursive_dependencies(current_formulae, f_deps, top_level: false) dependencies += f_deps end dependencies.uniq end IGNORED_TAPS = %w[homebrew/core].freeze sig { params(global: T::Boolean, file: T.nilable(String)).returns(T::Array[String]) } def self.taps_to_untap(global: false, file: nil) raise ArgumentError, "@dsl is unset!" unless @dsl require "bundle/tap" kept_formulae = self.kept_formulae(global:, file:).filter_map { lookup_formula(it) } kept_taps = @dsl.entries.select { |e| e.type == :tap }.map(&:name) kept_taps += kept_formulae.filter_map(&:tap).map(&:name) current_taps = Homebrew::Bundle::Tap.tap_names current_taps - kept_taps - IGNORED_TAPS end sig { params(formula: String).returns(T.nilable(Formula)) } private_class_method def self.lookup_formula(formula) Formulary.factory(formula) rescue TapFormulaUnavailableError # ignore these as an unavailable formula implies there is no tap to worry about nil end sig { params(cmd: T.any(Pathname, String), args: T.anything).returns(String) } def self.system_output_no_stderr(cmd, *args) IO.popen([cmd, *args], err: :close).read end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/dump.rb000066400000000000000000000013741517265720000244550ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/dumper" module Homebrew module Bundle module Commands module Dump sig { params(global: T::Boolean, file: T.nilable(String), describe: T::Boolean, force: T::Boolean, no_restart: T::Boolean, taps: T::Boolean, formulae: T::Boolean, casks: T::Boolean, extension_types: Homebrew::Bundle::ExtensionTypes).void } def self.run(global:, file:, describe:, force:, no_restart:, taps:, formulae:, casks:, extension_types: {}) Homebrew::Bundle::Dumper.dump_brewfile( global:, file:, describe:, force:, no_restart:, taps:, formulae:, casks:, extension_types:, ) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/exec.rb000066400000000000000000000312621517265720000244330ustar00rootroot00000000000000# typed: true # frozen_string_literal: true require "English" require "exceptions" require "extend/ENV" require "utils" require "PATH" require "utils/output" module Homebrew module Bundle module Commands module Exec extend Utils::Output::Mixin PATH_LIKE_ENV_REGEX = /.+#{File::PATH_SEPARATOR}/ sig { params( args: String, global: T::Boolean, file: T.nilable(String), subcommand: String, services: T::Boolean, check: T::Boolean, no_secrets: T::Boolean, ).void } def self.run( *args, global: false, file: nil, subcommand: "", services: false, check: false, no_secrets: false ) if check require "bundle/commands/check" Homebrew::Bundle::Commands::Check.run(global:, file:, quiet: true) end # Store the old environment so we can check if things were already set # before we start mutating it. old_env = ENV.to_h ENV.clear_sensitive_environment! if no_secrets # Setup Homebrew's ENV extensions ENV.activate_extensions! command = args.first raise UsageError, "No command to execute was specified!" if command.blank? require "bundle/brewfile" @dsl = Brewfile.read(global:, file:) require "formula" require "formulary" ENV.deps = @dsl.entries.filter_map do |entry| next if entry.type != :brew Formulary.factory(entry.name) end # Allow setting all dependencies to be keg-only # (i.e. should be explicitly in HOMEBREW_*PATHs ahead of HOMEBREW_PREFIX) ENV.keg_only_deps = if ENV["HOMEBREW_BUNDLE_EXEC_ALL_KEG_ONLY_DEPS"].present? ENV.delete("HOMEBREW_BUNDLE_EXEC_ALL_KEG_ONLY_DEPS") ENV.deps else ENV.deps.select(&:keg_only?) end ENV.setup_build_environment # Enable compiler flag filtering ENV.refurbish_args # Add variable to detect being inside a `brew bundle exec` environment ENV["HOMEBREW_INSIDE_BUNDLE"] = "1" # Set up `nodenv`, `pyenv` and `rbenv` if present. env_formulae = %w[nodenv pyenv rbenv] ENV.deps.each do |dep| dep_name = dep.name next unless env_formulae.include?(dep_name) dep_root = ENV.fetch("HOMEBREW_#{dep_name.upcase}_ROOT", "#{Dir.home}/.#{dep_name}") ENV.prepend_path "PATH", Pathname.new(dep_root)/"shims" end # Setup pkgconf, if needed, to help locate packages Bundle.prepend_pkgconf_path_if_needed! # For commands which aren't either absolute or relative # Add the command directory to PATH, since it may get blown away by superenv if command.exclude?("/") && (which_command = which(command)).present? ENV.prepend_path "PATH", which_command.dirname.to_s end # Replace the formula versions from the environment variables ENV.deps.each do |formula| formula_name = formula.name formula_version = Bundle.formula_versions_from_env(formula_name) next unless formula_version ENV.each do |key, value| opt = %r{/opt/#{formula_name}([/:$])} next unless value.match(opt) cellar = "/Cellar/#{formula_name}/#{formula_version}\\1" # Look for PATH-like environment variables ENV[key] = if key.include?("PATH") && value.match?(PATH_LIKE_ENV_REGEX) rejected_opts = [] path = PATH.new(ENV.fetch("PATH")) .reject do |path_value| rejected_opts << path_value if path_value.match?(opt) end rejected_opts.each do |path_value| path.prepend(path_value.gsub(opt, cellar)) end path.to_s else value.gsub(opt, cellar) end end end # Ensure brew bundle exec/sh/env commands have access to other tools in the PATH if (homebrew_path = ENV.fetch("HOMEBREW_PATH", nil)) ENV.append_path "PATH", homebrew_path end # For commands which aren't either absolute or relative raise "command was not found in your PATH: #{command}" if command.exclude?("/") && which(command).nil? %w[HOMEBREW_TEMP TMPDIR HOMEBREW_TMPDIR].each do |var| value = ENV.fetch(var, nil) next if value.blank? next if File.writable?(value) ENV.delete(var) end ENV.each do |key, value| # Look for PATH-like environment variables next if key.exclude?("PATH") || !value.match?(PATH_LIKE_ENV_REGEX) # Exclude Homebrew shims from the PATH as they don't work # without all Homebrew environment variables and can interfere with # non-Homebrew builds. ENV[key] = PATH.new(value) .reject do |path_value| path_value.include?("/Homebrew/shims/") end.to_s end if subcommand == "env" ENV.sort.each do |key, value| # Skip exporting Homebrew internal variables that won't be used by other tools. # Those Homebrew needs have already been set to global constants and/or are exported again later. # Setting these globally can interfere with nested Homebrew invocations/environments. if key.start_with?("HOMEBREW_", "PORTABLE_RUBY_") ENV.delete(key) next end # No need to export empty values. next if value.blank? # Skip exporting things that were the same in the old environment. old_value = old_env[key] next if old_value == value # Look for PATH-like environment variables if key.include?("PATH") && value.match?(PATH_LIKE_ENV_REGEX) old_values = old_value.to_s.split(File::PATH_SEPARATOR) path = PATH.new(value) .reject do |path_value| # Exclude existing/old values as they've already been exported. old_values.include?(path_value) end next if path.blank? puts "export #{key}=\"#{Utils::Shell.sh_quote(path.to_s)}:${#{key}:-}\"" else puts "export #{key}=\"#{Utils::Shell.sh_quote(value)}\"" end end return elsif subcommand == "sh" preferred_path = Utils::Shell.preferred_path(default: "/bin/bash") notice = unless Homebrew::EnvConfig.no_env_hints? <<~EOS Your shell has been configured to use a build environment from your `Brewfile`. This should help you build stuff. Hide these hints with `HOMEBREW_NO_ENV_HINTS=1` (see `man brew`). When done, type `exit`. EOS end ENV["HOMEBREW_FORCE_API_AUTO_UPDATE"] = nil args = [Utils::Shell.shell_with_prompt("brew bundle", preferred_path:, notice:)] end if services require "bundle/brew_services" exit_code = T.let(0, Integer) run_services(@dsl.entries) do Kernel.system(*args) if (system_exit_code = $CHILD_STATUS&.exitstatus) exit_code = system_exit_code end end exit!(exit_code) else exec(*args) end end sig { params( entries: T::Array[Homebrew::Bundle::Dsl::Entry], _block: T.proc.params( entry: Homebrew::Bundle::Dsl::Entry, info: T::Hash[String, T.untyped], service_file: Pathname, conflicting_services: T::Array[T::Hash[String, T.untyped]], ).void, ).void } private_class_method def self.map_service_info(entries, &_block) entries_formulae = entries.filter_map do |entry| next if entry.type != :brew formula = Formula[entry.name] next unless formula.any_version_installed? [entry, formula] end.to_h return if entries_formulae.empty? conflicts = entries_formulae.to_h do |entry, formula| [ entry, ( formula.versioned_formulae_names + formula.conflicts.map(&:name) + Array(entry.options[:conflicts_with]) ).uniq, ] end # The formula + everything that could possible conflict with the service names_to_query = entries_formulae.flat_map do |entry, formula| [ formula.name, *conflicts.fetch(entry), ] end # We parse from a command invocation so that brew wrappers can invoke special actions # for the elevated nature of `brew services` services_info = JSON.parse( Utils.safe_popen_read(HOMEBREW_BREW_FILE, "services", "info", "--json", *names_to_query), ) entries_formulae.filter_map do |entry, formula| service_file = Bundle::Brew::Services.versioned_service_file(entry.name) unless service_file&.file? prefix = formula.any_installed_prefix next if prefix.nil? service_file = if Homebrew::Services::System.launchctl? prefix/"#{formula.plist_name}.plist" else prefix/"#{formula.service_name}.service" end end next unless service_file.file? info = services_info.find { |candidate| candidate["name"] == formula.name } conflicting_services = services_info.select do |candidate| next unless candidate["running"] conflicts.fetch(entry).include?(candidate["name"]) end raise "Failed to get service info for #{entry.name}" if info.nil? yield entry, info, service_file, conflicting_services end end sig { params(entries: T::Array[Homebrew::Bundle::Dsl::Entry], _block: T.nilable(T.proc.void)).void } private_class_method def self.run_services(entries, &_block) entries_to_stop = [] services_to_restart = [] map_service_info(entries) do |entry, info, service_file, conflicting_services| # Don't restart if already running this version loaded_file = Pathname.new(info["loaded_file"].to_s) next if info["running"] && loaded_file.file? && loaded_file.realpath == service_file.realpath if info["running"] && !Bundle::Brew::Services.stop(info["name"], keep: true) opoo "Failed to stop #{info["name"]} service" end conflicting_services.each do |conflict| if Bundle::Brew::Services.stop(conflict["name"], keep: true) services_to_restart << conflict["name"] if conflict["registered"] else opoo "Failed to stop #{conflict["name"]} service" end end unless Bundle::Brew::Services.run(info["name"], file: service_file) opoo "Failed to start #{info["name"]} service" end entries_to_stop << entry end return unless block_given? begin yield ensure # Do a full re-evaluation of services instead state has changed stop_services(entries_to_stop) services_to_restart.each do |service| next if Bundle::Brew::Services.run(service) opoo "Failed to restart #{service} service" end end end sig { params(entries: T::Array[Homebrew::Bundle::Dsl::Entry]).void } private_class_method def self.stop_services(entries) map_service_info(entries) do |_, info, _, _| next unless info["loaded"] # Try avoid services not started by `brew bundle services` next if Homebrew::Services::System.launchctl? && info["registered"] if info["running"] && !Bundle::Brew::Services.stop(info["name"], keep: true) opoo "Failed to stop #{info["name"]} service" end end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/install.rb000066400000000000000000000024651517265720000251600ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/brewfile" require "bundle/installer" module Homebrew module Bundle module Commands module Install sig { params( global: T::Boolean, file: T.nilable(String), no_lock: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, jobs: Integer, quiet: T::Boolean, ).void } def self.run(global: false, file: nil, no_lock: false, no_upgrade: false, verbose: false, force: false, jobs: 1, quiet: false) @dsl = Brewfile.read(global:, file:) result = Homebrew::Bundle::Installer.install!( @dsl.entries, global:, file:, no_lock:, no_upgrade:, verbose:, force:, jobs:, quiet:, ) # Mark Brewfile formulae as installed_on_request to prevent autoremove # from removing them when their dependents are uninstalled Homebrew::Bundle.mark_as_installed_on_request!(@dsl.entries) result || exit(1) end sig { returns(T.nilable(Dsl)) } def self.dsl @dsl ||= T.let(nil, T.nilable(Dsl)) @dsl end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/list.rb000066400000000000000000000012731517265720000244610ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/brewfile" require "bundle/lister" module Homebrew module Bundle module Commands module List sig { params(global: T::Boolean, file: T.nilable(String), formulae: T::Boolean, casks: T::Boolean, taps: T::Boolean, extension_types: Homebrew::Bundle::ExtensionTypes).void } def self.run(global:, file:, formulae:, casks:, taps:, extension_types: {}) parsed_entries = Brewfile.read(global:, file:).entries Homebrew::Bundle::Lister.list( parsed_entries, formulae:, casks:, taps:, extension_types: ) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/commands/remove.rb000066400000000000000000000006321517265720000250010ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/remover" module Homebrew module Bundle module Commands module Remove sig { params(args: String, type: Symbol, global: T::Boolean, file: T.nilable(String)).void } def self.run(*args, type:, global:, file:) Homebrew::Bundle::Remover.remove(*args, type:, global:, file:) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/dsl.rb000066400000000000000000000126771517265720000225010ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/package_type" require "utils" module Homebrew module Bundle class Dsl class Entry sig { returns(Symbol) } attr_reader :type sig { returns(String) } attr_reader :name sig { returns(Homebrew::Bundle::EntryOptions) } attr_reader :options sig { params(type: Symbol, name: String, options: Homebrew::Bundle::EntryOptions).void } def initialize(type, name, options = {}) @type = type @name = name @options = options end sig { returns(String) } def to_s name end end sig { returns(T::Array[Entry]) } attr_reader :entries sig { returns(T::Hash[Symbol, T.untyped]) } attr_reader :cask_arguments sig { returns(String) } attr_reader :input sig { params(path: T.any(Pathname, StringIO)).void } def initialize(path) @path = path path_read = path.read raise "path_read is nil" unless path_read @input = T.let(path_read, String) @entries = T.let([], T::Array[Entry]) @cask_arguments = T.let({}, T::Hash[Symbol, T.untyped]) begin process # Want to catch all exceptions for e.g. syntax errors. rescue Exception => e # rubocop:disable Lint/RescueException error_msg = "Invalid Brewfile: #{e.message}" raise RuntimeError, error_msg, e.backtrace end end sig { void } def process instance_eval(@input, @path.to_s) end sig { params(args: T::Hash[Symbol, T.untyped]).void } def cask_args(args) @cask_arguments.merge!(args) end sig { params(name: String, options: Homebrew::Bundle::EntryOptions).void } def brew(name, options = {}) name = Homebrew::Bundle::Dsl.sanitize_brew_name(name) @entries << Entry.new(:brew, name, options) end sig { params(name: String, options: Homebrew::Bundle::EntryOptions).void } def cask(name, options = {}) options[:full_name] = name name = Homebrew::Bundle::Dsl.sanitize_cask_name(name) options[:args] = @cask_arguments.merge T.cast(options.fetch(:args, {}), T::Hash[Symbol, NestedEntryOptionValue]) @entries << Entry.new(:cask, name, options) end sig { params(name: String, clone_target: T.nilable(String), options: Homebrew::Bundle::EntryOptions).void } def tap(name, clone_target = nil, options = {}) options[:clone_target] = clone_target name = Homebrew::Bundle::Dsl.sanitize_tap_name(name) @entries << Entry.new(:tap, name, options) end HOMEBREW_TAP_ARGS_REGEX = %r{^([\w-]+)/(homebrew-)?([\w-]+)$} HOMEBREW_CORE_FORMULA_REGEX = %r{^homebrew/homebrew/([\w+-.@]+)$}i HOMEBREW_TAP_FORMULA_REGEX = %r{^([\w-]+)/([\w-]+)/([\w+-.@]+)$} sig { params(name: String).returns(String) } def self.sanitize_brew_name(name) name = name.downcase if name =~ HOMEBREW_CORE_FORMULA_REGEX sanitized_name = Regexp.last_match(1) raise "sanitized_name is nil" unless sanitized_name sanitized_name elsif name =~ HOMEBREW_TAP_FORMULA_REGEX user = Regexp.last_match(1) repo = Regexp.last_match(2) name = Regexp.last_match(3) raise "repo is nil" unless repo "#{user}/#{repo.sub("homebrew-", "")}/#{name}" else name end end sig { params(name: String).returns(String) } def self.sanitize_tap_name(name) name = name.downcase if name =~ HOMEBREW_TAP_ARGS_REGEX "#{Regexp.last_match(1)}/#{Regexp.last_match(3)}" else name end end sig { params(name: String).returns(String) } def self.sanitize_cask_name(name) Utils.name_from_full_name(name).downcase end sig { override.params(method_name: Symbol, args: T.untyped, options: T.untyped, block: T.nilable(T.proc.void)).returns(T.untyped) } def method_missing(method_name, *args, **options, &block) extension = Homebrew::Bundle.extension(method_name) return super if extension.nil? raise ArgumentError, "blocks are not supported for #{method_name}" if block # Extension DSL entries follow the existing Brewfile calling convention: # a required name plus an optional options hash, passed positionally, # with keywords, or both. unless (1..2).cover?(args.length) raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1..2)" end positional_options = {} if args.length == 2 positional_options = args[1] unless positional_options.is_a? Hash raise ArgumentError, "options(#{positional_options.inspect}) should be a Hash object" end end @entries << extension.entry(args.first, positional_options.merge(options)) end sig { override.params(method_name: T.any(String, Symbol), include_private: T::Boolean).returns(T::Boolean) } def respond_to_missing?(method_name, include_private = false) Homebrew::Bundle.extension(method_name).present? || super end end end end # Load extensions after `Dsl` is defined because their `entry` methods build # `Dsl::Entry` instances. require "bundle/extensions" Homebrew-brew-d7f73ce/Library/Homebrew/bundle/dumper.rb000066400000000000000000000056501517265720000232040ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "fileutils" require "bundle/dsl" require "bundle/package_types" module Homebrew module Bundle module Dumper sig { params(brewfile_path: Pathname, force: T::Boolean).returns(T::Boolean) } private_class_method def self.can_write_to_brewfile?(brewfile_path, force: false) raise "#{brewfile_path} already exists" if should_not_write_file?(brewfile_path, overwrite: force) true end sig { params( describe: T::Boolean, no_restart: T::Boolean, formulae: T::Boolean, taps: T::Boolean, casks: T::Boolean, extension_types: Homebrew::Bundle::ExtensionTypes, ).returns(String) } def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, extension_types: {}) selected_package_types = extension_types.dup selected_package_types[:tap] = taps selected_package_types[:brew] = formulae selected_package_types[:cask] = casks content = [] Homebrew::Bundle.dump_package_types.select(&:dump_supported?).each do |package_type| next unless selected_package_types.fetch(package_type.type, false) content << package_type.dump_output(describe:, no_restart:) end "#{content.reject(&:empty?).join("\n")}\n" end sig { params( global: T::Boolean, file: T.nilable(String), describe: T::Boolean, force: T::Boolean, no_restart: T::Boolean, formulae: T::Boolean, taps: T::Boolean, casks: T::Boolean, extension_types: Homebrew::Bundle::ExtensionTypes, ).void } def self.dump_brewfile(global:, file:, describe:, force:, no_restart:, formulae:, taps:, casks:, extension_types: {}) path = brewfile_path(global:, file:) can_write_to_brewfile?(path, force:) content = build_brewfile( describe:, no_restart:, taps:, formulae:, casks:, extension_types:, ) write_file path, content end sig { params(global: T::Boolean, file: T.nilable(String)).returns(Pathname) } def self.brewfile_path(global: false, file: nil) require "bundle/brewfile" Brewfile.path(dash_writes_to_stdout: true, global:, file:) end sig { params(file: Pathname, overwrite: T::Boolean).returns(T::Boolean) } private_class_method def self.should_not_write_file?(file, overwrite: false) file.exist? && !overwrite && file.to_s != "/dev/stdout" end sig { params(file: Pathname, content: String).void } def self.write_file(file, content) Bundle.exchange_uid_if_needed! do file.open("w") { |io| io.write content } end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions.rb000066400000000000000000000011721517265720000241020ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" extensions_dir = File.join(__dir__, "extensions") # Preserve the historical Brewfile section order for dumped extension entries. legacy_order = %w[mac_app_store vscode_extension go cargo uv flatpak].freeze extension_files = Dir.glob(File.join(extensions_dir, "*.rb")).sort_by do |file| basename = File.basename(file, ".rb") [legacy_order.index(basename) || legacy_order.length, basename] end extension_files.each do |file| basename = File.basename(file, ".rb") next if basename == "extension" require "bundle/extensions/#{basename}" end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/000077500000000000000000000000001517265720000235545ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/cargo.rb000066400000000000000000000063641517265720000252050ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" module Homebrew module Bundle class Cargo < Extension PACKAGE_TYPE = :cargo PACKAGE_TYPE_NAME = "Cargo Package" BANNER_NAME = "Cargo packages" class << self sig { override.void } def reset! @packages = T.let(nil, T.nilable(T::Array[String])) @installed_packages = T.let(nil, T.nilable(T::Array[String])) end sig { override.returns(T.nilable(String)) } def cleanup_heading banner_name end sig { override.returns(String) } def package_manager_name "rust" end sig { override.returns(T.nilable(Pathname)) } def package_manager_executable which("cargo", ORIGINAL_PATHS) end sig { override.returns(T::Array[String]) } def packages packages = @packages return packages if packages @packages = if (cargo = package_manager_executable) && (!cargo.to_s.start_with?("/") || cargo.exist?) with_env(cargo_env(cargo)) do parse_package_list(`#{cargo} install --list`) end end return [] if @packages.nil? @packages end sig { override.params( name: String, with: T.nilable(T::Array[String]), verbose: T::Boolean, ).returns(T::Boolean) } def install_package!(name, with: nil, verbose: false) _ = with cargo = package_manager_executable! with_env(cargo_env(cargo)) do Bundle.system(cargo.to_s, "install", "--locked", name, verbose:) end end sig { override.returns(T::Array[String]) } def installed_packages installed_packages = @installed_packages return installed_packages if installed_packages @installed_packages = packages.dup end sig { override.params(name: String, executable: Pathname).void } def uninstall_package!(name, executable: Pathname.new("")) Bundle.system(executable.to_s, "uninstall", name, verbose: false) end sig { override.params(executable: Pathname).returns(T::Hash[String, String]) } def package_manager_env(executable) cargo_env(executable) end sig { params(output: String).returns(T::Array[String]) } def parse_package_list(output) output.lines.filter_map do |line| next if line.match?(/^\s/) match = line.match(/\A(?[^\s:]+)\s+v[0-9A-Za-z.+-]+/) match[:name] if match end.uniq end private :parse_package_list sig { params(cargo: Pathname).returns(T::Hash[String, String]) } def cargo_env(cargo) { "CARGO_HOME" => ENV.fetch("HOMEBREW_CARGO_HOME", nil), "CARGO_INSTALL_ROOT" => ENV.fetch("HOMEBREW_CARGO_INSTALL_ROOT", nil), "PATH" => "#{cargo.dirname}:#{ENV.fetch("PATH")}", "RUSTUP_HOME" => ENV.fetch("HOMEBREW_RUSTUP_HOME", nil), }.compact end private :cargo_env end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/extension.rb000066400000000000000000000274761517265720000261350ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/package_type" module Homebrew module Bundle ExtensionTypes = T.type_alias { T::Hash[Symbol, T::Boolean] } class Extension < Homebrew::Bundle::PackageType extend T::Helpers abstract! sig { override.params(subclass: T.class_of(Homebrew::Bundle::PackageType)).void } def self.inherited(subclass) super Homebrew::Bundle.register_extension(T.cast(subclass, T.class_of(Homebrew::Bundle::Extension))) end sig { returns(Symbol) } def self.type T.cast(const_get(:PACKAGE_TYPE), Symbol) end sig { returns(String) } def self.check_label T.cast(const_get(:PACKAGE_TYPE_NAME), String) end sig { returns(String) } def self.banner_name T.cast(const_get(:BANNER_NAME), String) end sig { returns(String) } def self.switch_description if cleanup_supported? "`list`, `dump` or `cleanup` #{banner_name}." else "`list` or `dump` #{banner_name}." end end sig { params(name: String, options: Homebrew::Bundle::EntryInputOptions).returns(Dsl::Entry) } def self.entry(name, options = {}) raise "unknown options(#{options.keys.inspect}) for #{type}" if options.present? Dsl::Entry.new(type, name) end sig { returns(String) } def self.flag type.to_s.tr("_", "-") end sig { returns(Symbol) } def self.predicate_method :"#{type}?" end sig { returns(String) } def self.package_manager_name flag end sig { returns(T::Boolean) } def self.package_manager_installed? package_manager_executable.present? end sig { returns(T.nilable(Pathname)) } def self.package_manager_executable which(package_manager_name, ORIGINAL_PATHS) end sig { returns(Pathname) } def self.package_manager_executable! package_manager_executable || raise("#{package_manager_name} is not installed") end sig { params(executable: Pathname).returns(T::Hash[String, String]) } def self.package_manager_env(executable) { "PATH" => "#{executable.dirname}:#{ORIGINAL_PATHS.join(":")}" } end sig { type_parameters(:U) .params(_blk: T.proc.params(executable: Pathname).returns(T.type_parameter(:U))) .returns(T.type_parameter(:U)) } def self.with_package_manager_env(&_blk) executable = package_manager_executable! with_env(package_manager_env(executable)) { yield executable } end sig { returns(String) } def self.package_description check_label.downcase end sig { returns(T::Boolean) } def self.dump_supported? true end sig { returns(String) } def self.dump_disable_description "`dump` without #{banner_name}." end sig { returns(Symbol) } def self.dump_disable_env :"bundle_dump_no_#{type}" end sig { returns(T::Boolean) } def self.dump_disable_supported? true end sig { returns(Symbol) } def self.dump_disable_predicate_method :"no_#{type}?" end sig { returns(T::Boolean) } def self.add_supported? true end sig { returns(T::Boolean) } def self.remove_supported? true end sig { returns(T::Boolean) } def self.install_supported? true end sig { override.params(_name: String, _options: Homebrew::Bundle::EntryOptions).returns(String) } def self.install_verb(_name = "", _options = {}) "Installing" end sig { params( name: String, options: Homebrew::Bundle::EntryOptions, no_upgrade: T::Boolean, ).returns(T.nilable(String)) } def self.fetchable_name(name, options = {}, no_upgrade: false) _ = name _ = options _ = no_upgrade nil end sig { returns(T.nilable(String)) } def self.cleanup_heading nil end sig { returns(T::Boolean) } def self.cleanup_supported? !cleanup_heading.nil? end sig { abstract.void } def self.reset!; end sig { abstract.returns(T::Array[T.untyped]) } def self.packages; end sig { abstract.returns(T::Array[T.untyped]) } def self.installed_packages; end sig { params(package: Object).returns(String) } def self.dump_entry(package) line = "#{type} #{quote(dump_name(package))}" with = dump_with(package) return line if with.blank? formatted_with = with.map { |requirement| quote(requirement) }.join(", ") "#{line}, with: [#{formatted_with}]" end sig { params(value: String).returns(String) } def self.quote(value) value.inspect end sig { params(package: Object).returns(String) } def self.dump_name(package) package.to_s end sig { params(_package: Object).returns(T.nilable(T::Array[String])) } def self.dump_with(_package) nil end sig { override.returns(String) } def self.dump packages.map { |package| dump_entry(package) }.join("\n") end sig { params(describe: T::Boolean, no_restart: T::Boolean).returns(String) } def self.dump_output(describe: false, no_restart: false) _ = describe _ = no_restart dump end sig { params( entries: T::Array[Object], exit_on_first_error: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, ).returns(T::Array[Object]) } def self.check(entries, exit_on_first_error: false, no_upgrade: false, verbose: false) new.find_actionable(entries, exit_on_first_error:, no_upgrade:, verbose:) end sig { params(entries: T::Array[Dsl::Entry]).returns(T::Array[String]) } def self.cleanup_items(entries) return [].freeze unless package_manager_installed? kept_packages = entries.filter_map do |entry| entry.name if entry.type == type end return [].freeze if kept_packages.empty? installed_names = packages.map { |pkg| dump_name(pkg) } installed_names - kept_packages end sig { returns(Symbol) } def self.legacy_check_step :registered_extensions_to_install end sig { params(items: T::Array[String]).void } def self.cleanup!(items) executable = package_manager_executable return if executable.nil? with_env(package_manager_env(executable)) do items.each do |name| uninstall_package!(name, executable:) end end puts "Uninstalled #{items.size} #{banner_name}#{"s" if items.size != 1}" end sig { params(name: String, executable: Pathname).void } def self.uninstall_package!(name, executable: Pathname.new("")) raise NotImplementedError, "#{self} must override `uninstall_package!` or `cleanup!`." end sig { params(name: String, with: T.nilable(T::Array[String])).returns(Object) } def self.package_record(name, with: nil) _ = with name end sig { params(name: String, with: T.nilable(T::Array[String])).returns(T::Boolean) } def self.package_installed?(name, with: nil) installed_packages.include?(package_record(name, with:)) end sig { override.params( name: String, with: T.nilable(T::Array[String]), no_upgrade: T::Boolean, verbose: T::Boolean, _options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def self.preinstall!(name, with: nil, no_upgrade: false, verbose: false, **_options) _ = no_upgrade unless package_manager_installed? puts "Installing #{package_manager_name}. It is not currently installed." if verbose Bundle.system(HOMEBREW_BREW_FILE, "install", "--formula", package_manager_name, verbose:) # `formula_versions_from_env` consumes the env vars once at startup, so # keep the cached values across reset when bootstrapping a manager. formula_versions_from_env = T.let( Bundle.formula_versions_from_env_cache, T.nilable(T::Hash[String, String]), ) upgrade_formulae = Bundle.upgrade_formulae Bundle.reset! Bundle.formula_versions_from_env_cache = formula_versions_from_env Bundle.upgrade_formulae = upgrade_formulae.join(",") unless package_manager_installed? raise "Unable to install #{name} #{package_description}. " \ "#{package_manager_name} installation failed." end end if package_installed?(name, with:) puts "Skipping install of #{name} #{package_description}. It is already installed." if verbose return false end true end sig { override.params( name: String, with: T.nilable(T::Array[String]), preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, _options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def self.install!(name, with: nil, preinstall: true, no_upgrade: false, verbose: false, force: false, **_options) _ = no_upgrade _ = force return true unless preinstall puts "Installing #{name} #{package_description}. It is not currently installed." if verbose return false unless install_package!(name, with:, verbose:) package = package_record(name, with:) installed_packages << package unless installed_packages.include?(package) packages << package unless packages.include?(package) true end sig { override.params(package: Object, no_upgrade: T::Boolean).returns(String) } def failure_reason(package, no_upgrade:) "#{self.class.check_label} #{self.class.dump_name(package)} needs to be installed." end sig { override.params(package: Object, no_upgrade: T::Boolean).returns(T::Boolean) } def installed_and_up_to_date?(package, no_upgrade: false) self.class.package_installed?(self.class.dump_name(package), with: self.class.dump_with(package)) end sig { overridable.params( name: String, with: T.nilable(T::Array[String]), verbose: T::Boolean, ).returns(T::Boolean) } def self.install_package!(name, with: nil, verbose: false) _ = name _ = with _ = verbose raise NotImplementedError, "#{self} must override `install_package!` or `install!`." end end class << self sig { params(extension: T.class_of(Extension)).void } def register_extension(extension) @extensions ||= T.let([], T.nilable(T::Array[T.class_of(Extension)])) @extensions.reject! { |registered| registered.name == extension.name } @extensions << extension end sig { returns(T::Array[T.class_of(Extension)]) } def extensions @extensions ||= T.let([], T.nilable(T::Array[T.class_of(Extension)])) @extensions end sig { params(type: T.any(Symbol, String)).returns(T.nilable(T.class_of(Extension))) } def extension(type) requested_type = type.to_sym extensions.find { |registered| registered.type == requested_type } end sig { params( type: T.any(Symbol, String), ).returns(T.nilable(T.class_of(PackageType))) } def installable(type) package_type(type) || extension(type) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/flatpak.rb000066400000000000000000000413131517265720000255250ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" module Homebrew module Bundle class Flatpak < Extension Package = T.type_alias { { name: String, remote: String, remote_url: T.nilable(String) } } PACKAGE_TYPE = :flatpak PACKAGE_TYPE_NAME = "Flatpak" BANNER_NAME = "Flatpak packages" class << self sig { override.returns(String) } def switch_description "#{super} Note: Linux only." end sig { override.returns(T.nilable(String)) } def cleanup_heading "flatpaks" end sig { override.params(name: String, options: Homebrew::Bundle::EntryInputOptions).returns(Dsl::Entry) } def entry(name, options = {}) unknown_options = options.keys - [:remote, :url] raise "unknown options(#{unknown_options.inspect}) for flatpak" if unknown_options.present? remote = options[:remote] url = options[:url] if !remote.nil? && !remote.is_a?(String) raise "options[:remote](#{remote.inspect}) should be a String object" end raise "options[:url](#{url.inspect}) should be a String object" if !url.nil? && !url.is_a?(String) # Validate: url: can only be used with a named remote (not a URL remote) if url && remote&.start_with?("http://", "https://") raise "url: parameter cannot be used when remote: is already a URL" end normalized_options = {} normalized_options[:remote] = remote || "flathub" normalized_options[:url] = url if url Dsl::Entry.new(type, name, normalized_options) end sig { override.void } def reset! @packages = T.let(nil, T.nilable(T::Array[String])) @packages_with_remotes = T.let(nil, T.nilable(T::Array[Package])) @remote_urls = T.let(nil, T.nilable(T::Hash[String, String])) @installed_packages = T.let(nil, T.nilable(T::Array[Package])) end sig { returns(T::Hash[String, String]) } def remote_urls remote_urls = @remote_urls return remote_urls if remote_urls @remote_urls = if (flatpak = package_manager_executable) output = `#{flatpak} remote-list --system --columns=name,url 2>/dev/null`.chomp urls = {} output.split("\n").each do |line| parts = line.strip.split("\t") next if parts.size < 2 name = parts[0] url = parts[1] urls[name] = url if name && url end urls end return {} if @remote_urls.nil? @remote_urls end sig { returns(T::Array[Package]) } def packages_with_remotes packages_with_remotes = @packages_with_remotes return packages_with_remotes if packages_with_remotes @packages_with_remotes = if (flatpak = package_manager_executable) # List applications with their origin remote # Using --app to filter applications only # Using --columns=application,origin to get app IDs and their remotes output = `#{flatpak} list --app --columns=application,origin 2>/dev/null`.chomp packages = output.split("\n").filter_map do |line| parts = line.strip.split("\t") name = parts[0] next if parts.empty? || name.nil? || name.empty? remote = parts[1] || "flathub" package = T.let({ name:, remote:, remote_url: T.let(nil, T.nilable(String)) }, Package) remote_url = remote_urls[remote] package[:remote_url] = remote_url package end packages.sort_by { |pkg| pkg[:name].to_s } end return [] if @packages_with_remotes.nil? @packages_with_remotes end sig { override.returns(T::Array[String]) } def packages packages = @packages return packages if packages @packages = packages_with_remotes.map { |pkg| pkg[:name] } end sig { override.returns(T::Array[Package]) } def installed_packages installed_packages = @installed_packages return installed_packages if installed_packages @installed_packages = packages_with_remotes.dup end sig { override.params(package: Object).returns(String) } def dump_entry(package) package = T.cast(package, Package) remote = package[:remote] remote_url = package[:remote_url] name = package[:name] if remote == "flathub" # Tier 1: Don't specify remote for flathub (default) "flatpak #{quote(name)}" elsif remote&.end_with?("-origin") # Tier 2: Single-app remote - dump with URL only if remote_url.present? "flatpak #{quote(name)}, remote: #{quote(remote_url)}" else # Fallback if URL not available (shouldn't happen for -origin remotes) "flatpak #{quote(name)}, remote: #{quote(remote)}" end elsif remote_url.present? # Tier 3: Named shared remote - dump with name and URL "flatpak #{quote(name)}, remote: #{quote(remote)}, url: #{quote(remote_url)}" else # Named remote without URL (user-defined or system remote) "flatpak #{quote(name)}, remote: #{quote(remote)}" end end sig { override.returns(String) } def dump packages_with_remotes.map { |package| dump_entry(package) }.join("\n") end sig { override.params( name: String, with: T.nilable(T::Array[String]), no_upgrade: T::Boolean, verbose: T::Boolean, remote: String, url: T.nilable(String), _options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def preinstall!(name, with: nil, no_upgrade: false, verbose: false, remote: "flathub", url: nil, **_options) _ = with _ = no_upgrade _ = url return false unless package_manager_installed? # Check if package is installed at all (regardless of remote) if package_installed?(name) puts "Skipping install of #{name} Flatpak. It is already installed." if verbose return false end true end sig { override.params( name: String, with: T.nilable(T::Array[String]), preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, remote: String, url: T.nilable(String), _options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def install!(name, with: nil, preinstall: true, no_upgrade: false, verbose: false, force: false, remote: "flathub", url: nil, **_options) _ = with _ = no_upgrade _ = force return true unless package_manager_installed? return true unless preinstall flatpak = package_manager_executable!.to_s # 3-tier remote handling: # - Tier 1: no URL → use named remote (default: flathub) # - Tier 2: URL only → single-app remote (-origin) # - Tier 3: URL + name → named shared remote if url.present? # Tier 3: Named remote with URL - create shared remote puts "Installing #{name} Flatpak from #{remote} (#{url}). It is not currently installed." if verbose ensure_named_remote_exists!(flatpak, remote, url, verbose:) actual_remote = remote elsif remote.start_with?("http://", "https://") if remote.end_with?(".flatpakref") # .flatpakref files - install directly (Flatpak handles single-app remote natively) puts "Installing #{name} Flatpak from #{remote}. It is not currently installed." if verbose return install_flatpakref!(flatpak, name, remote, verbose:) else # Tier 2: URL only - create single-app remote actual_remote = generate_single_app_remote_name(name) if verbose puts "Installing #{name} Flatpak from #{actual_remote} (#{remote}). It is not currently installed." end ensure_single_app_remote_exists!(flatpak, actual_remote, remote, verbose:) end else # Tier 1: Named remote (default: flathub) puts "Installing #{name} Flatpak from #{remote}. It is not currently installed." if verbose actual_remote = remote end # Install from the remote return false unless Bundle.system(flatpak, "install", "-y", "--system", actual_remote, name, verbose:) package = { name:, remote: actual_remote, remote_url: url } packages_with_remotes = T.let(@packages_with_remotes || [], T::Array[Package]) packages_with_remotes << package @packages_with_remotes = packages_with_remotes @installed_packages = packages_with_remotes.dup @packages = packages_with_remotes.map { |pkg| pkg[:name] } true end # Install from a .flatpakref file (Tier 2 variant - Flatpak handles single-app remote natively) sig { params(flatpak: String, name: String, url: String, verbose: T::Boolean).returns(T::Boolean) } def install_flatpakref!(flatpak, name, url, verbose:) return false unless Bundle.system(flatpak, "install", "-y", "--system", url, verbose:) # Get the actual remote name used by Flatpak output = `#{flatpak} list --app --columns=application,origin 2>/dev/null`.chomp installed = output.split("\n").find { |line| line.start_with?(name) } actual_remote = installed ? installed.split("\t")[1] : "#{name}-origin" actual_remote ||= "#{name}-origin" package = { name:, remote: actual_remote, remote_url: nil } packages_with_remotes = T.let(@packages_with_remotes || [], T::Array[Package]) packages_with_remotes << package @packages_with_remotes = packages_with_remotes @installed_packages = packages_with_remotes.dup @packages = packages_with_remotes.map { |pkg| pkg[:name] } true end # Generate a single-app remote name (Tier 2) # Pattern: -origin (matches Flatpak's native behavior for .flatpakref) sig { params(app_id: String).returns(String) } def generate_single_app_remote_name(app_id) "#{app_id}-origin" end # Ensure a single-app remote exists (Tier 2) # Safe to replace if URL differs since it's isolated per-app sig { params(flatpak: String, remote_name: String, url: String, verbose: T::Boolean).void } def ensure_single_app_remote_exists!(flatpak, remote_name, url, verbose:) existing_url = get_remote_url(flatpak, remote_name) if existing_url && existing_url != url # Single-app remote with different URL - safe to replace puts "Replacing single-app remote #{remote_name} (URL changed)" if verbose Bundle.system(flatpak, "remote-delete", "--system", "--force", remote_name, verbose:) existing_url = nil end return if existing_url puts "Adding single-app remote #{remote_name} from #{url}" if verbose add_remote!(flatpak, remote_name, url, verbose:) end # Ensure a named shared remote exists (Tier 3) # Warn but don't change if URL differs (user explicitly named it) sig { params(flatpak: String, remote_name: String, url: String, verbose: T::Boolean).void } def ensure_named_remote_exists!(flatpak, remote_name, url, verbose:) existing_url = get_remote_url(flatpak, remote_name) if existing_url && existing_url != url # Named remote with different URL - warn but don't change (user explicitly named it) puts "Warning: Remote '#{remote_name}' exists with different URL (#{existing_url}), using existing" return end return if existing_url puts "Adding named remote #{remote_name} from #{url}" if verbose add_remote!(flatpak, remote_name, url, verbose:) end # Get URL for an existing remote, or nil if not found sig { params(flatpak: String, remote_name: String).returns(T.nilable(String)) } def get_remote_url(flatpak, remote_name) output = `#{flatpak} remote-list --system --columns=name,url 2>/dev/null`.chomp output.split("\n").each do |line| parts = line.split("\t") return parts[1] if parts[0] == remote_name end nil end # Add a remote with appropriate flags sig { params(flatpak: String, remote_name: String, url: String, verbose: T::Boolean).returns(T::Boolean) } def add_remote!(flatpak, remote_name, url, verbose:) if url.end_with?(".flatpakrepo") Bundle.system(flatpak, "remote-add", "--if-not-exists", "--system", remote_name, url, verbose:) else # For bare repository URLs, add with --no-gpg-verify for user repos Bundle.system( flatpak, "remote-add", "--if-not-exists", "--system", "--no-gpg-verify", remote_name, url, verbose: ) end end sig { override.params( name: String, with: T.nilable(T::Array[String]), remote: T.nilable(String), ).returns(T::Boolean) } def package_installed?(name, with: nil, remote: nil) _ = with if remote installed_packages.any? { |pkg| pkg[:name] == name && pkg[:remote] == remote } else installed_packages.any? { |pkg| pkg[:name] == name } end end sig { params(entries: T::Array[Object]).returns(T::Array[String]) } def cleanup_items(entries) return [].freeze unless package_manager_installed? kept_flatpaks = entries.filter_map do |entry| entry = T.cast(entry, Dsl::Entry) entry.name if entry.type == type end return [].freeze if kept_flatpaks.empty? packages - kept_flatpaks end sig { params(flatpaks: T::Array[String]).void } def cleanup!(flatpaks) flatpaks.each do |flatpak_name| Kernel.system("flatpak", "uninstall", "-y", "--system", flatpak_name) end puts "Uninstalled #{flatpaks.size} flatpak#{"s" if flatpaks.size != 1}" end end sig { override.params(entries: T::Array[Object]).returns(T::Array[Object]) } def format_checkable(entries) checkable_entries(entries).map do |entry| entry = T.cast(entry, Dsl::Entry) { name: entry.name, options: entry.options } end end sig { override.params(package: Object, no_upgrade: T::Boolean).returns(String) } def failure_reason(package, no_upgrade:) _ = no_upgrade name = if package.is_a?(Hash) package[:name] else package end "#{self.class.check_label} #{name} needs to be installed." end sig { override.params(package: Object, no_upgrade: T::Boolean).returns(T::Boolean) } def installed_and_up_to_date?(package, no_upgrade: false) _ = no_upgrade return self.class.package_installed?(T.cast(package, String)) unless package.is_a?(Hash) flatpak = package name = T.cast(flatpak[:name], String) options = T.cast(flatpak[:options], T::Hash[Symbol, String]) remote = options.fetch(:remote, "flathub") url = options[:url] # 3-tier remote handling: # - Tier 1: Named remote → check with that remote name # - Tier 2: URL only → resolve to single-app remote name (-origin) # - Tier 3: URL + name → check with the named remote actual_remote = if url.blank? && remote.start_with?("http://", "https://") # Tier 2: URL only - resolve to single-app remote name # (.flatpakref - check by name only since remote name varies) return self.class.package_installed?(name) if remote.end_with?(".flatpakref") self.class.generate_single_app_remote_name(name) else # Tier 1 (named remote) and Tier 3 (named remote with URL) both use the remote name remote end self.class.package_installed?(name, remote: actual_remote) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/go.rb000066400000000000000000000077531517265720000245220ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" module Homebrew module Bundle class Go < Extension PACKAGE_TYPE = :go PACKAGE_TYPE_NAME = "Go Package" BANNER_NAME = "Go packages" class << self sig { override.void } def reset! @packages = T.let(nil, T.nilable(T::Array[String])) @installed_packages = T.let(nil, T.nilable(T::Array[String])) end sig { override.returns(T.nilable(String)) } def cleanup_heading banner_name end sig { override.returns(T::Array[String]) } def packages packages = @packages return packages if packages @packages = if (go = package_manager_executable) ENV["GOBIN"] = ENV.fetch("HOMEBREW_GOBIN", nil) ENV["GOPATH"] = ENV.fetch("HOMEBREW_GOPATH", nil) gobin = `#{go} env GOBIN`.chomp gopath = `#{go} env GOPATH`.chomp bin_dir = gobin.empty? ? "#{gopath}/bin" : gobin if File.directory?(bin_dir) binaries = Dir.glob("#{bin_dir}/*").select do |file| File.executable?(file) && !File.directory?(file) && !File.symlink?(file) end binaries.filter_map do |binary| output = `#{go} version -m "#{binary}" 2>/dev/null` next if output.empty? lines = output.split("\n") path_line = lines.find { |line| line.strip.start_with?("path\t") } next unless path_line # Parse the output to find the path line # Format: "\tpath\tgithub.com/user/repo" parts = path_line.split("\t") # Extract the package path (second field after splitting by tab) # The line format is: "\tpath\tgithub.com/user/repo" path = parts[2]&.strip # `command-line-arguments` is a dummy package name for binaries built # from a list of source files instead of a specific package name. # https://github.com/golang/go/issues/36043 next if path == "command-line-arguments" path end.uniq end end return [] if @packages.nil? @packages end sig { override.params( name: String, with: T.nilable(T::Array[String]), verbose: T::Boolean, ).returns(T::Boolean) } def install_package!(name, with: nil, verbose: false) _ = with go = package_manager_executable! Bundle.system(go.to_s, "install", "#{name}@latest", verbose:) end sig { override.returns(T::Array[String]) } def installed_packages installed_packages = @installed_packages return installed_packages if installed_packages @installed_packages = packages.dup end sig { override.params(items: T::Array[String]).void } def cleanup!(items) go = package_manager_executable return if go.nil? gobin = `#{go} env GOBIN`.chomp gopath = `#{go} env GOPATH`.chomp bin_dir = gobin.empty? ? "#{gopath}/bin" : gobin return unless File.directory?(bin_dir) removed = 0 Dir.glob("#{bin_dir}/*").each do |binary| next if !File.executable?(binary) || File.directory?(binary) || File.symlink?(binary) output = `#{go} version -m "#{binary}" 2>/dev/null` next if output.empty? path_line = output.split("\n").find { |line| line.strip.start_with?("path\t") } next unless path_line module_path = path_line.split("\t")[2]&.strip next unless items.include?(module_path) FileUtils.rm_f(binary) removed += 1 end puts "Uninstalled #{removed} #{banner_name}#{"s" if removed != 1}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/krew.rb000066400000000000000000000053251517265720000250560ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" module Homebrew module Bundle class Krew < Extension PACKAGE_TYPE = :krew PACKAGE_TYPE_NAME = "Krew Plugin" BANNER_NAME = "Krew plugins" class << self sig { override.void } def reset! @packages = T.let(nil, T.nilable(T::Array[String])) @installed_packages = T.let(nil, T.nilable(T::Array[String])) @package_manager_executable = T.let(nil, T.nilable(Pathname)) @krew_installed = T.let(nil, T.nilable(T::Boolean)) end sig { override.returns(T.nilable(Pathname)) } def package_manager_executable @package_manager_executable ||= T.let(which("kubectl", ORIGINAL_PATHS), T.nilable(Pathname)) end sig { override.returns(T::Boolean) } def package_manager_installed? return @krew_installed unless @krew_installed.nil? kubectl = package_manager_executable result = if kubectl.present? Kernel.system(package_manager_env(kubectl), kubectl.to_s, "krew", "version", out: File::NULL, err: File::NULL) == true else false end @krew_installed = T.let(result, T.nilable(T::Boolean)) result end sig { override.returns(T::Array[String]) } def packages packages = @packages return packages if packages @packages = if package_manager_installed? with_package_manager_env do |kubectl| parse_plugin_list(`#{kubectl} krew list 2>/dev/null`) end else [] end end sig { override.params( name: String, with: T.nilable(T::Array[String]), verbose: T::Boolean, ).returns(T::Boolean) } def install_package!(name, with: nil, verbose: false) _ = with with_package_manager_env do |kubectl| Bundle.system(kubectl.to_s, "krew", "install", name, verbose:) end end sig { override.returns(T::Array[String]) } def installed_packages installed_packages = @installed_packages return installed_packages if installed_packages @installed_packages = packages.dup end sig { params(output: String).returns(T::Array[String]) } def parse_plugin_list(output) output.lines.filter_map do |line| line = line.strip next if line.empty? name = line.split(/\s+/).first name.presence end.uniq end private :parse_plugin_list end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/mac_app_store.rb000066400000000000000000000204611517265720000267200ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" module Homebrew module Bundle class MacAppStore < Extension class App < T::Struct const :id, String const :name, String end CheckablePackages = T.type_alias { T.any(T::Array[Object], T::Hash[Integer, String]) } PACKAGE_TYPE = :mas PACKAGE_TYPE_NAME = "App" BANNER_NAME = "Mac App Store dependencies" class << self sig { override.returns(Symbol) } def legacy_check_step :apps_to_install end sig { override.returns(T::Boolean) } def add_supported? false end sig { override.returns(T::Boolean) } def dump_disable_supported? false end sig { override.params(name: String, options: Homebrew::Bundle::EntryInputOptions).returns(Dsl::Entry) } def entry(name, options = {}) id = options[:id] raise "options[:id](#{id}) should be an Integer object" unless id.is_a? Integer Dsl::Entry.new(type, name, id:) end sig { override.void } def reset! @apps = T.let(nil, T.nilable(T::Array[[String, String]])) @packages = T.let(nil, T.nilable(T::Array[App])) @installed_app_ids = T.let(nil, T.nilable(T::Array[String])) @outdated_app_ids = T.let(nil, T.nilable(T::Array[String])) end sig { returns(T::Array[[String, String]]) } def apps apps = @apps return apps if apps @apps = if (mas = package_manager_executable) `#{mas} list 2>/dev/null`.split("\n").filter_map do |app| app_details = app.match(/\A\s*(?\d+)\s+(?.*?)\s+\((?[\d.]*)\)\Z/) next if app_details.nil? id = app_details[:id] name = app_details[:name] next if id.nil? || name.nil? # Only add the application details should we have a valid match. # Strip unprintable characters [id, name.gsub(/[[:cntrl:]]|\p{C}/, "")] end end return [] if @apps.nil? @apps end sig { returns(T::Array[String]) } def app_ids apps.map(&:first) end sig { override.returns(T::Array[App]) } def packages packages = @packages return packages if packages @packages = apps.sort_by { |_, name| name.downcase }.map { |id, name| App.new(id:, name:) } end sig { override.returns(T::Array[App]) } def installed_packages packages end sig { returns(T::Array[String]) } def installed_app_ids installed_app_ids = @installed_app_ids return installed_app_ids if installed_app_ids @installed_app_ids = app_ids end sig { override.params(package: Object).returns(String) } def dump_entry(package) app = T.cast(package, App) "mas #{quote(app.name)}, id: #{app.id}" end sig { params(id: Integer).returns(T::Boolean) } def app_id_installed?(id) installed_app_ids.any? { |app_id| app_id.to_i == id } end sig { params(id: Integer).returns(T::Boolean) } def app_id_upgradable?(id) outdated_app_ids.any? { |app_id| app_id.to_i == id } end sig { params(id: Integer, no_upgrade: T::Boolean).returns(T::Boolean) } def app_id_installed_and_up_to_date?(id, no_upgrade: false) return false unless app_id_installed?(id) return true if no_upgrade !app_id_upgradable?(id) end sig { returns(T::Array[String]) } def outdated_app_ids outdated_app_ids = @outdated_app_ids return outdated_app_ids if outdated_app_ids @outdated_app_ids = if (mas = package_manager_executable) `#{mas} outdated 2>/dev/null`.split("\n").map do |app| app.split(" ", 2).first.to_s end end return [] if @outdated_app_ids.nil? @outdated_app_ids end sig { override.params( name: String, id: T.nilable(Integer), with: T.nilable(T::Array[String]), no_upgrade: T::Boolean, verbose: T::Boolean, options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def preinstall!(name, id = nil, with: nil, no_upgrade: false, verbose: false, **options) _ = with id ||= T.cast(options[:id], T.nilable(Integer)) raise ArgumentError, "missing keyword: id" if id.nil? unless package_manager_installed? puts "Installing mas. It is not currently installed." if verbose Bundle.system(HOMEBREW_BREW_FILE, "install", "mas", verbose:) raise "Unable to install #{name} app. mas installation failed." unless package_manager_installed? end if app_id_installed?(id) && (no_upgrade || !app_id_upgradable?(id)) puts "Skipping install of #{name} app. It is already installed." if verbose return false end true end sig { override.params( name: String, id: T.nilable(Integer), with: T.nilable(T::Array[String]), preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def install!(name, id = nil, with: nil, preinstall: true, no_upgrade: false, verbose: false, force: false, **options) _ = with id ||= T.cast(options[:id], T.nilable(Integer)) raise ArgumentError, "missing keyword: id" if id.nil? _ = no_upgrade _ = force return true unless preinstall mas = package_manager_executable! if app_id_installed?(id) puts "Upgrading #{name} app. It is installed but not up-to-date." if verbose return false unless Bundle.system(mas, "upgrade", id.to_s, verbose:) return true end puts "Installing #{name} app. It is not currently installed." if verbose return false unless Bundle.system(mas, "get", id.to_s, verbose:) apps << [id.to_s, name] unless apps.any? { |app_id, _app_name| app_id.to_i == id } packages << App.new(id: id.to_s, name:) unless packages.any? { |app| app.id.to_i == id } installed_app_ids << id.to_s unless installed_app_ids.include?(id.to_s) true end end sig { override.params(entries: T::Array[Object]).returns(T::Array[Object]) } def format_checkable(entries) checkable_entries(entries).map do |entry| entry = T.cast(entry, Dsl::Entry) [T.cast(entry.options.fetch(:id), Integer), entry.name] end end sig { override.params(packages: CheckablePackages, no_upgrade: T::Boolean).returns(T::Array[Object]) } def exit_early_check(packages, no_upgrade:) work_to_be_done = (packages.is_a?(Hash) ? packages.to_a : packages).find do |id, _name| !installed_and_up_to_date?(id, no_upgrade:) end Array(work_to_be_done) end sig { override.params(packages: CheckablePackages, no_upgrade: T::Boolean).returns(T::Array[String]) } def full_check(packages, no_upgrade:) (packages.is_a?(Hash) ? packages.to_a : packages) .reject { |id, _name| installed_and_up_to_date?(id, no_upgrade:) } .map { |_id, name| failure_reason(name, no_upgrade:) } end sig { override.params(package: Object, no_upgrade: T::Boolean).returns(String) } def failure_reason(package, no_upgrade:) reason = no_upgrade ? "needs to be installed." : "needs to be installed or updated." "#{self.class.check_label} #{package} #{reason}" end sig { override.params(package: Object, no_upgrade: T::Boolean).returns(T::Boolean) } def installed_and_up_to_date?(package, no_upgrade: false) self.class.app_id_installed_and_up_to_date?(T.cast(package, Integer), no_upgrade:) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/npm.rb000066400000000000000000000047661517265720000247100ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" module Homebrew module Bundle class Npm < Extension PACKAGE_TYPE = :npm PACKAGE_TYPE_NAME = "npm Package" BANNER_NAME = "npm packages" class << self sig { override.void } def reset! @packages = T.let(nil, T.nilable(T::Array[String])) @installed_packages = T.let(nil, T.nilable(T::Array[String])) end sig { override.returns(T.nilable(String)) } def cleanup_heading banner_name end sig { override.returns(String) } def package_manager_name "node" end sig { override.returns(T.nilable(Pathname)) } def package_manager_executable which("npm", ORIGINAL_PATHS) end sig { override.returns(T::Array[String]) } def packages packages = @packages return packages if packages @packages = if (npm = package_manager_executable) && (!npm.to_s.start_with?("/") || npm.exist?) parse_package_list(`#{npm} list -g --depth=0 --json 2>/dev/null`) end return [] if @packages.nil? @packages end sig { override.params( name: String, with: T.nilable(T::Array[String]), verbose: T::Boolean, ).returns(T::Boolean) } def install_package!(name, with: nil, verbose: false) _ = with npm = package_manager_executable! Bundle.system(npm.to_s, "install", "-g", name, verbose:) end sig { override.returns(T::Array[String]) } def installed_packages installed_packages = @installed_packages return installed_packages if installed_packages @installed_packages = packages.dup end sig { override.params(name: String, executable: Pathname).void } def uninstall_package!(name, executable: Pathname.new("")) Bundle.system(executable.to_s, "uninstall", "-g", name, verbose: false) end sig { params(output: String).returns(T::Array[String]) } def parse_package_list(output) return [] if output.blank? json = JSON.parse(output) deps = json.fetch("dependencies", {}) deps.keys.reject { |name| name == "npm" } rescue JSON::ParserError [] end private :parse_package_list end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/uv.rb000066400000000000000000000173371517265720000245460ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" module Homebrew module Bundle class Uv < Extension WithOptions = T.type_alias { T::Hash[Symbol, T::Array[String]] } Tool = T.type_alias { { name: String, with: T::Array[String] } } Checkable = T.type_alias { { name: String, options: WithOptions } } ToolEntry = T.type_alias { T.any(Tool, Checkable) } PACKAGE_TYPE = :uv PACKAGE_TYPE_NAME = "uv Tool" BANNER_NAME = "uv tools" class << self sig { override.params(name: String, options: Homebrew::Bundle::EntryInputOptions).returns(Dsl::Entry) } def entry(name, options = {}) unknown_options = options.keys - [:with] raise "unknown options(#{unknown_options.inspect}) for uv" if unknown_options.present? with = options[:with] if !with.nil? && (!with.is_a?(Array) || with.any? { |requirement| !requirement.is_a?(String) }) raise "options[:with](#{with.inspect}) should be an Array of String objects" end normalized_options = {} normalized_with = normalize_with(with || []) normalized_options[:with] = normalized_with if normalized_with.present? Dsl::Entry.new(:uv, name, normalized_options) end sig { override.void } def reset! @packages = T.let(nil, T.nilable(T::Array[Tool])) @installed_packages = T.let(nil, T.nilable(T::Array[Tool])) end sig { override.returns(T.nilable(String)) } def cleanup_heading banner_name end sig { override.returns(T::Array[Tool]) } def packages packages = @packages return packages if packages @packages = if (uv = package_manager_executable) output = `#{uv} tool list --show-with --show-extras 2>/dev/null` parse_tool_list(output) end return [] if @packages.nil? @packages end sig { override.params(package: Object).returns(String) } def dump_name(package) package_name(T.cast(package, ToolEntry)) end sig { override.params(package: Object).returns(T.nilable(T::Array[String])) } def dump_with(package) package_with(T.cast(package, ToolEntry)) end sig { override.params( name: String, with: T.nilable(T::Array[String]), verbose: T::Boolean, ).returns(T::Boolean) } def install_package!(name, with: nil, verbose: false) uv = package_manager_executable! args = ["tool", "install", name] normalize_with(with || []).each do |requirement| args << "--with" args << requirement end Bundle.system(uv.to_s, *args, verbose:) end sig { override.returns(T::Array[Tool]) } def installed_packages installed_packages = @installed_packages return installed_packages if installed_packages @installed_packages = packages.dup end sig { params(output: String).returns(T::Array[Tool]) } def parse_tool_list(output) entries = T.let([], T::Array[Tool]) output.each_line do |line| match = line.match(/\A(\S+)\s+v\S+/) next unless match name = match[1] next if name.nil? extras_raw = line[/\[extras:\s*([^\]]+)\]/, 1] name = name_with_extras(name, extras_raw) with_raw = line[/\[with:\s*([^\]]+)\]/, 1] entries << { name: name, with: parse_with_requirements(with_raw), } end entries.sort_by { |entry| entry[:name].to_s } end private :parse_tool_list sig { params(name: String, extras_raw: T.nilable(String)).returns(String) } def name_with_extras(name, extras_raw) return name if extras_raw.blank? extras = extras_raw.split(",").map(&:strip).reject(&:empty?).uniq.sort return name if extras.empty? "#{name}[#{extras.join(",")}]" end private :name_with_extras sig { params(with_raw: T.nilable(String)).returns(T::Array[String]) } def parse_with_requirements(with_raw) return [] if with_raw.blank? entries = T.let([], T::Array[String]) with_raw.split(", ").each do |token| requirement = token.strip next if requirement.empty? if continuation_constraint?(requirement) && entries.any? last_requirement = entries.pop entries << "#{last_requirement}, #{normalize_constraint(requirement)}" if last_requirement else entries << requirement end end entries.uniq.sort end private :parse_with_requirements sig { params(requirement: String).returns(T::Boolean) } def continuation_constraint?(requirement) requirement.match?(/\A(?:<=|>=|!=|==|~=|<|>)\s*\S/) end private :continuation_constraint? sig { params(requirement: String).returns(String) } def normalize_constraint(requirement) requirement.strip.sub(/\A(<=|>=|!=|==|~=|<|>)\s+/, "\\1") end private :normalize_constraint sig { params(with: T::Array[String]).returns(T::Array[String]) } def normalize_with(with) with.map(&:strip).reject(&:empty?).uniq.sort end private :normalize_with sig { params(name: String).returns(String) } def normalize_name(name) match = name.strip.match(/\A(?[^\[\]]+)(?:\[(?[^\]]+)\])?\z/) return name.strip unless match base = match[:base] return name.strip if base.nil? extras_raw = match[:extras] return base.strip if extras_raw.blank? extras = extras_raw.split(",").map(&:strip).reject(&:empty?).uniq.sort return base.strip if extras.empty? "#{base.strip}[#{extras.join(",")}]" end private :normalize_name sig { override.params(name: String, with: T.nilable(T::Array[String])).returns(Object) } def package_record(name, with: nil) normalized_options(name, with: with || []) end sig { params(name: String, with: T::Array[String]).returns(Tool) } def normalized_options(name, with:) { name: normalize_name(name), with: normalize_with(with), } end private :normalized_options sig { params(package: ToolEntry).returns(String) } def package_name(package) package[:name] end private :package_name sig { params(package: ToolEntry).returns(T.nilable(T::Array[String])) } def package_with(package) if package.key?(:with) package[:with] else package[:options].fetch(:with, []) end end private :package_with sig { override.params(name: String, executable: Pathname).void } def uninstall_package!(name, executable: Pathname.new("")) Bundle.system(executable.to_s, "tool", "uninstall", name, verbose: false) end end sig { override.params(entries: T::Array[Object]).returns(T::Array[Object]) } def format_checkable(entries) checkable_entries(entries).map do |entry| entry = T.cast(entry, Dsl::Entry) with = if entry.options.is_a?(Hash) value = entry.options[:with] value.is_a?(Array) ? value : [] else [] end self.class.package_record(entry.name, with:) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/extensions/vscode_extension.rb000066400000000000000000000132531517265720000274640ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/extensions/extension" module Homebrew module Bundle class VscodeExtension < Extension PACKAGE_TYPE = :vscode PACKAGE_TYPE_NAME = "VSCode Extension" BANNER_NAME = "VSCode (and forks/variants) extensions" class << self sig { override.void } def reset! @extensions = T.let(nil, T.nilable(T::Array[String])) @installed_extensions = T.let(nil, T.nilable(T::Array[String])) end sig { override.returns(T.nilable(String)) } def cleanup_heading "VSCode extensions" end sig { override.params(name: String, with: T.nilable(T::Array[String])).returns(Object) } def package_record(name, with: nil) _ = with name.downcase end sig { override.returns(T.nilable(Pathname)) } def package_manager_executable which("code", ORIGINAL_PATHS) || which("codium", ORIGINAL_PATHS) || which("cursor", ORIGINAL_PATHS) || which("code-insiders", ORIGINAL_PATHS) end sig { returns(T::Array[String]) } def extensions extensions = @extensions return extensions if extensions @extensions = if (vscode = package_manager_executable) Bundle.exchange_uid_if_needed! do ENV["WSL_DISTRO_NAME"] = ENV.fetch("HOMEBREW_WSL_DISTRO_NAME", nil) `"#{vscode}" --list-extensions 2>/dev/null` end.split("\n").map(&:downcase) end return [] if @extensions.nil? @extensions end sig { override.returns(T::Array[String]) } def packages extensions end sig { override.returns(T::Array[String]) } def installed_packages installed_extensions end sig { returns(T::Array[String]) } def installed_extensions installed_extensions = @installed_extensions return installed_extensions if installed_extensions @installed_extensions = extensions.dup end sig { override.params(name: String, with: T.nilable(T::Array[String])).returns(T::Boolean) } def package_installed?(name, with: nil) _ = with installed_extensions.include?(name.downcase) end sig { override.params( name: String, with: T.nilable(T::Array[String]), no_upgrade: T::Boolean, verbose: T::Boolean, _options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def preinstall!(name, with: nil, no_upgrade: false, verbose: false, **_options) _ = with _ = no_upgrade if !package_manager_installed? && Bundle.cask_installed? puts "Installing visual-studio-code. It is not currently installed." if verbose Bundle.system(HOMEBREW_BREW_FILE, "install", "--cask", "visual-studio-code", verbose:) end if package_installed?(name) puts "Skipping install of #{name} VSCode extension. It is already installed." if verbose return false end unless package_manager_installed? raise "Unable to install #{name} VSCode extension. VSCode is not installed." end true end sig { override.params( name: String, with: T.nilable(T::Array[String]), verbose: T::Boolean, ).returns(T::Boolean) } def install_package!(name, with: nil, verbose: false) _ = with vscode = package_manager_executable! Bundle.exchange_uid_if_needed! do Bundle.system(vscode, "--install-extension", name, verbose:) end end sig { override.params( name: String, with: T.nilable(T::Array[String]), preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, _options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def install!(name, with: nil, preinstall: true, no_upgrade: false, verbose: false, force: false, **_options) _ = with _ = no_upgrade _ = force return true unless preinstall puts "Installing #{name} VSCode extension. It is not currently installed." if verbose return false unless install_package!(name, verbose:) package = T.cast(package_record(name), String) installed_extensions << package unless installed_extensions.include?(package) if @extensions @extensions << package unless @extensions.include?(package) else @extensions = [package] end true end sig { params(entries: T::Array[Object]).returns(T::Array[String]) } def cleanup_items(entries) kept_extensions = entries.filter_map do |entry| entry = T.cast(entry, Dsl::Entry) entry.name.downcase if entry.type == type end return [].freeze if kept_extensions.empty? packages - kept_extensions end sig { params(extensions: T::Array[String]).void } def cleanup!(extensions) vscode = package_manager_executable return if vscode.nil? Bundle.exchange_uid_if_needed! do extensions.each do |extension| Kernel.system(vscode.to_s, "--uninstall-extension", extension) end end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/installer.rb000066400000000000000000000106461517265720000237060ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/dsl" require "bundle/package_types" require "bundle/skipper" module Homebrew module Bundle module Installer class InstallableEntry < T::Struct const :name, String const :options, Homebrew::Bundle::EntryOptions const :verb, String const :cls, T.class_of(Homebrew::Bundle::PackageType) end sig { void } def self.reset! Homebrew::Bundle.reset! Homebrew::Bundle::Cask.reset! Homebrew::Bundle::Tap.reset! end sig { params( entries: T::Array[Dsl::Entry], global: T::Boolean, file: T.nilable(String), no_lock: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, jobs: Integer, quiet: T::Boolean, ).returns(T::Boolean) } def self.install!(entries, global: false, file: nil, no_lock: false, no_upgrade: false, verbose: false, force: false, jobs: 1, quiet: false) success = 0 failure = 0 installable_entries = entries.filter_map do |entry| next if Homebrew::Bundle::Skipper.skip? entry name = entry.name options = entry.options type = entry.type cls = Homebrew::Bundle.installable(type) next if cls.nil? || !cls.install_supported? InstallableEntry.new(name:, options:, verb: cls.install_verb(name, options), cls:) end if (fetchable_names = fetchable_formulae_and_casks(installable_entries, no_upgrade:).presence) fetchable_names_joined = fetchable_names.join(", ") puts Formatter.success("Fetching #{fetchable_names_joined}") unless quiet unless Bundle.brew("fetch", *fetchable_names, verbose:) $stderr.puts Formatter.error "`brew bundle` failed! Failed to fetch #{fetchable_names_joined}" return false end end if jobs > 1 && installable_entries.size > 1 require "bundle/parallel_installer" parallel = ParallelInstaller.new( installable_entries, jobs:, no_upgrade:, verbose:, force:, quiet: ) parallel_success, parallel_failure = parallel.run! success += parallel_success failure += parallel_failure else installable_entries.each do |entry| if install_entry!(entry, no_upgrade:, verbose:, force:, quiet:) success += 1 else failure += 1 end end end unless failure.zero? require "utils" dependency = Utils.pluralize("dependency", failure) $stderr.puts Formatter.error "`brew bundle` failed! #{failure} Brewfile #{dependency} failed to install" return false end unless quiet require "utils" dependency = Utils.pluralize("dependency", success) puts Formatter.success "`brew bundle` complete! #{success} Brewfile #{dependency} now installed." end true end sig { params( entries: T::Array[InstallableEntry], no_upgrade: T::Boolean, ).returns(T::Array[String]) } def self.fetchable_formulae_and_casks(entries, no_upgrade:) entries.filter_map do |entry| entry.cls.fetchable_name(entry.name, entry.options, no_upgrade:) end end sig { params( entry: InstallableEntry, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, quiet: T::Boolean, ).returns(T::Boolean) } def self.install_entry!(entry, no_upgrade:, verbose:, force:, quiet:) name = entry.name options = entry.options verb = entry.verb cls = entry.cls preinstall = if cls.preinstall!(name, **options, no_upgrade:, verbose:) puts Formatter.success("#{verb} #{name}") true else puts "Using #{name}" unless quiet false end if cls.install!(name, **options, preinstall:, no_upgrade:, verbose:, force:) true else $stderr.puts Formatter.error("#{verb} #{name} has failed!") false end end private_class_method :install_entry! end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/lister.rb000066400000000000000000000021161517265720000232040ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/dsl" require "bundle/extensions" module Homebrew module Bundle module Lister sig { params(entries: T::Array[Dsl::Entry], formulae: T::Boolean, casks: T::Boolean, taps: T::Boolean, extension_types: Homebrew::Bundle::ExtensionTypes).void } def self.list(entries, formulae:, casks:, taps:, extension_types: {}) entries.each do |entry| puts entry.name if show?(entry.type, formulae:, casks:, taps:, extension_types:) end end sig { params(type: Symbol, formulae: T::Boolean, casks: T::Boolean, taps: T::Boolean, extension_types: Homebrew::Bundle::ExtensionTypes) .returns(T::Boolean) } private_class_method def self.show?(type, formulae:, casks:, taps:, extension_types:) return true if formulae && type == :brew return true if casks && type == :cask return true if taps && type == :tap return true if extension_types.fetch(type, false) false end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/package_type.rb000066400000000000000000000150431517265720000243410ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Homebrew module Bundle EntryOptionScalar = T.type_alias { T.nilable(T.any(String, Integer, Symbol, TrueClass, FalseClass)) } NestedEntryOptionValue = T.type_alias { T.any(EntryOptionScalar, T::Array[String]) } NestedEntryOptions = T.type_alias { T::Hash[Symbol, NestedEntryOptionValue] } EntryOption = T.type_alias { T.any(EntryOptionScalar, T::Array[String], NestedEntryOptions) } EntryOptions = T.type_alias { T::Hash[Symbol, EntryOption] } EntryInputOptions = T.type_alias { T::Hash[Symbol, Object] } class PackageType extend T::Helpers abstract! sig { params(subclass: T.class_of(Homebrew::Bundle::PackageType)).void } def self.inherited(subclass) super return if subclass.name == "Homebrew::Bundle::Extension" Homebrew::Bundle.register_package_type(subclass) end sig { returns(Symbol) } def self.type T.cast(const_get(:PACKAGE_TYPE), Symbol) end sig { returns(T::Boolean) } def self.dump_supported? true end sig { returns(T::Boolean) } def self.install_supported? true end sig { overridable.params(_name: String, _options: Homebrew::Bundle::EntryOptions).returns(String) } def self.install_verb(_name = "", _options = {}) "Installing" end sig { params( name: String, options: Homebrew::Bundle::EntryOptions, no_upgrade: T::Boolean, ).returns(T.nilable(String)) } def self.fetchable_name(name, options = {}, no_upgrade: false) _ = name _ = options _ = no_upgrade nil end sig { abstract.void } def self.reset!; end sig { abstract.params( name: String, no_upgrade: T::Boolean, verbose: T::Boolean, options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def self.preinstall!(name, no_upgrade: false, verbose: false, **options); end sig { abstract.params( name: String, preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def self.install!(name, preinstall: true, no_upgrade: false, verbose: false, force: false, **options); end sig { params( entries: T::Array[Object], exit_on_first_error: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, ).returns(T::Array[Object]) } def self.check(entries, exit_on_first_error: false, no_upgrade: false, verbose: false) new.find_actionable(entries, exit_on_first_error:, no_upgrade:, verbose:) end sig { abstract.returns(String) } def self.dump; end sig { params(describe: T::Boolean, no_restart: T::Boolean).returns(String) } def self.dump_output(describe: false, no_restart: false) _ = describe _ = no_restart dump end sig { params(packages: T::Array[Object], no_upgrade: T::Boolean).returns(T::Array[Object]) } def exit_early_check(packages, no_upgrade:) work_to_be_done = packages.find do |pkg| !installed_and_up_to_date?(pkg, no_upgrade:) end Array(work_to_be_done) end sig { overridable.params(name: Object, no_upgrade: T::Boolean).returns(String) } def failure_reason(name, no_upgrade:) reason = if no_upgrade && Bundle.upgrade_formulae.exclude?(name) "needs to be installed." else "needs to be installed or updated." end "#{self.class.const_get(:PACKAGE_TYPE_NAME)} #{name} #{reason}" end sig { params(packages: T::Array[Object], no_upgrade: T::Boolean).returns(T::Array[String]) } def full_check(packages, no_upgrade:) packages.reject { |pkg| installed_and_up_to_date?(pkg, no_upgrade:) } .map { |pkg| failure_reason(pkg, no_upgrade:) } end sig { params(all_entries: T::Array[Object]).returns(T::Array[Object]) } def checkable_entries(all_entries) require "bundle/skipper" all_entries.filter_map do |entry| entry = T.cast(entry, Dsl::Entry) next if entry.type != self.class.const_get(:PACKAGE_TYPE) next if Bundle::Skipper.skip?(entry) entry end end sig { params(entries: T::Array[Object]).returns(T::Array[Object]) } def format_checkable(entries) checkable_entries(entries).map do |entry| entry = T.cast(entry, Dsl::Entry) entry.name end end sig { params(_pkg: Object, no_upgrade: T::Boolean).returns(T::Boolean) } def installed_and_up_to_date?(_pkg, no_upgrade: false) raise NotImplementedError end sig { params( entries: T::Array[Object], exit_on_first_error: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, ).returns(T::Array[Object]) } def find_actionable(entries, exit_on_first_error: false, no_upgrade: false, verbose: false) requested = format_checkable(entries) if exit_on_first_error exit_early_check(requested, no_upgrade:) else full_check(requested, no_upgrade:) end end end class << self sig { params(package_type: T.class_of(PackageType)).void } def register_package_type(package_type) @package_types ||= T.let([], T.nilable(T::Array[T.class_of(PackageType)])) @package_types.reject! { |registered| registered.name == package_type.name } @package_types << package_type end sig { returns(T::Array[T.class_of(PackageType)]) } def package_types @package_types ||= T.let([], T.nilable(T::Array[T.class_of(PackageType)])) @package_types end sig { params(type: T.any(Symbol, String)).returns(T.nilable(T.class_of(PackageType))) } def package_type(type) requested_type = type.to_sym package_types.find { |registered| registered.type == requested_type } end sig { returns(T::Array[T.class_of(PackageType)]) } def dump_package_types core_package_types = [:tap, :brew, :cask].filter_map { |type| package_type(type) } (core_package_types + (package_types - core_package_types)).uniq end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/package_types.rb000066400000000000000000000002521517265720000245200ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle/package_type" require "bundle/tap" require "bundle/brew" require "bundle/cask" require "bundle/extensions" Homebrew-brew-d7f73ce/Library/Homebrew/bundle/parallel_installer.rb000066400000000000000000000222261517265720000255570ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "concurrent/executors" require "concurrent/promises" require "monitor" require "bundle/package_types" module Homebrew module Bundle class ParallelInstaller sig { params( entries: T::Array[Installer::InstallableEntry], jobs: Integer, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, quiet: T::Boolean, ).void } def initialize(entries, jobs:, no_upgrade:, verbose:, force:, quiet:) @entries = entries @jobs = jobs @no_upgrade = no_upgrade @verbose = verbose @force = force @quiet = quiet @pool = T.let(Concurrent::FixedThreadPool.new(jobs), Concurrent::FixedThreadPool) @output_mutex = T.let(Monitor.new, Monitor) # Cask installs may trigger interactive sudo prompts that write # directly to the terminal. Serialize them so Password: prompts # don't interleave with status output from other workers. @cask_install_mutex = T.let(Mutex.new, Mutex) end sig { returns([Integer, Integer]) } def run! dependency_map = build_dependency_map success = 0 failure = 0 pending_entries = T.let(@entries.dup, T::Array[Installer::InstallableEntry]) completed = T.let(Set.new, T::Set[String]) until pending_entries.empty? ready_entries = pending_entries.select do |entry| dependency_map.fetch(entry.name, Set.new).all? { |dependency| completed.include?(dependency) } end if ready_entries.empty? pending_entries.each do |entry| installed = install_entry!(entry) completed << entry.name if installed success += 1 else failure += 1 end end break end batch = ready_entries.take(@jobs) futures = batch.to_h do |entry| [entry, Concurrent::Promises.future_on(@pool, entry) do |install_entry| install_entry!(install_entry) end] end batch.each do |entry| installed = begin !futures.fetch(entry).value!.nil? rescue => e write_output(Formatter.error("Installing #{entry.name} has failed!"), stream: $stderr) write_output("[#{entry.name}] #{e.message}", stream: $stderr) if @verbose false end pending_entries.delete(entry) completed << entry.name if installed success += 1 else failure += 1 end end end [success, failure] ensure @pool.shutdown @pool.wait_for_termination end private sig { returns(T::Hash[String, T::Set[String]]) } def build_dependency_map # Phase 1: Map both full and short names so dep lookups work either way. entry_name_map = @entries.each_with_object({}) do |entry, map| map[entry.name] = entry.name map[normalize_formula_name(entry.name)] = entry.name end # Phase 2: Direct dependencies declared in the Brewfile. Determines # install ordering (entry A must finish before entry B starts). brewfile_deps = T.let({}, T::Hash[String, T::Array[String]]) @entries.each do |entry| deps = case entry.cls.name when "Homebrew::Bundle::Brew" Homebrew::Bundle::Brew.formula_dep_names(entry.name) when "Homebrew::Bundle::Cask" Homebrew::Bundle::Cask.formula_dependencies([entry.name]) else [] end # Entries from non-default taps depend on the tap being installed first. tap_prefix = entry.name.split("/").first(2).join("/") if entry.name.include?("/") if tap_prefix && entry.cls != Homebrew::Bundle::Tap deps = deps.dup deps << tap_prefix end brewfile_deps[entry.name] = deps end # Phase 3: Recursive dependency sets for lock conflict detection. # Only include build deps when building from source. Pouring bottles # only locks runtime deps, so a shared build dep like cmake won't # serialize unrelated bottle pours. cask_names = T.let(@entries.select { |e| e.cls == Homebrew::Bundle::Cask }.to_set(&:name), T::Set[String]) recursive_deps = T.let({}, T::Hash[String, T::Set[String]]) @entries.each do |entry| recursive_deps[entry.name] = case entry.cls.name when "Homebrew::Bundle::Brew" building_from_source = Array(entry.options[:args]).any? { |a| a.to_s == "build-from-source" } || !Homebrew::Bundle::Brew.formula_bottled?(entry.name) Homebrew::Bundle::Brew.recursive_dep_names(entry.name, include_build: building_from_source) when "Homebrew::Bundle::Cask" cask_dep_names(entry.name, cask_names) else Set.new end end # Phase 4: Merge explicit ordering and implicit lock conflicts. @entries.each_with_object({}) do |entry, map| depends_on = brewfile_deps.fetch(entry.name).each_with_object(Set.new) do |dep, set| name = entry_name_map[dep] || entry_name_map[normalize_formula_name(dep)] set << name if name.present? && name != entry.name end # Later entries wait for earlier ones when they share any recursive dep. entry_rdeps = recursive_deps.fetch(entry.name) @entries.each do |earlier| break if earlier.name == entry.name next if depends_on.include?(earlier.name) earlier_rdeps = recursive_deps.fetch(earlier.name) depends_on << earlier.name if entry_rdeps.intersect?(earlier_rdeps) end map[entry.name] = depends_on end end sig { params(name: String).returns(String) } def normalize_formula_name(name) name.split("/").fetch(-1) end # Walk cask-on-cask dependencies transitively, returning the set of # cask names (from the Brewfile) that this cask depends on. sig { params(name: String, cask_names: T::Set[String]).returns(T::Set[String]) } def cask_dep_names(name, cask_names) return Set.new unless Bundle.cask_installed? require "cask/cask_loader" cask = ::Cask::CaskLoader.load(name) direct = Array(cask.depends_on[:cask]).to_set # Only include deps that are also in the Brewfile. direct & cask_names rescue ::Cask::CaskUnavailableError Set.new end sig { params(entry: Installer::InstallableEntry).returns(T::Boolean) } def install_entry!(entry) # Cask installs can trigger sudo password prompts that write directly # to /dev/tty. Hold the output lock for the entire install so that # status messages from parallel formula workers don't interleave with # the Password: prompt. Monitor is reentrant, so write_output calls # inside do_install_entry! can re-acquire the lock on the same thread. if entry.cls == Homebrew::Bundle::Cask @cask_install_mutex.synchronize do result = @output_mutex.synchronize { do_install_entry!(entry) } # Interactive prompts (sudo, macOS security frameworks) can leave # the terminal cursor mid-line on /dev/tty with no trailing # newline. Clear any trailing prompt text with \r + CSI-K so the # next worker's status message overwrites it rather than appending # to produce "Password:Using foo". Writes nothing visible when # the line is already clean, so formula and cask output stay # visually uniform. clear_tty_line result end else do_install_entry!(entry) end end sig { params(entry: Installer::InstallableEntry).returns(T::Boolean) } def do_install_entry!(entry) name = entry.name options = entry.options verb = entry.verb cls = entry.cls preinstall = if cls.preinstall!(name, **options, no_upgrade: @no_upgrade, verbose: @verbose) write_output(Formatter.success("#{verb} #{name}")) true else write_output("Using #{name}") unless @quiet false end if cls.install!(name, **options, preinstall:, no_upgrade: @no_upgrade, verbose: @verbose, force: @force) true else write_output(Formatter.error("#{verb} #{name} has failed!"), stream: $stderr) false end end sig { params(message: String, stream: IO).void } def write_output(message, stream: $stdout) @output_mutex.synchronize { stream.puts(message) } end sig { void } def clear_tty_line File.open("/dev/tty", "w") { |f| f.print("\r\e[K") } rescue Errno::ENXIO, Errno::ENOENT # No TTY available (CI, piped output) - nothing to clean up. nil end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/remover.rb000066400000000000000000000055251517265720000233700ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/output" module Homebrew module Bundle module Remover extend ::Utils::Output::Mixin sig { params(args: String, type: Symbol, global: T::Boolean, file: T.nilable(String)).void } def self.remove(*args, type:, global:, file:) require "bundle/brewfile" require "bundle/dumper" brewfile = Brewfile.read(global:, file:) content = brewfile.input entry_type = type.to_s if type != :none escaped_args = args.flat_map do |arg| names = if type == :brew possible_names(arg) else [arg] end names.uniq.map { |a| Regexp.escape(a) } end entry_regex = /#{entry_type}(\s+|\(\s*)"(#{escaped_args.join("|")})"/ new_lines = T.let([], T::Array[String]) content.split("\n").compact.each do |line| if line.match?(entry_regex) name = line[entry_regex, 2] remove_package_description_comment(new_lines, T.must(name)) else new_lines << line end end new_content = "#{new_lines.join("\n")}\n" if content.chomp == new_content.chomp && type == :none && args.any? { |arg| possible_names(arg, raise_error: false).count > 1 } opoo "No matching entries found in Brewfile. Try again with `--formula` to match formula " \ "aliases and old formula names." return end path = Dumper.brewfile_path(global:, file:) Dumper.write_file path, new_content end sig { params(formula_name: String, raise_error: T::Boolean).returns(T::Array[String]) } def self.possible_names(formula_name, raise_error: true) formula = find_formula_or_cask(formula_name, raise_error:) return [] if formula.nil? || !formula.is_a?(Formula) [formula_name, formula.name, formula.full_name, *formula.aliases, *formula.oldnames].compact.uniq end sig { params(lines: T::Array[String], package_name: String).void } def self.remove_package_description_comment(lines, package_name) comment = lines.last&.match(/^\s*#\s+(?.+)$/)&.[](:desc) return unless comment return if find_formula_or_cask(package_name)&.desc != comment lines.pop end sig { params(name: String, raise_error: T::Boolean).returns(T.nilable(T.any(Formula, ::Cask::Cask))) } def self.find_formula_or_cask(name, raise_error: false) formula = begin Formulary.factory(name) rescue FormulaUnavailableError raise if raise_error end return formula if formula.present? begin ::Cask::CaskLoader.load(name) rescue ::Cask::CaskUnavailableError raise if raise_error end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle/skipper.rb000066400000000000000000000034251517265720000233630ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Homebrew module Bundle module Skipper class << self sig { params(entry: Dsl::Entry, silent: T::Boolean).returns(T::Boolean) } def skip?(entry, silent: false) require "bundle/brew" full_name = entry.options[:full_name] return true if @failed_taps&.any? do |tap| prefix = "#{tap}/" entry.name.start_with?(prefix) || (full_name.is_a?(String) && full_name.start_with?(prefix)) end entry_type_skips = Array(skipped_entries[entry.type]) return false if entry_type_skips.empty? # Check the name or ID particularly for Mac App Store entries where they # can have spaces in the names (and the `mas` output format changes on # occasion). entry_ids = [entry.name, entry.options[:id]&.to_s].compact return false unless entry_type_skips.intersect?(entry_ids) puts Formatter.warning "Skipping #{entry.name}" unless silent true end sig { params(tap_name: String).void } def tap_failed!(tap_name) @failed_taps ||= T.let([], T.nilable(T::Array[String])) @failed_taps << tap_name end private sig { returns(T::Hash[Symbol, T.nilable(T::Array[String])]) } def skipped_entries return @skipped_entries if @skipped_entries @skipped_entries ||= T.let({}, T.nilable(T::Hash[Symbol, T.nilable(T::Array[String])])) [:brew, :cask, :mas, :tap, :flatpak].each do |type| @skipped_entries[type] = ENV["HOMEBREW_BUNDLE_#{type.to_s.upcase}_SKIP"]&.split end @skipped_entries end end end end end require "extend/os/bundle/skipper" Homebrew-brew-d7f73ce/Library/Homebrew/bundle/tap.rb000066400000000000000000000113761517265720000224760ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "json" require "bundle/package_type" module Homebrew module Bundle class Tap < Homebrew::Bundle::PackageType PACKAGE_TYPE = :tap PACKAGE_TYPE_NAME = "Tap" class << self sig { override.void } def reset! @taps = T.let(nil, T.nilable(T::Array[::Tap])) @installed_taps = T.let(nil, T.nilable(T::Array[String])) end sig { override.params( name: String, no_upgrade: T::Boolean, verbose: T::Boolean, _options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def preinstall!(name, no_upgrade: false, verbose: false, **_options) _ = no_upgrade if installed_taps.include? name puts "Skipping install of #{name} tap. It is already installed." if verbose return false end true end sig { override.params( name: String, preinstall: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean, force: T::Boolean, clone_target: T.nilable(String), _options: Homebrew::Bundle::EntryOption, ).returns(T::Boolean) } def install!(name, preinstall: true, no_upgrade: false, verbose: false, force: false, clone_target: nil, **_options) _ = no_upgrade return true unless preinstall puts "Installing #{name} tap. It is not currently installed." if verbose args = [] official_tap = name.downcase.start_with? "homebrew/" args << "--force" if force || (official_tap && Homebrew::EnvConfig.developer?) success = if clone_target Bundle.brew("tap", name, clone_target, *args, verbose:) else Bundle.brew("tap", name, *args, verbose:) end unless success require "bundle/skipper" Homebrew::Bundle::Skipper.tap_failed!(name) return false end installed_taps << name true end sig { override.params(_name: String, _options: Homebrew::Bundle::EntryOptions).returns(String) } def install_verb(_name = "", _options = {}) "Tapping" end sig { override.returns(String) } def dump taps.map do |tap| remote = if tap.custom_remote? && (tap_remote = tap.remote) if (api_token = ENV.fetch("HOMEBREW_GITHUB_API_TOKEN", false).presence) # Replace the API token in the remote URL with interpolation. # Rubocop's warning here is wrong; we intentionally want to not # evaluate this string until the Brewfile is evaluated. # rubocop:disable Lint/InterpolationCheck tap_remote = tap_remote.gsub api_token, '#{ENV.fetch("HOMEBREW_GITHUB_API_TOKEN")}' # rubocop:enable Lint/InterpolationCheck end ", \"#{tap_remote}\"" end "tap \"#{tap.name}\"#{remote}" end.sort.uniq.join("\n") end sig { override.params(describe: T::Boolean, no_restart: T::Boolean).returns(String) } def dump_output(describe: false, no_restart: false) _ = describe _ = no_restart dump end sig { returns(T::Array[String]) } def tap_names taps.map(&:name) end sig { returns(T::Array[String]) } def installed_taps @installed_taps ||= T.let(tap_names, T.nilable(T::Array[String])) end sig { returns(T::Array[::Tap]) } def taps @taps ||= begin require "tap" ::Tap.select(&:installed?).to_a end end private :taps end sig { override.params(entries: T::Array[Object], exit_on_first_error: T::Boolean, no_upgrade: T::Boolean, verbose: T::Boolean).returns(T::Array[String]) } def find_actionable(entries, exit_on_first_error: false, no_upgrade: false, verbose: false) _ = exit_on_first_error _ = no_upgrade _ = verbose requested_taps = format_checkable(entries) return [] if requested_taps.empty? current_taps = self.class.tap_names (requested_taps - current_taps).map { |entry| "Tap #{entry} needs to be tapped." } end sig { override.params(package: Object, no_upgrade: T::Boolean).returns(T::Boolean) } def installed_and_up_to_date?(package, no_upgrade: false) _ = no_upgrade self.class.installed_taps.include?(T.cast(package, String)) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/bundle_version.rb000066400000000000000000000103131517265720000234450ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "system_command" module Homebrew # Representation of a macOS bundle version, commonly found in `Info.plist` files. class BundleVersion include Comparable extend SystemCommand::Mixin sig { params(info_plist_path: Pathname).returns(T.nilable(T.attached_class)) } def self.from_info_plist(info_plist_path) plist = system_command!("plutil", args: ["-convert", "xml1", "-o", "-", info_plist_path]).plist from_info_plist_content(plist) end sig { params(plist: T::Hash[String, T.untyped]).returns(T.nilable(T.attached_class)) } def self.from_info_plist_content(plist) short_version = plist["CFBundleShortVersionString"].presence version = plist["CFBundleVersion"].presence new(short_version, version) if short_version || version end sig { params(package_info_path: Pathname).returns(T.nilable(T.attached_class)) } def self.from_package_info(package_info_path) require "rexml/document" xml = REXML::Document.new(package_info_path.read) bundle_version_bundle = xml.get_elements("//pkg-info//bundle-version//bundle").first bundle_id = bundle_version_bundle["id"] if bundle_version_bundle return if bundle_id.blank? bundle = xml.get_elements("//pkg-info//bundle").find { |b| b["id"] == bundle_id } return unless bundle short_version = bundle["CFBundleShortVersionString"] version = bundle["CFBundleVersion"] new(short_version, version) if short_version || version end sig { returns(T.nilable(String)) } attr_reader :short_version, :version sig { params(short_version: T.nilable(String), version: T.nilable(String)).void } def initialize(short_version, version) # Remove version from short version, if present. short_version = short_version&.sub(/\s*\(#{Regexp.escape(version)}\)\Z/, "") if version @short_version = T.let(short_version.presence, T.nilable(String)) @version = T.let(version.presence, T.nilable(String)) return if @short_version || @version raise ArgumentError, "`short_version` and `version` cannot both be `nil` or empty" end sig { params(other: BundleVersion).returns(T.nilable(Integer)) } def <=>(other) return super unless instance_of?(other.class) make_version = ->(v) { v ? Version.new(v) : Version::NULL } version = self.version.then(&make_version) other_version = other.version.then(&make_version) difference = version <=> other_version # If `version` is equal or cannot be compared, compare `short_version` instead. if difference.nil? || difference.zero? short_version = self.short_version.then(&make_version) other_short_version = other.short_version.then(&make_version) short_version_difference = short_version <=> other_short_version return short_version_difference unless short_version_difference.nil? end difference end sig { params(other: BundleVersion).returns(T::Boolean) } def ==(other) instance_of?(other.class) && short_version == other.short_version && version == other.version end alias eql? == # Create a nicely formatted version (on a best effort basis). sig { returns(String) } def nice_version nice_parts.join(",") end sig { returns(T::Array[String]) } def nice_parts short_version = self.short_version version = self.version return [T.must(short_version)] if short_version == version if short_version && version return [version] if version.match?(/\A\d+(\.\d+)+\Z/) && version.start_with?("#{short_version}.") return [short_version] if short_version.match?(/\A\d+(\.\d+)+\Z/) && short_version.start_with?("#{version}.") if short_version.match?(/\A\d+(\.\d+)*\Z/) && version.match?(/\A\d+\Z/) return [short_version] if short_version.start_with?("#{version}.") || short_version.end_with?(".#{version}") return [short_version, version] end end [short_version, version].compact end private :nice_parts sig { returns(T::Hash[Symbol, String]) } def to_h { short_version:, version:, }.compact end end end Homebrew-brew-d7f73ce/Library/Homebrew/cachable.rb000066400000000000000000000005761517265720000221630ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cachable extend T::Generic # Sorbet type members are mutable by design and cannot be frozen. Cache = type_member { { upper: T::Hash[T.anything, T.anything] } } sig { returns(Cache) } def cache @cache ||= T.let(T.cast({}, Cache), T.nilable(Cache)) end sig { void } def clear_cache cache.clear end end Homebrew-brew-d7f73ce/Library/Homebrew/cache_store.rb000066400000000000000000000115661517265720000227210ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "json" # # {CacheStoreDatabase} acts as an interface to a persistent storage mechanism # residing in the `HOMEBREW_CACHE`. # class CacheStoreDatabase extend T::Generic # Sorbet type members are mutable by design and cannot be frozen. Key = type_member # rubocop:disable Style/MutableConstant # Sorbet type members are mutable by design and cannot be frozen. Value = type_member # rubocop:disable Style/MutableConstant # Yields the cache store database. # Closes the database after use if it has been loaded. sig { type_parameters(:U) .params( type: Symbol, _blk: T.proc.params(arg0: CacheStoreDatabase[T.anything, T.anything]).returns(T.type_parameter(:U)), ) .returns(T.type_parameter(:U)) } def self.use(type, &_blk) @db_type_reference_hash ||= T.let({}, T.nilable(T::Hash[T.untyped, T.untyped])) @db_type_reference_hash[type] ||= {} type_ref = @db_type_reference_hash[type] type_ref[:count] ||= 0 type_ref[:count] += 1 type_ref[:db] ||= CacheStoreDatabase.new(type) return_value = yield(type_ref[:db]) if type_ref[:count].positive? type_ref[:count] -= 1 else type_ref[:count] = 0 end if type_ref[:count].zero? type_ref[:db].write_if_dirty! type_ref.delete(:db) end return_value end # Creates a CacheStoreDatabase. sig { params(type: Symbol).void } def initialize(type) @type = type @dirty = T.let(false, T.nilable(T::Boolean)) end # Sets a value in the underlying database (and creates it if necessary). sig { params(key: Key, value: Value).void } def set(key, value) dirty! db[key] = value end # Gets a value from the underlying database (if it already exists). sig { params(key: Key).returns(T.nilable(Value)) } def get(key) return unless created? db[key] end # Deletes a value from the underlying database (if it already exists). sig { params(key: Key).void } def delete(key) return unless created? dirty! db.delete(key) end # Deletes all content from the underlying database (if it already exists). sig { void } def clear! return unless created? dirty! db.clear end # Closes the underlying database (if it is created and open). sig { void } def write_if_dirty! return unless dirty? cache_path.dirname.mkpath cache_path.atomic_write(JSON.dump(@db)) end # Returns `true` if the cache file has been created for the given `@type`. sig { returns(T::Boolean) } def created? cache_path.exist? end # Returns the modification time of the cache file (if it already exists). sig { returns(T.nilable(Time)) } def mtime return unless created? cache_path.mtime end # Performs a `select` on the underlying database. sig { overridable.params(block: T.proc.params(arg0: Key, arg1: Value).returns(BasicObject)).returns(T::Hash[Key, Value]) } def select(&block) db.select(&block) end # Returns `true` if the cache is empty. sig { returns(T::Boolean) } def empty? db.empty? end # Performs a `each_key` on the underlying database. sig { params(block: T.proc.params(arg0: Key).returns(BasicObject)).returns(T::Hash[Key, Value]) } def each_key(&block) db.each_key(&block) end private # Lazily loaded database in read/write mode. If this method is called, a # database file will be created in the `HOMEBREW_CACHE` with a name # corresponding to the `@type` instance variable. sig { returns(T::Hash[Key, Value]) } def db @db ||= T.let({}, T.nilable(T::Hash[Key, Value])) return @db if !@db.empty? || !created? begin result = JSON.parse(cache_path.read) @db = result if result.is_a?(Hash) rescue JSON::ParserError # Ignore parse errors end @db end # The path where the database resides in the `HOMEBREW_CACHE` for the given # `@type`. sig { returns(Pathname) } def cache_path HOMEBREW_CACHE/"#{@type}.json" end # Sets that the cache needs to be written to disk. sig { void } def dirty! @dirty = true end # Returns `true` if the cache needs to be written to disk. sig { returns(T::Boolean) } def dirty? !!@dirty end end # # {CacheStore} provides methods to mutate and fetch data from a persistent # storage mechanism. # class CacheStore # rubocop:todo Style/OneClassPerFile extend T::Generic extend T::Helpers abstract! # Sorbet type members are mutable by design and cannot be frozen. Key = type_member # rubocop:disable Style/MutableConstant # Sorbet type members are mutable by design and cannot be frozen. Value = type_member # rubocop:disable Style/MutableConstant sig { params(database: CacheStoreDatabase[Key, Value]).void } def initialize(database) @database = database end protected sig { returns(CacheStoreDatabase[Key, Value]) } attr_reader :database end Homebrew-brew-d7f73ce/Library/Homebrew/cask.rb000066400000000000000000000010361517265720000213520ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact" require "cask/audit" require "cask/auditor" require "cask/cache" require "cask/cask_loader" require "cask/cask" require "cask/caskroom" require "cask/config" require "cask/exceptions" require "cask/denylist" require "cask/download" require "cask/dsl" require "cask/installer" require "cask/macos" require "cask/metadata" require "cask/migrator" require "cask/pkg" require "cask/quarantine" require "cask/staged" require "cask/tab" require "cask/url" require "cask/utils" Homebrew-brew-d7f73ce/Library/Homebrew/cask/000077500000000000000000000000001517265720000210255ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact.rb000066400000000000000000000035451517265720000231560ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/app" require "cask/artifact/artifact" # generic 'artifact' stanza require "cask/artifact/audio_unit_plugin" require "cask/artifact/binary" require "cask/artifact/colorpicker" require "cask/artifact/dictionary" require "cask/artifact/font" require "cask/artifact/input_method" require "cask/artifact/installer" require "cask/artifact/internet_plugin" require "cask/artifact/keyboard_layout" require "cask/artifact/manpage" require "cask/artifact/vst_plugin" require "cask/artifact/vst3_plugin" require "cask/artifact/pkg" require "cask/artifact/postflight_block" require "cask/artifact/preflight_block" require "cask/artifact/prefpane" require "cask/artifact/qlplugin" require "cask/artifact/mdimporter" require "cask/artifact/screen_saver" require "cask/artifact/bashcompletion" require "cask/artifact/fishcompletion" require "cask/artifact/generated_completion" require "cask/artifact/zshcompletion" require "cask/artifact/service" require "cask/artifact/stage_only" require "cask/artifact/suite" require "cask/artifact/uninstall" require "cask/artifact/zap" module Cask # Module containing all cask artifact classes. module Artifact MACOS_ONLY_ARTIFACTS = [ ::Cask::Artifact::App, ::Cask::Artifact::AudioUnitPlugin, ::Cask::Artifact::Colorpicker, ::Cask::Artifact::Dictionary, ::Cask::Artifact::InputMethod, ::Cask::Artifact::InternetPlugin, ::Cask::Artifact::KeyboardLayout, ::Cask::Artifact::Mdimporter, ::Cask::Artifact::Pkg, ::Cask::Artifact::Prefpane, ::Cask::Artifact::Qlplugin, ::Cask::Artifact::ScreenSaver, ::Cask::Artifact::Service, ::Cask::Artifact::Suite, ::Cask::Artifact::VstPlugin, ::Cask::Artifact::Vst3Plugin, ].freeze LINUX_ONLY_ARTIFACTS = T.let([].freeze, T::Array[T.untyped]) end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/000077500000000000000000000000001517265720000226225ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/abstract_artifact.rb000066400000000000000000000145701517265720000266360ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "extend/object/deep_dup" require "utils/output" module Cask module Artifact # Abstract superclass for all artifacts. class AbstractArtifact extend T::Helpers extend ::Utils::Output::Mixin abstract! include Comparable include ::Utils::Output::Mixin # T.anything or the union of all possible argument types would be better choice, but it's convenient to be # able to invoke `.inspect`, `.to_s`, etc. without the overhead of type guards. DirectivesType = T.type_alias { Object } sig { overridable.returns(String) } def self.english_name @english_name ||= T.let(T.must(name).sub(/^.*:/, "").gsub(/(.)([A-Z])/, '\1 \2'), T.nilable(String)) end sig { returns(String) } def self.english_article @english_article ||= T.let(/^[aeiou]/i.match?(english_name) ? "an" : "a", T.nilable(String)) end sig { overridable.returns(Symbol) } def self.dsl_key @dsl_key ||= T.let(T.must(name).sub(/^.*:/, "").gsub(/(.)([A-Z])/, '\1_\2').downcase.to_sym, T.nilable(Symbol)) end sig { overridable.returns(Symbol) } def self.dirmethod @dirmethod ||= T.let(:"#{dsl_key}dir", T.nilable(Symbol)) end sig { abstract.returns(String) } def summarize; end sig { params(path: T.any(String, Pathname)).returns(Pathname) } def staged_path_join_executable(path) path = Pathname(path) path = path.expand_path if path.to_s.start_with?("~") absolute_path = if path.absolute? path else cask.staged_path.join(path) end FileUtils.chmod "+x", absolute_path if absolute_path.exist? && !absolute_path.executable? if absolute_path.exist? absolute_path else path end end sig { returns(T::Hash[T.class_of(AbstractArtifact), Integer]) } def sort_order @sort_order ||= T.let( [ PreflightBlock, # The `uninstall` stanza should be run first, as it may # depend on other artifacts still being installed. Uninstall, Installer, # `pkg` should be run before `binary`, so # targets are created prior to linking. # `pkg` should be run before `app`, since an `app` could # contain a nested installer (e.g. `wireshark`). Pkg, [ App, Suite, Artifact, Colorpicker, Prefpane, Qlplugin, Mdimporter, Dictionary, Font, Service, InputMethod, InternetPlugin, KeyboardLayout, AudioUnitPlugin, VstPlugin, Vst3Plugin, ScreenSaver, ], Binary, Manpage, PostflightBlock, Zap, ].each_with_index.flat_map { |classes, i| Array(classes).map { |c| [c, i] } }.to_h, T.nilable(T::Hash[T.class_of(AbstractArtifact), Integer]), ) end sig { override.params(other: BasicObject).returns(T.nilable(Integer)) } def <=>(other) case other when AbstractArtifact return 0 if instance_of?(other.class) (sort_order[self.class] <=> sort_order[other.class]).to_i end end # TODO: this sort of logic would make more sense in dsl.rb, or a # constructor called from dsl.rb, so long as that isn't slow. sig { params( arguments: DirectivesType, stanza: T.any(String, Symbol), default_arguments: T::Hash[Symbol, T.anything], override_arguments: T::Hash[Symbol, T.anything], key: T.nilable(Symbol), ).returns([T.nilable(String), T::Hash[Symbol, T.untyped]]) } def self.read_script_arguments(arguments, stanza, default_arguments = {}, override_arguments = {}, key = nil) # TODO: when stanza names are harmonized with class names, # stanza may not be needed as an explicit argument description = key ? "#{stanza} #{key.inspect}" : stanza.to_s arguments = case arguments when String then { executable: arguments } # backward-compatible string value when Hash then arguments.dup # Avoid mutating the original argument else odie "Unsupported arguments type #{arguments.class}" end # key sanity permitted_keys = [:args, :input, :executable, :must_succeed, :sudo, :print_stdout, :print_stderr] unknown_keys = arguments.keys - permitted_keys unless unknown_keys.empty? opoo "Unknown arguments to #{description} -- " \ "#{unknown_keys.inspect} (ignored). Running " \ "`brew update; brew cleanup` will likely fix it." end arguments.select! { |k| permitted_keys.include?(k) } # key warnings override_keys = override_arguments.keys ignored_keys = arguments.keys & override_keys unless ignored_keys.empty? onoe "Some arguments to #{description} will be ignored -- :#{unknown_keys.inspect} (overridden)." end # extract executable executable = arguments.key?(:executable) ? arguments.delete(:executable) : nil arguments = default_arguments.merge arguments arguments.merge! override_arguments [executable, arguments] end sig { returns(Cask) } attr_reader :cask sig { params(cask: Cask, dsl_args: T.anything).void } def initialize(cask, *dsl_args) @cask = cask @dirmethod = T.let(nil, T.nilable(Symbol)) @dsl_args = T.let(dsl_args.deep_dup, T::Array[T.anything]) @dsl_key = T.let(nil, T.nilable(Symbol)) @english_article = T.let(nil, T.nilable(String)) @english_name = T.let(nil, T.nilable(String)) @sort_order = T.let(nil, T.nilable(T::Hash[T.class_of(AbstractArtifact), Integer])) end sig { returns(Config) } def config cask.config end sig { returns(String) } def to_s "#{summarize} (#{self.class.english_name})" end sig { returns(T::Array[T.anything]) } def to_args @dsl_args.compact_blank end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/abstract_flight_block.rb000066400000000000000000000031651517265720000274660ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_artifact" module Cask module Artifact # Abstract superclass for block artifacts. class AbstractFlightBlock < AbstractArtifact sig { override.returns(Symbol) } def self.dsl_key super.to_s.sub(/_block$/, "").to_sym end sig { returns(Symbol) } def self.uninstall_dsl_key :"uninstall_#{dsl_key}" end sig { returns(T::Hash[Symbol, DirectivesType]) } attr_reader :directives sig { params(cask: Cask, directives: DirectivesType).void } def initialize(cask, **directives) super(cask) @directives = directives end sig { params(_options: T.anything).void } def install_phase(**_options) abstract_phase(self.class.dsl_key) end sig { params(_options: T.anything).void } def uninstall_phase(**_options) abstract_phase(self.class.uninstall_dsl_key) end sig { override.returns(String) } def summarize directives.keys.join(", ") end private sig { params(dsl_key: Symbol).returns(T::Class[::Cask::DSL::Base]) } def class_for_dsl_key(dsl_key) namespace = self.class.name.to_s.sub(/::.*::.*$/, "") self.class.const_get("#{namespace}::DSL::#{dsl_key.to_s.split("_").map(&:capitalize).join}") end sig { params(dsl_key: Symbol).void } def abstract_phase(dsl_key) return if (block = directives[dsl_key]).nil? class_for_dsl_key(dsl_key).new(cask).instance_eval(&T.cast(block, T.proc.returns(T.anything))) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/abstract_uninstall.rb000066400000000000000000000522311517265720000270460ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "timeout" require "utils/user" require "cask/artifact/abstract_artifact" require "cask/pkg" require "extend/hash/keys" require "system_command" module Cask module Artifact # Abstract superclass for uninstall artifacts. class AbstractUninstall < AbstractArtifact include SystemCommand::Mixin ORDERED_DIRECTIVES = [ :early_script, :launchctl, :quit, :signal, :login_item, :kext, :script, :pkgutil, :delete, :trash, :rmdir, ].freeze METADATA_KEYS = [ :on_upgrade, ].freeze sig { params(cask: Cask, directives: DirectivesType).returns(AbstractUninstall) } def self.from_args(cask, **directives) new(cask, **directives) end sig { returns(T::Hash[Symbol, DirectivesType]) } attr_reader :directives sig { params(cask: Cask, directives: DirectivesType).void } def initialize(cask, **directives) directives.assert_valid_keys(*ORDERED_DIRECTIVES, *METADATA_KEYS) super directives[:signal] = Array(directives[:signal]).flatten.each_slice(2).to_a @directives = directives # This is already included when loading from the API. return if cask.loaded_from_api? return unless directives.key?(:kext) cask.caveats do T.bind(self, ::Cask::DSL::Caveats) kext end end sig { returns(T::Hash[Symbol, DirectivesType]) } def to_h directives.to_h end sig { override.returns(String) } def summarize to_h.flat_map { |key, val| Array(val).map { |v| "#{key.inspect} => #{v.inspect}" } }.join(", ") end private sig { params(options: DirectivesType).void } def dispatch_uninstall_directives(**options) ORDERED_DIRECTIVES.each do |directive_sym| dispatch_uninstall_directive(directive_sym, **options) end end sig { params(directive_sym: Symbol, options: T.anything).void } def dispatch_uninstall_directive(directive_sym, **options) return unless directives.key?(directive_sym) args = directives[directive_sym] send(:"uninstall_#{directive_sym}", *(args.is_a?(Hash) ? [args] : args), **options) end sig { returns(Symbol) } def stanza self.class.dsl_key end # Preserve prior functionality of script which runs first. Should rarely be needed. # :early_script should not delete files, better defer that to :script. # If cask writers never need :early_script it may be removed in the future. sig { params(directives: DirectivesType, options: T.anything).void } def uninstall_early_script(directives, **options) uninstall_script(directives, directive_name: :early_script, **options) end # :launchctl must come before :quit/:signal for cases where app would instantly re-launch sig { params(services: String, command: T.class_of(SystemCommand), _kwargs: T.anything).void } def uninstall_launchctl(*services, command:, **_kwargs) booleans = [false, true] all_services = [] # if launchctl item contains a wildcard, find matching process(es) services.each do |service| all_services << service unless service.include?("*") next unless service.include?("*") found_services = find_launchctl_with_wildcard(service) next if found_services.blank? found_services.each { |found_service| all_services << found_service } end all_services.each do |service| ohai "Removing launchctl service #{service}" booleans.each do |sudo| plist_status = command.run( "/bin/launchctl", args: ["list", service], sudo:, sudo_as_root: sudo, print_stderr: false, ).stdout if plist_status.start_with?("{") result = command.run( "/bin/launchctl", args: ["remove", service], must_succeed: false, sudo:, sudo_as_root: sudo, ) next unless result.success? sleep 1 end paths = [ "/Library/LaunchAgents/#{service}.plist", "/Library/LaunchDaemons/#{service}.plist", ] paths.each { |elt| elt.prepend(Dir.home).freeze } unless sudo paths = paths.map { |elt| Pathname(elt) }.select(&:exist?) paths.each do |path| command.run("/bin/rm", args: ["-f", "--", path], must_succeed: false, sudo:, sudo_as_root: sudo) end # undocumented and untested: pass a path to uninstall :launchctl next unless Pathname(service).exist? command.run( "/bin/launchctl", args: ["unload", "-w", "--", service], must_succeed: false, sudo:, sudo_as_root: sudo, ) command.run( "/bin/rm", args: ["-f", "--", service], must_succeed: false, sudo:, sudo_as_root: sudo, ) sleep 1 end end end sig { params(bundle_id: String).returns(T::Array[[Integer, Integer, T.nilable(String)]]) } def running_processes(bundle_id) system_command!("/bin/launchctl", args: ["list"]) .stdout.lines.drop(1) .map { |line| line.chomp.split("\t") } .map { |pid, state, id| [pid.to_i, state.to_i, id] } .select do |(pid, _, id)| pid.nonzero? && /\A(?:application\.)?#{Regexp.escape(bundle_id)}(?:\.\d+){0,2}\Z/.match?(id) end end sig { params(search: String).returns(T::Array[String]) } def find_launchctl_with_wildcard(search) regex = Regexp.escape(search).gsub("\\*", ".*") system_command!("/bin/launchctl", args: ["list"]) .stdout.lines.drop(1) # skip stdout column headers .filter_map do |line| pid, _state, id = line.chomp.split(/\s+/) id if pid.to_i.nonzero? && T.must(id).match?(regex) end end sig { returns(String) } def automation_access_instructions navigation_path = if MacOS.version >= :ventura "System Settings → Privacy & Security" else "System Preferences → Security & Privacy → Privacy" end <<~EOS Enable Automation access for "Terminal → System Events" in: #{navigation_path} → Automation if you haven't already. EOS end # :quit/:signal must come before :kext so the kext will not be in use by a running process sig { params(bundle_ids: String, command: T.nilable(T.class_of(SystemCommand)), _kwargs: T.anything).void } def uninstall_quit(*bundle_ids, command: nil, **_kwargs) bundle_ids.each do |bundle_id| next unless running?(bundle_id) unless T.must(User.current).gui? opoo "Not logged into a GUI; skipping quitting application ID '#{bundle_id}'." next end ohai "Quitting application '#{bundle_id}'..." begin Timeout.timeout(10) do Kernel.loop do next unless quit(bundle_id).success? next if running?(bundle_id) puts "Application '#{bundle_id}' quit successfully." break end end rescue Timeout::Error opoo "Application '#{bundle_id}' did not quit. #{automation_access_instructions}" end end end sig { params(bundle_id: String).returns(T::Boolean) } def running?(bundle_id) script = <<~JAVASCRIPT 'use strict'; ObjC.import('stdlib') function run(argv) { try { var app = Application(argv[0]) if (app.running()) { $.exit(0) } } catch (err) { } $.exit(1) } JAVASCRIPT system_command("osascript", args: ["-l", "JavaScript", "-e", script, bundle_id], print_stderr: true).status.success? || false end sig { params(bundle_id: String).returns(SystemCommand::Result) } def quit(bundle_id) script = <<~JAVASCRIPT 'use strict'; ObjC.import('stdlib') function run(argv) { var app = Application(argv[0]) try { app.quit() } catch (err) { if (app.running()) { $.exit(1) } } $.exit(0) } JAVASCRIPT system_command "osascript", args: ["-l", "JavaScript", "-e", script, bundle_id], print_stderr: false end private :quit # :signal should come after :quit so it can be used as a backup when :quit fails sig { params(signals: [String, String], command: T.nilable(T.class_of(SystemCommand)), _kwargs: T.anything).void } def uninstall_signal(*signals, command: nil, **_kwargs) signals.each do |pair| raise CaskInvalidError.new(cask, "Each #{stanza} :signal must consist of 2 elements.") if pair.size != 2 signal, bundle_id = pair ohai "Signalling '#{signal}' to application ID '#{bundle_id}'" pids = running_processes(bundle_id).map(&:first) next if pids.none? # Note that unlike :quit, signals are sent from the current user (not # upgraded to the superuser). This is a todo item for the future, but # there should be some additional thought/safety checks about that, as a # misapplied "kill" by root could bring down the system. The fact that we # learned the pid from AppleScript is already some degree of protection, # though indirect. # TODO: check the user that owns the PID and don't try to kill those from other users. odebug "Unix ids are #{pids.inspect} for processes with bundle identifier #{bundle_id}" begin Process.kill(signal, *pids) rescue Errno::EPERM => e opoo "Failed to kill #{bundle_id} PIDs #{pids.join(", ")} with signal #{signal}: #{e}" end sleep 3 end end sig { params( login_items: T.any(String, T::Hash[Symbol, T.any(String, Pathname)]), command: T.nilable(T.class_of(SystemCommand)), successor: T.nilable(Cask), _kwargs: T.anything, ).void } def uninstall_login_item(*login_items, command: nil, successor: nil, **_kwargs) return if successor apps = cask.artifacts.select { |a| a.class.dsl_key == :app } derived_login_items = apps.map { |a| { path: a.target } } [*derived_login_items, *login_items].each do |item| type, id = if item.respond_to?(:key) && item.key?(:path) ["path", item[:path]] else ["name", item] end ohai "Removing login item #{id}" result = system_command( "osascript", args: [ "-e", %Q(tell application "System Events" to delete every login item whose #{type} is #{id.to_s.inspect}), ], ) opoo "Removal of login item #{id} failed. #{automation_access_instructions}" unless result.success? sleep 1 end end # :kext should be unloaded before attempting to delete the relevant file sig { params(kexts: String, command: T.nilable(T.class_of(SystemCommand)), _kwargs: T.anything).void } def uninstall_kext(*kexts, command: nil, **_kwargs) kexts.each do |kext| ohai "Unloading kernel extension #{kext}" is_loaded = system_command!( "/usr/sbin/kextstat", args: ["-l", "-b", kext], sudo: true, sudo_as_root: true, ).stdout if is_loaded.length > 1 system_command!( "/sbin/kextunload", args: ["-b", kext], sudo: true, sudo_as_root: true, ) sleep 1 end found_kexts = system_command!( "/usr/sbin/kextfind", args: ["-b", kext], sudo: true, sudo_as_root: true, ).stdout.chomp.lines found_kexts.each do |kext_path| ohai "Removing kernel extension #{kext_path}" system_command!( "/bin/rm", args: ["-rf", kext_path], sudo: true, sudo_as_root: true, ) end end end # :script must come before :pkgutil, :delete, or :trash so that the script file is not already deleted sig { params( directives: DirectivesType, command: T.class_of(SystemCommand), directive_name: Symbol, force: T::Boolean, _kwargs: T.anything, ).void } def uninstall_script(directives, command:, directive_name: :script, force: false, **_kwargs) # TODO: Create a common `Script` class to run this and Artifact::Installer. executable, script_arguments = self.class.read_script_arguments(directives, "uninstall", { must_succeed: true, sudo: false }, { print_stdout: true }, directive_name) ohai "Running uninstall script #{executable}" raise CaskInvalidError.new(cask, "#{stanza} :#{directive_name} without :executable.") if executable.nil? executable_path = staged_path_join_executable(executable) if (executable_path.absolute? && !executable_path.exist?) || (!executable_path.absolute? && which(executable_path.to_s).nil?) message = "uninstall script #{executable} does not exist" raise CaskError, "#{message}." unless force opoo "#{message}; skipping." return end command.run(executable_path, **script_arguments) sleep 1 end sig { params(pkgs: String, command: T.class_of(SystemCommand), _kwargs: T.anything).void } def uninstall_pkgutil(*pkgs, command:, **_kwargs) ohai "Uninstalling packages with `sudo` (which may request your password)..." pkgs.each do |regex| ::Cask::Pkg.all_matching(regex, command).each do |pkg| puts pkg.package_id pkg.uninstall end end end # This returns T::Enumerable[[Pathname, T::Array[Pathname]]] when called without a block, # but sorbet doesn't support overloads. sig { params( action: Symbol, paths: T::Array[T.any(Pathname, String)], _block: T.nilable(T.proc.params(path: T.any(Pathname, String), resolved_paths: T::Array[Pathname]).void), ).returns(T.untyped) } def each_resolved_path(action, paths, &_block) return enum_for(:each_resolved_path, action, paths) unless block_given? paths.each do |path| resolved_path = Pathname.new(path.to_s.sub(%r{^~(?=(/|$))}, Dir.home)) if resolved_path.relative? opoo "Skipping #{Formatter.identifier(action)} for relative path '#{path}'." next end if resolved_path.each_filename.any? { |part| [".", ".."].include?(part) } opoo "Skipping #{Formatter.identifier(action)} for path with relative segments '#{path}'." next end begin resolved_paths = Pathname.glob(resolved_path).reject do |target| next false unless undeletable?(target) opoo "Skipping #{Formatter.identifier(action)} for undeletable path '#{target}'." true end yield path, resolved_paths rescue Errno::EPERM raise if File.readable?(File.expand_path("~/Library/Application Support/com.apple.TCC")) navigation_path = if MacOS.version >= :ventura "System Settings → Privacy & Security" else "System Preferences → Security & Privacy → Privacy" end odie "Unable to remove some files. Please enable Full Disk Access for your terminal under " \ "#{navigation_path} → Full Disk Access." end end end sig { params(paths: T.any(Pathname, String), command: T.class_of(SystemCommand), _kwargs: T.anything).void } def uninstall_delete(*paths, command:, **_kwargs) return if paths.empty? ohai "Removing files:" each_resolved_path(:delete, paths) do |path, resolved_paths| puts path command.run!( "/usr/bin/xargs", args: ["-0", "--", "/bin/rm", "-r", "-f", "--"], input: resolved_paths.join("\0"), sudo: true, ) end end sig { params(paths: T.any(Pathname, String), options: T.anything).void } def uninstall_trash(*paths, **options) return if paths.empty? resolved_paths = each_resolved_path(:trash, paths).to_a ohai "Trashing files:", resolved_paths.map(&:first) trash_paths(*resolved_paths.flat_map(&:last), **options) end sig { params(paths: Pathname, command: T.nilable(T.class_of(SystemCommand)), _kwargs: T.anything) .returns(T.nilable([T::Array[String], T::Array[String]])) } def trash_paths(*paths, command: nil, **_kwargs) return if paths.empty? stdout = system_command(HOMEBREW_LIBRARY_PATH/"cask/utils/trash.swift", args: paths, print_stderr: Homebrew::EnvConfig.developer?).stdout trashed, _, untrashable = stdout.partition("\n") trashed = trashed.split(":") untrashable = untrashable.split(":") trashed_with_permissions, untrashable = untrashable.partition do |path| Utils.gain_permissions(Pathname(path), ["-R"], SystemCommand) do system_command! HOMEBREW_LIBRARY_PATH/"cask/utils/trash.swift", args: [path], print_stderr: Homebrew::EnvConfig.developer? end true rescue false end trashed += trashed_with_permissions return trashed, untrashable if untrashable.empty? opoo "The following files could not be trashed, please do so manually:" $stderr.puts untrashable [trashed, untrashable] end sig { params(directories: Pathname).returns(T::Boolean) } def all_dirs?(*directories) directories.all?(&:directory?) end sig { params(directories: Pathname, command: T.class_of(SystemCommand), _kwargs: T.anything).void } def recursive_rmdir(*directories, command:, **_kwargs) directories.all? do |resolved_path| puts resolved_path.sub(Dir.home, "~") if resolved_path.readable? children = resolved_path.children next false unless children.all? { |child| child.directory? || child.basename.to_s == ".DS_Store" } else lines = command.run!("/bin/ls", args: ["-A", "-F", "--", resolved_path], sudo: true, print_stderr: false) .stdout.lines.map(&:chomp) .flat_map(&:chomp) # Using `-F` above outputs directories ending with `/`. next false unless lines.all? { |l| l.end_with?("/") || l == ".DS_Store" } children = lines.map { |l| resolved_path/l.delete_suffix("/") } end # Directory counts as empty if it only contains a `.DS_Store`. if children.include?(ds_store = resolved_path/".DS_Store") Utils.gain_permissions_remove(ds_store, command:) children.delete(ds_store) end next false unless recursive_rmdir(*children, command:) begin Utils.gain_permissions_rmdir(resolved_path, command:) rescue Errno::ENOTEMPTY, ErrorDuringExecution next false end true end end sig { params(directories: T.any(Pathname, String), kwargs: T.anything).void } def uninstall_rmdir(*directories, **kwargs) return if directories.empty? ohai "Removing directories if empty:" each_resolved_path(:rmdir, directories) do |_path, resolved_paths| next unless resolved_paths.all?(&:directory?) recursive_rmdir(*resolved_paths, **kwargs) end end sig { params(target: Pathname).returns(T::Boolean) } def undeletable?(target) !target.parent.writable? end end end end require "extend/os/cask/artifact/abstract_uninstall" Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/app.rb000066400000000000000000000023731517265720000237340ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `app` stanza. class App < Moved sig { override.params( adopt: T::Boolean, auto_updates: T.nilable(T::Boolean), force: T::Boolean, verbose: T::Boolean, predecessor: T.nilable(Cask), successor: T.nilable(Cask), reinstall: T::Boolean, command: T.class_of(SystemCommand), ).void } def install_phase( adopt: false, auto_updates: false, force: false, verbose: false, predecessor: nil, successor: nil, reinstall: false, command: SystemCommand ) super return if target.ascend.none? { OS::Mac.system_dir?(it) } odebug "Fixing up '#{target}' permissions for installation to '#{target.parent}'" # Ensure that globally installed applications can be accessed by all users. # We shell out to `chmod` instead of using `FileUtils.chmod` so that using `+X` works correctly. command.run!("chmod", args: ["-R", "a+rX", target], sudo: !target.writable?) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/artifact.rb000066400000000000000000000021251517265720000247440ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Generic artifact corresponding to the `artifact` stanza. class Artifact < Moved sig { override.returns(String) } def self.english_name "Generic Artifact" end sig { override.params( cask: Cask, source: T.any(String, Pathname), options: T.untyped, # required due to https://github.com/sorbet/sorbet/issues/10114 ).returns(T.attached_class) } def self.from_args(cask, source, options = nil) raise CaskInvalidError.new(cask.token, "No source provided for #{english_name}.") if source.blank? unless options&.key?(:target) raise CaskInvalidError.new(cask.token, "#{english_name} '#{source}' requires a target.") end new(cask, source, **options) end sig { override.params(target: T.any(String, Pathname), base_dir: T.nilable(Pathname)).returns(Pathname) } def resolve_target(target, base_dir: nil) super end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/audio_unit_plugin.rb000066400000000000000000000003401517265720000266620ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `audio_unit_plugin` stanza. class AudioUnitPlugin < Moved end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/bashcompletion.rb000066400000000000000000000012531517265720000261570ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/shellcompletion" module Cask module Artifact # Artifact corresponding to the `bash_completion` stanza. class BashCompletion < ShellCompletion sig { override.params(target: T.any(String, Pathname), base_dir: T.nilable(Pathname)).returns(Pathname) } def resolve_target(target, base_dir: nil) name = if File.extname(target).nil? target else new_name = File.basename(target, File.extname(target)) odebug "Renaming completion #{target} to #{new_name}" new_name end config.bash_completion/name end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/binary.rb000066400000000000000000000013121517265720000244300ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/symlinked" module Cask module Artifact # Artifact corresponding to the `binary` stanza. class Binary < Symlinked sig { override.params( force: T::Boolean, adopt: T::Boolean, command: T.class_of(SystemCommand), _options: T.anything, ).void } def link(force: false, adopt: false, command: SystemCommand, **_options) super return if source.executable? if source.writable? FileUtils.chmod "+x", source else command.run!("chmod", args: ["+x", source], sudo: true) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/colorpicker.rb000066400000000000000000000003261517265720000254640ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `colorpicker` stanza. class Colorpicker < Moved end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/dictionary.rb000066400000000000000000000003241517265720000253130ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `dictionary` stanza. class Dictionary < Moved end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/fishcompletion.rb000066400000000000000000000012711517265720000261730ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/shellcompletion" module Cask module Artifact # Artifact corresponding to the `fish_completion` stanza. class FishCompletion < ShellCompletion sig { override.params(target: T.any(String, Pathname), base_dir: T.nilable(Pathname)).returns(Pathname) } def resolve_target(target, base_dir: nil) name = if target.to_s.end_with? ".fish" target else new_name = "#{File.basename(target, File.extname(target))}.fish" odebug "Renaming completion #{target} to #{new_name}" new_name end config.fish_completion/name end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/font.rb000066400000000000000000000003101517265720000241070ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `font` stanza. class Font < Moved end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/generated_completion.rb000066400000000000000000000123361517265720000273430ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_artifact" require "cask/artifact/bashcompletion" require "cask/artifact/fishcompletion" require "cask/artifact/zshcompletion" require "extend/hash/keys" require "utils/shell_completion" module Cask module Artifact # Artifact corresponding to the `generate_completions_from_executable` stanza. class GeneratedCompletion < AbstractArtifact SUPPORTED_SHELLS = T.let([:bash, :zsh, :fish, :pwsh].freeze, T::Array[Symbol]) sig { override.returns(Symbol) } def self.dsl_key :generate_completions_from_executable end sig { params( cask: Cask, args: T.any(Pathname, String), base_name: T.nilable(String), shell_parameter_format: T.nilable(T.any(Symbol, String)), shells: T.nilable(T::Array[Symbol]), ).returns(T.attached_class) } def self.from_args(cask, *args, base_name: nil, shell_parameter_format: nil, shells: nil) raise CaskInvalidError.new(cask.token, "'#{dsl_key}' requires at least one command") if args.empty? commands = args.to_a resolved_shells = shells || ::Utils::ShellCompletion.default_completion_shells(shell_parameter_format) unsupported_shells = resolved_shells - SUPPORTED_SHELLS unless unsupported_shells.empty? raise CaskInvalidError.new( cask.token, "'#{dsl_key}' does not support shell(s): #{unsupported_shells.join(", ")}", ) end new( cask, commands, base_name:, shell_parameter_format:, shells: resolved_shells, ) end sig { params( cask: Cask, commands: T::Array[T.any(Pathname, String)], base_name: T.nilable(String), shell_parameter_format: T.nilable(T.any(Symbol, String)), shells: T::Array[Symbol], ).void } def initialize(cask, commands, base_name:, shell_parameter_format:, shells:) super(cask, *commands, base_name:, shell_parameter_format:, shells:) @commands = commands @base_name = base_name @shell_parameter_format = shell_parameter_format @shells = shells @resolved_base_name = T.let(nil, T.nilable(String)) end sig { returns(T::Array[T.any(Pathname, String)]) } attr_reader :commands sig { returns(T.nilable(String)) } attr_reader :base_name sig { returns(T.nilable(T.any(Symbol, String))) } attr_reader :shell_parameter_format sig { returns(T::Array[Symbol]) } attr_reader :shells sig { override.returns(String) } def summarize "#{commands.join(" ")} (base_name: #{resolved_base_name}, shells: #{shells.join(", ")})" end sig { params(_options: T.untyped).void } def install_phase(**_options) executable = staged_path_join_executable(T.must(commands.first)) shells.each do |shell| popen_read_env = { "SHELL" => shell.to_s } shell_parameter = ::Utils::ShellCompletion.completion_shell_parameter( shell_parameter_format, shell, executable.to_s, popen_read_env ) script_path = completion_script_path(shell) script_path.dirname.mkpath script_path.write(::Utils::ShellCompletion.generate_completion_output( [executable, *commands[1..]], shell_parameter, popen_read_env, )) rescue => e opoo "Failed to generate #{shell} completions from #{executable}: #{e}" end end sig { params(command: T.class_of(SystemCommand), _options: T.untyped).void } def uninstall_phase(command: SystemCommand, **_options) shells.each do |shell| path = completion_script_path(shell) next unless path.exist? Utils.gain_permissions_remove(path, command:) rescue => e opoo "Failed to remove #{shell} generated completions: #{e}" end end private sig { returns(String) } def resolved_base_name @resolved_base_name ||= T.let(begin executable = staged_path_join_executable(T.must(commands.first)) name = base_name || File.basename(executable.to_s) name = cask.token if name.empty? name end, T.nilable(String)) @resolved_base_name end sig { params(shell: Symbol).returns(Pathname) } def completion_script_path(shell) case shell when :bash BashCompletion.new(cask, resolved_base_name).resolve_target(resolved_base_name) when :zsh ZshCompletion.new(cask, resolved_base_name).resolve_target(resolved_base_name) when :fish FishCompletion.new(cask, resolved_base_name).resolve_target(resolved_base_name) when :pwsh HOMEBREW_PREFIX/"share/pwsh/completions"/"_#{resolved_base_name}.ps1" else raise ArgumentError, "unsupported shell: #{shell}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/input_method.rb000066400000000000000000000003271517265720000256500ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `input_method` stanza. class InputMethod < Moved end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/installer.rb000066400000000000000000000063051517265720000251500ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_artifact" require "extend/hash/keys" module Cask module Artifact # Artifact corresponding to the `installer` stanza. class Installer < AbstractArtifact VALID_KEYS = T.let(Set.new([ :manual, :script, ]).freeze, T::Set[Symbol]) sig { params(command: T.class_of(SystemCommand), _options: T.anything).void } def install_phase(command: SystemCommand, **_options) if manual_install puts <<~EOS Cask #{cask} only provides a manual installer. To run it and complete the installation: open #{cask.staged_path.join(path).to_s.shellescape} EOS else ohai "Running #{self.class.dsl_key} script '#{path}'" executable_path = staged_path_join_executable(path) command.run!( executable_path, **args, env: { "PATH" => PATH.new( HOMEBREW_PREFIX/"bin", HOMEBREW_PREFIX/"sbin", ENV.fetch("PATH") ) }, reset_uid: !args[:sudo], ) end end sig { params(cask: Cask, args: T.untyped).returns(T.attached_class) } def self.from_args(cask, **args) raise CaskInvalidError.new(cask, "'installer' stanza requires an argument.") if args.empty? if args.key?(:script) && !args[:script].respond_to?(:key?) if args.key?(:executable) raise CaskInvalidError.new(cask, "'installer' stanza gave arguments for both :script and :executable.") end args[:executable] = args[:script] args.delete(:script) args = { script: args } end if args.keys.count != 1 raise CaskInvalidError.new( cask, "invalid 'installer' stanza: Only one of #{VALID_KEYS.inspect} is permitted.", ) end args.assert_valid_keys(*VALID_KEYS) new(cask, **args) end sig { returns(Pathname) } attr_reader :path sig { returns(T::Hash[Symbol, T.untyped]) } attr_reader :args sig { returns(T::Boolean) } attr_reader :manual_install sig { params(cask: Cask, args: T.untyped).void } def initialize(cask, **args) super if args.key?(:manual) @path = T.let(Pathname(args[:manual]), Pathname) @args = T.let({}, T::Hash[Symbol, T.untyped]) @manual_install = T.let(true, T::Boolean) else script_path, script_args = self.class.read_script_arguments( args[:script], self.class.dsl_key.to_s, { must_succeed: true, sudo: false }, print_stdout: true ) raise CaskInvalidError.new(cask, "#{self.class.dsl_key} missing executable") if script_path.nil? @path = T.let(Pathname(script_path), Pathname) @args = T.let(script_args, T::Hash[Symbol, T.untyped]) @manual_install = T.let(false, T::Boolean) end end sig { override.returns(String) } def summarize = path.to_s sig { returns(T::Hash[Symbol, T.untyped]) } def to_h { path: }.tap do |h| h[:args] = args unless manual_install end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/internet_plugin.rb000066400000000000000000000003351517265720000263560ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `internet_plugin` stanza. class InternetPlugin < Moved end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/keyboard_layout.rb000066400000000000000000000034341517265720000263500ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `keyboard_layout` stanza. class KeyboardLayout < Moved sig { override.params( adopt: T::Boolean, auto_updates: T.nilable(T::Boolean), force: T::Boolean, verbose: T::Boolean, predecessor: T.nilable(Cask), successor: T.nilable(Cask), reinstall: T::Boolean, command: T.class_of(SystemCommand), ).void } def install_phase(adopt: false, auto_updates: false, force: false, verbose: false, predecessor: nil, successor: nil, reinstall: false, command: SystemCommand) super delete_keyboard_layout_cache(command:) end sig { override.params( skip: T::Boolean, force: T::Boolean, adopt: T::Boolean, verbose: T::Boolean, successor: T.nilable(Cask), upgrade: T::Boolean, reinstall: T::Boolean, command: T.class_of(SystemCommand), ).void } def uninstall_phase(skip: false, force: false, adopt: false, verbose: false, successor: nil, upgrade: false, reinstall: false, command: SystemCommand) super delete_keyboard_layout_cache(command:) end private sig { params(command: T.class_of(SystemCommand)).void } def delete_keyboard_layout_cache(command: SystemCommand) command.run!( "/bin/rm", args: ["-f", "--", "/System/Library/Caches/com.apple.IntlDataCache.le*"], sudo: true, sudo_as_root: true, ) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/manpage.rb000066400000000000000000000021761517265720000245650ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/symlinked" module Cask module Artifact # Artifact corresponding to the `manpage` stanza. class Manpage < Symlinked sig { returns(String) } attr_reader :section sig { override.params( cask: Cask, source: T.any(String, Pathname), _target_hash: T.anything, ).returns(T.attached_class) } def self.from_args(cask, source, _target_hash = nil) section = source.to_s[/\.([1-8]|n|l)(?:\.gz)?$/, 1] raise CaskInvalidError, "'#{source}' is not a valid man page name" unless section new(cask, source, section) end sig { params(cask: Cask, source: T.any(String, Pathname), section: String).void } def initialize(cask, source, section) @section = section super(cask, source) end sig { override.params(target: T.any(String, Pathname), base_dir: T.nilable(Pathname)).returns(Pathname) } def resolve_target(target, base_dir: nil) config.manpagedir.join("man#{section}", target) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/mdimporter.rb000066400000000000000000000022401517265720000253270ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `mdimporter` stanza. class Mdimporter < Moved sig { override.returns(String) } def self.english_name "Spotlight metadata importer" end sig { override.params( adopt: T::Boolean, auto_updates: T.nilable(T::Boolean), force: T::Boolean, verbose: T::Boolean, predecessor: T.nilable(Cask), reinstall: T::Boolean, command: T.class_of(SystemCommand), options: T.anything, ).void } def install_phase(adopt: false, auto_updates: false, force: false, verbose: false, predecessor: nil, reinstall: false, command: SystemCommand, **options) super reload_spotlight(command:, **options) end private sig { params(command: T.class_of(SystemCommand), _options: T.anything).void } def reload_spotlight(command:, **_options) command.run!("/usr/bin/mdimport", args: ["-r", target]) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/moved.rb000066400000000000000000000234201517265720000242620ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/relocated" require "cask/quarantine" module Cask module Artifact # Superclass for all artifacts that are installed by moving them to the target location. class Moved < Relocated sig { returns(String) } def self.english_description "#{english_name}s" end sig { overridable.params( adopt: T::Boolean, auto_updates: T.nilable(T::Boolean), force: T::Boolean, verbose: T::Boolean, predecessor: T.nilable(Cask), successor: T.nilable(Cask), reinstall: T::Boolean, command: T.class_of(SystemCommand), ).void } def install_phase(adopt: false, auto_updates: false, force: false, verbose: false, predecessor: nil, successor: nil, reinstall: false, command: SystemCommand) move(adopt:, auto_updates:, force:, verbose:, predecessor:, successor:, reinstall:, command:) end sig { overridable.params( skip: T::Boolean, force: T::Boolean, adopt: T::Boolean, verbose: T::Boolean, successor: T.nilable(Cask), upgrade: T::Boolean, reinstall: T::Boolean, command: T.class_of(SystemCommand), ).void } def uninstall_phase(skip: false, force: false, adopt: false, verbose: false, successor: nil, upgrade: false, reinstall: false, command: SystemCommand) move_back(skip:, force:, adopt:, successor:, command:) end sig { returns(String) } def summarize_installed if target.exist? "#{printable_target} (#{target.abv})" else Formatter.error(printable_target, label: "Missing #{self.class.english_name}") end end private sig { params( adopt: T::Boolean, auto_updates: T.nilable(T::Boolean), force: T::Boolean, verbose: T::Boolean, predecessor: T.nilable(Cask), successor: T.nilable(Cask), reinstall: T::Boolean, command: T.class_of(SystemCommand), ).returns(T.nilable(SystemCommand::Result)) } def move(adopt: false, auto_updates: false, force: false, verbose: false, predecessor: nil, successor: nil, reinstall: false, command: SystemCommand) unless source.exist? raise CaskError, "It seems the #{self.class.english_name} source '#{source}' is not there." end if Utils.path_occupied?(target) if target.directory? && target.children.empty? && matching_artifact?(predecessor) # An upgrade removed the directory contents but left the directory itself (see below). unless source.directory? if target.parent.writable? && !force target.rmdir else Utils.gain_permissions_remove(target, command:) end end else if adopt ohai "Adopting existing #{self.class.english_name} at '#{target}'" unless auto_updates source_plist = Pathname("#{source}/Contents/Info.plist") target_plist = Pathname("#{target}/Contents/Info.plist") same = if source_plist.size? && (source_bundle_version = Homebrew::BundleVersion.from_info_plist(source_plist)) && target_plist.size? && (target_bundle_version = Homebrew::BundleVersion.from_info_plist(target_plist)) if source_bundle_version.short_version == target_bundle_version.short_version if source_bundle_version.version == target_bundle_version.version true else onoe "The bundle version of #{source} is #{source_bundle_version.version} but " \ "is #{target_bundle_version.version} for #{target}!" false end else onoe "The bundle short version of #{source} is #{source_bundle_version.short_version} but " \ "is #{target_bundle_version.short_version} for #{target}!" false end else command.run( "/usr/bin/diff", args: ["--recursive", "--brief", source, target], verbose:, print_stdout: verbose, ).success? end unless same raise CaskError, "It seems the existing #{self.class.english_name} is different from " \ "the one being installed." end end # Remove the source as we don't need to move it to the target location FileUtils.rm_r(source) return post_move(command) end message = "It seems there is already #{self.class.english_article} " \ "#{self.class.english_name} at '#{target}'" raise CaskError, "#{message}." if !force && !adopt opoo "#{message}; overwriting." delete(target, force:, successor:, command:) end end ohai "Moving #{self.class.english_name} '#{source.basename}' to '#{target}'" Utils.gain_permissions_mkpath(target.dirname, command:) unless target.dirname.exist? if target.directory? && Quarantine.app_management_permissions_granted?(app: target, command:) if target.writable? source.children.each { |child| FileUtils.move(child, target/child.basename) } else command.run!("/bin/cp", args: ["-pR", *source.children, target], sudo: true) end Quarantine.copy_xattrs(source, target, command:) FileUtils.rm_r(source) elsif target.dirname.writable? FileUtils.move(source, target) else # default sudo user isn't necessarily able to write to Homebrew's locations # e.g. with runas_default set in the sudoers (5) file. command.run!("/bin/cp", args: ["-pR", source, target], sudo: true) FileUtils.rm_r(source) end post_move(command) end # Performs any actions necessary after the source has been moved to the target location. sig { params(command: T.class_of(SystemCommand)).returns(T.nilable(SystemCommand::Result)) } def post_move(command) FileUtils.ln_sf target, source add_altname_metadata(target, source.basename, command:) end sig { params(cask: T.nilable(Cask)).returns(T::Boolean) } def matching_artifact?(cask) return false unless cask cask.artifacts.any? do |a| a.instance_of?(self.class) && instance_of?(a.class) && a.target == target end end sig { params( skip: T::Boolean, force: T::Boolean, adopt: T::Boolean, command: T.class_of(SystemCommand), successor: T.nilable(Cask), ).void } def move_back(skip: false, force: false, adopt: false, command: SystemCommand, successor: nil) FileUtils.rm source if source.symlink? && source.dirname.join(source.readlink) == target if Utils.path_occupied?(source) message = "It seems there is already #{self.class.english_article} " \ "#{self.class.english_name} at '#{source}'" raise CaskError, "#{message}." if !force && !adopt opoo "#{message}; overwriting." delete(source, force:, successor:, command:) end unless target.exist? return if skip || force raise CaskError, "It seems the #{self.class.english_name} source '#{target}' is not there." end ohai "Backing #{self.class.english_name} '#{target.basename}' up to '#{source}'" source.dirname.mkpath # We need to preserve extended attributes between copies. # This may fail and need sudo if the source has files with restricted permissions. [!source.parent.writable?, true].uniq.each do |sudo| result = command.run( "/bin/cp", args: ["-pR", target, source], must_succeed: sudo, sudo:, ) break if result.success? end delete(target, force:, successor:, command:) end sig { params( target: Pathname, force: T::Boolean, successor: T.nilable(Cask), command: T.class_of(SystemCommand), ).void } def delete(target, force: false, successor: nil, command: SystemCommand) ohai "Removing #{self.class.english_name} '#{target}'" raise CaskError, "Cannot remove undeletable #{self.class.english_name}." if undeletable?(target) return unless Utils.path_occupied?(target) if target.directory? && matching_artifact?(successor) && Quarantine.app_management_permissions_granted?( app: target, command:, ) # If an app folder is deleted, macOS considers the app uninstalled and removes some data. # Remove only the contents to handle this case. target.children.each do |child| Utils.gain_permissions_remove(child, command:) end else Utils.gain_permissions_remove(target, command:) end end sig { params(target: Pathname).returns(T::Boolean) } def undeletable?(target) !target.parent.writable? end end end end require "extend/os/cask/artifact/moved" Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/pkg.rb000066400000000000000000000063301517265720000237320ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "plist" require "utils/user" require "cask/artifact/abstract_artifact" require "extend/hash/keys" module Cask module Artifact # Artifact corresponding to the `pkg` stanza. class Pkg < AbstractArtifact sig { returns(Pathname) } attr_reader :path sig { returns(T::Hash[Symbol, T.untyped]) } attr_reader :stanza_options sig { params(cask: Cask, path: T.any(String, Pathname), stanza_options: T.untyped).returns(T.attached_class) } def self.from_args(cask, path, **stanza_options) stanza_options.assert_valid_keys(:allow_untrusted, :choices) new(cask, path, **stanza_options) end sig { params(cask: Cask, path: T.any(String, Pathname), stanza_options: T.untyped).void } def initialize(cask, path, **stanza_options) super @path = T.let(cask.staged_path.join(path), Pathname) @stanza_options = T.let(stanza_options, T::Hash[Symbol, T.untyped]) end sig { override.returns(String) } def summarize path.relative_path_from(cask.staged_path).to_s end sig { params( command: T.class_of(SystemCommand), verbose: T::Boolean, _options: T.anything, ).void } def install_phase(command: SystemCommand, verbose: false, **_options) run_installer(command:, verbose:) end private sig { params(command: T.class_of(SystemCommand), verbose: T::Boolean).void } def run_installer(command: SystemCommand, verbose: false) ohai "Running installer for #{cask} with `sudo` (which may request your password)..." unless path.exist? pkg = path.relative_path_from(cask.staged_path) pkgs = Pathname.glob(cask.staged_path/"**"/"*.pkg").map { |path| path.relative_path_from(cask.staged_path) } message = "Could not find PKG source file '#{pkg}'" message += ", found #{pkgs.map { |path| "'#{path}'" }.to_sentence} instead" if pkgs.any? message += "." raise CaskError, message end args = [ "-pkg", path, "-target", "/" ] args << "-verboseR" if verbose args << "-allowUntrusted" if stanza_options.fetch(:allow_untrusted, false) with_choices_file do |choices_path| args << "-applyChoiceChangesXML" << choices_path if choices_path env = { "LOGNAME" => User.current, "USER" => User.current, "USERNAME" => User.current, } command.run!( "/usr/sbin/installer", sudo: true, sudo_as_root: true, args:, print_stdout: true, env:, ) end end sig { params(_blk: T.proc.params(choices_path: T.nilable(String)).void) .void } def with_choices_file(&_blk) choices = stanza_options.fetch(:choices, {}) return yield nil if choices.empty? Tempfile.open(["choices", ".xml"]) do |file| file.write Plist::Emit.dump(choices) file.close yield file.path ensure file.unlink end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/postflight_block.rb000066400000000000000000000003671517265720000265120ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_flight_block" module Cask module Artifact # Artifact corresponding to the `postflight` stanza. class PostflightBlock < AbstractFlightBlock end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/preflight_block.rb000066400000000000000000000003651517265720000263110ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_flight_block" module Cask module Artifact # Artifact corresponding to the `preflight` stanza. class PreflightBlock < AbstractFlightBlock end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/prefpane.rb000066400000000000000000000004671517265720000247560ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `prefpane` stanza. class Prefpane < Moved sig { override.returns(String) } def self.english_name "Preference Pane" end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/qlplugin.rb000066400000000000000000000034331517265720000250050ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `qlplugin` stanza. class Qlplugin < Moved sig { override.returns(String) } def self.english_name "Quick Look Plugin" end sig { override.params( adopt: T::Boolean, auto_updates: T.nilable(T::Boolean), force: T::Boolean, verbose: T::Boolean, predecessor: T.nilable(Cask), successor: T.nilable(Cask), reinstall: T::Boolean, command: T.class_of(SystemCommand), options: T.anything, ).void } def install_phase(adopt: false, auto_updates: false, force: false, verbose: false, predecessor: nil, successor: nil, reinstall: false, command: SystemCommand, **options) super reload_quicklook(command:) end sig { override.params( skip: T::Boolean, force: T::Boolean, adopt: T::Boolean, verbose: T::Boolean, successor: T.nilable(Cask), upgrade: T::Boolean, reinstall: T::Boolean, command: T.class_of(SystemCommand), options: T.anything, ).void } def uninstall_phase(skip: false, force: false, adopt: false, verbose: false, successor: nil, upgrade: false, reinstall: false, command: SystemCommand, **options) super reload_quicklook(command:) end private sig { params(command: T.class_of(SystemCommand)).void } def reload_quicklook(command: SystemCommand) command.run!("/usr/bin/qlmanage", args: ["-r"]) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/relocated.rb000066400000000000000000000100641517265720000251120ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_artifact" require "extend/hash/keys" module Cask module Artifact # Superclass for all artifacts which have a source and a target location. class Relocated < AbstractArtifact sig { overridable.params( cask: Cask, source_string: T.any(String, Pathname), target_hash: T.untyped, ).returns(T.attached_class) } def self.from_args(cask, source_string, target_hash = nil) if target_hash raise CaskInvalidError, cask unless target_hash.respond_to?(:keys) target_hash.assert_valid_keys(:target) end target_hash ||= {} new(cask, source_string, **target_hash) end sig { overridable.params(target: T.any(String, Pathname), base_dir: T.nilable(Pathname)).returns(Pathname) } def resolve_target(target, base_dir: config.public_send(self.class.dirmethod)) target = Pathname(target) if target.relative? return target.expand_path if target.descend.first.to_s == "~" return base_dir/target if base_dir end target end sig { params(cask: Cask, source: T.any(String, Pathname), target_hash: T.any(String, Pathname)) .void } def initialize(cask, source, **target_hash) super target = target_hash[:target] @source = T.let(nil, T.nilable(Pathname)) @source_string = T.let(source.to_s, String) @target = T.let(nil, T.nilable(Pathname)) @target_string = T.let(target.to_s, String) end sig { returns(Pathname) } def source @source ||= begin base_path = cask.staged_path base_path = base_path.join(T.must(cask.url).only_path) if cask.url&.only_path.present? base_path.join(@source_string) end end sig { returns(Pathname) } def target @target ||= resolve_target(@target_string.presence || source.basename) end sig { returns(T::Array[T.anything]) } def to_a [@source_string].tap do |ary| ary << { target: @target_string } unless @target_string.empty? end end sig { override.returns(String) } def summarize target_string = @target_string.empty? ? "" : " -> #{@target_string}" "#{@source_string}#{target_string}" end private ALT_NAME_ATTRIBUTE = "com.apple.metadata:kMDItemAlternateNames" private_constant :ALT_NAME_ATTRIBUTE # Try to make the asset searchable under the target name. Spotlight # respects this attribute for many filetypes, but ignores it for App # bundles. Alfred 2.2 respects it even for App bundles. sig { params(file: Pathname, altname: Pathname, command: T.class_of(SystemCommand)).returns(T.nilable(SystemCommand::Result)) } def add_altname_metadata(file, altname, command:) return if altname.to_s.casecmp(file.basename.to_s)&.zero? odebug "Adding #{ALT_NAME_ATTRIBUTE} metadata" altnames = command.run("/usr/bin/xattr", args: ["-p", ALT_NAME_ATTRIBUTE, file], print_stderr: false).stdout.sub(/\A\((.*)\)\Z/, '\1') odebug "Existing metadata is: #{altnames}" altnames.concat(", ") unless altnames.empty? altnames.concat(%Q("#{altname}")) altnames = "(#{altnames})" # Some packages are shipped as u=rx (e.g. Bitcoin Core) command.run!("chmod", args: ["--", "u+rw", file, file.realpath], sudo: !file.writable? || !file.realpath.writable?) command.run!("/usr/bin/xattr", args: ["-w", ALT_NAME_ATTRIBUTE, altnames, file], print_stderr: false, sudo: !file.writable?) end sig { returns(String) } def printable_target target.to_s.sub(/^#{Dir.home}(#{File::SEPARATOR}|$)/, "~/") end end end end require "extend/os/cask/artifact/relocated" Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/screen_saver.rb000066400000000000000000000003271517265720000256300ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `screen_saver` stanza. class ScreenSaver < Moved end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/service.rb000066400000000000000000000003161517265720000246070ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `service` stanza. class Service < Moved end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/shellcompletion.rb000066400000000000000000000006321517265720000263510ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/symlinked" module Cask module Artifact class ShellCompletion < Symlinked sig { override.overridable.params(_: T.any(String, Pathname), base_dir: T.nilable(Pathname)).returns(Pathname) } def resolve_target(_, base_dir: nil) raise CaskInvalidError, "Shell completion without shell info" end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/stage_only.rb000066400000000000000000000013641517265720000253170ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_artifact" module Cask module Artifact # Artifact corresponding to the `stage_only` stanza. class StageOnly < AbstractArtifact sig { params(cask: Cask, args: T.anything, kwargs: T.anything).returns(StageOnly) } def self.from_args(cask, *args, **kwargs) if (args != [true] && args != ["true"]) || kwargs.present? raise CaskInvalidError.new(cask.token, "'stage_only' takes only a single argument: true") end new(cask, true) end sig { returns(T::Array[T::Boolean]) } def to_a [true] end sig { override.returns(String) } def summarize "true" end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/suite.rb000066400000000000000000000006061517265720000243020ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `suite` stanza. class Suite < Moved sig { override.returns(String) } def self.english_name "App Suite" end sig { override.returns(Symbol) } def self.dirmethod :appdir end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/symlinked.rb000066400000000000000000000102301517265720000251420ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/relocated" module Cask module Artifact # Superclass for all artifacts which are installed by symlinking them to the target location. class Symlinked < Relocated sig { returns(String) } def self.link_type_english_name "Symlink" end sig { returns(String) } def self.english_description "#{english_name} #{link_type_english_name}s" end sig { params( force: T::Boolean, adopt: T::Boolean, command: T.class_of(SystemCommand), options: T.anything, ).void } def install_phase(force: false, adopt: false, command: SystemCommand, **options) link(force:, adopt:, command:, **options) end sig { params( command: T.class_of(SystemCommand), _options: T.anything, ).void } def uninstall_phase(command: SystemCommand, **_options) unlink(command:) end sig { returns(String) } def summarize_installed if target.symlink? && target.exist? && target.readlink.exist? "#{printable_target} -> #{target.readlink} (#{target.readlink.abv})" else string = if target.symlink? "#{printable_target} -> #{target.readlink}" else printable_target end Formatter.error(string, label: "Broken Link") end end private sig { overridable.params( force: T::Boolean, adopt: T::Boolean, command: T.class_of(SystemCommand), _options: T.anything, ).void } def link(force: false, adopt: false, command: SystemCommand, **_options) unless source.exist? raise CaskError, "It seems the #{self.class.link_type_english_name.downcase} " \ "source '#{source}' is not there." end if target.exist? message = "It seems there is already #{self.class.english_article} " \ "#{self.class.english_name} at '#{target}'" if (force || adopt) && target.symlink? && (target.realpath == source.realpath || target.realpath.to_s.start_with?("#{cask.caskroom_path}/")) opoo "#{message}; overwriting." Utils.gain_permissions_remove(target, command:) elsif (formula = conflicting_formula) opoo "#{message} from formula #{formula}; skipping link." return else raise CaskError, "#{message}." end end ohai "Linking #{self.class.english_name} '#{source.basename}' to '#{target}'" create_filesystem_link(command) end sig { params(command: T.class_of(SystemCommand)).void } def unlink(command: SystemCommand) return unless target.symlink? ohai "Unlinking #{self.class.english_name} '#{target}'" if (formula = conflicting_formula) odebug "#{target} is from formula #{formula}; skipping unlink." return end Utils.gain_permissions_remove(target, command:) end sig { params(command: T.class_of(SystemCommand)).void } def create_filesystem_link(command) Utils.gain_permissions_mkpath(target.dirname, command:) command.run! "/bin/ln", args: ["--no-dereference", "--force", "--symbolic", source, target], sudo: !target.dirname.writable? end # Check if the target file is a symlink that originates from a formula # with the same name as this cask, indicating a potential conflict sig { returns(T.nilable(String)) } def conflicting_formula if target.symlink? && target.exist? && (match = target.realpath.to_s.match(%r{^#{HOMEBREW_CELLAR}/(?[^/]+)/}o)) match[:formula] end rescue => e # If we can't determine the realpath or any other error occurs, # don't treat it as a conflicting formula file odebug "Error checking for conflicting formula file: #{e}" nil end end end end require "extend/os/cask/artifact/symlinked" Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/uninstall.rb000066400000000000000000000027141517265720000251640ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_uninstall" module Cask module Artifact # Artifact corresponding to the `uninstall` stanza. class Uninstall < AbstractUninstall UPGRADE_REINSTALL_SKIP_DIRECTIVES = [:quit, :signal].freeze sig { params( upgrade: T::Boolean, reinstall: T::Boolean, options: T.anything, ).void } def uninstall_phase(upgrade: false, reinstall: false, **options) raw_on_upgrade = directives[:on_upgrade] on_upgrade_syms = case raw_on_upgrade when Symbol [raw_on_upgrade] when Array raw_on_upgrade.map(&:to_sym) else [] end on_upgrade_set = on_upgrade_syms.to_set filtered_directives = ORDERED_DIRECTIVES.filter do |directive_sym| next false if directive_sym == :rmdir if (upgrade || reinstall) && UPGRADE_REINSTALL_SKIP_DIRECTIVES.include?(directive_sym) && on_upgrade_set.exclude?(directive_sym) next false end true end filtered_directives.each do |directive_sym| dispatch_uninstall_directive(directive_sym, **options) end end sig { params(options: T.anything).void } def post_uninstall_phase(**options) dispatch_uninstall_directive(:rmdir, **options) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/vst3_plugin.rb000066400000000000000000000004701517265720000254250ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `vst3_plugin` stanza. class Vst3Plugin < Moved sig { override.returns(String) } def self.english_name "VST3 Plugin" end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/vst_plugin.rb000066400000000000000000000004651517265720000253460ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/moved" module Cask module Artifact # Artifact corresponding to the `vst_plugin` stanza. class VstPlugin < Moved sig { override.returns(String) } def self.english_name "VST Plugin" end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/zap.rb000066400000000000000000000005501517265720000237410ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/abstract_uninstall" module Cask module Artifact # Artifact corresponding to the `zap` stanza. class Zap < AbstractUninstall sig { params(options: T.anything).void } def zap_phase(**options) dispatch_uninstall_directives(**options) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact/zshcompletion.rb000066400000000000000000000012601517265720000260440ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/shellcompletion" module Cask module Artifact # Artifact corresponding to the `zsh_completion` stanza. class ZshCompletion < ShellCompletion sig { override.params(target: T.any(String, Pathname), base_dir: T.nilable(Pathname)).returns(Pathname) } def resolve_target(target, base_dir: nil) name = if target.to_s.start_with? "_" target else new_name = "_#{File.basename(target, File.extname(target))}" odebug "Renaming completion #{target} to #{new_name}" new_name end config.zsh_completion/name end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/artifact_set.rb000066400000000000000000000010501517265720000240160ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask # Sorted set containing all cask artifacts. class ArtifactSet < ::Set extend T::Generic Elem = type_member(:out) { { fixed: Artifact::AbstractArtifact } } sig { params(block: T.nilable(T.proc.params(arg0: Elem).returns(T.untyped))).void } def each(&block) return enum_for(T.must(__method__)) { size } unless block to_a.each(&block) self end sig { returns(T::Array[Artifact::AbstractArtifact]) } def to_a super.sort end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/audit.rb000066400000000000000000001362371517265720000224740ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/denylist" require "cask/download" require "cask/installer" require "cask/quarantine" require "digest" require "livecheck/livecheck" require "source_location" require "system_command" require "utils/backtrace" require "formula_name_cask_token_auditor" require "utils/curl" require "utils/shared_audits" require "utils/output" module Cask # Audit a cask for various problems. class Audit include SystemCommand::Mixin include ::Utils::Curl include ::Utils::Output::Mixin Error = T.type_alias do { message: T.nilable(String), location: T.nilable(Homebrew::SourceLocation), corrected: T::Boolean, } end sig { returns(Cask) } attr_reader :cask sig { returns(T.nilable(Download)) } attr_reader :download sig { params( cask: ::Cask::Cask, download: T::Boolean, quarantine: T::Boolean, online: T.nilable(T::Boolean), strict: T.nilable(T::Boolean), signing: T.nilable(T::Boolean), new_cask: T.nilable(T::Boolean), only: T::Array[String], except: T::Array[String] ).void } def initialize( cask, download: false, quarantine: false, online: nil, strict: nil, signing: nil, new_cask: nil, only: [], except: [] ) # `new_cask` implies `online`, `strict` and `signing` online = new_cask if online.nil? strict = new_cask if strict.nil? signing = new_cask if signing.nil? # `online` and `signing` imply `download` download ||= online || signing @cask = cask @download = T.let(nil, T.nilable(Download)) @download = Download.new(cask, quarantine:) if download @online = online @strict = strict @signing = signing @new_cask = new_cask @only = only @except = except @livecheck_result = T.let(nil, T.nilable(T.any(T::Boolean, Symbol))) end sig { returns(T::Boolean) } def new_cask? = !!@new_cask sig { returns(T::Boolean) } def online? =!!@online sig { returns(T::Boolean) } def signing? = !!@signing sig { returns(T::Boolean) } def strict? = !!@strict sig { returns(::Cask::Audit) } def run! only_audits = @only except_audits = @except private_methods.map(&:to_s).grep(/^audit_/).each do |audit_method_name| name = audit_method_name.delete_prefix("audit_") next if !only_audits.empty? && only_audits.exclude?(name) next if except_audits.include?(name) send(audit_method_name) end self rescue => e odebug e, ::Utils::Backtrace.clean(e) add_error "exception while auditing #{cask}: #{e.message}" self end sig { returns(T::Array[Error]) } def errors @errors ||= T.let([], T.nilable(T::Array[Error])) end sig { returns(T::Boolean) } def errors? errors.any? end sig { returns(T::Boolean) } def success? !errors? end sig { params( message: T.nilable(String), location: T.nilable(Homebrew::SourceLocation), strict_only: T::Boolean, ).void } def add_error(message, location: nil, strict_only: false) # Only raise non-critical audits if the user specified `--strict`. return if strict_only && !@strict errors << { message:, location:, corrected: false } end sig { returns(T.nilable(String)) } def result Formatter.error("failed") if errors? end sig { returns(T.nilable(String)) } def summary return if success? summary = ["audit for #{cask}: #{result}"] errors.each do |error| summary << " #{Formatter.error("-")} #{error[:message]}" end summary.join("\n") end private sig { void } def audit_untrusted_pkg odebug "Auditing pkg stanza: allow_untrusted" return if @cask.sourcefile_path.nil? tap = @cask.tap return if tap.nil? return if tap.user != "Homebrew" return if cask.artifacts.none? { |k| k.is_a?(Artifact::Pkg) && k.stanza_options.key?(:allow_untrusted) } add_error "allow_untrusted is not permitted in official Homebrew Cask taps" end sig { void } def audit_stanza_requires_uninstall odebug "Auditing stanzas which require an uninstall" return if cask.artifacts.none? { |k| k.is_a?(Artifact::Pkg) || k.is_a?(Artifact::Installer) } return if cask.artifacts.any?(Artifact::Uninstall) add_error "installer and pkg stanzas require an uninstall stanza" end sig { void } def audit_single_pre_postflight odebug "Auditing preflight and postflight stanzas" if cask.artifacts.count { |k| k.is_a?(Artifact::PreflightBlock) && k.directives.key?(:preflight) } > 1 add_error "only a single preflight stanza is allowed" end count = cask.artifacts.count do |k| k.is_a?(Artifact::PostflightBlock) && k.directives.key?(:postflight) end return if count <= 1 add_error "only a single postflight stanza is allowed" end sig { void } def audit_single_uninstall_zap odebug "Auditing single uninstall_* and zap stanzas" count = cask.artifacts.count do |k| k.is_a?(Artifact::PreflightBlock) && k.directives.key?(:uninstall_preflight) end add_error "only a single uninstall_preflight stanza is allowed" if count > 1 count = cask.artifacts.count do |k| k.is_a?(Artifact::PostflightBlock) && k.directives.key?(:uninstall_postflight) end add_error "only a single uninstall_postflight stanza is allowed" if count > 1 return if cask.artifacts.count { |k| k.is_a?(Artifact::Zap) } <= 1 add_error "only a single zap stanza is allowed" end sig { void } def audit_required_stanzas odebug "Auditing required stanzas" [:version, :sha256, :url, :homepage].each do |sym| add_error "a #{sym} stanza is required" unless cask.send(sym) end add_error "at least one name stanza is required" if cask.name.empty? # TODO: specific DSL knowledge should not be spread around in various files like this rejected_artifacts = [:uninstall, :zap] installable_artifacts = cask.artifacts.reject { |k| rejected_artifacts.include?(k) } add_error "at least one activatable artifact stanza is required" if installable_artifacts.empty? end sig { void } def audit_description # Fonts seldom benefit from descriptions and requiring them disproportionately # increases the maintenance burden. return if cask.tap == "homebrew/cask" && cask.token.include?("font-") add_error("Cask should have a description. Please add a `desc` stanza.", strict_only: true) if cask.desc.blank? end sig { void } def audit_version_special_characters return unless cask.version return if cask.version.latest? raw_version = cask.version.raw_version return if raw_version.exclude?(":") && raw_version.exclude?("/") add_error "version should not contain colons or slashes" end sig { void } def audit_no_string_version_latest return unless cask.version odebug "Auditing version :latest does not appear as a string ('latest')" return if cask.version.raw_version != "latest" add_error "you should use version :latest instead of version 'latest'" end sig { void } def audit_sha256_no_check_if_latest return unless cask.sha256 return unless cask.version odebug "Auditing sha256 :no_check with version :latest" return unless cask.version.latest? return if cask.sha256 == :no_check add_error "you should use sha256 :no_check when version is :latest" end sig { void } def audit_sha256_no_check_if_unversioned return unless cask.sha256 return if cask.sha256 == :no_check return unless cask.url&.unversioned? add_error "Use `sha256 :no_check` when URL is unversioned." end sig { void } def audit_sha256_actually_256 return unless cask.sha256 odebug "Auditing sha256 string is a legal SHA-256 digest" return unless cask.sha256.is_a?(Checksum) return if cask.sha256.length == 64 && cask.sha256[/^[0-9a-f]+$/i] add_error "sha256 string must be of 64 hexadecimal characters" end sig { void } def audit_sha256_invalid return unless cask.sha256 odebug "Auditing sha256 is not a known invalid value" empty_sha256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" return if cask.sha256 != empty_sha256 add_error "cannot use the sha256 for an empty string: #{empty_sha256}" end sig { void } def audit_latest_with_livecheck return unless cask.version&.latest? return unless cask.livecheck_defined? return if cask.livecheck.skip? add_error "Casks with a `livecheck` should not use `version :latest`." end sig { void } def audit_latest_with_auto_updates return unless cask.version&.latest? return unless cask.auto_updates add_error "Casks with `version :latest` should not use `auto_updates`." end LIVECHECK_REFERENCE_URL = "https://docs.brew.sh/Cask-Cookbook#stanza-livecheck" private_constant :LIVECHECK_REFERENCE_URL sig { void } def audit_hosting_with_livecheck return if cask.deprecated? || cask.disabled? return if cask.version&.latest? return if (url = cask.url).nil? return if cask.livecheck_defined? return if audit_livecheck_version == :auto_detected add_livecheck = "please add a livecheck. See #{Formatter.url(LIVECHECK_REFERENCE_URL)}" case url.to_s when %r{sourceforge.net/(\S+)} return unless online? add_error "Download is hosted on SourceForge, #{add_livecheck}", location: url.location when %r{dl.devmate.com/(\S+)} add_error "Download is hosted on DevMate, #{add_livecheck}", location: url.location when %r{rink.hockeyapp.net/(\S+)} add_error "Download is hosted on HockeyApp, #{add_livecheck}", location: url.location end end SOURCEFORGE_OSDN_REFERENCE_URL = "https://docs.brew.sh/Cask-Cookbook#sourceforgeosdn-urls" private_constant :SOURCEFORGE_OSDN_REFERENCE_URL sig { void } def audit_download_url_format return if (url = cask.url).nil? odebug "Auditing URL format" return unless bad_sourceforge_url? add_error "SourceForge URL format incorrect. See #{Formatter.url(SOURCEFORGE_OSDN_REFERENCE_URL)}", location: url.location end sig { void } def audit_download_url_is_osdn return if (url = cask.url).nil? return unless bad_osdn_url? add_error "OSDN download urls are disabled.", location: url.location, strict_only: true end VERIFIED_URL_REFERENCE_URL = "https://docs.brew.sh/Cask-Cookbook#when-url-and-homepage-domains-differ-add-verified" private_constant :VERIFIED_URL_REFERENCE_URL sig { void } def audit_unnecessary_verified return unless cask.url return unless verified_present? return unless url_match_homepage? return unless verified_matches_url? add_error "The URL's domain #{Formatter.url(domain)} matches the homepage domain " \ "#{Formatter.url(homepage)}, the 'verified' parameter of the 'url' stanza is unnecessary. " \ "See #{Formatter.url(VERIFIED_URL_REFERENCE_URL)}" end sig { void } def audit_missing_verified return unless cask.url return if file_url? return if url_match_homepage? return if verified_present? add_error "The URL's domain #{Formatter.url(domain)} does not match the homepage domain " \ "#{Formatter.url(homepage)}, a 'verified' parameter has to be added to the 'url' stanza. " \ "See #{Formatter.url(VERIFIED_URL_REFERENCE_URL)}" end sig { void } def audit_no_match return if (url = cask.url).nil? return unless verified_present? return if verified_matches_url? add_error "Verified URL #{Formatter.url(url_from_verified)} does not match URL " \ "#{Formatter.url(strip_url_scheme(url.to_s))}. " \ "See #{Formatter.url(VERIFIED_URL_REFERENCE_URL)}", location: url.location end sig { void } def audit_generic_artifacts cask.artifacts.grep(Artifact::Artifact).each do |artifact| unless artifact.target.absolute? add_error "target must be absolute path for #{artifact.class.english_name} #{artifact.source}" end end end sig { void } def audit_languages @cask.languages.each do |language| Locale.parse(language) rescue Locale::ParserError add_error "Locale '#{language}' is invalid." end end sig { void } def audit_token token_auditor = Homebrew::FormulaNameCaskTokenAuditor.new(cask.token) return if (errors = token_auditor.errors).none? add_error "Cask token '#{cask.token}' must not contain #{errors.to_sentence(two_words_connector: " or ", last_word_connector: " or ")}." end sig { void } def audit_token_conflicts Homebrew.with_no_api_env do return unless core_formula_names.include?(cask.token) add_error("cask token conflicts with an existing homebrew/core formula: #{Formatter.url(core_formula_url)}") end end sig { void } def audit_token_bad_words return unless new_cask? token = cask.token add_error "cask token contains .app" if token.end_with? ".app" match_data = /-(?alpha|beta|rc|release-candidate)$/.match(cask.token) if match_data && cask.tap&.official? add_error "cask token contains version designation '#{match_data[:designation]}'" end add_error("cask token mentions launcher", strict_only: true) if token.end_with? "launcher" add_error("cask token mentions desktop", strict_only: true) if token.end_with? "desktop" add_error("cask token mentions platform", strict_only: true) if token.end_with? "mac", "osx", "macos" add_error("cask token mentions architecture", strict_only: true) if token.end_with? "x86", "32_bit", "x86_64", "64_bit" frameworks = %w[cocoa qt gtk wx java] return if frameworks.include?(token) || !token.end_with?(*frameworks) add_error("cask token mentions framework", strict_only: true) end sig { void } def audit_download return if (download = self.download).blank? || (url = cask.url).nil? begin download.fetch rescue => e add_error "download not possible: #{e}", location: url.location end end sig { void } def audit_livecheck_unneeded_long_version return if cask.version.nil? || (url = cask.url).nil? return if cask.livecheck.strategy != :sparkle return unless cask.version.csv.second return if cask.url.to_s.include? cask.version.csv.second return if cask.version.csv.third.present? && cask.url.to_s.include?(cask.version.csv.third) add_error "Download does not require additional version components. Use `&:short_version` in the livecheck", location: url.location, strict_only: true end sig { void } def audit_signing return if download.blank? url = cask.url return if url.nil? return if !cask.tap&.official? && !signing? return if cask.deprecated? && cask.deprecation_reason != :fails_gatekeeper_check unless Quarantine.available? odebug "Quarantine support is not available, skipping signing audit" return end odebug "Auditing signing" is_in_skiplist = cask.tap&.audit_exception(:signing_audit_skiplist, cask.token, Homebrew::SimulateSystem.current_arch.to_s) || cask.tap&.audit_exception(:signing_audit_skiplist, cask.token, "all") extract_artifacts(include_manual_installers: true) do |artifacts, tmpdir| is_container = artifacts.any? do |artifact| artifact.is_a?(Artifact::App) || artifact.is_a?(Artifact::Pkg) || (artifact.is_a?(Artifact::Installer) && [".app", ".pkg"].include?(artifact.path.extname.downcase)) end any_signing_failure = artifacts.any? do |artifact| next false if artifact.is_a?(Artifact::Binary) && is_container == true artifact_path = case artifact when Artifact::Pkg, Artifact::Installer artifact.path else artifact.source end artifact_path = artifact_path.relative_path_from(cask.staged_path) if artifact_path.absolute? path = tmpdir/artifact_path unless Quarantine.detect(path) odebug "#{path} does not have quarantine attributes, skipping signing audit" next false end result = case artifact when Artifact::Pkg system_command("spctl", args: ["--assess", "--type", "install", path], print_stderr: false) when Artifact::App next opoo "gktool not found, skipping app signing audit" unless which("gktool") system_command("gktool", args: ["scan", path], print_stderr: false) when Artifact::Installer if artifact.path.extname.downcase == ".app" next opoo "gktool not found, skipping app signing audit" unless which("gktool") system_command("gktool", args: ["scan", path], print_stderr: false) elsif artifact.path.extname.downcase == ".pkg" system_command("spctl", args: ["--assess", "--type", "install", path], print_stderr: false) else next false end when Artifact::Binary # Shell scripts cannot be signed, so we skip them next false if path.text_executable? system_command("codesign", args: ["--verify", "-R=notarized", "--check-notarization", path], print_stderr: false) else add_error "Unknown artifact type: #{artifact.class}", location: url.location next end next false if result.success? next true if cask.deprecated? && cask.deprecation_reason == :fails_gatekeeper_check next true if is_in_skiplist signing_failure_message = <<~EOS Signature verification failed: #{result.merged_output} EOS if cask.tap&.official? signing_failure_message += <<~EOS The homebrew/cask tap requires all casks to be signed and notarized by Apple. Please contact the upstream developer and ask them to sign and notarize their software. EOS end add_error signing_failure_message true end return if any_signing_failure add_error "Cask is in the signing audit skiplist, but does not need to be skipped!" if is_in_skiplist return unless cask.deprecated? return if cask.deprecation_reason != :fails_gatekeeper_check add_error <<~EOS Cask is deprecated because it failed Gatekeeper checks but all artifacts now pass! Remove the deprecate/disable stanza or update the deprecate/disable reason. EOS end end sig { params( include_manual_installers: T::Boolean, _block: T.nilable(T.proc.params( arg0: T::Array[T.any(Artifact::Installer, Artifact::Pkg, Artifact::Relocated)], arg1: Pathname, ).void), ).void } def extract_artifacts(include_manual_installers: false, &_block) return unless online? return if (download = self.download).nil? artifacts = cask.artifacts.select do |artifact| artifact.is_a?(Artifact::Pkg) || artifact.is_a?(Artifact::App) || artifact.is_a?(Artifact::Binary) || (include_manual_installers && artifact.is_a?(Artifact::Installer) && artifact.manual_install && [".app", ".pkg"].include?(artifact.path.extname.downcase)) end if @artifacts_extracted && @tmpdir yield artifacts, @tmpdir if block_given? return end return if artifacts.empty? @tmpdir ||= T.let(Pathname(Dir.mktmpdir("cask-audit", HOMEBREW_TEMP)), T.nilable(Pathname)) # Clean up tmp dir when @tmpdir object is destroyed ObjectSpace.define_finalizer( @tmpdir, proc { FileUtils.remove_entry(@tmpdir) }, ) ohai "Downloading and extracting artifacts" downloaded_path = download.fetch primary_container = UnpackStrategy.detect(downloaded_path, type: @cask.container&.type, merge_xattrs: true) return if primary_container.nil? # If the container has any dependencies we need to install them or unpacking will fail. if primary_container.dependencies.any? install_options = { show_header: true, installed_as_dependency: true, installed_on_request: false, verbose: false, }.compact Homebrew::Install.perform_preinstall_checks_once formula_installers = primary_container.dependencies.filter_map do |dep| next unless dep.is_a?(Formula) next if dep.linked? FormulaInstaller.new( dep, **install_options, ) end valid_formula_installers = Homebrew::Install.fetch_formulae(formula_installers) formula_installers.each do |fi| next unless valid_formula_installers.include?(fi) fi.install fi.finish end end # Extract the container to the temporary directory. primary_container.extract_nestedly(to: @tmpdir, basename: downloaded_path.basename, verbose: false) if (nested_container = @cask.container&.nested) FileUtils.chmod_R "+rw", @tmpdir/nested_container, force: true, verbose: false UnpackStrategy.detect(@tmpdir/nested_container, merge_xattrs: true) .extract_nestedly(to: @tmpdir, verbose: false) end # Propagate quarantine attributes from the downloaded file to extracted contents. # This is necessary because some extraction tools (like 7zr) don't preserve xattrs. Quarantine.propagate(from: downloaded_path, to: @tmpdir) if Quarantine.detect(downloaded_path) # Process rename operations after extraction # Create a temporary installer to process renames in the audit directory temp_installer = Installer.new(@cask) temp_installer.process_rename_operations(target_dir: @tmpdir) # Set the flag to indicate that extraction has occurred. @artifacts_extracted = T.let(true, T.nilable(TrueClass)) # Yield the artifacts and temp directory to the block if provided. yield artifacts, @tmpdir if block_given? end sig { void } def audit_rosetta return if (url = cask.url).nil? return unless online? # Rosetta 2 is only for ARM-capable macOS versions, which are Big Sur (11.x) and later return if Homebrew::SimulateSystem.current_arch != :arm return if MacOSVersion::SYMBOLS.fetch(Homebrew::SimulateSystem.current_os, "10") < "11" return if cask.depends_on.macos&.maximum_version.to_s < "11" odebug "Auditing Rosetta 2 requirement" extract_artifacts do |artifacts, tmpdir| is_container = artifacts.any? { |a| a.is_a?(Artifact::App) || a.is_a?(Artifact::Pkg) } mentions_rosetta = cask.caveats.include?("requires Rosetta 2") requires_intel = cask.depends_on.arch&.any? { |arch| arch[:type] == :intel } artifacts_to_test = artifacts.filter do |artifact| next false if !artifact.is_a?(Artifact::App) && !artifact.is_a?(Artifact::Binary) next false if artifact.is_a?(Artifact::Binary) && is_container true end next if artifacts_to_test.blank? any_requires_rosetta = artifacts_to_test.any? do |artifact| artifact = T.cast(artifact, T.any(Artifact::App, Artifact::Binary)) path = tmpdir/artifact.source.relative_path_from(cask.staged_path) result = case artifact when Artifact::App files = Dir[path/"Contents/MacOS/*"].select do |f| File.executable?(f) && !File.directory?(f) && !f.end_with?(".dylib") end add_error "No binaries in App: #{artifact.source}", location: url.location if files.empty? main_binary = get_plist_main_binary(path) main_binary ||= files.fetch(0) system_command("lipo", args: ["-archs", main_binary], print_stderr: false) when Artifact::Binary binary_path = path.to_s.gsub(cask.appdir, tmpdir.to_s) system_command("lipo", args: ["-archs", binary_path], print_stderr: true) else T.absurd(artifact) end # binary stanza can contain shell scripts, so we just continue if lipo fails. next false unless result.success? odebug "Architectures: #{result.merged_output}" unless /arm64|x86_64/.match?(result.merged_output) add_error "Artifacts architecture is no longer supported by macOS!", location: url.location next end result.merged_output.exclude?("arm64") && result.merged_output.include?("x86_64") end if any_requires_rosetta if !mentions_rosetta && !requires_intel add_error "At least one artifact requires Rosetta 2 but this is not indicated by the caveats!", location: url.location end elsif mentions_rosetta add_error "No artifacts require Rosetta 2 but the caveats say otherwise!", location: url.location end end end sig { returns(T.nilable(T.any(T::Boolean, Symbol))) } def audit_livecheck_version return @livecheck_result unless @livecheck_result.nil? return unless online? return unless cask.version odebug "Auditing livecheck version" referenced_cask, = Homebrew::Livecheck.resolve_livecheck_reference(cask) # Respect skip conditions for a referenced cask if referenced_cask skip_info = Homebrew::Livecheck::SkipConditions.referenced_skip_information( referenced_cask, Homebrew::Livecheck.package_or_resource_name(cask), ) end # Respect cask skip conditions (e.g. deprecated, disabled, latest, unversioned) skip_info ||= Homebrew::Livecheck::SkipConditions.skip_information(cask) if skip_info.present? @livecheck_result = :skip return @livecheck_result end result = Homebrew::Livecheck.latest_version( cask, referenced_formula_or_cask: referenced_cask, ) if result throttle = cask.livecheck.throttle throttle_days = cask.livecheck.throttle_days if referenced_cask throttle ||= referenced_cask.livecheck.throttle throttle_days ||= referenced_cask.livecheck.throttle_days end latest_version = (throttle || throttle_days) ? result[:latest_throttled] : result[:latest] end if latest_version && (cask.version.to_s == latest_version.to_s) @livecheck_result = :auto_detected return @livecheck_result end add_error "Version '#{cask.version}' differs from '#{latest_version}' retrieved by livecheck." @livecheck_result = false end sig { void } def audit_min_os return unless online? odebug "Auditing minimum macOS version" bundle_min_os = cask_bundle_min_os sparkle_min_os = cask_sparkle_min_os app_min_os = [bundle_min_os, sparkle_min_os].compact.max debug_messages = [] debug_messages << "from artifact: #{bundle_min_os.to_sym}" if bundle_min_os debug_messages << "from upstream: #{sparkle_min_os.to_sym}" if sparkle_min_os odebug "Detected minimum macOS: #{app_min_os.to_sym} (#{debug_messages.join(" | ")})" if app_min_os return if app_min_os.nil? || app_min_os <= HOMEBREW_MACOS_OLDEST_ALLOWED on_system_block_min_os = cask.on_system_block_min_os depends_on_min_os = cask.depends_on.macos&.minimum_version cask_min_os = [on_system_block_min_os, depends_on_min_os].compact.max debug_messages = [] debug_messages << "from on_system block: #{on_system_block_min_os.to_sym}" if on_system_block_min_os if depends_on_min_os > HOMEBREW_MACOS_OLDEST_ALLOWED debug_messages << "from depends_on stanza: #{depends_on_min_os.to_sym}" end odebug "Declared minimum macOS: #{cask_min_os.to_sym} (#{debug_messages.join(" | ").presence || "default"})" return if cask_min_os.to_sym == app_min_os.to_sym # ignore declared minimum OS < 11.x when auditing as ARM a cask with arch-specific artifacts return if OnSystem.arch_condition_met?(:arm) && cask.on_system_blocks_exist? && cask_min_os.present? && app_min_os < MacOSVersion.new("11") && app_min_os < cask_min_os min_os_definition = if cask_min_os > HOMEBREW_MACOS_OLDEST_ALLOWED definition = if T.must(on_system_block_min_os.to_s <=> depends_on_min_os.to_s).positive? "an on_system block" else "a depends_on stanza" end "#{definition} with a minimum macOS version of #{cask_min_os.to_sym.inspect}" else "no minimum macOS version" end source = T.must(bundle_min_os.to_s <=> sparkle_min_os.to_s).positive? ? "Artifact" : "Upstream" add_error "#{source} defined #{app_min_os.to_sym.inspect} as the minimum macOS version " \ "but the cask declared #{min_os_definition}" end sig { returns(T.nilable(MacOSVersion)) } def cask_sparkle_min_os return unless online? return unless cask.livecheck_defined? return if cask.livecheck.strategy != :sparkle # `Sparkle` strategy blocks that use the `items` argument (instead of # `item`) contain arbitrary logic that ignores/overrides the strategy's # sorting, so we can't identify which item would be first/newest here. return if cask.livecheck.strategy_block.present? && cask.livecheck.strategy_block.parameters[0] == [:opt, :items] content = Homebrew::Livecheck::Strategy.page_content(cask.livecheck.url)[:content] return if content.blank? begin items = Homebrew::Livecheck::Strategy::Sparkle.sort_items( Homebrew::Livecheck::Strategy::Sparkle.filter_items( Homebrew::Livecheck::Strategy::Sparkle.items_from_content(content), ), ) rescue return end return if items.blank? min_os = items[0]&.minimum_system_version&.strip_patch # Big Sur is sometimes identified as 10.16, so we override it to the # expected macOS version (11). min_os = MacOSVersion.new("11") if min_os == "10.16" min_os end sig { returns(T.nilable(MacOSVersion)) } def cask_bundle_min_os return unless online? min_os = T.let(nil, T.untyped) @staged_path ||= T.let(cask.staged_path, T.nilable(Pathname)) extract_artifacts do |artifacts, tmpdir| artifacts.each do |artifact| next if artifact.is_a?(Artifact::Installer) artifact_path = artifact.is_a?(Artifact::Pkg) ? artifact.path : artifact.source path = tmpdir/artifact_path.relative_path_from(cask.staged_path) # Handle .pkg artifacts by expanding and checking Distribution file if artifact.is_a?(Artifact::Pkg) pkg_expanded_dir = tmpdir/"pkg-expanded" begin system_command!("pkgutil", args: ["--expand", path.to_s, pkg_expanded_dir.to_s]) distribution_file = pkg_expanded_dir/"Distribution" if File.exist?(distribution_file) distribution_content = File.read(distribution_file) if (match = distribution_content.match(/[^"]+)"/)) min_os = match[:version] break if min_os end end rescue break end end info_plist_paths = Dir.glob("#{path}/**/Contents/Info.plist") # Ensure the main `Info.plist` file is checked first, as this can # sometimes use the min_os version from a framework instead if info_plist_paths.delete("#{path}/Contents/Info.plist") info_plist_paths.insert(0, "#{path}/Contents/Info.plist") end info_plist_paths.each do |plist_path| next unless File.exist?(plist_path) plist = system_command!("plutil", args: ["-convert", "xml1", "-o", "-", plist_path]).plist min_os = plist["LSMinimumSystemVersion"].presence break if min_os # Get the app bundle path from the plist path app_bundle_path = Pathname(plist_path).dirname.dirname next unless (main_binary = get_plist_main_binary(app_bundle_path)) next if !File.exist?(main_binary) || File.open(main_binary, "rb") { |f| f.read(2) == "#!" } macho = MachO.open(main_binary) min_os = case macho when MachO::MachOFile [ macho[:LC_VERSION_MIN_MACOSX].first&.version_string, macho[:LC_BUILD_VERSION].first&.minos_string, ] when MachO::FatFile # Collect requirements by architecture arch_min_os = { arm: [], intel: [] } macho.machos.each do |slice| macos_reqs = [ slice[:LC_VERSION_MIN_MACOSX].first&.version_string, slice[:LC_BUILD_VERSION].first&.minos_string, ] case slice.cputype when *Hardware::CPU::ARM_ARCHS arch_min_os[:arm].concat(macos_reqs) when *Hardware::CPU::INTEL_ARCHS arch_min_os[:intel].concat(macos_reqs) end end # Only use the requirements for the current architecture arch_min_os.fetch(Homebrew::SimulateSystem.current_arch, []) end.compact.max break if min_os end break if min_os end end begin MacOSVersion.new(min_os).strip_patch rescue MacOSVersion::Error nil end end sig { params(path: Pathname).returns(T.nilable(String)) } def get_plist_main_binary(path) return unless online? plist_path = "#{path}/Contents/Info.plist" return unless File.exist?(plist_path) plist = system_command!("plutil", args: ["-convert", "xml1", "-o", "-", plist_path]).plist binary = plist["CFBundleExecutable"].presence return unless binary binary_path = "#{path}/Contents/MacOS/#{binary}" binary_path if File.exist?(binary_path) && File.executable?(binary_path) end sig { void } def audit_github_prerelease_version return if (url = cask.url).nil? odebug "Auditing GitHub prerelease" user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*}) if online? return if user.nil? || repo.nil? tag = SharedAudits.github_tag_from_url(url.to_s) tag ||= cask.version error = SharedAudits.github_release(user, repo, tag, cask:) add_error error, location: url.location if error end sig { void } def audit_gitlab_prerelease_version return if (url = cask.url).nil? user, repo = get_repo_data(%r{https?://gitlab\.com/([^/]+)/([^/]+)/?.*}) if online? return if user.nil? || repo.nil? odebug "Auditing GitLab prerelease" tag = SharedAudits.gitlab_tag_from_url(url.to_s) tag ||= cask.version error = SharedAudits.gitlab_release(user, repo, tag, cask:) add_error error, location: url.location if error end sig { void } def audit_forgejo_prerelease_version return if (url = cask.url).nil? odebug "Auditing Forgejo prerelease" user, repo = get_repo_data(%r{https?://codeberg\.org/([^/]+)/([^/]+)/?.*}) if online? return if user.nil? || repo.nil? tag = SharedAudits.forgejo_tag_from_url(url.to_s) tag ||= cask.version error = SharedAudits.forgejo_release(user, repo, tag, cask:) add_error error, location: url.location if error end sig { void } def audit_github_repository_archived # Deprecated/disabled casks may have an archived repository. return if cask.deprecated? || cask.disabled? return if (url = cask.url).nil? user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*}) if online? return if user.nil? || repo.nil? metadata = SharedAudits.github_repo_data(user, repo) return if metadata.nil? add_error "GitHub repo is archived", location: url.location if metadata["archived"] end sig { void } def audit_gitlab_repository_archived # Deprecated/disabled casks may have an archived repository. return if cask.deprecated? || cask.disabled? return if (url = cask.url).nil? user, repo = get_repo_data(%r{https?://gitlab\.com/([^/]+)/([^/]+)/?.*}) if online? return if user.nil? || repo.nil? odebug "Auditing GitLab repo archived" metadata = SharedAudits.gitlab_repo_data(user, repo) return if metadata.nil? add_error "GitLab repo is archived", location: url.location if metadata["archived"] end sig { void } def audit_forgejo_repository_archived return if cask.deprecated? || cask.disabled? return if (url = cask.url).nil? user, repo = get_repo_data(%r{https?://codeberg\.org/([^/]+)/([^/]+)/?.*}) if online? return if user.nil? || repo.nil? metadata = SharedAudits.forgejo_repo_data(user, repo) return if metadata.nil? return unless metadata["archived"] add_error "Forgejo repository is archived since #{metadata["archived_at"]}", location: url.location end sig { void } def audit_github_repository return unless new_cask? return if (url = cask.url).nil? user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*}) return if user.nil? || repo.nil? odebug "Auditing GitHub repo" self_submission = self_submission?(user) error = SharedAudits.github(user, repo, self_submission:) add_error error, location: url.location if error end sig { void } def audit_gitlab_repository return unless new_cask? return if (url = cask.url).nil? user, repo = get_repo_data(%r{https?://gitlab\.com/([^/]+)/([^/]+)/?.*}) return if user.nil? || repo.nil? odebug "Auditing GitLab repo" self_submission = self_submission?(user) error = SharedAudits.gitlab(user, repo, self_submission:) add_error error, location: url.location if error end sig { void } def audit_bitbucket_repository return unless new_cask? return if (url = cask.url).nil? user, repo = get_repo_data(%r{https?://bitbucket\.org/([^/]+)/([^/]+)/?.*}) return if user.nil? || repo.nil? odebug "Auditing Bitbucket repo" self_submission = self_submission?(user) error = SharedAudits.bitbucket(user, repo, self_submission:) add_error error, location: url.location if error end sig { void } def audit_forgejo_repository return unless new_cask? return if (url = cask.url).nil? user, repo = get_repo_data(%r{https?://codeberg\.org/([^/]+)/([^/]+)/?.*}) return if user.nil? || repo.nil? odebug "Auditing Forgejo repo" self_submission = self_submission?(user) error = SharedAudits.forgejo(user, repo, self_submission:) add_error error, location: url.location if error end sig { void } def audit_conflicts_with return if !cask.tap&.official? || cask.conflicts_with.nil? Homebrew.with_no_api_env do nonexisting_conflicting_casks = cask.conflicts_with.fetch(:cask, Set.new) - core_cask_tokens nonexisting_conflicting_casks.each do |c| add_error("cask conflicts with non-existing cask `#{c}`") end end end sig { void } def audit_denylist return unless cask.tap&.official? return unless (reason = Denylist.reason(cask.token)) add_error "#{cask.token} is not allowed: #{reason}" end sig { void } def audit_reverse_migration return unless new_cask? return unless cask.tap&.official? return unless cask.tap&.tap_migrations&.key?(cask.token) add_error "#{cask.token} is listed in tap_migrations.json" end sig { void } def audit_homepage_https_availability return unless online? return unless (homepage = cask.homepage) user_agents = if cask.tap&.audit_exception(:simple_user_agent_for_homepage, cask.token) ["curl"] else [:browser, :default] end validate_url_for_https_availability( homepage, SharedAudits::URL_TYPE_HOMEPAGE, user_agents:, check_content: true, strict: strict? ) end sig { void } def audit_url_https_availability return unless online? return unless (url = cask.url) return if url.using validate_url_for_https_availability( url, "binary URL", location: url.location, user_agents: [url.user_agent], referer: url.referer ) end sig { void } def audit_livecheck_https_availability return unless online? return unless cask.livecheck_defined? return unless (url = cask.livecheck.url) return if url.is_a?(Symbol) options = cask.livecheck.options return if options.post_form || options.post_json # Validating HTTPS availability is unnecessary if the check uses HTTPS # and does not fail. if url.start_with?("https:") && audit_livecheck_version != false odebug "Skipping livecheck_https_availability audit (working HTTPS livecheck)" return end odebug "Auditing livecheck HTTPS availability" validate_url_for_https_availability( url, "livecheck URL", check_content: true, user_agents: [:default, :browser] ) end sig { void } def audit_cask_path return unless (tap = cask.tap)&.core_cask_tap? expected_path = tap.new_cask_path(cask.token) return if cask.sourcefile_path.to_s.end_with?(expected_path.to_s) add_error "Cask should be located in '#{expected_path}'" end sig { void } def audit_deprecate_disable error = SharedAudits.check_deprecate_disable_reason(cask) add_error error if error end sig { params( url_to_check: T.any(String, URL), url_type: String, location: T.nilable(Homebrew::SourceLocation), options: T.untyped, ).void } def validate_url_for_https_availability(url_to_check, url_type, location: nil, **options) problem = curl_check_http_content(url_to_check.to_s, url_type, **options) exception = cask.tap&.audit_exception(:secure_connection_audit_skiplist, cask.token, url_to_check.to_s) if problem add_error problem, location: location unless exception elsif exception add_error "#{url_to_check} is in the secure connection audit skiplist but does not need to be skipped", location: end end sig { params(regex: T.any(String, Regexp)).returns(T.nilable(T::Array[String])) } def get_repo_data(regex) return unless online? _, user, repo = *regex.match(cask.url.to_s) _, user, repo = *regex.match(cask.homepage) unless user return if !user || !repo repo.gsub!(/.git$/, "") [user, repo] end sig { params(repo_owner: String).returns(T::Boolean) } def self_submission?(repo_owner) return false if repo_owner.empty? SharedAudits.self_submission_for_repo_owner?(repo_owner) end sig { params(regex: T.any(String, Regexp), valid_formats_array: T::Array[T.any(String, Regexp)]).returns(T::Boolean) } def bad_url_format?(regex, valid_formats_array) return false unless cask.url.to_s.match?(regex) valid_formats_array.none? { |format| cask.url.to_s.match?(format) } end sig { returns(T::Boolean) } def bad_sourceforge_url? bad_url_format?(%r{((downloads|\.dl)\.|//)sourceforge}, [ %r{\Ahttps://sourceforge\.net/projects/[^/]+/files/latest/download\Z}, %r{\Ahttps://downloads\.sourceforge\.net/(?!(project|sourceforge)/)}, ]) end sig { returns(T::Boolean) } def bad_osdn_url? T.must(domain).match?(%r{^(?:\w+\.)*osdn\.jp(?=/|$)}) end sig { returns(T.nilable(String)) } def homepage URI(cask.homepage.to_s).host end sig { returns(T.nilable(String)) } def domain URI(cask.url.to_s).host end sig { returns(T::Boolean) } def url_match_homepage? host = cask.url.to_s host_uri = URI(host) host = if host.match?(/:\d/) && host_uri.port != 80 "#{host_uri.host}:#{host_uri.port}" else host_uri.host end home = homepage return false if home.blank? home.downcase! if (split_host = T.must(host).split(".")).length >= 3 host = T.must(split_host[-2..]).join(".") end if (split_home = home.split(".")).length >= 3 home = T.must(split_home[-2..]).join(".") end host == home end sig { params(url: String).returns(String) } def strip_url_scheme(url) url.sub(%r{^[^:/]+://(www\.)?}, "") end sig { returns(T.nilable(String)) } def url_from_verified return unless (verified_url = T.must(cask.url).verified) strip_url_scheme(verified_url) end sig { returns(T::Boolean) } def verified_matches_url? url_domain, url_path = strip_url_scheme(cask.url.to_s).split("/", 2) verified_domain, verified_path = url_from_verified&.split("/", 2) domains_match = (url_domain == verified_domain) || (verified_domain && url_domain&.end_with?(".#{verified_domain}")) paths_match = !verified_path || url_path&.start_with?(verified_path) (domains_match && paths_match) || false end sig { returns(T::Boolean) } def verified_present? cask.url&.verified.present? end sig { returns(T::Boolean) } def file_url? URI(cask.url.to_s).scheme == "file" end sig { returns(Tap) } def core_tap @core_tap ||= T.let(CoreTap.instance, T.nilable(Tap)) end sig { returns(T::Array[String]) } def core_formula_names core_tap.formula_names end sig { returns(Tap) } def core_cask_tap @core_cask_tap ||= T.let(CoreCaskTap.instance, T.nilable(Tap)) end sig { returns(T::Array[String]) } def core_cask_tokens core_cask_tap.cask_tokens end sig { returns(String) } def core_formula_url formula_path = Formulary.core_path(cask.token) .to_s .delete_prefix(core_tap.path.to_s) "#{core_tap.default_remote}/blob/HEAD#{formula_path}" end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/auditor.rb000066400000000000000000000110731517265720000230230ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/audit" require "utils/output" module Cask # Helper class for auditing all available languages of a cask. class Auditor include ::Utils::Output::Mixin # TODO: use argument forwarding (...) when Sorbet supports it in strict mode sig { params( cask: ::Cask::Cask, audit_download: T::Boolean, audit_online: T.nilable(T::Boolean), audit_strict: T.nilable(T::Boolean), audit_signing: T.nilable(T::Boolean), audit_new_cask: T.nilable(T::Boolean), quarantine: T::Boolean, any_named_args: T::Boolean, language: T.nilable(String), only: T::Array[String], except: T::Array[String] ).returns(T::Set[String]) } def self.audit( cask, audit_download: false, audit_online: nil, audit_strict: nil, audit_signing: nil, audit_new_cask: nil, quarantine: false, any_named_args: false, language: nil, only: [], except: [] ) new( cask, audit_download:, audit_online:, audit_strict:, audit_signing:, audit_new_cask:, quarantine:, any_named_args:, language:, only:, except: ).audit end sig { returns(::Cask::Cask) } attr_reader :cask sig { returns(T.nilable(String)) } attr_reader :language sig { params( cask: ::Cask::Cask, audit_download: T::Boolean, audit_online: T.nilable(T::Boolean), audit_strict: T.nilable(T::Boolean), audit_signing: T.nilable(T::Boolean), audit_new_cask: T.nilable(T::Boolean), quarantine: T::Boolean, any_named_args: T::Boolean, language: T.nilable(String), only: T::Array[String], except: T::Array[String] ).void } def initialize( cask, audit_download: false, audit_online: nil, audit_strict: nil, audit_signing: nil, audit_new_cask: nil, quarantine: false, any_named_args: false, language: nil, only: [], except: [] ) @cask = cask @audit_download = audit_download @audit_online = audit_online @audit_new_cask = audit_new_cask @audit_strict = audit_strict @audit_signing = audit_signing @quarantine = quarantine @any_named_args = any_named_args @language = language @only = only @except = except end LANGUAGE_BLOCK_LIMIT = 10 sig { returns(T::Set[String]) } def audit errors = Set.new if !language && !(blocks = language_blocks).empty? sample_languages = if blocks.length > LANGUAGE_BLOCK_LIMIT && !@audit_new_cask sample_keys = T.must(blocks.keys.sample(LANGUAGE_BLOCK_LIMIT)) ohai "Auditing a sample of available languages for #{cask}: " \ "#{sample_keys.map { |lang| lang[0].to_s }.to_sentence}" blocks.select { |k| sample_keys.include?(k) } else blocks end sample_languages.each_key do |l| audit = audit_languages(l) if audit.summary.present? && output_summary?(audit) ohai "Auditing language: #{l.map { |lang| "'#{lang}'" }.to_sentence}" if output_summary? puts audit.summary end errors += audit.errors end else audit = audit_cask_instance(cask) puts audit.summary if audit.summary.present? && output_summary?(audit) errors += audit.errors end errors end private sig { params(audit: T.nilable(Audit)).returns(T::Boolean) } def output_summary?(audit = nil) return true if @any_named_args return true if @audit_strict return false if audit.nil? audit.errors? end sig { params(languages: T::Array[String]).returns(::Cask::Audit) } def audit_languages(languages) original_config = cask.config begin localized_config = original_config.merge(Config.new(explicit: { languages: })) cask.config = localized_config audit_cask_instance(cask) ensure cask.config = original_config end end sig { params(cask: ::Cask::Cask).returns(::Cask::Audit) } def audit_cask_instance(cask) audit = Audit.new( cask, online: @audit_online, strict: @audit_strict, signing: @audit_signing, new_cask: @audit_new_cask, download: @audit_download, quarantine: @quarantine, only: @only, except: @except, ) audit.run! end sig { returns(T::Hash[T::Array[String], T.proc.returns(T.untyped)]) } def language_blocks cask.instance_variable_get(:@dsl).instance_variable_get(:@language_blocks) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/cache.rb000066400000000000000000000003671517265720000224230ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask # Helper functions for the cask cache. module Cache sig { returns(Pathname) } def self.path @path ||= T.let(HOMEBREW_CACHE/"Cask", T.nilable(Pathname)) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/cask.rb000066400000000000000000000605751517265720000223100ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "bundle_version" require "cask/cask_loader" require "cask/config" require "cask/dsl" require "cask/metadata" require "cask/tab" require "utils/output" require "api_hashable" module Cask # An instance of a cask. class Cask extend Forwardable extend APIHashable extend ::Utils::Output::Mixin include Metadata # The unique identifier for this {Cask}, used to refer to it in commands # and tap paths. # e.g. `firefox` # # @api public sig { returns(String) } attr_reader :token # The configuration of this {Cask}. # # @api internal sig { returns(Config) } attr_reader :config sig { returns(T.nilable(Pathname)) } attr_reader :sourcefile_path sig { returns(T.nilable(String)) } attr_reader :source sig { returns(Config) } attr_reader :default_config sig { returns(T.nilable(CaskLoader::ILoader)) } attr_reader :loader sig { returns(T.nilable(Pathname)) } attr_accessor :download sig { returns(T::Boolean) } attr_accessor :allow_reassignment sig { params(eval_all: T::Boolean).returns(T::Array[Cask]) } def self.all(eval_all: false) if !eval_all && !Homebrew::EnvConfig.eval_all? raise ArgumentError, "Cask::Cask#all cannot be used without `--eval-all` or `HOMEBREW_EVAL_ALL=1`" end # Load core casks from tokens so they load from the API when the core cask is not tapped. tokens_and_files = CoreCaskTap.instance.cask_tokens tokens_and_files += Tap.reject(&:core_cask_tap?).flat_map(&:cask_files) tokens_and_files.filter_map do |token_or_file| CaskLoader.load(token_or_file) rescue CaskUnreadableError => e opoo e.message nil end end # This collides with Kernel#tap, complicating the type signature. # Overload sigs are not supported by Sorbet, otherwise we would use: # sig { params(blk: T.proc.params(arg0: Cask).void).returns(T.self_type) } # sig { params(blk: NilClass).returns(T.nilable(Tap)) } # Using a union type would require casts or type guards at call sites, # so T.untyped is used as the return type instead. sig { params(blk: T.nilable(T.proc.params(arg0: Cask).void)).returns(T.untyped) } def tap(&blk) return super if block_given? # Kernel#tap @tap end sig { params( token: String, sourcefile_path: T.nilable(Pathname), source: T.nilable(String), tap: T.nilable(Tap), loaded_from_api: T::Boolean, loaded_from_internal_api: T::Boolean, api_source: T.nilable(T::Hash[String, T.untyped]), config: T.nilable(Config), allow_reassignment: T::Boolean, loader: T.nilable(CaskLoader::ILoader), block: T.nilable(T.proc.bind(DSL).void), ).void } def initialize(token, sourcefile_path: nil, source: nil, tap: nil, loaded_from_api: false, loaded_from_internal_api: false, api_source: nil, config: nil, allow_reassignment: false, loader: nil, &block) @token = token @sourcefile_path = sourcefile_path @source = source @tap = tap @allow_reassignment = allow_reassignment @loaded_from_api = loaded_from_api @loaded_from_internal_api = loaded_from_internal_api @api_source = api_source @loader = loader # Sorbet has trouble with bound procs assigned to instance variables: # https://github.com/sorbet/sorbet/issues/6843 @block = T.let(block, T.untyped) @default_config = T.let(config || Config.new, Config) @config = T.let(if config_path.exist? Config.from_json(File.read(config_path), ignore_invalid_keys: true) else @default_config end, Config) refresh end sig { returns(T::Boolean) } def loaded_from_api? = @loaded_from_api sig { returns(T::Boolean) } def loaded_from_internal_api? = @loaded_from_internal_api sig { returns(T.nilable(T::Hash[String, T.untyped])) } attr_reader :api_source # An old name for the cask. sig { returns(T::Array[String]) } def old_tokens @old_tokens ||= T.let( if (t = tap) Tap.tap_migration_oldnames(t, token) + t.cask_reverse_renames.fetch(token, []) else [] end, T.nilable(T::Array[String]), ) end sig { params(config: Config).void } def config=(config) @config = config refresh end sig { void } def refresh @dsl = T.let(DSL.new(self), T.nilable(DSL)) @contains_os_specific_artifacts = nil return unless @block dsl!.instance_eval(&@block) dsl!.add_implicit_macos_dependency dsl!.language_eval rescue NoMethodError => e raise CaskInvalidError.new(token, e.message), e.backtrace end def_delegators :@dsl, *::Cask::DSL::DSL_METHODS sig { returns(DSL::Caveats) } def caveats_object = dsl!.caveats_object sig { params(caskroom_path: Pathname).returns(T::Array[[String, String]]) } def timestamped_versions(caskroom_path: self.caskroom_path) pattern = metadata_timestamped_path(version: "*", timestamp: "*", caskroom_path:).to_s relative_paths = Pathname.glob(pattern) .map { |p| p.relative_path_from(p.parent.parent) } # Sorbet is unaware that Pathname is sortable: https://github.com/sorbet/sorbet/issues/6844 T.unsafe(relative_paths).sort_by(&:basename) # sort by timestamp .map { |p| p.split.map(&:to_s) } end # The fully-qualified token of this {Cask}. # # @api internal sig { returns(String) } def full_token return token if (t = tap).nil? return token if t.core_cask_tap? "#{t.name}/#{token}" end # Alias for {#full_token}. # # @api internal sig { returns(String) } def full_name = full_token sig { returns(T::Boolean) } def installed? installed_caskfile&.exist? || false end sig { returns(T::Boolean) } def font? artifacts.all?(Artifact::Font) end sig { returns(T::Boolean) } def supports_linux? return true if font? # Bare `depends_on :macos` explicitly marks a cask as macOS-only return false if (macos_requirement = depends_on.macos) && !macos_requirement.version_specified? # Cache the os value before contains_os_specific_artifacts? refreshes the cask # (the refresh clears @dsl.os in generic/non-OS-specific contexts) os_value = dsl!.os return false if contains_os_specific_artifacts? # Casks with OS-specific blocks rely on the os stanza for Linux support return os_value.present? if dsl!.on_os_blocks_exist? # Platform-agnostic casks: reject macOS-only artifacts and manual installers artifacts.none? do |a| Artifact::MACOS_ONLY_ARTIFACTS.include?(a.class) || (a.is_a?(Artifact::Installer) && a.manual_install) end end sig { returns(T::Boolean) } def contains_os_specific_artifacts? return false unless @dsl&.on_system_blocks_exist? return @contains_os_specific_artifacts unless @contains_os_specific_artifacts.nil? any_loaded = T.let(false, T::Boolean) OnSystem::VALID_OS_ARCH_TAGS.each do |bottle_tag| Homebrew::SimulateSystem.with_tag(bottle_tag) do refresh any_loaded = true if artifacts.any? do |artifact| (bottle_tag.linux? && ::Cask::Artifact::MACOS_ONLY_ARTIFACTS.include?(artifact.class)) || (bottle_tag.macos? && ::Cask::Artifact::LINUX_ONLY_ARTIFACTS.include?(artifact.class)) end end rescue CaskInvalidError # Invalid for this OS/arch tag; treat as having no OS-specific artifacts. next ensure refresh end @contains_os_specific_artifacts = T.let(any_loaded, T.nilable(T::Boolean)) any_loaded end # The caskfile is needed during installation when there are # `*flight` blocks or the cask has multiple languages sig { returns(T::Boolean) } def caskfile_only? languages.any? || artifacts.any?(Artifact::AbstractFlightBlock) end sig { returns(T::Boolean) } def uninstall_flight_blocks? artifacts.any? do |artifact| case artifact when Artifact::PreflightBlock artifact.directives.key?(:uninstall_preflight) when Artifact::PostflightBlock artifact.directives.key?(:uninstall_postflight) end end end sig { returns(T.nilable(Time)) } def install_time # /.metadata///Casks/.{rb,json} -> caskfile = installed_caskfile Time.strptime(caskfile.dirname.dirname.basename.to_s, Metadata::TIMESTAMP_FORMAT) if caskfile end sig { returns(T.nilable(Pathname)) } def installed_caskfile installed_caskroom_path = caskroom_path installed_token = token # Check if the cask is installed with an old name. old_tokens.each do |old_token| old_caskroom_path = Caskroom.path/old_token next if !old_caskroom_path.directory? || old_caskroom_path.symlink? installed_caskroom_path = old_caskroom_path installed_token = old_token break end installed_version = timestamped_versions(caskroom_path: installed_caskroom_path).last return unless installed_version caskfile_dir = metadata_main_container_path(caskroom_path: installed_caskroom_path) .join(*installed_version, "Casks") ["internal.json", "json", "rb"] .map { |ext| caskfile_dir.join("#{installed_token}.#{ext}") } .find(&:exist?) end sig { returns(T.nilable(String)) } def installed_version return unless (installed_caskfile = self.installed_caskfile) # /.metadata///Casks/.{rb,json} -> installed_caskfile.dirname.dirname.dirname.basename.to_s end sig { returns(T.nilable(String)) } def bundle_short_version bundle_version&.short_version end sig { returns(T.nilable(String)) } def bundle_long_version bundle_version&.version end sig { returns(Tab) } def tab Tab.for_cask(self) end sig { returns(Pathname) } def config_path metadata_main_container_path/"config.json" end sig { returns(T::Boolean) } def checksumable? return false if (url = self.url).nil? DownloadStrategyDetector.detect(url.to_s, url.using) <= AbstractFileDownloadStrategy || false end sig { returns(Pathname) } def download_sha_path metadata_main_container_path/"LATEST_DOWNLOAD_SHA256" end sig { returns(String) } def new_download_sha require "cask/installer" # Call checksumable? before hashing @new_download_sha ||= T.let( Installer.new(self, verify_download_integrity: false) .download(quiet: true) .instance_eval { |x| Digest::SHA256.file(x).hexdigest }, T.nilable(String), ) end sig { returns(T::Boolean) } def outdated_download_sha? return true unless checksumable? current_download_sha = download_sha_path.read if download_sha_path.exist? current_download_sha.blank? || current_download_sha != new_download_sha end sig { returns(Pathname) } def caskroom_path @caskroom_path ||= T.let(Caskroom.path.join(token), T.nilable(Pathname)) end # Check if the installed cask is outdated. # # @api internal sig { params(greedy: T::Boolean, greedy_latest: T.nilable(T::Boolean), greedy_auto_updates: T.nilable(T::Boolean)) .returns(T::Boolean) } def outdated?(greedy: false, greedy_latest: false, greedy_auto_updates: false) !outdated_version(greedy:, greedy_latest:, greedy_auto_updates:).nil? end sig { params(greedy: T::Boolean, greedy_latest: T.nilable(T::Boolean), greedy_auto_updates: T.nilable(T::Boolean)) .returns(T.nilable(String)) } def outdated_version(greedy: false, greedy_latest: false, greedy_auto_updates: false) # special case: tap version is not available return if version.nil? if version.latest? return installed_version if (greedy || greedy_latest) && outdated_download_sha? return end return if installed_version == version if auto_updates && !greedy && !greedy_auto_updates return installed_version if auto_updates_bundle_outdated? return end installed_version end sig { params( greedy: T::Boolean, verbose: T::Boolean, json: T::Boolean, greedy_latest: T::Boolean, greedy_auto_updates: T::Boolean, ).returns(T.any(String, T::Hash[Symbol, T.untyped])) } def outdated_info(greedy, verbose, json, greedy_latest, greedy_auto_updates) return token if !verbose && !json installed_version = outdated_version(greedy:, greedy_latest:, greedy_auto_updates:).to_s if json { name: token, installed_versions: [installed_version], current_version: version, } else "#{token} (#{installed_version}) != #{version}" end end sig { returns(T.nilable(String)) } def ruby_source_path return @ruby_source_path if defined?(@ruby_source_path) return unless (sfp = sourcefile_path) return unless (t = tap) @ruby_source_path = T.let(sfp.relative_path_from(t.path).to_s, T.nilable(String)) end sig { returns(T::Hash[Symbol, T.nilable(String)]) } def ruby_source_checksum @ruby_source_checksum ||= T.let( begin sfp = sourcefile_path { sha256: sfp ? Digest::SHA256.file(sfp).hexdigest : nil, }.freeze end, T.nilable(T::Hash[Symbol, T.nilable(String)]), ) end sig { returns(T::Array[String]) } def languages @languages ||= T.let(dsl!.languages, T.nilable(T::Array[String])) end sig { returns(T.nilable(String)) } def tap_git_head @tap_git_head ||= T.let(tap&.git_head, T.nilable(String)) rescue TapUnavailableError nil end sig { params(cask_struct: Homebrew::API::CaskStruct, tap_git_head: T.nilable(String)).void } def populate_from_api!(cask_struct, tap_git_head:) raise ArgumentError, "Expected cask to be loaded from the API" unless loaded_from_api? @languages = cask_struct.languages @tap_git_head = tap_git_head @ruby_source_path = cask_struct.ruby_source_path @ruby_source_checksum = cask_struct.ruby_source_checksum end # The string representation of this {Cask}, returning its {#token}. # # @api public sig { returns(String) } def to_s = token sig { returns(String) } def inspect "#" end sig { returns(Integer) } def hash token.hash end sig { params(other: T.untyped).returns(T::Boolean) } def eql?(other) instance_of?(other.class) && token == other.token end alias == eql? sig { returns(T::Hash[String, T.untyped]) } def to_h { "token" => token, "full_token" => full_name, "old_tokens" => old_tokens, "tap" => tap&.name, "name" => name, "desc" => desc, "homepage" => homepage, "url" => url, "url_specs" => url_specs, "version" => version, "autobump" => autobump?, "no_autobump_message" => no_autobump_message, "skip_livecheck" => livecheck.skip?, "installed" => installed_version, "installed_time" => install_time&.to_i, "bundle_version" => bundle_long_version, "bundle_short_version" => bundle_short_version, "outdated" => outdated?, "sha256" => sha256, "artifacts" => artifacts_list, "caveats" => caveats_for_api, "caveats_rosetta" => caveats_object.invoked?(:requires_rosetta) || nil, "depends_on" => depends_on, "conflicts_with" => conflicts_with, "container" => container&.pairs, "rename" => rename_list, "auto_updates" => auto_updates, "deprecated" => deprecated?, "deprecation_date" => deprecation_date, "deprecation_reason" => deprecation_reason, "deprecation_replacement_formula" => deprecation_replacement_formula, "deprecation_replacement_cask" => deprecation_replacement_cask, "deprecate_args" => deprecate_args, "disabled" => disabled?, "disable_date" => disable_date, "disable_reason" => disable_reason, "disable_replacement_formula" => disable_replacement_formula, "disable_replacement_cask" => disable_replacement_cask, "disable_args" => disable_args, "tap_git_head" => tap_git_head, "languages" => languages, "ruby_source_path" => ruby_source_path, "ruby_source_checksum" => ruby_source_checksum, } end HASH_KEYS_TO_SKIP = T.let(%w[outdated installed versions].freeze, T::Array[String]) private_constant :HASH_KEYS_TO_SKIP AUTO_UPDATES_BAD_BUNDLE_VERSIONS = %w[0 0.0].freeze private_constant :AUTO_UPDATES_BAD_BUNDLE_VERSIONS sig { returns(T::Hash[String, T.untyped]) } def to_hash_with_variations if loaded_from_internal_api? raise UsageError, "Cannot call #to_hash_with_variations on casks loaded from the internal API" end if loaded_from_api? && (json_cask = api_source) && !Homebrew::EnvConfig.no_install_from_api? return api_to_local_hash(json_cask.dup) end hash = to_h variations = {} if dsl!.on_system_blocks_exist? begin OnSystem::VALID_OS_ARCH_TAGS.each do |bottle_tag| next if bottle_tag.linux? && dsl!.os.nil? next if bottle_tag.macos? && depends_on.macos && !dsl!.depends_on_set_in_block? && !depends_on.macos.allows?(bottle_tag.to_macos_version) Homebrew::SimulateSystem.with_tag(bottle_tag) do refresh to_h.each do |key, value| next if HASH_KEYS_TO_SKIP.include? key next if value.to_s == hash[key].to_s variations[bottle_tag.to_sym] ||= {} variations[bottle_tag.to_sym][key] = value end end end ensure refresh end end hash["variations"] = variations hash end sig { params(uninstall_only: T::Boolean).returns(T::Array[T::Hash[Symbol, T.untyped]]) } def artifacts_list(uninstall_only: false) artifacts.filter_map do |artifact| case artifact when Artifact::AbstractFlightBlock uninstall_flight_block = artifact.directives.key?(:uninstall_preflight) || artifact.directives.key?(:uninstall_postflight) next if uninstall_only && !uninstall_flight_block # Only indicate whether this block is used as we don't load it from the API { artifact.summarize.to_sym => nil } else zap_artifact = artifact.is_a?(Artifact::Zap) uninstall_artifact = artifact.respond_to?(:uninstall_phase) || artifact.respond_to?(:post_uninstall_phase) next if uninstall_only && !zap_artifact && !uninstall_artifact { artifact.class.dsl_key => artifact.to_args } end end end sig { params(uninstall_only: T::Boolean).returns(T::Array[T::Hash[Symbol, T.untyped]]) } def rename_list(uninstall_only: false) rename.filter_map do |rename| { from: rename.from, to: rename.to } end end private # Returns caveats text for API serialization, excluding conditional # built-in caveats that depend on the current machine's state. # These are stored as separate boolean fields (e.g. caveats_rosetta) # and evaluated at install time instead. sig { returns(T.nilable(String)) } def caveats_for_api Tty.strip_ansi(caveats_object.to_s_without_conditional) .presence end sig { returns(T.nilable(Homebrew::BundleVersion)) } def bundle_version @bundle_version ||= T.let( if (bundle = artifacts.find { |a| a.is_a?(Artifact::App) }&.target) && (plist = Pathname("#{bundle}/Contents/Info.plist")) && plist.exist? && plist.readable? Homebrew::BundleVersion.from_info_plist(plist) end, T.nilable(Homebrew::BundleVersion), ) end sig { returns(DSL) } def dsl! @dsl || raise("unexpected nil @dsl") end sig { returns(T.nilable(Artifact::App)) } def single_app_artifact app_artifacts = artifacts.grep(Artifact::App) return unless app_artifacts.one? app_artifacts.first end sig { returns(T.nilable(Pathname)) } def installed_app_info_plist return unless (app_artifact = single_app_artifact) info_plist = app_artifact.target/"Contents/Info.plist" info_plist if info_plist.exist? && info_plist.readable? end sig { params(first: T.nilable(String), second: T.nilable(String)).returns(T.nilable(Integer)) } def compare_version_strings(first, second) return if first.blank? || second.blank? return if first.split(".").size != second.split(".").size Version.new(first) <=> Version.new(second) rescue nil end sig { returns(T::Boolean) } def auto_updates_bundle_outdated? return false unless Homebrew::EnvConfig.upgrade_auto_updates_casks? return false if !auto_updates || version.latest? return false unless installed_app_info_plist tap_short_version = version.csv.first.to_s.presence || version.to_s begin installed_short_version = bundle_short_version installed_bundle_version = bundle_long_version rescue ErrorDuringExecution return false end installed_bundle_version = nil if AUTO_UPDATES_BAD_BUNDLE_VERSIONS.include?(installed_bundle_version) installed_short_version = nil if AUTO_UPDATES_BAD_BUNDLE_VERSIONS.include?(installed_short_version) return false if installed_short_version.nil? && installed_bundle_version.nil? return false if [installed_short_version, installed_bundle_version].any? do |installed_plist_version| compare_version_strings(installed_plist_version, tap_short_version)&.zero? end short_comparison = compare_version_strings(installed_short_version, tap_short_version) return true if short_comparison == -1 return false if short_comparison == 1 build_comparisons = version.csv.filter_map do |candidate| compare_version_strings(installed_bundle_version, candidate.to_s) end return false if build_comparisons.empty? return false if build_comparisons.include?(0) build_comparisons.include?(-1) end sig { params(hash: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) } def api_to_local_hash(hash) hash["token"] = token hash["installed"] = installed_version hash["outdated"] = outdated? hash end sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) } def url_specs url&.specs.dup.tap do |url_specs| case url_specs&.dig(:user_agent) when :default url_specs.delete(:user_agent) when Symbol url_specs[:user_agent] = ":#{url_specs[:user_agent]}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/cask_loader.rb000066400000000000000000000616511517265720000236320ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/cache" require "cask/cask" require "uri" require "utils/curl" require "utils/output" require "utils/path" require "extend/hash/keys" require "api" module Cask # Loads a cask from various sources. module CaskLoader extend Context extend ::Utils::Output::Mixin ALLOWED_URL_SCHEMES = %w[file].freeze private_constant :ALLOWED_URL_SCHEMES module ILoader extend T::Helpers include ::Utils::Output::Mixin interface! sig { abstract.params(config: T.nilable(Config)).returns(Cask) } def load(config:); end end # Loads a cask from a string. class AbstractContentLoader include ILoader extend T::Helpers abstract! sig { returns(String) } attr_reader :content sig { overridable.returns(T.nilable(Tap)) } attr_reader :tap sig { void } def initialize @content = T.let("", String) @tap = T.let(nil, T.nilable(Tap)) @config = T.let(nil, T.nilable(Config)) end private sig { overridable.params( header_token: String, options: T.untyped, block: T.nilable(T.proc.bind(DSL).void), ).returns(Cask) } def cask(header_token, **options, &block) Cask.new(header_token, source: content, tap:, **options, config: @config, &block) end end # Loads a cask from a string. class FromContentLoader < AbstractContentLoader sig { params(ref: T.any(Pathname, String, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(T.attached_class)) } def self.try_new(ref, warn: false) return if ref.is_a?(Cask) content = ref.to_str # Cache compiled regex @regex ||= T.let( begin token = /(?:"[^"]*"|'[^']*')/ curly = /\(\s*#{token.source}\s*\)\s*\{.*\}/ do_end = /\s+#{token.source}\s+do(?:\s*;\s*|\s+).*end/ /\A\s*cask(?:#{curly.source}|#{do_end.source})\s*\Z/m end, T.nilable(Regexp), ) return unless content.match?(@regex) new(content) end sig { params(content: String, tap: Tap).void } def initialize(content, tap: T.unsafe(nil)) super() @content = T.let(content.dup.force_encoding("UTF-8"), String) @tap = T.let(tap, T.nilable(Tap)) end sig { override.params(config: T.nilable(Config)).returns(Cask) } def load(config:) @config = config instance_eval(content, __FILE__, __LINE__) end end # Loads a cask from a path. class FromPathLoader < AbstractContentLoader sig { overridable.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(T.attached_class)) } def self.try_new(ref, warn: false) path = case ref when String Pathname(ref) when Pathname ref else return end return unless path.expand_path.exist? return if invalid_path?(path) return unless ::Utils::Path.loadable_package_path?(path, :cask) new(path) end sig { params(pathname: Pathname, valid_extnames: T::Array[String]).returns(T::Boolean) } def self.invalid_path?(pathname, valid_extnames: %w[.rb .json]) return true if valid_extnames.exclude?(pathname.extname) @invalid_basenames ||= T.let(%w[INSTALL_RECEIPT.json sbom.spdx.json].freeze, T.nilable(T::Array[String])) @invalid_basenames.include?(pathname.basename.to_s) end sig { returns(String) } attr_reader :token sig { returns(Pathname) } attr_reader :path sig { params(path: T.any(Pathname, String), token: String).void } def initialize(path, token: T.unsafe(nil)) super() path = Pathname(path).expand_path @token = T.let(path.basename(path.extname).basename(".internal").to_s, String) @path = T.let(path, Pathname) @tap = T.let(Tap.from_path(path) || Homebrew::API.tap_from_source_download(path), T.nilable(Tap)) @from_installed_caskfile = T.let(false, T::Boolean) end sig { override.params(config: T.nilable(Config)).returns(Cask) } def load(config:) raise CaskUnavailableError.new(token, "'#{path}' does not exist.") unless path.exist? raise CaskUnavailableError.new(token, "'#{path}' is not readable.") unless path.readable? raise CaskUnavailableError.new(token, "'#{path}' is not a file.") unless path.file? @content = path.read(encoding: "UTF-8") @config = config if !self.class.invalid_path?(path, valid_extnames: %w[.json]) && (from_json = JSON.parse(@content).presence) && from_json.is_a?(Hash) begin from_internal_json = path.to_s.end_with?(".internal.json") return FromAPILoader.new( token, from_json:, path:, from_installed_caskfile: @from_installed_caskfile, from_internal_json:, ).load(config:) rescue CaskInvalidError => e if @from_installed_caskfile error = CaskUnreadableError.new(token, e.reason) error.set_backtrace e.backtrace raise error end raise end end begin instance_eval(content, path.to_s).tap do |cask| raise CaskUnreadableError.new(token, "'#{path}' does not contain a cask.") unless cask.is_a?(Cask) end rescue NameError, ArgumentError, ScriptError => e error = CaskUnreadableError.new(token, e.message) error.set_backtrace e.backtrace raise error rescue CaskInvalidError => e # e.g. NoMethodError from removed DSL methods, wrapped # as CaskInvalidError by Cask#refresh before reaching here. if @from_installed_caskfile error = CaskUnreadableError.new(token, e.reason) error.set_backtrace e.backtrace raise error end raise end end private sig { override.params( header_token: String, options: T.untyped, block: T.nilable(T.proc.bind(DSL).void), ).returns(Cask) } def cask(header_token, **options, &block) raise CaskTokenMismatchError.new(token, header_token) if token != header_token super(header_token, **options, sourcefile_path: path, &block) end end # Loads a cask from a URI. class FromURILoader < FromPathLoader sig { override.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(T.attached_class)) } def self.try_new(ref, warn: false) return if Homebrew::EnvConfig.forbid_packages_from_paths? # Cache compiled regex @uri_regex ||= T.let( begin uri_regex = ::URI::RFC2396_PARSER.make_regexp Regexp.new("\\A#{uri_regex.source}\\Z", uri_regex.options) end, T.nilable(Regexp), ) uri = ref.to_s return unless uri.match?(@uri_regex) uri = URI(uri) return unless uri.path new(uri) end sig { returns(URI::Generic) } attr_reader :url sig { returns(String) } attr_reader :name sig { params(url: T.any(URI::Generic, String)).void } def initialize(url) @url = T.let(URI(url), URI::Generic) url_path = @url.path raise "unexpected nil url.path" unless url_path @name = T.let(File.basename(url_path), String) super Cache.path/name end sig { override.params(config: T.nilable(Config)).returns(Cask) } def load(config:) path.dirname.mkpath if ALLOWED_URL_SCHEMES.exclude?(url.scheme) raise UnsupportedInstallationMethod, "Non-checksummed download of #{name} formula file from an arbitrary URL is unsupported! " \ "`brew version-install` to install a formula file from your own custom tap " \ "instead." end begin ohai "Downloading #{url}" ::Utils::Curl.curl_download url.to_s, to: path rescue ErrorDuringExecution raise CaskUnavailableError.new(token, "Failed to download #{Formatter.url(url)}.") end super end end # Loads a cask from a specific tap. class FromTapLoader < FromPathLoader sig { override.returns(Tap) } attr_reader :tap sig { override(allow_incompatible: true) # rubocop:todo Sorbet/AllowIncompatibleOverride .params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(T.any(T.attached_class, FromAPILoader))) } def self.try_new(ref, warn: false) ref = ref.to_s return unless (token_tap_type = CaskLoader.tap_cask_token_type(ref, warn:)) token, tap, type = token_tap_type if type == :migration && tap.core_cask_tap? && (loader = FromAPILoader.try_new(token)) loader else new("#{tap}/#{token}") end end sig { params(tapped_token: String).void } def initialize(tapped_token) tap_with_token = Tap.with_cask_token(tapped_token) raise "unexpected nil Tap.with_cask_token" unless tap_with_token tap, token = tap_with_token cask = CaskLoader.find_cask_in_tap(token, tap) super cask @tap = T.let(tap, Tap) end sig { override.params(config: T.nilable(Config)).returns(Cask) } def load(config:) raise TapCaskUnavailableError.new(tap, token) unless tap.installed? super end end # Loads a cask from an existing {Cask} instance. class FromInstanceLoader include ILoader sig { params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(FromInstanceLoader)) } def self.try_new(ref, warn: false) new(ref) if ref.is_a?(Cask) end sig { params(cask: Cask).void } def initialize(cask) @cask = cask end # This is a false positive incompatibililty warning, due to Kernel#load being overridden. sig { override(allow_incompatible: true).params(config: T.nilable(Config)).returns(Cask) } # rubocop:disable Sorbet/AllowIncompatibleOverride def load(config:) @cask end end # Loads a cask from the JSON API. class FromAPILoader include ILoader sig { returns(String) } attr_reader :token sig { returns(Pathname) } attr_reader :path sig { returns(T.nilable(T::Hash[String, T.untyped])) } attr_reader :from_json sig { params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(FromAPILoader)) } def self.try_new(ref, warn: false) return if Homebrew::EnvConfig.no_install_from_api? return unless ref.is_a?(String) return unless (token = ref[HOMEBREW_DEFAULT_TAP_CASK_REGEX, :token]) if Homebrew::API.cask_tokens.exclude?(token) && !Homebrew::API.cask_renames.key?(token) return end ref = "#{CoreCaskTap.instance}/#{token}" token, tap, = CaskLoader.tap_cask_token_type(ref, warn:) new("#{tap}/#{token}") end sig { params( token: String, from_json: T.nilable(T::Hash[String, T.untyped]), path: T.nilable(Pathname), from_installed_caskfile: T::Boolean, from_internal_json: T::Boolean, ).void } def initialize(token, from_json: T.unsafe(nil), path: nil, from_installed_caskfile: false, from_internal_json: false) @token = T.let(token.sub(%r{^homebrew/(?:homebrew-)?cask/}i, ""), String) @sourcefile_path = T.let( if path path elsif from_json from_internal_json ? Homebrew::API::Internal.cached_packages_json_file_path : Homebrew::API::Cask.cached_json_file_path else Homebrew::API.cached_cask_json_file_path end, Pathname, ) @path = T.let(path || CaskLoader.default_path(@token), Pathname) @from_json = from_json @from_installed_caskfile = from_installed_caskfile @from_internal_json = from_internal_json end # This is a false positive incompatibililty warning, due to Kernel#load being overridden. sig { override(allow_incompatible: true).params(config: T.nilable(Config)).returns(Cask) } # rubocop:disable Sorbet/AllowIncompatibleOverride def load(config:) if (api_source = from_json) if @from_internal_json load_from_internal_json(config:, api_source:) else load_from_json(config:, api_source:) end elsif Homebrew::EnvConfig.use_internal_api? load_from_internal_api(config:) else load_from_api(config:) end end private sig { params(config: T.nilable(Config)).returns(Cask) } def load_from_api(config:) api_source = Homebrew::API::Cask.all_casks.fetch(token) tap_git_head = api_source["tap_git_head"] cask_struct = Homebrew::API::Cask::CaskStructGenerator.generate_cask_struct_hash( api_source, ignore_types: @from_installed_caskfile ) load_from_struct(config:, cask_struct:, api_source:, tap_git_head:) end sig { params(config: T.nilable(Config)).returns(Cask) } def load_from_internal_api(config:) cask_struct = Homebrew::API::Internal.cask_struct(token) api_source = Homebrew::API::Internal.cask_hashes.fetch(token) tap_git_head = Homebrew::API::Internal.cask_tap_git_head load_from_struct(config:, cask_struct:, api_source:, tap_git_head:, internal_api: true) end sig { params(config: T.nilable(Config), api_source: T::Hash[String, T.untyped]).returns(Cask) } def load_from_json(config:, api_source:) tap_git_head = api_source["tap_git_head"] cask_struct = Homebrew::API::Cask::CaskStructGenerator.generate_cask_struct_hash( api_source, ignore_types: @from_installed_caskfile ) load_from_struct(config:, cask_struct:, api_source:, tap_git_head:) end sig { params(config: T.nilable(Config), api_source: T::Hash[String, T.untyped]).returns(Cask) } def load_from_internal_json(config:, api_source:) api_source = api_source.dup tap_git_head = api_source.delete("tap_git_head") cask_struct = Homebrew::API::CaskStruct.deserialize(api_source) load_from_struct(config:, cask_struct:, api_source:, tap_git_head:, internal_api: true) end sig { params( config: T.nilable(Config), cask_struct: Homebrew::API::CaskStruct, api_source: T::Hash[String, T.untyped], tap_git_head: T.nilable(String), internal_api: T::Boolean, ).returns(Cask) } def load_from_struct(config:, cask_struct:, api_source:, tap_git_head:, internal_api: false) cask_options = { loaded_from_api: true, loaded_from_internal_api: internal_api, api_source:, sourcefile_path: @sourcefile_path, source: JSON.pretty_generate(api_source), config:, loader: self, } if (tap_string = cask_struct.tap_string) cask_options[:tap] = Tap.fetch(tap_string) end api_cask = Cask.new(token, **cask_options) do version cask_struct.version sha256 cask_struct.sha256 url(*cask_struct.url_args, **cask_struct.url_kwargs) cask_struct.names.each do |cask_name| name cask_name end desc cask_struct.desc if cask_struct.desc? homepage cask_struct.homepage if cask_struct.homepage? deprecate!(**cask_struct.deprecate_args) if cask_struct.deprecate? disable!(**cask_struct.disable_args) if cask_struct.disable? auto_updates cask_struct.auto_updates if cask_struct.auto_updates? conflicts_with(**cask_struct.conflicts_with_args) if cask_struct.conflicts? cask_struct.renames.each do |from, to| rename from, to end if cask_struct.depends_on? args = cask_struct.depends_on_args begin depends_on(**args) rescue MacOSVersion::Error => e odebug "Ignored invalid macOS version dependency in cask '#{token}': #{args.inspect} (#{e.message})" nil end end if cask_struct.container? container(nested: cask_struct.container_args[:nested], type: cask_struct.container_args[:type]) end cask_struct.artifacts(appdir:).each do |key, args, kwargs, block| send(key, *args, **kwargs, &block) end caveats T.must(cask_struct.caveats(appdir:)) if cask_struct.caveats? if cask_struct.caveats_rosetta caveats do # Dynamically defined via `caveat :requires_rosetta` — Sorbet can't resolve it. public_send(:requires_rosetta) # rubocop:disable Style/SendWithLiteralMethodName end end end api_cask.populate_from_api!(cask_struct, tap_git_head:) api_cask end end # Loader which tries loading casks from tap paths, failing # if the same token exists in multiple taps. class FromNameLoader < FromTapLoader sig { override.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(T.any(T.attached_class, FromAPILoader))) } def self.try_new(ref, warn: false) return unless ref.is_a?(String) return unless ref.match?(/\A#{HOMEBREW_TAP_CASK_TOKEN_REGEX}\Z/o) token = ref # If it exists in the default tap, never treat it as ambiguous with another tap. if (core_cask_tap = CoreCaskTap.instance).installed? && (core_cask_loader = super("#{core_cask_tap}/#{token}", warn:))&.path&.exist? return core_cask_loader end loaders = Tap.select { |tap| tap.installed? && !tap.core_cask_tap? } .filter_map { |tap| super("#{tap}/#{token}", warn:) } .uniq(&:path) .select { |loader| loader.is_a?(FromAPILoader) || loader.path.exist? } case loaders.count when 1 loaders.first when 2..Float::INFINITY raise TapCaskAmbiguityError.new(token, loaders) end end end # Loader which loads a cask from the installed cask file. class FromInstalledPathLoader < FromPathLoader sig { override.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(T.attached_class)) } def self.try_new(ref, warn: false) token = if ref.is_a?(String) ref elsif ref.is_a?(Pathname) ref.basename(ref.extname).basename(".internal").to_s end return unless token possible_installed_cask = Cask.new(token) return unless (installed_caskfile = possible_installed_cask.installed_caskfile) new(installed_caskfile) end sig { params(path: T.any(Pathname, String), token: String).void } def initialize(path, token: "") super installed_tap = Cask.new(@token).tab.tap @tap = installed_tap if installed_tap @from_installed_caskfile = T.let(true, T::Boolean) end end # Pseudo-loader which raises an error when trying to load the corresponding cask. class NullLoader < FromPathLoader sig { override.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean) .returns(T.nilable(T.attached_class)) } def self.try_new(ref, warn: false) return if ref.is_a?(Cask) return if ref.is_a?(URI::Generic) new(ref) end sig { params(ref: T.any(String, Pathname)).void } def initialize(ref) token = File.basename(ref, ".rb") super CaskLoader.default_path(token) end sig { override.params(config: T.nilable(Config)).returns(Cask) } def load(config:) raise CaskUnavailableError.new(token, "No Cask with this name exists.") end end # NOTE: Using `WithoutRuntime` to avoid Sorbet wrapping this method, # which would interfere with RSpec mocking of this class method. T::Sig::WithoutRuntime.sig { params(ref: T.any(String, Pathname, Cask, URI::Generic)).returns(Pathname) } def self.path(ref) T.cast(self.for(ref, need_path: true), T.any(FromAPILoader, FromPathLoader)).path end # NOTE: Using `WithoutRuntime` to avoid Sorbet wrapping this method, # which would interfere with RSpec mocking of this class method. T::Sig::WithoutRuntime.sig { params(ref: T.any(String, Symbol, Pathname, Cask, URI::Generic), config: T.nilable(Config), warn: T::Boolean).returns(Cask) } def self.load(ref, config: nil, warn: true) normalized_ref = ref.is_a?(Symbol) ? ref.to_s : ref self.for(normalized_ref, warn:).load(config:) end sig { params(tapped_token: String, warn: T::Boolean).returns(T.nilable([String, Tap, T.nilable(Symbol)])) } def self.tap_cask_token_type(tapped_token, warn:) return unless (tap_with_token = Tap.with_cask_token(tapped_token)) tap, token = tap_with_token type = nil if (new_token = tap.cask_renames[token].presence) old_token = tap.core_cask_tap? ? token : tapped_token token = new_token new_token = tap.core_cask_tap? ? token : "#{tap}/#{token}" type = :rename elsif (new_tap_name = tap.tap_migrations[token].presence) new_tap, new_token = Tap.with_cask_token(new_tap_name) unless new_tap if new_tap_name.include?("/") new_tap = Tap.fetch(new_tap_name) new_token = token else new_tap = tap new_token = new_tap_name end end new_tapped_token = "#{new_tap}/#{new_token}" if tapped_token != new_tapped_token old_token = tap.core_cask_tap? ? token : tapped_token return unless (token_tap_type = tap_cask_token_type(new_tapped_token, warn: false)) token, tap, = token_tap_type new_token = new_tap.core_cask_tap? ? token : "#{tap}/#{token}" type = :migration end end opoo "Cask #{old_token} was renamed to #{new_token}." if warn && old_token && new_token [token, tap, type] end # NOTE: Using `WithoutRuntime` to avoid Sorbet wrapping this method, # which would interfere with RSpec mocking of this class method. T::Sig::WithoutRuntime.sig { params(ref: T.any(String, Pathname, Cask, URI::Generic), need_path: T::Boolean, warn: T::Boolean) .returns(ILoader) } def self.for(ref, need_path: false, warn: true) [ FromInstanceLoader, FromContentLoader, FromURILoader, FromAPILoader, FromTapLoader, FromNameLoader, FromPathLoader, FromInstalledPathLoader, NullLoader, ].each do |loader_class| if (loader = loader_class.try_new(ref, warn:)) $stderr.puts "#{$PROGRAM_NAME} (#{loader.class}): loading #{ref}" if verbose? && debug? return loader end end raise CaskError, "No cask loader found for #{ref.inspect}" end sig { params(ref: String, config: T.nilable(Config), warn: T::Boolean).returns(Cask) } def self.load_prefer_installed(ref, config: nil, warn: true) tap, token = Tap.with_cask_token(ref) token ||= ref tap ||= Cask.new(ref).tab.tap if tap.nil? self.load(token, config:, warn:) else begin self.load("#{tap}/#{token}", config:, warn:) rescue CaskUnavailableError # cask may be migrated to different tap. Try to search in all taps. self.load(token, config:, warn:) end end end sig { params(path: Pathname, config: T.nilable(Config), warn: T::Boolean).returns(Cask) } def self.load_from_installed_caskfile(path, config: nil, warn: true) loader = FromInstalledPathLoader.try_new(path, warn:) loader ||= NullLoader.new(path) loader.load(config:) end sig { params(token: T.any(String, Symbol)).returns(Pathname) } def self.default_path(token) find_cask_in_tap(token.to_s.downcase, CoreCaskTap.instance) end sig { params(token: String, tap: Tap).returns(Pathname) } def self.find_cask_in_tap(token, tap) filename = "#{token}.rb" tap.cask_files_by_name.fetch(token, tap.cask_dir/filename) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/caskroom.rb000066400000000000000000000050141517265720000231700ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/user" require "utils/output" module Cask # Helper functions for interacting with the `Caskroom` directory. # # @api internal module Caskroom extend ::Utils::Output::Mixin sig { returns(Pathname) } def self.path @path ||= T.let(HOMEBREW_PREFIX/"Caskroom", T.nilable(Pathname)) end # Return all paths for installed casks. sig { returns(T::Array[Pathname]) } def self.paths return [] unless path.exist? path.children.select { |p| p.directory? && !p.symlink? } end private_class_method :paths # Return all tokens for installed casks. sig { returns(T::Array[String]) } def self.tokens paths.map { |path| path.basename.to_s } end sig { returns(T::Boolean) } def self.any_casks_installed? paths.any? end # Return tokens for Caskroom directories missing expected installed metadata. sig { returns(T::Array[String]) } def self.corrupt_cask_dirs paths.filter_map { |p| p.basename.to_s unless cask_with_metadata?(p) } end sig { params(cask_path: Pathname).returns(T::Boolean) } def self.cask_with_metadata?(cask_path) cask_path.glob(".metadata/*/*/Casks/*.{rb,json}").any? end private_class_method :cask_with_metadata? sig { void } def self.ensure_caskroom_exists return if path.exist? sudo = !path.parent.writable? if sudo && !ENV.key?("SUDO_ASKPASS") && $stdout.tty? ohai "Creating Caskroom directory: #{path}", "We'll set permissions properly so we won't need sudo in the future." end SystemCommand.run("mkdir", args: ["-p", path], sudo:) SystemCommand.run("chmod", args: ["g+rwx", path], sudo:) SystemCommand.run("chown", args: [User.current.to_s, path], sudo:) chgrp_path(path, sudo) end sig { params(path: Pathname, sudo: T::Boolean).void } def self.chgrp_path(path, sudo) SystemCommand.run("chgrp", args: ["admin", path], sudo:) end # Get all installed casks. # # @api internal sig { params(config: T.nilable(Config)).returns(T::Array[Cask]) } def self.casks(config: nil) tokens.sort.filter_map do |token| CaskLoader.load_prefer_installed(token, config:, warn: false) rescue TapCaskAmbiguityError => e e.loaders.fetch(0).load(config:) rescue # Don't blow up because of a single unavailable cask. nil end.select(&:installed?) end end end require "extend/os/cask/caskroom" Homebrew-brew-d7f73ce/Library/Homebrew/cask/config.rb000066400000000000000000000161421517265720000226230ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "json" require "lazy_object" require "locale" require "extend/hash/keys" module Cask # Configuration for installing casks. # # @api internal class Config ConfigHash = T.type_alias { T::Hash[Symbol, T.any(LazyObject, String, Pathname, T::Array[String])] } DEFAULT_DIRS = T.let( { appdir: "/Applications", keyboard_layoutdir: "/Library/Keyboard Layouts", colorpickerdir: "~/Library/ColorPickers", prefpanedir: "~/Library/PreferencePanes", qlplugindir: "~/Library/QuickLook", mdimporterdir: "~/Library/Spotlight", dictionarydir: "~/Library/Dictionaries", fontdir: "~/Library/Fonts", servicedir: "~/Library/Services", input_methoddir: "~/Library/Input Methods", internet_plugindir: "~/Library/Internet Plug-Ins", audio_unit_plugindir: "~/Library/Audio/Plug-Ins/Components", vst_plugindir: "~/Library/Audio/Plug-Ins/VST", vst3_plugindir: "~/Library/Audio/Plug-Ins/VST3", screen_saverdir: "~/Library/Screen Savers", }.freeze, T::Hash[Symbol, String], ) # runtime recursive evaluation forces the LazyObject to be evaluated T::Sig::WithoutRuntime.sig { returns(T::Hash[Symbol, T.any(LazyObject, String)]) } def self.defaults { languages: LazyObject.new { ::OS::Mac.languages }, }.merge(DEFAULT_DIRS).freeze end sig { params(args: Homebrew::CLI::Args).returns(T.attached_class) } def self.from_args(args) # FIXME: T.unsafe is a workaround for methods that are only defined when `cask_options` # is invoked on the parser. (These could be captured by a DSL compiler instead.) args = T.unsafe(args) new(explicit: { appdir: args.appdir, keyboard_layoutdir: args.keyboard_layoutdir, colorpickerdir: args.colorpickerdir, prefpanedir: args.prefpanedir, qlplugindir: args.qlplugindir, mdimporterdir: args.mdimporterdir, dictionarydir: args.dictionarydir, fontdir: args.fontdir, servicedir: args.servicedir, input_methoddir: args.input_methoddir, internet_plugindir: args.internet_plugindir, audio_unit_plugindir: args.audio_unit_plugindir, vst_plugindir: args.vst_plugindir, vst3_plugindir: args.vst3_plugindir, screen_saverdir: args.screen_saverdir, languages: args.language, }.compact) end sig { params(json: String, ignore_invalid_keys: T::Boolean).returns(T.attached_class) } def self.from_json(json, ignore_invalid_keys: false) config = JSON.parse(json, symbolize_names: true) new( default: config.fetch(:default, {}), env: config.fetch(:env, {}), explicit: config.fetch(:explicit, {}), ignore_invalid_keys:, ) end sig { params(config: ConfigHash).returns(ConfigHash) } def self.canonicalize(config) config.to_h do |k, v| if DEFAULT_DIRS.key?(k) raise TypeError, "Invalid path for default dir #{k}: #{v.inspect}" if v.is_a?(Array) [k, Pathname(v.to_s).expand_path] else [k, v] end end end # Get the explicit configuration. # # @api internal sig { returns(ConfigHash) } attr_accessor :explicit sig { params( default: T.nilable(ConfigHash), env: T.nilable(ConfigHash), explicit: ConfigHash, ignore_invalid_keys: T::Boolean, ).void } def initialize(default: nil, env: nil, explicit: {}, ignore_invalid_keys: false) if default @default = T.let( self.class.canonicalize(self.class.defaults.merge(default)), T.nilable(ConfigHash), ) end if env @env = T.let( self.class.canonicalize(env), T.nilable(ConfigHash), ) end @explicit = T.let( self.class.canonicalize(explicit), ConfigHash, ) if ignore_invalid_keys @env&.delete_if { |key, _| self.class.defaults.keys.exclude?(key) } @explicit.delete_if { |key, _| self.class.defaults.keys.exclude?(key) } return end @env&.assert_valid_keys(*self.class.defaults.keys) @explicit.assert_valid_keys(*self.class.defaults.keys) end sig { returns(ConfigHash) } def default @default ||= self.class.canonicalize(self.class.defaults) end sig { returns(ConfigHash) } def env @env ||= self.class.canonicalize( Homebrew::EnvConfig.cask_opts .select { |arg| arg.include?("=") } .map { |arg| T.cast(arg.split("=", 2), [String, String]) } .to_h do |(flag, value)| key = flag.sub(/^--/, "") # converts --language flag to :languages config key if key == "language" key = "languages" value = value.split(",") end [key.to_sym, value] end, ) end sig { returns(Pathname) } def binarydir @binarydir ||= T.let(HOMEBREW_PREFIX/"bin", T.nilable(Pathname)) end sig { returns(Pathname) } def manpagedir @manpagedir ||= T.let(HOMEBREW_PREFIX/"share/man", T.nilable(Pathname)) end sig { returns(Pathname) } def bash_completion @bash_completion ||= T.let(HOMEBREW_PREFIX/"etc/bash_completion.d", T.nilable(Pathname)) end sig { returns(Pathname) } def zsh_completion @zsh_completion ||= T.let(HOMEBREW_PREFIX/"share/zsh/site-functions", T.nilable(Pathname)) end sig { returns(Pathname) } def fish_completion @fish_completion ||= T.let(HOMEBREW_PREFIX/"share/fish/vendor_completions.d", T.nilable(Pathname)) end sig { returns(T::Array[String]) } def languages [ *explicit.fetch(:languages, []), *env.fetch(:languages, []), *default.fetch(:languages, []), ].uniq.select do |lang| # Ensure all languages are valid. Locale.parse(lang) true rescue Locale::ParserError false end end sig { params(languages: T::Array[String]).void } def languages=(languages) explicit[:languages] = languages end DEFAULT_DIRS.each_key do |dir| define_method(dir) do T.bind(self, Config) explicit.fetch(dir, env.fetch(dir, default.fetch(dir))) end define_method(:"#{dir}=") do |path| T.bind(self, Config) explicit[dir] = Pathname(path).expand_path end end sig { params(other: Config).returns(T.self_type) } def merge(other) self.class.new(explicit: other.explicit.merge(explicit)) end sig { params(options: T.untyped).returns(String) } def to_json(*options) { default:, env:, explicit:, }.to_json(*options) end end end require "extend/os/cask/config" Homebrew-brew-d7f73ce/Library/Homebrew/cask/denylist.rb000066400000000000000000000007441517265720000232120ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask # List of casks which are not allowed in official taps. module Denylist sig { params(name: String).returns(T.nilable(String)) } def self.reason(name) case name when /^adobe-(after|illustrator|indesign|photoshop|premiere)/ "Adobe casks were removed because they are too difficult to maintain." when /^pharo$/ "Pharo developers maintain their own tap." end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/download.rb000066400000000000000000000110771517265720000231670ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "downloadable" require "fileutils" require "cask/cache" require "cask/quarantine" module Cask # A download corresponding to a {Cask}. class Download include Downloadable include Context sig { returns(::Cask::Cask) } attr_reader :cask sig { params( cask: ::Cask::Cask, quarantine: T.nilable(T::Boolean), require_sha: T::Boolean, ).void } def initialize(cask, quarantine: nil, require_sha: false) super() @cask = cask @quarantine = quarantine @require_sha = require_sha end sig { override.returns(T.nilable(::URL)) } def url return if (cask_url = cask.url).nil? @url ||= ::URL.new(cask_url.to_s, cask_url.specs) end sig { override.returns(T.nilable(::Checksum)) } def checksum @checksum ||= cask.sha256 if cask.sha256 != :no_check end sig { override.returns(T.nilable(Version)) } def version return if cask.version.nil? @version ||= Version.new(cask.version) end sig { override .params(quiet: T.nilable(T::Boolean), verify_download_integrity: T::Boolean, timeout: T.nilable(T.any(Integer, Float))) .returns(Pathname) } def fetch(quiet: nil, verify_download_integrity: true, timeout: nil) verify_has_sha if @require_sha downloader.quiet! if quiet begin super(verify_download_integrity: false, timeout:) rescue DownloadError => e error = CaskError.new("Download failed on Cask '#{cask}' with message: #{e.cause}") error.set_backtrace e.backtrace raise error end downloaded_path = cached_download quarantine(downloaded_path) self.verify_download_integrity(downloaded_path) if verify_download_integrity downloaded_path end sig { params(timeout: T.nilable(T.any(Float, Integer))).returns([T.nilable(Time), Integer]) } def time_file_size(timeout: nil) raise ArgumentError, "not supported for this download strategy" unless downloader.is_a?(CurlDownloadStrategy) T.cast(downloader, CurlDownloadStrategy).resolved_time_file_size(timeout:) end sig { returns(Pathname) } def basename downloader.basename end sig { override.params(filename: Pathname).void } def verify_download_integrity(filename) if no_checksum_defined? && !official_cask_tap? opoo "No checksum defined for cask '#{@cask}', skipping verification." return end super end sig { override.returns(String) } def download_queue_name = "#{cask.token} (#{version})" sig { override.returns(String) } def download_queue_type = "Cask" private sig { void } def verify_has_sha return if @cask.sha256 != :no_check raise CaskError, <<~EOS Cask '#{@cask}' does not have a sha256 checksum defined. This means you have the #{Formatter.identifier("--require-sha")} option set, perhaps in your `$HOMEBREW_CASK_OPTS`. EOS end sig { params(path: Pathname).void } def quarantine(path) return if @quarantine.nil? return unless Quarantine.available? if @quarantine Quarantine.cask!(cask: @cask, download_path: path) else Quarantine.release!(download_path: path) end end sig { returns(T::Boolean) } def official_cask_tap? tap = @cask.tap return false if tap.blank? tap.official? end sig { returns(T::Boolean) } def no_checksum_defined? @cask.sha256 == :no_check end sig { override.returns(T::Boolean) } def silence_checksum_missing_error? no_checksum_defined? && official_cask_tap? end sig { override.returns(T.nilable(::URL)) } def determine_url url end sig { override.returns(Pathname) } def cache Cache.path end sig { override.returns(String) } def download_name url_basename = super version = self.version url = self.url return url_basename if version.nil? || url.nil? temp_downloader = download_strategy.new(url.to_s, url_basename, version, mirrors: [], cache:, **url.specs) return url_basename unless temp_downloader.is_a?(AbstractFileDownloadStrategy) potential_symlink_length = temp_downloader.symlink_location.basename.to_s.length max_filesystem_symlink_length = 255 return url_basename if potential_symlink_length < max_filesystem_symlink_length cask.full_token.gsub("/", "--") end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl.rb000066400000000000000000000634641517265720000221510ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "autobump_constants" require "locale" require "livecheck" require "utils/output" require "cask/artifact" require "cask/artifact_set" require "cask/caskroom" require "cask/exceptions" require "cask/dsl/base" require "cask/dsl/caveats" require "cask/dsl/conflicts_with" require "cask/dsl/container" require "cask/dsl/depends_on" require "cask/dsl/postflight" require "cask/dsl/preflight" require "cask/dsl/rename" require "cask/dsl/uninstall_postflight" require "cask/dsl/uninstall_preflight" require "cask/dsl/version" require "cask/url" require "cask/utils" require "on_system" module Cask # Class representing the domain-specific language used for casks. class DSL include ::Utils::Output::Mixin ORDINARY_ARTIFACT_CLASSES = [ Artifact::Installer, Artifact::App, Artifact::Artifact, Artifact::AudioUnitPlugin, Artifact::Binary, Artifact::Colorpicker, Artifact::Dictionary, Artifact::Font, Artifact::InputMethod, Artifact::InternetPlugin, Artifact::KeyboardLayout, Artifact::Manpage, Artifact::Pkg, Artifact::Prefpane, Artifact::Qlplugin, Artifact::Mdimporter, Artifact::ScreenSaver, Artifact::Service, Artifact::StageOnly, Artifact::Suite, Artifact::VstPlugin, Artifact::Vst3Plugin, Artifact::ZshCompletion, Artifact::FishCompletion, Artifact::BashCompletion, Artifact::GeneratedCompletion, Artifact::Uninstall, Artifact::Zap, ].freeze ACTIVATABLE_ARTIFACT_CLASSES = T.let( (ORDINARY_ARTIFACT_CLASSES - [Artifact::StageOnly]).freeze, T::Array[T.class_of(Artifact::AbstractArtifact)], ) ARTIFACT_BLOCK_CLASSES = [ Artifact::PreflightBlock, Artifact::PostflightBlock, ].freeze DSL_METHODS = T.let(Set.new([ :arch, :artifacts, :auto_updates, :caveats, :conflicts_with, :container, :desc, :depends_on, :homepage, :language, :name, :os, :rename, :sha256, :staged_path, :url, :version, :appdir, :deprecate!, :deprecated?, :deprecation_date, :deprecation_reason, :deprecation_replacement_cask, :deprecation_replacement_formula, :deprecate_args, :disable!, :disabled?, :disable_date, :disable_reason, :disable_replacement_cask, :disable_replacement_formula, :disable_args, :livecheck, :livecheck_defined?, :no_autobump!, :autobump?, :no_autobump_message, :on_system_blocks_exist?, :on_os_blocks_exist?, :on_system_block_min_os, :depends_on_set_in_block?, *ORDINARY_ARTIFACT_CLASSES.map(&:dsl_key), *ACTIVATABLE_ARTIFACT_CLASSES.map(&:dsl_key), *ARTIFACT_BLOCK_CLASSES.flat_map { |klass| [klass.dsl_key, klass.uninstall_dsl_key] }, ]).freeze, T::Set[Symbol]) include OnSystem::MacOSAndLinux sig { returns(Cask) } attr_reader :cask sig { returns(String) } attr_reader :token sig { returns(T.nilable(T.any(String, Symbol))) } attr_reader :no_autobump_message sig { returns(ArtifactSet) } attr_reader :artifacts sig { returns(T.nilable(Date)) } attr_reader :deprecation_date sig { returns(T.nilable(T.any(String, Symbol))) } attr_reader :deprecation_reason sig { returns(T.nilable(String)) } attr_reader :deprecation_replacement_cask sig { returns(T.nilable(String)) } attr_reader :deprecation_replacement_formula sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.any(String, Symbol))])) } attr_reader :deprecate_args sig { returns(T.nilable(Date)) } attr_reader :disable_date sig { returns(T.nilable(T.any(String, Symbol))) } attr_reader :disable_reason sig { returns(T.nilable(String)) } attr_reader :disable_replacement_cask sig { returns(T.nilable(String)) } attr_reader :disable_replacement_formula sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.any(String, Symbol))])) } attr_reader :disable_args sig { returns(T.nilable(MacOSVersion)) } attr_reader :on_system_block_min_os sig { params(cask: Cask).void } def initialize(cask) # NOTE: `:"@#{stanza}"` variables set by `set_unique_stanza` must be # initialized to `nil`. @arch = T.let(nil, T.nilable(String)) @arch_set_in_block = T.let(false, T::Boolean) @artifacts = T.let(ArtifactSet.new, ArtifactSet) @auto_updates = T.let(nil, T.nilable(T::Boolean)) @auto_updates_set_in_block = T.let(false, T::Boolean) @autobump = T.let(true, T::Boolean) @called_in_on_system_block = T.let(false, T::Boolean) @cask = cask @caveats = T.let(DSL::Caveats.new(cask), DSL::Caveats) @conflicts_with = T.let(nil, T.nilable(DSL::ConflictsWith)) @conflicts_with_set_in_block = T.let(false, T::Boolean) @container = T.let(nil, T.nilable(DSL::Container)) @container_set_in_block = T.let(false, T::Boolean) @depends_on = T.let(DSL::DependsOn.new, DSL::DependsOn) @depends_on_set_in_block = T.let(false, T::Boolean) @deprecated = T.let(false, T::Boolean) @deprecation_date = T.let(nil, T.nilable(Date)) @deprecation_reason = T.let(nil, T.nilable(T.any(String, Symbol))) @deprecation_replacement_cask = T.let(nil, T.nilable(String)) @deprecation_replacement_formula = T.let(nil, T.nilable(String)) @deprecate_args = T.let(nil, T.nilable(T::Hash[Symbol, T.nilable(T.any(String, Symbol))])) @desc = T.let(nil, T.nilable(String)) @desc_set_in_block = T.let(false, T::Boolean) @disable_date = T.let(nil, T.nilable(Date)) @disable_reason = T.let(nil, T.nilable(T.any(String, Symbol))) @disable_replacement_cask = T.let(nil, T.nilable(String)) @disable_replacement_formula = T.let(nil, T.nilable(String)) @disable_args = T.let(nil, T.nilable(T::Hash[Symbol, T.nilable(T.any(String, Symbol))])) @disabled = T.let(false, T::Boolean) @homepage = T.let(nil, T.nilable(String)) @homepage_set_in_block = T.let(false, T::Boolean) @language_blocks = T.let({}, T::Hash[T::Array[String], Proc]) @language_eval = T.let(nil, T.nilable(String)) @livecheck = T.let(Livecheck.new(cask), Livecheck) @livecheck_defined = T.let(false, T::Boolean) @name = T.let([], T::Array[String]) @no_autobump_defined = T.let(false, T::Boolean) @no_autobump_message = T.let(nil, T.nilable(T.any(String, Symbol))) @on_system_blocks_exist = T.let(false, T::Boolean) @on_os_blocks_exist = T.let(false, T::Boolean) @on_system_block_min_os = T.let(nil, T.nilable(MacOSVersion)) @os = T.let(nil, T.nilable(String)) @os_set_in_block = T.let(false, T::Boolean) @rename = T.let([], T::Array[DSL::Rename]) @sha256 = T.let(nil, T.nilable(T.any(Checksum, Symbol))) @sha256_set_in_block = T.let(false, T::Boolean) @staged_path = T.let(nil, T.nilable(Pathname)) @token = T.let(cask.token, String) @url = T.let(nil, T.nilable(URL)) @url_set_in_block = T.let(false, T::Boolean) @version = T.let(nil, T.nilable(DSL::Version)) @version_set_in_block = T.let(false, T::Boolean) end sig { returns(T::Boolean) } def depends_on_set_in_block? = @depends_on_set_in_block sig { returns(T::Boolean) } def deprecated? = @deprecated sig { returns(T::Boolean) } def disabled? = @disabled sig { returns(T::Boolean) } def livecheck_defined? = @livecheck_defined sig { returns(T::Boolean) } def on_system_blocks_exist? = @on_system_blocks_exist sig { returns(T::Boolean) } def on_os_blocks_exist? = @on_os_blocks_exist # Specifies the cask's name. # # NOTE: Multiple names can be specified. # # ### Example # # ```ruby # name "Visual Studio Code" # ``` # # @api public sig { params(args: T.any(String, T::Array[String])).returns(T::Array[String]) } def name(*args) return @name if args.empty? @name.concat(args.flatten) end # Describes the cask. # # ### Example # # ```ruby # desc "Open-source code editor" # ``` # # @api public sig { params(description: T.nilable(String)).returns(T.nilable(String)) } def desc(description = nil) set_unique_stanza(:desc, description.nil?) { description } end # NOTE: Using `WithoutRuntime` to avoid Sorbet wrapping this method, # which would interfere with `caller_locations` in methods like `url`. T::Sig::WithoutRuntime.sig { type_parameters(:U).params( stanza: Symbol, should_return: T::Boolean, _block: T.proc.returns(T.all(BasicObject, T.type_parameter(:U))), ).returns(T.type_parameter(:U)) } def set_unique_stanza(stanza, should_return, &_block) return instance_variable_get(:"@#{stanza}") if should_return unless @cask.allow_reassignment if !instance_variable_get(:"@#{stanza}").nil? && !@called_in_on_system_block raise CaskInvalidError.new(cask, "'#{stanza}' stanza may only appear once.") end if instance_variable_get(:"@#{stanza}_set_in_block") && @called_in_on_system_block raise CaskInvalidError.new(cask, "'#{stanza}' stanza may only be overridden once.") end end instance_variable_set(:"@#{stanza}_set_in_block", true) if @called_in_on_system_block instance_variable_set(:"@#{stanza}", yield) rescue CaskInvalidError raise rescue => e raise CaskInvalidError.new(cask, "'#{stanza}' stanza failed with: #{e}") end # Sets the cask's homepage. # # ### Example # # ```ruby # homepage "https://code.visualstudio.com/" # ``` # # @api public sig { params(homepage: T.nilable(String)).returns(T.nilable(String)) } def homepage(homepage = nil) set_unique_stanza(:homepage, homepage.nil?) { homepage } end # Specifies language-specific values for the cask. # # @api public sig { params( args: String, default: T::Boolean, block: T.nilable(T.proc.returns(String)), ).returns(T.nilable(String)) } def language(*args, default: false, &block) if args.empty? language_eval elsif block @language_blocks[args] = block return unless default if !@cask.allow_reassignment && @language_blocks.default.present? raise CaskInvalidError.new(cask, "Only one default language may be defined.") end @language_blocks.default = block nil else raise CaskInvalidError.new(cask, "No block given to language stanza.") end end sig { returns(T.nilable(String)) } def language_eval return @language_eval unless @language_eval.nil? return @language_eval = nil if @language_blocks.empty? if (language_blocks_default = @language_blocks.default).nil? raise CaskInvalidError.new(cask, "No default language specified.") end locales = cask.config.languages .filter_map do |language| Locale.parse(language) rescue Locale::ParserError nil end locales.each do |locale| key = T.cast(locale.detect(@language_blocks.keys), T.nilable(T::Array[String])) next if key.nil? || (language_block = @language_blocks[key]).nil? return @language_eval = language_block.call end @language_eval = language_blocks_default.call end sig { returns(T::Array[String]) } def languages @language_blocks.keys.flatten end # Sets the cask's download URL. # # ### Example # # ```ruby # url "https://update.code.visualstudio.com/#{version}/#{arch}/stable" # ``` # # @api public T::Sig::WithoutRuntime.sig { params(uri: T.nilable(T.any(URI::Generic, String)), options: T.untyped).returns(T.nilable(URL)) } def url(uri = nil, **options) caller_location = caller_locations.fetch(0) return @url unless uri set_unique_stanza(:url, false) do URL.new(uri, **options, caller_location:) end end # Sets the cask's container type or nested container path. # # ### Examples # # The container is a nested disk image: # # ```ruby # container nested: "orca-#{version}.dmg" # ``` # # The container should not be unarchived: # # ```ruby # container type: :naked # ``` # # @api public sig { params(nested: T.nilable(String), type: T.nilable(Symbol)).returns(T.nilable(DSL::Container)) } def container(nested: nil, type: nil) set_unique_stanza(:container, nested.nil? && type.nil?) do DSL::Container.new(nested:, type:) end end # Renames files after extraction. # # This is useful when the downloaded file has unpredictable names # that need to be normalized for proper artifact installation. # # ### Example # # ```ruby # rename "RØDECaster App*.pkg", "RØDECaster App.pkg" # ``` # # @api public sig { params(from: String, to: String).returns(T::Array[DSL::Rename]) } def rename(from = T.unsafe(nil), to = T.unsafe(nil)) return @rename if from.nil? @rename << DSL::Rename.new(from, to) end # Sets the cask's version. # # ### Example # # ```ruby # version "1.88.1" # ``` # # @see DSL::Version # @api public sig { params(arg: T.nilable(T.any(String, Symbol))).returns(T.nilable(DSL::Version)) } def version(arg = nil) set_unique_stanza(:version, arg.nil?) do if !arg.is_a?(String) && arg != :latest raise CaskInvalidError.new(cask, "invalid 'version' value: #{arg.inspect}") end set_no_autobump(because: :latest_version) if arg == :latest && !no_autobump_defined? DSL::Version.new(arg) end end # Sets the cask's download checksum. # # ### Example # # For universal or single-architecture downloads: # # ```ruby # sha256 "7bdb497080ffafdfd8cc94d8c62b004af1be9599e865e5555e456e2681e150ca" # ``` # # For architecture-dependent downloads: # # ```ruby # sha256 arm: "7bdb497080ffafdfd8cc94d8c62b004af1be9599e865e5555e456e2681e150ca", # x86_64: "b3c1c2442480a0219b9e05cf91d03385858c20f04b764ec08a3fa83d1b27e7b2" # x86_64_linux: "1a2aee7f1ddc999993d4d7d42a150c5e602bc17281678050b8ed79a0500cc90f" # arm64_linux: "bd766af7e692afceb727a6f88e24e6e68d9882aeb3e8348412f6c03d96537c75" # ``` # # @api public sig { params( arg: T.nilable(T.any(String, Symbol)), arm: T.nilable(String), intel: T.nilable(String), x86_64: T.nilable(String), x86_64_linux: T.nilable(String), arm64_linux: T.nilable(String), ).returns(T.nilable(T.any(Symbol, Checksum))) } def sha256(arg = nil, arm: nil, intel: nil, x86_64: nil, x86_64_linux: nil, arm64_linux: nil) should_return = arg.nil? && arm.nil? && (intel.nil? || x86_64.nil?) && x86_64_linux.nil? && arm64_linux.nil? x86_64 ||= intel if intel.present? && x86_64.nil? set_unique_stanza(:sha256, should_return) do if arm.present? || x86_64.present? || x86_64_linux.present? || arm64_linux.present? @on_system_blocks_exist = true end val = arg || on_system_conditional( macos: on_arch_conditional(arm:, intel: x86_64), linux: on_arch_conditional(arm: arm64_linux, intel: x86_64_linux), ) case val when :no_check :no_check when String Checksum.new(val) else raise CaskInvalidError.new(cask, "invalid 'sha256' value: #{val.inspect}") end end end # Sets the cask's architecture strings. # # ### Example # # ```ruby # arch arm: "darwin-arm64", intel: "darwin" # ``` # # @api public sig { params(arm: T.nilable(String), intel: T.nilable(String)).returns(T.nilable(String)) } def arch(arm: nil, intel: nil) should_return = arm.nil? && intel.nil? set_unique_stanza(:arch, should_return) do @on_system_blocks_exist = true on_arch_conditional(arm:, intel:) end end # Sets the cask's os strings. # # ### Example # # ```ruby # os macos: "darwin", linux: "tux" # ``` # # @api public sig { params( macos: T.nilable(String), linux: T.nilable(String), ).returns(T.nilable(String)) } def os(macos: nil, linux: nil) should_return = macos.nil? && linux.nil? set_unique_stanza(:os, should_return) do @on_system_blocks_exist = true @on_os_blocks_exist = true on_system_conditional(macos:, linux:) end end # Declare dependencies and requirements for a cask. # # NOTE: Multiple dependencies can be specified. # # @api public sig { params(arg: T.nilable(Symbol), kwargs: T.untyped).returns(DSL::DependsOn) } def depends_on(arg = nil, **kwargs) @depends_on_set_in_block = true if @called_in_on_system_block if arg == :macos kwargs[:macos] = :any elsif arg raise CaskInvalidError.new(cask, "invalid 'depends_on' value: #{arg.inspect}") end return @depends_on if kwargs.empty? begin @depends_on.load(**kwargs) rescue RuntimeError => e raise CaskInvalidError.new(cask, e) end @depends_on end # @api private sig { void } def add_implicit_macos_dependency return if (cask_depends_on = @depends_on).present? && cask_depends_on.macos.present? depends_on macos: ">= #{MacOSVersion.new(HOMEBREW_MACOS_OLDEST_ALLOWED).to_sym.inspect}" end # Declare conflicts that keep a cask from installing or working correctly. # # @api public sig { params(kwargs: T.anything).returns(T.nilable(DSL::ConflictsWith)) } def conflicts_with(**kwargs) # TODO: Remove this constraint and instead merge multiple `conflicts_with` stanzas set_unique_stanza(:conflicts_with, kwargs.empty?) { DSL::ConflictsWith.new(**kwargs) } end sig { returns(Pathname) } def caskroom_path cask.caskroom_path end # The staged location for this cask, including version number. # # @api public sig { returns(Pathname) } def staged_path return @staged_path if @staged_path cask_version = version || :unknown @staged_path = caskroom_path.join(cask_version.to_s) end # Provide the user with cask-specific information at install time. # # @api public sig { params( strings: String, block: T.nilable(T.proc.returns(T.nilable(T.any(Symbol, String)))), ).returns(T.any(String, DSL::Caveats)) } def caveats(*strings, &block) if block @caveats.eval_caveats(&block) elsif strings.any? strings.each do |string| @caveats.eval_caveats { string } end else return @caveats.to_s end @caveats end sig { returns(DSL::Caveats) } def caveats_object = @caveats # Asserts that the cask artifacts auto-update. # # @api public sig { params(auto_updates: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) } def auto_updates(auto_updates = nil) set_unique_stanza(:auto_updates, auto_updates.nil?) { auto_updates } end # Automatically fetch the latest version of a cask from changelogs. # # @api public sig { params(block: T.nilable(T.proc.void)).returns(Livecheck) } def livecheck(&block) return @livecheck unless block if !@cask.allow_reassignment && @livecheck_defined raise CaskInvalidError.new(cask, "'livecheck' stanza may only appear once.") end @livecheck_defined = true @livecheck.instance_eval(&block) set_no_autobump(because: :extract_plist) if @livecheck.strategy == :extract_plist && !no_autobump_defined? @livecheck end # Excludes the cask from autobump list. # # @api public sig { params(because: T.any(String, Symbol)).void } def no_autobump!(because:) tap = @cask.tap if tap && !tap.official? raise CaskInvalidError.new(cask, "'no_autobump!' can only be used in official Homebrew taps.") end set_no_autobump(because:) end # Is the cask in autobump list? sig { returns(T::Boolean) } def autobump? @autobump == true end # Declare that a cask is no longer functional or supported. # # NOTE: A warning will be shown when trying to install this cask. # # @api public sig { params( date: String, because: T.any(String, Symbol), replacement: T.nilable(String), replacement_formula: T.nilable(String), replacement_cask: T.nilable(String), ).void } def deprecate!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil) if [replacement, replacement_formula, replacement_cask].filter_map(&:presence).length > 1 raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!" end if replacement odeprecated( "deprecate!(:replacement)", "deprecate!(:replacement_formula) or deprecate!(:replacement_cask)", ) end @deprecate_args = { date:, because:, replacement_formula:, replacement_cask: } @deprecation_date = Date.parse(date) return if @deprecation_date > Date.today @deprecation_reason = because @deprecation_replacement_formula = replacement_formula.presence || replacement @deprecation_replacement_cask = replacement_cask.presence || replacement @deprecated = true end # Declare that a cask is no longer functional or supported. # # NOTE: An error will be thrown when trying to install this cask. # # @api public sig { params( date: String, because: T.any(String, Symbol), replacement: T.nilable(String), replacement_formula: T.nilable(String), replacement_cask: T.nilable(String), ).void } def disable!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil) if [replacement, replacement_formula, replacement_cask].filter_map(&:presence).length > 1 raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!" end # odeprecate: remove this remapping when the :unsigned reason is removed because = :fails_gatekeeper_check if because == :unsigned if replacement odeprecated( "disable!(:replacement)", "disable!(:replacement_formula) or disable!(:replacement_cask)", ) end @disable_args = { date:, because:, replacement_formula:, replacement_cask: } @disable_date = Date.parse(date) if @disable_date > Date.today @deprecation_reason = because @deprecation_replacement_formula = replacement_formula.presence || replacement @deprecation_replacement_cask = replacement_cask.presence || replacement @deprecated = true return end @disable_reason = because @disable_replacement_formula = replacement_formula.presence || replacement @disable_replacement_cask = replacement_cask.presence || replacement @disabled = true end ORDINARY_ARTIFACT_CLASSES.each do |klass| define_method(klass.dsl_key) do |*args, **kwargs| T.bind(self, DSL) if [*artifacts.map(&:class), klass].include?(Artifact::StageOnly) && artifacts.map(&:class).intersect?(ACTIVATABLE_ARTIFACT_CLASSES) raise CaskInvalidError.new(cask, "'stage_only' must be the only activatable artifact.") end artifacts.add(klass.from_args(cask, *args, **kwargs)) rescue CaskInvalidError raise rescue => e raise CaskInvalidError.new(cask, "invalid '#{klass.dsl_key}' stanza: #{e}") end end ARTIFACT_BLOCK_CLASSES.each do |klass| [klass.dsl_key, klass.uninstall_dsl_key].each do |dsl_key| define_method(dsl_key) do |&block| T.bind(self, DSL) artifacts.add(klass.new(cask, dsl_key => block)) end end end sig { override.params(method: Symbol, _args: T.anything).returns(T.noreturn) } def method_missing(method, *_args) raise NoMethodError, "undefined method '#{method}' for Cask '#{token}'" end sig { override.params(_method_name: T.any(String, Symbol), _include_private: T::Boolean).returns(T::Boolean) } def respond_to_missing?(_method_name, _include_private = false) false end sig { returns(T.nilable(MacOSVersion)) } def os_version nil end # The directory `app`s are installed into. # # @api public sig { returns(T.any(Pathname, String)) } def appdir return HOMEBREW_CASK_APPDIR_PLACEHOLDER if Cask.generating_hash? cask.config.appdir end private sig { returns(T::Boolean) } def no_autobump_defined? @no_autobump_defined end sig { params(because: T.any(String, Symbol)).void } def set_no_autobump(because:) if because.is_a?(Symbol) && !NO_AUTOBUMP_REASONS_LIST.key?(because) raise ArgumentError, "'because' argument should use valid symbol or a string!" end if !@cask.allow_reassignment && no_autobump_defined? raise CaskInvalidError.new(cask, "'no_autobump!' stanza may only appear once.") end odeprecated "no_autobump! because: :requires_manual_review" if because == :requires_manual_review @no_autobump_defined = true @no_autobump_message = because @autobump = false end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/000077500000000000000000000000001517265720000216075ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/base.rb000066400000000000000000000022511517265720000230460ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask class DSL # Superclass for all stanzas which take a block. class Base extend Forwardable sig { returns(Cask) } attr_reader :cask sig { returns(T.class_of(SystemCommand)) } attr_reader :command sig { params(cask: Cask, command: T.class_of(SystemCommand)).void } def initialize(cask, command = SystemCommand) @cask = cask @command = command end def_delegators :@cask, :token, :version, :caskroom_path, :staged_path, :appdir, :language, :arch sig { params(executable: String, options: T.untyped).returns(T.nilable(SystemCommand::Result)) } def system_command(executable, **options) @command.run!(executable, **options) end sig { params(method: Symbol, _args: T.untyped).returns(T.noreturn) } def method_missing(method, *_args) raise NoMethodError, "undefined method '#{method}' for Cask '#{@cask}'" end sig { params(_method: Symbol, _include_private: T::Boolean).returns(T::Boolean) } def respond_to_missing?(_method, _include_private = false) false end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/caveats.rb000066400000000000000000000156701517265720000235730ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask class DSL # Class corresponding to the `caveats` stanza. # # Each method should handle output, following the # convention of at least one trailing blank line so that the user # can distinguish separate caveats. # # The return value of the last method in the block is also sent # to the output by the caller, but that feature is only for the # convenience of cask authors. class Caveats < Base # Built-in caveats that have runtime conditions (arch, prefix, etc.) # and should not be pre-serialized into the API JSON string. CONDITIONAL_CAVEATS = T.let([:requires_rosetta, :files_in_usr_local].freeze, T::Array[Symbol]) sig { params(args: T.anything).void } def initialize(*args) super @built_in_caveats = T.let({}, T::Hash[T::Array[Symbol], String]) @custom_caveats = T.let([], T::Array[String]) @discontinued = T.let(false, T::Boolean) @invoked_caveats = T.let(Set.new, T::Set[Symbol]) end sig { params(name: Symbol, block: T.proc.bind(Caveats).void).void } def self.caveat(name, &block) define_method(name) do |*args| T.bind(self, Caveats) key = [name, *args] invoked_caveats.add(name) text = instance_exec(*args, &block) built_in_caveats[key] = text if text :built_in_caveat end end private_class_method :caveat sig { returns(T::Boolean) } def discontinued? = @discontinued sig { returns(String) } def to_s (@custom_caveats + @built_in_caveats.values).join("\n") end # Returns caveats text excluding conditional built-in caveats. # Used when serializing caveats for the JSON API so that conditional # caveats (like requires_rosetta) are not pre-baked into the string. sig { returns(String) } def to_s_without_conditional unconditional = @built_in_caveats.reject do |key, _| name = key.first name && CONDITIONAL_CAVEATS.include?(name) end (@custom_caveats + unconditional.values).join("\n") end sig { params(name: Symbol).returns(T::Boolean) } def invoked?(name) @invoked_caveats.include?(name) end # Override `puts` to collect caveats. sig { params(args: String).returns(Symbol) } def puts(*args) @custom_caveats += args :built_in_caveat end sig { params(block: T.proc.returns(T.nilable(T.any(Symbol, String)))).void } def eval_caveats(&block) result = instance_eval(&block) return unless result return if result == :built_in_caveat @custom_caveats << result.to_s.sub(/\s*\Z/, "\n") end caveat :kext do next if MacOS.version < :sonoma navigation_path = if MacOS.version >= :ventura "System Settings → Privacy & Security" else "System Preferences → Security & Privacy → General" end <<~EOS #{cask} requires a kernel extension to work. If the installation fails, retry after you enable it in: #{navigation_path} For more information, refer to vendor documentation or this Apple Technical Note: #{Formatter.url("https://developer.apple.com/library/content/technotes/tn2459/_index.html")} EOS end caveat :unsigned_accessibility do |access = "Accessibility"| # access: the category in the privacy settings the app requires. navigation_path = if MacOS.version >= :ventura "System Settings → Privacy & Security" else "System Preferences → Security & Privacy → Privacy" end <<~EOS #{cask} is not signed and requires Accessibility access, so you will need to re-grant Accessibility access every time the app is updated. Enable or re-enable it in: #{navigation_path} → #{access} To re-enable, untick and retick #{cask}.app. EOS end caveat :path_environment_variable do |path| <<~EOS To use #{cask}, you may need to add the #{path} directory to your PATH environment variable, e.g. (for Bash shell): export PATH=#{path}:"$PATH" EOS end caveat :zsh_path_helper do |path| <<~EOS To use #{cask}, zsh users may need to add the following line to their ~/.zprofile. (Among other effects, #{path} will be added to the PATH environment variable): eval `/usr/libexec/path_helper -s` EOS end caveat :files_in_usr_local do next unless HOMEBREW_PREFIX.to_s.downcase.start_with?("/usr/local") <<~EOS Cask #{cask} installs files under /usr/local. The presence of such files can cause warnings when running `brew doctor`, which is considered to be a bug in Homebrew Cask. EOS end caveat :depends_on_java do |java_version = :any| if java_version == :any <<~EOS #{cask} requires Java. You can install the latest version with: brew install --cask temurin EOS elsif java_version.to_s.include?("+") <<~EOS #{cask} requires Java #{java_version}. You can install the latest version with: brew install --cask temurin EOS else <<~EOS #{cask} requires Java #{java_version}. You can install it with: brew install --cask temurin@#{java_version} EOS end end caveat :requires_rosetta do next if Homebrew::SimulateSystem.current_arch != :arm <<~EOS #{cask} is built for Intel macOS and so requires Rosetta 2 to be installed. You can install Rosetta 2 with: softwareupdate --install-rosetta --agree-to-license Note that it is very difficult to remove Rosetta 2 once it is installed. EOS end caveat :logout do <<~EOS You must log out and log back in for the installation of #{cask} to take effect. EOS end caveat :reboot do <<~EOS You must reboot for the installation of #{cask} to take effect. EOS end caveat :license do |web_page| <<~EOS Installing #{cask} means you have AGREED to the license at: #{Formatter.url(web_page.to_s)} EOS end caveat :free_license do |web_page| <<~EOS The vendor offers a free license for #{cask} at: #{Formatter.url(web_page.to_s)} EOS end private # These attrs are required as a workaround for https://github.com/sorbet/sorbet/issues/8106 sig { returns(T::Set[Symbol]) } attr_reader :invoked_caveats sig { returns(T::Hash[T::Array[Symbol], String]) } attr_reader :built_in_caveats end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/caveats.rbi000066400000000000000000000001301517265720000237250ustar00rootroot00000000000000# typed: strict class Cask::DSL::Caveats sig { returns(Symbol) } def kext; end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/conflicts_with.rb000066400000000000000000000014761517265720000251630ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "delegate" require "extend/hash/keys" require "utils/output" module Cask class DSL # Class corresponding to the `conflicts_with` stanza. class ConflictsWith < SimpleDelegator VALID_KEYS = [:cask].freeze sig { params(options: T.anything).void } def initialize(**options) options.assert_valid_keys(*VALID_KEYS) conflicts = options.transform_values { |v| Set.new(Kernel.Array(v)) } conflicts.default = Set.new super(conflicts) end sig { returns(T::Hash[Symbol, T::Array[String]]) } def to_h __getobj__.transform_values(&:to_a) end sig { params(generator: T.anything).returns(String) } def to_json(generator) to_h.to_json(generator) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/container.rb000066400000000000000000000017401517265720000241200ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "unpack_strategy" module Cask class DSL # Class corresponding to the `container` stanza. class Container sig { returns(T.nilable(String)) } attr_accessor :nested sig { returns(T.nilable(Symbol)) } attr_accessor :type sig { params(nested: T.nilable(String), type: T.nilable(Symbol)).void } def initialize(nested: nil, type: nil) @nested = nested @type = type return if type.nil? return unless UnpackStrategy.from_type(type).nil? raise "invalid container type: #{type.inspect}" end sig { returns(T::Hash[Symbol, T.nilable(T.any(String, Symbol))]) } def pairs instance_variables.to_h { |ivar| [ivar[1..].to_sym, instance_variable_get(ivar)] }.compact end sig { returns(String) } def to_yaml pairs.to_yaml end sig { returns(String) } def to_s = pairs.inspect end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/depends_on.rb000066400000000000000000000100431517265720000242500ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "delegate" require "requirements/macos_requirement" module Cask class DSL # Class corresponding to the `depends_on` stanza. class DependsOn < SimpleDelegator VALID_KEYS = T.let(Set.new([ :formula, :cask, :macos, :arch, ]).freeze, T::Set[Symbol]) VALID_ARCHES = T.let({ intel: { type: :intel, bits: 64 }, # specific x86_64: { type: :intel, bits: 64 }, arm64: { type: :arm, bits: 64 }, }.freeze, T::Hash[Symbol, T::Hash[Symbol, T.any(Symbol, Integer)]]) sig { returns(T.nilable(T::Array[T::Hash[Symbol, T.any(Symbol, Integer)]])) } attr_reader :arch sig { returns(T.nilable(MacOSRequirement)) } attr_reader :macos sig { void } def initialize super({}) @arch = T.let(nil, T.nilable(T::Array[T::Hash[Symbol, T.any(Symbol, Integer)]])) @cask = T.let(nil, T.nilable(T::Array[String])) @formula = T.let(nil, T.nilable(T::Array[String])) @macos = T.let(nil, T.nilable(MacOSRequirement)) end sig { returns(T::Array[String]) } def cask @cask ||= [] end sig { returns(T::Array[String]) } def formula @formula ||= [] end sig { params(pairs: T::Hash[Symbol, T.any(String, Symbol, T::Array[T.any(String, Symbol)])]).void } def load(pairs) pairs.each do |key, value| raise "invalid depends_on key: '#{key.inspect}'" unless VALID_KEYS.include?(key) __getobj__[key] = send(:"#{key}=", *value) end end sig { params(args: String).returns(T::Array[String]) } def formula=(*args) formula.concat(args) end sig { params(args: String).returns(T::Array[String]) } def cask=(*args) cask.concat(args) end sig { params(args: T.any(String, Symbol)).returns(T.nilable(MacOSRequirement)) } def macos=(*args) raise "Only a single 'depends_on macos' is allowed." if @macos # workaround for https://github.com/sorbet/sorbet/issues/6860 first_arg = args.first first_arg_s = first_arg&.to_s begin @macos = if first_arg == :any MacOSRequirement.new elsif args.count > 1 MacOSRequirement.new([args], comparator: "==") elsif first_arg.is_a?(Symbol) && MacOSVersion::SYMBOLS.key?(first_arg) MacOSRequirement.new([args.first], comparator: "==") elsif (md = /^\s*(?<|>|[=<>]=)\s*:(?\S+)\s*$/.match(first_arg_s)) # The named capture groups must exist, so we use T.must to assert that they do. MacOSRequirement.new([T.must(md[:version]).to_sym], comparator: T.must(md[:comparator])) elsif (md = /^\s*(?<|>|[=<>]=)\s*(?\S+)\s*$/.match(first_arg_s)) # The named capture groups must exist, so we use T.must to assert that they do. MacOSRequirement.new([md[:version]], comparator: T.must(md[:comparator])) # This is not duplicate of the first case: see `args.first` and a different comparator. else # rubocop:disable Lint/DuplicateBranch MacOSRequirement.new([args.first], comparator: "==") end rescue MacOSVersion::Error, TypeError => e raise "invalid 'depends_on macos' value: #{e}" end end sig { params(args: Symbol).returns(T::Array[T::Hash[Symbol, T.any(Symbol, Integer)]]) } def arch=(*args) @arch ||= [] arches = args.map do |elt| elt.to_s.downcase.sub(/^:/, "").tr("-", "_").to_sym end invalid_arches = arches - VALID_ARCHES.keys raise "invalid 'depends_on arch' values: #{invalid_arches.inspect}" unless invalid_arches.empty? @arch.concat(arches.map { |arch| VALID_ARCHES.fetch(arch) }) end sig { returns(T::Boolean) } def empty? = T.let(__getobj__, T::Hash[Symbol, T.untyped]).empty? sig { returns(T::Boolean) } def present? = !empty? end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/depends_on.rbi000066400000000000000000000001011517265720000244130ustar00rootroot00000000000000# typed: strict class Cask::DSL::DependsOn include Kernel end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/postflight.rb000066400000000000000000000003271517265720000243210ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/staged" module Cask class DSL # Class corresponding to the `postflight` stanza. class Postflight < Base include Staged end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/preflight.rb000066400000000000000000000003251517265720000241200ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/staged" module Cask class DSL # Class corresponding to the `preflight` stanza. class Preflight < Base include Staged end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/rename.rb000066400000000000000000000023441517265720000234060ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask class DSL # Class corresponding to the `rename` stanza. class Rename sig { returns(String) } attr_reader :from, :to sig { params(from: String, to: String).void } def initialize(from, to) @from = from @to = to end sig { params(staged_path: Pathname).void } def perform_rename(staged_path) return unless staged_path.exist? # Find files matching the glob pattern matching_files = if @from.include?("*") staged_path.glob(@from) else [staged_path.join(@from)].select(&:exist?) end return if matching_files.empty? # Rename the first matching file to the target path source_file = matching_files.first return if source_file.nil? target_file = staged_path.join(@to) # Ensure target directory exists target_file.dirname.mkpath # Perform the rename source_file.rename(target_file.to_s) if source_file.exist? end sig { returns(T::Hash[Symbol, String]) } def pairs { from:, to: } end sig { returns(String) } def to_s = pairs.inspect end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/uninstall_postflight.rb000066400000000000000000000002761517265720000264150ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask class DSL # Class corresponding to the `uninstall_postflight` stanza. class UninstallPostflight < Base end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/uninstall_preflight.rb000066400000000000000000000003501517265720000262070ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/staged" module Cask class DSL # Class corresponding to the `uninstall_preflight` stanza. class UninstallPreflight < Base include Staged end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/dsl/version.rb000066400000000000000000000131231517265720000236210ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask class DSL # Class corresponding to the `version` stanza. class Version < ::String DIVIDERS = T.let({ "." => :dots, "-" => :hyphens, "_" => :underscores, }.freeze, T::Hash[String, Symbol]) DIVIDER_REGEX = /(#{DIVIDERS.keys.map { |v| Regexp.quote(v) }.join("|")})/ MAJOR_MINOR_PATCH_REGEX = /^([^.,:]+)(?:.([^.,:]+)(?:.([^.,:]+))?)?/ INVALID_CHARACTERS = /[^0-9a-zA-Z.,:\-_+ ]/ class << self private sig { params(divider: String).void } def define_divider_methods(divider) define_divider_deletion_method(divider) define_divider_conversion_methods(divider) end sig { params(divider: String).void } def define_divider_deletion_method(divider) method_name = deletion_method_name(divider) define_method(method_name) do T.bind(self, Version) version { delete(divider) } end end sig { params(divider: String).returns(String) } def deletion_method_name(divider) "no_#{DIVIDERS[divider]}" end sig { params(left_divider: String).void } def define_divider_conversion_methods(left_divider) (DIVIDERS.keys - [left_divider]).each do |right_divider| define_divider_conversion_method(left_divider, right_divider) end end sig { params(left_divider: String, right_divider: String).void } def define_divider_conversion_method(left_divider, right_divider) method_name = conversion_method_name(left_divider, right_divider) define_method(method_name) do T.bind(self, Version) version { gsub(left_divider, right_divider) } end end sig { params(left_divider: String, right_divider: String).returns(String) } def conversion_method_name(left_divider, right_divider) "#{DIVIDERS[left_divider]}_to_#{DIVIDERS[right_divider]}" end end DIVIDERS.each_key do |divider| define_divider_methods(divider) end sig { returns(T.nilable(T.any(String, Symbol))) } attr_reader :raw_version sig { params(raw_version: T.nilable(T.any(String, Symbol))).void } def initialize(raw_version) @raw_version = raw_version super(raw_version.to_s) invalid = invalid_characters raise TypeError, "#{raw_version} contains invalid characters: #{invalid.uniq.join}!" if invalid.present? end sig { returns(T::Array[T.any(T::Array[String], String)]) } def invalid_characters return [] if raw_version.blank? || latest? raw_version.to_s.scan(INVALID_CHARACTERS) end sig { returns(T::Boolean) } def unstable? return false if latest? s = downcase.delete(".").gsub(/[^a-z\d]+/, "-") return true if s.match?(/(\d+|\b)(alpha|beta|preview|rc|dev|canary|snapshot)(\d+|\b)/i) return true if s.match?(/\A[a-z\d]+(-\d+)*-?(a|b|pre)(\d+|\b)/i) false end sig { returns(T::Boolean) } def latest? to_s == "latest" end # The major version. # # @api public sig { returns(T.self_type) } def major version { slice(MAJOR_MINOR_PATCH_REGEX, 1) } end # The minor version. # # @api public sig { returns(T.self_type) } def minor version { slice(MAJOR_MINOR_PATCH_REGEX, 2) } end # The patch version. # # @api public sig { returns(T.self_type) } def patch version { slice(MAJOR_MINOR_PATCH_REGEX, 3) } end # The major and minor version. # # @api public sig { returns(T.self_type) } def major_minor version { [major, minor].reject(&:empty?).join(".") } end # The major, minor and patch version. # # @api public sig { returns(T.self_type) } def major_minor_patch version { [major, minor, patch].reject(&:empty?).join(".") } end # The minor and patch version. # # @api public sig { returns(T.self_type) } def minor_patch version { [minor, patch].reject(&:empty?).join(".") } end # The comma separated values of the version as array. # # @api public sig { returns(T::Array[Version]) } # Only top-level T.self_type is supported https://sorbet.org/docs/self-type def csv split(",").map { self.class.new(it) } end # The version part before the first comma. # # @api public sig { returns(T.self_type) } def before_comma version { split(",", 2).first } end # The version part after the first comma. # # @api public sig { returns(T.self_type) } def after_comma version { split(",", 2).second } end # The version without any dividers. # # @see DIVIDER_REGEX # @api public sig { returns(T.self_type) } def no_dividers version { gsub(DIVIDER_REGEX, "") } end # The version with the given record separator removed from the end. # # @see String#chomp # @api public sig { params(separator: String).returns(T.self_type) } def chomp(separator = T.unsafe(nil)) version { to_s.chomp(separator) } end private sig { params(_block: T.proc.returns(T.nilable(String))).returns(T.self_type) } def version(&_block) return self if empty? || latest? self.class.new(yield) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/exceptions.rb000066400000000000000000000151761517265720000235450ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Cask # General cask error. class CaskError < RuntimeError; end # Cask error containing multiple other errors. class MultipleCaskErrors < CaskError sig { params(errors: T::Array[StandardError]).void } def initialize(errors) super() @errors = errors end sig { returns(String) } def to_s <<~EOS Problems with multiple casks: #{@errors.join("\n")} EOS end end # Abstract cask error containing a cask token. class AbstractCaskErrorWithToken < CaskError sig { returns(String) } attr_reader :token sig { returns(String) } attr_reader :reason sig { params(token: T.any(String, Symbol, Cask), reason: T.nilable(Object)).void } def initialize(token, reason = nil) super() @token = T.let(token.to_s, String) @reason = T.let(reason.to_s, String) end end # Error when a cask is not installed. class CaskNotInstalledError < AbstractCaskErrorWithToken sig { returns(String) } def to_s "Cask '#{token}' is not installed." end end # Error when a cask cannot be installed. class CaskCannotBeInstalledError < AbstractCaskErrorWithToken sig { returns(String) } attr_reader :message sig { params(token: T.any(String, Symbol, Cask), message: String).void } def initialize(token, message) super(token) @message = message end sig { returns(String) } def to_s "Cask '#{token}' has been #{message}" end end # Error when a cask conflicts with another cask. class CaskConflictError < AbstractCaskErrorWithToken sig { returns(Cask) } attr_reader :conflicting_cask sig { params(token: T.any(String, Symbol, Cask), conflicting_cask: Cask).void } def initialize(token, conflicting_cask) super(token) @conflicting_cask = conflicting_cask end sig { returns(String) } def to_s "Cask '#{token}' conflicts with '#{conflicting_cask}'." end end # Error when a cask is not available. class CaskUnavailableError < AbstractCaskErrorWithToken sig { returns(String) } def to_s "Cask '#{token}' is unavailable#{reason.empty? ? "." : ": #{reason}"}" end end # Error when a cask is unreadable. class CaskUnreadableError < CaskUnavailableError sig { returns(String) } def to_s "Cask '#{token}' is unreadable#{reason.empty? ? "." : ": #{reason}"}" end end # Error when a cask in a specific tap is not available. class TapCaskUnavailableError < CaskUnavailableError sig { returns(Tap) } attr_reader :tap sig { params(tap: Tap, token: String).void } def initialize(tap, token) super("#{tap}/#{token}") @tap = tap end sig { returns(String) } def to_s s = super unless tap.installed? s += "\nThis command requires the tap #{tap}." s += "\nIf you trust this tap, tap it explicitly and then try again:\n brew tap #{tap}" end s end end # Error when a cask with the same name is found in multiple taps. class TapCaskAmbiguityError < CaskError sig { returns(String) } attr_reader :token sig { returns(T::Array[CaskLoader::FromNameLoader]) } attr_reader :loaders sig { params(token: String, loaders: T::Array[CaskLoader::FromNameLoader]).void } def initialize(token, loaders) @token = token @loaders = loaders taps = loaders.map(&:tap) casks = taps.map { |tap| "#{tap}/#{token}" } cask_list = casks.sort.map { |f| "\n * #{f}" }.join super <<~EOS Cask #{token} exists in multiple taps:#{cask_list} Please use the fully-qualified name (e.g. #{casks.first}) to refer to a specific Cask. EOS end end # Error when a cask already exists. class CaskAlreadyCreatedError < AbstractCaskErrorWithToken sig { returns(String) } def to_s %Q(Cask '#{token}' already exists. Run #{Formatter.identifier("brew edit --cask #{token}")} to edit it.) end end # Error when there is a cyclic cask dependency. class CaskCyclicDependencyError < AbstractCaskErrorWithToken sig { returns(String) } def to_s "Cask '#{token}' includes cyclic dependencies on other Casks#{reason.empty? ? "." : ": #{reason}"}" end end # Error when a cask depends on itself. class CaskSelfReferencingDependencyError < CaskCyclicDependencyError sig { returns(String) } def to_s "Cask '#{token}' depends on itself." end end # Error when no cask is specified. class CaskUnspecifiedError < CaskError sig { returns(String) } def to_s "This command requires a Cask token." end end # Error when a cask is invalid. class CaskInvalidError < AbstractCaskErrorWithToken sig { returns(String) } def to_s "Cask '#{token}' definition is invalid#{reason.empty? ? "." : ": #{reason}"}" end end # Error when a cask token does not match the file name. class CaskTokenMismatchError < CaskInvalidError sig { params(token: T.any(String, Symbol, Cask), header_token: String).void } def initialize(token, header_token) super(token, "Token '#{header_token}' in header line does not match the file name.") end end # Error during quarantining of a file. class CaskQuarantineError < CaskError sig { returns(T.any(String, Pathname)) } attr_reader :path sig { returns(String) } attr_reader :reason sig { params(path: T.any(String, Pathname), reason: String).void } def initialize(path, reason) super() @path = path @reason = reason end sig { returns(String) } def to_s s = "Failed to quarantine #{path}." unless reason.empty? s << " Here's the reason:\n" s << Formatter.error(reason) s << "\n" unless reason.end_with?("\n") end s.freeze end end # Error while propagating quarantine information to subdirectories. class CaskQuarantinePropagationError < CaskQuarantineError sig { returns(String) } def to_s s = "Failed to quarantine one or more files within #{path}." unless reason.empty? s << " Here's the reason:\n" s << Formatter.error(reason) s << "\n" unless reason.end_with?("\n") end s.freeze end end # Error while removing quarantine information. class CaskQuarantineReleaseError < CaskQuarantineError sig { returns(String) } def to_s s = "Failed to release #{path} from quarantine." unless reason.empty? s << " Here's the reason:\n" s << Formatter.error(reason) s << "\n" unless reason.end_with?("\n") end s.freeze end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/info.rb000066400000000000000000000153301517265720000223070ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "json" require "cmd/info" require "utils/output" module Cask class Info extend ::Utils::Output::Mixin sig { params(cask: Cask).returns(String) } def self.get_info(cask) require "cask/installer" installed = cask.installed? output = "#{title_info(cask, installed:)}\n" output << "#{cask.desc}\n" if cask.desc output << "#{Formatter.url(cask.homepage)}\n" if cask.homepage deprecate_disable = DeprecateDisable.message(cask) if deprecate_disable.present? deprecate_disable.tap { |message| message[0] = message[0].upcase } output << "#{deprecate_disable}\n" end output << "#{installation_info(cask, installed:)}\n" repo = repo_info(cask) output << "#{repo}\n" if repo deps = deps_info(cask) output << deps if deps requirements = requirements_info(cask) output << requirements if requirements language = language_info(cask) output << language if language output << "#{artifact_info(cask)}\n" caveats = Installer.caveats(cask) output << caveats if caveats output end sig { params(cask: Cask, args: Homebrew::Cmd::Info::Args).void } def self.info(cask, args:) puts get_info(cask) return unless cask.tap&.core_cask_tap? require "utils/analytics" ::Utils::Analytics.cask_output(cask, args:) end sig { params(cask: Cask, installed: T::Boolean).returns(String) } def self.title_info(cask, installed:) name_with_status = if installed pretty_installed(cask.token) else pretty_uninstalled(cask.token) end title = oh1_title(name_with_status).to_s title += " (#{cask.name.join(", ")})" unless cask.name.empty? title += ": #{cask.version}" title += " (auto_updates)" if cask.auto_updates title end sig { params(cask: Cask, installed: T::Boolean).returns(String) } def self.installation_info(cask, installed:) return "Not installed" unless installed return "No installed version" unless (installed_version = cask.installed_version).present? versioned_staged_path = cask.caskroom_path.join(installed_version) tab = Tab.for_cask(cask) unless versioned_staged_path.exist? return "#{Homebrew::Cmd::Info.installation_status(tab)}\n" \ "#{versioned_staged_path} (#{Formatter.error("does not exist")})\n" end path_details = versioned_staged_path.children.sum(&:disk_usage) info = [Homebrew::Cmd::Info.installation_status(tab)] info << "#{versioned_staged_path} (#{Formatter.disk_usage_readable(path_details)})" info << " #{tab}" if tab.tabfile&.exist? info.join("\n") end sig { params(cask: Cask).returns(T.nilable(String)) } def self.deps_info(cask) depends_on = cask.depends_on formula_deps = Array(depends_on[:formula]).map do |dep| name = dep.to_s rack = HOMEBREW_CELLAR/name.split("/").last decorate_dependency(name, installed: rack.directory? && !rack.subdirs.empty?) end cask_deps = Array(depends_on[:cask]).map do |dep| name = dep.to_s decorate_dependency("#{name} (cask)", installed: (Caskroom.path/name).directory?) end all_deps = formula_deps + cask_deps return if all_deps.empty? formula_dependencies = T.let(Set.new, T::Set[String]) cask_dependencies = T.let(Set.new, T::Set[String]) Homebrew::Cmd::Info.collect_cask_dependency_names(cask, formula_dependencies, cask_dependencies, Set[cask.token]) recursive_count = formula_dependencies.count + cask_dependencies.count lines = T.let( [ohai_title("Dependencies").to_s, "Required (#{all_deps.count}): #{all_deps.join(", ")}"], T::Array[String], ) unless recursive_count.zero? installed_count = formula_dependencies.count do |name| rack = HOMEBREW_CELLAR/name.split("/").last rack.directory? && !rack.subdirs.empty? end + cask_dependencies.count do |name| (Caskroom.path/name).directory? end lines << "Recursive Runtime (#{recursive_count}): " \ "#{Homebrew::Cmd::Info.dependency_status_counts(installed_count, recursive_count)}" end "#{lines.join("\n")}\n" end sig { params(dep: String, installed: T::Boolean).returns(String) } def self.decorate_dependency(dep, installed:) installed ? pretty_installed(dep) : pretty_uninstalled(dep) end sig { params(cask: Cask).returns(T.nilable(String)) } def self.requirements_info(cask) require "cask_dependent" requirements = CaskDependent.new(cask).requirements.grep_v(CaskDependent::Requirement) return if requirements.empty? supports_linux = cask.supports_linux? output = "#{ohai_title("Requirements")}\n" %w[build required recommended optional].each do |type| reqs = case type when "build" requirements.select(&:build?) when "required" requirements.select(&:required?) when "recommended" requirements.select(&:recommended?) when "optional" requirements.select(&:optional?) else [] end next if reqs.empty? output << "#{type.capitalize}: #{reqs.map do |requirement| requirement_s = if requirement.is_a?(MacOSRequirement) && !supports_linux requirement.display_s.delete_suffix(" (or Linux)") else requirement.display_s end installed = requirement.satisfied? installed ? pretty_installed(requirement_s) : pretty_uninstalled(requirement_s) end.join(", ")}\n" end output end sig { params(cask: Cask).returns(T.nilable(String)) } def self.language_info(cask) return if cask.languages.empty? <<~EOS #{ohai_title("Languages")} #{cask.languages.join(", ")} EOS end sig { params(cask: Cask).returns(T.nilable(String)) } def self.repo_info(cask) return unless (tap = cask.tap) url = if tap.custom_remote? && !tap.remote.nil? tap.remote else "#{tap.default_remote}/blob/HEAD/#{tap.relative_cask_path(cask.token)}" end "From: #{Formatter.url(url)}" end sig { params(cask: Cask).returns(String) } def self.artifact_info(cask) artifact_output = ohai_title("Artifacts").dup cask.artifacts.each do |artifact| next unless artifact.respond_to?(:install_phase) next unless DSL::ORDINARY_ARTIFACT_CLASSES.include?(artifact.class) artifact_output << "\n" << artifact.to_s end artifact_output.freeze end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/installer.rb000066400000000000000000000736411517265720000233620ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "formula_installer" require "unpack_strategy" require "utils/topological_hash" require "utils/analytics" require "utils/output" require "cask/config" require "cask/download" require "cask/migrator" require "cask/quarantine" require "cask/tab" module Cask # Installer for a {Cask}. class Installer extend ::Utils::Output::Mixin include ::Utils::Output::Mixin sig { params( cask: ::Cask::Cask, command: T.class_of(SystemCommand), force: T::Boolean, adopt: T::Boolean, skip_cask_deps: T::Boolean, binaries: T::Boolean, verbose: T::Boolean, zap: T::Boolean, require_sha: T::Boolean, upgrade: T::Boolean, reinstall: T::Boolean, installed_as_dependency: T::Boolean, installed_on_request: T::Boolean, quarantine: T::Boolean, verify_download_integrity: T::Boolean, quiet: T::Boolean, download_queue: Homebrew::DownloadQueue, defer_fetch: T::Boolean ).void } def initialize(cask, command: SystemCommand, force: false, adopt: false, skip_cask_deps: false, binaries: true, verbose: false, zap: false, require_sha: false, upgrade: false, reinstall: false, installed_as_dependency: false, installed_on_request: true, quarantine: true, verify_download_integrity: true, quiet: false, download_queue: Homebrew.default_download_queue, defer_fetch: false) @cask = cask @command = command @force = force @adopt = adopt @skip_cask_deps = skip_cask_deps @binaries = binaries @verbose = verbose @zap = zap @require_sha = require_sha @reinstall = reinstall @upgrade = upgrade @installed_as_dependency = installed_as_dependency @installed_on_request = installed_on_request @quarantine = quarantine @verify_download_integrity = verify_download_integrity @quiet = quiet @download_queue = download_queue @defer_fetch = defer_fetch @ran_prelude = T.let(false, T::Boolean) @cask_and_formula_dependencies = T.let(nil, T.nilable(T::Array[T.any(Formula, ::Cask::Cask)])) end sig { returns(T::Boolean) } def adopt? = @adopt sig { returns(T::Boolean) } def binaries? = @binaries sig { returns(T::Boolean) } def force? = @force sig { returns(T::Boolean) } def installed_as_dependency? = @installed_as_dependency sig { returns(T::Boolean) } def installed_on_request? = @installed_on_request sig { returns(T::Boolean) } def quarantine? = @quarantine sig { returns(T::Boolean) } def quiet? = @quiet sig { returns(T::Boolean) } def reinstall? = @reinstall sig { returns(T::Boolean) } def require_sha? = @require_sha sig { returns(T::Boolean) } def skip_cask_deps? = @skip_cask_deps sig { returns(T::Boolean) } def upgrade? = @upgrade sig { returns(T::Boolean) } def verbose? = @verbose sig { returns(T::Boolean) } def zap? = @zap sig { params(cask: ::Cask::Cask).returns(T.nilable(String)) } def self.caveats(cask) odebug "Printing caveats" caveats = cask.caveats return if caveats.empty? Homebrew.messages.record_caveats(cask.token, caveats) <<~EOS #{ohai_title "Caveats"} #{caveats} EOS end sig { params(quiet: T.nilable(T::Boolean), timeout: T.nilable(T.any(Integer, Float))).void } def fetch(quiet: nil, timeout: nil) odebug "Cask::Installer#fetch" check_requirements load_cask_from_source_api! if cask_from_source_api? forbidden_tap_check forbidden_cask_and_formula_check forbidden_cask_artifacts_check download(quiet:, timeout:) unless @defer_fetch satisfy_cask_and_formula_dependencies end sig { void } def stage odebug "Cask::Installer#stage" Caskroom.ensure_caskroom_exists extract_primary_container process_rename_operations save_caskfile rescue => e purge_versioned_files raise e end sig { void } def install start_time = Time.now odebug "Cask::Installer#install" Migrator.migrate_if_needed(@cask) old_config = @cask.config predecessor = @cask if reinstall? && @cask.installed? prelude print caveats fetch uninstall_existing_cask if reinstall? backup if force? && @cask.staged_path.exist? && @cask.metadata_versioned_path.exist? oh1 "Installing Cask #{Formatter.identifier(@cask)}" # GitHub Actions globally disables Gatekeeper. unless quarantine? opoo_outside_github_actions "--no-quarantine bypasses macOS’s Gatekeeper, reducing system security. " \ "Do not use this flag unless you understand the risks." end stage @cask.config = @cask.default_config.merge(old_config) install_artifacts(predecessor:) tab = Tab.create(@cask) tab.installed_as_dependency = installed_as_dependency? tab.installed_on_request = installed_on_request? tab.write if (tap = @cask.tap) && tap.should_report_analytics? ::Utils::Analytics.report_package_event(:cask_install, package_name: @cask.token, tap_name: tap.name, on_request: true) end purge_backed_up_versioned_files puts summary end_time = Time.now Homebrew.messages.package_installed(@cask.token, end_time - start_time) rescue restore_backup raise end sig { void } def check_deprecate_disable deprecate_disable_type = DeprecateDisable.type(@cask) return if deprecate_disable_type.nil? message = DeprecateDisable.message(@cask).to_s message_full = "#{@cask.token} has been #{message}" case deprecate_disable_type when :deprecated opoo message_full when :disabled GitHub::Actions.puts_annotation_if_env_set!(:error, message) raise CaskCannotBeInstalledError.new(@cask, message) end end sig { void } def check_conflicts return unless @cask.conflicts_with @cask.conflicts_with[:cask].each do |conflicting_cask| if (conflicting_cask_tap_with_token = Tap.with_cask_token(conflicting_cask)) conflicting_cask_tap, = conflicting_cask_tap_with_token next unless conflicting_cask_tap.installed? end conflicting_cask = CaskLoader.load(conflicting_cask) raise CaskConflictError.new(@cask, conflicting_cask) if conflicting_cask.installed? rescue CaskUnavailableError next # Ignore conflicting Casks that do not exist. end end sig { void } def uninstall_existing_cask return unless @cask.installed? # Always force uninstallation, ignore method parameter cask_installer = Installer.new(@cask, verbose: verbose?, force: true, upgrade: upgrade?, reinstall: true) zap? ? cask_installer.zap : cask_installer.uninstall(successor: @cask) end sig { returns(String) } def summary s = +"" s << "#{Homebrew::EnvConfig.install_badge} " unless Homebrew::EnvConfig.no_emoji? s << "#{@cask} was successfully #{upgrade? ? "upgraded" : "installed"}!" s.freeze end sig { returns(Download) } def downloader @downloader ||= T.let( Download.new(@cask, quarantine: quarantine?, require_sha: require_sha? && !force?), T.nilable(Download), ) end sig { params(quiet: T.nilable(T::Boolean), timeout: T.nilable(T.any(Integer, Float))).returns(Pathname) } def download(quiet: nil, timeout: nil) # Store cask download path in cask to prevent multiple downloads in a row when checking if it's outdated @cask.download ||= downloader.fetch(quiet:, verify_download_integrity: @verify_download_integrity, timeout:) end sig { returns(UnpackStrategy) } def primary_container @primary_container ||= T.let( begin downloaded_path = download(quiet: true) UnpackStrategy.detect(downloaded_path, type: @cask.container&.type, merge_xattrs: true) end, T.nilable(UnpackStrategy), ) end sig { returns(ArtifactSet) } def artifacts @cask.artifacts end sig { params(to: Pathname).void } def extract_primary_container(to: @cask.staged_path) odebug "Extracting primary container" container = primary_container raise "unexpected nil primary_container" unless container odebug "Using container class #{container.class} for #{container.path}" basename = downloader.basename if (nested_container = @cask.container&.nested) Dir.mktmpdir("cask-installer", HOMEBREW_TEMP) do |tmpdir| tmpdir = Pathname(tmpdir) container.extract(to: tmpdir, basename:, verbose: verbose?) FileUtils.chmod_R "+rw", tmpdir/nested_container, force: true, verbose: verbose? UnpackStrategy.detect(tmpdir/nested_container, merge_xattrs: true) .extract_nestedly(to:, verbose: verbose?) end else container.extract_nestedly(to:, basename:, verbose: verbose?) end return unless quarantine? return unless Quarantine.available? Quarantine.propagate(from: container.path, to:) end sig { params(target_dir: T.nilable(Pathname)).void } def process_rename_operations(target_dir: nil) return if @cask.rename.empty? working_dir = target_dir || @cask.staged_path odebug "Processing rename operations in #{working_dir}" @cask.rename.each do |rename_operation| odebug "Renaming #{rename_operation.from} to #{rename_operation.to}" rename_operation.perform_rename(working_dir) end end sig { params(predecessor: T.nilable(Cask)).void } def install_artifacts(predecessor: nil) already_installed_artifacts = [] odebug "Installing artifacts" artifacts.each do |artifact| next unless artifact.respond_to?(:install_phase) odebug "Installing artifact of class #{artifact.class}" next if artifact.is_a?(Artifact::Binary) && !binaries? artifact = T.cast( artifact, T.any( Artifact::AbstractFlightBlock, Artifact::GeneratedCompletion, Artifact::Installer, Artifact::KeyboardLayout, Artifact::Mdimporter, Artifact::Moved, Artifact::Pkg, Artifact::Qlplugin, Artifact::Symlinked, ), ) artifact.install_phase( command: @command, verbose: verbose?, adopt: adopt?, auto_updates: @cask.auto_updates, force: force?, predecessor: ) already_installed_artifacts.unshift(artifact) end save_config_file save_download_sha if @cask.version.latest? rescue => e begin already_installed_artifacts&.each do |artifact| if artifact.respond_to?(:uninstall_phase) odebug "Reverting installation of artifact of class #{artifact.class}" artifact.uninstall_phase(command: @command, verbose: verbose?, force: force?) end next unless artifact.respond_to?(:post_uninstall_phase) odebug "Reverting installation of artifact of class #{artifact.class}" artifact.post_uninstall_phase(command: @command, verbose: verbose?, force: force?) end ensure purge_versioned_files raise e end end sig { void } def check_requirements check_stanza_os_requirements check_macos_requirements check_arch_requirements end sig { void } def check_stanza_os_requirements nil end sig { void } def check_macos_requirements return unless @cask.depends_on.macos return if @cask.depends_on.macos.satisfied? raise CaskError, @cask.depends_on.macos.message(type: :cask) end sig { void } def check_arch_requirements return if @cask.depends_on.arch.nil? @current_arch = T.let(@current_arch, T.nilable(T::Hash[Symbol, T.untyped])) @current_arch ||= { type: Hardware::CPU.type, bits: Hardware::CPU.bits } return if @cask.depends_on.arch.any? do |arch| arch[:type] == @current_arch[:type] && Array(arch[:bits]).include?(@current_arch[:bits]) end raise CaskError, "Cask #{@cask} depends on hardware architecture being one of " \ "[#{@cask.depends_on.arch.join(", ")}], " \ "but you are running #{@current_arch}." end sig { returns(T::Array[T.any(Formula, ::Cask::Cask)]) } def cask_and_formula_dependencies return @cask_and_formula_dependencies if @cask_and_formula_dependencies graph = ::Utils::TopologicalHash.graph_package_dependencies(@cask) raise CaskSelfReferencingDependencyError, @cask.token if graph.fetch(@cask).include?(@cask) pc = primary_container raise "unexpected nil primary_container" unless pc ::Utils::TopologicalHash.graph_package_dependencies(pc.dependencies, graph) begin @cask_and_formula_dependencies = graph.tsort - [@cask] rescue TSort::Cyclic strongly_connected_components = graph.strongly_connected_components.sort_by(&:count) cyclic_dependencies = strongly_connected_components.last - [@cask] raise CaskCyclicDependencyError.new(@cask.token, cyclic_dependencies.to_sentence) end end sig { returns(T::Array[T.any(Formula, ::Cask::Cask)]) } def missing_cask_and_formula_dependencies cask_and_formula_dependencies.reject do |cask_or_formula| case cask_or_formula when Formula cask_or_formula.any_version_installed? && cask_or_formula.optlinked? when Cask cask_or_formula.installed? end end end sig { void } def satisfy_cask_and_formula_dependencies return if installed_as_dependency? formulae_and_casks = cask_and_formula_dependencies return if formulae_and_casks.empty? missing_formulae_and_casks = missing_cask_and_formula_dependencies if missing_formulae_and_casks.empty? puts "All dependencies satisfied." return end ohai "Installing dependencies: #{missing_formulae_and_casks.join(", ")}" cask_installers = T.let([], T::Array[Installer]) formula_installers = T.let([], T::Array[FormulaInstaller]) missing_formulae_and_casks.each do |cask_or_formula| if cask_or_formula.is_a?(Cask) if skip_cask_deps? opoo "`--skip-cask-deps` is set; skipping installation of #{cask_or_formula}." next end cask_installers << Installer.new( cask_or_formula, adopt: adopt?, binaries: binaries?, force: false, installed_as_dependency: true, installed_on_request: false, quarantine: quarantine?, quiet: quiet?, require_sha: require_sha?, verbose: verbose?, ) else formula_installers << FormulaInstaller.new( cask_or_formula, **{ show_header: true, installed_as_dependency: true, installed_on_request: false, verbose: verbose?, }.compact, ) end end cask_installers.each(&:install) return if formula_installers.blank? Homebrew::Install.perform_preinstall_checks_once valid_formula_installers = Homebrew::Install.fetch_formulae(formula_installers) valid_formula_installers.each do |formula_installer| formula_installer.install formula_installer.finish end end sig { returns(T.nilable(String)) } def caveats self.class.caveats(@cask) end sig { returns(Pathname) } def metadata_subdir @metadata_subdir ||= T.let( begin msd = @cask.metadata_subdir("Casks", timestamp: :now, create: true) raise "unexpected nil metadata_subdir" unless msd msd end, T.nilable(Pathname), ) end sig { void } def save_caskfile old_savedir = @cask.metadata_timestamped_path return if @cask.source.blank? extension = if @cask.loaded_from_internal_api? "internal.json" elsif @cask.loaded_from_api? "json" else "rb" end source = if @cask.loaded_from_internal_api? && (api_source = @cask.api_source) api_source = api_source.merge({ "tap_git_head" => @cask.tap_git_head }) JSON.pretty_generate(api_source) else @cask.source end (metadata_subdir/"#{@cask.token}.#{extension}").write source FileUtils.rm_r(old_savedir) if old_savedir end sig { void } def save_config_file @cask.config_path.atomic_write(@cask.config.to_json) end sig { void } def save_download_sha return unless @cask.checksumable? @cask.download_sha_path.atomic_write(@cask.new_download_sha) end sig { params(successor: T.nilable(Cask)).void } def uninstall(successor: nil) load_installed_caskfile! oh1 "Uninstalling Cask #{Formatter.identifier(@cask)}" uninstall_artifacts(clear: true, successor:) if !reinstall? && !upgrade? remove_tabfile remove_download_sha remove_config_file end purge_versioned_files purge_caskroom_path if force? end sig { void } def remove_tabfile tabfile = @cask.tab.tabfile FileUtils.rm_f tabfile if tabfile @cask.config_path.parent.rmdir_if_possible end sig { void } def remove_config_file FileUtils.rm_f @cask.config_path @cask.config_path.parent.rmdir_if_possible end sig { void } def remove_download_sha FileUtils.rm_f @cask.download_sha_path @cask.download_sha_path.parent.rmdir_if_possible end sig { params(successor: T.nilable(Cask)).void } def start_upgrade(successor:) uninstall_artifacts(successor:) backup end sig { void } def backup bp = backup_path raise "unexpected nil backup_path" unless bp bmp = backup_metadata_path raise "unexpected nil backup_metadata_path" unless bmp @cask.staged_path.rename bp.to_s @cask.metadata_versioned_path.rename bmp.to_s end sig { void } def restore_backup bp = backup_path return unless bp bmp = backup_metadata_path return unless bmp return if !bp.directory? || !bmp.directory? FileUtils.rm_r(@cask.staged_path) if @cask.staged_path.exist? FileUtils.rm_r(@cask.metadata_versioned_path) if @cask.metadata_versioned_path.exist? bp.rename @cask.staged_path.to_s bmp.rename @cask.metadata_versioned_path.to_s end sig { params(predecessor: Cask).void } def revert_upgrade(predecessor:) opoo "Reverting upgrade for Cask #{@cask}" restore_backup install_artifacts(predecessor:) end sig { void } def finalize_upgrade ohai "Purging files for version #{@cask.version} of Cask #{@cask}" purge_backed_up_versioned_files puts summary end sig { params(clear: T::Boolean, successor: T.nilable(Cask)).void } def uninstall_artifacts(clear: false, successor: nil) odebug "Uninstalling artifacts" odebug "#{::Utils.pluralize("artifact", artifacts.length, include_count: true)} defined", artifacts artifacts.each do |artifact| if artifact.respond_to?(:uninstall_phase) artifact = T.cast( artifact, T.any( Artifact::AbstractFlightBlock, Artifact::GeneratedCompletion, Artifact::KeyboardLayout, Artifact::Moved, Artifact::Qlplugin, Artifact::Symlinked, Artifact::Uninstall, ), ) odebug "Uninstalling artifact of class #{artifact.class}" artifact.uninstall_phase( command: @command, verbose: verbose?, skip: clear, force: force?, successor:, upgrade: upgrade?, reinstall: reinstall?, ) end next unless artifact.respond_to?(:post_uninstall_phase) artifact = T.cast(artifact, Artifact::Uninstall) odebug "Post-uninstalling artifact of class #{artifact.class}" artifact.post_uninstall_phase( command: @command, verbose: verbose?, skip: clear, force: force?, successor:, ) end end sig { void } def zap load_installed_caskfile! uninstall_artifacts if (zap_stanzas = @cask.artifacts.grep(Artifact::Zap)).empty? opoo "No zap stanza present for Cask '#{@cask}'" else ohai "Dispatching zap stanza" zap_stanzas.each do |stanza| stanza.zap_phase(command: @command, verbose: verbose?, force: force?) end end ohai "Removing all staged versions of Cask '#{@cask}'" purge_caskroom_path end sig { returns(T.nilable(Pathname)) } def backup_path return if @cask.staged_path.nil? Pathname("#{@cask.staged_path}.upgrading") end sig { returns(T.nilable(Pathname)) } def backup_metadata_path return if @cask.metadata_versioned_path.nil? Pathname("#{@cask.metadata_versioned_path}.upgrading") end sig { params(path: Pathname).void } def gain_permissions_remove(path) Utils.gain_permissions_remove(path, command: @command) end sig { void } def purge_backed_up_versioned_files # versioned staged distribution gain_permissions_remove(T.must(backup_path)) if backup_path&.exist? # Homebrew Cask metadata bmp = backup_metadata_path return unless bmp&.directory? bmp.children.each do |subdir| gain_permissions_remove(subdir) end bmp.rmdir_if_possible end sig { void } def purge_versioned_files ohai "Purging files for version #{@cask.version} of Cask #{@cask}" # versioned staged distribution gain_permissions_remove(@cask.staged_path) if @cask.staged_path&.exist? # Homebrew Cask metadata if @cask.metadata_versioned_path.directory? @cask.metadata_versioned_path.children.each do |subdir| gain_permissions_remove(subdir) end @cask.metadata_versioned_path.rmdir_if_possible end @cask.metadata_main_container_path.rmdir_if_possible unless upgrade? # toplevel staged distribution @cask.caskroom_path.rmdir_if_possible unless upgrade? # Remove symlinks for renamed casks if they are now broken. @cask.old_tokens.each do |old_token| old_caskroom_path = Caskroom.path/old_token FileUtils.rm old_caskroom_path if old_caskroom_path.symlink? && !old_caskroom_path.exist? end end sig { void } def purge_caskroom_path odebug "Purging all staged versions of Cask #{@cask}" gain_permissions_remove(@cask.caskroom_path) end sig { void } def forbidden_tap_check return if Tap.allowed_taps.blank? && Tap.forbidden_taps.blank? owner = Homebrew::EnvConfig.forbidden_owner owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence) "\n#{contact}" end unless skip_cask_deps? cask_and_formula_dependencies.each do |cask_or_formula| dep_tap = cask_or_formula.tap next if dep_tap.blank? || (dep_tap.allowed_by_env? && !dep_tap.forbidden_by_env?) dep_full_name = cask_or_formula.full_name error_message = "The installation of #{@cask} has a dependency #{dep_full_name}\n" \ "from the #{dep_tap} tap but #{owner} " error_message << "has not allowed this tap in `$HOMEBREW_ALLOWED_TAPS`" unless dep_tap.allowed_by_env? error_message << " and\n" if !dep_tap.allowed_by_env? && dep_tap.forbidden_by_env? error_message << "has forbidden this tap in `$HOMEBREW_FORBIDDEN_TAPS`" if dep_tap.forbidden_by_env? error_message << ".#{owner_contact}" raise CaskCannotBeInstalledError.new(@cask, error_message) end end cask_tap = @cask.tap return if cask_tap.blank? || (cask_tap.allowed_by_env? && !cask_tap.forbidden_by_env?) error_message = "The installation of #{@cask.full_name} has the tap #{cask_tap}\n" \ "but #{owner} " error_message << "has not allowed this tap in `$HOMEBREW_ALLOWED_TAPS`" unless cask_tap.allowed_by_env? error_message << " and\n" if !cask_tap.allowed_by_env? && cask_tap.forbidden_by_env? error_message << "has forbidden this tap in `$HOMEBREW_FORBIDDEN_TAPS`" if cask_tap.forbidden_by_env? error_message << ".#{owner_contact}" raise CaskCannotBeInstalledError.new(@cask, error_message) end sig { void } def forbidden_cask_and_formula_check forbid_casks = Homebrew::EnvConfig.forbid_casks? forbidden_formulae = Set.new(Homebrew::EnvConfig.forbidden_formulae.to_s.split) forbidden_casks = Set.new(Homebrew::EnvConfig.forbidden_casks.to_s.split) return if !forbid_casks && forbidden_formulae.blank? && forbidden_casks.blank? owner = Homebrew::EnvConfig.forbidden_owner owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence) "\n#{contact}" end unless skip_cask_deps? cask_and_formula_dependencies.each do |dep_cask_or_formula| dep_name, dep_type, variable = if dep_cask_or_formula.is_a?(Cask) && forbidden_casks.present? dep_cask = dep_cask_or_formula env_variable = "HOMEBREW_FORBIDDEN_CASKS" dep_cask_name = if forbid_casks env_variable = "HOMEBREW_FORBID_CASKS" dep_cask.token elsif forbidden_casks.include?(dep_cask.full_name) dep_cask.token elsif dep_cask.tap.present? && forbidden_casks.include?(dep_cask.full_name) dep_cask.full_name end [dep_cask_name, "cask", env_variable] elsif dep_cask_or_formula.is_a?(Formula) && forbidden_formulae.present? dep_formula = dep_cask_or_formula formula_name = if forbidden_formulae.include?(dep_formula.name) dep_formula.name elsif dep_formula.tap.present? && forbidden_formulae.include?(dep_formula.full_name) dep_formula.full_name end [formula_name, "formula", "HOMEBREW_FORBIDDEN_FORMULAE"] end next if dep_name.blank? raise CaskCannotBeInstalledError.new(@cask, <<~EOS has a dependency #{dep_name} but the #{dep_name} #{dep_type} was forbidden for installation by #{owner} in `#{variable}`.#{owner_contact} EOS ) end end return if !forbid_casks && forbidden_casks.blank? variable = "HOMEBREW_FORBIDDEN_CASKS" if forbid_casks variable = "HOMEBREW_FORBID_CASKS" @cask.token elsif forbidden_casks.include?(@cask.token) @cask.token elsif forbidden_casks.include?(@cask.full_name) @cask.full_name else return end raise CaskCannotBeInstalledError.new(@cask, <<~EOS forbidden for installation by #{owner} in `#{variable}`.#{owner_contact} EOS ) end sig { void } def forbidden_cask_artifacts_check forbidden_artifacts = Set.new(Homebrew::EnvConfig.forbidden_cask_artifacts.to_s.split) return if forbidden_artifacts.blank? owner = Homebrew::EnvConfig.forbidden_owner owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence) "\n#{contact}" end artifacts.each do |artifact| # Get the artifact class name (e.g., "Pkg", "Installer", "App") artifact_name = artifact.class.name next if artifact_name.nil? artifact_type = artifact_name.split("::").last&.downcase next if artifact_type.nil? next unless forbidden_artifacts.include?(artifact_type) raise CaskCannotBeInstalledError.new(@cask, <<~EOS contains a '#{artifact_type}' artifact, which is forbidden for installation by #{owner} in `HOMEBREW_FORBIDDEN_CASK_ARTIFACTS`.#{owner_contact} EOS ) end end sig { void } def prelude return if @ran_prelude check_deprecate_disable check_conflicts @ran_prelude = true end sig { void } def enqueue_downloads download_queue = @download_queue check_requirements # FIXME: We need to load Cask source before enqueuing to support # language-specific URLs, but this will block the main process. if cask_from_source_api? if @cask.languages.any? load_cask_from_source_api! else Homebrew::API::Cask.source_download(@cask, download_queue:, enqueue: true) end end download_queue.enqueue(downloader) end private # load the same cask file that was used for installation, if possible sig { void } def load_installed_caskfile! Migrator.migrate_if_needed(@cask) installed_caskfile = @cask.installed_caskfile if installed_caskfile&.exist? begin @cask = CaskLoader.load_from_installed_caskfile(installed_caskfile) return rescue CaskInvalidError, CaskUnavailableError # could be caused by trying to load outdated or deleted caskfile end end load_cask_from_source_api! if cask_from_source_api? # otherwise we default to the current cask end sig { void } def load_cask_from_source_api! @cask = Homebrew::API::Cask.source_download_cask(@cask) end sig { returns(T::Boolean) } def cask_from_source_api? @cask.loaded_from_api? && @cask.caskfile_only? end end end require "extend/os/cask/installer" Homebrew-brew-d7f73ce/Library/Homebrew/cask/list.rb000066400000000000000000000035501517265720000223300ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/artifact/relocated" require "utils/output" module Cask module List extend ::Utils::Output::Mixin TAP_AND_NAME_COMPARISON = T.let( proc do |a, b| if a.include?("/") && b.exclude?("/") 1 elsif a.exclude?("/") && b.include?("/") -1 else a <=> b end end.freeze, T.proc.params(a: String, b: String).returns(Integer), ) sig { params(casks: Cask, one: T::Boolean, full_name: T::Boolean, versions: T::Boolean).void } def self.list_casks(*casks, one: false, full_name: false, versions: false) output = if casks.any? casks.each do |cask| raise CaskNotInstalledError, cask unless cask.installed? end else Caskroom.casks end if one puts output.map(&:to_s) elsif full_name puts output.map(&:full_name).sort(&TAP_AND_NAME_COMPARISON) elsif versions puts output.map { format_versioned(it) } elsif !output.empty? && casks.any? output.map { list_artifacts(it) } elsif !output.empty? puts Formatter.columns(output.map(&:to_s)) end end sig { params(cask: Cask).void } def self.list_artifacts(cask) cask.artifacts.group_by(&:class).sort_by { |klass, _| klass.english_name }.each do |klass, artifacts| next if [Artifact::Uninstall, Artifact::Zap].include? klass ohai klass.english_name artifacts.each do |artifact| puts artifact.summarize_installed if artifact.respond_to?(:summarize_installed) next if artifact.respond_to?(:summarize_installed) puts artifact end end end sig { params(cask: Cask).returns(String) } def self.format_versioned(cask) "#{cask}#{cask.installed_version&.prepend(" ")}" end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/macos.rb000066400000000000000000000266741517265720000224730ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module OS module Mac SYSTEM_DIRS = T.let([ "/", "/Applications", "/Applications/Utilities", "/Incompatible Software", "/Library", "/Library/Application Support", "/Library/Audio", "/Library/Caches", "/Library/ColorPickers", "/Library/ColorSync", "/Library/Components", "/Library/Compositions", "/Library/Contextual Menu Items", "/Library/CoreMediaIO", "/Library/Desktop Pictures", "/Library/Developer", "/Library/Dictionaries", "/Library/DirectoryServices", "/Library/Documentation", "/Library/Extensions", "/Library/Filesystems", "/Library/Fonts", "/Library/Frameworks", "/Library/Graphics", "/Library/Image Capture", "/Library/Input Methods", "/Library/Internet Plug-Ins", "/Library/Java", "/Library/Java/Extensions", "/Library/Java/JavaVirtualMachines", "/Library/Keyboard Layouts", "/Library/Keychains", "/Library/LaunchAgents", "/Library/LaunchDaemons", "/Library/Logs", "/Library/Messages", "/Library/Modem Scripts", "/Library/OpenDirectory", "/Library/PDF Services", "/Library/Perl", "/Library/PreferencePanes", "/Library/Preferences", "/Library/Printers", "/Library/PrivilegedHelperTools", "/Library/Python", "/Library/QuickLook", "/Library/QuickTime", "/Library/Receipts", "/Library/Ruby", "/Library/Sandbox", "/Library/Screen Savers", "/Library/ScriptingAdditions", "/Library/Scripts", "/Library/Security", "/Library/Speech", "/Library/Spelling", "/Library/Spotlight", "/Library/StartupItems", "/Library/SystemProfiler", "/Library/Updates", "/Library/User Pictures", "/Library/Video", "/Library/WebServer", "/Library/Widgets", "/Library/iTunes", "/Network", "/System", "/System/Library", "/System/Library/Accessibility", "/System/Library/Accounts", "/System/Library/Address Book Plug-Ins", "/System/Library/Assistant", "/System/Library/Automator", "/System/Library/BridgeSupport", "/System/Library/Caches", "/System/Library/ColorPickers", "/System/Library/ColorSync", "/System/Library/Colors", "/System/Library/Components", "/System/Library/Compositions", "/System/Library/CoreServices", "/System/Library/DTDs", "/System/Library/DirectoryServices", "/System/Library/Displays", "/System/Library/Extensions", "/System/Library/Filesystems", "/System/Library/Filters", "/System/Library/Fonts", "/System/Library/Frameworks", "/System/Library/Graphics", "/System/Library/IdentityServices", "/System/Library/Image Capture", "/System/Library/Input Methods", "/System/Library/InternetAccounts", "/System/Library/Java", "/System/Library/KerberosPlugins", "/System/Library/Keyboard Layouts", "/System/Library/Keychains", "/System/Library/LaunchAgents", "/System/Library/LaunchDaemons", "/System/Library/LinguisticData", "/System/Library/LocationBundles", "/System/Library/LoginPlugins", "/System/Library/Messages", "/System/Library/Metadata", "/System/Library/MonitorPanels", "/System/Library/OpenDirectory", "/System/Library/OpenSSL", "/System/Library/Password Server Filters", "/System/Library/PerformanceMetrics", "/System/Library/Perl", "/System/Library/PreferencePanes", "/System/Library/Printers", "/System/Library/PrivateFrameworks", "/System/Library/QuickLook", "/System/Library/QuickTime", "/System/Library/QuickTimeJava", "/System/Library/Recents", "/System/Library/SDKSettingsPlist", "/System/Library/Sandbox", "/System/Library/Screen Savers", "/System/Library/ScreenReader", "/System/Library/ScriptingAdditions", "/System/Library/ScriptingDefinitions", "/System/Library/Security", "/System/Library/Services", "/System/Library/Sounds", "/System/Library/Speech", "/System/Library/Spelling", "/System/Library/Spotlight", "/System/Library/StartupItems", "/System/Library/SyncServices", "/System/Library/SystemConfiguration", "/System/Library/SystemProfiler", "/System/Library/Tcl", "/System/Library/TextEncodings", "/System/Library/User Template", "/System/Library/UserEventPlugins", "/System/Library/Video", "/System/Library/WidgetResources", "/User Information", "/Users", "/Volumes", "/bin", "/boot", "/cores", "/dev", "/etc", "/etc/X11", "/etc/opt", "/etc/sgml", "/etc/xml", "/home", "/libexec", "/lost+found", "/media", "/mnt", "/net", "/opt", "/private", "/private/etc", "/private/tftpboot", "/private/tmp", "/private/var", "/proc", "/root", "/sbin", "/srv", "/tmp", "/usr", "/usr/X11R6", "/usr/bin", "/usr/etc", "/usr/include", "/usr/lib", "/usr/libexec", "/usr/libexec/cups", "/usr/local", "/usr/local/Cellar", "/usr/local/Frameworks", "/usr/local/Library", "/usr/local/bin", "/usr/local/etc", "/usr/local/include", "/usr/local/lib", "/usr/local/libexec", "/usr/local/opt", "/usr/local/share", "/usr/local/share/man", "/usr/local/share/man/man1", "/usr/local/share/man/man2", "/usr/local/share/man/man3", "/usr/local/share/man/man4", "/usr/local/share/man/man5", "/usr/local/share/man/man6", "/usr/local/share/man/man7", "/usr/local/share/man/man8", "/usr/local/share/man/man9", "/usr/local/share/man/mann", "/usr/local/var", "/usr/local/var/lib", "/usr/local/var/lock", "/usr/local/var/run", "/usr/sbin", "/usr/share", "/usr/share/man", "/usr/share/man/man1", "/usr/share/man/man2", "/usr/share/man/man3", "/usr/share/man/man4", "/usr/share/man/man5", "/usr/share/man/man6", "/usr/share/man/man7", "/usr/share/man/man8", "/usr/share/man/man9", "/usr/share/man/mann", "/usr/src", "/var", "/var/cache", "/var/lib", "/var/lock", "/var/log", "/var/mail", "/var/run", "/var/spool", "/var/spool/mail", "/var/tmp", ] .to_set { |path| ::Pathname.new(path) } .freeze, T::Set[::Pathname]) private_constant :SYSTEM_DIRS # TODO: There should be a way to specify a containing # directory under which nothing can be deleted. UNDELETABLE_PATHS = T.let([ "~/", "~/Applications", "~/Applications/.localized", "~/Desktop", "~/Desktop/.localized", "~/Documents", "~/Documents/.localized", "~/Downloads", "~/Downloads/.localized", "~/Mail", "~/Movies", "~/Movies/.localized", "~/Music", "~/Music/.localized", "~/Music/iTunes", "~/Music/iTunes/iTunes Music", "~/Music/iTunes/Album Artwork", "~/News", "~/Pictures", "~/Pictures/.localized", "~/Pictures/Desktops", "~/Pictures/Photo Booth", "~/Pictures/iChat Icons", "~/Pictures/iPhoto Library", "~/Public", "~/Public/.localized", "~/Sites", "~/Sites/.localized", "~/Library", "~/Library/.localized", "~/Library/Accessibility", "~/Library/Accounts", "~/Library/Address Book Plug-Ins", "~/Library/Application Scripts", "~/Library/Application Support", "~/Library/Application Support/Apple", "~/Library/Application Support/com.apple.AssistiveControl", "~/Library/Application Support/com.apple.QuickLook", "~/Library/Application Support/com.apple.TCC", "~/Library/Assistants", "~/Library/Audio", "~/Library/Automator", "~/Library/Autosave Information", "~/Library/Caches", "~/Library/Calendars", "~/Library/ColorPickers", "~/Library/ColorSync", "~/Library/Colors", "~/Library/Components", "~/Library/Compositions", "~/Library/Containers", "~/Library/Contextual Menu Items", "~/Library/Cookies", "~/Library/DTDs", "~/Library/Desktop Pictures", "~/Library/Developer", "~/Library/Dictionaries", "~/Library/DirectoryServices", "~/Library/Displays", "~/Library/Documentation", "~/Library/Extensions", "~/Library/Favorites", "~/Library/FileSync", "~/Library/Filesystems", "~/Library/Filters", "~/Library/FontCollections", "~/Library/Fonts", "~/Library/Frameworks", "~/Library/GameKit", "~/Library/Graphics", "~/Library/Group Containers", "~/Library/Icons", "~/Library/IdentityServices", "~/Library/Image Capture", "~/Library/Images", "~/Library/Input Methods", "~/Library/Internet Plug-Ins", "~/Library/InternetAccounts", "~/Library/iTunes", "~/Library/KeyBindings", "~/Library/Keyboard Layouts", "~/Library/Keychains", "~/Library/LaunchAgents", "~/Library/LaunchDaemons", "~/Library/LocationBundles", "~/Library/LoginPlugins", "~/Library/Logs", "~/Library/Mail", "~/Library/Mail Downloads", "~/Library/Messages", "~/Library/Metadata", "~/Library/Mobile Documents", "~/Library/MonitorPanels", "~/Library/OpenDirectory", "~/Library/PDF Services", "~/Library/PhonePlugins", "~/Library/Phones", "~/Library/PreferencePanes", "~/Library/Preferences", "~/Library/Printers", "~/Library/PrivateFrameworks", "~/Library/PubSub", "~/Library/QuickLook", "~/Library/QuickTime", "~/Library/Receipts", "~/Library/Recent Servers", "~/Library/Recents", "~/Library/Safari", "~/Library/Saved Application State", "~/Library/Screen Savers", "~/Library/ScreenReader", "~/Library/ScriptingAdditions", "~/Library/ScriptingDefinitions", "~/Library/Scripts", "~/Library/Security", "~/Library/Services", "~/Library/Sounds", "~/Library/Speech", "~/Library/Spelling", "~/Library/Spotlight", "~/Library/StartupItems", "~/Library/StickiesDatabase", "~/Library/Sync Services", "~/Library/SyncServices", "~/Library/SyncedPreferences", "~/Library/TextEncodings", "~/Library/User Pictures", "~/Library/Video", "~/Library/Voices", "~/Library/WebKit", "~/Library/WidgetResources", "~/Library/Widgets", "~/Library/Workflows", ] .to_set { |path| ::Pathname.new(path.sub(%r{^~(?=(/|$))}, Dir.home)).expand_path } .union(SYSTEM_DIRS) .freeze, T::Set[::Pathname]) private_constant :UNDELETABLE_PATHS sig { params(dir: T.any(::Pathname, String)).returns(T::Boolean) } def self.system_dir?(dir) SYSTEM_DIRS.include?(::Pathname.new(dir).expand_path) end sig { params(path: T.any(::Pathname, String)).returns(T::Boolean) } def self.undeletable?(path) UNDELETABLE_PATHS.include?(::Pathname.new(path).expand_path) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/metadata.rb000066400000000000000000000060711517265720000231360ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/output" module Cask # Helper module for reading and writing cask metadata. module Metadata extend T::Helpers include ::Utils::Output::Mixin METADATA_SUBDIR = ".metadata" TIMESTAMP_FORMAT = "%Y%m%d%H%M%S.%L" requires_ancestor { Cask } sig { params(caskroom_path: Pathname).returns(Pathname) } def metadata_main_container_path(caskroom_path: self.caskroom_path) caskroom_path.join(METADATA_SUBDIR) end sig { params(version: T.nilable(T.any(DSL::Version, String)), caskroom_path: Pathname).returns(Pathname) } def metadata_versioned_path(version: self.version, caskroom_path: self.caskroom_path) cask_version = (version || :unknown).to_s raise CaskError, "Cannot create metadata path with empty version." if cask_version.empty? metadata_main_container_path(caskroom_path:).join(cask_version) end sig { params( version: T.nilable(T.any(DSL::Version, String)), timestamp: T.any(Symbol, String), create: T::Boolean, caskroom_path: Pathname, ).returns(T.nilable(Pathname)) } def metadata_timestamped_path(version: self.version, timestamp: :latest, create: false, caskroom_path: self.caskroom_path) case timestamp when :latest raise CaskError, "Cannot create metadata path when timestamp is :latest." if create return Pathname.glob(metadata_versioned_path(version:, caskroom_path:).join("*")).max when :now timestamp = new_timestamp when Symbol raise CaskError, "Invalid timestamp symbol :#{timestamp}. Valid symbols are :latest and :now." end path = metadata_versioned_path(version:, caskroom_path:).join(timestamp) if create && !path.directory? odebug "Creating metadata directory: #{path}" path.mkpath end path end sig { params( leaf: String, version: T.nilable(T.any(DSL::Version, String)), timestamp: T.any(Symbol, String), create: T::Boolean, caskroom_path: Pathname, ).returns(T.nilable(Pathname)) } def metadata_subdir(leaf, version: self.version, timestamp: :latest, create: false, caskroom_path: self.caskroom_path) raise CaskError, "Cannot create metadata subdir when timestamp is :latest." if create && timestamp == :latest raise CaskError, "Cannot create metadata subdir for empty leaf." if !leaf.respond_to?(:empty?) || leaf.empty? parent = metadata_timestamped_path(version:, timestamp:, create:, caskroom_path:) return if parent.nil? subdir = parent.join(leaf) if create && !subdir.directory? odebug "Creating metadata subdirectory: #{subdir}" subdir.mkpath end subdir end private sig { params(time: Time).returns(String) } def new_timestamp(time = Time.now) time.utc.strftime(TIMESTAMP_FORMAT) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/migrator.rb000066400000000000000000000057321517265720000232050ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/inreplace" require "utils/output" module Cask class Migrator include ::Utils::Output::Mixin sig { returns(Cask) } attr_reader :old_cask, :new_cask sig { params(old_cask: Cask, new_cask: Cask).void } def initialize(old_cask, new_cask) raise CaskNotInstalledError, new_cask unless new_cask.installed? @old_cask = old_cask @new_cask = new_cask end sig { params(new_cask: Cask, dry_run: T::Boolean).void } def self.migrate_if_needed(new_cask, dry_run: false) old_tokens = new_cask.old_tokens return if old_tokens.empty? return unless (installed_caskfile = new_cask.installed_caskfile) installed_token = installed_caskfile.basename(installed_caskfile.extname).to_s return if new_cask.token == installed_token old_cask = Cask.new(installed_token) migrator = new(old_cask, new_cask) migrator.migrate(dry_run:) end sig { params(dry_run: T::Boolean).void } def migrate(dry_run: false) old_token = old_cask.token new_token = new_cask.token old_caskroom_path = old_cask.caskroom_path new_caskroom_path = new_cask.caskroom_path old_caskfile = old_cask.installed_caskfile return if old_caskfile.nil? old_installed_caskfile = old_caskfile.relative_path_from(old_caskroom_path) new_installed_caskfile = old_installed_caskfile.dirname/old_installed_caskfile.basename.sub( old_token, new_token, ) if dry_run oh1 "Would migrate cask #{Formatter.identifier(old_token)} to #{Formatter.identifier(new_token)}" puts "cp -r #{old_caskroom_path} #{new_caskroom_path}" puts "mv #{new_caskroom_path}/#{old_installed_caskfile} #{new_caskroom_path}/#{new_installed_caskfile}" puts "rm -r #{old_caskroom_path}" puts "ln -s #{new_caskroom_path.basename} #{old_caskroom_path}" else oh1 "Migrating cask #{Formatter.identifier(old_token)} to #{Formatter.identifier(new_token)}" begin FileUtils.cp_r old_caskroom_path, new_caskroom_path FileUtils.mv new_caskroom_path/old_installed_caskfile, new_caskroom_path/new_installed_caskfile self.class.replace_caskfile_token(new_caskroom_path/new_installed_caskfile, old_token, new_token) rescue => e FileUtils.rm_rf new_caskroom_path raise e end FileUtils.rm_r old_caskroom_path FileUtils.ln_s new_caskroom_path.basename, old_caskroom_path end end sig { params(path: Pathname, old_token: String, new_token: String).void } def self.replace_caskfile_token(path, old_token, new_token) case path.extname when ".rb" ::Utils::Inreplace.inreplace path, /\A\s*cask\s+"#{Regexp.escape(old_token)}"/, "cask #{new_token.inspect}" when ".json" json = JSON.parse(path.read) json["token"] = new_token path.atomic_write json.to_json end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/pkg.rb000066400000000000000000000102351517265720000221340ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask/macos" require "utils/output" module Cask # Helper class for uninstalling `.pkg` installers. class Pkg include ::Utils::Output::Mixin sig { params(regexp: String, command: T.class_of(SystemCommand)).returns(T::Array[Pkg]) } def self.all_matching(regexp, command) command.run("/usr/sbin/pkgutil", args: ["--pkgs=#{regexp}"]).stdout.split("\n").map do |package_id| new(package_id.chomp, command) end end sig { returns(String) } attr_reader :package_id sig { params(package_id: String, command: T.class_of(SystemCommand)).void } def initialize(package_id, command = SystemCommand) @package_id = package_id @command = command end sig { void } def uninstall unless pkgutil_bom_files.empty? odebug "Deleting pkg files" @command.run!( "/usr/bin/xargs", args: ["-0", "--", "/bin/rm", "--"], input: pkgutil_bom_files.join("\0"), sudo: true, sudo_as_root: true, ) end unless pkgutil_bom_specials.empty? odebug "Deleting pkg symlinks and special files" @command.run!( "/usr/bin/xargs", args: ["-0", "--", "/bin/rm", "--"], input: pkgutil_bom_specials.join("\0"), sudo: true, sudo_as_root: true, ) end unless pkgutil_bom_dirs.empty? odebug "Deleting pkg directories" rmdir(deepest_path_first(pkgutil_bom_dirs)) end rmdir(root) unless MacOS.undeletable?(root) forget end sig { void } def forget odebug "Unregistering pkg receipt (aka forgetting)" @command.run!( "/usr/sbin/pkgutil", args: ["--forget", package_id], sudo: true, sudo_as_root: true, ) end sig { returns(T::Array[Pathname]) } def pkgutil_bom_files @pkgutil_bom_files ||= T.let(pkgutil_bom_all.select(&:file?) - pkgutil_bom_specials, T.nilable(T::Array[Pathname])) end sig { returns(T::Array[Pathname]) } def pkgutil_bom_specials @pkgutil_bom_specials ||= T.let(pkgutil_bom_all.select { special?(it) }, T.nilable(T::Array[Pathname])) end sig { returns(T::Array[Pathname]) } def pkgutil_bom_dirs @pkgutil_bom_dirs ||= T.let(pkgutil_bom_all.select(&:directory?) - pkgutil_bom_specials, T.nilable(T::Array[Pathname])) end sig { returns(T::Array[Pathname]) } def pkgutil_bom_all @pkgutil_bom_all ||= T.let( @command.run!("/usr/sbin/pkgutil", args: ["--files", package_id]) .stdout .split("\n") .map { |path| root.join(path) } .reject { |path| MacOS.undeletable?(path) }, T.nilable(T::Array[Pathname]), ) end sig { returns(Pathname) } def root @root ||= T.let(Pathname.new(info.fetch("volume")).join(info.fetch("install-location")), T.nilable(Pathname)) end sig { returns(T.untyped) } def info @info ||= T.let(@command.run!("/usr/sbin/pkgutil", args: ["--pkg-info-plist", package_id]).plist, T.untyped) end private sig { params(path: Pathname).returns(T::Boolean) } def special?(path) path.symlink? || path.chardev? || path.blockdev? end # Helper script to delete empty directories after deleting `.DS_Store` files and broken symlinks. # Needed in order to execute all file operations with `sudo`. RMDIR_SH = T.let((HOMEBREW_LIBRARY_PATH/"cask/utils/rmdir.sh").freeze, Pathname) private_constant :RMDIR_SH sig { params(path: T.any(Pathname, T::Array[Pathname])).void } def rmdir(path) @command.run!( "/usr/bin/xargs", args: ["-0", "--", RMDIR_SH.to_s], input: Array(path).join("\0"), sudo: true, sudo_as_root: true, ) end sig { params(paths: T::Array[Pathname]).returns(T::Array[Pathname]) } def deepest_path_first(paths) paths.sort_by { |path| -path.to_s.split(File::SEPARATOR).count } end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/quarantine.rb000066400000000000000000000301331517265720000235210ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "development_tools" require "cask/exceptions" require "system_command" require "utils/output" module Cask # Helper module for quarantining files. module Quarantine extend SystemCommand::Mixin extend ::Utils::Output::Mixin class SigningIdentity < T::Struct const :identifier, T.nilable(String) const :team_identifier, T.nilable(String) end QUARANTINE_ATTRIBUTE = "com.apple.quarantine" USER_APPROVED_FLAG = 0x0040 QUARANTINE_SCRIPT = T.let((HOMEBREW_LIBRARY_PATH/"cask/utils/quarantine.swift").freeze, Pathname) COPY_XATTRS_SCRIPT = T.let((HOMEBREW_LIBRARY_PATH/"cask/utils/copy-xattrs.swift").freeze, Pathname) sig { returns(T.nilable(T.any(String, Pathname))) } def self.swift @swift ||= T.let( begin # /usr/bin/swift (which runs via xcrun) adds `/usr/local/include` to the top of the include path, # which allows really broken local setups to break our Swift usage here. Using the underlying # Swift executable directly however (returned by `xcrun -find`) avoids this CPATH mess. xcrun_swift = ::Utils.popen_read("/usr/bin/xcrun", "-find", "swift", err: :close).chomp if $CHILD_STATUS.success? && File.executable?(xcrun_swift) xcrun_swift else DevelopmentTools.locate("swift") end end, T.nilable(T.any(String, Pathname)), ) end private_class_method :swift sig { returns(T.nilable(Pathname)) } def self.xattr @xattr ||= T.let(DevelopmentTools.locate("xattr"), T.nilable(Pathname)) end private_class_method :xattr sig { returns(T::Array[String]) } def self.swift_target_args ["-target", "#{Hardware::CPU.arch}-apple-macosx#{MacOS.version}"] end private_class_method :swift_target_args sig { returns([Symbol, T.nilable(String)]) } def self.check_quarantine_support odebug "Checking quarantine support" check_output = nil status = if xattr.nil? || !system_command(T.must(xattr), args: ["-h"], print_stderr: false).success? odebug "There's no working version of `xattr` on this system." :xattr_broken elsif swift.nil? odebug "Swift is not available on this system." :no_swift else s = swift raise "unexpected nil swift" unless s api_check = system_command(s, args: [*swift_target_args, QUARANTINE_SCRIPT], print_stderr: false) exit_status = api_check.exit_status check_output = api_check.merged_output.to_s.strip error_output = api_check.stderr.to_s.strip case exit_status when 2 odebug "Quarantine is available." :quarantine_available when 1 # Swift script ran but failed (likely due to CLT issues) odebug "Swift quarantine script failed: #{error_output}" if error_output.include?("does not exist") || error_output.include?("No such file") :swift_broken_clt elsif error_output.include?("compiler") || error_output.include?("SDK") :swift_compilation_failed else :swift_runtime_error end when 127 # Command not found or execution failed odebug "Swift execution failed with exit status 127" :swift_not_executable else odebug "Swift returned unexpected exit status: #{exit_status}" :swift_unexpected_error end end [status, check_output] end sig { returns(T::Boolean) } def self.available? @quarantine_support ||= T.let(check_quarantine_support, T.nilable([Symbol, T.nilable(String)])) @quarantine_support[0] == :quarantine_available end sig { params(file: T.nilable(T.any(String, Pathname))).returns(T.nilable(T::Boolean)) } def self.detect(file) return if file.nil? odebug "Verifying Gatekeeper status of #{file}" quarantine_status = !status(file).empty? odebug "#{file} is #{quarantine_status ? "quarantined" : "not quarantined"}" quarantine_status end sig { params(file: T.any(String, Pathname)).returns(String) } def self.status(file) raise "unexpected nil xattr" unless xattr system_command(T.must(xattr), args: ["-p", QUARANTINE_ATTRIBUTE, file], print_stderr: false).stdout.rstrip end sig { params(file: T.any(String, Pathname)).returns(T::Boolean) } def self.user_approved?(file) return false if xattr.nil? quarantine_status = status(file) return false if quarantine_status.empty? quarantine_status.split(";").fetch(0).to_i(16).anybits?(USER_APPROVED_FLAG) end sig { params(file: T.any(String, Pathname)).returns(T.nilable(SigningIdentity)) } def self.signing_identity(file) result = system_command("codesign", args: ["-dvvv", file], print_stderr: false) return unless result.success? identifier = T.let(nil, T.nilable(String)) team_identifier = T.let(nil, T.nilable(String)) result.merged_output.to_s.each_line do |line| case line.chomp when /\AIdentifier=(.+)\z/ identifier = Regexp.last_match(1) when /\ATeamIdentifier=(.+)\z/ team_identifier = Regexp.last_match(1) team_identifier = nil if team_identifier == "not set" end end SigningIdentity.new(identifier:, team_identifier:) end sig { params(attribute: String).returns(String) } def self.toggle_no_translocation_bit(attribute) fields = attribute.split(";") # Fields: status, epoch, download agent, event ID # Let's toggle the app translocation bit, bit 8 # http://www.openradar.me/radar?id=5022734169931776 fields[0] = (fields.fetch(0).to_i(16) | 0x0100).to_s(16).rjust(4, "0") fields.join(";") end sig { params(download_path: T.nilable(Pathname)).void } def self.release!(download_path: nil) return if !download_path || !detect(download_path) odebug "Releasing #{download_path} from quarantine" raise "unexpected nil xattr" unless xattr quarantiner = system_command(T.must(xattr), args: [ "-d", QUARANTINE_ATTRIBUTE, download_path, ], print_stderr: false) return if quarantiner.success? raise CaskQuarantineReleaseError.new(download_path, quarantiner.stderr) end sig { params(cask: T.nilable(Cask), download_path: T.nilable(Pathname), action: T::Boolean).void } def self.cask!(cask: nil, download_path: nil, action: true) return if cask.nil? || download_path.nil? return if detect(download_path) odebug "Quarantining #{download_path}" raise "unexpected nil swift" unless swift quarantiner = system_command(T.must(swift), args: [ *swift_target_args, QUARANTINE_SCRIPT, download_path, cask.url.to_s, cask.homepage.to_s, ], print_stderr: false) return if quarantiner.success? case quarantiner.exit_status when 2 raise CaskQuarantineError.new(download_path, "Insufficient parameters") else raise CaskQuarantineError.new(download_path, quarantiner.stderr) end end sig { params(from: T.nilable(Pathname), to: T.nilable(Pathname)).void } def self.propagate(from: nil, to: nil) return if from.nil? || to.nil? raise CaskError, "#{from} was not quarantined properly." unless detect(from) odebug "Propagating quarantine from #{from} to #{to}" quarantine_status = toggle_no_translocation_bit(status(from)) resolved_paths = Pathname.glob(to/"**/*", File::FNM_DOTMATCH).reject(&:symlink?) system_command!("/usr/bin/xargs", args: [ "-0", "--", "chmod", "-h", "u+w", ], input: resolved_paths.join("\0")) raise "unexpected nil xattr" unless xattr quarantiner = system_command("/usr/bin/xargs", args: [ "-0", "--", T.must(xattr), "-w", QUARANTINE_ATTRIBUTE, quarantine_status, ], input: resolved_paths.join("\0"), print_stderr: false) return if quarantiner.success? raise CaskQuarantinePropagationError.new(to, quarantiner.stderr) end sig { params(from: Pathname, to: Pathname, command: T.class_of(SystemCommand)).void } def self.copy_xattrs(from, to, command:) odebug "Copying xattrs from #{from} to #{to}" raise "unexpected nil swift" unless swift command.run!( T.must(swift), args: [ *swift_target_args, COPY_XATTRS_SCRIPT, from, to, ], sudo: !to.writable?, ) end # Ensures that Homebrew has permission to update apps on macOS Ventura. # This may be granted either through the App Management toggle or the Full Disk Access toggle. # The system will only show a prompt for App Management, so we ask the user to grant that. sig { params(app: Pathname, command: T.class_of(SystemCommand)).returns(T::Boolean) } def self.app_management_permissions_granted?(app:, command:) return true unless app.directory? # To get macOS to prompt the user for permissions, we need to actually attempt to # modify a file in the app. test_file = app/".homebrew-write-test" # We can't use app.writable? here because that conflates several access checks, # including both file ownership and whether system permissions are granted. # Here we just want to check whether sudo would be needed. looks_writable_without_sudo = if app.owned? app.lstat.mode.anybits?(0200) elsif app.grpowned? app.lstat.mode.anybits?(0020) else app.lstat.mode.anybits?(0002) end if looks_writable_without_sudo begin File.write(test_file, "") test_file.delete return true rescue Errno::EACCES, Errno::EPERM # Using error handler below end else begin command.run!( "touch", args: [ test_file, ], print_stderr: false, sudo: true, ) command.run!( "rm", args: [ test_file, ], print_stderr: false, sudo: true, ) return true rescue ErrorDuringExecution => e # We only want to handle "touch" errors here; propagate "sudo" errors up raise e unless e.stderr.include?("touch: #{test_file}: Operation not permitted") end end # Allow undocumented way to skip the prompt. if ENV["HOMEBREW_NO_APP_MANAGEMENT_PERMISSIONS_PROMPT"] opoo <<~EOF Your terminal does not have App Management permissions, so Homebrew will delete and reinstall the app. This may result in some configurations (like notification settings or location in the Dock/Launchpad) being lost. To fix this, go to System Settings → Privacy & Security → App Management and add or enable your terminal. EOF end false end end end require "extend/os/cask/quarantine" Homebrew-brew-d7f73ce/Library/Homebrew/cask/reinstall.rb000066400000000000000000000044341517265720000233540ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/output" module Cask class Reinstall extend ::Utils::Output::Mixin sig { params( casks: ::Cask::Cask, verbose: T::Boolean, force: T::Boolean, skip_cask_deps: T::Boolean, binaries: T::Boolean, require_sha: T::Boolean, quarantine: T::Boolean, zap: T::Boolean, skip_prefetch: T::Boolean, download_queue: T.nilable(Homebrew::DownloadQueue) ).void } def self.reinstall_casks( *casks, verbose: false, force: false, skip_cask_deps: false, binaries: false, require_sha: false, quarantine: false, zap: false, skip_prefetch: false, download_queue: nil ) require "cask/installer" quarantine = true if quarantine.nil? created_download_queue = T.let(false, T::Boolean) if download_queue.nil? if skip_prefetch download_queue = Homebrew.default_download_queue else download_queue = Homebrew::DownloadQueue.new(pour: true) created_download_queue = true end end cask_installers = T.let([], T::Array[Installer]) begin cask_installers = casks.map do |cask| Installer.new( cask, binaries:, verbose:, force:, skip_cask_deps:, require_sha:, reinstall: true, quarantine:, zap:, download_queue:, defer_fetch: true, ) end unless skip_prefetch cask_installers.each(&:prelude) oh1 "Fetching downloads for: #{casks.map { |cask| Formatter.identifier(cask.full_name) }.to_sentence}", truncate: false cask_installers.each(&:enqueue_downloads) download_queue.fetch end ensure download_queue.shutdown if created_download_queue end exit 1 if Homebrew.failed? caught_exceptions = [] cask_installers.each do |installer| installer.install rescue => e caught_exceptions << e next end return if caught_exceptions.empty? raise MultipleCaskErrors, caught_exceptions if caught_exceptions.count > 1 raise caught_exceptions.fetch(0) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/staged.rb000066400000000000000000000024751517265720000226310ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/user" require "utils/output" module Cask # Helper functions for staged casks. module Staged include ::Utils::Output::Mixin extend T::Helpers requires_ancestor { ::Cask::DSL::Base } Paths = T.type_alias { T.any(String, Pathname, T::Array[T.any(String, Pathname)]) } sig { params(paths: Paths, permissions_str: String).void } def set_permissions(paths, permissions_str) full_paths = remove_nonexistent(paths) return if full_paths.empty? command.run!("chmod", args: ["-R", "--", permissions_str, *full_paths], sudo: false) end sig { params(paths: Paths, user: T.any(String, User), group: String).void } def set_ownership(paths, user: T.must(User.current), group: "staff") full_paths = remove_nonexistent(paths) return if full_paths.empty? ohai "Changing ownership of paths required by #{cask} with `sudo` (which may request your password)..." command.run!("chown", args: ["-R", "--", "#{user}:#{group}", *full_paths], sudo: true) end private sig { params(paths: Paths).returns(T::Array[Pathname]) } def remove_nonexistent(paths) Array(paths).map { |p| Pathname(p).expand_path }.select(&:exist?) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/tab.rb000066400000000000000000000106011517265720000221160ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "tab" module Cask class Tab < ::AbstractTab # Sorbet type members are mutable by design and cannot be frozen. # rubocop:disable Style/MutableConstant Cache = type_template { { fixed: T::Hash[T.any(Pathname, String), T.untyped] } } # rubocop:enable Style/MutableConstant sig { returns(T.nilable(T::Boolean)) } attr_accessor :uninstall_flight_blocks sig { returns(T.nilable(T::Array[T.untyped])) } attr_accessor :uninstall_artifacts sig { params(attributes: T.any(T::Hash[String, T.untyped], T::Hash[Symbol, T.untyped])).void } def initialize(attributes = {}) @uninstall_flight_blocks = T.let(nil, T.nilable(T::Boolean)) @uninstall_artifacts = T.let(nil, T.nilable(T::Array[T.untyped])) super end # Instantiates a {Tab} for a new installation of a cask. sig { override.params(formula_or_cask: T.any(Formula, Cask)).returns(T.attached_class) } def self.create(formula_or_cask) cask = T.cast(formula_or_cask, Cask) tab = super tab.tabfile = cask.metadata_main_container_path/FILENAME tab.uninstall_flight_blocks = cask.uninstall_flight_blocks? tab.runtime_dependencies = Tab.runtime_deps_hash(cask) tab.source["version"] = cask.version.to_s tab.source["path"] = cask.sourcefile_path.to_s tab.uninstall_artifacts = cask.artifacts_list(uninstall_only: true) tab end # Returns a {Tab} for an already installed cask, # or a fake one if the cask is not installed. sig { params(cask: Cask).returns(T.attached_class) } def self.for_cask(cask) path = cask.metadata_main_container_path/FILENAME return from_file(path) if path.exist? tab = empty tab.source = { "path" => cask.sourcefile_path.to_s, "tap" => cask.tap&.name, "tap_git_head" => cask.tap_git_head, "version" => cask.version.to_s, } tab.uninstall_artifacts = cask.artifacts_list(uninstall_only: true) tab end sig { returns(T.attached_class) } def self.empty tab = super tab.uninstall_flight_blocks = false tab.uninstall_artifacts = [] tab.source["version"] = nil tab end sig { params(cask: Cask).returns(T::Hash[Symbol, T::Array[T::Hash[String, T.untyped]]]) } def self.runtime_deps_hash(cask) cask_and_formula_dep_graph = ::Utils::TopologicalHash.graph_package_dependencies(cask) cask_deps, formula_deps = T.cast(cask_and_formula_dep_graph.values.flatten.uniq.partition do |dep| dep.is_a?(Cask) end, [T::Array[Cask], T::Array[Formula]]) runtime_deps = {} if cask_deps.any? runtime_deps[:cask] = cask_deps.map do |dep| { "full_name" => dep.full_name, "version" => dep.version.to_s, "declared_directly" => cask.depends_on.cask.include?(dep.full_name), } end end if formula_deps.any? runtime_deps[:formula] = formula_deps.map do |dep| formula_to_dep_hash(dep, cask.depends_on.formula) end end runtime_deps end sig { returns(T.nilable(String)) } def version source["version"] end sig { params(_args: T.untyped).returns(String) } def to_json(*_args) attributes = { "homebrew_version" => homebrew_version, "loaded_from_api" => loaded_from_api, "loaded_from_internal_api" => loaded_from_internal_api, "uninstall_flight_blocks" => uninstall_flight_blocks, "installed_as_dependency" => installed_as_dependency, "installed_on_request" => installed_on_request, "time" => time, "runtime_dependencies" => runtime_dependencies, "source" => source, "arch" => arch, "uninstall_artifacts" => uninstall_artifacts, "built_on" => built_on, } JSON.pretty_generate(attributes) end sig { returns(String) } def to_s s = ["Installed"] if loaded_from_internal_api s << "using the internal formulae.brew.sh API" elsif loaded_from_api s << "using the formulae.brew.sh API" end if (t = time) s << Time.at(t).strftime("on %Y-%m-%d at %H:%M:%S") end s.join(" ") end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/uninstall.rb000066400000000000000000000033061517265720000233650ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cask_dependent" require "dependents_message" require "utils/output" module Cask class Uninstall extend ::Utils::Output::Mixin sig { params(casks: ::Cask::Cask, binaries: T::Boolean, force: T::Boolean, verbose: T::Boolean).void } def self.uninstall_casks(*casks, binaries: false, force: false, verbose: false) require "cask/installer" caught_exceptions = [] casks.each do |cask| odebug "Uninstalling Cask #{cask}" raise CaskNotInstalledError, cask if !cask.installed? && !force Installer.new(cask, binaries:, force:, verbose:).uninstall rescue => e caught_exceptions << e next end return if caught_exceptions.empty? raise MultipleCaskErrors, caught_exceptions if caught_exceptions.count > 1 raise caught_exceptions.fetch(0) end sig { params(casks: ::Cask::Cask, named_args: T::Array[String]).void } def self.check_dependent_casks(*casks, named_args: []) dependents = [] all_requireds = casks.map(&:token) requireds = Set.new caskroom = ::Cask::Caskroom.casks caskroom.each do |dependent| next if all_requireds.include?(dependent.token) d = CaskDependent.new(dependent) dependencies = d.recursive_requirements.filter_map { |r| r.cask if r.is_a?(CaskDependent::Requirement) } found_dependents = dependencies.intersection(all_requireds) next if found_dependents.empty? requireds += found_dependents dependents << dependent.token end return if dependents.empty? DependentsMessage.new(requireds.to_a, dependents, named_args:).output end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/upgrade.rb000066400000000000000000000330761517265720000230120ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "env_config" require "cask/config" require "cask/quarantine" require "deprecate_disable" require "utils/output" module Cask class Upgrade extend ::Utils::Output::Mixin sig { returns(T::Array[String]) } def self.greedy_casks if (upgrade_greedy_casks = Homebrew::EnvConfig.upgrade_greedy_casks.presence) upgrade_greedy_casks.split else [] end end sig { params( casks: T::Array[Cask], args: Homebrew::CLI::Args, force: T.nilable(T::Boolean), quiet: T.nilable(T::Boolean), greedy: T.nilable(T::Boolean), greedy_latest: T.nilable(T::Boolean), greedy_auto_updates: T.nilable(T::Boolean), ).returns(T::Array[Cask]) } def self.outdated_casks(casks, args:, force:, quiet:, greedy: false, greedy_latest: false, greedy_auto_updates: false) # Validate mutually exclusive opt-in/opt-out env vars before we start # selecting casks so `brew upgrade` errors consistently. Homebrew::EnvConfig.upgrade_auto_updates_casks? greedy = true if Homebrew::EnvConfig.upgrade_greedy? if casks.empty? Caskroom.casks(config: Config.from_args(args)).select do |cask| if cask.disabled? opoo "Not upgrading #{cask.token}, it is #{DeprecateDisable.message(cask)}" unless quiet next false end cask_greedy = greedy || greedy_casks.include?(cask.token) cask.outdated?(greedy: cask_greedy, greedy_latest:, greedy_auto_updates:) end else casks.select do |cask| raise CaskNotInstalledError, cask if !cask.installed? && !force if cask.disabled? opoo "Not upgrading #{cask.token}, it is #{DeprecateDisable.message(cask)}" unless quiet next false end if cask.outdated?(greedy: true) true elsif cask.version.latest? opoo "Not upgrading #{cask.token}, the downloaded artifact has not changed" unless quiet false else opoo "Not upgrading #{cask.token}, the latest version is already installed" unless quiet false end end end end sig { params(cask_upgrades: T::Array[String], dry_run: T.nilable(T::Boolean)).void } def self.show_upgrade_summary(cask_upgrades, dry_run: false) return if cask_upgrades.empty? verb = dry_run ? "Would upgrade" : "Upgrading" oh1 "#{verb} #{cask_upgrades.count} outdated #{::Utils.pluralize("package", cask_upgrades.count)}:" puts cask_upgrades.join("\n") end sig { params( casks: Cask, args: Homebrew::CLI::Args, force: T.nilable(T::Boolean), greedy: T.nilable(T::Boolean), greedy_latest: T.nilable(T::Boolean), greedy_auto_updates: T.nilable(T::Boolean), dry_run: T.nilable(T::Boolean), skip_cask_deps: T.nilable(T::Boolean), verbose: T.nilable(T::Boolean), quiet: T.nilable(T::Boolean), binaries: T.nilable(T::Boolean), quarantine: T.nilable(T::Boolean), require_sha: T.nilable(T::Boolean), skip_prefetch: T::Boolean, show_upgrade_summary: T::Boolean, download_queue: T.nilable(Homebrew::DownloadQueue), ).returns(T::Boolean) } def self.upgrade_casks!( *casks, args:, force: false, greedy: false, greedy_latest: false, greedy_auto_updates: false, dry_run: false, skip_cask_deps: false, verbose: false, quiet: false, binaries: nil, quarantine: nil, require_sha: nil, skip_prefetch: false, show_upgrade_summary: true, download_queue: nil ) quarantine = true if quarantine.nil? outdated_casks = self.outdated_casks(casks, args:, greedy:, greedy_latest:, greedy_auto_updates:, force:, quiet:) manual_installer_casks = outdated_casks.select do |cask| cask.artifacts.any? do |artifact| artifact.is_a?(Artifact::Installer) && artifact.manual_install end end if manual_installer_casks.present? count = manual_installer_casks.count ofail "Not upgrading #{count} `installer manual` #{::Utils.pluralize("cask", count)}." puts manual_installer_casks.map(&:to_s) outdated_casks -= manual_installer_casks end return false if outdated_casks.empty? if !Homebrew::EnvConfig.no_env_hints? && casks.empty? && !greedy && greedy_casks.empty? output_hint = false if !greedy_auto_updates && outdated_casks.any?(&:auto_updates) puts "Homebrew will now attempt to upgrade casks with `auto_updates true`." puts "Disable this behaviour with `HOMEBREW_NO_UPGRADE_AUTO_UPDATES_CASKS=1`." output_hint ||= true end if !greedy_auto_updates && !greedy_latest puts "Some casks with `auto_updates true` or `version :latest` may still require `--greedy`," puts "`HOMEBREW_UPGRADE_GREEDY` or `HOMEBREW_UPGRADE_GREEDY_CASKS` to be upgraded." output_hint ||= true end if greedy_auto_updates && !greedy_latest puts "Casks with `version :latest` will not be upgraded; pass `--greedy-latest` to upgrade them." output_hint ||= true end if !greedy_auto_updates && greedy_latest puts "Some casks with `auto_updates true` may still require `--greedy-auto-updates` to be upgraded." output_hint ||= true end puts "Hide these hints with `HOMEBREW_NO_ENV_HINTS=1` (see `man brew`)." if output_hint end upgradable_casks = outdated_casks.filter_map do |c| invalid_cask = !c.installed? invalid_cask ||= begin loaded_cask = CaskLoader.load(T.must(c.installed_caskfile)) false rescue CaskInvalidError, CaskUnavailableError true end if invalid_cask opoo <<~EOS The cask '#{c.token}' cannot be upgraded as-is. To fix this, run: brew reinstall --cask --force #{c.token} EOS next end [loaded_cask, c] end return false if upgradable_casks.empty? cask_upgrades = upgradable_casks.map do |(old_cask, new_cask)| "#{new_cask.full_name} #{old_cask.version} -> #{new_cask.version}" end created_download_queue = T.let(false, T::Boolean) download_queue ||= if !dry_run && !skip_prefetch created_download_queue = true Homebrew::DownloadQueue.new(pour: true) end if !dry_run && !skip_prefetch prefetch_download_queue = download_queue || Homebrew.default_download_queue begin fetchable_casks = upgradable_casks.map(&:last) fetchable_cask_installers = fetchable_casks.map do |cask| # This is significantly easier given the weird difference in Sorbet signatures here. # rubocop:disable Style/DoubleNegation Installer.new(cask, binaries: !!binaries, verbose: !!verbose, force: !!force, skip_cask_deps: !!skip_cask_deps, require_sha: !!require_sha, upgrade: true, quarantine: quarantine != false, download_queue: prefetch_download_queue, defer_fetch: true) # rubocop:enable Style/DoubleNegation end fetchable_cask_installers.each(&:prelude) fetchable_casks_sentence = fetchable_casks.map { |cask| Formatter.identifier(cask.full_name) }.to_sentence oh1 "Fetching downloads for: #{fetchable_casks_sentence}", truncate: false fetchable_cask_installers.each(&:enqueue_downloads) prefetch_download_queue.fetch ensure prefetch_download_queue.shutdown if created_download_queue end end show_upgrade_summary(cask_upgrades, dry_run:) if show_upgrade_summary return true if dry_run caught_exceptions = [] download_queue ||= Homebrew.default_download_queue upgradable_casks.each do |(old_cask, new_cask)| upgrade_cask( old_cask, new_cask, binaries:, force:, skip_cask_deps:, verbose:, quarantine:, require_sha:, download_queue: ) rescue => e new_exception = e.exception("#{new_cask.full_name}: #{e}") new_exception.set_backtrace(e.backtrace) caught_exceptions << new_exception next end return true if caught_exceptions.empty? raise MultipleCaskErrors, caught_exceptions if caught_exceptions.count > 1 raise caught_exceptions.fetch(0) if caught_exceptions.one? false end sig { params( old_cask: Cask, new_cask: Cask, old_signing_identities: T::Hash[String, T.nilable(Quarantine::SigningIdentity)], old_user_approved: T::Hash[String, T::Boolean], ).returns(T::Boolean) } def self.release_app_upgrade_quarantine?(old_cask, new_cask, old_signing_identities, old_user_approved) old_app_artifacts = old_cask.artifacts.grep(Artifact::App) new_app_artifacts = new_cask.artifacts.grep(Artifact::App) return false if old_app_artifacts.empty? || old_app_artifacts.length != new_app_artifacts.length old_app_artifacts.each_with_index.all? do |artifact, index| next false unless old_user_approved.fetch(artifact.target.to_s, false) old_identity = old_signing_identities[artifact.target.to_s] new_identity = Quarantine.signing_identity(new_app_artifacts.fetch(index).target) [ [old_identity&.identifier, new_identity&.identifier], [old_identity&.team_identifier, new_identity&.team_identifier], ].none? do |old_value, new_value| !old_value.nil? && !new_value.nil? && old_value != new_value end end rescue false end sig { params( old_cask: Cask, new_cask: Cask, binaries: T.nilable(T::Boolean), force: T.nilable(T::Boolean), quarantine: T.nilable(T::Boolean), require_sha: T.nilable(T::Boolean), skip_cask_deps: T.nilable(T::Boolean), verbose: T.nilable(T::Boolean), download_queue: Homebrew::DownloadQueue, ).void } def self.upgrade_cask( old_cask, new_cask, binaries:, force:, quarantine:, require_sha:, skip_cask_deps:, verbose:, download_queue: ) require "cask/installer" start_time = Time.now odebug "Started upgrade process for Cask #{old_cask}" old_config = old_cask.config old_options = { binaries:, verbose:, force:, upgrade: true, }.compact old_cask_installer = Installer.new(old_cask, **old_options) new_cask.config = new_cask.default_config.merge(old_config) new_options = { binaries:, verbose:, force:, skip_cask_deps:, require_sha:, upgrade: true, download_queue:, }.compact new_cask_installer = Installer.new(new_cask, **new_options, quarantine: quarantine != false, defer_fetch: true) started_upgrade = false new_artifacts_installed = false old_signing_identities = T.let({}, T::Hash[String, T.nilable(Quarantine::SigningIdentity)]) old_user_approved = T.let({}, T::Hash[String, T::Boolean]) begin oh1 "Upgrading #{Formatter.identifier(old_cask)}" puts " #{old_cask.version} -> #{new_cask.version}" # Start new cask's installation steps new_cask_installer.check_conflicts if (caveats = new_cask_installer.caveats) puts caveats end new_cask_installer.fetch if quarantine.nil? old_cask.artifacts.grep(Artifact::App).each do |artifact| old_user_approved[artifact.target.to_s] = if artifact.target.exist? Quarantine.user_approved?(artifact.target) else false end old_signing_identities[artifact.target.to_s] = Quarantine.signing_identity(artifact.target) end end # Move the old cask's artifacts back to staging old_cask_installer.start_upgrade(successor: new_cask) # And flag it so in case of error started_upgrade = true # Install the new cask new_cask_installer.stage new_cask_installer.install_artifacts(predecessor: old_cask) new_artifacts_installed = true if quarantine.nil? && Quarantine.available? && release_app_upgrade_quarantine?(old_cask, new_cask, old_signing_identities, old_user_approved) new_cask.artifacts.grep(Artifact::App).each do |artifact| Quarantine.release!(download_path: artifact.target) end end # If successful, wipe the old cask from staging. old_cask_installer.finalize_upgrade rescue => e new_cask_installer.uninstall_artifacts(successor: old_cask) if new_artifacts_installed new_cask_installer.purge_versioned_files old_cask_installer.revert_upgrade(predecessor: new_cask) if started_upgrade raise e end end_time = Time.now Homebrew.messages.package_installed(new_cask.token, end_time - start_time) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/url.rb000066400000000000000000000111141517265720000221520ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "source_location" module Cask # Class corresponding to the `url` stanza. class URL sig { returns(URI::Generic) } attr_reader :uri sig { returns(T.nilable(T::Hash[T.any(Symbol, String), String])) } attr_reader :revisions sig { returns(T.nilable(T::Boolean)) } attr_reader :trust_cert sig { returns(T.nilable(T::Hash[String, String])) } attr_reader :cookies, :data sig { returns(T.nilable(T::Array[String])) } attr_reader :header sig { returns(T.nilable(T.any(URI::Generic, String))) } attr_reader :referer sig { returns(T::Hash[Symbol, T.untyped]) } attr_reader :specs sig { returns(T.nilable(T.any(Symbol, String))) } attr_reader :user_agent sig { returns(T.nilable(T.any(T::Class[AbstractDownloadStrategy], Symbol))) } attr_reader :using sig { returns(T.nilable(String)) } attr_reader :tag, :branch, :revision, :only_path, :verified extend Forwardable def_delegators :uri, :path, :scheme, :to_s # Creates a `url` stanza. # # @api public sig { params( uri: T.any(URI::Generic, String), verified: T.nilable(String), using: T.nilable(T.any(T::Class[AbstractDownloadStrategy], Symbol)), tag: T.nilable(String), branch: T.nilable(String), revisions: T.nilable(T::Hash[T.any(Symbol, String), String]), revision: T.nilable(String), trust_cert: T.nilable(T::Boolean), cookies: T.nilable(T::Hash[T.any(String, Symbol), String]), referer: T.nilable(T.any(URI::Generic, String)), header: T.nilable(T.any(String, T::Array[String])), user_agent: T.nilable(T.any(Symbol, String)), data: T.nilable(T::Hash[String, String]), only_path: T.nilable(String), caller_location: Thread::Backtrace::Location, ).void } def initialize( uri, verified: nil, using: nil, tag: nil, branch: nil, revisions: nil, revision: nil, trust_cert: nil, cookies: nil, referer: nil, header: nil, user_agent: nil, data: nil, only_path: nil, caller_location: caller_locations.fetch(0) ) @uri = T.let(URI(uri), URI::Generic) header = Array(header) unless header.nil? specs = {} specs[:verified] = @verified = T.let(verified, T.nilable(String)) specs[:using] = @using = T.let(using, T.nilable(T.any(T::Class[AbstractDownloadStrategy], Symbol))) specs[:tag] = @tag = T.let(tag, T.nilable(String)) specs[:branch] = @branch = T.let(branch, T.nilable(String)) specs[:revisions] = @revisions = T.let(revisions, T.nilable(T::Hash[T.any(Symbol, String), String])) specs[:revision] = @revision = T.let(revision, T.nilable(String)) specs[:trust_cert] = @trust_cert = T.let(trust_cert, T.nilable(T::Boolean)) specs[:cookies] = @cookies = T.let(cookies&.transform_keys(&:to_s), T.nilable(T::Hash[String, String])) specs[:referer] = @referer = T.let(referer, T.nilable(T.any(URI::Generic, String))) specs[:headers] = @header = T.let(header, T.nilable(T::Array[String])) specs[:user_agent] = @user_agent = T.let(user_agent || :default, T.nilable(T.any(Symbol, String))) specs[:data] = @data = T.let(data, T.nilable(T::Hash[String, String])) specs[:only_path] = @only_path = T.let(only_path, T.nilable(String)) @specs = T.let(specs.compact, T::Hash[Symbol, T.untyped]) @caller_location = caller_location end sig { returns(Homebrew::SourceLocation) } def location Homebrew::SourceLocation.new(@caller_location.lineno, raw_url_line&.index("url")) end sig { params(ignore_major_version: T::Boolean).returns(T::Boolean) } def unversioned?(ignore_major_version: false) interpolated_url = raw_url_line&.then { |line| line[/url\s+"([^"]+)"/, 1] } return false unless interpolated_url interpolated_url = interpolated_url.gsub(/\#{\s*arch\s*}/, "") interpolated_url = interpolated_url.gsub(/\#{\s*version\s*\.major\s*}/, "") if ignore_major_version interpolated_url.exclude?('#{') end private sig { returns(T.nilable(String)) } def raw_url_line return @raw_url_line if defined?(@raw_url_line) @raw_url_line = T.let(Pathname(T.must(@caller_location.path)) .each_line .drop(@caller_location.lineno - 1) .first, T.nilable(String)) end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/utils.rb000066400000000000000000000101671517265720000225170ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/user" require "open3" require "utils/output" module Cask # Helper functions for various cask operations. module Utils extend ::Utils::Output::Mixin BUG_REPORTS_URL = "https://github.com/Homebrew/homebrew-cask#reporting-bugs" sig { params(path: Pathname, command: T.class_of(SystemCommand)).void } def self.gain_permissions_mkpath(path, command: SystemCommand) dir = path.ascend.find(&:directory?) return if path == dir if dir&.writable? path.mkpath else command.run!("mkdir", args: ["-p", "--", path], sudo: true, print_stderr: false) end end sig { params(path: Pathname, command: T.class_of(SystemCommand)).void } def self.gain_permissions_rmdir(path, command: SystemCommand) gain_permissions(path, [], command) do |p| if p.parent.writable? FileUtils.rmdir p else command.run!("rmdir", args: ["--", p], sudo: true, print_stderr: false) end end end sig { params(path: Pathname, command: T.class_of(SystemCommand)).void } def self.gain_permissions_remove(path, command: SystemCommand) directory = false permission_flags = if path.symlink? ["-h"] elsif path.directory? directory = true ["-R"] elsif path.exist? [] else # Nothing to remove. return end gain_permissions(path, permission_flags, command) do |p| if p.parent.writable? if directory FileUtils.rm_r p else FileUtils.rm_f p end else recursive_flag = directory ? ["-R"] : [] command.run!("/bin/rm", args: recursive_flag + ["-f", "--", p], sudo: true, print_stderr: false) end end end sig { params( path: Pathname, command_args: T::Array[String], command: T.class_of(SystemCommand), _block: T.proc.params(path: Pathname).void, ).void } def self.gain_permissions(path, command_args, command, &_block) tried_permissions = false tried_ownership = false begin yield path rescue # in case of permissions problems unless tried_permissions print_stderr = Context.current.debug? || Context.current.verbose? # TODO: Better handling for the case where path is a symlink. # The `-h` and `-R` flags cannot be combined and behavior is # dependent on whether the file argument has a trailing # slash. This should do the right thing, but is fragile. command.run("/usr/bin/chflags", print_stderr:, args: command_args + ["--", "000", path]) command.run("chmod", print_stderr:, args: command_args + ["--", "u+rwx", path]) command.run("chmod", print_stderr:, args: command_args + ["-N", path]) tried_permissions = true retry # rmtree end unless tried_ownership # in case of ownership problems # TODO: Further examine files to see if ownership is the problem # before using `sudo` and `chown`. ohai "Using sudo to gain ownership of path '#{path}'" command.run("chown", args: command_args + ["--", User.current.to_s, path], sudo: true) tried_ownership = true # retry chflags/chmod after chown tried_permissions = false retry # rmtree end raise end end sig { params(path: Pathname).returns(T::Boolean) } def self.path_occupied?(path) path.exist? || path.symlink? end sig { params(name: String).returns(String) } def self.token_from(name) name.downcase .gsub("+", "-plus-") .gsub(/[ _·•]/, "-") .gsub(/[^\w@-]/, "") .gsub(/--+/, "-") .delete_prefix("-") .delete_suffix("-") end end end Homebrew-brew-d7f73ce/Library/Homebrew/cask/utils/000077500000000000000000000000001517265720000221655ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/cask/utils/copy-xattrs.swift000077500000000000000000000057521517265720000255540ustar00rootroot00000000000000#!/usr/bin/swift import Foundation struct SwiftErr: TextOutputStream { public static var stream = SwiftErr() mutating func write(_ string: String) { fputs(string, stderr) } } guard CommandLine.arguments.count >= 3 else { print("Usage: swift copy-xattrs.swift ") exit(2) } CommandLine.arguments[2].withCString { destinationPath in let destinationNamesLength = listxattr(destinationPath, nil, 0, 0) if destinationNamesLength == -1 { print("listxattr for destination failed: \(errno)", to: &SwiftErr.stream) exit(1) } let destinationNamesBuffer = UnsafeMutablePointer.allocate(capacity: destinationNamesLength) if listxattr(destinationPath, destinationNamesBuffer, destinationNamesLength, 0) != destinationNamesLength { print("Attributes changed during system call", to: &SwiftErr.stream) exit(1) } var destinationNamesIndex = 0 while destinationNamesIndex < destinationNamesLength { let attribute = destinationNamesBuffer + destinationNamesIndex if removexattr(destinationPath, attribute, 0) != 0 { print("removexattr for \(String(cString: attribute)) failed: \(errno)", to: &SwiftErr.stream) exit(1) } destinationNamesIndex += strlen(attribute) + 1 } destinationNamesBuffer.deallocate() CommandLine.arguments[1].withCString { sourcePath in let sourceNamesLength = listxattr(sourcePath, nil, 0, 0) if sourceNamesLength == -1 { print("listxattr for source failed: \(errno)", to: &SwiftErr.stream) exit(1) } let sourceNamesBuffer = UnsafeMutablePointer.allocate(capacity: sourceNamesLength) if listxattr(sourcePath, sourceNamesBuffer, sourceNamesLength, 0) != sourceNamesLength { print("Attributes changed during system call", to: &SwiftErr.stream) exit(1) } var sourceNamesIndex = 0 while sourceNamesIndex < sourceNamesLength { let attribute = sourceNamesBuffer + sourceNamesIndex let valueLength = getxattr(sourcePath, attribute, nil, 0, 0, 0) if valueLength == -1 { print("getxattr for \(String(cString: attribute)) failed: \(errno)", to: &SwiftErr.stream) exit(1) } let valueBuffer = UnsafeMutablePointer.allocate(capacity: valueLength) if getxattr(sourcePath, attribute, valueBuffer, valueLength, 0, 0) != valueLength { print("Attributes changed during system call", to: &SwiftErr.stream) exit(1) } if setxattr(destinationPath, attribute, valueBuffer, valueLength, 0, 0) != 0 { print("setxattr for \(String(cString: attribute)) failed: \(errno)", to: &SwiftErr.stream) exit(1) } valueBuffer.deallocate() sourceNamesIndex += strlen(attribute) + 1 } sourceNamesBuffer.deallocate() } } Homebrew-brew-d7f73ce/Library/Homebrew/cask/utils/quarantine.swift000077500000000000000000000025101517265720000254130ustar00rootroot00000000000000#!/usr/bin/swift import Foundation struct SwiftErr: TextOutputStream { public static var stream = SwiftErr() mutating func write(_ string: String) { fputs(string, stderr) } } // TODO: tell which arguments have to be provided guard CommandLine.arguments.count >= 4 else { exit(2) } var dataLocationURL = URL(fileURLWithPath: CommandLine.arguments[1]) let quarantineProperties: [String: Any] = [ kLSQuarantineAgentNameKey as String: "Homebrew Cask", kLSQuarantineTypeKey as String: kLSQuarantineTypeWebDownload, kLSQuarantineDataURLKey as String: CommandLine.arguments[2], kLSQuarantineOriginURLKey as String: CommandLine.arguments[3] ] // Check for if the data location URL is reachable do { let isDataLocationURLReachable = try dataLocationURL.checkResourceIsReachable() guard isDataLocationURLReachable else { print("URL \(dataLocationURL.path) is not reachable. Not proceeding.", to: &SwiftErr.stream) exit(1) } } catch { print(error.localizedDescription, to: &SwiftErr.stream) exit(1) } // Quarantine the file do { var resourceValues = URLResourceValues() resourceValues.quarantineProperties = quarantineProperties try dataLocationURL.setResourceValues(resourceValues) } catch { print(error.localizedDescription, to: &SwiftErr.stream) exit(1) } Homebrew-brew-d7f73ce/Library/Homebrew/cask/utils/rmdir.sh000077500000000000000000000021611517265720000236410ustar00rootroot00000000000000#!/bin/bash set -euo pipefail # Try removing as many empty directories as possible with a single # `rmdir` call to avoid or at least speed up the loop below. if rmdir -- "${@}" &>/dev/null then exit fi for path in "${@}" do symlink=true [[ -L "${path}" ]] || symlink=false directory=false if [[ -d "${path}" ]] then directory=true if [[ -e "${path}/.DS_Store" ]] then /bin/rm -- "${path}/.DS_Store" fi # Some packages leave broken symlinks around; we clean them out before # attempting to `rmdir` to prevent extra cruft from accumulating. /usr/bin/find -f "${path}" -- -mindepth 1 -maxdepth 1 -type l ! -exec test -e {} \; -delete || true elif ! ${symlink} && [[ ! -e "${path}" ]] then # Skip paths that don't exists and aren't a broken symlink. continue fi if ${symlink} then # Delete directory symlink. /bin/rm -- "${path}" elif ${directory} then # Delete directory if empty. /usr/bin/find -f "${path}" -- -maxdepth 0 -type d -empty -exec rmdir -- {} \; else # Try `rmdir` anyways to show a proper error. rmdir -- "${path}" fi done Homebrew-brew-d7f73ce/Library/Homebrew/cask/utils/trash.swift000077500000000000000000000013501517265720000243660ustar00rootroot00000000000000#!/usr/bin/swift import Foundation let manager = FileManager.default var success = true // The command line arguments given but without the script's name let CMDLineArgs = Array(CommandLine.arguments.dropFirst()) var trashed: [String] = [] var untrashable: [String] = [] for item in CMDLineArgs { do { let url = URL(fileURLWithPath: item) var trashedPath: NSURL! try manager.trashItem(at: url, resultingItemURL: &trashedPath) trashed.append((trashedPath as URL).path) success = true } catch { untrashable.append(item) success = false } } print(trashed.joined(separator: ":")) print(untrashable.joined(separator: ":"), terminator: "") guard success else { exit(1) } Homebrew-brew-d7f73ce/Library/Homebrew/cask_dependent.rb000066400000000000000000000054301517265720000234020ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "requirement" # An adapter for casks to provide dependency information in a formula-like interface. class CaskDependent # Defines a dependency on another cask class Requirement < ::Requirement # Sorbet type members are mutable by design and cannot be frozen. # rubocop:disable Style/MutableConstant Cache = type_template { { fixed: T::Hash[String, T.untyped] } } # rubocop:enable Style/MutableConstant satisfy(build_env: false) do cask_token = cask raise "unexpected nil cask" unless cask_token Cask::CaskLoader.load(cask_token).installed? end end sig { returns(Cask::Cask) } attr_reader :cask sig { params(cask: Cask::Cask).void } def initialize(cask) @cask = cask end sig { returns(String) } def name @cask.token end sig { returns(String) } def full_name @cask.full_name end sig { returns(T::Array[Dependency]) } def runtime_dependencies deps.flat_map { |dep| [dep, *dep.to_installed_formula.runtime_dependencies] }.uniq end sig { returns(T::Array[Dependency]) } def deps @deps ||= T.let( @cask.depends_on.formula.map do |f| Dependency.new f end, T.nilable(T::Array[Dependency]), ) end sig { returns(T::Array[::Requirement]) } def requirements @requirements ||= T.let( begin requirements = [] dsl_reqs = @cask.depends_on dsl_reqs.arch&.each do |arch| arch = if arch[:bits] == 64 if arch[:type] == :intel :x86_64 else :"#{arch[:type]}64" end elsif arch[:type] == :intel && arch[:bits] == 32 :i386 else arch[:type] end requirements << ArchRequirement.new([arch]) end dsl_reqs.cask.each do |cask_ref| requirements << CaskDependent::Requirement.new([{ cask: cask_ref }]) end requirements << dsl_reqs.macos if dsl_reqs.macos requirements end, T.nilable(T::Array[::Requirement]), ) end sig { params( block: T.nilable(T.proc.params(arg0: T.any(Formula, CaskDependent, SoftwareSpec), arg1: ::Dependency).returns(T.nilable(Symbol))), ).returns(T::Array[::Dependency]) } def recursive_dependencies(&block) Dependency.expand(self, &block) end sig { params( block: T.nilable(T.proc.params(arg0: T.any(Formula, CaskDependent, SoftwareSpec), arg1: ::Requirement).returns(T.nilable(Symbol))), ).returns(Requirements) } def recursive_requirements(&block) Requirement.expand(self, &block) end sig { returns(T::Boolean) } def any_version_installed? @cask.installed? end end Homebrew-brew-d7f73ce/Library/Homebrew/caveats.rb000066400000000000000000000161321517265720000220620ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/service" # A formula's caveats. class Caveats extend Forwardable sig { returns(Formula) } attr_reader :formula sig { params(formula: Formula).void } def initialize(formula) @formula = formula @caveats = T.let(nil, T.nilable(String)) @completions_and_elisp = T.let(nil, T.nilable(T::Array[String])) end sig { returns(String) } def caveats @caveats ||= begin caveats = [] build = formula.build begin formula.build = Tab.for_formula(formula) string = formula.caveats.to_s caveats << "#{string.chomp}\n" unless string.empty? ensure formula.build = build end caveats << keg_only_text caveats << service_caveats caveats.compact.join("\n") end end sig { returns(T::Boolean) } def empty? caveats.blank? && completions_and_elisp.blank? end delegate [:to_s] => :caveats sig { returns(T::Array[String]) } def completions_and_elisp @completions_and_elisp ||= begin valid_shells = [:bash, :zsh, :fish, :pwsh].freeze current_shell = Utils::Shell.preferred || Utils::Shell.parent shells = if current_shell.present? && (shell_sym = current_shell.to_sym) && valid_shells.include?(shell_sym) [shell_sym] else valid_shells end completions_and_elisp = shells.map do |shell| function_completion_caveats(shell) end completions_and_elisp << elisp_caveats completions_and_elisp.compact end end sig { params(skip_reason: T::Boolean).returns(T.nilable(String)) } def keg_only_text(skip_reason: false) return unless formula.keg_only? return if formula.linked? s = if skip_reason "" else <<~EOS #{formula.name} is keg-only, which means it was not symlinked into #{HOMEBREW_PREFIX}, because #{formula.keg_only_reason.to_s.chomp}. EOS end.dup if formula.bin.directory? || formula.sbin.directory? s << <<~EOS If you need to have #{formula.name} first in your PATH, run: EOS s << " #{Utils::Shell.prepend_path_in_profile(formula.opt_bin.to_s)}\n" if formula.bin.directory? s << " #{Utils::Shell.prepend_path_in_profile(formula.opt_sbin.to_s)}\n" if formula.sbin.directory? end if formula.lib.directory? || formula.include.directory? s << <<~EOS For compilers to find #{formula.name} you may need to set: EOS s << " #{Utils::Shell.export_value("LDFLAGS", "-L#{formula.opt_lib}")}\n" if formula.lib.directory? s << " #{Utils::Shell.export_value("CPPFLAGS", "-I#{formula.opt_include}")}\n" if formula.include.directory? if which("pkgconf", ORIGINAL_PATHS) && ((formula.lib/"pkgconfig").directory? || (formula.share/"pkgconfig").directory?) s << <<~EOS For pkgconf to find #{formula.name} you may need to set: EOS if (formula.lib/"pkgconfig").directory? s << " #{Utils::Shell.export_value("PKG_CONFIG_PATH", "#{formula.opt_lib}/pkgconfig")}\n" end if (formula.share/"pkgconfig").directory? s << " #{Utils::Shell.export_value("PKG_CONFIG_PATH", "#{formula.opt_share}/pkgconfig")}\n" end end if which("cmake", ORIGINAL_PATHS) && ((formula.lib/"cmake").directory? || (formula.share/"cmake").directory?) s << <<~EOS For cmake to find #{formula.name} you may need to set: #{Utils::Shell.export_value("CMAKE_PREFIX_PATH", formula.opt_prefix.to_s)} EOS end end s << "\n" unless s.end_with?("\n") s end private sig { returns(T.nilable(Keg)) } def keg @keg ||= T.let([formula.prefix, formula.opt_prefix, formula.linked_keg].filter_map do |d| Keg.new(d.resolved_path) rescue nil end.first, T.nilable(Keg)) end sig { params(shell: Symbol).returns(T.nilable(String)) } def function_completion_caveats(shell) return unless (keg = self.keg) return unless which(shell.to_s, ORIGINAL_PATHS) completion_installed = keg.completion_installed?(shell) functions_installed = keg.functions_installed?(shell) return if !completion_installed && !functions_installed installed = [] installed << "completions" if completion_installed installed << "functions" if functions_installed root_dir = formula.keg_only? ? formula.opt_prefix : HOMEBREW_PREFIX case shell when :bash <<~EOS Bash completion has been installed to: #{root_dir}/etc/bash_completion.d EOS when :fish fish_caveats = "fish #{installed.join(" and ")} have been installed to:" fish_caveats << "\n #{root_dir}/share/fish/vendor_completions.d" if completion_installed fish_caveats << "\n #{root_dir}/share/fish/vendor_functions.d" if functions_installed fish_caveats.freeze when :zsh <<~EOS zsh #{installed.join(" and ")} have been installed to: #{root_dir}/share/zsh/site-functions EOS when :pwsh <<~EOS PowerShell completion has been installed to: #{root_dir}/share/pwsh/completions EOS end end sig { returns(T.nilable(String)) } def elisp_caveats return if formula.keg_only? return unless (keg = self.keg) return unless keg.elisp_installed? <<~EOS Emacs Lisp files have been installed to: #{HOMEBREW_PREFIX}/share/emacs/site-lisp/#{formula.name} EOS end sig { returns(T.nilable(String)) } def service_caveats return if !formula.service? && !Utils::Service.installed?(formula) && !keg&.plist_installed? return if formula.service? && !formula.service.command? && !Utils::Service.installed?(formula) s = [] # Brew services only works with these two tools return <<~EOS if !Utils::Service.systemctl? && !Utils::Service.launchctl? && formula.service.command? #{Formatter.warning("Warning:")} #{formula.name} provides a service which can only be used on macOS or systemd! You can manually execute the service instead with: #{formula.service.manual_command} EOS startup = formula.service.requires_root? if Utils::Service.running?(formula) s << "To restart #{formula.full_name} after an upgrade:" s << " #{"sudo " if startup}brew services restart #{formula.full_name}" elsif startup s << "To start #{formula.full_name} now and restart at startup:" s << " sudo brew services start #{formula.full_name}" else s << "To start #{formula.full_name} now and restart at login:" s << " brew services start #{formula.full_name}" end if formula.service.command? s << "Or, if you don't want/need a background service you can just run:" s << " #{formula.service.manual_command}" end # pbpaste is the system clipboard tool on macOS and fails with `tmux` by default # check if this is being run under `tmux` to avoid failing if ENV["HOMEBREW_TMUX"] && !quiet_system("/usr/bin/pbpaste") s << "" << "WARNING: brew services will fail when run under tmux." end "#{s.join("\n")}\n" unless s.empty? end end Homebrew-brew-d7f73ce/Library/Homebrew/checksum.rb000066400000000000000000000012071517265720000222330ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # A formula's checksum. class Checksum extend Forwardable sig { returns(String) } attr_reader :hexdigest sig { params(hexdigest: String).void } def initialize(hexdigest) @hexdigest = T.let(hexdigest.downcase, String) end sig { returns(String) } def inspect "#" end delegate [:empty?, :to_s, :length, :[]] => :@hexdigest sig { params(other: T.anything).returns(T::Boolean) } def ==(other) case other when String to_s == other.downcase when Checksum hexdigest == other.hexdigest else false end end end Homebrew-brew-d7f73ce/Library/Homebrew/cleaner.rb000066400000000000000000000142501517265720000220440ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/output" # Cleans a newly installed keg. # By default: # # * removes `.la` files # * removes `.tbd` files # * removes `perllocal.pod` files # * removes `.packlist` files # * removes empty directories # * sets permissions on executables # * removes unresolved symlinks class Cleaner include Context include Utils::Output::Mixin # Create a cleaner for the given formula. sig { params(formula: Formula).void } def initialize(formula) @formula = formula end # Clean the keg of the formula. sig { void } def clean ObserverPathnameExtension.reset_counts! # Many formulae include `lib/charset.alias`, but it is not strictly needed # and will conflict if more than one formula provides it. observe_file_removal @formula.lib/"charset.alias" [@formula.bin, @formula.sbin, @formula.lib].each { |dir| clean_dir(dir) if dir.exist? } # Get rid of any info `dir` files, so they don't conflict at the link stage. # # The `dir` files come in at least 3 locations: # # 1. `info/dir` # 2. `info/#{name}/dir` # 3. `info/#{arch}/dir` # # Of these 3 only `info/#{name}/dir` is safe to keep since the rest will # conflict with other formulae because they use a shared location. # # See # [cleaner: recursively delete info `dir`s][1], # [emacs 28.1 bottle does not contain `dir` file][2] and # [Keep `info/#{f.name}/dir` files in cleaner][3] # for more info. # # [1]: https://github.com/Homebrew/brew/pull/11597 # [2]: https://github.com/Homebrew/homebrew-core/issues/100190 # [3]: https://github.com/Homebrew/brew/pull/13215 @formula.info.glob("**/dir").each do |info_dir_file| next unless info_dir_file.file? next if info_dir_file == @formula.info/@formula.name/"dir" next if @formula.skip_clean?(info_dir_file) observe_file_removal info_dir_file end rewrite_shebangs clean_python_metadata prune end private sig { params(path: Pathname).void } def observe_file_removal(path) path.extend(ObserverPathnameExtension).unlink if path.exist? end # Removes any empty directories in the formula's prefix subtree # Keeps any empty directories protected by skip_clean # Removes any unresolved symlinks sig { void } def prune dirs = [] symlinks = [] @formula.prefix.find do |path| if path == @formula.libexec || @formula.skip_clean?(path) Find.prune elsif path.symlink? symlinks << path elsif path.directory? dirs << path end end # Remove directories opposite from traversal, so that a subtree with no # actual files gets removed correctly. dirs.reverse_each do |d| if d.children.empty? puts "rmdir: #{d} (empty)" if verbose? d.rmdir end end # Remove unresolved symlinks symlinks.reverse_each do |s| s.unlink unless s.resolved_path_exists? end end sig { params(path: Pathname).returns(T::Boolean) } def executable_path?(path) path.text_executable? || path.executable? end # Both these files are completely unnecessary to package and cause # pointless conflicts with other formulae. They are removed by Debian, # Arch & MacPorts amongst other packagers as well. The files are # created as part of installing any Perl module. PERL_BASENAMES = T.let(Set.new(%w[perllocal.pod .packlist]).freeze, T::Set[String]) private_constant :PERL_BASENAMES # Clean a top-level (`bin`, `sbin`, `lib`) directory, recursively, by fixing file # permissions and removing .la files, unless the files (or parent # directories) are protected by skip_clean. # # `bin` and `sbin` should not have any subdirectories; if either do that is # caught as an audit warning. # # `lib` may have a large directory tree (see Erlang for instance) and # clean_dir applies cleaning rules to the entire tree. sig { params(directory: Pathname).void } def clean_dir(directory) directory.find do |path| path.extend(ObserverPathnameExtension) Find.prune if @formula.skip_clean? path next if path.directory? if path.extname == ".la" || path.extname == ".tbd" || PERL_BASENAMES.include?(path.basename.to_s) path.unlink elsif path.symlink? # Skip it. else # Set permissions for executables and non-executables. perms = if executable_path?(path) 0555 else 0444 end if debug? old_perms = path.stat.mode & 0777 odebug "Fixing #{path} permissions from #{old_perms.to_s(8)} to #{perms.to_s(8)}" if perms != old_perms end path.chmod perms end end end sig { void } def rewrite_shebangs require "language/node" require "language/perl" require "utils/shebang" rewrites = [Language::Node::Shebang.method(:detected_node_shebang), Language::Perl::Shebang.method(:detected_perl_shebang)].filter_map do |detector| detector.call(@formula) rescue ShebangDetectionError nil end return if rewrites.empty? basepath = @formula.prefix.realpath basepath.find do |path| Find.prune if @formula.skip_clean? path next if path.directory? || path.symlink? rewrites.each { |rw| Utils::Shebang.rewrite_shebang rw, path } end end # Remove non-reproducible pip direct_url.json which records the /tmp build directory. # Remove RECORD files to prevent changes to the installed Python package. # Modify INSTALLER to provide information that files are managed by brew. # # @see https://packaging.python.org/en/latest/specifications/recording-installed-packages/ sig { void } def clean_python_metadata basepath = @formula.prefix.realpath basepath.find do |path| Find.prune if @formula.skip_clean?(path) next if path.directory? || path.symlink? next if path.parent.extname != ".dist-info" case path.basename.to_s when "direct_url.json", "RECORD" observe_file_removal path when "INSTALLER" odebug "Modifying #{path} contents from #{path.read.chomp} to brew" path.atomic_write("brew\n") end end end end require "extend/os/cleaner" Homebrew-brew-d7f73ce/Library/Homebrew/cleanup.rb000066400000000000000000000654111517265720000220670ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/bottles" require "utils/output" require "installed_dependents" require "formula" require "cask/cask_loader" module Homebrew # Helper class for cleaning up the Homebrew cache. class Cleanup extend Utils::Output::Mixin include Utils::Output::Mixin CLEANUP_DEFAULT_DAYS = T.let(Homebrew::EnvConfig.cleanup_periodic_full_days.to_i.freeze, Integer) GH_ACTIONS_ARTIFACT_CLEANUP_DAYS = 3 private_constant :CLEANUP_DEFAULT_DAYS, :GH_ACTIONS_ARTIFACT_CLEANUP_DAYS class << self sig { params(pathname: Pathname).returns(T::Boolean) } def incomplete?(pathname) pathname.extname.end_with?(".incomplete") end sig { params(pathname: Pathname).returns(T::Boolean) } def nested_cache?(pathname) pathname.directory? && %w[ cargo_cache go_cache go_mod_cache glide_home java_cache npm_cache pip_cache gclient_cache ].include?(pathname.basename.to_s) end sig { params(pathname: Pathname).returns(T::Boolean) } def go_cache_directory?(pathname) # Go makes its cache contents read-only to ensure cache integrity, # which makes sense but is something we need to undo for cleanup. pathname.directory? && %w[go_cache go_mod_cache].include?(pathname.basename.to_s) end sig { params(pathname: Pathname, days: T.nilable(Integer)).returns(T::Boolean) } def prune?(pathname, days) return false unless days return true if days.zero? return true if pathname.symlink? && !pathname.exist? days_ago = (DateTime.now - days).to_time pathname.mtime < days_ago && pathname.ctime < days_ago end sig { params(entry: { path: Pathname, type: T.nilable(Symbol) }, scrub: T::Boolean).returns(T::Boolean) } def stale?(entry, scrub: false) pathname = entry[:path] return false unless pathname.resolved_path.file? case entry[:type] when :api_source stale_api_source?(pathname, scrub) when :cask stale_cask?(pathname, scrub) when :gh_actions_artifact stale_gh_actions_artifact?(pathname, scrub) else stale_formula?(pathname, scrub) end end private sig { params(pathname: Pathname, scrub: T::Boolean).returns(T::Boolean) } def stale_gh_actions_artifact?(pathname, scrub) scrub || prune?(pathname, GH_ACTIONS_ARTIFACT_CLEANUP_DAYS) end sig { params(pathname: Pathname, scrub: T::Boolean).returns(T::Boolean) } def stale_api_source?(pathname, scrub) return true if scrub org, repo, git_head, type, basename = pathname.each_filename.to_a.last(5) name = "#{org}/#{repo}/#{File.basename(T.must(basename), ".rb")}" package = if type == "Cask" begin Cask::CaskLoader.load(name) rescue Cask::CaskError nil end else begin Formulary.factory(name) rescue FormulaUnavailableError nil end end return true if package.nil? package.tap_git_head != git_head end sig { params(formula: Formula).returns(T::Set[String]) } def excluded_versions_from_cleanup(formula) @excluded_versions_from_cleanup ||= T.let({}, T.nilable(T::Hash[String, T::Set[String]])) @excluded_versions_from_cleanup[formula.name] ||= begin eligible_kegs_for_cleanup = formula.eligible_kegs_for_cleanup(quiet: true) Set.new((formula.installed_kegs - eligible_kegs_for_cleanup).map { |keg| keg.version.to_s }) end end sig { params(pathname: Pathname, scrub: T::Boolean).returns(T::Boolean) } def stale_formula?(pathname, scrub) return false unless HOMEBREW_CELLAR.directory? version = if HOMEBREW_BOTTLES_EXTNAME_REGEX.match?(to_s) begin Utils::Bottles.resolve_version(pathname).to_s rescue nil end end basename_str = pathname.basename.to_s version ||= basename_str[/\A.*(?:--.*?)*--(.*?)#{Regexp.escape(pathname.extname)}\Z/, 1] version ||= basename_str[/\A.*--?(.*?)#{Regexp.escape(pathname.extname)}\Z/, 1] return false if version.blank? version = Version.new(version) unless (formula_name = basename_str[/\A(.*?)(?:--.*?)*--?(?:#{Regexp.escape(version.to_s)})/, 1]) return false end formula = begin Formulary.from_rack(HOMEBREW_CELLAR/formula_name) rescue FormulaUnavailableError, TapFormulaAmbiguityError nil end formula_excluded_versions_from_cleanup = nil if formula.blank? && formula_name.delete_suffix!("_bottle_manifest") formula = begin Formulary.from_rack(HOMEBREW_CELLAR/formula_name) rescue FormulaUnavailableError, TapFormulaAmbiguityError nil end return false if formula.blank? formula_excluded_versions_from_cleanup = excluded_versions_from_cleanup(formula) return false if formula_excluded_versions_from_cleanup.include?(version.to_s) if pathname.to_s.include?("_bottle_manifest") excluded_version = version.to_s excluded_version.sub!(/-\d+$/, "") return false if formula_excluded_versions_from_cleanup.include?(excluded_version) end # We can't determine an installed rebuild and parsing manifest version cannot be reliably done. return false unless formula.latest_version_installed? return true if (bottle = formula.bottle).blank? resource_version = bottle.resource.version return false unless resource_version return version != GitHubPackages.version_rebuild(resource_version, bottle.rebuild) end return false if formula.blank? resource_name = basename_str[/\A.*?--(.*?)--?(?:#{Regexp.escape(version.to_s)})/, 1] stable = formula.stable if resource_name == "patch" patch_hashes = stable&.patches&.filter_map { T.cast(it, ExternalPatch).resource.version if it.external? } return true unless patch_hashes&.include?(Checksum.new(version.to_s)) elsif resource_name && stable && (resource_version = stable.resources[resource_name]&.version) return true if resource_version != version elsif (formula_excluded_versions_from_cleanup ||= excluded_versions_from_cleanup(formula).presence) && formula_excluded_versions_from_cleanup.include?(version.to_s) return false elsif (formula.latest_version_installed? && formula.pkg_version.to_s != version) || formula.pkg_version.to_s > version return true end return true if scrub && !formula.latest_version_installed? return true if Utils::Bottles.file_outdated?(formula, pathname) false end sig { params(pathname: Pathname, scrub: T::Boolean).returns(T::Boolean) } def stale_cask?(pathname, scrub) basename = pathname.basename return false unless (name = basename.to_s[/\A(.*?)--/, 1]) cask = begin Cask::CaskLoader.load(name, warn: false) rescue Cask::CaskError nil end return false if cask.blank? return true unless basename.to_s.match?(/\A#{Regexp.escape(name)}--#{Regexp.escape(cask.version)}\b/) return true if scrub && cask.installed_version != cask.version if cask.version.latest? cleanup_threshold = (DateTime.now - CLEANUP_DEFAULT_DAYS).to_time return pathname.mtime < cleanup_threshold && pathname.ctime < cleanup_threshold end false end end PERIODIC_CLEAN_FILE = T.let((HOMEBREW_CACHE/".cleaned").freeze, Pathname) sig { returns(T::Array[String]) } attr_reader :args sig { returns(Integer) } attr_reader :days sig { returns(Pathname) } attr_reader :cache sig { returns(Integer) } attr_reader :disk_cleanup_size sig { params(args: String, dry_run: T::Boolean, scrub: T::Boolean, days: T.nilable(Integer), cache: Pathname).void } def initialize(*args, dry_run: false, scrub: false, days: nil, cache: HOMEBREW_CACHE) @disk_cleanup_size = T.let(0, Integer) @args = args @dry_run = dry_run @scrub = scrub @prune = T.let(days.present?, T::Boolean) @days = T.let(days || Homebrew::EnvConfig.cleanup_max_age_days.to_i, Integer) @cache = cache @cleaned_up_paths = T.let(Set.new, T::Set[Pathname]) end sig { returns(T::Boolean) } def dry_run? = @dry_run sig { returns(T::Boolean) } def prune? = @prune sig { returns(T::Boolean) } def scrub? = @scrub sig { params(formula: Formula, dry_run: T::Boolean).void } def self.install_formula_clean!(formula, dry_run: false) return if Homebrew::EnvConfig.no_install_cleanup? return unless formula.latest_version_installed? return if skip_clean_formula?(formula) if dry_run ohai "Would run `brew cleanup #{formula}`" else ohai "Running `brew cleanup #{formula}`..." end puts_no_install_cleanup_disable_message_if_not_already! return if dry_run Cleanup.new.cleanup_formula(formula) end sig { void } def self.puts_no_install_cleanup_disable_message return if Homebrew::EnvConfig.no_env_hints? return if Homebrew::EnvConfig.no_install_cleanup? puts "Disable this behaviour by setting `HOMEBREW_NO_INSTALL_CLEANUP=1`." puts "Hide these hints with `HOMEBREW_NO_ENV_HINTS=1` (see `man brew`)." end sig { void } def self.puts_no_install_cleanup_disable_message_if_not_already! return if @puts_no_install_cleanup_disable_message_if_not_already puts_no_install_cleanup_disable_message @puts_no_install_cleanup_disable_message_if_not_already = T.let(true, T.nilable(TrueClass)) end sig { params(formula: Formula).returns(T::Boolean) } def self.skip_clean_formula?(formula) no_cleanup_formula = Homebrew::EnvConfig.no_cleanup_formulae return false if no_cleanup_formula.blank? @skip_clean_formulae ||= T.let(no_cleanup_formula.split(","), T.nilable(T::Array[String])) @skip_clean_formulae.include?(formula.name) || @skip_clean_formulae.intersect?(formula.aliases) end sig { returns(T::Boolean) } def self.periodic_clean_due? return false if Homebrew::EnvConfig.no_install_cleanup? unless PERIODIC_CLEAN_FILE.exist? HOMEBREW_CACHE.mkpath FileUtils.touch PERIODIC_CLEAN_FILE return false end PERIODIC_CLEAN_FILE.mtime < (DateTime.now - CLEANUP_DEFAULT_DAYS).to_time end sig { params(dry_run: T::Boolean).void } def self.periodic_clean!(dry_run: false) return if Homebrew::EnvConfig.no_install_cleanup? return unless periodic_clean_due? if dry_run oh1 "Would run `brew cleanup` which has not been run in the last #{CLEANUP_DEFAULT_DAYS} days" else oh1 "`brew cleanup` has not been run in the last #{CLEANUP_DEFAULT_DAYS} days, running now..." end puts_no_install_cleanup_disable_message return if dry_run Cleanup.new.clean!(quiet: true, periodic: true) end sig { params(quiet: T::Boolean, periodic: T::Boolean).void } def clean!(quiet: false, periodic: false) if args.empty? Formula.installed .sort_by(&:name) .reject { |f| Cleanup.skip_clean_formula?(f) } .each do |formula| cleanup_formula(formula, quiet:, ds_store: false, cache_db: false) end if ENV["HOMEBREW_AUTOREMOVE"].present? opoo "`$HOMEBREW_AUTOREMOVE` is now a no-op as it is the default behaviour. " \ "Set `HOMEBREW_NO_AUTOREMOVE=1` to disable it." end Cleanup.autoremove(dry_run: dry_run?) unless Homebrew::EnvConfig.no_autoremove? cleanup_cache cleanup_empty_api_source_directories cleanup_bootsnap cleanup_logs cleanup_temp_cellar cleanup_lockfiles cleanup_python_site_packages prune_prefix_symlinks_and_directories unless dry_run? cleanup_cache_db rm_ds_store HOMEBREW_CACHE.mkpath FileUtils.touch PERIODIC_CLEAN_FILE end # Cleaning up Ruby needs to be done last to avoid requiring additional # files afterwards. Additionally, don't allow it on periodic cleans to # avoid having to try to do a `brew install` when we've just deleted # the running Ruby process... return if periodic cleanup_portable_ruby else args.each do |arg| formula = begin Formulary.resolve(arg) rescue FormulaUnavailableError, TapFormulaAmbiguityError nil end cask = begin Cask::CaskLoader.load(arg) rescue Cask::CaskError nil end if formula && Cleanup.skip_clean_formula?(formula) onoe "Refusing to clean #{formula} because it is listed in " \ "#{Tty.bold}HOMEBREW_NO_CLEANUP_FORMULAE#{Tty.reset}!" elsif formula cleanup_formula(formula) end cleanup_cask(cask) if cask end end end sig { returns(T::Array[Keg]) } def unremovable_kegs @unremovable_kegs ||= T.let([], T.nilable(T::Array[Keg])) end sig { params(formula: Formula, quiet: T::Boolean, ds_store: T::Boolean, cache_db: T::Boolean).void } def cleanup_formula(formula, quiet: false, ds_store: true, cache_db: true) formula.eligible_kegs_for_cleanup(quiet:) .each { |keg| cleanup_keg(keg) } cleanup_cache(Pathname.glob(cache/"#{formula.name}{_bottle_manifest,}--*").map { |path| { path:, type: nil } }) rm_ds_store([formula.rack]) if ds_store cleanup_cache_db(formula.rack) if cache_db cleanup_lockfiles(FormulaLock.new(formula.name).path) end sig { params(cask: Cask::Cask, ds_store: T::Boolean).void } def cleanup_cask(cask, ds_store: true) cleanup_cache(Pathname.glob(cache/"Cask/#{cask.token}--*").map { |path| { path:, type: :cask } }) rm_ds_store([cask.caskroom_path]) if ds_store cleanup_lockfiles(CaskLock.new(cask.token).path) end sig { params(keg: Keg).void } def cleanup_keg(keg) cleanup_path(Pathname.new(keg)) { keg.uninstall(raise_failures: true) } rescue Errno::EACCES, Errno::ENOTEMPTY => e opoo e.message unremovable_kegs << keg end sig { void } def cleanup_logs return unless HOMEBREW_LOGS.directory? logs_days = [days, CLEANUP_DEFAULT_DAYS].min HOMEBREW_LOGS.subdirs.each do |dir| cleanup_path(dir) { FileUtils.rm_r(dir) } if self.class.prune?(dir, logs_days) end end sig { void } def cleanup_temp_cellar return unless HOMEBREW_TEMP_CELLAR.directory? HOMEBREW_TEMP_CELLAR.each_child do |child| cleanup_path(child) { FileUtils.rm_r(child) } end end sig { returns(T::Array[{ path: Pathname, type: T.nilable(Symbol) }]) } def cache_files files = cache.directory? ? cache.children : [] cask_files = (cache/"Cask").directory? ? (cache/"Cask").children : [] api_source_files = (cache/"api-source").glob("*/*/*/*/*") # `////.rb` gh_actions_artifacts = (cache/"gh-actions-artifact").directory? ? (cache/"gh-actions-artifact").children : [] files.map { |path| { path:, type: nil } } + cask_files.map { |path| { path:, type: :cask } } + api_source_files.map { |path| { path:, type: :api_source } } + gh_actions_artifacts.map { |path| { path:, type: :gh_actions_artifact } } end sig { params(directory: Pathname).void } def cleanup_empty_api_source_directories(directory = cache/"api-source") return if dry_run? return unless directory.directory? directory.each_child do |child| next unless child.directory? cleanup_empty_api_source_directories(child) child.rmdir if child.empty? end end sig { void } def cleanup_unreferenced_downloads return if dry_run? return unless (cache/"downloads").directory? downloads = (cache/"downloads").children referenced_downloads = cache_files.map { |file| file[:path] }.select(&:symlink?).map(&:resolved_path) (downloads - referenced_downloads).each do |download| if self.class.incomplete?(download) begin DownloadLock.new(download).with_lock do download.unlink end rescue OperationInProgressError # Skip incomplete downloads which are still in progress. next end elsif download.directory? FileUtils.rm_rf download else download.unlink end end end sig { params(entries: T.nilable(T::Array[{ path: Pathname, type: T.nilable(Symbol) }])).void } def cleanup_cache(entries = nil) entries ||= cache_files entries.each do |entry| path = entry[:path] next if path == PERIODIC_CLEAN_FILE FileUtils.chmod_R 0755, path if self.class.go_cache_directory?(path) && !dry_run? next cleanup_path(path) { path.unlink } if self.class.incomplete?(path) next cleanup_path(path) { FileUtils.rm_rf path } if self.class.nested_cache?(path) if self.class.prune?(path, days) if path.file? || path.symlink? cleanup_path(path) { path.unlink } elsif path.directory? && path.to_s.include?("--") cleanup_path(path) { FileUtils.rm_rf path } end next end # If we've specified --prune don't do the (expensive) .stale? check. cleanup_path(path) { path.unlink } if !prune? && self.class.stale?(entry, scrub: scrub?) end cleanup_unreferenced_downloads end sig { params(path: Pathname, _block: T.proc.void).void } def cleanup_path(path, &_block) return unless path.exist? return unless @cleaned_up_paths.add?(path) @disk_cleanup_size += path.disk_usage if dry_run? puts "Would remove: #{path} (#{path.abv})" else puts "Removing: #{path}... (#{path.abv})" yield end end sig { params(lockfiles: Pathname).void } def cleanup_lockfiles(*lockfiles) return if dry_run? lockfiles = HOMEBREW_LOCKS.children.select(&:file?) if lockfiles.empty? && HOMEBREW_LOCKS.directory? lockfiles.each do |file| next unless file.readable? file.open(File::RDWR) do |lockfile| next unless lockfile.flock(File::LOCK_EX | File::LOCK_NB) begin file.unlink ensure lockfile.flock(File::LOCK_UN) if file.exist? end end end end sig { void } def cleanup_portable_ruby vendor_dir = HOMEBREW_LIBRARY/"Homebrew/vendor" portable_ruby_latest_version = (vendor_dir/"portable-ruby-version").read.chomp portable_rubies_to_remove = [] Pathname.glob(vendor_dir/"portable-ruby/*.*").select(&:directory?).each do |path| next if !use_system_ruby? && portable_ruby_latest_version == path.basename.to_s portable_rubies_to_remove << path end return if portable_rubies_to_remove.empty? bundler_paths = (vendor_dir/"bundle/ruby").children.select do |child| basename = child.basename.to_s next false if basename == ".homebrew_gem_groups" next true unless child.directory? [ "#{Version.new(portable_ruby_latest_version).major_minor}.0", RbConfig::CONFIG["ruby_version"], ].uniq.exclude?(basename) end bundler_paths.each do |bundler_path| if dry_run? puts Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "clean", "-nx", bundler_path).chomp else puts Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "clean", "-ffqx", bundler_path).chomp end end portable_rubies_to_remove.each do |portable_ruby| cleanup_path(portable_ruby) { FileUtils.rm_r(portable_ruby) } end end sig { returns(T::Boolean) } def use_system_ruby? false end sig { void } def cleanup_bootsnap bootsnap = cache/"bootsnap" return unless bootsnap.directory? bootsnap.each_child do |subdir| cleanup_path(subdir) { FileUtils.rm_r(subdir) } if subdir.basename.to_s != Homebrew::Bootsnap.key end end sig { params(rack: T.nilable(Pathname)).void } def cleanup_cache_db(rack = nil) FileUtils.rm_rf [ cache/"desc_cache.json", cache/"linkage.db", cache/"linkage.db.db", ] CacheStoreDatabase.use(:linkage) do |db| break unless db.created? db.each_key do |keg| keg = T.cast(keg, String) next if rack.present? && !keg.start_with?("#{rack}/") next if File.directory?(keg) LinkageCacheStore.new( keg, T.cast(db, CacheStoreDatabase[String, T::Hash[T.any(String, Symbol), T.anything]]), ).delete! end end end sig { params(dirs: T.nilable(T::Array[Pathname])).void } def rm_ds_store(dirs = nil) dirs ||= Keg.must_exist_directories + [ HOMEBREW_PREFIX/"Caskroom", ] dirs.select(&:directory?) .flat_map { |d| Pathname.glob("#{d}/**/.DS_Store") } .each do |dir| dir.unlink rescue Errno::EACCES # don't care if we can't delete a .DS_Store nil end end sig { void } def cleanup_python_site_packages pyc_files = Hash.new { |h, k| h[k] = [] } seen_non_pyc_file = Hash.new { |h, k| h[k] = false } unused_pyc_files = [] HOMEBREW_PREFIX.glob("lib/python*/site-packages").each do |site_packages| site_packages.each_child do |child| next unless child.directory? # TODO: Work out a sensible way to clean up `pip`'s, `setuptools`' and `wheel`'s # `{dist,site}-info` directories. Alternatively, consider always removing # all `-info` directories, because we may not be making use of them. next if child.basename.to_s.end_with?("-info") # Clean up old *.pyc files in the top-level __pycache__. if child.basename.to_s == "__pycache__" child.find do |path| next if path.extname != ".pyc" next unless self.class.prune?(path, days) unused_pyc_files << path end next end # Look for directories that contain only *.pyc files. child.find do |path| next if path.directory? if path.extname == ".pyc" pyc_files[child] << path else seen_non_pyc_file[child] = true break end end end end unused_pyc_files += pyc_files.reject { |k,| seen_non_pyc_file[k] } .values .flatten return if unused_pyc_files.blank? unused_pyc_files.each do |pyc| cleanup_path(pyc) { pyc.unlink } end end sig { void } def prune_prefix_symlinks_and_directories ObserverPathnameExtension.reset_counts! dirs = [] children_count = {} Keg.must_exist_subdirectories.each do |dir| next unless dir.directory? dir.find do |path| path.extend(ObserverPathnameExtension) if path.symlink? unless path.resolved_path_exists? path.uninstall_info if path.to_s.match?(Keg::INFOFILE_RX) && !dry_run? if dry_run? puts "Would remove (broken link): #{path}" children_count[path.dirname] -= 1 if children_count.key?(path.dirname) else path.unlink end end elsif path.directory? && Keg.must_exist_subdirectories.exclude?(path) dirs << path children_count[path] = path.children.length if dry_run? end end end dirs.reverse_each do |d| if !dry_run? d.rmdir_if_possible elsif children_count[d].zero? puts "Would remove (empty directory): #{d}" children_count[d.dirname] -= 1 if children_count.key?(d.dirname) end end require "cask/caskroom" if Cask::Caskroom.path.directory? Cask::Caskroom.path.each_child do |path| path.extend(ObserverPathnameExtension) next if !path.symlink? || path.resolved_path_exists? if dry_run? puts "Would remove (broken link): #{path}" else path.unlink end end end return if dry_run? return if ObserverPathnameExtension.total.zero? n, d = ObserverPathnameExtension.counts print "Pruned #{n} symbolic links " print "and #{d} directories " if d.positive? puts "from #{HOMEBREW_PREFIX}" end sig { params(dry_run: T::Boolean).void } def self.autoremove(dry_run: false) require "utils/autoremove" require "cask/caskroom" # If this runs after install, uninstall, reinstall or upgrade, # the cache of installed formulae may no longer be valid. Formula.clear_cache unless dry_run formulae = Formula.installed # Remove formulae listed in HOMEBREW_NO_CLEANUP_FORMULAE and their dependencies. if Homebrew::EnvConfig.no_cleanup_formulae.present? formulae -= formulae.select { skip_clean_formula?(it) } .flat_map { |f| [f, *f.installed_runtime_formula_dependencies] } end casks = Cask::Caskroom.casks removable_formulae = Utils::Autoremove.removable_formulae(formulae, casks) if (candidate_kegs = removable_formulae.filter_map(&:any_installed_keg).presence) && (required_kegs, = InstalledDependents.find_some_installed_dependents(candidate_kegs)) && (required_names = Set.new(required_kegs.map(&:name)).presence) removable_formulae.reject! { |formula| required_names.include?(formula.name) } end return if removable_formulae.blank? formulae_names = removable_formulae.map(&:full_name).sort verb = dry_run ? "Would autoremove" : "Autoremoving" oh1 "#{verb} #{formulae_names.count} unneeded #{Utils.pluralize("formula", formulae_names.count)}:" puts formulae_names.join("\n") return if dry_run require "uninstall" kegs_by_rack = removable_formulae.filter_map(&:any_installed_keg).group_by(&:rack) Uninstall.uninstall_kegs(kegs_by_rack) # The installed formula cache will be invalid after uninstalling. Formula.clear_cache end end end require "extend/os/cleanup" Homebrew-brew-d7f73ce/Library/Homebrew/cli/000077500000000000000000000000001517265720000206535ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/cli/args.rb000066400000000000000000000131401517265720000221330ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true module Homebrew module CLI class Args # Represents a processed option. The array elements are: # 0: short option name (e.g. "-d") # 1: long option name (e.g. "--debug") # 2: option description (e.g. "Print debugging information") # 3: whether the option is hidden OptionsType = T.type_alias { T::Array[[T.nilable(String), T.nilable(String), String, T::Boolean]] } sig { returns(T::Array[String]) } attr_reader :options_only, :flags_only, :remaining sig { void } def initialize require "cli/named_args" @cli_args = T.let(nil, T.nilable(T::Array[String])) @processed_options = T.let([], OptionsType) @options_only = T.let([], T::Array[String]) @flags_only = T.let([], T::Array[String]) @cask_options = T.let(false, T::Boolean) @table = T.let({}, T::Hash[Symbol, T.untyped]) # Can set these because they will be overwritten by freeze_named_args! # (whereas other values below will only be overwritten if passed). @named = T.let(NamedArgs.new(parent: self), T.nilable(NamedArgs)) @remaining = T.let([], T::Array[String]) end sig { params(remaining_args: T::Array[T.any(T::Array[String], String)]).void } def freeze_remaining_args!(remaining_args) = @remaining.replace(remaining_args).freeze sig { params(named_args: T::Array[String], cask_options: T::Boolean, without_api: T::Boolean).void } def freeze_named_args!(named_args, cask_options:, without_api:) @named = T.let( NamedArgs.new( *named_args.freeze, cask_options:, flags: flags_only, force_bottle: @table[:force_bottle?] || false, override_spec: @table[:HEAD?] ? :head : nil, parent: self, without_api:, ), T.nilable(NamedArgs), ) end sig { params(name: Symbol, value: T.untyped).void } def set_arg(name, value) @table[name] = value end sig { override.params(_blk: T.nilable(T.proc.params(x: T.untyped).void)).returns(T.untyped) } def tap(&_blk) return super if block_given? # Object#tap @table[:tap] end sig { params(processed_options: OptionsType).void } def freeze_processed_options!(processed_options) # Reset cache values reliant on processed_options @cli_args = nil @processed_options += processed_options @processed_options.freeze @options_only = cli_args.select { it.start_with?("-") }.freeze @flags_only = cli_args.select { it.start_with?("--") }.freeze end sig { returns(NamedArgs) } def named require "formula" T.must(@named) end sig { returns(T::Boolean) } def no_named? = named.empty? sig { returns(T::Array[String]) } def build_from_source_formulae if @table[:build_from_source?] || @table[:HEAD?] || @table[:build_bottle?] named.to_formulae.map(&:full_name) else [] end end sig { returns(T::Array[String]) } def include_test_formulae if @table[:include_test?] named.to_formulae.map(&:full_name) else [] end end sig { params(name: String).returns(T.nilable(String)) } def value(name) arg_prefix = "--#{name}=" flag_with_value = flags_only.find { |arg| arg.start_with?(arg_prefix) } return unless flag_with_value flag_with_value.delete_prefix(arg_prefix) end sig { returns(Context::ContextStruct) } def context Context::ContextStruct.new(debug: debug?, quiet: quiet?, verbose: verbose?) end sig { returns(T.nilable(Symbol)) } def only_formula_or_cask if @table[:formula?] && !@table[:cask?] :formula elsif @table[:cask?] && !@table[:formula?] :cask end end sig { returns(T::Array[[Symbol, Symbol]]) } def os_arch_combinations skip_invalid_combinations = false oses = case (os_sym = @table[:os]&.to_sym) when nil [SimulateSystem.current_os] when :all skip_invalid_combinations = true OnSystem::ALL_OS_OPTIONS else [os_sym] end arches = case (arch_sym = @table[:arch]&.to_sym) when nil [SimulateSystem.current_arch] when :all skip_invalid_combinations = true OnSystem::ARCH_OPTIONS else [arch_sym] end oses.product(arches).select do |os, arch| if skip_invalid_combinations bottle_tag = Utils::Bottles::Tag.new(system: os, arch:) bottle_tag.valid_combination? else true end end end private sig { params(option: String).returns(String) } def option_to_name(option) option.sub(/\A--?/, "") .tr("-", "_") end sig { returns(T::Array[String]) } def cli_args @cli_args ||= @processed_options.filter_map do |short, long| option = T.must(long || short) switch = :"#{option_to_name(option)}?" flag = option_to_name(option).to_sym if @table[switch] == true || @table[flag] == true option elsif @table[flag].instance_of? String "#{option}=#{@table[flag]}" elsif @table[flag].instance_of? Array "#{option}=#{@table[flag].join(",")}" end end.freeze end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cli/args.rbi000066400000000000000000000007311517265720000223060ustar00rootroot00000000000000# typed: strict # This file contains global args as defined in `Homebrew::CLI::Parser.global_options` # `Command`-specific args are defined in the commands themselves, with type signatures # generated by the `Tapioca::Compilers::Args` compiler. class Homebrew::CLI::Args sig { returns(T::Boolean) } def debug?; end sig { returns(T::Boolean) } def help?; end sig { returns(T::Boolean) } def quiet?; end sig { returns(T::Boolean) } def verbose?; end end Homebrew-brew-d7f73ce/Library/Homebrew/cli/error.rb000066400000000000000000000050751517265720000223400ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "utils/formatter" module Homebrew module CLI class OptionConstraintError < UsageError sig { params(arg1: String, arg2: String, missing: T::Boolean).void } def initialize(arg1, arg2, missing: false) message = if missing "`#{arg2}` cannot be passed without `#{arg1}`." else "`#{arg1}` and `#{arg2}` should be passed together." end super message end end class OptionConflictError < UsageError sig { params(args: T::Array[String]).void } def initialize(args) args_list = args.map { Formatter.option(it) }.join(" and ") super "Options #{args_list} are mutually exclusive." end end class InvalidConstraintError < UsageError sig { params(arg1: String, arg2: String).void } def initialize(arg1, arg2) super "`#{arg1}` and `#{arg2}` cannot be mutually exclusive and mutually dependent simultaneously." end end class MaxNamedArgumentsError < UsageError sig { params(maximum: Integer, types: T::Array[Symbol]).void } def initialize(maximum, types: []) super case maximum when 0 "This command does not take named arguments." else types << :named if types.empty? arg_types = types.map { |type| type.to_s.tr("_", " ") } .to_sentence two_words_connector: " or ", last_word_connector: " or " "This command does not take more than #{maximum} #{arg_types} #{Utils.pluralize("argument", maximum)}." end end end class MinNamedArgumentsError < UsageError sig { params(minimum: Integer, types: T::Array[Symbol]).void } def initialize(minimum, types: []) types << :named if types.empty? arg_types = types.map { |type| type.to_s.tr("_", " ") } .to_sentence two_words_connector: " or ", last_word_connector: " or " super "This command requires at least #{minimum} #{arg_types} #{Utils.pluralize("argument", minimum)}." end end class NumberOfNamedArgumentsError < UsageError sig { params(minimum: Integer, types: T::Array[Symbol]).void } def initialize(minimum, types: []) types << :named if types.empty? arg_types = types.map { |type| type.to_s.tr("_", " ") } .to_sentence two_words_connector: " or ", last_word_connector: " or " super "This command requires exactly #{minimum} #{arg_types} #{Utils.pluralize("argument", minimum)}." end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cli/named_args.rb000066400000000000000000000526631517265720000233140ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "cli/args" require "utils" require "utils/output" module Homebrew module CLI # Helper class for loading formulae/casks from named arguments. class NamedArgs < Array include Utils::Output::Mixin extend T::Generic Elem = type_member(:out) { { fixed: String } } sig { returns(Args) } attr_reader :parent sig { params( args: String, parent: Args, override_spec: T.nilable(Symbol), force_bottle: T::Boolean, flags: T::Array[String], cask_options: T::Boolean, without_api: T::Boolean, ).void } def initialize( *args, parent: Args.new, override_spec: nil, force_bottle: false, flags: [], cask_options: false, without_api: false ) super(args) @override_spec = override_spec @force_bottle = force_bottle @flags = flags @cask_options = cask_options @without_api = without_api @parent = parent end sig { returns(T::Array[Cask::Cask]) } def to_casks @to_casks ||= T.let( to_formulae_and_casks(only: :cask).freeze, T.nilable(T::Array[T.any(Formula, Keg, Cask::Cask)]) ) T.cast(@to_casks, T::Array[Cask::Cask]) end sig { returns(T::Array[Formula]) } def to_formulae @to_formulae ||= T.let( to_formulae_and_casks(only: :formula).freeze, T.nilable(T::Array[T.any(Formula, Keg, Cask::Cask)]) ) T.cast(@to_formulae, T::Array[Formula]) end # Convert named arguments to {Formula} or {Cask} objects. # If both a formula and cask with the same name exist, returns # the formula and prints a warning unless `only` is specified. sig { params( only: T.nilable(Symbol), ignore_unavailable: T::Boolean, method: T.nilable(Symbol), uniq: T::Boolean, warn: T::Boolean, ).returns(T::Array[T.any(Formula, Keg, Cask::Cask)]) } def to_formulae_and_casks( only: parent.only_formula_or_cask, ignore_unavailable: false, method: nil, uniq: true, warn: false ) @to_formulae_and_casks ||= T.let( {}, T.nilable(T::Hash[T.nilable(Symbol), T::Array[T.any(Formula, Keg, Cask::Cask)]]) ) @to_formulae_and_casks[only] ||= downcased_unique_named.flat_map do |name| load_formula_or_cask(name, only:, method:, warn:) rescue FormulaUnreadableError, FormulaClassUnavailableError, TapFormulaUnreadableError, TapFormulaClassUnavailableError, Cask::CaskUnreadableError # Need to rescue before `*UnavailableError` (superclass of this) # The formula/cask was found, but there's a problem with its implementation raise rescue NoSuchKegError, FormulaUnavailableError, Cask::CaskUnavailableError, FormulaOrCaskUnavailableError ignore_unavailable ? [] : raise end.freeze if uniq @to_formulae_and_casks.fetch(only).uniq.freeze else @to_formulae_and_casks.fetch(only) end end sig { params(only: T.nilable(Symbol), method: T.nilable(Symbol)) .returns([T::Array[T.any(Formula, Keg)], T::Array[Cask::Cask]]) } def to_formulae_to_casks(only: parent.only_formula_or_cask, method: nil) @to_formulae_to_casks ||= T.let( {}, T.nilable(T::Hash[[T.nilable(Symbol), T.nilable(Symbol)], [T::Array[T.any(Formula, Keg)], T::Array[Cask::Cask]]]) ) @to_formulae_to_casks[[method, only]] = T.cast( to_formulae_and_casks(only:, method:).partition { |o| o.is_a?(Formula) || o.is_a?(Keg) } .map(&:freeze).freeze, [T::Array[T.any(Formula, Keg)], T::Array[Cask::Cask]], ) end # Returns formulae and casks after validating that a tap is present for each of them. sig { returns(T::Array[T.any(Formula, Keg, Cask::Cask)]) } def to_formulae_and_casks_with_taps formulae_and_casks_with_taps, formulae_and_casks_without_taps = to_formulae_and_casks.partition do |formula_or_cask| T.cast(formula_or_cask, T.any(Formula, Cask::Cask)).tap&.installed? end return formulae_and_casks_with_taps if formulae_and_casks_without_taps.empty? types = [] types << "formulae" if formulae_and_casks_without_taps.any?(Formula) types << "casks" if formulae_and_casks_without_taps.any?(Cask::Cask) odie <<~ERROR These #{types.join(" and ")} are not in any locally installed taps! #{formulae_and_casks_without_taps.sort_by(&:to_s).join("\n ")} You may need to run `brew tap` to install additional taps. ERROR end sig { params(only: T.nilable(Symbol), method: T.nilable(Symbol)) .returns(T::Array[T.any(Formula, Keg, Cask::Cask, T::Array[Keg], FormulaOrCaskUnavailableError, NoSuchKegError)]) } def to_formulae_and_casks_and_unavailable(only: parent.only_formula_or_cask, method: nil) @to_formulae_casks_unknowns ||= T.let( {}, T.nilable(T::Hash[ T.nilable(Symbol), T::Array[T.any(Formula, Keg, Cask::Cask, T::Array[Keg], FormulaOrCaskUnavailableError, NoSuchKegError)], ]), ) @to_formulae_casks_unknowns[method] = downcased_unique_named.map do |name| load_formula_or_cask(name, only:, method:) rescue FormulaOrCaskUnavailableError, NoSuchKegError => e e end.uniq.freeze end sig { params(uniq: T::Boolean).returns(T::Array[Formula]) } def to_resolved_formulae(uniq: true) @to_resolved_formulae ||= T.let( to_formulae_and_casks(only: :formula, method: :resolve, uniq:).freeze, T.nilable(T::Array[T.any(Formula, Keg, Cask::Cask)]), ) T.cast(@to_resolved_formulae, T::Array[Formula]) end sig { params(only: T.nilable(Symbol)).returns([T::Array[Formula], T::Array[Cask::Cask]]) } def to_resolved_formulae_to_casks(only: parent.only_formula_or_cask) T.cast(to_formulae_to_casks(only:, method: :resolve), [T::Array[Formula], T::Array[Cask::Cask]]) end LOCAL_PATH_REGEX = %r{^/|[.]|/$} TAP_NAME_REGEX = %r{^[^./]+/[^./]+$} private_constant :LOCAL_PATH_REGEX, :TAP_NAME_REGEX # Keep existing paths and try to convert others to tap, formula or cask paths. # If a cask and formula with the same name exist, includes both their paths # unless `only` is specified. sig { params(only: T.nilable(Symbol), recurse_tap: T::Boolean).returns(T::Array[Pathname]) } def to_paths(only: parent.only_formula_or_cask, recurse_tap: false) @to_paths ||= T.let({}, T.nilable(T::Hash[T.nilable(Symbol), T::Array[Pathname]])) @to_paths[only] ||= Homebrew.with_no_api_env_if_needed(@without_api) do downcased_unique_named.flat_map do |name| path = Pathname(name).expand_path if only.nil? && name.match?(LOCAL_PATH_REGEX) && path.exist? path elsif name.match?(TAP_NAME_REGEX) tap = Tap.fetch(name) if recurse_tap next tap.formula_files if only == :formula next tap.cask_files if only == :cask end tap.path else next Formulary.path(name) if only == :formula next Cask::CaskLoader.path(name) if only == :cask formula_path = Formulary.path(name) cask_path = Cask::CaskLoader.path(name) paths = [] if formula_path.exist? || (!Homebrew::EnvConfig.no_install_from_api? && !CoreTap.instance.installed? && Homebrew::API.formula_names.include?(path.basename.to_s)) paths << formula_path end if cask_path.exist? || (!Homebrew::EnvConfig.no_install_from_api? && !CoreCaskTap.instance.installed? && Homebrew::API.cask_tokens.include?(path.basename.to_s)) paths << cask_path end paths.empty? ? path : paths end end.uniq.freeze end end sig { returns(T::Array[Keg]) } def to_default_kegs require "missing_formula" @to_default_kegs ||= T.let(begin to_formulae_and_casks(only: :formula, method: :default_kegs).freeze rescue NoSuchKegError => e if (reason = MissingFormula.suggest_command(e.name, "uninstall")) $stderr.puts reason end raise e end, T.nilable(T::Array[T.any(Formula, Keg, Cask::Cask)])) T.cast(@to_default_kegs, T::Array[Keg]) end sig { returns(T::Array[Keg]) } def to_latest_kegs require "missing_formula" @to_latest_kegs ||= T.let(begin to_formulae_and_casks(only: :formula, method: :latest_kegs).freeze rescue NoSuchKegError => e if (reason = MissingFormula.suggest_command(e.name, "uninstall")) $stderr.puts reason end raise e end, T.nilable(T::Array[T.any(Formula, Keg, Cask::Cask)])) T.cast(@to_latest_kegs, T::Array[Keg]) end sig { returns(T::Array[Keg]) } def to_kegs require "missing_formula" @to_kegs ||= T.let(begin to_formulae_and_casks(only: :formula, method: :kegs).freeze rescue NoSuchKegError => e if (reason = MissingFormula.suggest_command(e.name, "uninstall")) $stderr.puts reason end raise e end, T.nilable(T::Array[T.any(Formula, Keg, Cask::Cask)])) T.cast(@to_kegs, T::Array[Keg]) end sig { params(only: T.nilable(Symbol), ignore_unavailable: T::Boolean, all_kegs: T.nilable(T::Boolean)) .returns([T::Array[Keg], T::Array[Cask::Cask]]) } def to_kegs_to_casks(only: parent.only_formula_or_cask, ignore_unavailable: false, all_kegs: nil) method = all_kegs ? :kegs : :default_kegs key = [method, only, ignore_unavailable] @to_kegs_to_casks ||= T.let( {}, T.nilable( T::Hash[ [T.nilable(Symbol), T.nilable(Symbol), T::Boolean], [T::Array[Keg], T::Array[Cask::Cask]], ], ), ) @to_kegs_to_casks[key] ||= T.cast( to_formulae_and_casks(only:, ignore_unavailable:, method:) .partition { |o| o.is_a?(Keg) } .map(&:freeze).freeze, [T::Array[Keg], T::Array[Cask::Cask]], ) end sig { returns(T::Array[Tap]) } def to_taps @to_taps ||= T.let(downcased_unique_named.map { |name| Tap.fetch name }.uniq.freeze, T.nilable(T::Array[Tap])) end sig { returns(T::Array[Tap]) } def to_installed_taps @to_installed_taps ||= T.let(to_taps.each do |tap| raise TapUnavailableError, tap.name unless tap.installed? end.uniq.freeze, T.nilable(T::Array[Tap])) end sig { returns(T::Array[String]) } def homebrew_tap_cask_names downcased_unique_named.grep(HOMEBREW_CASK_TAP_CASK_REGEX) end private sig { returns(T::Array[String]) } def downcased_unique_named # Only lowercase names, not paths, bottle filenames or URLs map do |arg| if arg.include?("/") || arg.end_with?(".tar.gz") || File.exist?(arg) arg else arg.downcase end end.uniq end sig { params(name: String, only: T.nilable(Symbol), method: T.nilable(Symbol), warn: T::Boolean) .returns(T.any(Formula, Keg, Cask::Cask, T::Array[Keg])) } def load_formula_or_cask(name, only: nil, method: nil, warn: false) Homebrew.with_no_api_env_if_needed(@without_api) do unreadable_error = nil formula_or_kegs = if only != :cask begin case method when nil, :factory Formulary.factory(name, *@override_spec, warn:, force_bottle: @force_bottle, flags: @flags) when :resolve resolve_formula(name) when :latest_kegs resolve_latest_keg(name) when :default_kegs resolve_default_keg(name) when :kegs _, kegs = resolve_kegs(name) kegs else raise end rescue FormulaUnreadableError, FormulaClassUnavailableError, TapFormulaUnreadableError, TapFormulaClassUnavailableError, FormulaSpecificationError => e # Need to rescue before `FormulaUnavailableError` (superclass of this) # The formula was found, but there's a problem with its implementation unreadable_error ||= e nil rescue NoSuchKegError, FormulaUnavailableError => e raise e if only == :formula nil end end if only == :formula return formula_or_kegs if formula_or_kegs elsif formula_or_kegs && (!formula_or_kegs.is_a?(Formula) || formula_or_kegs.tap&.core_tap?) warn_if_cask_conflicts(name, "formula") return formula_or_kegs else want_keg_like_cask = [:latest_kegs, :default_kegs, :kegs].include?(method) cask = begin config = Cask::Config.from_args(@parent) if @cask_options options = { warn: }.compact candidate_cask = Cask::CaskLoader.load(name, config:, **options) if unreadable_error onoe <<~EOS Failed to load formula: #{name} #{unreadable_error} EOS opoo "Treating #{name} as a cask." end # If we're trying to get a keg-like Cask, do our best to use the same cask # file that was used for installation, if possible. if want_keg_like_cask && (installed_caskfile = candidate_cask.installed_caskfile) && installed_caskfile.exist? cask = Cask::CaskLoader.load_from_installed_caskfile(installed_caskfile) requested_tap, requested_token = Tap.with_cask_token(name) if requested_tap && requested_token installed_cask_tap = cask.tab.tap if installed_cask_tap && installed_cask_tap != requested_tap raise Cask::TapCaskUnavailableError.new(requested_tap, requested_token) end end cask else candidate_cask end rescue Cask::CaskUnreadableError, Cask::CaskInvalidError => e # If we're trying to get a keg-like Cask, do our best to handle it # not being readable and return something that can be used. if want_keg_like_cask cask_version = Cask::Cask.new(name, config:).installed_version Cask::Cask.new(name, config:) do version cask_version if cask_version end else # Need to rescue before `CaskUnavailableError` (superclass of this) # The cask was found, but there's a problem with its implementation unreadable_error ||= e nil end rescue Cask::CaskUnavailableError => e raise e if only == :cask nil end # Prioritise formulae unless it's a core tap cask (we already prioritised core tap formulae above) if formula_or_kegs && !cask&.tap&.core_cask_tap? if cask || unreadable_error onoe <<~EOS if unreadable_error Failed to load cask: #{name} #{unreadable_error} EOS opoo package_conflicts_message(name, "formula", cask) unless Context.current.quiet? end return formula_or_kegs elsif cask if formula_or_kegs && !Context.current.quiet? opoo package_conflicts_message(name, "cask", formula_or_kegs) end return cask end end raise unreadable_error if unreadable_error downcased_name = name.downcase if (tap_name = Utils.tap_from_full_name(downcased_name)) raise TapFormulaOrCaskUnavailableError.new(Tap.fetch(tap_name), Utils.name_from_full_name(downcased_name)) end raise NoSuchKegError, name if resolve_formula(name) end end sig { params(name: String).returns(Formula) } def resolve_formula(name) Formulary.resolve(name, spec: @override_spec, force_bottle: @force_bottle, flags: @flags) end sig { params(name: String).returns([Pathname, T::Array[Keg]]) } def resolve_kegs(name) raise UsageError if name.blank? require "keg" rack = Formulary.to_rack(name.downcase) kegs = rack.directory? ? rack.subdirs.map { |d| Keg.new(d) } : [] requested_tap, requested_formula = Tap.with_formula_name(name) if requested_tap && requested_formula kegs = kegs.select do |keg| keg.tab.tap == requested_tap end raise NoSuchKegError.new(requested_formula, tap: requested_tap) if kegs.none? end raise NoSuchKegError, name if kegs.none? [rack, kegs] end sig { params(name: String).returns(Keg) } def resolve_latest_keg(name) _, kegs = resolve_kegs(name) # Return keg if it is the only installed keg return kegs.fetch(0) if kegs.length == 1 stable_kegs = kegs.reject { |keg| keg.version.head? } latest_keg = if stable_kegs.empty? kegs.max_by do |keg| [keg.tab.source_modified_time, keg.version.revision] end else stable_kegs.max_by(&:scheme_and_version) end T.must(latest_keg) end sig { params(name: String).returns(Keg) } def resolve_default_keg(name) rack, kegs = resolve_kegs(name) linked_keg_ref = HOMEBREW_LINKED_KEGS/rack.basename opt_prefix = HOMEBREW_PREFIX/"opt/#{rack.basename}" begin return Keg.new(opt_prefix.resolved_path) if opt_prefix.symlink? && opt_prefix.directory? return Keg.new(linked_keg_ref.resolved_path) if linked_keg_ref.symlink? && linked_keg_ref.directory? return kegs.fetch(0) if kegs.length == 1 f = if name.include?("/") || File.exist?(name) Formulary.factory(name) else Formulary.from_rack(rack) end unless (prefix = f.latest_installed_prefix).directory? raise MultipleVersionsInstalledError, <<~EOS #{rack.basename} has multiple installed versions Run `brew uninstall --force #{rack.basename}` to remove all versions. EOS end Keg.new(prefix) rescue FormulaUnavailableError raise MultipleVersionsInstalledError, <<~EOS Multiple kegs installed to #{rack} However we don't know which one you refer to. Please delete (with `rm -rf`!) all but one and then try again. EOS end end sig { params( ref: String, loaded_type: String, package: T.nilable(T.any(T::Array[T.any(Formula, Keg)], Cask::Cask, Formula, Keg)) ).returns(String) } def package_conflicts_message(ref, loaded_type, package) message = "Treating #{ref} as a #{loaded_type}." case package when Formula, Keg, Array message += " For the formula, " if package.is_a?(Formula) && (tap = package.tap) message += "use #{tap.name}/#{package.name} or " end message += "specify the `--formula` flag. To silence this message, use the `--cask` flag." when Cask::Cask message += " For the cask, " if (tap = package.tap) message += "use #{tap.name}/#{package.token} or " end message += "specify the `--cask` flag. To silence this message, use the `--formula` flag." end message.freeze end sig { params(ref: String, loaded_type: String).void } def warn_if_cask_conflicts(ref, loaded_type) available = true cask = begin Cask::CaskLoader.load(ref, warn: false) rescue Cask::CaskUnreadableError => e # Need to rescue before `CaskUnavailableError` (superclass of this) # The cask was found, but there's a problem with its implementation onoe <<~EOS Failed to load cask: #{ref} #{e} EOS nil rescue Cask::CaskUnavailableError # No ref conflict with a cask, do nothing available = false nil end return unless available return if Context.current.quiet? return if cask&.old_tokens&.include?(ref) opoo package_conflicts_message(ref, loaded_type, cask) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cli/parser.rb000066400000000000000000000650151517265720000225030ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "env_config" require "cask/config" require "cli/args" require "cli/error" require "commands" require "optparse" require "utils/tty" require "utils/formatter" require "utils/output" module Homebrew module CLI class Parser include Utils::Output::Mixin ArgType = T.type_alias { T.nilable(T.any(Symbol, T::Array[String], T::Array[Symbol])) } HIDDEN_DESC_PLACEHOLDER = "@@HIDDEN@@" SYMBOL_TO_USAGE_MAPPING = T.let({ text_or_regex: "|`/``/`", url: "", }.freeze, T::Hash[Symbol, String]) private_constant :ArgType, :HIDDEN_DESC_PLACEHOLDER, :SYMBOL_TO_USAGE_MAPPING sig { returns(Args) } attr_reader :args sig { returns(Args::OptionsType) } attr_reader :processed_options sig { returns(T::Boolean) } attr_reader :hide_from_man_page sig { returns(ArgType) } attr_reader :named_args_type sig { params(cmd_path: Pathname).returns(T.nilable(CLI::Parser)) } def self.from_cmd_path(cmd_path) cmd_args_method_name = Commands.args_method_name(cmd_path) cmd_name = cmd_args_method_name.to_s.delete_suffix("_args").tr("_", "-") begin if Homebrew.require?(cmd_path) cmd = Homebrew::AbstractCommand.command(cmd_name) if cmd cmd.parser else # FIXME: remove once commands are all subclasses of `AbstractCommand`: Homebrew.send(cmd_args_method_name) end end rescue NoMethodError => e raise if e.name.to_sym != cmd_args_method_name nil end end sig { returns(T::Array[[Symbol, String, { description: String }]]) } def self.global_cask_options [ [:flag, "--appdir=", { description: "Target location for Applications " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:appdir]}`).", }], [:flag, "--keyboard-layoutdir=", { description: "Target location for Keyboard Layouts " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:keyboard_layoutdir]}`).", }], [:flag, "--colorpickerdir=", { description: "Target location for Color Pickers " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:colorpickerdir]}`).", }], [:flag, "--prefpanedir=", { description: "Target location for Preference Panes " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:prefpanedir]}`).", }], [:flag, "--qlplugindir=", { description: "Target location for Quick Look Plugins " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:qlplugindir]}`).", }], [:flag, "--mdimporterdir=", { description: "Target location for Spotlight Plugins " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:mdimporterdir]}`).", }], [:flag, "--dictionarydir=", { description: "Target location for Dictionaries " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:dictionarydir]}`).", }], [:flag, "--fontdir=", { description: "Target location for Fonts " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:fontdir]}`).", }], [:flag, "--servicedir=", { description: "Target location for Services " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:servicedir]}`).", }], [:flag, "--input-methoddir=", { description: "Target location for Input Methods " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:input_methoddir]}`).", }], [:flag, "--internet-plugindir=", { description: "Target location for Internet Plugins " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:internet_plugindir]}`).", }], [:flag, "--audio-unit-plugindir=", { description: "Target location for Audio Unit Plugins " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:audio_unit_plugindir]}`).", }], [:flag, "--vst-plugindir=", { description: "Target location for VST Plugins " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:vst_plugindir]}`).", }], [:flag, "--vst3-plugindir=", { description: "Target location for VST3 Plugins " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:vst3_plugindir]}`).", }], [:flag, "--screen-saverdir=", { description: "Target location for Screen Savers " \ "(default: `#{Cask::Config::DEFAULT_DIRS[:screen_saverdir]}`).", }], [:comma_array, "--language", { description: "Comma-separated list of language codes to prefer for cask installation. " \ "The first matching language is used, otherwise it reverts to the cask's " \ "default language. The default value is the language of your system.", }], ] end sig { returns(T::Array[[String, String, String]]) } def self.global_options [ ["-d", "--debug", "Display any debugging information."], ["-q", "--quiet", "Make some output more quiet."], ["-v", "--verbose", "Make some output more verbose."], ["-h", "--help", "Show this message."], ] end sig { params(option: String).returns(String) } def self.option_to_name(option) option.sub(/\A--?(\[no-\])?/, "").tr("-", "_").delete("=") end sig { params(cmd: T.class_of(Homebrew::AbstractCommand), block: T.nilable(T.proc.bind(Parser).void)).void } def initialize(cmd, &block) @parser = T.let(OptionParser.new, OptionParser) @parser.summary_indent = " " # Disable default handling of `--version` switch. @parser.base.long.delete("version") # Disable default handling of `--help` switch. @parser.base.long.delete("help") @args = T.let((cmd.args_class || Args).new, Args) @command_name = T.let(cmd.command_name, String) @is_dev_cmd = T.let(cmd.dev_cmd?, T::Boolean) @constraints = T.let([], T::Array[[String, String]]) @conflicts = T.let([], T::Array[T::Array[String]]) @switch_sources = T.let({}, T::Hash[String, Symbol]) @processed_options = T.let([], Args::OptionsType) @non_global_processed_options = T.let([], T::Array[[String, ArgType]]) @named_args_type = T.let(nil, T.nilable(ArgType)) @max_named_args = T.let(nil, T.nilable(Integer)) @min_named_args = T.let(nil, T.nilable(Integer)) @named_args_without_api = T.let(false, T::Boolean) @description = T.let(nil, T.nilable(String)) @usage_banner = T.let(nil, T.nilable(String)) @hide_from_man_page = T.let(false, T::Boolean) @formula_options = T.let(false, T::Boolean) @cask_options = T.let(false, T::Boolean) self.class.global_options.each do |short, long, desc| switch short, long, description: desc, env: option_to_name(long), method: :on_tail end instance_eval(&block) if block generate_banner end sig { params(names: String, description: T.nilable(String), env: T.untyped, depends_on: T.nilable(String), method: Symbol, hidden: T::Boolean, replacement: T.nilable(T.any(String, FalseClass)), odeprecated: T::Boolean, odisabled: T::Boolean, disable: T::Boolean).void } def switch(*names, description: nil, env: nil, depends_on: nil, method: :on, hidden: false, replacement: nil, odeprecated: false, odisabled: false, disable: false) global_switch = names.first.is_a?(Symbol) return if global_switch if disable # this odisabled should be removed in 5.2.0 odisabled "disable:", "odisabled:" odisabled = disable end if !odeprecated && !odisabled && replacement # this odisabled should be removed in 5.2.0 odisabled "replacement: without :odeprecated or :odisabled", "replacement: with :odeprecated or :odisabled" odeprecated = true end hidden = true if odisabled || odeprecated description = option_description(description, *names, hidden:) env, counterpart = env env_hidden = Homebrew::EnvConfig::ENVS.fetch(:"HOMEBREW_#{env.upcase}", {}).fetch(:hidden, false) if env if env && @non_global_processed_options.any? && !hidden && !env_hidden affix = counterpart ? " and `#{counterpart}` is passed." : "." description += " Enabled by default if `$HOMEBREW_#{env.upcase}` is set#{affix}" end process_option(*names, description, type: :switch, hidden:) unless odisabled @parser.public_send(method, *names, *wrap_option_desc(description)) do |value| # This odeprecated should stick around indefinitely. replacement_string = replacement if replacement if odeprecated || odisabled odeprecated "the `#{names.first}` switch", replacement_string, disable: odisabled end value = true if names.none? { |name| name.start_with?("--[no-]") } set_switch(*names, value:, from: :args) end names.each do |name| set_constraints(name, depends_on:) end env_value = value_for_env(env) value = env_value&.present? set_switch(*names, value:, from: :env) unless value.nil? end alias switch_option switch sig { params(text: T.nilable(String)).returns(T.nilable(String)) } def description(text = nil) return @description if text.blank? @description = text.chomp end sig { params(text: String).void } def usage_banner(text) @usage_banner, @description = text.chomp.split("\n\n", 2) end sig { returns(T.nilable(String)) } def usage_banner_text = @parser.banner sig { params(name: String, description: T.nilable(String), hidden: T::Boolean).void } def comma_array(name, description: nil, hidden: false) name = name.chomp "=" description = option_description(description, name, hidden:) process_option(name, description, type: :comma_array, hidden:) @parser.on(name, OptionParser::REQUIRED_ARGUMENT, Array, *wrap_option_desc(description)) do |list| set_args_method(option_to_name(name).to_sym, list) end end sig { params(names: String, description: T.nilable(String), replacement: T.nilable(T.any(Symbol, String)), depends_on: T.nilable(String), hidden: T::Boolean).void } def flag(*names, description: nil, replacement: nil, depends_on: nil, hidden: false) required, flag_type = if names.any? { |name| name.end_with? "=" } [OptionParser::REQUIRED_ARGUMENT, :required_flag] else [OptionParser::OPTIONAL_ARGUMENT, :optional_flag] end names.map! { |name| name.chomp "=" } description = option_description(description, *names, hidden:) if replacement.nil? process_option(*names, description, type: flag_type, hidden:) else description += " (disabled#{"; replaced by #{replacement}" if replacement.present?})" end @parser.on(*names, *wrap_option_desc(description), required) do |option_value| # This odisabled should stick around indefinitely. odisabled "the `#{names.first}` flag", replacement unless replacement.nil? names.each do |name| set_args_method(option_to_name(name).to_sym, option_value) end end names.each do |name| set_constraints(name, depends_on:) end end sig { params(name: Symbol, value: T.untyped).void } def set_args_method(name, value) @args.set_arg(name, value) return if @args.respond_to?(name) @args.define_singleton_method(name) do # We cannot reference the ivar directly due to https://github.com/sorbet/sorbet/issues/8106 instance_variable_get(:@table).fetch(name) end end sig { params(options: String).returns(T::Array[T::Array[String]]) } def conflicts(*options) @conflicts << options.map { |option| option_to_name(option) } end sig { params(option: String).returns(String) } def option_to_name(option) = self.class.option_to_name(option) sig { params(name: String).returns(String) } def name_to_option(name) if name.length == 1 "-#{name}" else "--#{name.tr("_", "-")}" end end sig { params(names: String).returns(T.nilable(String)) } def option_to_description(*names) names.map { |name| name.to_s.sub(/\A--?/, "").tr("-", " ") }.max end sig { params(description: T.nilable(String), names: String, hidden: T::Boolean).returns(String) } def option_description(description, *names, hidden: false) return HIDDEN_DESC_PLACEHOLDER if hidden return description if description.present? option_to_description(*names) end sig { params(argv: T::Array[String], ignore_invalid_options: T::Boolean) .returns([T::Array[String], T::Array[String]]) } def parse_remaining(argv, ignore_invalid_options: false) i = 0 remaining = [] argv, non_options = split_non_options(argv) allow_commands = Array(@named_args_type).include?(:command) while i < argv.count begin begin arg = argv[i] remaining << arg unless @parser.parse([arg]).empty? rescue OptionParser::MissingArgument raise if i + 1 >= argv.count args = argv[i..(i + 1)] @parser.parse(args) i += 1 end rescue OptionParser::InvalidOption if ignore_invalid_options || (allow_commands && arg && Commands.path(arg)) remaining << arg else $stderr.puts generate_help_text raise end end i += 1 end [remaining, non_options] end sig { params(argv: T::Array[String], ignore_invalid_options: T::Boolean).returns(Args) } def parse(argv = ARGV.freeze, ignore_invalid_options: false) raise "Arguments were already parsed!" if @args_parsed # If we accept formula options, but the command isn't scoped only # to casks, parse once allowing invalid options so we can get the # remaining list containing formula names. if @formula_options && !only_casks?(argv) remaining, non_options = parse_remaining(argv, ignore_invalid_options: true) argv = [*remaining, "--", *non_options] formulae(argv).each do |f| next if f.options.empty? f.options.each do |o| name = o.flag description = "`#{f.name}`: #{o.description}" if name.end_with? "=" flag(name, description:) else switch name, description: end conflicts "--cask", name end end end remaining, non_options = parse_remaining(argv, ignore_invalid_options:) named_args = if ignore_invalid_options [] else remaining + non_options end unless ignore_invalid_options unless @is_dev_cmd set_default_options validate_options end check_constraint_violations check_named_args(named_args) end @args.freeze_named_args!(named_args, cask_options: @cask_options, without_api: @named_args_without_api) @args.freeze_remaining_args!(non_options.empty? ? remaining : [*remaining, "--", non_options]) @args.freeze_processed_options!(@processed_options) @args.freeze @args_parsed = T.let(true, T.nilable(TrueClass)) if !ignore_invalid_options && @args.help? puts generate_help_text exit end @args end sig { void } def set_default_options; end sig { void } def validate_options; end sig { returns(String) } def generate_help_text Formatter.format_help_text(@parser.to_s, width: Formatter::COMMAND_DESC_WIDTH) .gsub(/\n.*?@@HIDDEN@@.*?(?=\n)/, "") .sub(/^/, "#{Tty.bold}Usage: brew#{Tty.reset} ") .gsub(/`(.*?)`/m, "#{Tty.bold}\\1#{Tty.reset}") .gsub(%r{<([^\s]+?://[^\s]+?)>}) { |url| Formatter.url(url) } .gsub(/\*(.*?)\*|<(.*?)>/m) do |underlined| T.must(underlined[1...-1]).gsub(/^(\s*)(.*?)$/, "\\1#{Tty.underline}\\2#{Tty.reset}") end end sig { void } def cask_options self.class.global_cask_options.each do |args| options = T.cast(args.pop, T::Hash[Symbol, String]) send(*args, **options) conflicts "--formula", args[1] end @cask_options = true end sig { void } def formula_options @formula_options = true end sig { params( type: ArgType, number: T.nilable(Integer), min: T.nilable(Integer), max: T.nilable(Integer), without_api: T::Boolean, ).void } def named_args(type = nil, number: nil, min: nil, max: nil, without_api: false) raise ArgumentError, "Do not specify both `number` and `min` or `max`" if number && (min || max) if type == :none && (number || min || max) raise ArgumentError, "Do not specify both `number`, `min` or `max` with `named_args :none`" end @named_args_type = type if type == :none @max_named_args = 0 elsif number @min_named_args = @max_named_args = number elsif min || max @min_named_args = min @max_named_args = max end @named_args_without_api = without_api end sig { void } def hide_from_man_page! @hide_from_man_page = true end private sig { returns(String) } def generate_usage_banner command_names = ["`#{@command_name}`"] aliases_to_skip = %w[instal uninstal] command_names += Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.filter_map do |command_alias, command| next if aliases_to_skip.include? command_alias "`#{command_alias}`" if command == @command_name end.sort options = if @non_global_processed_options.empty? "" elsif @non_global_processed_options.count > 2 " []" else required_argument_types = [:required_flag, :comma_array] @non_global_processed_options.map do |option, type| next " [`#{option}=`]" if required_argument_types.include? type " [`#{option}`]" end.join end named_args = "" if @named_args_type.present? && @named_args_type != :none arg_type = if @named_args_type.is_a? Array types = @named_args_type.filter_map do |type| next unless type.is_a? Symbol next SYMBOL_TO_USAGE_MAPPING[type] if SYMBOL_TO_USAGE_MAPPING.key?(type) "<#{type}>" end types << "" if @named_args_type.any?(String) types.join("|") elsif SYMBOL_TO_USAGE_MAPPING.key? @named_args_type SYMBOL_TO_USAGE_MAPPING[@named_args_type] else "<#{@named_args_type}>" end named_args = if @min_named_args.nil? && @max_named_args == 1 " [#{arg_type}]" elsif @min_named_args.nil? " [#{arg_type} ...]" elsif @min_named_args == 1 && @max_named_args == 1 " #{arg_type}" elsif @min_named_args == 1 " #{arg_type} [...]" else " #{arg_type} ..." end end "#{command_names.join(", ")}#{options}#{named_args}" end sig { returns(String) } def generate_banner @usage_banner ||= generate_usage_banner @parser.banner = <<~BANNER #{@usage_banner} #{@description} BANNER end sig { params(names: String, value: T.untyped, from: Symbol).void } def set_switch(*names, value:, from:) names.each do |name| @switch_sources[option_to_name(name)] = from set_args_method(:"#{option_to_name(name)}?", value) end end sig { params(args: String).void } def disable_switch(*args) args.each do |name| result = if name.start_with?("--[no-]") nil else false end set_args_method(:"#{option_to_name(name)}?", result) end end sig { params(name: String).returns(T::Boolean) } def option_passed?(name) [name.to_sym, :"#{name}?"].any? do |method| @args.public_send(method) if @args.respond_to?(method) end end sig { params(desc: String).returns(T::Array[String]) } def wrap_option_desc(desc) Formatter.format_help_text(desc, width: Formatter::OPTION_DESC_WIDTH).split("\n") end sig { params(name: String, depends_on: T.nilable(String)).returns(T.nilable(T::Array[[String, String]])) } def set_constraints(name, depends_on:) return if depends_on.nil? primary = option_to_name(depends_on) secondary = option_to_name(name) @constraints << [primary, secondary] end sig { void } def check_constraints @constraints.each do |primary, secondary| primary_passed = option_passed?(primary) secondary_passed = option_passed?(secondary) next if !secondary_passed || (primary_passed && secondary_passed) primary = name_to_option(primary) secondary = name_to_option(secondary) raise OptionConstraintError.new(primary, secondary, missing: true) end end sig { void } def check_conflicts @conflicts.each do |mutually_exclusive_options_group| violations = mutually_exclusive_options_group.select do |option| option_passed? option end next if violations.count < 2 env_var_options = violations.select do |option| @switch_sources[option_to_name(option)] == :env end select_cli_arg = violations.count - env_var_options.count == 1 raise OptionConflictError, violations.map { name_to_option(it) } unless select_cli_arg env_var_options.each { disable_switch(it) } end end sig { void } def check_invalid_constraints @conflicts.each do |mutually_exclusive_options_group| @constraints.each do |p, s| next unless Set[p, s].subset?(Set[*mutually_exclusive_options_group]) raise InvalidConstraintError.new(p, s) end end end sig { void } def check_constraint_violations check_invalid_constraints check_conflicts check_constraints end sig { params(args: T::Array[String]).void } def check_named_args(args) types = Array(@named_args_type).filter_map do |type| next type if type.is_a? Symbol :subcommand end.uniq exception = if @min_named_args && @max_named_args && @min_named_args == @max_named_args && args.size != @max_named_args NumberOfNamedArgumentsError.new(@min_named_args, types:) elsif @min_named_args && args.size < @min_named_args MinNamedArgumentsError.new(@min_named_args, types:) elsif @max_named_args && args.size > @max_named_args MaxNamedArgumentsError.new(@max_named_args, types:) end raise exception if exception end sig { params(args: String, type: Symbol, hidden: T::Boolean).void } def process_option(*args, type:, hidden: false) option, = @parser.make_switch(args) @processed_options.reject! { |existing| existing.second == option.long.first } if option.long.first.present? @processed_options << [option.short.first, option.long.first, option.desc.first, hidden] args.pop # last argument is the description if type == :switch disable_switch(*args) else args.each do |name| set_args_method(option_to_name(name).to_sym, nil) end end return if hidden return if self.class.global_options.include? [option.short.first, option.long.first, option.desc.first] @non_global_processed_options << [option.long.first || option.short.first, type] end sig { params(argv: T::Array[String]).returns([T::Array[String], T::Array[String]]) } def split_non_options(argv) if (sep = argv.index("--")) [argv.take(sep), argv.drop(sep + 1)] else [argv, []] end end sig { params(argv: T::Array[String]).returns(T::Array[Formula]) } def formulae(argv) argv, non_options = split_non_options(argv) named_args = argv.reject { |arg| arg.start_with?("-") } + non_options spec = if argv.include?("--HEAD") :head else :stable end # Only lowercase names, not paths, bottle filenames or URLs named_args.filter_map do |arg| next if arg.match?(HOMEBREW_CASK_TAP_CASK_REGEX) begin Formulary.factory(arg, spec, flags: argv.select { |a| a.start_with?("--") }) rescue FormulaUnavailableError, FormulaSpecificationError nil end end.uniq(&:name) end sig { params(argv: T::Array[String]).returns(T::Boolean) } def only_casks?(argv) argv.include?("--casks") || argv.include?("--cask") end sig { params(env: T.nilable(T.any(String, Symbol))).returns(T.untyped) } def value_for_env(env) return if env.blank? method_name = :"#{env}?" if Homebrew::EnvConfig.respond_to?(method_name) Homebrew::EnvConfig.public_send(method_name) else ENV.fetch("HOMEBREW_#{env.upcase}", nil) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmake/000077500000000000000000000000001517265720000211645ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/cmake/trap_fetchcontent_provider.cmake000066400000000000000000000015101517265720000276070ustar00rootroot00000000000000# Dependency providers were introduced in CMake 3.24. We don't set cmake_minimum_required here because that would # propagate to downstream projects, which may break projects that rely on deprecated CMake behavior. Since the build # is using brewed CMake, we can assume that the CMake version in use is at least 3.24. option(HOMEBREW_ALLOW_FETCHCONTENT "Allow FetchContent to be used in Homebrew builds" OFF) if (HOMEBREW_ALLOW_FETCHCONTENT) return() endif() macro(trap_fetchcontent_provider method depName) message(FATAL_ERROR "Refusing to populate dependency '${depName}' with FetchContent while building in Homebrew, please use a formula dependency or add a resource to the formula.") endmacro() cmake_language( SET_DEPENDENCY_PROVIDER trap_fetchcontent_provider SUPPORTED_METHODS FETCHCONTENT_MAKEAVAILABLE_SERIAL ) Homebrew-brew-d7f73ce/Library/Homebrew/cmd/000077500000000000000000000000001517265720000206475ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--cache.rb000066400000000000000000000107441517265720000223770ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "fetch" require "cask/download" module Homebrew module Cmd class Cache < AbstractCommand include Fetch sig { override.returns(String) } def self.command_name = "--cache" cmd_args do description <<~EOS Display Homebrew's download cache. See also `$HOMEBREW_CACHE`. If a or is provided, display the file or directory used to cache it. EOS flag "--os=", description: "Show cache file for the given operating system. " \ "(Pass `all` to show cache files for all operating systems.)" flag "--arch=", description: "Show cache file for the given CPU architecture. " \ "(Pass `all` to show cache files for all architectures.)" switch "-s", "--build-from-source", description: "Show the cache file used when building from source." switch "--force-bottle", description: "Show the cache file used when pouring a bottle." flag "--bottle-tag=", description: "Show the cache file used when pouring a bottle for the given tag." switch "--HEAD", description: "Show the cache file used when building from HEAD." switch "--formula", "--formulae", description: "Only show cache files for formulae." switch "--cask", "--casks", description: "Only show cache files for casks." conflicts "--build-from-source", "--force-bottle", "--bottle-tag", "--HEAD", "--cask" conflicts "--formula", "--cask" conflicts "--os", "--bottle-tag" conflicts "--arch", "--bottle-tag" named_args [:formula, :cask] end sig { override.void } def run if args.no_named? puts HOMEBREW_CACHE return end formulae_or_casks = args.named.to_formulae_and_casks os_arch_combinations = args.os_arch_combinations formulae_or_casks.each do |formula_or_cask| case formula_or_cask when Formula formula = formula_or_cask ref = formula.loaded_from_api? ? formula.full_name : formula.path os_arch_combinations.each do |os, arch| SimulateSystem.with(os:, arch:) do formula = Formulary.factory(ref) print_formula_cache(formula, os:, arch:) end end when Cask::Cask cask = formula_or_cask if cask.loaded_from_api? ref = cask.full_name else ref = cask.sourcefile_path raise "unexpected nil cask sourcefile_path" unless ref end os_arch_combinations.each do |os, arch| next if os == :linux SimulateSystem.with(os:, arch:) do loaded_cask = Cask::CaskLoader.load(ref) print_cask_cache(loaded_cask) end end else raise "Invalid type: #{formula_or_cask.class}" end end end private sig { params(formula: Formula, os: Symbol, arch: Symbol).void } def print_formula_cache(formula, os:, arch:) if fetch_bottle?( formula, force_bottle: args.force_bottle?, bottle_tag: args.bottle_tag&.to_sym, build_from_source_formulae: args.build_from_source_formulae, os: args.os&.to_sym, arch: args.arch&.to_sym, ) bottle_tag = if (bottle_tag = args.bottle_tag&.to_sym) Utils::Bottles::Tag.from_symbol(bottle_tag) else Utils::Bottles::Tag.new(system: os, arch:) end bottle = formula.bottle_for_tag(bottle_tag) if bottle.nil? opoo "Bottle for tag #{bottle_tag.to_sym.inspect} is unavailable." return end puts bottle.cached_download elsif args.HEAD? if (head = formula.head) puts head.cached_download else opoo "No head is defined for #{formula.full_name}." end else puts formula.cached_download end end sig { params(cask: Cask::Cask).void } def print_cask_cache(cask) puts Cask::Download.new(cask).downloader.cached_location end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--caskroom.rb000066400000000000000000000014611517265720000231460ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" module Homebrew module Cmd class Caskroom < AbstractCommand sig { override.returns(String) } def self.command_name = "--caskroom" cmd_args do description <<~EOS Display Homebrew's Caskroom path. If is provided, display the location in the Caskroom where would be installed, without any sort of versioned directory as the last path. EOS named_args :cask end sig { override.void } def run if args.named.to_casks.blank? puts Cask::Caskroom.path else args.named.to_casks.each do |cask| puts "#{Cask::Caskroom.path}/#{cask.token}" end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--cellar.rb000066400000000000000000000015351517265720000225740ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" module Homebrew module Cmd class Cellar < AbstractCommand sig { override.returns(String) } def self.command_name = "--cellar" cmd_args do description <<~EOS Display Homebrew's Cellar path. *Default:* `$(brew --prefix)/Cellar`, or if that directory doesn't exist, `$(brew --repository)/Cellar`. If is provided, display the location in the Cellar where would be installed, without any sort of versioned directory as the last path. EOS named_args :formula end sig { override.void } def run if args.no_named? puts HOMEBREW_CELLAR else puts args.named.to_resolved_formulae.map(&:rack) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--env.rb000066400000000000000000000031451517265720000221210ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "extend/ENV" require "build_environment" require "utils/shell" module Homebrew module Cmd class Env < AbstractCommand sig { override.returns(String) } def self.command_name = "--env" cmd_args do description <<~EOS Summarise Homebrew's build environment as a plain list. If the command's output is sent through a pipe and no shell is specified, the list is formatted for export to `bash`(1) unless `--plain` is passed. EOS flag "--shell=", description: "Generate a list of environment variables for the specified shell, " \ "or `--shell=auto` to detect the current shell." switch "--plain", description: "Generate plain output even when piped." named_args :formula end sig { override.void } def run ENV.activate_extensions! ENV.deps = args.named.to_formulae if superenv?(nil) ENV.setup_build_environment shell = if args.plain? nil elsif args.shell.nil? :bash unless $stdout.tty? elsif args.shell == "auto" Utils::Shell.parent || Utils::Shell.preferred elsif args.shell Utils::Shell.from_path(T.must(args.shell)) end if shell.nil? BuildEnvironment.dump ENV.to_h else BuildEnvironment.keys(ENV.to_h).each do |key| puts Utils::Shell.export_value(key, ENV.fetch(key), shell) end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--prefix.rb000066400000000000000000000066551517265720000226370ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "fileutils" module Homebrew module Cmd class Prefix < AbstractCommand include FileUtils UNBREWED_EXCLUDE_FILES = %w[.DS_Store].freeze UNBREWED_EXCLUDE_PATHS = %w[ */.keepme .github/* bin/brew completions/zsh/_brew docs/* lib/gdk-pixbuf-2.0/* lib/gio/* lib/node_modules/* lib/python[23].[0-9]/* lib/python3.[0-9][0-9]/* lib/pypy/* lib/pypy3/* lib/ruby/gems/[12].* lib/ruby/site_ruby/[12].* lib/ruby/vendor_ruby/[12].* manpages/brew.1 share/pypy/* share/pypy3/* share/info/dir share/man/whatis share/mime/* texlive/* ].freeze sig { override.returns(String) } def self.command_name = "--prefix" cmd_args do description <<~EOS Display Homebrew's install path. *Default:* - macOS ARM: `#{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}` - macOS Intel: `#{HOMEBREW_DEFAULT_PREFIX}` - Linux: `#{HOMEBREW_LINUX_DEFAULT_PREFIX}` If is provided, display the location where is or would be installed. EOS switch "--unbrewed", description: "List files in Homebrew's prefix not installed by Homebrew." switch "--installed", description: "Outputs nothing and returns a failing status code if is not installed." conflicts "--unbrewed", "--installed" named_args :formula end sig { override.void } def run raise UsageError, "`--installed` requires a formula argument." if args.installed? && args.no_named? if args.unbrewed? raise UsageError, "`--unbrewed` does not take a formula argument." unless args.no_named? list_unbrewed elsif args.no_named? puts HOMEBREW_PREFIX else formulae = args.named.to_resolved_formulae prefixes = formulae.filter_map do |f| next nil if args.installed? && !f.opt_prefix.exist? # this case will be short-circuited by brew.sh logic for a single formula f.opt_prefix end puts prefixes if args.installed? missing_formulae = formulae.reject(&:optlinked?) .map(&:name) return if missing_formulae.blank? raise NotAKegError, <<~EOS The following formulae are not installed: #{missing_formulae.join(" ")} EOS end end end private sig { void } def list_unbrewed dirs = HOMEBREW_PREFIX.subdirs.map { |dir| dir.basename.to_s } dirs -= %w[Library Cellar Caskroom .git] # Exclude cache, logs and repository, if they are located under the prefix. [HOMEBREW_CACHE, HOMEBREW_LOGS, HOMEBREW_REPOSITORY].each do |dir| dirs.delete dir.relative_path_from(HOMEBREW_PREFIX).to_s end dirs.delete "etc" dirs.delete "var" arguments = dirs.sort + %w[-type f (] arguments.concat UNBREWED_EXCLUDE_FILES.flat_map { |f| %W[! -name #{f}] } arguments.concat UNBREWED_EXCLUDE_PATHS.flat_map { |d| %W[! -path #{d}] } arguments.push ")" cd(HOMEBREW_PREFIX) { safe_system("find", *arguments) } end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--repository.rb000066400000000000000000000010521517265720000235430ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class Repository < AbstractCommand include ShellCommand sig { override.returns(String) } def self.command_name = "--repository" cmd_args do description <<~EOS Display where Homebrew's Git repository is located. If `/` are provided, display where tap `/`'s directory is located. EOS named_args :tap end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--repository.sh000066400000000000000000000015541517265720000235610ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/--repository.rb # HOMEBREW_REPOSITORY, HOMEBREW_LIBRARY are set by brew.sh # shellcheck disable=SC2154 tap_path() { local tap="$1" local user local repo local part if [[ "${tap}" != *"/"* ]] then odie "Invalid tap name: ${tap}" fi user="$(echo "${tap%%/*}" | tr '[:upper:]' '[:lower:]')" repo="$(echo "${tap#*/}" | tr '[:upper:]' '[:lower:]')" for part in "${user}" "${repo}" do if [[ -z "${part}" || "${part}" == *"/"* ]] then odie "Invalid tap name: ${tap}" fi done repo="${repo#@(home|linux)brew-}" echo "${HOMEBREW_LIBRARY}/Taps/${user}/homebrew-${repo}" } homebrew---repository() { local tap if [[ "$#" -eq 0 ]] then echo "${HOMEBREW_REPOSITORY}" return fi ( shopt -s extglob for tap in "$@" do tap_path "${tap}" done ) } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--taps.rb000066400000000000000000000006341517265720000223000ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class Taps < AbstractCommand include ShellCommand sig { override.returns(String) } def self.command_name = "--taps" cmd_args do description <<~EOS Display the path to Homebrew’s Taps directory. EOS end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--taps.sh000066400000000000000000000002651517265720000223070ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/--taps.rb # HOMEBREW_LIBRARY is set by brew.sh # shellcheck disable=SC2154 homebrew---taps() { echo "${HOMEBREW_LIBRARY}/Taps" } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--version.rb000066400000000000000000000007641517265720000230220ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class Version < AbstractCommand include ShellCommand sig { override.returns(String) } def self.command_name = "--version" cmd_args do description <<~EOS Print the version numbers of Homebrew, Homebrew/homebrew-core and Homebrew/homebrew-cask (if tapped) to standard output. EOS end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/--version.sh000066400000000000000000000017311517265720000230240ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/--version.rb # HOMEBREW_CORE_REPOSITORY, HOMEBREW_CASK_REPOSITORY, HOMEBREW_VERSION are set by brew.sh # shellcheck disable=SC2154 version_string() { local repo="$1" if ! [[ -d "${repo}" ]] then echo "N/A" return fi local git_revision_and_date git_revision_and_date="$(git -C "${repo}" log -1 --format='%h %cd' --date=short HEAD 2>/dev/null)" if [[ -z "${git_revision_and_date}" ]] then echo "(no Git repository)" return fi echo "(git revision ${git_revision_and_date%% *}; last commit ${git_revision_and_date#* })" } homebrew-version() { echo "Homebrew ${HOMEBREW_VERSION}" if [[ -n "${HOMEBREW_NO_INSTALL_FROM_API}" || -d "${HOMEBREW_CORE_REPOSITORY}" ]] then echo "Homebrew/homebrew-core $(version_string "${HOMEBREW_CORE_REPOSITORY}")" fi if [[ -d "${HOMEBREW_CASK_REPOSITORY}" ]] then echo "Homebrew/homebrew-cask $(version_string "${HOMEBREW_CASK_REPOSITORY}")" fi } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/alias.rb000077500000000000000000000022651517265720000222750ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "aliases/aliases" module Homebrew module Cmd class Alias < AbstractCommand cmd_args do usage_banner "`alias` [`--edit`] [|=]" description <<~EOS Show an alias's command. If no alias is given, print the whole list. EOS switch "--edit", description: "Edit aliases in a text editor. Either one or all aliases may be opened at once. " \ "If the given alias doesn't exist it'll be pre-populated with a template." named_args max: 1 end sig { override.void } def run name = args.named.first name, command = name.split("=", 2) if name.present? Aliases.init if name.nil? if args.edit? Aliases.edit_all else Aliases.show end elsif command.nil? if args.edit? Aliases.edit name else Aliases.show name end else Aliases.add name, command Aliases.edit name if args.edit? end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/analytics.rb000066400000000000000000000025501517265720000231650ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" module Homebrew module Cmd class Analytics < AbstractCommand cmd_args do description <<~EOS Control Homebrew's anonymous aggregate user behaviour analytics. Read more at . `brew analytics` [`state`]: Display the current state of Homebrew's analytics. `brew analytics` (`on`|`off`): Turn Homebrew's analytics on or off respectively. EOS named_args %w[state on off regenerate-uuid], max: 1 end sig { override.void } def run case args.named.first when nil, "state" if Utils::Analytics.disabled? puts "InfluxDB analytics are disabled." else puts "InfluxDB analytics are enabled." end puts "Google Analytics were destroyed." when "on" Utils::Analytics.enable! when "off" Utils::Analytics.disable! when "regenerate-uuid" Utils::Analytics.delete_uuid! opoo "Homebrew no longer uses an analytics UUID so this has been deleted!" puts "brew analytics regenerate-uuid is no longer necessary." else raise UsageError, "unknown subcommand: #{args.named.first}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/autoremove.rb000066400000000000000000000011671517265720000233670ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "cleanup" module Homebrew module Cmd class Autoremove < AbstractCommand cmd_args do description <<~EOS Uninstall formulae that were only installed as a dependency of another formula and are now no longer needed. EOS switch "-n", "--dry-run", description: "List what would be uninstalled, but do not actually uninstall anything." named_args :none end sig { override.void } def run Cleanup.autoremove(dry_run: args.dry_run?) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/bundle.rb000077500000000000000000000407401517265720000224550ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "etc" require "bundle/dsl" require "bundle/extensions" module Homebrew module Cmd class Bundle < AbstractCommand sig { params(args: Args, extension: T.class_of(Homebrew::Bundle::Extension)).returns(T::Boolean) } def self.extension_selected?(args, extension) args.public_send(extension.predicate_method) end sig { params(args: Args, extension: T.class_of(Homebrew::Bundle::Extension)).returns(T::Boolean) } def self.extension_dump_disabled?(args, extension) args.public_send(extension.dump_disable_predicate_method) end BUNDLE_EXTENSIONS = T.let(Homebrew::Bundle.extensions.dup.freeze, T::Array[T.class_of(Homebrew::Bundle::Extension)]) BUNDLE_SOURCES_DESCRIPTION = T.let( [ "Homebrew", "Homebrew Cask", *BUNDLE_EXTENSIONS.map(&:banner_name), ].to_sentence.freeze, String, ) BUNDLE_ADD_FLAGS_DESCRIPTION = T.let( ["`--cask`", "`--tap`", *BUNDLE_EXTENSIONS.select(&:add_supported?).map do |extension| "`--#{extension.flag}`" end].to_sentence.freeze, String, ) BUNDLE_REMOVE_FLAGS_DESCRIPTION = T.let( ["`--formula`", "`--cask`", "`--tap`", *BUNDLE_EXTENSIONS.select(&:remove_supported?).map do |extension| "`--#{extension.flag}`" end].to_sentence.freeze, String, ) cmd_args do usage_banner <<~EOS `bundle` [] Bundler for non-Ruby dependencies from #{BUNDLE_SOURCES_DESCRIPTION}. Note: Flatpak support is only available on Linux. `brew bundle` [`install`]: Install and upgrade (by default) all dependencies from the `Brewfile`. You can specify the `Brewfile` location using `--file` or by setting the `$HOMEBREW_BUNDLE_FILE` environment variable. You can skip the installation of dependencies by adding space-separated values to one or more of the following environment variables: `$HOMEBREW_BUNDLE_BREW_SKIP`, `$HOMEBREW_BUNDLE_CASK_SKIP`, `$HOMEBREW_BUNDLE_MAS_SKIP`, `$HOMEBREW_BUNDLE_TAP_SKIP`. `brew bundle upgrade`: Shorthand for `brew bundle install --upgrade`. `brew bundle dump`: Write all installed casks/formulae/images/taps into a `Brewfile` in the current directory or to a custom file specified with the `--file` option. `brew bundle cleanup`: Uninstall all dependencies not present in the `Brewfile`. This workflow is useful for maintainers or testers who regularly install lots of formulae. Unless `--force` is passed, this returns a 1 exit code if anything would be removed. `brew bundle check`: Check if all dependencies present in the `Brewfile` are installed. This provides a successful exit code if everything is up-to-date, making it useful for scripting. `brew bundle list`: List all dependencies present in the `Brewfile`. By default, only Homebrew formula dependencies are listed. `brew bundle edit`: Edit the `Brewfile` in your editor. `brew bundle add` [...]: Add entries to your `Brewfile`. Adds formulae by default. Use #{BUNDLE_ADD_FLAGS_DESCRIPTION} to add the corresponding entry instead. `brew bundle remove` [...]: Remove entries that match `name` from your `Brewfile`. Use #{BUNDLE_REMOVE_FLAGS_DESCRIPTION} to remove only entries of the corresponding type. Passing `--formula` also removes matches against formula aliases and old formula names. `brew bundle exec` [`--check`] [`--no-secrets`] : Run an external command in an isolated build environment based on the `Brewfile` dependencies. This sanitized build environment ignores unrequested dependencies, which makes sure that things you didn't specify in your `Brewfile` won't get picked up by commands like `bundle install`, `npm install`, etc. It will also add compiler flags which will help with finding keg-only dependencies like `openssl`, `icu4c`, etc. `brew bundle sh` [`--check`] [`--no-secrets`]: Run your shell in a `brew bundle exec` environment. `brew bundle env` [`--check`] [`--no-secrets`]: Print the environment variables that would be set in a `brew bundle exec` environment. EOS flag "--file=", description: "Read from or write to the `Brewfile` from this location. " \ "Use `--file=-` to pipe to stdin/stdout." switch "-g", "--global", description: "Read from or write to the `Brewfile` from `$HOMEBREW_BUNDLE_FILE_GLOBAL` (if set), " \ "`${XDG_CONFIG_HOME}/homebrew/Brewfile` (if `$XDG_CONFIG_HOME` is set), " \ "`~/.homebrew/Brewfile` or `~/.Brewfile` otherwise." switch "-v", "--verbose", description: "`install` prints output from commands as they are run. " \ "`check` lists all missing dependencies." switch "--no-upgrade", description: "`install` does not run `brew upgrade` on outdated dependencies. " \ "`check` does not check for outdated dependencies. " \ "Note they may still be upgraded by `brew install` if needed.", env: :bundle_no_upgrade switch "--upgrade", description: "`install` runs `brew upgrade` on outdated dependencies, " \ "even if `$HOMEBREW_BUNDLE_NO_UPGRADE` is set." flag "--upgrade-formulae=", "--upgrade-formula=", description: "`install` runs `brew upgrade` on any of these comma-separated formulae, " \ "even if `$HOMEBREW_BUNDLE_NO_UPGRADE` is set." switch "--install", description: "Run `install` before continuing to other operations, e.g. `exec`." # odeprecated: change default for 5.2 and document HOMEBREW_BUNDLE_JOBS flag "--jobs=", description: "`install` runs up to this many formula installations in parallel. " \ "Defaults to 1 (sequential). Use `auto` for the number of CPU cores (max 4)." switch "--services", description: "Temporarily start services while running the `exec` or `sh` command.", env: :bundle_services switch "-f", "--force", description: "`install` runs with `--force`/`--overwrite`. " \ "`dump` overwrites an existing `Brewfile`. " \ "`cleanup` actually performs its cleanup operations." switch "--cleanup", description: "`install` performs cleanup operation, same as running `cleanup --force`.", env: [:bundle_install_cleanup, "--global"] switch "--all", description: "`list` all dependencies." switch "--formula", "--formulae", "--brews", description: "`list`, `dump` or `cleanup` Homebrew formula dependencies." switch "--cask", "--casks", description: "`list`, `dump` or `cleanup` Homebrew cask dependencies." switch "--tap", "--taps", description: "`list`, `dump` or `cleanup` Homebrew tap dependencies." BUNDLE_EXTENSIONS.each do |extension| switch "--#{extension.flag}", description: extension.switch_description end BUNDLE_EXTENSIONS.select(&:dump_disable_supported?).each do |extension| switch "--no-#{extension.flag}", description: extension.dump_disable_description, env: extension.dump_disable_env end switch "--describe", description: "`dump` and `add` add a description comment above each line, unless the " \ "dependency does not have a description.", env: :bundle_describe switch "--no-restart", description: "`dump` does not add `restart_service` to formula lines." switch "--zap", description: "`cleanup` casks using the `zap` command instead of `uninstall`." switch "--check", description: "Check that all dependencies in the Brewfile are installed before " \ "running `exec`, `sh`, or `env`.", env: :bundle_check switch "--no-secrets", description: "Attempt to remove secrets from the environment before `exec`, `sh`, or `env`.", env: :bundle_no_secrets BUNDLE_EXTENSIONS.select(&:dump_disable_supported?).each do |extension| conflicts "--all", "--no-#{extension.flag}" conflicts "--#{extension.flag}", "--no-#{extension.flag}" end conflicts "--install", "--upgrade" conflicts "--file", "--global" named_args %w[install dump cleanup check exec list sh env edit] end BUNDLE_EXEC_COMMANDS = %w[exec sh env].freeze sig { override.void } def run # Keep this inside `run` to keep --help fast. require "bundle" # Don't want to ask for input in Bundle ENV["HOMEBREW_ASK"] = nil subcommand = args.named.first.presence if %w[exec add remove].exclude?(subcommand) && args.named.size > 1 raise UsageError, "This command does not take more than 1 subcommand argument." end if args.check? && !ENV["HOMEBREW_BUNDLE_CHECK"] && BUNDLE_EXEC_COMMANDS.exclude?(subcommand) raise UsageError, "`--check` can be used only with #{BUNDLE_EXEC_COMMANDS.join(", ")}." end if args.no_secrets? && !ENV["HOMEBREW_BUNDLE_NO_SECRETS"] && BUNDLE_EXEC_COMMANDS.exclude?(subcommand) raise UsageError, "`--no-secrets` can be used only with #{BUNDLE_EXEC_COMMANDS.join(", ")}." end if !args.describe? && (dump_describe = ENV["HOMEBREW_BUNDLE_DUMP_DESCRIBE"].presence) opoo "`HOMEBREW_BUNDLE_DUMP_DESCRIBE` is deprecated. Use `HOMEBREW_BUNDLE_DESCRIBE` instead." # odeprecated "HOMEBREW_BUNDLE_DUMP_DESCRIBE", "HOMEBREW_BUNDLE_DESCRIBE" ENV["HOMEBREW_BUNDLE_DESCRIBE"] = dump_describe end global = args.global? file = args.file no_upgrade = if args.upgrade? || subcommand == "upgrade" false else args.no_upgrade?.present? end verbose = args.verbose? force = args.force? jobs_arg = args.jobs || ENV.fetch("HOMEBREW_BUNDLE_JOBS", nil) jobs = if jobs_arg == "auto" [Etc.nprocessors, 4].min else jobs_arg&.to_i || 1 end jobs = [jobs, 1].max zap = args.zap? Homebrew::Bundle.upgrade_formulae = args.upgrade_formulae no_type_args = ([args.formulae?, args.casks?, args.taps?] + BUNDLE_EXTENSIONS.map { |extension| self.class.extension_selected?(args, extension) }).none? if args.install? if [nil, "install", "upgrade"].include?(subcommand) raise UsageError, "`--install` cannot be used with `install`, `upgrade` or no subcommand." end require "bundle/commands/install" redirect_stdout($stderr) do Homebrew::Bundle::Commands::Install.run(global:, file:, no_upgrade:, verbose:, force:, jobs:, quiet: true) end end case subcommand when nil, "install", "upgrade" require "bundle/commands/install" Homebrew::Bundle::Commands::Install.run(global:, file:, no_upgrade:, verbose:, force:, jobs:, quiet: args.quiet?) cleanup = if ENV.fetch("HOMEBREW_BUNDLE_INSTALL_CLEANUP", nil) args.global? else args.cleanup? end if cleanup require "bundle/commands/cleanup" # Don't need to reset cleanup specifically but this resets all the dumper modules. Homebrew::Bundle::Commands::Cleanup.reset! Homebrew::Bundle::Commands::Cleanup.run( global:, file:, zap:, force: true, dsl: Homebrew::Bundle::Commands::Install.dsl ) end when "dump" require "bundle/commands/dump" Homebrew::Bundle::Commands::Dump.run( global:, file:, force:, describe: args.describe?, no_restart: args.no_restart?, taps: args.taps? || no_type_args, formulae: args.formulae? || no_type_args, casks: args.casks? || no_type_args, extension_types: BUNDLE_EXTENSIONS.select(&:dump_supported?).to_h do |extension| disabled = extension.dump_disable_supported? && self.class.extension_dump_disabled?(args, extension) enabled = !disabled && (self.class.extension_selected?(args, extension) || no_type_args) [extension.type, enabled] end ) when "edit" require "bundle/brewfile" exec_editor(Homebrew::Bundle::Brewfile.path(global:, file:)) when "cleanup" require "bundle/commands/cleanup" Homebrew::Bundle::Commands::Cleanup.run( global:, file:, force:, zap:, formulae: args.formulae? || no_type_args, casks: args.casks? || no_type_args, taps: args.taps? || no_type_args, extension_types: BUNDLE_EXTENSIONS.select(&:cleanup_supported?).to_h do |extension| [extension.type, self.class.extension_selected?(args, extension) || no_type_args] end ) when "check" require "bundle/commands/check" Homebrew::Bundle::Commands::Check.run(global:, file:, no_upgrade:, verbose:) when "list" extension_list_options = BUNDLE_EXTENSIONS.to_h do |extension| [extension.type, self.class.extension_selected?(args, extension) || args.all?] end require "bundle/commands/list" Homebrew::Bundle::Commands::List.run( global:, file:, formulae: args.formulae? || args.all? || no_type_args, casks: args.casks? || args.all?, taps: args.taps? || args.all?, extension_types: extension_list_options, ) when "add", "remove" # We intentionally omit the s from `brews`, `casks`, and `taps` for ease of handling later. type_hash = { brew: args.formulae?, cask: args.casks?, tap: args.taps?, } BUNDLE_EXTENSIONS.each do |extension| type_hash[extension.type] = self.class.extension_selected?(args, extension) end type_hash[:none] = no_type_args selected_types = type_hash.select { |_, v| v }.keys raise UsageError, "`#{subcommand}` supports only one type of entry at a time." if selected_types.count != 1 _, *named_args = args.named if subcommand == "add" type = case (t = selected_types.first) when :none then :brew when :mas then raise UsageError, "`add` does not support `--mas`." else t end extension = Homebrew::Bundle.extension(type) if extension && !extension.add_supported? raise UsageError, "`add` does not support `--#{extension.flag}`." end require "bundle/commands/add" Homebrew::Bundle::Commands::Add.run(*named_args, type:, global:, file:, describe: args.describe?) else require "bundle/commands/remove" Homebrew::Bundle::Commands::Remove.run(*named_args, type: selected_types.first, global:, file:) end when *BUNDLE_EXEC_COMMANDS named_args = case subcommand when "exec" _subcommand, *named_args = args.named named_args when "sh" ["sh"] when "env" ["env"] end require "bundle/commands/exec" Homebrew::Bundle::Commands::Exec.run( *named_args, global:, file:, subcommand:, services: args.services?, no_secrets: args.no_secrets?, ) else raise UsageError, "unknown subcommand: #{subcommand}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/casks.rb000066400000000000000000000006551517265720000223060ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" # This Ruby command exists to allow generation of completions for the Bash # version. It is not meant to be run. module Homebrew module Cmd class Casks < AbstractCommand include ShellCommand cmd_args do description "List all locally installable casks including short names." end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/casks.sh000066400000000000000000000014131517265720000223060ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/casks.rb # HOMEBREW_LIBRARY is set in bin/brew # shellcheck disable=SC2154 source "${HOMEBREW_LIBRARY}/Homebrew/items.sh" homebrew-casks() { local find_include_filter='*/Casks/*\.rb' local sed_filter='s|/Casks/(.+/)?|/|' local grep_filter='^homebrew/cask' # HOMEBREW_CACHE is set by brew.sh # shellcheck disable=SC2154 if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" && -f "${HOMEBREW_CACHE}/api/cask_names.txt" ]] then { cat "${HOMEBREW_CACHE}/api/cask_names.txt" echo homebrew-items "${find_include_filter}" '.*/homebrew/homebrew-cask/.*' "${sed_filter}" "${grep_filter}" } | sort -uf else homebrew-items "${find_include_filter}" '^\b$' "${sed_filter}" "${grep_filter}" fi } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/cleanup.rb000066400000000000000000000052001517265720000226200ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "cleanup" module Homebrew module Cmd class CleanupCmd < AbstractCommand cmd_args do days = Homebrew::EnvConfig::ENVS[:HOMEBREW_CLEANUP_MAX_AGE_DAYS]&.dig(:default) description <<~EOS Remove stale lock files and outdated downloads for all formulae and casks, and remove old versions of installed formulae. If arguments are specified, only do this for the given formulae and casks. Removes all downloads more than #{days} days old. This can be adjusted with `$HOMEBREW_CLEANUP_MAX_AGE_DAYS`. EOS flag "--prune=", description: "Remove all cache files older than specified . " \ "If you want to remove everything, use `--prune=all`." switch "-n", "--dry-run", description: "Show what would be removed, but do not actually remove anything." switch "-s", "--scrub", description: "Scrub the cache, including downloads for even the latest versions. " \ "Note that downloads for any installed formulae or casks will still not be deleted. " \ "If you want to delete those too: `rm -rf \"$(brew --cache)\"`" switch "--prune-prefix", description: "Only prune the symlinks and directories from the prefix and remove no other files." named_args [:formula, :cask] end sig { override.void } def run days = args.prune.presence&.then do |prune| case prune when /\A\d+\Z/ prune.to_i when "all" 0 else raise UsageError, "`--prune` expects an integer or `all`." end end cleanup = Cleanup.new(*args.named, dry_run: args.dry_run?, scrub: args.s?, days:) if args.prune_prefix? cleanup.prune_prefix_symlinks_and_directories return end cleanup.clean!(quiet: args.quiet?, periodic: false) unless cleanup.disk_cleanup_size.zero? disk_space = Formatter.disk_usage_readable(cleanup.disk_cleanup_size) if args.dry_run? ohai "This operation would free approximately #{disk_space} of disk space." else ohai "This operation has freed approximately #{disk_space} of disk space." end end return if cleanup.unremovable_kegs.empty? ofail <<~EOS Could not cleanup old kegs! Fix your permissions on: #{cleanup.unremovable_kegs.join "\n "} EOS end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/command-not-found-init.rb000077500000000000000000000043321517265720000254670ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # License: MIT # The license text can be found in Library/Homebrew/command-not-found/LICENSE require "abstract_command" require "utils/shell" module Homebrew module Cmd class CommandNotFoundInit < AbstractCommand cmd_args do description <<~EOS Print instructions for setting up the command-not-found hook for your shell. If the output is not to a tty, print the appropriate handler script for your shell. For more information, see: https://docs.brew.sh/Command-Not-Found EOS named_args :none end sig { override.void } def run if $stdout.tty? help else init end end sig { returns(T.nilable(Symbol)) } def shell Utils::Shell.parent || Utils::Shell.preferred end sig { void } def init case shell when :bash, :zsh puts File.read(File.expand_path("#{File.dirname(__FILE__)}/../command-not-found/handler.sh")) when :fish puts File.read(File.expand_path("#{File.dirname(__FILE__)}/../command-not-found/handler.fish")) else raise "Unsupported shell type #{shell}" end end sig { void } def help case shell when :bash, :zsh puts <<~EOS # To enable command-not-found # Add the following lines to ~/.#{shell}rc HOMEBREW_COMMAND_NOT_FOUND_HANDLER="$(brew --repository)/Library/Homebrew/command-not-found/handler.sh" if [ -f "$HOMEBREW_COMMAND_NOT_FOUND_HANDLER" ]; then source "$HOMEBREW_COMMAND_NOT_FOUND_HANDLER"; fi EOS when :fish puts <<~EOS # To enable command-not-found # Add the following line to ~/.config/fish/config.fish set HOMEBREW_COMMAND_NOT_FOUND_HANDLER (brew --repository)/Library/Homebrew/command-not-found/handler.fish if test -f $HOMEBREW_COMMAND_NOT_FOUND_HANDLER source $HOMEBREW_COMMAND_NOT_FOUND_HANDLER end EOS else raise "Unsupported shell type #{shell}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/command.rb000066400000000000000000000010731517265720000226130ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "commands" module Homebrew module Cmd class Command < AbstractCommand cmd_args do description <<~EOS Display the path to the file being used when invoking `brew` . EOS named_args :command, min: 1 end sig { override.void } def run args.named.each do |cmd| path = Commands.path(cmd) odie "Unknown command: brew #{cmd}" unless path puts path end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/commands.rb000066400000000000000000000023521517265720000227770ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" module Homebrew module Cmd class CommandsCmd < AbstractCommand cmd_args do description <<~EOS Show lists of built-in and external commands. EOS switch "-q", "--quiet", description: "List only the names of commands without category headers." switch "--include-aliases", depends_on: "--quiet", description: "Include aliases of internal commands." named_args :none end sig { override.void } def run if args.quiet? puts Formatter.columns(Commands.commands(aliases: args.include_aliases?)) return end prepend_separator = T.let(false, T::Boolean) { "Built-in commands" => Commands.internal_commands, "Built-in developer commands" => Commands.internal_developer_commands, "External commands" => Commands.external_commands, }.each do |title, commands| next if commands.blank? puts if prepend_separator ohai title, Formatter.columns(commands) prepend_separator ||= true end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/completions.rb000066400000000000000000000023101517265720000235240ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "completions" module Homebrew module Cmd class CompletionsCmd < AbstractCommand cmd_args do description <<~EOS Control whether Homebrew automatically links external tap shell completion files. Read more at . `brew completions` [`state`]: Display the current state of Homebrew's completions. `brew completions` (`link`|`unlink`): Link or unlink Homebrew's completions. EOS named_args %w[state link unlink], max: 1 end sig { override.void } def run case args.named.first when nil, "state" if Completions.link_completions? puts "Completions are linked." else puts "Completions are not linked." end when "link" Completions.link! puts "Completions are now linked." when "unlink" Completions.unlink! puts "Completions are no longer linked." else raise UsageError, "unknown subcommand: #{args.named.first}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/config.rb000066400000000000000000000010221517265720000224340ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "system_config" module Homebrew module Cmd class Config < AbstractCommand cmd_args do description <<~EOS Show Homebrew and system configuration info useful for debugging. If you file a bug report, you will be required to provide this information. EOS named_args :none end sig { override.void } def run SystemConfig.dump_verbose_config end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/deps.rb000066400000000000000000000407551517265720000221420ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "cask/caskroom" require "dependencies_helpers" module Homebrew module Cmd class Deps < AbstractCommand include DependenciesHelpers class DepsCombineMode < T::Enum enums do # enum values are not mutable, and calling .freeze on them breaks Sorbet # rubocop:disable Style/MutableConstant Intersection = new Union = new # rubocop:enable Style/MutableConstant end end cmd_args do description <<~EOS Show dependencies for . When given multiple formula arguments, show the intersection of dependencies for each formula. By default, `deps` shows all required and recommended dependencies. If any version of each formula argument is installed and no other options are passed, this command displays their actual runtime dependencies (similar to `brew linkage`), which may differ from a formula's declared dependencies. *Note:* `--missing` and `--skip-recommended` have precedence over `--include-*`. EOS switch "-n", "--topological", description: "Sort dependencies in topological order." switch "-1", "--direct", "--declared", "--1", description: "Show only the direct dependencies declared in the formula." switch "--union", description: "Show the union of dependencies for multiple , instead of the intersection." switch "--full-name", description: "List dependencies by their full name." switch "--include-implicit", description: "Include implicit dependencies used to download and unpack source files." switch "--include-build", description: "Include `:build` dependencies for ." switch "--include-optional", description: "Include `:optional` dependencies for ." switch "--include-test", description: "Include `:test` dependencies for (non-recursive unless `--graph` or `--tree`)." switch "--skip-recommended", description: "Skip `:recommended` dependencies for ." switch "--include-requirements", description: "Include requirements in addition to dependencies for ." switch "--tree", description: "Show dependencies as a tree. When given multiple formula arguments, " \ "show individual trees for each formula." switch "--prune", depends_on: "--tree", description: "Prune parts of tree already seen." switch "--graph", description: "Show dependencies as a directed graph." switch "--dot", depends_on: "--graph", description: "Show text-based graph description in DOT format." switch "--annotate", description: "Mark any build, test, implicit, optional, or recommended dependencies as " \ "such in the output." switch "--installed", description: "List dependencies for formulae that are currently installed. If is " \ "specified, list only its dependencies that are currently installed." switch "--missing", description: "Show only missing dependencies." switch "--eval-all", description: "Evaluate all available formulae and casks, whether installed or not, to list " \ "their dependencies." switch "--for-each", description: "Switch into the mode used by the `--eval-all` option, but only list dependencies " \ "for each provided , one formula per line. This is used for " \ "debugging the `--installed`/`--eval-all` display mode." switch "--HEAD", description: "Show dependencies for HEAD version instead of stable version." flag "--os=", description: "Show dependencies for the given operating system." flag "--arch=", description: "Show dependencies for the given CPU architecture." switch "--formula", "--formulae", description: "Treat all named arguments as formulae." switch "--cask", "--casks", description: "Treat all named arguments as casks." conflicts "--tree", "--graph" conflicts "--installed", "--missing" conflicts "--installed", "--eval-all" conflicts "--formula", "--cask" formula_options named_args [:formula, :cask] end sig { override.params(argv: T::Array[String]).void } def initialize(argv = ARGV.freeze) super @use_runtime_dependencies = T.let(true, T::Boolean) end sig { override.void } def run raise UsageError, "`brew deps --os=all` is not supported." if args.os == "all" raise UsageError, "`brew deps --arch=all` is not supported." if args.arch == "all" os, arch = args.os_arch_combinations.fetch(0) eval_all = args.eval_all? Formulary.enable_factory_cache! SimulateSystem.with(os:, arch:) do installed = args.installed? || dependents(args.named.to_formulae_and_casks).all?(&:any_version_installed?) unless installed not_using_runtime_dependencies_reason = if args.installed? "not all the named formulae were installed" else "`--installed` was not passed" end @use_runtime_dependencies = false end %w[direct tree graph HEAD skip_recommended missing include_implicit include_build include_test include_optional].each do |arg| next unless args.public_send("#{arg}?") not_using_runtime_dependencies_reason = "--#{arg.tr("_", "-")} was passed" @use_runtime_dependencies = false end %w[os arch].each do |arg| next if args.public_send(arg).nil? not_using_runtime_dependencies_reason = "--#{arg.tr("_", "-")} was passed" @use_runtime_dependencies = false end if !@use_runtime_dependencies && !Homebrew::EnvConfig.no_env_hints? opoo <<~EOS `brew deps` is not the actual runtime dependencies because #{not_using_runtime_dependencies_reason}! This means dependencies may differ from a formula's declared dependencies. Hide these hints with `HOMEBREW_NO_ENV_HINTS=1` (see `man brew`). EOS end recursive = !args.direct? if args.tree? || args.graph? dependents = if args.named.present? sorted_dependents(args.named.to_formulae_and_casks) elsif args.installed? case args.only_formula_or_cask when :formula sorted_dependents(Formula.installed) when :cask sorted_dependents(Cask::Caskroom.casks) else sorted_dependents(Formula.installed + Cask::Caskroom.casks) end else raise FormulaUnspecifiedError end if args.graph? dot_code = dot_code(dependents, recursive:) if args.dot? puts dot_code else exec_browser "https://dreampuf.github.io/GraphvizOnline/##{ERB::Util.url_encode(dot_code)}" end return end puts_deps_tree(dependents, recursive:) return elsif eval_all puts_deps(sorted_dependents( Formula.all(eval_all:) + Cask::Cask.all(eval_all:), ), recursive:) return elsif !args.no_named? && args.for_each? puts_deps(sorted_dependents(args.named.to_formulae_and_casks), recursive:) return end if args.no_named? raise FormulaUnspecifiedError unless args.installed? sorted_dependents_formulae_and_casks = case args.only_formula_or_cask when :formula sorted_dependents(Formula.installed) when :cask sorted_dependents(Cask::Caskroom.casks) else sorted_dependents(Formula.installed + Cask::Caskroom.casks) end puts_deps(sorted_dependents_formulae_and_casks, recursive:) return end dependents = dependents(args.named.to_formulae_and_casks) check_head_spec(dependents) if args.HEAD? deps_combine_mode = args.union? ? DepsCombineMode::Union : DepsCombineMode::Intersection all_deps = deps_for_dependents(dependents, deps_combine_mode:, recursive:) condense_requirements(all_deps) all_deps.map! { dep_display_name(it) } all_deps.uniq! all_deps.sort! unless args.topological? puts all_deps end end private sig { params(formulae_or_casks: T::Array[T.any(Formula, Keg, Cask::Cask)]) .returns(T::Array[T.any(Formula, CaskDependent)]) } def sorted_dependents(formulae_or_casks) dependents(formulae_or_casks).sort_by(&:name) end sig { params(deps: T::Array[T.any(Dependency, Requirement)]).void } def condense_requirements(deps) deps.select! { |dep| dep.is_a?(Dependency) } unless args.include_requirements? deps.select! { |dep| dep.is_a?(Requirement) || dep.installed? } if args.installed? end sig { params(dep: T.any(Requirement, Dependency)).returns(String) } def dep_display_name(dep) str = if dep.is_a? Requirement if args.include_requirements? ":#{dep.display_s}" else # This shouldn't happen, but we'll put something here to help debugging "::#{dep.name}" end elsif args.full_name? dep.to_formula.full_name else dep.name end if args.annotate? str = "#{str} " if args.tree? str = "#{str} [build]" if dep.build? str = "#{str} [test]" if dep.test? str = "#{str} [optional]" if dep.optional? str = "#{str} [recommended]" if dep.recommended? str = "#{str} [implicit]" if dep.implicit? end str end sig { params(dependency: T.any(Formula, CaskDependent), recursive: T::Boolean) .returns(T::Array[T.any(Dependency, Requirement)]) } def deps_for_dependent(dependency, recursive: false) includes, ignores = args_includes_ignores(args) deps = dependency.runtime_dependencies if @use_runtime_dependencies if recursive deps ||= recursive_dep_includes(dependency, includes, ignores) reqs = args.include_requirements? ? recursive_req_includes(dependency, includes, ignores) : Requirements.new else deps ||= select_includes(dependency.deps, ignores, includes) reqs = select_includes(dependency.requirements, ignores, includes) end deps + reqs.to_a end sig { params( dependents: T::Array[T.any(Formula, CaskDependent)], deps_combine_mode: DepsCombineMode, recursive: T::Boolean, ).returns(T::Array[T.any(Dependency, Requirement)]) } def deps_for_dependents(dependents, deps_combine_mode:, recursive:) symbol = (deps_combine_mode == DepsCombineMode::Intersection) ? :& : :| dependents.map { deps_for_dependent(it, recursive:) }.reduce(symbol) end sig { params(dependents: T::Array[T.any(Formula, CaskDependent)]).void } def check_head_spec(dependents) headless = dependents.select { it.is_a?(Formula) && it.active_spec_sym != :head } .to_sentence two_words_connector: " or ", last_word_connector: " or " opoo "No head spec for #{headless}, using stable spec instead" unless headless.empty? end sig { params(dependents: T::Array[T.any(Formula, CaskDependent)], recursive: T::Boolean).void } def puts_deps(dependents, recursive: false) check_head_spec(dependents) if args.HEAD? dependents.each do |dependent| deps = deps_for_dependent(dependent, recursive:) condense_requirements(deps) deps.sort_by!(&:name) deps.map! { dep_display_name(it) } puts "#{dependent.full_name}: #{deps.join(" ")}" end end sig { params(dependents: T::Array[T.any(Formula, CaskDependent)], recursive: T::Boolean).returns(String) } def dot_code(dependents, recursive:) dep_graph = {} dependents.each { graph_deps(it, dep_graph:, recursive:) } dot_code = dep_graph.map do |d, deps| deps.map do |dep| attributes = [] attributes << "style = dotted" if dep.build? attributes << "arrowhead = empty" if dep.test? if dep.optional? attributes << "color = red" elsif dep.recommended? attributes << "color = green" end comment = " # #{dep.tags.map(&:inspect).join(", ")}" if dep.tags.any? " \"#{d.name}\" -> \"#{dep}\"#{" [#{attributes.join(", ")}]" if attributes.any?}#{comment}" end end.flatten.join("\n") "digraph {\n#{dot_code}\n}" end sig { params( formula: T.any(Formula, CaskDependent), dep_graph: T::Hash[T.any(Formula, CaskDependent), T::Array[T.any(Dependency, Requirement)]], recursive: T::Boolean, ).void } def graph_deps(formula, dep_graph:, recursive:) return if dep_graph.key?(formula) dependables = dependables(formula) dep_graph[formula] = dependables return unless recursive dependables.each do |dep| next unless dep.is_a? Dependency graph_deps(Formulary.factory(dep.name), dep_graph:, recursive: true) end end sig { params(dependents: T::Array[T.any(Formula, CaskDependent)], recursive: T::Boolean).void } def puts_deps_tree(dependents, recursive: false) check_head_spec(dependents) if args.HEAD? dependents.each do |d| puts d.full_name recursive_deps_tree(d, deps_seen: {}, prefix: "", recursive:) puts end end sig { params(formula: T.any(Formula, CaskDependent)).returns(T::Array[T.any(Dependency, Requirement)]) } def dependables(formula) includes, ignores = args_includes_ignores(args) deps = @use_runtime_dependencies ? formula.runtime_dependencies : formula.deps deps = select_includes(deps, ignores, includes) reqs = select_includes(formula.requirements, ignores, includes) if args.include_requirements? reqs ||= [] reqs + deps end sig { params( formula: T.any(Formula, CaskDependent), deps_seen: T::Hash[String, T::Boolean], prefix: String, recursive: T::Boolean ).void } def recursive_deps_tree(formula, deps_seen:, prefix:, recursive:) dependables = dependables(formula) max = dependables.length - 1 deps_seen[formula.name] = true dependables.each_with_index do |dep, i| tree_lines = if i == max "└──" else "├──" end display_s = "#{tree_lines} #{dep_display_name(dep)}" # Detect circular dependencies and consider them a failure if present. is_circular = deps_seen.fetch(dep.name, false) pruned = args.prune? && deps_seen.include?(dep.name) if is_circular display_s = "#{display_s} (CIRCULAR DEPENDENCY)" Homebrew.failed = true elsif pruned display_s = "#{display_s} (PRUNED)" end puts "#{prefix}#{display_s}" next if !recursive || is_circular || pruned prefix_addition = if i == max " " else "│ " end next unless dep.is_a? Dependency recursive_deps_tree(Formulary.factory(dep.name), deps_seen:, prefix: prefix + prefix_addition, recursive: true) end deps_seen[formula.name] = false end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/desc.rb000066400000000000000000000056111517265720000221150ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "descriptions" require "search" require "description_cache_store" module Homebrew module Cmd class Desc < AbstractCommand cmd_args do description <<~EOS Display 's name and one-line description. The cache is created on the first search, making that search slower than subsequent ones. EOS switch "-s", "--search", description: "Search both names and descriptions for . If is flanked by " \ "slashes, it is interpreted as a regular expression." switch "-n", "--name", description: "Search just names for . If is flanked by slashes, it is " \ "interpreted as a regular expression." switch "-d", "--description", description: "Search just descriptions for . If is flanked by slashes, " \ "it is interpreted as a regular expression." switch "--eval-all", description: "Evaluate all available formulae and casks, whether installed or not, to search their " \ "descriptions.", env: :eval_all switch "--formula", "--formulae", description: "Treat all named arguments as formulae." switch "--cask", "--casks", description: "Treat all named arguments as casks." conflicts "--search", "--name", "--description" named_args [:formula, :cask, :text_or_regex], min: 1 end sig { override.void } def run search_type = if args.search? Descriptions::SearchField::Either elsif args.name? Descriptions::SearchField::Name elsif args.description? Descriptions::SearchField::Description end if search_type if !args.eval_all? && Homebrew::EnvConfig.no_install_from_api? raise UsageError, "`brew desc --search` needs `--eval-all` passed or `HOMEBREW_EVAL_ALL=1` set!" end query = args.named.join(" ") string_or_regex = Search.query_regexp(query) return Search.search_descriptions(string_or_regex, args, search_type:) end desc = {} args.named.to_formulae_and_casks.each do |formula_or_cask| case formula_or_cask when Formula desc[formula_or_cask.full_name] = formula_or_cask.desc when Cask::Cask description = formula_or_cask.desc.presence || Formatter.warning("[no description]") desc[formula_or_cask.full_name] = "(#{formula_or_cask.name.join(", ")}) #{description}" else raise TypeError, "Unsupported formula_or_cask type: #{formula_or_cask.class}" end end Descriptions.new(desc).print end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/developer.rb000066400000000000000000000044121517265720000231620ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" module Homebrew module Cmd class Developer < AbstractCommand cmd_args do description <<~EOS Control Homebrew's developer mode. When developer mode is enabled, `brew update` will update Homebrew to the latest commit on the `main` branch instead of the latest stable version along with some other behaviour changes. `brew developer` [`state`]: Display the current state of Homebrew's developer mode. `brew developer` (`on`|`off`): Turn Homebrew's developer mode on or off respectively. EOS named_args %w[state on off], max: 1 end sig { override.void } def run case args.named.first when nil, "state" if Homebrew::EnvConfig.developer? puts "Developer mode is enabled because #{Tty.bold}HOMEBREW_DEVELOPER#{Tty.reset} is set." elsif Homebrew::EnvConfig.devcmdrun? puts "Developer mode is enabled because a developer command or `brew developer on` was run." else puts "Developer mode is disabled." end if Homebrew::EnvConfig.developer? || Homebrew::EnvConfig.devcmdrun? if Homebrew::EnvConfig.update_to_tag? puts "However, `brew update` will update to the latest stable tag because " \ "#{Tty.bold}HOMEBREW_UPDATE_TO_TAG#{Tty.reset} is set." else puts "`brew update` will update to the latest commit on the `main` branch." end else puts "`brew update` will update to the latest stable tag." end when "on" Homebrew::Settings.write "devcmdrun", true if Homebrew::EnvConfig.update_to_tag? puts "To fully enable developer mode, you must unset #{Tty.bold}HOMEBREW_UPDATE_TO_TAG#{Tty.reset}." end when "off" Homebrew::Settings.delete "devcmdrun" if Homebrew::EnvConfig.developer? puts "To fully disable developer mode, you must unset #{Tty.bold}HOMEBREW_DEVELOPER#{Tty.reset}." end else raise UsageError, "unknown subcommand: #{args.named.first}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/docs.rb000066400000000000000000000006211517265720000221230ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" module Homebrew module Cmd class Docs < AbstractCommand cmd_args do description <<~EOS Open Homebrew's online documentation at <#{HOMEBREW_DOCS_WWW}> in a browser. EOS end sig { override.void } def run exec_browser HOMEBREW_DOCS_WWW end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/doctor.rb000066400000000000000000000050471517265720000224740ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "diagnostic" require "cask/caskroom" module Homebrew module Cmd class Doctor < AbstractCommand cmd_args do description <<~EOS Check your system for potential problems. Will exit with a non-zero status if any potential problems are found. Please note that these warnings are just used to help the Homebrew maintainers with debugging if you file an issue. If everything you use Homebrew for is working fine: please don't worry or file an issue; just ignore this. EOS switch "--list-checks", description: "List all audit methods, which can be run individually " \ "if provided as arguments." switch "-D", "--audit-debug", description: "Enable debugging and profiling of audit methods." named_args :diagnostic_check end sig { override.void } def run Homebrew.inject_dump_stats!(Diagnostic::Checks, /^check_*/) if args.audit_debug? checks = Diagnostic::Checks.new(verbose: args.verbose?) if args.list_checks? puts checks.all return end if args.no_named? slow_checks = %w[ check_for_broken_symlinks check_missing_deps ] methods = (checks.all - slow_checks) + slow_checks methods -= checks.cask_checks unless Cask::Caskroom.any_casks_installed? else methods = args.named end first_warning = T.let(true, T::Boolean) methods.each do |method| $stderr.puts Formatter.headline("Checking #{method}", color: :magenta) if args.debug? unless checks.respond_to?(method) ofail "No check available by the name: #{method}" next end out = checks.send(method) next if out.blank? if first_warning && !args.quiet? $stderr.puts <<~EOS #{Tty.bold}Please note that these warnings are just used to help the Homebrew maintainers with debugging if you file an issue. If everything you use Homebrew for is working fine: please don't worry or file an issue; just ignore this. Thanks!#{Tty.reset} EOS end $stderr.puts opoo out Homebrew.failed = true first_warning = false end puts "Your system is ready to brew." if !Homebrew.failed? && !args.quiet? end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/fetch.rb000066400000000000000000000166741517265720000223030ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "fetch" require "cask/download" require "download_queue" module Homebrew module Cmd class FetchCmd < AbstractCommand include Fetch FETCH_MAX_TRIES = 5 cmd_args do description <<~EOS Download a bottle (if available) or source packages for e and binaries for s. For files, also print SHA-256 checksums. EOS flag "--os=", description: "Download for the given operating system. " \ "(Pass `all` to download for all operating systems.)" flag "--arch=", description: "Download for the given CPU architecture. " \ "(Pass `all` to download for all architectures.)" flag "--bottle-tag=", description: "Download a bottle for given tag." switch "--HEAD", description: "Fetch HEAD version instead of stable version." switch "-f", "--force", description: "Remove a previously cached version and re-fetch." switch "-v", "--verbose", description: "Do a verbose VCS checkout, if the URL represents a VCS. This is useful for " \ "seeing if an existing VCS cache has been updated." switch "--retry", description: "Retry if downloading fails or re-download if the checksum of a previously cached " \ "version no longer matches. Tries at most #{FETCH_MAX_TRIES} times with " \ "exponential backoff." switch "--deps", description: "Also download dependencies for any listed ." switch "-s", "--build-from-source", description: "Download source packages rather than a bottle." switch "--build-bottle", description: "Download source packages (for eventual bottling) rather than a bottle." switch "--force-bottle", description: "Download a bottle if it exists for the current or newest version of macOS, " \ "even if it would not be used during installation." switch "--[no-]quarantine", env: :cask_opts_quarantine, odisabled: true switch "--formula", "--formulae", description: "Treat all named arguments as formulae." switch "--cask", "--casks", description: "Treat all named arguments as casks." conflicts "--build-from-source", "--build-bottle", "--force-bottle", "--bottle-tag" conflicts "--cask", "--HEAD" conflicts "--cask", "--deps" conflicts "--cask", "-s" conflicts "--cask", "--build-bottle" conflicts "--cask", "--force-bottle" conflicts "--cask", "--bottle-tag" conflicts "--formula", "--cask" conflicts "--os", "--bottle-tag" conflicts "--arch", "--bottle-tag" named_args [:formula, :cask], min: 1 end sig { override.void } def run Formulary.enable_factory_cache! bucket = if args.deps? args.named.to_formulae_and_casks.flat_map do |formula_or_cask| case formula_or_cask when Formula formula = formula_or_cask [formula, *formula.recursive_dependencies.map(&:to_formula)] else formula_or_cask end end else args.named.to_formulae_and_casks end.uniq os_arch_combinations = args.os_arch_combinations puts "Fetching: #{bucket * ", "}" if bucket.size > 1 bucket.each do |formula_or_cask| case formula_or_cask when Formula formula = formula_or_cask ref = formula.loaded_from_api? ? formula.full_name : formula.path os_arch_combinations.each do |os, arch| SimulateSystem.with(os:, arch:) do formula = Formulary.factory(ref, args.HEAD? ? :head : :stable) formula.print_tap_action verb: "Fetching" fetched_bottle = false if fetch_bottle?( formula, force_bottle: args.force_bottle?, bottle_tag: args.bottle_tag&.to_sym, build_from_source_formulae: args.build_from_source_formulae, os: args.os&.to_sym, arch: args.arch&.to_sym, ) begin formula.clear_cache if args.force? bottle_tag = if (bottle_tag = args.bottle_tag&.to_sym) Utils::Bottles::Tag.from_symbol(bottle_tag) else Utils::Bottles::Tag.new(system: os, arch:) end bottle = formula.bottle_for_tag(bottle_tag) if bottle.nil? opoo "Bottle for tag #{bottle_tag.to_sym.inspect} is unavailable." next end if (manifest_resource = bottle.github_packages_manifest_resource) download_queue.enqueue(manifest_resource) end download_queue.enqueue(bottle) rescue Interrupt raise rescue => e raise if Homebrew::EnvConfig.developer? fetched_bottle = false onoe e.message opoo "Bottle fetch failed, fetching the source instead." else fetched_bottle = true end end next if fetched_bottle if (resource = formula.resource) download_queue.enqueue(resource) end formula.enqueue_resources_and_patches(download_queue:) end end when Cask::Cask cask = formula_or_cask ref = cask.loaded_from_api? ? cask.full_name : cask.sourcefile_path odie "unexpected nil cask sourcefile_path" unless ref os_arch_combinations.each do |os, arch| SimulateSystem.with(os:, arch:) do cask = Cask::CaskLoader.load(ref) if cask.url.nil? || cask.sha256.nil? opoo "Cask #{cask} is not supported on os #{os} and arch #{arch}" next end quarantine = args.quarantine? quarantine = true if quarantine.nil? download = Cask::Download.new( cask, quarantine:, require_sha: Homebrew::EnvConfig.cask_opts_require_sha?, ) download_queue.enqueue(download) end end else odie "Invalid formula or cask: #{formula_or_cask}" end end download_queue.fetch ensure download_queue.shutdown end private sig { returns(Integer) } def retries @retries ||= T.let(args.retry? ? FETCH_MAX_TRIES : 1, T.nilable(Integer)) end sig { returns(DownloadQueue) } def download_queue @download_queue ||= T.let(begin DownloadQueue.new(retries:, force: args.force?) end, T.nilable(DownloadQueue)) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/formulae.rb000066400000000000000000000005021517265720000230030ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class Formulae < AbstractCommand include ShellCommand cmd_args do description "List all locally installable formulae including short names." end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/formulae.sh000066400000000000000000000014521517265720000230170ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/formulae.rb # HOMEBREW_LIBRARY is set by bin/brew # shellcheck disable=SC2154 source "${HOMEBREW_LIBRARY}/Homebrew/items.sh" homebrew-formulae() { local find_include_filter='*\.rb' local sed_filter='s|/Formula/(.+/)?|/|' local grep_filter='^homebrew/core' # HOMEBREW_CACHE is set by brew.sh # shellcheck disable=SC2154 if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" && -f "${HOMEBREW_CACHE}/api/formula_names.txt" ]] then { cat "${HOMEBREW_CACHE}/api/formula_names.txt" echo homebrew-items "${find_include_filter}" '.*Casks(/.*|$)|.*/homebrew/homebrew-core/.*' "${sed_filter}" "${grep_filter}" } | sort -uf else homebrew-items "${find_include_filter}" '.*Casks(/.*|$)' "${sed_filter}" "${grep_filter}" fi } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/gist-logs.rb000066400000000000000000000137321517265720000231120ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "install" require "system_config" require "stringio" require "socket" module Homebrew module Cmd class GistLogs < AbstractCommand include Install cmd_args do description <<~EOS Upload logs for a failed build of to a new Gist. Presents an error message if no logs are found. EOS switch "--with-hostname", description: "Include the hostname in the Gist." switch "-n", "--new-issue", description: "Automatically create a new issue in the appropriate GitHub repository " \ "after creating the Gist." switch "-p", "--private", description: "The Gist will be marked private and will not appear in listings but will " \ "be accessible with its link." named_args :formula, number: 1 end sig { override.void } def run Install.perform_preinstall_checks_once(all_fatal: true) Install.perform_build_from_source_checks(all_fatal: true) return unless (formula = args.named.to_resolved_formulae.first) gistify_logs(formula) end # Truncates a text string to fit within a byte size constraint, # preserving character encoding validity. The returned string will # be not much longer than the specified max_bytes, though the exact # shortfall or overrun may vary. sig { params(str: String, max_bytes: Integer, options: T::Hash[Symbol, T.untyped]).returns(String) } def self.truncate_text_to_approximate_size(str, max_bytes, options = {}) front_weight = options.fetch(:front_weight, 0.5) raise "opts[:front_weight] must be between 0.0 and 1.0" if front_weight < 0.0 || front_weight > 1.0 return str if str.bytesize <= max_bytes glue = "\n[...snip...]\n" max_bytes_in = [max_bytes - glue.bytesize, 1].max bytes = str.dup.force_encoding("BINARY") glue_bytes = glue.encode("BINARY") n_front_bytes = (max_bytes_in * front_weight).floor n_back_bytes = max_bytes_in - n_front_bytes if n_front_bytes.zero? front = bytes[1..0] back = bytes[-max_bytes_in..] elsif n_back_bytes.zero? front = bytes[0..(max_bytes_in - 1)] back = bytes[1..0] else front = bytes[0..(n_front_bytes - 1)] back = bytes[-n_back_bytes..] end out = T.must(front) + glue_bytes + T.must(back) out.force_encoding("UTF-8") out.encode!("UTF-16", invalid: :replace) out.encode!("UTF-8") out end private sig { params(formula: Formula).void } def gistify_logs(formula) files = load_logs(formula.logs) build_time = formula.logs.ctime timestamp = build_time.strftime("%Y-%m-%d_%H-%M-%S") s = StringIO.new SystemConfig.dump_verbose_config s # Dummy summary file, asciibetically first, to control display title of gist files["# #{formula.name} - #{timestamp}.txt"] = { content: brief_build_info(formula, with_hostname: args.with_hostname?), } files["00.config.out"] = { content: s.string } files["00.doctor.out"] = { content: Utils.popen_read("#{HOMEBREW_PREFIX}/bin/brew", "doctor", err: :out) } unless formula.core_formula? tap = <<~EOS Formula: #{formula.name} Tap: #{formula.tap} Path: #{formula.path} EOS files["00.tap.out"] = { content: tap } end if GitHub::API.credentials_type == :none odie "`brew gist-logs` requires `$HOMEBREW_GITHUB_API_TOKEN` to be set!" end # Description formatted to work well as page title when viewing gist descr = if formula.core_formula? "#{formula.name} on #{OS_VERSION} - Homebrew build logs" else "#{formula.name} (#{formula.full_name}) on #{OS_VERSION} - Homebrew build logs" end begin url = GitHub.create_gist(files, descr, private: args.private?) rescue GitHub::API::HTTPNotFoundError odie <<~EOS Your GitHub API token likely doesn't have the `gist` scope. #{GitHub.pat_blurb(GitHub::CREATE_GIST_SCOPES)} EOS end if args.new_issue? tap = formula.tap odie "Formula #{formula.name} is not associated with a tap!" unless tap url = GitHub.create_issue(tap.full_name, "#{formula.name} failed to build on #{OS_VERSION}", url) end puts url if url end sig { params(formula: Formula, with_hostname: T::Boolean).returns(String) } def brief_build_info(formula, with_hostname:) build_time_string = formula.logs.ctime.strftime("%Y-%m-%d %H:%M:%S") string = <<~EOS Homebrew build logs for #{formula.full_name} on #{OS_VERSION} EOS if with_hostname hostname = Socket.gethostname string << "Host: #{hostname}\n" end string << "Build date: #{build_time_string}\n" string.freeze end sig { params(dir: Pathname, basedir: Pathname).returns(T::Hash[String, { content: String }]) } def load_logs(dir, basedir = dir) logs = {} if dir.exist? dir.children.sort.each do |file| if file.directory? logs.merge! load_logs(file, basedir) else contents = file.size? ? file.read : "empty log" # small enough to avoid GitHub "unicorn" page-load-timeout errors max_file_size = 1_000_000 contents = GistLogs.truncate_text_to_approximate_size(contents, max_file_size, front_weight: 0.2) logs[file.relative_path_from(basedir).to_s.tr("/", ":")] = { content: contents } end end end odie "No logs." if logs.empty? logs end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/help.rb000066400000000000000000000007061517265720000221270ustar00rootroot00000000000000# typed: strong # frozen_string_literal: true require "abstract_command" require "help" module Homebrew module Cmd class HelpCmd < AbstractCommand cmd_args do description <<~EOS Outputs the usage instructions for `brew` . Equivalent to `brew --help` . EOS named_args [:command] end sig { override.void } def run Help.help end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/home.rb000066400000000000000000000027641517265720000221350ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" module Homebrew module Cmd class Home < AbstractCommand cmd_args do description <<~EOS Open a or 's homepage in a browser, or open Homebrew's own homepage if no argument is provided. EOS switch "--formula", "--formulae", description: "Treat all named arguments as formulae." switch "--cask", "--casks", description: "Treat all named arguments as casks." conflicts "--formula", "--cask" named_args [:formula, :cask] end sig { override.void } def run if args.no_named? exec_browser HOMEBREW_WWW return end # to_formulae_and_casks is typed to possibly return Kegs (but won't without explicitly asking) formulae_or_casks = T.cast(args.named.to_formulae_and_casks, T::Array[T.any(Formula, Cask::Cask)]) homepages = formulae_or_casks.map do |formula_or_cask| puts "Opening homepage for #{name_of(formula_or_cask)}" formula_or_cask.homepage end exec_browser(*homepages) end private sig { params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(String) } def name_of(formula_or_cask) if formula_or_cask.is_a? Formula "Formula #{formula_or_cask.name}" else "Cask #{formula_or_cask.token}" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/info.rb000066400000000000000000000620211517265720000221300ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "missing_formula" require "caveats" require "options" require "formula" require "formula_pin" require "keg" require "tab" require "json" require "cask/cask_loader" require "utils/spdx" require "deprecate_disable" require "api" module Homebrew module Cmd class Info < AbstractCommand class NameSize < T::Struct const :name, String const :size, Integer end private_constant :NameSize VALID_DAYS = %w[30 90 365].freeze VALID_FORMULA_CATEGORIES = %w[install install-on-request build-error].freeze VALID_CATEGORIES = T.let((VALID_FORMULA_CATEGORIES + %w[cask-install os-version]).freeze, T::Array[String]) cmd_args do description <<~EOS Display brief statistics for your Homebrew installation. If a or is provided, show summary of information about it. EOS switch "--analytics", description: "List global Homebrew analytics data or, if specified, installation and " \ "build error data for (provided neither `$HOMEBREW_NO_ANALYTICS` " \ "nor `$HOMEBREW_NO_GITHUB_API` are set)." flag "--days=", depends_on: "--analytics", description: "How many days of analytics data to retrieve. " \ "The value for must be `30`, `90` or `365`. The default is `30`." flag "--category=", depends_on: "--analytics", description: "Which type of analytics data to retrieve. " \ "The value for must be `install`, `install-on-request` or `build-error`; " \ "`cask-install` or `os-version` may be specified if is not. " \ "The default is `install`." switch "--github-packages-downloads", description: "Scrape GitHub Packages download counts from HTML for a core formula.", hidden: true switch "--github", description: "Open the GitHub source page for and in a browser. " \ "To view the history locally: `brew log -p` or " switch "--fetch-manifest", description: "Fetch GitHub Packages manifest for extra information when is not installed." flag "--json", description: "Print a JSON representation. Currently the default value for is `v1` for " \ ". For and use `v2`. See the docs for examples of using the " \ "JSON output: " switch "--installed", depends_on: "--json", description: "Print JSON of formulae that are currently installed." switch "--eval-all", depends_on: "--json", description: "Evaluate all available formulae and casks, whether installed or not, to print their " \ "JSON." switch "--variations", depends_on: "--json", description: "Include the variations hash in each formula's JSON output." switch "-v", "--verbose", description: "Show more verbose analytics data for ." switch "--formula", "--formulae", description: "Treat all named arguments as formulae." switch "--cask", "--casks", description: "Treat all named arguments as casks." switch "--sizes", description: "Show the size of installed formulae and casks." conflicts "--installed", "--eval-all" conflicts "--formula", "--cask" conflicts "--fetch-manifest", "--cask" conflicts "--fetch-manifest", "--json" named_args [:formula, :cask] end sig { override.void } def run if args.sizes? if args.no_named? print_sizes else formulae, casks = args.named.to_formulae_to_casks formulae = T.cast(formulae, T::Array[Formula]) print_sizes(formulae:, casks:) end elsif args.analytics? if args.days.present? && VALID_DAYS.exclude?(args.days) raise UsageError, "`--days` must be one of #{VALID_DAYS.join(", ")}." end if args.category.present? if args.named.present? && VALID_FORMULA_CATEGORIES.exclude?(args.category) raise UsageError, "`--category` must be one of #{VALID_FORMULA_CATEGORIES.join(", ")} when querying formulae." end unless VALID_CATEGORIES.include?(args.category) raise UsageError, "`--category` must be one of #{VALID_CATEGORIES.join(", ")}." end end print_analytics elsif (json = args.json) print_json(json, args.eval_all?) elsif args.github? raise FormulaOrCaskUnspecifiedError if args.no_named? exec_browser(*args.named.to_formulae_and_casks.map do |formula_keg_or_cask| formula_or_cask = T.cast(formula_keg_or_cask, T.any(Formula, Cask::Cask)) github_info(formula_or_cask) end) elsif args.no_named? print_statistics else print_info end end sig { params(remote: String, path: String).returns(String) } def github_remote_path(remote, path) if remote =~ %r{^(?:https?://|git(?:@|://))github\.com[:/](.+)/(.+?)(?:\.git)?$} "https://github.com/#{Regexp.last_match(1)}/#{Regexp.last_match(2)}/blob/HEAD/#{path}" else "#{remote}/#{path}" end end sig { params(formula_or_cask: T.untyped).returns(T::Array[String]) } def self.metadata_lines(formula_or_cask) return [] unless $stdout.tty? if formula_or_cask.is_a?(Formula) || formula_or_cask.respond_to?(:pinned?) formula_metadata_lines(formula_or_cask) elsif formula_or_cask.is_a?(Cask::Cask) || formula_or_cask.respond_to?(:supports_macos?) [] else raise TypeError, "Unsupported formula_or_cask type: #{formula_or_cask.class}" end end sig { params(formula_or_cask: T.untyped).returns(T::Array[String]) } def self.requirements_lines(formula_or_cask) return [] unless $stdout.tty? return [] if formula_or_cask.is_a?(Formula) || formula_or_cask.respond_to?(:pinned?) if formula_or_cask.is_a?(Cask::Cask) || formula_or_cask.respond_to?(:supports_macos?) return cask_requirements_lines(formula_or_cask) end raise TypeError, "Unsupported formula_or_cask type: #{formula_or_cask.class}" end sig { params(tab: T.any(Tab, Cask::Tab)).returns(String) } def self.installation_status(tab) # TODO: Deprecate reading `installed_as_dependency`; `installed_on_request` # is the only state we need to render install intent. tab.installed_on_request ? "Installed (on request)" : "Installed (as dependency)" end sig { params(requirement: Requirement).returns(T::Boolean) } def self.requirement_for_other_os?(requirement) requirement.instance_of?(MacOSRequirement) || requirement.instance_of?(LinuxRequirement) end sig { params(installed_count: Integer, total_count: Integer).returns(String) } def self.dependency_status_counts(installed_count, total_count) "#{installed_count} #{Formatter.success("✔")}, " \ "#{total_count - installed_count} #{Formatter.error("✘")}" end sig { params(full_name: String, name: String).returns(Integer) } def self.count_installed_dependents(full_name, name) Formula.racks.count do |rack| keg = Keg.from_rack(rack) next false unless keg tab_path = keg/AbstractTab::FILENAME next false unless tab_path.file? # Fast path: skip JSON parsing when the formula name # does not appear anywhere in the raw receipt. content = File.read(tab_path) next false unless content.include?(name) tab_deps = Tab.from_file_content(content, tab_path).runtime_dependencies next false unless tab_deps tab_deps.any? do |dep| dep_full_name = T.cast(dep, T::Hash[String, T.untyped])["full_name"] dep_full_name == full_name || dep_full_name&.split("/")&.last == name end end end sig { params(formula: T.untyped).returns(T::Array[String]) } def self.formula_metadata_lines(formula) metadata = T.let([], T::Array[String]) if formula.pinned? pinned = "Pinned: #{formula.pinned_version}" if (pinned_time = formula_pinned_time(formula)) pinned << " on #{formatted_time(pinned_time)}" end metadata << pinned end if !formula.any_version_installed? && formula_installs_from_source?(formula) && formula.requirements.none? { |requirement| requirement_for_other_os?(requirement) } metadata << "Installs from source: yes" end metadata end sig { params(cask: T.untyped).returns(T::Array[String]) } def self.cask_requirements_lines(cask) requirement = if (macos = cask.depends_on.macos) requirement = macos.display_s if cask.supports_linux? requirement.sub(" (or Linux)", " or Linux") else requirement.delete_suffix(" (or Linux)") end elsif cask.supports_macos? && cask.supports_linux? "macOS or Linux" elsif cask.supports_macos? "macOS" elsif cask.supports_linux? "Linux" end requirement ? [requirement] : [] end sig { params(time: T.any(Integer, Time)).returns(String) } def self.formatted_time(time) time = Time.at(time) if time.is_a?(Integer) time.strftime("%Y-%m-%d at %H:%M:%S") end sig { params(formula: T.untyped).returns(T.nilable(Time)) } def self.formula_pinned_time(formula) pin_path = FormulaPin.new(formula).path pin_path.lstat.mtime if pin_path.symlink? || pin_path.exist? rescue Errno::ENOENT nil end sig { params(formula: T.untyped).returns(T::Boolean) } def self.formula_installs_from_source?(formula) return true if formula.stable.blank? && formula.head.present? return false if formula.stable.blank? !formula.stable.bottled? || !formula.pour_bottle? end sig { params(cask: T.untyped, formula_dependencies: T::Set[String], cask_dependencies: T::Set[String], visited_casks: T::Set[String]).void } def self.collect_cask_dependency_names(cask, formula_dependencies, cask_dependencies, visited_casks) cask.depends_on.formula.each do |name| dep_name = name.to_s formula_dependencies << dep_name rack = HOMEBREW_CELLAR/dep_name.split("/").last next unless rack.directory? keg = Keg.from_rack(rack) next unless keg tab_deps = Tab.for_keg(keg).runtime_dependencies tab_deps&.each do |runtime_dep| dep_full_name = T.cast(runtime_dep, T::Hash[String, T.untyped])["full_name"] formula_dependencies << dep_full_name if dep_full_name end end cask.depends_on.cask.each do |name| token = name.to_s next if visited_casks.include?(token) cask_dependencies << token visited_casks << token begin dependency = Cask::CaskLoader.load(token) collect_cask_dependency_names(dependency, formula_dependencies, cask_dependencies, visited_casks) rescue Cask::CaskUnavailableError next end end end private_class_method :formula_metadata_lines, :formatted_time, :formula_pinned_time, :formula_installs_from_source?, :cask_requirements_lines private sig { void } def print_statistics return unless HOMEBREW_CELLAR.exist? count = Formula.racks.length puts "#{Utils.pluralize("keg", count, include_count: true)}, #{HOMEBREW_CELLAR.dup.abv}" end sig { void } def print_analytics if args.no_named? Utils::Analytics.output(args:) return end args.named.to_formulae_and_casks_and_unavailable.each_with_index do |obj, i| puts unless i.zero? case obj when Formula Utils::Analytics.formula_output(obj, args:) if obj.core_formula? when Cask::Cask Utils::Analytics.cask_output(obj, args:) if obj.tap&.core_cask_tap? when FormulaOrCaskUnavailableError Utils::Analytics.output(filter: obj.name, args:) else raise end end end sig { void } def print_info args.named.to_formulae_and_casks_and_unavailable.each_with_index do |obj, i| puts unless i.zero? case obj when Formula info_formula(obj) when Cask::Cask info_cask(obj) when FormulaOrCaskUnavailableError # The formula/cask could not be found ofail obj.message # No formula with this name, try a missing formula lookup if (reason = MissingFormula.reason(obj.name, show_info: true)) $stderr.puts reason end else raise end end end sig { params(version: T.any(T::Boolean, String)).returns(Symbol) } def json_version(version) version_hash = { true => :default, "v1" => :v1, "v2" => :v2, } raise UsageError, "invalid JSON version: #{version}" unless version_hash.include?(version) version_hash[version] end sig { params(json: T.any(T::Boolean, String), eval_all: T::Boolean).void } def print_json(json, eval_all) raise FormulaOrCaskUnspecifiedError if !(eval_all || args.installed?) && args.no_named? json = case json_version(json) when :v1, :default raise UsageError, "Cannot specify `--cask` when using `--json=v1`!" if args.cask? formulae = if eval_all Formula.all(eval_all:).sort elsif args.installed? Formula.installed.sort else args.named.to_formulae end if args.variations? formulae.map(&:to_hash_with_variations) else formulae.map(&:to_hash) end when :v2 formulae, casks = T.let( if eval_all [ Formula.all(eval_all:).sort, Cask::Cask.all(eval_all:).sort_by(&:full_name), ] elsif args.installed? [Formula.installed.sort, Cask::Caskroom.casks.sort_by(&:full_name)] else T.cast(args.named.to_formulae_to_casks, [T::Array[Formula], T::Array[Cask::Cask]]) end, [T::Array[Formula], T::Array[Cask::Cask]] ) if args.variations? { "formulae" => formulae.map(&:to_hash_with_variations), "casks" => casks.map(&:to_hash_with_variations), } else { "formulae" => formulae.map(&:to_hash), "casks" => casks.map(&:to_h), } end else raise end puts JSON.pretty_generate(json) end sig { params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(String) } def github_info(formula_or_cask) tap = T.let(nil, T.nilable(Tap)) path = case formula_or_cask when Formula formula = formula_or_cask tap = formula.tap return formula.path.to_s if tap.blank? || tap.remote.blank? # The formula file may live outside the tap (e.g. loaded from a keg's # `.brew/` directory after the formula was removed from its tap), in # which case there is no meaningful upstream URL to link to. return formula.path.to_s unless formula.path.to_s.start_with?("#{tap.path}/") formula.path.relative_path_from(tap.path) when Cask::Cask cask = formula_or_cask tap = cask.tap return cask.sourcefile_path.to_s if tap.blank? || tap.remote.blank? sourcefile_path = cask.sourcefile_path if sourcefile_path.blank? || sourcefile_path.extname != ".rb" return "#{tap.default_remote}/blob/HEAD/#{tap.relative_cask_path(cask.token)}" end sourcefile_path.relative_path_from(tap.path) end remote = tap.remote raise "unexpected nil tap.remote" unless remote github_remote_path(remote, path.to_s) end sig { params(formula: Formula).void } def info_formula(formula) specs = [] if (stable = formula.stable) string = "stable #{stable.version}" string += " (bottled)" if stable.bottled? && formula.pour_bottle? specs << string end specs << "HEAD" if formula.head attrs = [] attrs << "keg-only" if formula.keg_only? kegs = formula.installed_kegs name_with_status = if kegs.empty? pretty_uninstalled(formula.full_name) else pretty_installed(formula.full_name) end puts "#{oh1_title(name_with_status)}: #{specs * ", "}#{" [#{attrs * ", "}]" unless attrs.empty?}" puts formula.desc if formula.desc puts Formatter.url(formula.homepage) if formula.homepage deprecate_disable_info_string = DeprecateDisable.message(formula) if deprecate_disable_info_string.present? deprecate_disable_info_string.tap { |info_string| info_string[0] = info_string[0].upcase } puts deprecate_disable_info_string end conflicts = formula.conflicts.map do |conflict| reason = " (because #{conflict.reason})" if conflict.reason "#{conflict.name}#{reason}" end.sort! unless conflicts.empty? puts <<~EOS Conflicts with: #{conflicts.join("\n ")} EOS end heads, versioned = kegs.partition { |keg| keg.version.head? } kegs = [ *heads.sort_by { |keg| -keg.tab.time.to_i }, *versioned.sort_by(&:scheme_and_version), ] if kegs.empty? puts "Not installed" if (bottle = formula.bottle) begin bottle.fetch_tab(quiet: !args.debug?) if args.fetch_manifest? bottle_size = bottle.bottle_size installed_size = bottle.installed_size puts "Bottle Size: #{Formatter.disk_usage_readable(bottle_size)}" if bottle_size puts "Installed Size: #{Formatter.disk_usage_readable(installed_size)}" if installed_size rescue RuntimeError => e odebug e end end else puts self.class.installation_status(Tab.for_formula(formula)) kegs.each do |keg| puts "#{keg} (#{keg.abv})#{" *" if keg.linked?}" tab = keg.tab.to_s puts " #{tab}" unless tab.empty? end end puts "From: #{Formatter.url(github_info(formula))}" puts "License: #{SPDX.license_expression_to_string formula.license}" if formula.license.present? metadata = self.class.metadata_lines(formula) puts metadata if metadata.present? tab_runtime_deps = kegs.last&.runtime_dependencies installed_dependents = if $stdout.tty? && kegs.any? self.class.count_installed_dependents(formula.full_name, formula.name) else 0 end dependency_lines = %w[build required recommended optional].filter_map do |type| next if type == "build" && (kegs.all? { |keg| keg.tab.poured_from_bottle } || (kegs.empty? && (formula.requirements.any? { |requirement| self.class.requirement_for_other_os?(requirement) } || (stable.present? ? stable.bottled? && formula.pour_bottle? : formula.head.blank?)))) deps = formula.deps.send(type).uniq "#{type.capitalize} (#{deps.count}): #{decorate_dependencies deps}" unless deps.empty? end if dependency_lines.present? || tab_runtime_deps.present? || installed_dependents.positive? ohai "Dependencies" puts dependency_lines if tab_runtime_deps.present? installed_count = tab_runtime_deps.count do |dep| dep_name = dep["full_name"]&.split("/")&.last next false unless dep_name rack = HOMEBREW_CELLAR/dep_name rack.directory? && !rack.subdirs.empty? end puts "Recursive Runtime (#{tab_runtime_deps.count}): " \ "#{self.class.dependency_status_counts(installed_count, tab_runtime_deps.count)}" end puts "Dependents: #{installed_dependents}" if installed_dependents.positive? end unless formula.requirements.to_a.empty? ohai "Requirements" %w[build required recommended optional].map do |type| reqs = formula.requirements.select(&:"#{type}?") next if reqs.to_a.empty? puts "#{type.capitalize}: #{decorate_requirements(reqs)}" end end if !formula.options.empty? || formula.head ohai "Options" Options.dump_for_formula formula end caveats = Caveats.new(formula) if (caveats_string = caveats.to_s.presence) ohai "Caveats", caveats_string end return unless formula.core_formula? Utils::Analytics.formula_output(formula, args:) end sig { params(dependencies: T::Array[Dependency]).returns(String) } def decorate_dependencies(dependencies) deps_status = dependencies.map do |dep| if dep.satisfied? pretty_installed(dep_display_s(dep)) else pretty_uninstalled(dep_display_s(dep)) end end deps_status.join(", ") end sig { params(requirements: T::Array[Requirement]).returns(String) } def decorate_requirements(requirements) req_status = requirements.map do |req| req_s = req.display_s req.satisfied? ? pretty_installed(req_s) : pretty_uninstalled(req_s) end req_status.join(", ") end sig { params(dep: Dependency).returns(String) } def dep_display_s(dep) return dep.name if dep.option_tags.empty? "#{dep.name} #{dep.option_tags.map { |o| "--#{o}" }.join(" ")}" end sig { params(cask: Cask::Cask).void } def info_cask(cask) require "cask/info" Cask::Info.info(cask, args:) end sig { params(title: String, items: T::Array[NameSize]).void } def print_sizes_table(title, items) return if items.blank? ohai title total_size = items.sum(&:size) total_size_str = Formatter.disk_usage_readable(total_size) name_width = (items.map { |item| item.name.length } + [5]).max size_width = (items.map do |item| Formatter.disk_usage_readable(item.size).length end + [total_size_str.length]).max items.each do |item| puts format("%-#{name_width}s %#{size_width}s", item.name, Formatter.disk_usage_readable(item.size)) end puts format("%-#{name_width}s %#{size_width}s", "Total", total_size_str) end sig { params(formulae: T::Array[Formula], casks: T::Array[Cask::Cask]).void } def print_sizes(formulae: [], casks: []) if formulae.blank? && (args.formulae? || (!args.casks? && args.no_named?)) formulae = Formula.installed end if casks.blank? && (args.casks? || (!args.formulae? && args.no_named?)) casks = Cask::Caskroom.casks end unless args.casks? formula_sizes = formulae.map do |formula| kegs = formula.installed_kegs size = kegs.sum(&:disk_usage) NameSize.new(name: formula.full_name, size:) end formula_sizes.sort_by! { |f| -f.size } print_sizes_table("Formulae sizes:", formula_sizes) end return if casks.blank? || args.formulae? cask_sizes = casks.filter_map do |cask| installed_version = cask.installed_version next unless installed_version.present? versioned_staged_path = cask.caskroom_path.join(installed_version) next unless versioned_staged_path.exist? size = versioned_staged_path.children.sum(&:disk_usage) NameSize.new(name: cask.full_name, size:) end cask_sizes.sort_by! { |c| -c.size } print_sizes_table("Casks sizes:", cask_sizes) end end end end require "extend/os/cmd/info" Homebrew-brew-d7f73ce/Library/Homebrew/cmd/install.rb000066400000000000000000000522061517265720000226470ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "cask/config" require "cask/installer" require "cask/upgrade" require "cask_dependent" require "missing_formula" require "formula_installer" require "development_tools" require "install" require "cleanup" require "upgrade" module Homebrew module Cmd class InstallCmd < AbstractCommand cmd_args do description <<~EOS Install a or . Additional options specific to a may be appended to the command. Unless `$HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for outdated dependents and dependents with broken linkage, respectively. Unless `$HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the installed formulae or, every 30 days, for all formulae. Unless `$HOMEBREW_NO_INSTALL_UPGRADE` is set, `brew install` will upgrade if it is already installed but outdated. EOS switch "-d", "--debug", description: "If brewing fails, open an interactive debugging session with access to IRB " \ "or a shell inside the temporary build directory." switch "--display-times", description: "Print install times for each package at the end of the run.", env: :display_install_times switch "-f", "--force", description: "Install formulae without checking for previously installed keg-only or " \ "non-migrated versions. When installing casks, overwrite existing files " \ "(binaries and symlinks are excluded, unless originally from the same cask)." switch "-v", "--verbose", description: "Print the verification and post-install steps." switch "-n", "--dry-run", description: "Show what would be installed, but do not actually install anything." switch "--ask", description: "Ask for confirmation before downloading and installing formulae. " \ "Print download and install sizes of bottles and dependencies.", env: :ask [ [:switch, "--formula", "--formulae", { description: "Treat all named arguments as formulae.", }], [:flag, "--env=", { description: "Disabled other than for internal Homebrew use.", hidden: true, }], [:switch, "--ignore-dependencies", { description: "An unsupported Homebrew development option to skip installing any dependencies of any " \ "kind. If the dependencies are not already present, the formula will have issues. If " \ "you're not developing Homebrew, consider adjusting your PATH rather than using this " \ "option.", }], [:switch, "--only-dependencies", { description: "Install the dependencies with specified options but do not install the " \ "formula itself.", }], [:flag, "--cc=", { description: "Attempt to compile using the specified , which should be the name of the " \ "compiler's executable, e.g. `gcc-9` for GCC 9. In order to use LLVM's clang, specify " \ "`llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only " \ "accept compilers that are provided by Homebrew or bundled with macOS. Please do not " \ "file issues if you encounter errors while using this option.", }], [:switch, "-s", "--build-from-source", { description: "Compile from source even if a bottle is provided. " \ "Dependencies will still be installed from bottles if they are available.", }], [:switch, "--force-bottle", { description: "Install from a bottle if it exists for the current or newest version of " \ "macOS, even if it would not normally be used for installation.", }], [:switch, "--include-test", { description: "Install testing dependencies required to run `brew test` .", }], [:switch, "--HEAD", { description: "If defines it, install the HEAD version, aka. main, trunk, unstable, master.", }], [:switch, "--fetch-HEAD", { description: "Fetch the upstream repository to detect if the HEAD installation of the " \ "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \ "updates when a new stable or development version has been released.", }], [:switch, "--keep-tmp", { description: "Retain the temporary files created during installation.", }], [:switch, "--debug-symbols", { depends_on: "--build-from-source", description: "Generate debug symbols on build. Source will be retained in a cache directory.", }], [:switch, "--build-bottle", { description: "Prepare the formula for eventual bottling during installation, skipping any " \ "post-install steps.", }], [:switch, "--skip-post-install", { description: "Install but skip any post-install steps.", }], [:switch, "--skip-link", { description: "Install but skip linking the keg into the prefix.", }], [:switch, "--as-dependency", { description: "Install but mark as installed as a dependency and not installed on request.", }], [:flag, "--bottle-arch=", { depends_on: "--build-bottle", description: "Optimise bottles for the specified architecture rather than the oldest " \ "architecture supported by the version of macOS the bottles are built on.", }], [:switch, "-i", "--interactive", { description: "Download and patch , then open a shell. This allows the user to " \ "run `./configure --help` and otherwise determine how to turn the software " \ "package into a Homebrew package.", }], [:switch, "-g", "--git", { description: "Create a Git repository, useful for creating patches to the software.", }], [:switch, "--overwrite", { description: "Delete files that already exist in the prefix while linking.", }], ].each do |args| options = args.pop send(*args, **options) conflicts "--cask", args.last end formula_options [ [:switch, "--cask", "--casks", { description: "Treat all named arguments as casks.", }], [:switch, "--[no-]binaries", { description: "Disable/enable linking of helper executables (default: enabled).", env: :cask_opts_binaries, }], [:switch, "--require-sha", { description: "Require all casks to have a checksum.", env: :cask_opts_require_sha, }], [:switch, "--[no-]quarantine", { env: :cask_opts_quarantine, odisabled: true, }], [:switch, "--adopt", { description: "Adopt existing artifacts in the destination that are identical to those being installed. " \ "Cannot be combined with `--force`.", }], [:switch, "--skip-cask-deps", { description: "Skip installing cask dependencies.", }], [:switch, "--zap", { description: "For use with `brew reinstall --cask`. Remove all files associated with a cask. " \ "*May remove files which are shared between applications.*", }], ].each do |args| options = args.pop send(*args, **options) conflicts "--formula", args.last end cask_options conflicts "--ignore-dependencies", "--only-dependencies" conflicts "--build-from-source", "--build-bottle", "--force-bottle" conflicts "--adopt", "--force" named_args [:formula, :cask], min: 1 end sig { override.void } def run if args.env.present? # Can't use `replacement: false` because `install_args` are used by # `build.rb`. Instead, `hide_from_man_page` and don't do anything with # this argument here. # This odisabled should stick around indefinitely. odisabled "`brew install --env`", "`env :std` in specific formula files" end args.named.each do |name| if (tap_with_name = Tap.with_formula_name(name)) tap, = tap_with_name elsif (tap_with_token = Tap.with_cask_token(name)) tap, = tap_with_token end tap&.ensure_installed! end if args.ignore_dependencies? opoo <<~EOS #{Tty.bold}`--ignore-dependencies` is an unsupported Homebrew developer option!#{Tty.reset} Adjust your PATH to put any preferred versions of applications earlier in the PATH rather than using this unsupported option! EOS end formulae, casks = T.cast( args.named.to_formulae_and_casks(warn: false).partition { it.is_a?(Formula) }, [T::Array[Formula], T::Array[Cask::Cask]], ) installed_casks = T.let([], T::Array[Cask::Cask]) new_casks = T.let([], T::Array[Cask::Cask]) upgrade_casks = T.let([], T::Array[Cask::Cask]) fetch_casks = T.let([], T::Array[Cask::Cask]) if casks.any? Install.ask_casks casks if args.ask? if args.dry_run? if (casks_to_install = casks.reject(&:installed?).presence) ohai "Would install #{::Utils.pluralize("cask", casks_to_install.count, include_count: true)}:" puts casks_to_install.map(&:full_name).join(" ") end casks.each do |cask| dep_names = CaskDependent.new(cask) .runtime_dependencies .reject(&:installed?) .map(&:name) next if dep_names.blank? ohai "Would install #{::Utils.pluralize("dependency", dep_names.count, include_count: true)} " \ "for #{cask.full_name}:" puts dep_names.join(" ") end return end require "cask/installer" installed_casks, new_casks = casks.partition(&:installed?) fetch_casks = if Homebrew::EnvConfig.no_install_upgrade? new_casks else upgrade_casks = Cask::Upgrade.outdated_casks(casks, args:, force: true, quiet: true) new_casks | upgrade_casks end end formulae = Homebrew::Attestation.sort_formulae_for_install(formulae) if Homebrew::Attestation.enabled? # if the user's flags will prevent bottle only-installations when no # developer tools are available, we need to stop them early on build_flags = [] unless DevelopmentTools.installed? build_flags << "--HEAD" if args.HEAD? build_flags << "--build-bottle" if args.build_bottle? build_flags << "--build-from-source" if args.build_from_source? raise BuildFlagsError.new(build_flags, bottled: formulae.all?(&:bottled?)) if build_flags.present? end if build_flags.present? && !Homebrew::EnvConfig.developer? opoo "building from source is not supported!" puts "You're on your own. Failures are expected so don't create any issues, please!" end installed_formulae = formulae.select do |f| Install.install_formula?( f, head: args.HEAD?, fetch_head: args.fetch_HEAD?, only_dependencies: args.only_dependencies?, force: args.force?, quiet: args.quiet?, skip_link: args.skip_link?, overwrite: args.overwrite?, ) end return if formulae.any? && installed_formulae.empty? && casks.empty? Install.perform_preinstall_checks_once Install.check_cc_argv(args.cc) formulae_installer = Install.formula_installers( installed_formulae, installed_on_request: !args.as_dependency?, installed_as_dependency: args.as_dependency?, build_bottle: args.build_bottle?, force_bottle: args.force_bottle?, bottle_arch: args.bottle_arch, ignore_deps: args.ignore_dependencies?, only_deps: args.only_dependencies?, include_test_formulae: args.include_test_formulae, build_from_source_formulae: args.build_from_source_formulae, cc: args.cc, git: args.git?, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, overwrite: args.overwrite?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose?, dry_run: args.dry_run?, skip_post_install: args.skip_post_install?, skip_link: args.skip_link?, ) dependants = Upgrade.dependants( installed_formulae, flags: args.flags_only, ask: args.ask?, installed_on_request: !args.as_dependency?, force_bottle: args.force_bottle?, build_from_source_formulae: args.build_from_source_formulae, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose?, dry_run: args.dry_run?, ) # Main block: if asking the user is enabled, show dependency and size information. Install.ask_formulae(formulae_installer, dependants, args: args) if args.ask? if !args.dry_run? && (formulae_installer.any? || fetch_casks.any?) download_queue = Homebrew::DownloadQueue.new(pour: true) begin Cask::Upgrade.show_upgrade_summary( upgrade_casks.map { |cask| "#{cask.full_name} #{cask.installed_version} -> #{cask.version}" }, ) Install.show_combined_fetch_downloads_heading( formula_names: formulae_installer.map { |fi| fi.formula.name }, cask_names: fetch_casks.map(&:full_name), ) formulae_installer = Install.enqueue_formulae(formulae_installer, download_queue:) if fetch_casks.any? fetch_cask_installers = fetch_casks.map do |cask| Cask::Installer.new( cask, reinstall: true, binaries: args.binaries?, verbose: args.verbose?, force: args.force?, skip_cask_deps: args.skip_cask_deps?, require_sha: args.require_sha?, quarantine: args.quarantine?, zap: args.zap?, download_queue:, defer_fetch: true, ) end Install.enqueue_cask_installers(fetch_cask_installers) end download_queue.fetch ensure download_queue.shutdown end end exit 1 if Homebrew.failed? Install.install_formulae(formulae_installer, dry_run: args.dry_run?, verbose: args.verbose?) Upgrade.upgrade_dependents( dependants, installed_formulae, flags: args.flags_only, dry_run: args.dry_run?, force_bottle: args.force_bottle?, build_from_source_formulae: args.build_from_source_formulae, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose? ) if casks.any? begin new_casks.each do |cask| Cask::Installer.new( cask, adopt: args.adopt?, binaries: args.binaries?, defer_fetch: fetch_casks.include?(cask), force: args.force?, quarantine: args.quarantine?, quiet: args.quiet?, require_sha: args.require_sha?, skip_cask_deps: args.skip_cask_deps?, verbose: args.verbose?, ).install end rescue => e ofail e end if !Homebrew::EnvConfig.no_install_upgrade? && installed_casks.any? begin Cask::Upgrade.upgrade_casks!( *installed_casks, force: args.force?, dry_run: args.dry_run?, binaries: args.binaries?, quarantine: args.quarantine?, require_sha: args.require_sha?, skip_cask_deps: args.skip_cask_deps?, verbose: args.verbose?, quiet: args.quiet?, skip_prefetch: true, show_upgrade_summary: false, args:, ) rescue => e ofail e end end end Cleanup.periodic_clean!(dry_run: args.dry_run?) Homebrew.messages.display_messages(display_times: args.display_times?) rescue FormulaUnreadableError, FormulaClassUnavailableError, TapFormulaUnreadableError, TapFormulaClassUnavailableError => e require "utils/backtrace" # Need to rescue before `FormulaUnavailableError` (superclass of this) # is handled, as searching for a formula doesn't make sense here (the # formula was found, but there's a problem with its implementation). $stderr.puts Utils::Backtrace.clean(e) if Homebrew::EnvConfig.developer? ofail e.message rescue FormulaOrCaskUnavailableError, Cask::CaskUnavailableError => e Homebrew.failed = true # formula name or cask token name = case e when FormulaOrCaskUnavailableError then e.name when Cask::CaskUnavailableError then e.token else T.absurd(e) end if name == "updog" ofail "What's updog?" return end opoo e reason = MissingFormula.reason(name, silent: true) if !args.cask? && reason $stderr.puts reason return end # We don't seem to get good search results when the tap is specified # so we might as well return early. return if name.include?("/") require "search" package_types = [] package_types << "formulae" unless args.cask? package_types << "casks" unless args.formula? ohai "Searching for similarly named #{package_types.join(" and ")}..." # Don't treat formula/cask name as a regex string_or_regex = name all_formulae, all_casks = Search.search_names(string_or_regex, args) if all_formulae.any? ohai "Formulae", Formatter.columns(all_formulae) first_formula = all_formulae.first.to_s puts <<~EOS To install #{first_formula}, run: brew install #{first_formula} EOS end puts if all_formulae.any? && all_casks.any? if all_casks.any? ohai "Casks", Formatter.columns(all_casks) first_cask = all_casks.first.to_s puts <<~EOS To install #{first_cask}, run: brew install --cask #{first_cask} EOS end return if all_formulae.any? || all_casks.any? odie "No #{package_types.join(" or ")} found for #{name}." end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/leaves.rb000066400000000000000000000050621517265720000224560ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "cask_dependent" module Homebrew module Cmd class Leaves < AbstractCommand cmd_args do description <<~EOS List installed formulae that are not dependencies of another installed formula or cask. EOS switch "-r", "--installed-on-request", description: "Only list leaves that were manually installed." switch "-p", "--installed-as-dependency", description: "Only list leaves that were installed as dependencies." conflicts "--installed-on-request", "--installed-as-dependency" named_args :none end sig { override.void } def run installed = Formula.installed # Build a set of dependency names from tab data to avoid loading full Formula objects # via Formulary.resolve for each dependency (which is expensive I/O). formula_dep_names = installed.flat_map do |f| if (tab_deps = f.any_installed_keg&.runtime_dependencies) tab_deps.filter_map do |dep| full_name = dep["full_name"] next unless full_name Utils.name_from_full_name(full_name) end else # Fallback for installations without tab runtime_dependencies. f.installed_runtime_formula_dependencies.map(&:name) end end # Add direct cask formula dependency names; their transitive deps are already in dep_names. cask_dep_names = Cask::Caskroom.casks.flat_map do |cask| CaskDependent.new(cask).deps.map { |dep| Utils.name_from_full_name(dep.name) } end dep_names = T.let((formula_dep_names + cask_dep_names).to_set, T::Set[String]) leaves_list = installed.reject { |f| dep_names.intersect?(f.possible_names) } leaves_list.select! { |leaf| installed_on_request?(leaf) } if args.installed_on_request? leaves_list.select! { |leaf| installed_as_dependency?(leaf) } if args.installed_as_dependency? leaves_list.map(&:full_name) .sort .each { |leaf| puts(leaf) } end private sig { params(formula: Formula).returns(T::Boolean) } def installed_on_request?(formula) formula.any_installed_keg&.tab&.installed_on_request == true end sig { params(formula: Formula).returns(T::Boolean) } def installed_as_dependency?(formula) formula.any_installed_keg&.tab&.installed_as_dependency == true end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/link.rb000066400000000000000000000110621517265720000221310ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "caveats" require "unlink" module Homebrew module Cmd class Link < AbstractCommand cmd_args do description <<~EOS Symlink all of 's installed files into Homebrew's prefix. This is done automatically when you install formulae but can be useful for manual installations. EOS switch "--overwrite", description: "Delete files that already exist in the prefix while linking." switch "-n", "--dry-run", description: "List files which would be linked or deleted by " \ "`brew link --overwrite` without actually linking or deleting any files." switch "-f", "--force", description: "Allow keg-only formulae to be linked." switch "--HEAD", description: "Link the HEAD version of the formula if it is installed." named_args :installed_formula, min: 1 end sig { override.void } def run options = { overwrite: args.overwrite?, dry_run: args.dry_run?, verbose: args.verbose?, } kegs = if args.HEAD? args.named.to_kegs.group_by(&:name).filter_map do |name, resolved_kegs| head_keg = resolved_kegs.find { |keg| keg.version.head? } next head_keg if head_keg.present? opoo <<~EOS No HEAD keg installed for #{name} To install, run: brew install --HEAD #{name} EOS nil end else args.named.to_latest_kegs end kegs.freeze.each do |keg| keg_only = Formulary.keg_only?(keg.rack) formula = begin keg.to_formula rescue FormulaUnavailableError # Not all kegs may belong to current formulae nil end versioned_keg_only_formula = formula.present? && formula.keg_only_reason&.versioned_formula? if keg.linked? opoo "Already linked: #{keg}" name_and_flag = +"" name_and_flag << "--HEAD " if args.HEAD? name_and_flag << "--force " if keg_only && !versioned_keg_only_formula name_and_flag << keg.name puts <<~EOS To relink, run: brew unlink #{keg.name} && brew link #{name_and_flag} EOS next end if args.dry_run? if args.overwrite? puts "Would remove:" else puts "Would link:" end keg.link(**options) puts_keg_only_path_message(keg) if keg_only && !versioned_keg_only_formula next end if keg_only if HOMEBREW_PREFIX.to_s == HOMEBREW_DEFAULT_PREFIX && formula.present? && formula.keg_only_reason.by_macos? caveats = Caveats.new(formula) opoo <<~EOS Refusing to link macOS provided/shadowed software: #{keg.name} #{T.must(caveats.keg_only_text(skip_reason: true)).strip} EOS next end if !args.force? && (formula.nil? || !formula.keg_only_reason.versioned_formula?) opoo "#{keg.name} is keg-only and must be linked with `--force`." puts_keg_only_path_message(keg) next end end Unlink.unlink_link_overwrite_formulae(formula, verbose: args.verbose?) if formula keg.lock do print "Linking #{keg}... " puts if args.verbose? begin n = keg.link(**options) rescue Keg::LinkError puts raise else puts "#{n} symlinks created." end if keg_only && !versioned_keg_only_formula && !Homebrew::EnvConfig.developer? puts_keg_only_path_message(keg) end end end end private sig { params(keg: Keg).void } def puts_keg_only_path_message(keg) bin = keg/"bin" sbin = keg/"sbin" return if !bin.directory? && !sbin.directory? opt = HOMEBREW_PREFIX/"opt/#{keg.name}" puts "\nIf you need to have this software first in your PATH instead consider running:" puts " #{Utils::Shell.prepend_path_in_profile(opt/"bin")}" if bin.directory? puts " #{Utils::Shell.prepend_path_in_profile(opt/"sbin")}" if sbin.directory? end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/list.rb000066400000000000000000000304421517265720000221520ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "metafiles" require "formula" require "cli/parser" require "cask/list" require "system_command" require "tab" module Homebrew module Cmd class List < AbstractCommand include SystemCommand::Mixin cmd_args do description <<~EOS List all installed formulae and casks. If is provided, summarise the paths within its current keg. If is provided, list its artifacts. EOS switch "--formula", "--formulae", description: "List only formulae, or treat all named arguments as formulae." switch "--cask", "--casks", description: "List only casks, or treat all named arguments as casks." switch "--full-name", description: "Print formulae with fully-qualified names. Unless `--full-name`, `--versions` " \ "or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are " \ "passed to `ls`(1) which produces the actual output." switch "--versions", description: "Show the version number for installed formulae, or only the specified " \ "formulae if are provided." switch "--multiple", depends_on: "--versions", description: "Only show formulae with multiple versions installed." switch "--pinned", description: "List only pinned formulae, or only the specified (pinned) " \ "formulae if are provided. See also `pin`, `unpin`." switch "--installed-on-request", description: "List the formulae installed on request." switch "--installed-as-dependency", description: "List the formulae installed as dependencies." switch "--poured-from-bottle", description: "List the formulae installed from a bottle." switch "--built-from-source", description: "List the formulae compiled from source." # passed through to ls switch "-1", description: "Force output to be one entry per line. " \ "This is the default when output is not to a terminal." switch "-l", description: "List formulae and/or casks in long format. " \ "Has no effect when a formula or cask name is passed as an argument." switch "-r", description: "Reverse the order of formula and/or cask sorting to list the oldest entries first. " \ "Has no effect when a formula or cask name is passed as an argument." switch "-t", description: "Sort formulae and/or casks by time modified, listing most recently modified first. " \ "Has no effect when a formula or cask name is passed as an argument." conflicts "--formula", "--cask" conflicts "--pinned", "--cask" conflicts "--multiple", "--cask" conflicts "--pinned", "--multiple" ["--installed-on-request", "--installed-as-dependency", "--poured-from-bottle", "--built-from-source"].each do |flag| conflicts "--cask", flag conflicts "--versions", flag conflicts "--pinned", flag conflicts "-l", flag end ["-1", "-l", "-r", "-t"].each do |flag| conflicts "--versions", flag conflicts "--pinned", flag end ["--versions", "--pinned", "-l", "-r", "-t"].each do |flag| conflicts "--full-name", flag end named_args [:installed_formula, :installed_cask] end sig { override.void } def run if args.full_name? && !(args.installed_on_request? || args.installed_as_dependency? || args.poured_from_bottle? || args.built_from_source?) unless args.cask? formula_names = args.no_named? ? Formula.installed : args.named.to_resolved_formulae full_formula_names = formula_names.map(&:full_name).sort(&Cask::List::TAP_AND_NAME_COMPARISON) full_formula_names = Formatter.columns(full_formula_names) unless args.public_send(:"1?") puts full_formula_names if full_formula_names.present? end if args.cask? || (!args.formula? && args.no_named?) cask_names = if args.no_named? Cask::Caskroom.casks else args.named.to_formulae_and_casks(only: :cask, method: :resolve) end # The cast is because `Keg`` does not define `full_name` full_cask_names = T.cast(cask_names, T::Array[T.any(Formula, Cask::Cask)]) .map(&:full_name).sort(&Cask::List::TAP_AND_NAME_COMPARISON) full_cask_names = Formatter.columns(full_cask_names) unless args.public_send(:"1?") puts full_cask_names if full_cask_names.present? end elsif args.pinned? filtered_list elsif args.versions? filtered_list unless args.cask? list_casks if args.cask? || (!args.formula? && !args.multiple? && args.no_named?) elsif args.installed_on_request? || args.installed_as_dependency? || args.poured_from_bottle? || args.built_from_source? flags = [] flags << "`--installed-on-request`" if args.installed_on_request? flags << "`--installed-as-dependency`" if args.installed_as_dependency? flags << "`--poured-from-bottle`" if args.poured_from_bottle? flags << "`--built-from-source`" if args.built_from_source? raise UsageError, "Cannot use #{flags.join(", ")} with formula arguments." unless args.no_named? formulae = if args.t? # See https://ruby-doc.org/3.2/Kernel.html#method-i-test Formula.installed.sort_by { |formula| T.cast(test("M", formula.rack.to_s), Time) }.reverse! elsif args.full_name? Formula.installed.sort { |a, b| Cask::List::TAP_AND_NAME_COMPARISON.call(a.full_name, b.full_name) } else Formula.installed.sort end formulae.reverse! if args.r? formulae.each do |formula| tab = Tab.for_formula(formula) statuses = [] statuses << "installed on request" if args.installed_on_request? && tab.installed_on_request statuses << "installed as dependency" if args.installed_as_dependency? && tab.installed_as_dependency statuses << "poured from bottle" if args.poured_from_bottle? && tab.poured_from_bottle statuses << "built from source" if args.built_from_source? && !tab.poured_from_bottle next if statuses.empty? name = args.full_name? ? formula.full_name : formula.name if flags.count > 1 puts "#{name}: #{statuses.join(", ")}" else puts name end end elsif args.no_named? ENV["CLICOLOR"] = nil ls_args = [] ls_args << "-1" if args.public_send(:"1?") ls_args << "-l" if args.l? ls_args << "-r" if args.r? ls_args << "-t" if args.t? if !args.cask? && HOMEBREW_CELLAR.exist? && HOMEBREW_CELLAR.children.any? ohai "Formulae" if $stdout.tty? && !args.formula? system_command! "ls", args: [*ls_args, HOMEBREW_CELLAR], print_stdout: true puts if $stdout.tty? && !args.formula? end if !args.formula? && Cask::Caskroom.any_casks_installed? ohai "Casks" if $stdout.tty? && !args.cask? system_command! "ls", args: [*ls_args, Cask::Caskroom.path], print_stdout: true end else kegs, casks = args.named.to_kegs_to_casks if args.verbose? || !$stdout.tty? find_args = %w[-not -type d -not -name .DS_Store -print] system_command! "find", args: kegs.map(&:to_s) + find_args, print_stdout: true if kegs.present? system_command! "find", args: casks.map(&:caskroom_path) + find_args, print_stdout: true if casks.present? else kegs.each { |keg| PrettyListing.new keg } if kegs.present? Cask::List.list_casks(*casks, one: args.public_send(:"1?")) if casks.present? end end end private sig { void } def filtered_list names = if args.no_named? Formula.racks else racks = args.named.map { |n| Formulary.to_rack(n) } racks.select do |rack| Homebrew.failed = true unless rack.exist? rack.exist? end end if args.pinned? pinned_versions = {} names.sort.each do |d| keg_pin = (HOMEBREW_PINNED_KEGS/d.basename.to_s) pinned_versions[d] = keg_pin.readlink.basename.to_s if keg_pin.exist? || keg_pin.symlink? end pinned_versions.each do |d, version| puts d.basename.to_s.concat(args.versions? ? " #{version}" : "") end else # --versions without --pinned names.sort.each do |d| versions = d.subdirs.map { |pn| pn.basename.to_s } next if args.multiple? && versions.length < 2 puts "#{d.basename} #{versions * " "}" end end end sig { void } def list_casks casks = if args.no_named? cask_paths = Cask::Caskroom.path.children.reject(&:file?).map do |path| if path.symlink? real_path = path.realpath real_path.basename.to_s else path.basename.to_s end end.uniq.sort cask_paths.map { |name| Cask::CaskLoader.load(name) } else filtered_args = args.named.dup.delete_if do |n| Homebrew.failed = true unless Cask::Caskroom.path.join(n).exist? !Cask::Caskroom.path.join(n).exist? end # NamedAargs subclasses array T.cast(filtered_args, Homebrew::CLI::NamedArgs).to_formulae_and_casks(only: :cask) end return if casks.blank? Cask::List.list_casks( *casks, one: args.public_send(:"1?"), full_name: args.full_name?, versions: args.versions?, ) end end class PrettyListing sig { params(path: T.any(String, Pathname, Keg)).void } def initialize(path) valid_lib_extensions = [".dylib", ".pc"] Pathname.new(path).children.sort_by { |p| p.to_s.downcase }.each do |pn| case pn.basename.to_s when "bin", "sbin" pn.find { |pnn| puts pnn unless pnn.directory? } when "lib" print_dir pn do |pnn| # dylibs have multiple symlinks and we don't care about them valid_lib_extensions.include?(pnn.extname) && !pnn.symlink? end when ".brew" next # Ignore .brew else if pn.directory? if pn.symlink? puts "#{pn} -> #{pn.readlink}" else print_dir pn end elsif Metafiles.list?(pn.basename.to_s) puts pn end end end end private sig { params(root: Pathname, block: T.nilable(T.proc.params(arg0: Pathname).returns(T::Boolean))).void } def print_dir(root, &block) dirs = [] remaining_root_files = [] other = "" root.children.sort.each do |pn| if pn.directory? dirs << pn elsif block && yield(pn) puts pn other = "other " elsif pn.basename.to_s != ".DS_Store" remaining_root_files << pn end end dirs.each do |d| files = [] d.find { |pn| files << pn unless pn.directory? } print_remaining_files files, d end print_remaining_files remaining_root_files, root, other end sig { params(files: T::Array[Pathname], root: Pathname, other: String).void } def print_remaining_files(files, root, other = "") if files.length == 1 puts files elsif files.length > 1 puts "#{root}/ (#{files.length} #{other}files)" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/log.rb000066400000000000000000000054731517265720000217660ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "fileutils" module Homebrew module Cmd class Log < AbstractCommand include FileUtils cmd_args do description <<~EOS Show the `git log` for or , or show the log for the Homebrew repository if no formula or cask is provided. EOS switch "-p", "-u", "--patch", description: "Also print patch from commit." switch "--stat", description: "Also print diffstat from commit." switch "--oneline", description: "Print only one line per commit." switch "-1", description: "Print only one commit." flag "-n", "--max-count=", description: "Print only a specified number of commits." switch "--formula", "--formulae", description: "Treat all named arguments as formulae." switch "--cask", "--casks", description: "Treat all named arguments as casks." conflicts "-1", "--max-count" conflicts "--formula", "--cask" named_args [:formula, :cask], max: 1, without_api: true end sig { override.void } def run # As this command is simplifying user-run commands then let's just use a # user path, too. ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s if args.no_named? git_log(HOMEBREW_REPOSITORY) else path = args.named.to_paths.fetch(0) tap = Tap.from_path(path) git_log path.dirname, path, tap end end private sig { params(cd_dir: Pathname, path: T.nilable(Pathname), tap: T.nilable(Tap)).void } def git_log(cd_dir, path = nil, tap = nil) cd cd_dir do repo = Utils.popen_read("git", "rev-parse", "--show-toplevel").chomp if tap name = tap.to_s git_cd = "$(brew --repo #{tap})" elsif cd_dir == HOMEBREW_REPOSITORY name = "Homebrew/brew" git_cd = "$(brew --repo)" else name, git_cd = cd_dir end if File.exist? "#{repo}/.git/shallow" opoo <<~EOS #{name} is a shallow clone so only partial output will be shown. To get a full clone, run: git -C "#{git_cd}" fetch --unshallow EOS end git_args = [] git_args << "--patch" if args.patch? git_args << "--stat" if args.stat? git_args << "--oneline" if args.oneline? git_args << "-1" if args.public_send(:"1?") git_args << "--max-count" << args.max_count if args.max_count git_args += ["--follow", "--", path] if path&.file? system "git", "log", *git_args end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/mcp-server.rb000066400000000000000000000012341517265720000232570ustar00rootroot00000000000000# typed: strong # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class McpServerCmd < AbstractCommand # This is a shell command as MCP servers need a faster startup time # than a normal Homebrew Ruby command allows. include ShellCommand cmd_args do description <<~EOS Starts the Homebrew MCP (Model Context Protocol) server. EOS switch "-d", "--debug", description: "Enable debug logging to stderr." switch "--ping", description: "Start the server, act as if receiving a ping and then exit.", hidden: true end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/mcp-server.sh000066400000000000000000000010211517265720000232600ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/mcp-server.rb # This is a shell command as MCP servers need a faster startup time # than a normal Homebrew Ruby command allows. # HOMEBREW_LIBRARY is set by brew.sh # HOMEBREW_BREW_FILE is set by extend/ENV/super.rb # shellcheck disable=SC2154 homebrew-mcp-server() { source "${HOMEBREW_LIBRARY}/Homebrew/utils/ruby.sh" setup-ruby-path export HOMEBREW_VERSION "${HOMEBREW_RUBY_PATH}" "-r${HOMEBREW_LIBRARY}/Homebrew/mcp_server.rb" -e "Homebrew::McpServer.new.run" "$@" } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/migrate.rb000066400000000000000000000026111517265720000226240ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "migrator" require "cask/migrator" module Homebrew module Cmd class Migrate < AbstractCommand cmd_args do description <<~EOS Migrate renamed packages to new names, where are old names of packages. EOS switch "-f", "--force", description: "Treat installed and provided as if they are from " \ "the same taps and migrate them anyway." switch "-n", "--dry-run", description: "Show what would be migrated, but do not actually migrate anything." switch "--formula", "--formulae", description: "Only migrate formulae." switch "--cask", "--casks", description: "Only migrate casks." conflicts "--formula", "--cask" named_args [:installed_formula, :installed_cask], min: 1 end sig { override.void } def run args.named.to_formulae_and_casks(warn: false).each do |formula_or_cask| case formula_or_cask when Formula Migrator.migrate_if_needed(formula_or_cask, force: args.force?, dry_run: args.dry_run?) when Cask::Cask Cask::Migrator.migrate_if_needed(formula_or_cask, dry_run: args.dry_run?) end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/missing.rb000066400000000000000000000022601517265720000226450ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "diagnostic" module Homebrew module Cmd class Missing < AbstractCommand cmd_args do description <<~EOS Check the given kegs for missing dependencies. If no are provided, check all kegs. Will exit with a non-zero status if any kegs are found to be missing dependencies. EOS comma_array "--hide", description: "Act as if none of the specified are installed. should be " \ "a comma-separated list of formulae." named_args :formula end sig { override.void } def run return unless HOMEBREW_CELLAR.exist? ff = if args.no_named? Formula.installed.sort else args.named.to_resolved_formulae.sort end ff.each do |f| missing = f.missing_dependencies(hide: args.hide || []) next if missing.empty? Homebrew.failed = true print "#{f}: " if ff.size > 1 puts missing.join(" ") end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/nodenv-sync.rb000066400000000000000000000050441517265720000234420ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "fileutils" require "keg" module Homebrew module Cmd class NodenvSync < AbstractCommand cmd_args do description <<~EOS Create symlinks for Homebrew's installed NodeJS versions in `~/.nodenv/versions`. Note that older version symlinks will also be created so e.g. NodeJS 19.1.0 will also be symlinked to 19.0.0. EOS named_args :none end sig { override.void } def run nodenv_root = Pathname(ENV.fetch("HOMEBREW_NODENV_ROOT", Pathname(Dir.home)/".nodenv")) # Don't run multiple times at once. nodenv_sync_running = nodenv_root/".nodenv_sync_running" return if nodenv_sync_running.exist? begin nodenv_versions = nodenv_root/"versions" nodenv_versions.mkpath FileUtils.touch nodenv_sync_running HOMEBREW_CELLAR.glob("node{,@*}") .flat_map(&:children) .each { |path| link_nodenv_versions(path, nodenv_versions) } nodenv_versions.children .select(&:symlink?) .reject(&:exist?) .each { |path| FileUtils.rm_f path } ensure nodenv_sync_running.unlink if nodenv_sync_running.exist? end end private sig { params(path: Pathname, nodenv_versions: Pathname).void } def link_nodenv_versions(path, nodenv_versions) nodenv_versions.mkpath version = Keg.new(path).version major_version = version.major.to_i minor_version = version.minor.to_i patch_version = version.patch.to_i minor_version_range, patch_version_range = if Homebrew::EnvConfig.env_sync_strict? # Only create symlinks for the exact installed patch version. # e.g. 23.9.0 => 23.9.0 [[minor_version], [patch_version]] else # Create folder symlinks for all patch versions to the latest patch version # e.g. 23.9.0 => 23.10.1 [0..minor_version, 0..patch_version] end minor_version_range.each do |minor| patch_version_range.each do |patch| link_path = nodenv_versions/"#{major_version}.#{minor}.#{patch}" # Don't clobber existing user installations. next if link_path.exist? && !link_path.symlink? FileUtils.rm_f link_path FileUtils.ln_s path, link_path end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/options.rb000066400000000000000000000042331517265720000226710ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "options" module Homebrew module Cmd class OptionsCmd < AbstractCommand cmd_args do description <<~EOS Show install options specific to . EOS switch "--compact", description: "Show all options on a single line separated by spaces." switch "--installed", description: "Show options for formulae that are currently installed." switch "--eval-all", description: "Evaluate all available formulae and casks, whether installed or not, to show their " \ "options.", env: :eval_all flag "--command=", description: "Show options for the specified ." conflicts "--command", "--installed", "--eval-all" named_args :formula end sig { override.void } def run eval_all = args.eval_all? if eval_all puts_options(Formula.all(eval_all:).sort) elsif args.installed? puts_options(Formula.installed.sort) elsif args.command.present? cmd_options = Commands.command_options(T.must(args.command)) odie "Unknown command: brew #{args.command}" if cmd_options.nil? if args.compact? puts cmd_options.sort.map(&:first) * " " else cmd_options.sort.each { |option, desc| puts "#{option}\n\t#{desc}" } puts end elsif args.no_named? raise UsageError, "`brew options` needs a formula or `--eval-all` passed or `HOMEBREW_EVAL_ALL=1` set!" else puts_options args.named.to_formulae end end private sig { params(formulae: T::Array[Formula]).void } def puts_options(formulae) formulae.each do |f| next if f.options.empty? if args.compact? puts f.options.as_flags.sort * " " else puts f.full_name if formulae.length > 1 Options.dump_for_formula f puts end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/outdated.rb000066400000000000000000000217241517265720000230130ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "cask/caskroom" require "api" module Homebrew module Cmd class Outdated < AbstractCommand cmd_args do description <<~EOS List installed casks and formulae that have an updated version available. By default, version information is displayed in interactive shells and suppressed otherwise. EOS switch "-q", "--quiet", description: "List only the names of outdated kegs (takes precedence over `--verbose`)." switch "-v", "--verbose", description: "Include detailed version information." switch "--formula", "--formulae", description: "List only outdated formulae." switch "--cask", "--casks", description: "List only outdated casks." flag "--json", description: "Print output in JSON format. There are two versions: `v1` and `v2`. " \ "`v1` is deprecated and is currently the default if no version is specified. " \ "`v2` prints outdated formulae and casks." switch "--fetch-HEAD", description: "Fetch the upstream repository to detect if the HEAD installation of the " \ "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \ "updates when a new stable or development version has been released." switch "-g", "--greedy", description: "Also include outdated casks with `version :latest` and `auto_updates true` " \ "casks that would otherwise be skipped.", env: :upgrade_greedy switch "--greedy-latest", description: "Also include outdated casks including those with `version :latest`." switch "--greedy-auto-updates", description: "Also include outdated `auto_updates true` casks that would otherwise be skipped." conflicts "--quiet", "--verbose", "--json" conflicts "--formula", "--cask" named_args [:formula, :cask] end sig { override.void } def run case json_version(args.json) when :v1 odie "`brew outdated --json=v1` is no longer supported. Use brew outdated --json=v2 instead." when :v2, :default formulae, casks = if args.formula? [outdated_formulae, []] elsif args.cask? [[], outdated_casks] else outdated_formulae_casks end json = { formulae: json_info(formulae), casks: json_info(casks), } # json v2.8.1 is inconsistent it how it renders empty arrays, # so we use `[]` for consistency: puts JSON.pretty_generate(json).gsub(/\[\n\n\s*\]/, "[]") outdated = formulae + casks else outdated = if args.formula? outdated_formulae elsif args.cask? outdated_casks else outdated_formulae_casks.flatten end print_outdated(outdated) end Homebrew.failed = args.named.present? && outdated.present? end private sig { params(formulae_or_casks: T::Array[T.any(Formula, Cask::Cask)]).void } def print_outdated(formulae_or_casks) formulae_or_casks.each do |formula_or_cask| if formula_or_cask.is_a?(Formula) f = formula_or_cask if verbose? outdated_kegs = f.outdated_kegs(fetch_head: args.fetch_HEAD?) latest_formula = f.latest_formula current_version = if f.alias_changed? && !latest_formula.latest_version_installed? "#{latest_formula.name} (#{latest_formula.pkg_version})" elsif f.head? latest_head_version = f.latest_head_pkg_version(fetch_head: args.fetch_HEAD?) if outdated_kegs.any? { |k| k.version.to_s == latest_head_version.to_s } # There is a newer HEAD but the version number has not changed. "latest HEAD" else latest_head_version.to_s end else latest_formula.pkg_version.to_s end outdated_versions = outdated_kegs.group_by { |keg| Formulary.from_keg(keg).full_name } .sort_by { |full_name, _kegs| full_name } .map do |full_name, kegs| "#{full_name} (#{kegs.map(&:version).join(", ")})" end.join(", ") pinned_version = " [pinned at #{f.pinned_version}]" if f.pinned? puts "#{outdated_versions} < #{current_version}#{pinned_version}" else puts f.full_installed_specified_name end else c = formula_or_cask puts c.outdated_info(upgrade_greedy_cask?(args.greedy?, formula_or_cask), verbose?, false, args.greedy_latest?, args.greedy_auto_updates?) end end end sig { params( formulae_or_casks: T::Array[T.any(Formula, Cask::Cask)], ).returns(T::Array[T::Hash[Symbol, T.untyped]]) } def json_info(formulae_or_casks) formulae_or_casks.map do |formula_or_cask| if formula_or_cask.is_a?(Formula) f = formula_or_cask outdated_versions = f.outdated_kegs(fetch_head: args.fetch_HEAD?).map(&:version) current_version = if f.head? && outdated_versions.any? { |v| v.to_s == f.pkg_version.to_s } "HEAD" else f.pkg_version.to_s end { name: f.full_name, installed_versions: outdated_versions.map(&:to_s), current_version:, pinned: f.pinned?, pinned_version: f.pinned_version } else c = formula_or_cask T.cast( c.outdated_info(upgrade_greedy_cask?(args.greedy?, formula_or_cask), verbose?, true, args.greedy_latest?, args.greedy_auto_updates?), T::Hash[Symbol, T.untyped], ) end end end sig { returns(T::Boolean) } def verbose? ($stdout.tty? || Context.current.verbose?) && !Context.current.quiet? end sig { params(version: T.nilable(T.any(TrueClass, String))).returns(T.nilable(Symbol)) } def json_version(version) version_hash = { nil => nil, true => :default, "v1" => :v1, "v2" => :v2, } version_hash.fetch(version) { raise UsageError, "invalid JSON version: #{version}" } end sig { returns(T::Array[Formula]) } def outdated_formulae T.cast( select_outdated(args.named.to_resolved_formulae.presence || Formula.installed).sort, T::Array[Formula], ) end sig { returns(T::Array[Cask::Cask]) } def outdated_casks outdated = if args.named.present? select_outdated(args.named.to_casks) else select_outdated(Cask::Caskroom.casks) end T.cast(outdated, T::Array[Cask::Cask]) end sig { returns([T::Array[T.any(Formula, Cask::Cask)], T::Array[T.any(Formula, Cask::Cask)]]) } def outdated_formulae_casks formulae, casks = args.named.to_resolved_formulae_to_casks if formulae.blank? && casks.blank? formulae = Formula.installed casks = Cask::Caskroom.casks end [select_outdated(formulae).sort, select_outdated(casks)] end sig { params(formulae_or_casks: T::Array[T.any(Formula, Cask::Cask)]).returns(T::Array[T.any(Formula, Cask::Cask)]) } def select_outdated(formulae_or_casks) formulae_or_casks.select do |formula_or_cask| if formula_or_cask.is_a?(Formula) formula_or_cask.outdated?(fetch_head: args.fetch_HEAD?) else cask_greedy = upgrade_greedy_cask?(args.greedy?, formula_or_cask) next false if formula_or_cask.auto_updates && !cask_greedy && !args.greedy_auto_updates? formula_or_cask.outdated?(greedy: cask_greedy, greedy_latest: args.greedy_latest?, greedy_auto_updates: args.greedy_auto_updates?) end end end sig { params(greedy: T::Boolean, cask: Cask::Cask).returns(T::Boolean) } def upgrade_greedy_cask?(greedy, cask) return true if greedy @greedy_list ||= T.let( begin upgrade_greedy_casks = Homebrew::EnvConfig.upgrade_greedy_casks.presence upgrade_greedy_casks&.split || [] end, T.nilable(T::Array[String]) ) @greedy_list.include?(cask.token) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/pin.rb000066400000000000000000000015531517265720000217660ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" module Homebrew module Cmd class Pin < AbstractCommand cmd_args do description <<~EOS Pin the specified , preventing them from being upgraded when issuing the `brew upgrade` command. See also `unpin`. *Note:* Other packages which depend on newer versions of a pinned formula might not install or run correctly. EOS named_args :installed_formula, min: 1 end sig { override.void } def run args.named.to_resolved_formulae.each do |f| if f.pinned? opoo "#{f.name} already pinned" elsif !f.pinnable? ofail "#{f.name} not installed" else f.pin end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/postinstall.rb000066400000000000000000000014771517265720000235610ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula_installer" module Homebrew module Cmd class Postinstall < AbstractCommand cmd_args do description <<~EOS Rerun the post-install steps for . EOS named_args :installed_formula, min: 1 end sig { override.void } def run args.named.to_resolved_formulae.each do |f| ohai "Postinstalling #{f}" f.install_etc_var if f.post_install_defined? fi = FormulaInstaller.new(f, **{ debug: args.debug?, quiet: args.quiet?, verbose: args.verbose? }.compact) fi.post_install else opoo "#{f}: no `post_install` method was defined in the formula!" end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/pyenv-sync.rb000066400000000000000000000065151517265720000233160ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "fileutils" require "keg" module Homebrew module Cmd class PyenvSync < AbstractCommand cmd_args do description <<~EOS Create symlinks for Homebrew's installed Python versions in `~/.pyenv/versions`. Note that older patch version symlinks will be created and linked to the minor version so e.g. Python 3.11.0 will also be symlinked to 3.11.3. EOS named_args :none end sig { override.void } def run pyenv_root = Pathname(ENV.fetch("HOMEBREW_PYENV_ROOT", Pathname(Dir.home)/".pyenv")) # Don't run multiple times at once. pyenv_sync_running = pyenv_root/".pyenv_sync_running" return if pyenv_sync_running.exist? begin pyenv_versions = pyenv_root/"versions" pyenv_versions.mkpath FileUtils.touch pyenv_sync_running HOMEBREW_CELLAR.glob("python{,@*}") .flat_map(&:children) .each { |path| link_pyenv_versions(path, pyenv_versions) } pyenv_versions.children .select(&:symlink?) .reject(&:exist?) .each { |path| FileUtils.rm_f path } ensure pyenv_sync_running.unlink if pyenv_sync_running.exist? end end private sig { params(path: Pathname, pyenv_versions: Pathname).void } def link_pyenv_versions(path, pyenv_versions) pyenv_versions.mkpath version = Keg.new(path).version major_version = version.major.to_i minor_version = version.minor.to_i patch_version = version.patch.to_i patch_version_range = if Homebrew::EnvConfig.env_sync_strict? # Only create symlinks for the exact installed patch version. # e.g. 3.11.0 => 3.11.0 [patch_version] else # Create folder symlinks for all patch versions to the latest patch version # e.g. 3.11.0 => 3.11.3 0..patch_version end patch_version_range.each do |patch| link_path = pyenv_versions/"#{major_version}.#{minor_version}.#{patch}" # Don't clobber existing user installations. next if link_path.exist? && !link_path.symlink? FileUtils.rm_f link_path FileUtils.ln_s path, link_path # Create an unversioned symlinks # This is what pyenv expects to find in ~/.pyenv/versions/___/bin'. # Without this, `python3`, `pip3` do not exist and pyenv falls back to system Python. # (eg. python3 -> python3.11, pip3 -> pip3.11) executables = %w[python3 pip3 wheel3 idle3 pydoc3] executables.each do |executable| major_link_path = link_path/"bin/#{executable}" # Don't clobber existing user installations. next if major_link_path.exist? && !major_link_path.symlink? executable_link_path = link_path/"bin/#{executable}.#{minor_version}" FileUtils.rm_f major_link_path begin FileUtils.ln_s executable_link_path, major_link_path rescue => e opoo "Failed to link #{executable_link_path} to #{major_link_path}: #{e}" end end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/rbenv-sync.rb000066400000000000000000000046051517265720000232670ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "fileutils" require "keg" module Homebrew module Cmd class RbenvSync < AbstractCommand cmd_args do description <<~EOS Create symlinks for Homebrew's installed Ruby versions in `~/.rbenv/versions`. Note that older version symlinks will also be created so e.g. Ruby 3.2.1 will also be symlinked to 3.2.0. EOS named_args :none end sig { override.void } def run rbenv_root = Pathname(ENV.fetch("HOMEBREW_RBENV_ROOT", Pathname(Dir.home)/".rbenv")) # Don't run multiple times at once. rbenv_sync_running = rbenv_root/".rbenv_sync_running" return if rbenv_sync_running.exist? begin rbenv_versions = rbenv_root/"versions" rbenv_versions.mkpath FileUtils.touch rbenv_sync_running HOMEBREW_CELLAR.glob("ruby{,@*}") .flat_map(&:children) .each { |path| link_rbenv_versions(path, rbenv_versions) } rbenv_versions.children .select(&:symlink?) .reject(&:exist?) .each { |path| FileUtils.rm_f path } ensure rbenv_sync_running.unlink if rbenv_sync_running.exist? end end private sig { params(path: Pathname, rbenv_versions: Pathname).void } def link_rbenv_versions(path, rbenv_versions) rbenv_versions.mkpath version = Keg.new(path).version major_version = version.major.to_i minor_version = version.minor.to_i patch_version = version.patch.to_i patch_version_range = if Homebrew::EnvConfig.env_sync_strict? # Only create symlinks for the exact installed patch version. # e.g. 3.4.0 => 3.4.0 [patch_version] else # Create folder symlinks for all patch versions to the latest patch version # e.g. 3.4.0 => 3.4.2 0..patch_version end patch_version_range.each do |patch| link_path = rbenv_versions/"#{major_version}.#{minor_version}.#{patch}" # Don't clobber existing user installations. next if link_path.exist? && !link_path.symlink? FileUtils.rm_f link_path FileUtils.ln_s path, link_path end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/readall.rb000066400000000000000000000046111517265720000226020ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "readall" require "env_config" module Homebrew module Cmd class ReadallCmd < AbstractCommand cmd_args do description <<~EOS Import all items from the specified , or from all installed taps if none is provided. This can be useful for debugging issues across all items when making significant changes to `formula.rb`, testing the performance of loading all items or checking if any current formulae/casks have Ruby issues. EOS flag "--os=", description: "Read using the given operating system. (Pass `all` to simulate all operating systems.)" flag "--arch=", description: "Read using the given CPU architecture. (Pass `all` to simulate all architectures.)" switch "--aliases", description: "Verify any alias symlinks in each tap." switch "--syntax", description: "Syntax-check all of Homebrew's Ruby files (if no is passed)." switch "--eval-all", description: "Evaluate all available formulae and casks, whether installed or not.", env: :eval_all switch "--no-simulate", description: "Don't simulate other system configurations when checking formulae and casks." named_args :tap end sig { override.void } def run Homebrew.with_no_api_env do if args.syntax? && args.no_named? scan_files = "#{HOMEBREW_LIBRARY_PATH}/**/*.rb" ruby_files = Dir.glob(scan_files).grep_v(%r{/(vendor)/}) Homebrew.failed = true unless Readall.valid_ruby_syntax?(ruby_files) end options = { aliases: args.aliases?, no_simulate: args.no_simulate?, } options[:os_arch_combinations] = args.os_arch_combinations if args.os || args.arch taps = if args.no_named? unless args.eval_all? raise UsageError, "`brew readall` needs a tap or `--eval-all` passed or `HOMEBREW_EVAL_ALL=1` set!" end Tap.installed else args.named.to_installed_taps end taps.each do |tap| Homebrew.failed = true unless Readall.valid_tap?(tap, **options) end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/reinstall.rb000066400000000000000000000267371517265720000232100ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula_installer" require "development_tools" require "messages" require "install" require "reinstall" require "cleanup" require "cask/utils" require "cask/reinstall" require "upgrade" require "api" module Homebrew module Cmd class Reinstall < AbstractCommand cmd_args do description <<~EOS Uninstall and then reinstall a or using the same options it was originally installed with, plus any appended options specific to a . Unless `$HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for outdated dependents and dependents with broken linkage, respectively. Unless `$HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the reinstalled formulae or, every 30 days, for all formulae. EOS switch "-d", "--debug", description: "If brewing fails, open an interactive debugging session with access to IRB " \ "or a shell inside the temporary build directory." switch "--display-times", description: "Print install times for each package at the end of the run.", env: :display_install_times switch "-f", "--force", description: "Install without checking for previously installed keg-only or " \ "non-migrated versions." switch "-v", "--verbose", description: "Print the verification and post-install steps." switch "--ask", description: "Ask for confirmation before downloading and upgrading formulae. " \ "Print download, install and net install sizes of bottles and dependencies.", env: :ask [ [:switch, "--formula", "--formulae", { description: "Treat all named arguments as formulae.", }], [:switch, "-s", "--build-from-source", { description: "Compile from source even if a bottle is available.", }], [:switch, "-i", "--interactive", { description: "Download and patch , then open a shell. This allows the user to " \ "run `./configure --help` and otherwise determine how to turn the software " \ "package into a Homebrew package.", }], [:switch, "--force-bottle", { description: "Install from a bottle if it exists for the current or newest version of " \ "macOS, even if it would not normally be used for installation.", }], [:switch, "--keep-tmp", { description: "Retain the temporary files created during installation.", }], [:switch, "--debug-symbols", { depends_on: "--build-from-source", description: "Generate debug symbols on build. Source will be retained in a cache directory.", }], [:switch, "-g", "--git", { description: "Create a Git repository, useful for creating patches to the software.", }], ].each do |args| options = args.pop send(*args, **options) conflicts "--cask", args.last end formula_options [ [:switch, "--cask", "--casks", { description: "Treat all named arguments as casks.", }], [:switch, "--[no-]binaries", { description: "Disable/enable linking of helper executables (default: enabled).", env: :cask_opts_binaries, }], [:switch, "--require-sha", { description: "Require all casks to have a checksum.", env: :cask_opts_require_sha, }], [:switch, "--[no-]quarantine", { env: :cask_opts_quarantine, odisabled: true, }], [:switch, "--adopt", { description: "Adopt existing artifacts in the destination that are identical to those being installed. " \ "Cannot be combined with `--force`.", }], [:switch, "--skip-cask-deps", { description: "Skip installing cask dependencies.", }], [:switch, "--zap", { description: "For use with `brew reinstall --cask`. Remove all files associated with a cask. " \ "*May remove files which are shared between applications.*", }], ].each do |args| options = args.pop send(*args, **options) conflicts "--formula", args.last end cask_options conflicts "--build-from-source", "--force-bottle" named_args [:formula, :cask], min: 1 end sig { override.void } def run formulae = T.let([], T::Array[Formula]) casks = T.let([], T::Array[Cask::Cask]) unavailable_errors = T.let( [], T::Array[T.any(FormulaOrCaskUnavailableError, NoSuchKegError)], ) args.named.to_formulae_and_casks_and_unavailable(method: :resolve).each do |item| case item when FormulaOrCaskUnavailableError, NoSuchKegError unavailable_errors << item when Formula formulae << item when Cask::Cask casks << item end end if args.build_from_source? unless DevelopmentTools.installed? raise BuildFlagsError.new(["--build-from-source"], bottled: formulae.all?(&:bottled?)) end unless Homebrew::EnvConfig.developer? opoo "building from source is not supported!" puts "You're on your own. Failures are expected so don't create any issues, please!" end end formulae = Homebrew::Attestation.sort_formulae_for_install(formulae) if Homebrew::Attestation.enabled? shared_download_queue = T.let(nil, T.nilable(Homebrew::DownloadQueue)) casks_prefetched = T.let(false, T::Boolean) unless formulae.empty? Install.perform_preinstall_checks_once reinstall_contexts = formulae.filter_map do |formula| if formula.pinned? onoe "#{formula.full_name} is pinned. You must unpin it to reinstall." next end Migrator.migrate_if_needed(formula, force: args.force?) Homebrew::Reinstall.build_install_context( formula.latest_formula, flags: args.flags_only, force_bottle: args.force_bottle?, build_from_source_formulae: args.build_from_source_formulae, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose?, git: args.git?, ) end dependants = Upgrade.dependants( formulae, flags: args.flags_only, ask: args.ask?, force_bottle: args.force_bottle?, build_from_source_formulae: args.build_from_source_formulae, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose?, ) formulae_installers = reinstall_contexts.map(&:formula_installer) # Main block: if asking the user is enabled, show dependency and size information. Install.ask_formulae(formulae_installers, dependants, args: args) if args.ask? valid_formula_installers = if casks.any? shared_download_queue = Homebrew::DownloadQueue.new(pour: true) begin Install.show_combined_fetch_downloads_heading( formula_names: formulae_installers.map { |fi| fi.formula.name }, cask_names: casks.map(&:full_name), ) valid_formula_installers = Install.enqueue_formulae(formulae_installers, download_queue: shared_download_queue) require "cask/installer" fetch_cask_installers = casks.map do |cask| Cask::Installer.new( cask, binaries: args.binaries?, verbose: args.verbose?, force: args.force?, skip_cask_deps: args.skip_cask_deps?, require_sha: args.require_sha?, reinstall: true, quarantine: args.quarantine?, zap: args.zap?, download_queue: shared_download_queue, defer_fetch: true, ) end Install.enqueue_cask_installers(fetch_cask_installers) shared_download_queue.fetch casks_prefetched = true valid_formula_installers ensure shared_download_queue.shutdown end else Install.fetch_formulae(formulae_installers) end exit 1 if Homebrew.failed? reinstall_contexts.each do |reinstall_context| next unless valid_formula_installers.include?(reinstall_context.formula_installer) Homebrew::Reinstall.reinstall_formula(reinstall_context) Cleanup.install_formula_clean!(reinstall_context.formula) end Upgrade.upgrade_dependents( dependants, formulae, flags: args.flags_only, force_bottle: args.force_bottle?, build_from_source_formulae: args.build_from_source_formulae, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose? ) end if casks.any? Install.ask_casks casks if args.ask? begin Cask::Reinstall.reinstall_casks( *casks, binaries: args.binaries?, verbose: args.verbose?, force: args.force?, require_sha: args.require_sha?, skip_cask_deps: args.skip_cask_deps?, quarantine: args.quarantine?, zap: args.zap?, skip_prefetch: casks_prefetched, download_queue: nil, ) rescue => e ofail e end end unavailable_errors.each { |e| ofail e } Cleanup.periodic_clean! Homebrew.messages.display_messages(display_times: args.display_times?) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/search.rb000066400000000000000000000136771517265720000224570ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "missing_formula" require "search" module Homebrew module Cmd class SearchCmd < AbstractCommand PACKAGE_MANAGERS = T.let({ alpine: ->(query) { "https://pkgs.alpinelinux.org/packages?name=#{query}" }, repology: ->(query) { "https://repology.org/projects/?search=#{query}" }, macports: ->(query) { "https://ports.macports.org/search/?q=#{query}" }, fink: ->(query) { "https://pdb.finkproject.org/pdb/browse.php?summary=#{query}" }, opensuse: ->(query) { "https://software.opensuse.org/search?q=#{query}" }, fedora: ->(query) { "https://packages.fedoraproject.org/search?query=#{query}" }, archlinux: ->(query) { "https://archlinux.org/packages/?q=#{query}" }, debian: lambda { |query| "https://packages.debian.org/search?keywords=#{query}&searchon=names&suite=all§ion=all" }, ubuntu: lambda { |query| "https://packages.ubuntu.com/search?keywords=#{query}&searchon=names&suite=all§ion=all" }, }.freeze, T::Hash[Symbol, T.proc.params(query: String).returns(String)]) cmd_args do description <<~EOS Perform a substring search of cask tokens and formula names for . If is flanked by slashes, it is interpreted as a regular expression. EOS switch "--formula", "--formulae", description: "Search for formulae." switch "--cask", "--casks", description: "Search for casks." switch "--desc", description: "Search for formulae with a description matching and casks with " \ "a name or description matching ." switch "--eval-all", description: "Evaluate all available formulae and casks, whether installed or not, to search their " \ "descriptions.", env: :eval_all switch "--pull-request", description: "Search for GitHub pull requests containing ." switch "--open", depends_on: "--pull-request", description: "Search for only open GitHub pull requests." switch "--closed", depends_on: "--pull-request", description: "Search for only closed GitHub pull requests." package_manager_switches = PACKAGE_MANAGERS.keys.map { |name| "--#{name}" } package_manager_switches.each do |s| switch s, description: "Search for in the given database." end conflicts "--desc", "--pull-request" conflicts "--open", "--closed" conflicts(*package_manager_switches) named_args :text_or_regex, min: 1 end sig { override.void } def run return if search_package_manager! query = args.named.join(" ") string_or_regex = Search.query_regexp(query) if args.desc? if !args.eval_all? && Homebrew::EnvConfig.no_install_from_api? raise UsageError, "`brew search --desc` needs `--eval-all` passed or `HOMEBREW_EVAL_ALL=1` set!" end Search.search_descriptions(string_or_regex, args) elsif args.pull_request? search_pull_requests(query) else formulae, casks = Search.search_names(string_or_regex, args) print_results(formulae, casks, query) end puts "Use `brew desc` to list packages with a short description." if args.verbose? print_regex_help end private sig { void } def print_regex_help return unless $stdout.tty? metacharacters = %w[\\ | ( ) [ ] { } ^ $ * + ?].freeze return unless metacharacters.any? do |char| args.named.any? do |arg| arg.include?(char) && !arg.start_with?("/") end end opoo <<~EOS Did you mean to perform a regular expression search? Surround your query with /slashes/ to search locally by regex. EOS end sig { returns(T::Boolean) } def search_package_manager! package_manager = PACKAGE_MANAGERS.find { |name,| args.public_send(:"#{name}?") } return false if package_manager.nil? _, url = package_manager exec_browser url.call(URI.encode_www_form_component(args.named.join(" "))) true end sig { params(query: String).void } def search_pull_requests(query) only = if args.open? && !args.closed? "open" elsif args.closed? && !args.open? "closed" end GitHub.print_pull_requests_matching(query, only) end sig { params(all_formulae: T::Array[String], all_casks: T::Array[String], query: String).void } def print_results(all_formulae, all_casks, query) count = all_formulae.size + all_casks.size if all_formulae.any? if $stdout.tty? ohai "Formulae", Formatter.columns(all_formulae) else puts all_formulae end end puts if all_formulae.any? && all_casks.any? if all_casks.any? if $stdout.tty? ohai "Casks", Formatter.columns(all_casks) else puts all_casks end end print_missing_formula_help(query, count.positive?) if all_casks.exclude?(query) odie "No formulae or casks found for #{query.inspect}." if count.zero? end sig { params(query: String, found_matches: T::Boolean).void } def print_missing_formula_help(query, found_matches) return unless $stdout.tty? return if query.match?(Search::QUERY_REGEX) reason = MissingFormula.reason(query, silent: true) return if reason.nil? if found_matches puts puts "If you meant #{query.inspect} specifically:" end puts reason end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/services.rb000066400000000000000000000207431517265720000230250ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "services/system" require "services/commands/list" require "services/commands/cleanup" require "services/commands/info" require "services/commands/restart" require "services/commands/run" require "services/commands/start" require "services/commands/stop" require "services/commands/kill" module Homebrew module Cmd class Services < AbstractCommand cmd_args do usage_banner <<~EOS `services` [] Manage background services with macOS' `launchctl`(1) daemon manager or Linux's `systemctl`(1) service manager. If `sudo` is passed, operate on `/Library/LaunchDaemons` or `/usr/lib/systemd/system` (started at boot). Otherwise, operate on `~/Library/LaunchAgents` or `~/.config/systemd/user` (started at login). [`sudo`] `brew services` [`list`] [`--json`] [`--debug`]: List information about all managed services for the current user (or root). Provides more output from Homebrew and `launchctl`(1) or `systemctl`(1) if run with `--debug`. [`sudo`] `brew services info` (|`--all`) [`--json`]: List all managed services for the current user (or root). [`sudo`] `brew services run` (|`--all`) [`--file=`]: Run the service without registering to launch at login (or boot). [`sudo`] `brew services start` (|`--all`) [`--file=`]: Start the service immediately and register it to launch at login (or boot). [`sudo`] `brew services stop` [`--keep`] [`--no-wait`|`--max-wait=`] (|`--all`): Stop the service immediately and unregister it from launching at login (or boot), unless `--keep` is specified. [`sudo`] `brew services kill` (|`--all`): Stop the service immediately but keep it registered to launch at login (or boot). [`sudo`] `brew services restart` (|`--all`) [`--file=`]: Stop (if necessary) and start the service immediately and register it to launch at login (or boot). [`sudo`] `brew services cleanup`: Remove all unused services. EOS flag "--file=", description: "Use the service file from this location to `start` the service." flag "--sudo-service-user=", description: "When run as root on macOS, run the service(s) as this user." flag "--max-wait=", description: "Wait at most this many seconds for `stop` to finish stopping a service. " \ "Defaults to 60. Set this to zero (0) seconds to wait indefinitely." switch "--no-wait", description: "Don't wait for `stop` to finish stopping the service." switch "--keep", description: "When stopped, don't unregister the service from launching at login (or boot)." switch "--all", description: "Run on all services." switch "--json", description: "Output as JSON." conflicts "--all", "--file" conflicts "--max-wait", "--no-wait" named_args %w[list info run start stop kill restart cleanup] end sig { override.void } def run # pbpaste's exit status is a proxy for detecting the use of reattach-to-user-namespace if ENV.fetch("HOMEBREW_TMUX", nil) && File.exist?("/usr/bin/pbpaste") && !quiet_system("/usr/bin/pbpaste") raise UsageError, "`brew services` cannot run under tmux!" end # Keep this after the .parse to keep --help fast. require "utils" if !Homebrew::Services::System.launchctl? && !Homebrew::Services::System.systemctl? raise UsageError, Homebrew::Services::System::MISSING_DAEMON_MANAGER_EXCEPTION_MESSAGE end if (sudo_service_user = args.sudo_service_user) unless Homebrew::Services::System.root? raise UsageError, "`brew services` is supported only when running as root!" end unless Homebrew::Services::System.launchctl? raise UsageError, "`brew services --sudo-service-user` is currently supported only on macOS " \ "(but we'd love a PR to add Linux support)!" end Homebrew::Services::Cli.sudo_service_user = sudo_service_user end # Parse arguments. subcommand, *formulae = args.named no_named_formula_commands = [ *Homebrew::Services::Commands::List::TRIGGERS, *Homebrew::Services::Commands::Cleanup::TRIGGERS, ] if no_named_formula_commands.include?(subcommand) raise UsageError, "The `#{subcommand}` subcommand does not accept a formula argument!" if formulae.present? raise UsageError, "The `#{subcommand}` subcommand does not accept the `--all` argument!" if args.all? end if args.file file_commands = [ *Homebrew::Services::Commands::Start::TRIGGERS, *Homebrew::Services::Commands::Run::TRIGGERS, *Homebrew::Services::Commands::Restart::TRIGGERS, ] if file_commands.exclude?(subcommand) raise UsageError, "The `#{subcommand}` subcommand does not accept the `--file=` argument!" end end unless Homebrew::Services::Commands::Stop::TRIGGERS.include?(subcommand) raise UsageError, "The `#{subcommand}` subcommand does not accept the `--keep` argument!" if args.keep? if args.no_wait? raise UsageError, "The `#{subcommand}` subcommand does not accept the `--no-wait` argument!" end if args.max_wait raise UsageError, "The `#{subcommand}` subcommand does not accept the `--max-wait=` argument!" end end opoo "The `--all` argument overrides provided formula argument!" if formulae.present? && args.all? targets = if args.all? if subcommand == "start" Homebrew::Services::Formulae.available_services( loaded: false, skip_root: !Homebrew::Services::System.root?, ) elsif subcommand == "stop" Homebrew::Services::Formulae.available_services( loaded: true, skip_root: !Homebrew::Services::System.root?, ) else Homebrew::Services::Formulae.available_services end elsif formulae.present? formulae.map { |formula| Homebrew::Services::FormulaWrapper.new(Formulary.factory(formula)) } else [] end # Exit successfully if --all was used but there is nothing to do return if args.all? && targets.empty? if Homebrew::Services::System.systemctl? ENV["DBUS_SESSION_BUS_ADDRESS"] = ENV.fetch("HOMEBREW_DBUS_SESSION_BUS_ADDRESS", nil) ENV["XDG_RUNTIME_DIR"] = ENV.fetch("HOMEBREW_XDG_RUNTIME_DIR", nil) end # Dispatch commands and aliases. case subcommand.presence when *Homebrew::Services::Commands::List::TRIGGERS Homebrew::Services::Commands::List.run(json: args.json?) when *Homebrew::Services::Commands::Cleanup::TRIGGERS Homebrew::Services::Commands::Cleanup.run when *Homebrew::Services::Commands::Info::TRIGGERS Homebrew::Services::Commands::Info.run(targets, verbose: args.verbose?, json: args.json?) when *Homebrew::Services::Commands::Restart::TRIGGERS Homebrew::Services::Commands::Restart.run(targets, args.file, verbose: args.verbose?) when *Homebrew::Services::Commands::Run::TRIGGERS Homebrew::Services::Commands::Run.run(targets, args.file, verbose: args.verbose?) when *Homebrew::Services::Commands::Start::TRIGGERS Homebrew::Services::Commands::Start.run(targets, args.file, verbose: args.verbose?) when *Homebrew::Services::Commands::Stop::TRIGGERS Homebrew::Services::Commands::Stop.run( targets, verbose: args.verbose?, no_wait: args.no_wait?, max_wait: args.max_wait&.to_f || 60.0, keep: args.keep?, ) when *Homebrew::Services::Commands::Kill::TRIGGERS Homebrew::Services::Commands::Kill.run(targets, verbose: args.verbose?) else raise UsageError, "unknown subcommand: `#{subcommand}`" end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/setup-ruby.rb000066400000000000000000000006671517265720000233240ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class SetupRuby < AbstractCommand include ShellCommand cmd_args do description <<~EOS Installs and configures Homebrew's Ruby. If `command` is passed, it will only run Bundler if necessary for that command. EOS named_args :command end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/setup-ruby.sh000066400000000000000000000016401517265720000233230ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/setup-ruby.rb # HOMEBREW_LIBRARY is set by brew.sh # HOMEBREW_BREW_FILE is set by extend/ENV/super.rb # shellcheck disable=SC2154 homebrew-setup-ruby() { source "${HOMEBREW_LIBRARY}/Homebrew/utils/helpers.sh" source "${HOMEBREW_LIBRARY}/Homebrew/utils/ruby.sh" setup-ruby-path if [[ -z "${HOMEBREW_DEVELOPER}" ]] then return fi # Avoid running Bundler if the command doesn't need it. local command="$1" if [[ -n "${command}" ]] then source "${HOMEBREW_LIBRARY}/Homebrew/command_path.sh" command_path="$(homebrew-command-path "${command}")" if [[ -n "${command_path}" ]] then if [[ "${command_path}" != *"/dev-cmd/"* ]] then return elif ! grep -q "Homebrew.install_bundler_gems\!" "${command_path}" then return fi fi fi setup-gem-home-bundle-gemfile ensure-bundle-dependencies } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/shellenv.rb000066400000000000000000000024751517265720000230240ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class Shellenv < AbstractCommand include ShellCommand cmd_args do description <<~EOS Valid shells: bash|csh|fish|pwsh|sh|tcsh|zsh Print export statements. When run in a shell, this installation of Homebrew will be added to your `$PATH`, `$MANPATH`, and `$INFOPATH`. The variables `$HOMEBREW_PREFIX`, `$HOMEBREW_CELLAR` and `$HOMEBREW_REPOSITORY` are also exported to avoid querying them multiple times. To help guarantee idempotence, this command produces no output when Homebrew's `bin` and `sbin` directories are first and second respectively in your `$PATH`. Consider adding evaluation of this command's output to your dotfiles (e.g. `~/.bash_profile` or ~/.zprofile` on macOS and ~/.bashrc` or ~/.zshrc` on Linux) with e.g.: `eval "$(brew shellenv zsh)"` or `eval "$(brew shellenv bash)"` The shell should be specified explicitly with a supported shell name parameter but will be detected automatically if not provided (but this may not be correct). Unknown shells will output POSIX exports. EOS named_args :shell end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/shellenv.sh000066400000000000000000000110231517265720000230200ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/shellenv.rb # HOMEBREW_CELLAR and HOMEBREW_PREFIX are set by extend/ENV/super.rb # HOMEBREW_REPOSITORY is set by bin/brew # Leading colon in MANPATH prepends default man dirs to search path in Linux and macOS. # Please do not submit PRs to remove it! # shellcheck disable=SC2154 homebrew-shellenv() { if [[ "${HOMEBREW_PATH%%:"${HOMEBREW_PREFIX}"/sbin*}" == "${HOMEBREW_PREFIX}/bin" ]] then return fi # Use specified shell name parameter, if available. HOMEBREW_SHELL_NAME="${1:-}" # Use the parent process name, if possible. # This is known to fail under some sandboxes. if [[ -z "${HOMEBREW_SHELL_NAME}" ]] then HOMEBREW_SHELL_NAME="$(/bin/ps -p "${PPID}" -c -o comm= 2>/dev/null)" fi # Fall back to the (login) shell name from the environment. if [[ -z "${HOMEBREW_SHELL_NAME}" ]] then HOMEBREW_SHELL_NAME="${SHELL##*/}" fi if [[ -n "${HOMEBREW_MACOS}" ]] && [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "140000" ]] && [[ -x /usr/libexec/path_helper ]] then HOMEBREW_PATHS_FILE="${HOMEBREW_PREFIX}/etc/paths" if [[ ! -f "${HOMEBREW_PATHS_FILE}" ]] then printf '%s/bin\n%s/sbin\n' "${HOMEBREW_PREFIX}" "${HOMEBREW_PREFIX}" 2>/dev/null >"${HOMEBREW_PATHS_FILE}" fi if [[ -r "${HOMEBREW_PATHS_FILE}" ]] then PATH_HELPER_ROOT="${HOMEBREW_PREFIX}" fi fi case "${HOMEBREW_SHELL_NAME}" in fish | -fish) echo "set --global --export HOMEBREW_PREFIX \"${HOMEBREW_PREFIX}\";" echo "set --global --export HOMEBREW_CELLAR \"${HOMEBREW_CELLAR}\";" echo "set --global --export HOMEBREW_REPOSITORY \"${HOMEBREW_REPOSITORY}\";" echo "fish_add_path --global --move --path \"${HOMEBREW_PREFIX}/bin\" \"${HOMEBREW_PREFIX}/sbin\";" echo "if test -n \"\$MANPATH[1]\"; set --global --export MANPATH '' \$MANPATH; end;" echo "if not contains \"${HOMEBREW_PREFIX}/share/info\" \$INFOPATH; set --global --export INFOPATH \"${HOMEBREW_PREFIX}/share/info\" \$INFOPATH; end;" ;; csh | -csh | tcsh | -tcsh) echo "setenv HOMEBREW_PREFIX ${HOMEBREW_PREFIX};" echo "setenv HOMEBREW_CELLAR ${HOMEBREW_CELLAR};" echo "setenv HOMEBREW_REPOSITORY ${HOMEBREW_REPOSITORY};" if [[ -n "${PATH_HELPER_ROOT}" ]] then echo "eval \`/usr/bin/env PATH_HELPER_ROOT=\"${PATH_HELPER_ROOT}\" /usr/libexec/path_helper -c\`;" else echo "setenv PATH ${HOMEBREW_PREFIX}/bin:${HOMEBREW_PREFIX}/sbin:\$PATH;" fi echo "test \${?MANPATH} -eq 1 && setenv MANPATH :\${MANPATH};" echo "setenv INFOPATH ${HOMEBREW_PREFIX}/share/info\`test \${?INFOPATH} -eq 1 && echo :\${INFOPATH}\`;" ;; pwsh | -pwsh | pwsh-preview | -pwsh-preview) echo "[System.Environment]::SetEnvironmentVariable('HOMEBREW_PREFIX','${HOMEBREW_PREFIX}',[System.EnvironmentVariableTarget]::Process)" echo "[System.Environment]::SetEnvironmentVariable('HOMEBREW_CELLAR','${HOMEBREW_CELLAR}',[System.EnvironmentVariableTarget]::Process)" echo "[System.Environment]::SetEnvironmentVariable('HOMEBREW_REPOSITORY','${HOMEBREW_REPOSITORY}',[System.EnvironmentVariableTarget]::Process)" echo "[System.Environment]::SetEnvironmentVariable('PATH',\$('${HOMEBREW_PREFIX}/bin:${HOMEBREW_PREFIX}/sbin:'+\$ENV:PATH),[System.EnvironmentVariableTarget]::Process)" echo "[System.Environment]::SetEnvironmentVariable('MANPATH',\$('${HOMEBREW_PREFIX}/share/man'+\$(if(\${ENV:MANPATH}){':'+\${ENV:MANPATH}})+':'),[System.EnvironmentVariableTarget]::Process)" echo "[System.Environment]::SetEnvironmentVariable('INFOPATH',\$('${HOMEBREW_PREFIX}/share/info'+\$(if(\${ENV:INFOPATH}){':'+\${ENV:INFOPATH}})),[System.EnvironmentVariableTarget]::Process)" ;; *) echo "export HOMEBREW_PREFIX=\"${HOMEBREW_PREFIX}\";" echo "export HOMEBREW_CELLAR=\"${HOMEBREW_CELLAR}\";" echo "export HOMEBREW_REPOSITORY=\"${HOMEBREW_REPOSITORY}\";" if [[ "${HOMEBREW_SHELL_NAME}" == "zsh" ]] || [[ "${HOMEBREW_SHELL_NAME}" == "-zsh" ]] then echo "fpath[1,0]=\"${HOMEBREW_PREFIX}/share/zsh/site-functions\";" echo "export FPATH;" fi if [[ -n "${PATH_HELPER_ROOT}" ]] then echo "eval \"\$(/usr/bin/env PATH_HELPER_ROOT=\"${PATH_HELPER_ROOT}\" /usr/libexec/path_helper -s)\"" else echo "export PATH=\"${HOMEBREW_PREFIX}/bin:${HOMEBREW_PREFIX}/sbin\${PATH+:\$PATH}\";" fi echo "[ -z \"\${MANPATH-}\" ] || export MANPATH=\":\${MANPATH#:}\";" echo "export INFOPATH=\"${HOMEBREW_PREFIX}/share/info:\${INFOPATH:-}\";" ;; esac } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/source.rb000066400000000000000000000117431517265720000225020ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "utils/curl" module Homebrew module Cmd class Source < AbstractCommand cmd_args do description <<~EOS Open a 's source repository in a browser, or open Homebrew's own repository if no argument is provided. The repository URL is determined from the formula's head URL, stable URL, or homepage. Supports GitHub, GitLab, Bitbucket, Codeberg and SourceHut repositories. EOS named_args :formula end sig { override.void } def run if args.no_named? exec_browser "https://github.com/Homebrew/brew" return end formulae = args.named.to_formulae repo_urls = formulae.filter_map do |formula| repo_url = extract_repo_url(formula) if repo_url puts "Opening repository for #{formula.name}" repo_url else opoo "Could not determine repository URL for #{formula.name}" nil end end return if repo_urls.empty? exec_browser(*repo_urls) end private sig { params(formula: Formula).returns(T.nilable(String)) } def extract_repo_url(formula) urls_to_check = [ formula.head&.url, formula.stable&.url, formula.homepage, ] urls_to_check.each do |url| next if url.nil? repo_url = url_to_repo(url) return repo_url if repo_url end nil end sig { params(url: String).returns(T.nilable(String)) } def url_to_repo(url) github_repo_url(url) || gitlab_repo_url(url) || bitbucket_repo_url(url) || codeberg_repo_url(url) || sourcehut_repo_url(url) || pypi_repo_url(url) end sig { params(url: String).returns(T.nilable(String)) } def github_repo_url(url) regex = %r{ https?://github\.com/ (?[\w.-]+)/ (?[\w.-]+) (?:/.*)? }x match = url.match(regex) return unless match user = match[:user] repo = match[:repo]&.delete_suffix(".git") "https://github.com/#{user}/#{repo}" end sig { params(url: String).returns(T.nilable(String)) } def gitlab_repo_url(url) regex = %r{ https?://gitlab\.com/ (?(?:[\w.-]+/)*?[\w.-]+) (?:/-/|\.git|/archive/) }x match = url.match(regex) return unless match path = match[:path]&.delete_suffix(".git") "https://gitlab.com/#{path}" end sig { params(url: String).returns(T.nilable(String)) } def bitbucket_repo_url(url) regex = %r{ https?://bitbucket\.org/ (?[\w.-]+)/ (?[\w.-]+) (?:/.*)? }x match = url.match(regex) return unless match user = match[:user] repo = match[:repo]&.delete_suffix(".git") "https://bitbucket.org/#{user}/#{repo}" end sig { params(url: String).returns(T.nilable(String)) } def codeberg_repo_url(url) regex = %r{ https?://codeberg\.org/ (?[\w.-]+)/ (?[\w.-]+) (?:/.*)? }x match = url.match(regex) return unless match user = match[:user] repo = match[:repo]&.delete_suffix(".git") "https://codeberg.org/#{user}/#{repo}" end sig { params(url: String).returns(T.nilable(String)) } def sourcehut_repo_url(url) regex = %r{ https?://(?:git\.)?sr\.ht/ ~(?[\w.-]+)/ (?[\w.-]+) (?:/.*)? }x match = url.match(regex) return unless match user = match[:user] repo = match[:repo]&.delete_suffix(".git") "https://sr.ht/~#{user}/#{repo}" end sig { params(url: String).returns(T.nilable(String)) } def pypi_repo_url(url) regex = %r{ https?://files\.pythonhosted\.org /packages (?:/[^/]+)+ /(?.+)- .*? (?:\.tar\.[a-z0-9]+|\.[a-z0-9]+) }x match = url.match(regex) return unless match package_name = match[:package_name] return unless package_name api_url = "https://pypi.org/pypi/#{package_name.gsub(/%20|_/, "-")}/json" curl_args = Utils::Curl.curl_args(show_error: false, retries: 2) stdout, _, status = Utils::Curl.curl_output(*curl_args, api_url) return unless status.success? project_urls = JSON.parse(stdout).dig("info", "project_urls")&.transform_keys(&:downcase) project_urls["repository"] || project_urls["source"] || url_to_repo(project_urls.fetch("homepage", "")) # Homepages often link to source repositories rescue JSON::ParserError nil end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/tab.rb000066400000000000000000000062351517265720000217500ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "tab" module Homebrew module Cmd class TabCmd < AbstractCommand cmd_args do description <<~EOS Edit tab information for installed formulae or casks. This can be useful when you want to control whether an installed formula should be removed by `brew autoremove`. To prevent removal, mark the formula as installed on request; to allow removal, mark the formula as not installed on request. EOS switch "--installed-on-request", description: "Mark or as installed on request." switch "--no-installed-on-request", description: "Mark or as not installed on request." switch "--formula", "--formulae", description: "Only mark formulae." switch "--cask", "--casks", description: "Only mark casks." conflicts "--formula", "--cask" conflicts "--installed-on-request", "--no-installed-on-request" named_args [:installed_formula, :installed_cask], min: 1 end sig { override.void } def run installed_on_request = if args.installed_on_request? true elsif args.no_installed_on_request? false end raise UsageError, "No marking option specified." if installed_on_request.nil? formulae, casks = T.cast(args.named.to_formulae_to_casks, [T::Array[Formula], T::Array[Cask::Cask]]) formulae_not_installed = formulae.reject(&:any_version_installed?) casks_not_installed = casks.reject(&:installed?) if formulae_not_installed.any? || casks_not_installed.any? names = formulae_not_installed.map(&:name) + casks_not_installed.map(&:token) is_or_are = (names.length == 1) ? "is" : "are" odie "#{names.to_sentence} #{is_or_are} not installed." end [*formulae, *casks].each do |formula_or_cask| update_tab formula_or_cask, installed_on_request: end end private sig { params(formula_or_cask: T.any(Formula, Cask::Cask), installed_on_request: T::Boolean).void } def update_tab(formula_or_cask, installed_on_request:) name, tab = if formula_or_cask.is_a?(Formula) [formula_or_cask.name, Tab.for_formula(formula_or_cask)] else [formula_or_cask.token, formula_or_cask.tab] end tabfile = tab.tabfile if tabfile.blank? || !tabfile.exist? raise ArgumentError, "Tab file for #{name} does not exist." end installed_on_request_str = "#{"not " unless installed_on_request}installed on request" if (tab.installed_on_request && installed_on_request) || (!tab.installed_on_request && !installed_on_request) ohai "#{name} is already marked as #{installed_on_request_str}." return end tab.installed_on_request = installed_on_request tab.write ohai "#{name} is now marked as #{installed_on_request_str}." end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/tap-info.rb000066400000000000000000000064301517265720000227140ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" module Homebrew module Cmd class TapInfo < AbstractCommand cmd_args do description <<~EOS Show detailed information about one or more s. If no names are provided, display brief statistics for all installed taps. EOS switch "--installed", description: "Show information on each installed tap." flag "--json", description: "Print a JSON representation of . Currently the default and only accepted " \ "value for is `v1`. See the docs for examples of using the JSON " \ "output: " named_args :tap end sig { override.void } def run require "tap" taps = if args.installed? Tap else args.named.to_taps end if args.json raise UsageError, "invalid JSON version: #{args.json}" unless ["v1", true].include? args.json print_tap_json(taps.sort_by(&:to_s)) else print_tap_info(taps.sort_by(&:to_s)) end end private sig { params(taps: T::Array[Tap]).void } def print_tap_info(taps) if taps.none? tap_count = 0 formula_count = 0 command_count = 0 private_count = 0 Tap.installed.each do |tap| tap_count += 1 formula_count += tap.formula_files.size command_count += tap.command_files.size private_count += 1 if tap.private? end info = Utils.pluralize("tap", tap_count, include_count: true) info += ", #{private_count} private" info += ", #{Utils.pluralize("formula", formula_count, include_count: true)}" info += ", #{Utils.pluralize("command", command_count, include_count: true)}" info += ", #{HOMEBREW_TAP_DIRECTORY.dup.abv}" if HOMEBREW_TAP_DIRECTORY.directory? puts info else info = "" default_branches = %w[main master].freeze taps.each_with_index do |tap, i| puts unless i.zero? info = "#{tap}: " if tap.installed? info += "Installed" info += if (contents = tap.contents).blank? "\nNo commands/casks/formulae" else "\n#{contents.join(", ")}" end info += "\nPrivate" if tap.private? info += "\n#{tap.path} (#{tap.path.abv})" info += "\nFrom: #{tap.remote.presence || "N/A"}" info += "\norigin: #{tap.remote}" if tap.remote != tap.default_remote info += "\nHEAD: #{tap.git_head || "(none)"}" info += "\nlast commit: #{tap.git_last_commit || "never"}" info += "\nbranch: #{tap.git_branch || "(none)"}" if default_branches.exclude?(tap.git_branch) else info += "Not installed" Homebrew.failed = true end puts info end end end sig { params(taps: T::Array[Tap]).void } def print_tap_json(taps) puts JSON.pretty_generate(taps.map(&:to_hash)) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/tap.rb000066400000000000000000000050141517265720000217600ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "tap" module Homebrew module Cmd class TapCmd < AbstractCommand cmd_args do usage_banner "`tap` [] [`/`] []" description <<~EOS Tap a formula repository. If no arguments are provided, list all installed taps. With unspecified, tap a formula repository from GitHub using HTTPS. Since so many taps are hosted on GitHub, this command is a shortcut for `brew tap` `/` `https://github.com/``/homebrew-`. With specified, tap a formula repository from anywhere, using any transport protocol that `git`(1) handles. The one-argument form of `tap` simplifies but also limits. This two-argument command makes no assumptions, so taps can be cloned from places other than GitHub and using protocols other than HTTPS, e.g. SSH, git, HTTP, FTP(S), rsync. EOS switch "--custom-remote", description: "Install or change a tap with a custom remote. Useful for mirrors." switch "--repair", description: "Add missing symlinks to tap manpages and shell completions. Correct git remote " \ "refs for any taps where upstream HEAD branch has been renamed." switch "--eval-all", description: "Evaluate all formulae, casks and aliases in the new tap to check their validity.", env: :eval_all switch "-f", "--force", description: "Force install core taps even under API mode." named_args :tap, max: 2 end sig { override.void } def run if args.repair? Tap.installed.each do |tap| tap.link_completions_and_manpages tap.fix_remote_configuration end elsif args.no_named? puts Tap.installed.sort_by(&:name) else begin tap = Tap.fetch(args.named.fetch(0)) tap.install clone_target: args.named.second, custom_remote: args.custom_remote?, quiet: args.quiet?, verify: args.eval_all?, force: args.force? rescue Tap::InvalidNameError, TapRemoteMismatchError, TapNoCustomRemoteError => e odie e rescue TapAlreadyTappedError nil end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/unalias.rb000077500000000000000000000006631517265720000226400ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "aliases/aliases" module Homebrew module Cmd class Unalias < AbstractCommand cmd_args do description <<~EOS Remove aliases. EOS named_args :alias, min: 1 end sig { override.void } def run Aliases.init args.named.each { |a| Aliases.remove a } end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/uninstall.rb000066400000000000000000000074561517265720000232210ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "keg" require "formula" require "diagnostic" require "migrator" require "cask/cask_loader" require "cask/exceptions" require "cask/installer" require "cask/uninstall" require "uninstall" module Homebrew module Cmd class UninstallCmd < AbstractCommand cmd_args do description <<~EOS Uninstall a or . EOS switch "-f", "--force", description: "Delete all installed versions of . Uninstall even if is not " \ "installed, overwrite existing files and ignore errors when removing files." switch "--zap", description: "Remove all files associated with a . " \ "*May remove files which are shared between applications.*" switch "--ignore-dependencies", description: "Don't fail uninstall, even if is a dependency of any installed " \ "formulae." switch "--formula", "--formulae", description: "Treat all named arguments as formulae." switch "--cask", "--casks", description: "Treat all named arguments as casks." conflicts "--formula", "--cask" conflicts "--formula", "--zap" named_args [:installed_formula, :installed_cask], min: 1 end sig { override.void } def run method = args.force? ? :kegs : :default_kegs results = args.named.to_formulae_and_casks_and_unavailable(method:) unavailable_errors = T.let([], T::Array[T.any(FormulaOrCaskUnavailableError, NoSuchKegError)]) all_kegs = T.let([], T::Array[Keg]) casks = T.let([], T::Array[Cask::Cask]) results.each do |item| case item when FormulaOrCaskUnavailableError, NoSuchKegError unavailable_errors << item when Cask::Cask casks << item when Keg all_kegs << item when Array all_kegs += item end end return if all_kegs.blank? && casks.blank? && unavailable_errors.blank? kegs_by_rack = all_kegs.group_by(&:rack) Uninstall.uninstall_kegs( kegs_by_rack, casks:, force: args.force?, ignore_dependencies: args.ignore_dependencies?, named_args: args.named, ) Cask::Uninstall.check_dependent_casks(*casks, named_args: args.named) unless args.ignore_dependencies? return if Homebrew.failed? begin if args.zap? caught_exceptions = [] casks.each do |cask| odebug "Zapping Cask #{cask}" raise Cask::CaskNotInstalledError, cask if !cask.installed? && !args.force? Cask::Installer.new(cask, verbose: args.verbose?, force: args.force?).zap rescue => e caught_exceptions << e next end if caught_exceptions.count > 1 raise Cask::MultipleCaskErrors, caught_exceptions elsif caught_exceptions.one? raise caught_exceptions.fetch(0) end else Cask::Uninstall.uninstall_casks( *casks, verbose: args.verbose?, force: args.force?, ) end rescue => e ofail e end if ENV["HOMEBREW_AUTOREMOVE"].present? opoo "`$HOMEBREW_AUTOREMOVE` is now a no-op as it is the default behaviour. " \ "Set `HOMEBREW_NO_AUTOREMOVE=1` to disable it." end Cleanup.autoremove unless Homebrew::EnvConfig.no_autoremove? unavailable_errors.each { |e| ofail e } unless args.force? end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/unlink.rb000066400000000000000000000020511517265720000224720ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "unlink" module Homebrew module Cmd class UnlinkCmd < AbstractCommand cmd_args do description <<~EOS Remove symlinks for from Homebrew's prefix. This can be useful for temporarily disabling a formula: `brew unlink` `&&` `&& brew link` EOS switch "-n", "--dry-run", description: "List files which would be unlinked without actually unlinking or " \ "deleting any files." named_args :installed_formula, min: 1 end sig { override.void } def run options = { dry_run: args.dry_run?, verbose: args.verbose? } args.named.to_default_kegs.each do |keg| if args.dry_run? puts "Would remove:" keg.unlink(**options) next end Unlink.unlink(keg, dry_run: args.dry_run?, verbose: args.verbose?) end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/unpin.rb000066400000000000000000000012741517265720000223310ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" module Homebrew module Cmd class Unpin < AbstractCommand cmd_args do description <<~EOS Unpin , allowing them to be upgraded by `brew upgrade` . See also `pin`. EOS named_args :installed_formula, min: 1 end sig { override.void } def run args.named.to_resolved_formulae.each do |f| if f.pinned? f.unpin elsif !f.pinnable? onoe "#{f.name} not installed" else opoo "#{f.name} not pinned" end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/untap.rb000066400000000000000000000064541517265720000223340ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "utils" module Homebrew module Cmd class Untap < AbstractCommand cmd_args do description <<~EOS Remove a tapped formula repository. EOS switch "-f", "--force", description: "Untap even if formulae or casks from this tap are currently installed." named_args :tap, min: 1 end sig { override.void } def run args.named.to_installed_taps.each do |tap| odie "Untapping #{tap} is not allowed" if tap.core_tap? && Homebrew::EnvConfig.no_install_from_api? if Homebrew::EnvConfig.no_install_from_api? || (!tap.core_tap? && !tap.core_cask_tap?) installed_tap_formulae = installed_formulae_for(tap:) installed_tap_casks = installed_casks_for(tap:) if installed_tap_formulae.present? || installed_tap_casks.present? installed_names = (installed_tap_formulae + installed_tap_casks.map(&:token)).join("\n") if args.force? || Homebrew::EnvConfig.developer? opoo <<~EOS Untapping #{tap} even though it contains the following installed formulae or casks: #{installed_names} EOS else odie <<~EOS Refusing to untap #{tap} because it contains the following installed formulae or casks: #{installed_names} EOS end end end tap.uninstall manual: true end end # All installed formulae currently available in a tap by formula full name. sig { params(tap: Tap).returns(T::Array[Formula]) } def installed_formulae_for(tap:) tap.formula_names.filter_map do |formula_name| next unless installed_formulae_names.include?(Utils.name_from_full_name(formula_name)) formula = begin Formulary.factory(formula_name) rescue FormulaUnavailableError # Don't blow up because of a single unavailable formula. next end # Can't use Formula#any_version_installed? because it doesn't consider # taps correctly. formula if formula.installed_kegs.any? { |keg| keg.tab.tap == tap } end end # All installed casks currently available in a tap by cask full name. sig { params(tap: Tap).returns(T::Array[Cask::Cask]) } def installed_casks_for(tap:) tap.cask_tokens.filter_map do |cask_token| next unless installed_cask_tokens.include?(Utils.name_from_full_name(cask_token)) cask = begin Cask::CaskLoader.load(cask_token) rescue Cask::CaskUnavailableError # Don't blow up because of a single unavailable cask. next end cask if cask.installed? end end private sig { returns(T::Set[String]) } def installed_formulae_names @installed_formulae_names ||= T.let(Formula.installed_formula_names.to_set.freeze, T.nilable(T::Set[String])) end sig { returns(T::Set[String]) } def installed_cask_tokens @installed_cask_tokens ||= T.let(Cask::Caskroom.tokens.to_set.freeze, T.nilable(T::Set[String])) end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/update-if-needed.rb000066400000000000000000000010001517265720000242630ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class UpdateIfNeeded < AbstractCommand include ShellCommand cmd_args do description <<~EOS Runs `brew update --auto-update` only if needed. This is a good replacement for `brew update` in scripts where you want the no-op case to be both possible and really fast. EOS named_args :none end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/update-if-needed.sh000066400000000000000000000002421517265720000243010ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/update-if-needed.rb homebrew-update-if-needed() { export HOMEBREW_AUTO_UPDATE_COMMAND="1" auto-update "$@" } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/update-report.rb000066400000000000000000001016771517265720000240030ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "migrator" require "formulary" require "cask/cask_loader" require "cask/migrator" require "descriptions" require "cleanup" require "description_cache_store" require "settings" require "reinstall" require "version" module Homebrew module Cmd class UpdateReport < AbstractCommand cmd_args do description <<~EOS The Ruby implementation of `brew update`. Never called manually. EOS switch "--auto-update", "--preinstall", description: "Run in 'auto-update' mode (faster, less output)." switch "-f", "--force", description: "Treat installed and updated formulae as if they are from " \ "the same taps and migrate them anyway." hide_from_man_page! end sig { override.void } def run return output_update_report if $stdout.tty? redirect_stdout($stderr) do output_update_report end end private sig { void } def auto_update_header @auto_update_header ||= T.let(begin ohai "Auto-updated Homebrew!" if args.auto_update? true end, T.nilable(T::Boolean)) end sig { void } def output_update_report if ENV["HOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID"].present? opoo "HOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID is now a no-op so can be unset." puts "All Homebrew Google Analytics code and data was destroyed." end if ENV["HOMEBREW_NO_GOOGLE_ANALYTICS"].present? opoo "HOMEBREW_NO_GOOGLE_ANALYTICS is now a no-op so can be unset." puts "All Homebrew Google Analytics code and data was destroyed." end unless args.quiet? analytics_message donation_message install_from_api_message end tap_or_untap_core_taps_if_necessary updated = false new_tag = nil initial_revision = ENV["HOMEBREW_UPDATE_BEFORE"].to_s current_revision = ENV["HOMEBREW_UPDATE_AFTER"].to_s odie "update-report should not be called directly!" if initial_revision.empty? || current_revision.empty? if initial_revision != current_revision auto_update_header updated = true old_tag = Settings.read "latesttag" new_tag = Utils.popen_read( "git", "-C", HOMEBREW_REPOSITORY, "tag", "--list", "--sort=-version:refname", "*.*" ).lines.fetch(0).chomp Settings.write "latesttag", new_tag if new_tag != old_tag if new_tag == old_tag ohai "Updated Homebrew from #{shorten_revision(initial_revision)} " \ "to #{shorten_revision(current_revision)}." elsif old_tag.blank? ohai "Updated Homebrew from #{shorten_revision(initial_revision)} " \ "to #{new_tag} (#{shorten_revision(current_revision)})." else ohai "Updated Homebrew from #{old_tag} (#{shorten_revision(initial_revision)}) " \ "to #{new_tag} (#{shorten_revision(current_revision)})." end end # Check if we can parse the JSON and do any Ruby-side follow-up. Homebrew::API.write_names_and_aliases unless Homebrew::EnvConfig.no_install_from_api? Homebrew.failed = true if ENV["HOMEBREW_UPDATE_FAILED"] return if Homebrew::EnvConfig.disable_load_formula? migrate_gcc_dependents_if_needed hub = ReporterHub.new updated_taps = [] Tap.installed.each do |tap| next if !tap.git? || tap.git_repository.origin_url.nil? next if (tap.core_tap? || tap.core_cask_tap?) && !Homebrew::EnvConfig.no_install_from_api? begin reporter = Reporter.new(tap) rescue Reporter::ReporterRevisionUnsetError => e if Homebrew::EnvConfig.developer? require "utils/backtrace" onoe "#{e.message}\n#{Utils::Backtrace.clean(e)&.join("\n")}" end next end if reporter.updated? updated_taps << tap.name hub.add(reporter, auto_update: args.auto_update?) end end # If we're installing from the API: we cannot use Git to check for # # differences in packages so instead use {formula,cask}_names.txt to do so. # The first time this runs: we won't yet have a base state # ({formula,cask}_names.before.txt) to compare against so we don't output a # anything and just copy the files for next time. unless Homebrew::EnvConfig.no_install_from_api? api_cache = Homebrew::API::HOMEBREW_CACHE_API core_tap = CoreTap.instance cask_tap = CoreCaskTap.instance [ [:formula, core_tap, core_tap.formula_dir], [:cask, cask_tap, cask_tap.cask_dir], ].each do |type, tap, dir| names_txt = api_cache/"#{type}_names.txt" next unless names_txt.exist? names_before_txt = api_cache/"#{type}_names.before.txt" if names_before_txt.exist? reporter = Reporter.new( tap, api_names_txt: names_txt, api_names_before_txt: names_before_txt, api_dir_prefix: dir, ) if reporter.updated? updated_taps << tap.name hub.add(reporter, auto_update: args.auto_update?) end else FileUtils.cp names_txt, names_before_txt end end end unless updated_taps.empty? auto_update_header puts "Updated #{Utils.pluralize("tap", updated_taps.count, include_count: true)} (#{updated_taps.to_sentence})." updated = true end if updated if hub.empty? puts no_changes_message unless args.quiet? else if ENV.fetch("HOMEBREW_UPDATE_REPORT_ONLY_INSTALLED", false) opoo "HOMEBREW_UPDATE_REPORT_ONLY_INSTALLED is now the default behaviour, " \ "so you can unset it from your environment." end hub.dump(auto_update: args.auto_update?) unless args.quiet? hub.reporters.each(&:migrate_tap_migration) hub.reporters.each(&:migrate_cask_rename) hub.reporters.each { |r| r.migrate_formula_rename(force: args.force?, verbose: args.verbose?) } CacheStoreDatabase.use(:descriptions) do |db| DescriptionCacheStore.new(T.cast(db, CacheStoreDatabase[String, T.anything])) .update_from_report!(hub) end CacheStoreDatabase.use(:cask_descriptions) do |db| CaskDescriptionCacheStore.new(T.cast(db, CacheStoreDatabase[String, T.anything])) .update_from_report!(hub) end end puts if args.auto_update? elsif !args.auto_update? && !ENV["HOMEBREW_UPDATE_FAILED"] puts "Already up-to-date." unless args.quiet? end Homebrew::Reinstall.reinstall_pkgconf_if_needed! Commands.rebuild_commands_completion_list link_completions_manpages_and_docs Tap.installed.each(&:link_completions_and_manpages) failed_fetch_dirs = ENV["HOMEBREW_MISSING_REMOTE_REF_DIRS"]&.split("\n") if failed_fetch_dirs.present? failed_fetch_taps = failed_fetch_dirs.map { |dir| Tap.from_path(dir) } ofail <<~EOS Some taps failed to update! The following taps can not read their remote branches: #{failed_fetch_taps.join("\n ")} This is happening because the remote branch was renamed or deleted. Reset taps to point to the correct remote branches by running `brew tap --repair` EOS end return if new_tag.blank? || new_tag == old_tag || args.quiet? puts new_version = ::Version.new(new_tag) if new_version.major_minor > ::Version.new(old_tag || "0").major_minor puts <<~EOS The #{new_version.major_minor}.0 release notes are available on the Homebrew Blog: #{Formatter.url("https://brew.sh/blog/#{new_version.major_minor}.0")} EOS end return if new_version.patch.to_i.zero? puts <<~EOS The #{new_tag} changelog can be found at: #{Formatter.url("https://github.com/Homebrew/brew/releases/tag/#{new_tag}")} EOS end sig { returns(String) } def no_changes_message "No changes to formulae or casks." end sig { params(revision: String).returns(String) } def shorten_revision(revision) Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "rev-parse", "--short", revision).chomp end sig { void } def tap_or_untap_core_taps_if_necessary return if ENV["HOMEBREW_UPDATE_TEST"] if Homebrew::EnvConfig.no_install_from_api? return if Homebrew::EnvConfig.automatically_set_no_install_from_api? core_tap = CoreTap.instance return if core_tap.installed? core_tap.ensure_installed! revision = CoreTap.instance.git_head ENV["HOMEBREW_UPDATE_BEFORE_HOMEBREW_HOMEBREW_CORE"] = revision ENV["HOMEBREW_UPDATE_AFTER_HOMEBREW_HOMEBREW_CORE"] = revision else return if Homebrew::EnvConfig.developer? || ENV["HOMEBREW_DEV_CMD_RUN"] return if ENV["HOMEBREW_GITHUB_HOSTED_RUNNER"] || ENV["GITHUB_ACTIONS_HOMEBREW_SELF_HOSTED"] return if (HOMEBREW_PREFIX/".homebrewdocker").exist? tap_output_header_printed = T.let(false, T::Boolean) default_branches = %w[main master].freeze [CoreTap.instance, CoreCaskTap.instance].each do |tap| next unless tap.installed? if default_branches.include?(tap.git_branch) && (Date.parse(T.must(tap.git_repository.last_commit_date)) <= Date.today.prev_month) ohai "#{tap.name} is old and unneeded, untapping to save space..." tap.uninstall else unless tap_output_header_printed puts "Installing from the API is now the default behaviour!" puts "You can save space and time by running:" tap_output_header_printed = true end puts " brew untap #{tap.name}" end end end end sig { params(repository: Pathname).void } def link_completions_manpages_and_docs(repository = HOMEBREW_REPOSITORY) command = "brew update" Utils::Link.link_completions(repository, command) Utils::Link.link_manpages(repository, command) Utils::Link.link_docs(repository, command) rescue => e ofail <<~EOS Failed to link all completions, docs and manpages: #{e} EOS end sig { void } def migrate_gcc_dependents_if_needed # do nothing end sig { void } def analytics_message return if Utils::Analytics.messages_displayed? return if Utils::Analytics.no_message_output? if Utils::Analytics.disabled? && !Utils::Analytics.influx_message_displayed? ohai "Homebrew's analytics have entirely moved to our InfluxDB instance in the EU." puts "We gather less data than before and have destroyed all Google Analytics data:" puts " #{Formatter.url("https://docs.brew.sh/Analytics")}#{Tty.reset}" puts "Please reconsider re-enabling analytics to help our volunteer maintainers with:" puts " brew analytics on" elsif !Utils::Analytics.disabled? ENV["HOMEBREW_NO_ANALYTICS_THIS_RUN"] = "1" # Use the shell's audible bell. print "\a" # Use an extra newline and bold to avoid this being missed. ohai "Homebrew collects anonymous analytics." puts <<~EOS #{Tty.bold}Read the analytics documentation (and how to opt-out) here: #{Formatter.url("https://docs.brew.sh/Analytics")}#{Tty.reset} No analytics have been recorded yet (nor will be during this `brew` run). EOS end # Consider the messages possibly missed if not a TTY. Utils::Analytics.messages_displayed! if $stdout.tty? end sig { void } def donation_message return if Settings.read("donationmessage") == "true" ohai "Homebrew is run entirely by unpaid volunteers. Please consider donating:" puts " #{Formatter.url("https://github.com/Homebrew/brew#donations")}\n\n" # Consider the message possibly missed if not a TTY. Settings.write "donationmessage", true if $stdout.tty? end sig { void } def install_from_api_message return if Settings.read("installfromapimessage") == "true" no_install_from_api_set = Homebrew::EnvConfig.no_install_from_api? && !Homebrew::EnvConfig.automatically_set_no_install_from_api? return unless no_install_from_api_set ohai "You have `$HOMEBREW_NO_INSTALL_FROM_API` set" puts "Homebrew >=4.1.0 is dramatically faster and less error-prone when installing" puts "from the JSON API. Please consider unsetting `$HOMEBREW_NO_INSTALL_FROM_API`." puts "This message will only be printed once." puts "\n\n" # Consider the message possibly missed if not a TTY. Settings.write "installfromapimessage", true if $stdout.tty? end end end end require "extend/os/cmd/update-report" class Reporter # rubocop:todo Style/OneClassPerFile include Utils::Output::Mixin Report = T.type_alias do { A: T::Array[String], AC: T::Array[String], D: T::Array[String], DC: T::Array[String], M: T::Array[String], MC: T::Array[String], R: T::Array[[String, String]], RC: T::Array[[String, String]], T: T::Array[String], } end class ReporterRevisionUnsetError < RuntimeError sig { params(var_name: String).void } def initialize(var_name) super "#{var_name} is unset!" end end sig { params(tap: Tap, api_names_txt: T.nilable(Pathname), api_names_before_txt: T.nilable(Pathname), api_dir_prefix: T.nilable(Pathname)).void } def initialize(tap, api_names_txt: nil, api_names_before_txt: nil, api_dir_prefix: nil) @tap = tap # This is slightly involved/weird but all the #report logic is shared so it's worth it. if installed_from_api?(api_names_txt, api_names_before_txt, api_dir_prefix) @api_names_txt = T.let(api_names_txt, T.nilable(Pathname)) @api_names_before_txt = T.let(api_names_before_txt, T.nilable(Pathname)) @api_dir_prefix = T.let(api_dir_prefix, T.nilable(Pathname)) else initial_revision_var = "HOMEBREW_UPDATE_BEFORE#{tap.repository_var_suffix}" @initial_revision = T.let(ENV[initial_revision_var].to_s, String) raise ReporterRevisionUnsetError, initial_revision_var if @initial_revision.empty? current_revision_var = "HOMEBREW_UPDATE_AFTER#{tap.repository_var_suffix}" @current_revision = T.let(ENV[current_revision_var].to_s, String) raise ReporterRevisionUnsetError, current_revision_var if @current_revision.empty? end @report = T.let(nil, T.nilable(Report)) end sig { params(auto_update: T::Boolean).returns(Report) } def report(auto_update: false) return @report if @report @report = { A: [], AC: [], D: [], DC: [], M: [], MC: [], R: T.let([], T::Array[[String, String]]), RC: T.let([], T::Array[[String, String]]), T: [] } return @report unless updated? diff.each_line do |line| status, *paths = line.split src = Pathname.new paths.first dst = Pathname.new paths.last next if dst.extname != ".rb" if paths.any? { |p| tap.cask_file?(p) } case status when "A" # Have a dedicated report array for new casks. @report[:AC] << tap.formula_file_to_name(src) when "D" # Have a dedicated report array for deleted casks. @report[:DC] << tap.formula_file_to_name(src) when "M" # Report updated casks @report[:MC] << tap.formula_file_to_name(src) when /^R\d{0,3}/ src_full_name = tap.formula_file_to_name(src) dst_full_name = tap.formula_file_to_name(dst) # Don't report formulae that are moved within a tap but not renamed next if src_full_name == dst_full_name @report[:DC] << src_full_name @report[:AC] << dst_full_name end end next unless paths.any? do |p| tap.formula_file?(p) || # Need to check for case where Formula directory was deleted (status == "D" && File.fnmatch?("{Homebrew,}Formula/**/*.rb", p, File::FNM_EXTGLOB | File::FNM_PATHNAME)) end case status when "A", "D" full_name = tap.formula_file_to_name(src) name = Utils.name_from_full_name(full_name) new_tap = tap.tap_migrations[name] if new_tap.blank? @report[T.must(status).to_sym] << full_name elsif status == "D" # Retain deleted formulae for tap migrations separately to avoid reporting as deleted @report[:T] << full_name end when "M" name = tap.formula_file_to_name(src) @report[:M] << name when /^R\d{0,3}/ src_full_name = tap.formula_file_to_name(src) dst_full_name = tap.formula_file_to_name(dst) # Don't report formulae that are moved within a tap but not renamed next if src_full_name == dst_full_name @report[:D] << src_full_name @report[:A] << dst_full_name end end renamed_casks = Set.new @report[:DC].each do |old_full_name| old_name = Utils.name_from_full_name(old_full_name) new_name = tap.cask_renames[old_name] next unless new_name new_full_name = if tap.core_cask_tap? new_name else "#{tap}/#{new_name}" end renamed_casks << [old_full_name, new_full_name] if @report[:AC].include?(new_full_name) end @report[:AC].each do |new_full_name| new_name = Utils.name_from_full_name(new_full_name) old_name = tap.cask_renames.key(new_name) next unless old_name old_full_name = if tap.core_cask_tap? old_name else "#{tap}/#{old_name}" end renamed_casks << [old_full_name, new_full_name] end if renamed_casks.any? @report[:AC] -= renamed_casks.map(&:last) @report[:DC] -= renamed_casks.map(&:first) @report[:RC] = renamed_casks.to_a end renamed_formulae = Set.new @report[:D].each do |old_full_name| old_name = Utils.name_from_full_name(old_full_name) new_name = tap.formula_renames[old_name] next unless new_name new_full_name = if tap.core_tap? new_name else "#{tap}/#{new_name}" end renamed_formulae << [old_full_name, new_full_name] if @report[:A].include? new_full_name end @report[:A].each do |new_full_name| new_name = Utils.name_from_full_name(new_full_name) old_name = tap.formula_renames.key(new_name) next unless old_name old_full_name = if tap.core_tap? old_name else "#{tap}/#{old_name}" end renamed_formulae << [old_full_name, new_full_name] end if renamed_formulae.any? @report[:A] -= renamed_formulae.map(&:last) @report[:D] -= renamed_formulae.map(&:first) @report[:R] = renamed_formulae.to_a end # If any formulae/casks are marked as added and deleted, remove them from # the report as we've not detected things correctly. if (added_and_deleted_formulae = (@report[:A] & @report[:D]).presence) @report[:A] -= added_and_deleted_formulae @report[:D] -= added_and_deleted_formulae end if (added_and_deleted_casks = (@report[:AC] & @report[:DC]).presence) @report[:AC] -= added_and_deleted_casks @report[:DC] -= added_and_deleted_casks end @report end sig { returns(T::Boolean) } def updated? if installed_from_api? diff.present? else initial_revision != current_revision end end sig { void } def migrate_tap_migration [report[:D], report[:DC], report[:T]].flatten.each do |full_name| name = Utils.name_from_full_name(full_name) migration_target = tap.tap_migrations[name] next if migration_target.nil? # skip if not in tap_migrations list. migrated_tap_name = Utils.tap_from_full_name(migration_target) new_name = if migrated_tap_name new_full_name = Utils.name_from_full_name(migration_target) new_tap_name = migrated_tap_name new_full_name elsif migration_target.include?("/") new_tap_name = migration_target new_full_name = "#{new_tap_name}/#{name}" name else new_tap_name = tap.name new_full_name = "#{new_tap_name}/#{migration_target}" migration_target end # This means it is a cask if Array(report[:DC]).include? full_name next unless (HOMEBREW_PREFIX/"Caskroom"/name).exist? new_tap = Tap.fetch(new_tap_name) new_tap.ensure_installed! ohai "#{name} has been moved to Homebrew.", <<~EOS To uninstall the cask, run: brew uninstall --cask --force #{name} EOS next if (HOMEBREW_CELLAR/Utils.name_from_full_name(new_name)).directory? ohai "Installing #{new_name}..." begin system HOMEBREW_BREW_FILE, "install", "--overwrite", new_full_name # Rescue any possible exception types. rescue Exception => e # rubocop:disable Lint/RescueException if Homebrew::EnvConfig.developer? require "utils/backtrace" onoe "#{e.message}\n#{Utils::Backtrace.clean(e)&.join("\n")}" end end next end next unless (dir = HOMEBREW_CELLAR/name).exist? # skip if formula is not installed. tabs = dir.subdirs.map { |d| Keg.new(d).tab } next if tabs.first.tap != tap # skip if installed formula is not from this tap. new_tap = Tap.fetch(new_tap_name) # For formulae migrated to cask: Auto-install cask or provide install instructions. # Check if the migration target is a cask (either in homebrew/cask or any other tap) if new_tap.core_cask_tap? || new_tap.cask_tokens.intersect?([new_full_name, new_name]) migration_message = if new_tap == tap "#{full_name} has been migrated from a formula to a cask." else "#{name} has been moved to #{new_tap_name}." end if new_tap.installed? && (HOMEBREW_PREFIX/"Caskroom").directory? ohai migration_message ohai "brew unlink #{name}" system HOMEBREW_BREW_FILE, "unlink", name ohai "brew cleanup" system HOMEBREW_BREW_FILE, "cleanup" ohai "brew install --cask #{new_full_name}" system HOMEBREW_BREW_FILE, "install", "--cask", new_full_name ohai migration_message, <<~EOS The existing keg has been unlinked. Please uninstall the formula when convenient by running: brew uninstall --formula --force #{name} EOS else ohai migration_message, <<~EOS To uninstall the formula and install the cask, run: brew uninstall --formula --force #{name} brew tap #{new_tap_name} brew install --cask #{new_full_name} EOS end else new_tap.ensure_installed! # update tap for each Tab tabs.each { |tab| tab.tap = new_tap } tabs.each(&:write) end end end sig { void } def migrate_cask_rename Cask::Caskroom.casks.each do |cask| Cask::Migrator.migrate_if_needed(cask) end end sig { params(force: T::Boolean, verbose: T::Boolean).void } def migrate_formula_rename(force:, verbose:) Formula.installed.each do |formula| next unless Migrator.needs_migration?(formula) oldnames_to_migrate = formula.oldnames.select do |oldname| oldname_rack = HOMEBREW_CELLAR/oldname next false unless oldname_rack.exist? if oldname_rack.subdirs.empty? oldname_rack.rmdir_if_possible next false end true end next if oldnames_to_migrate.empty? Migrator.migrate_if_needed(formula, force:) end end private sig { returns(Tap) } attr_reader :tap sig { returns(String) } attr_reader :initial_revision sig { returns(String) } attr_reader :current_revision sig { returns(T.nilable(Pathname)) } attr_reader :api_names_txt sig { returns(T.nilable(Pathname)) } attr_reader :api_names_before_txt sig { returns(T.nilable(Pathname)) } attr_reader :api_dir_prefix sig { params(api_names_txt: T.nilable(Pathname), api_names_before_txt: T.nilable(Pathname), api_dir_prefix: T.nilable(Pathname)).returns(T::Boolean) } def installed_from_api?(api_names_txt = @api_names_txt, api_names_before_txt = @api_names_before_txt, api_dir_prefix = @api_dir_prefix) !api_names_txt.nil? && !api_names_before_txt.nil? && !api_dir_prefix.nil? end sig { returns(String) } def diff @diff ||= T.let(nil, T.nilable(String)) @diff ||= if installed_from_api? # Hack `git diff` output with regexes to look like `git diff-tree` output. # Yes, I know this is a bit filthy but it saves duplicating the #report logic. diff_output = Utils.popen_read("git", "diff", "--no-ext-diff", api_names_before_txt, api_names_txt) header_regex = /^(---|\+\+\+) / add_delete_characters = ["+", "-"].freeze api_dir_prefix_basename = T.must(api_dir_prefix).basename diff_hash = diff_output.lines.each_with_object({}) do |line, hash| next if line.match?(header_regex) next unless add_delete_characters.include?(line[0]) name = line.chomp.delete_prefix("+").delete_prefix("-") file = "#{api_dir_prefix_basename}/#{name}.rb" hash[file] ||= 0 if line.start_with?("+") hash[file] += 1 elsif line.start_with?("-") hash[file] -= 1 end end diff_hash.filter_map do |file, count| if count.positive? "A #{file}" elsif count.negative? "D #{file}" end end.join("\n") else Utils.popen_read( "git", "-C", tap.path, "diff-tree", "-r", "--name-status", "--diff-filter=AMDR", "-M85%", initial_revision, current_revision ) end end end class ReporterHub # rubocop:todo Style/OneClassPerFile include Utils::Output::Mixin sig { returns(T::Array[Reporter]) } attr_reader :reporters sig { void } def initialize @hash = T.let({}, T::Hash[Symbol, T::Array[T.any(String, [String, String])]]) @reporters = T.let([], T::Array[Reporter]) end sig { params(key: Symbol).returns(T::Array[String]) } def select_formula_or_cask(key) raise "Unsupported key #{key}" unless [:A, :AC, :D, :DC, :M, :MC, :R, :RC, :T].include?(key) T.cast(@hash.fetch(key, []), T::Array[String]) end sig { params(reporter: Reporter, auto_update: T::Boolean).void } def add(reporter, auto_update: false) @reporters << reporter report = reporter.report(auto_update:).reject { |_k, v| v.empty? } @hash.update(report) { |_key, oldval, newval| oldval.concat(newval) } end sig { returns(T::Boolean) } def empty? @hash.empty? end sig { params(auto_update: T::Boolean).void } def dump(auto_update: false) unless Homebrew::EnvConfig.no_update_report_new? dump_new_formula_report dump_new_cask_report end dump_deleted_formula_report dump_deleted_cask_report outdated_formulae = Formula.installed.select(&:outdated?).map(&:name) outdated_casks = Cask::Caskroom.casks.select(&:outdated?).map(&:token) unless auto_update output_dump_formula_or_cask_report "Outdated Formulae", outdated_formulae output_dump_formula_or_cask_report "Outdated Casks", outdated_casks end return if outdated_formulae.blank? && outdated_casks.blank? outdated_formulae = outdated_formulae.count outdated_casks = outdated_casks.count update_pronoun = if (outdated_formulae + outdated_casks) == 1 "it" else "them" end msg = "" if outdated_formulae.positive? noun = Utils.pluralize("formula", outdated_formulae) msg += "#{Tty.bold}#{outdated_formulae}#{Tty.reset} outdated #{noun}" end if outdated_casks.positive? msg += " and " if msg.present? msg += "#{Tty.bold}#{outdated_casks}#{Tty.reset} outdated #{Utils.pluralize("cask", outdated_casks)}" end return if msg.blank? puts puts "You have #{msg} installed." # If we're auto-updating, don't need to suggest commands that we're perhaps # already running. return if auto_update puts <<~EOS You can upgrade #{update_pronoun} with #{Tty.bold}brew upgrade#{Tty.reset} or list #{update_pronoun} with #{Tty.bold}brew outdated#{Tty.reset}. EOS end private sig { void } def dump_new_formula_report formulae = select_formula_or_cask(:A).sort.reject { |name| installed?(name) } return if formulae.blank? ohai "New Formulae" should_display_descriptions = if Homebrew::EnvConfig.no_install_from_api? formulae.size <= 100 else true end formulae.each do |formula| if should_display_descriptions && (desc = description(formula)) puts "#{formula}: #{desc}" else puts formula end end end sig { void } def dump_new_cask_report return unless Cask::Caskroom.any_casks_installed? casks = select_formula_or_cask(:AC).sort.reject { |name| cask_installed?(name) } return if casks.blank? ohai "New Casks" should_display_descriptions = if Homebrew::EnvConfig.no_install_from_api? casks.size <= 100 else true end casks.each do |cask| cask_token = Utils.name_from_full_name(cask) if should_display_descriptions && (desc = cask_description(cask)) puts "#{cask_token}: #{desc}" else puts cask_token end end end sig { void } def dump_deleted_formula_report formulae = select_formula_or_cask(:D).sort.filter_map do |name| pretty_uninstalled(name) if installed?(name) end output_dump_formula_or_cask_report "Deleted Installed Formulae", formulae end sig { void } def dump_deleted_cask_report return if Homebrew::SimulateSystem.simulating_or_running_on_linux? casks = select_formula_or_cask(:DC).sort.filter_map do |name| name = Utils.name_from_full_name(name) pretty_uninstalled(name) if cask_installed?(name) end output_dump_formula_or_cask_report "Deleted Installed Casks", casks end sig { params(title: String, formulae_or_casks: T::Array[String]).void } def output_dump_formula_or_cask_report(title, formulae_or_casks) return if formulae_or_casks.blank? ohai title, Formatter.columns(formulae_or_casks.sort) end sig { params(formula: String).returns(T::Boolean) } def installed?(formula) (HOMEBREW_CELLAR/Utils.name_from_full_name(formula)).directory? end sig { params(cask: String).returns(T::Boolean) } def cask_installed?(cask) (Cask::Caskroom.path/cask).directory? end sig { returns(T::Array[T.untyped]) } def all_formula_json return @all_formula_json if @all_formula_json @all_formula_json = T.let(nil, T.nilable(T::Array[T.untyped])) all_formula_json, = Homebrew::API.fetch_json_api_file "formula.jws.json" all_formula_json = T.cast(all_formula_json, T::Array[T.untyped]) @all_formula_json = all_formula_json end sig { returns(T::Array[T.untyped]) } def all_cask_json return @all_cask_json if @all_cask_json @all_cask_json = T.let(nil, T.nilable(T::Array[T.untyped])) all_cask_json, = Homebrew::API.fetch_json_api_file "cask.jws.json" all_cask_json = T.cast(all_cask_json, T::Array[T.untyped]) @all_cask_json = all_cask_json end sig { params(formula: String).returns(T.nilable(String)) } def description(formula) if Homebrew::EnvConfig.no_install_from_api? # Skip non-homebrew/core formulae for security. return if formula.include?("/") begin Formula[formula].desc&.presence rescue FormulaUnavailableError nil end else all_formula_json.find { |f| f["name"] == formula } &.fetch("desc", nil) &.presence end end sig { params(cask: String).returns(T.nilable(String)) } def cask_description(cask) if Homebrew::EnvConfig.no_install_from_api? # Skip non-homebrew/cask formulae for security. return if cask.include?("/") begin Cask::CaskLoader.load(cask).desc&.presence rescue Cask::CaskError nil end else all_cask_json.find { |f| f["token"] == cask } &.fetch("desc", nil) &.presence end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/update-reset.rb000066400000000000000000000010231517265720000235720ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class UpdateReset < AbstractCommand include ShellCommand cmd_args do description <<~EOS Fetch and reset Homebrew and all tap repositories (or any specified ) using `git`(1) to their latest `origin/HEAD`. *Note:* this will destroy all your uncommitted or committed changes. EOS named_args :repository end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/update-reset.sh000066400000000000000000000051431517265720000236100ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/update-reset.rb # Replaces the function in Library/Homebrew/brew.sh to cache the Git executable to provide # speedup when using Git repeatedly and prevent errors if the shim changes mid-update. git() { if [[ -z "${GIT_EXECUTABLE}" ]] then # HOMEBREW_LIBRARY is set by bin/brew # shellcheck disable=SC2154 GIT_EXECUTABLE="$("${HOMEBREW_LIBRARY}/Homebrew/shims/shared/git" --homebrew=print-path)" if [[ -z "${GIT_EXECUTABLE}" ]] then odie "Can't find a working Git!" fi fi "${GIT_EXECUTABLE}" "$@" } homebrew-update-reset() { local option local DIR local -a REPOS=() for option in "$@" do case "${option}" in -\? | -h | --help | --usage) brew help update-reset exit $? ;; --debug) HOMEBREW_DEBUG=1 ;; -*) [[ "${option}" == *d* ]] && HOMEBREW_DEBUG=1 ;; *) if [[ -d "${option}/.git" ]] then REPOS+=("${option}") else onoe "${option} is not a Git repository!" brew help update-reset exit 1 fi ;; esac done if [[ -n "${HOMEBREW_DEBUG}" ]] then set -x fi if [[ -z "${REPOS[*]}" ]] then # HOMEBREW_REPOSITORY is set by bin/brew # shellcheck disable=SC2154 REPOS+=("${HOMEBREW_REPOSITORY}" "${HOMEBREW_LIBRARY}"/Taps/*/*) fi for DIR in "${REPOS[@]}" do [[ -d "${DIR}/.git" ]] || continue if ! git -C "${DIR}" config --local --get remote.origin.url &>/dev/null then opoo "No remote 'origin' in ${DIR}, skipping update and reset!" continue fi git -C "${DIR}" config --bool core.autocrlf false git -C "${DIR}" config --bool core.symlinks true ohai "Fetching ${DIR}..." git -C "${DIR}" fetch --force --tags origin git -C "${DIR}" remote set-head origin --auto >/dev/null echo ohai "Resetting ${DIR}..." # HOMEBREW_* variables here may all be set by bin/brew or the user # shellcheck disable=SC2154 if [[ "${DIR}" == "${HOMEBREW_REPOSITORY}" && (-n "${HOMEBREW_UPDATE_TO_TAG}" || (-z "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_DEV_CMD_RUN}")) ]] then local latest_git_tag latest_git_tag="$(git -C "${DIR}" tag --list --sort="-version:refname" | head -n1)" git -C "${DIR}" checkout --force -B stable "refs/tags/${latest_git_tag}" else head="$(git -C "${DIR}" symbolic-ref refs/remotes/origin/HEAD)" head="${head#refs/remotes/origin/}" git -C "${DIR}" checkout --force -B "${head}" origin/HEAD fi rm -rf "${DIR}/.git/describe-cache" echo done } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/update.rb000066400000000000000000000021411517265720000224540ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class Update < AbstractCommand include ShellCommand cmd_args do description <<~EOS Fetch the newest version of Homebrew and all formulae from GitHub using `git`(1) and perform any necessary migrations. EOS switch "--merge", description: "Use `git merge` to apply updates (rather than `git rebase`)." switch "--auto-update", description: "Run on auto-updates (e.g. before `brew install`). Skips some slower steps." switch "-f", "--force", description: "Always do a slower, full update check (even if unnecessary)." switch "-q", "--quiet", description: "Make some output more quiet." switch "-v", "--verbose", description: "Print the directories checked and `git` operations performed." switch "-d", "--debug", description: "Display a trace of all shell commands as they are executed." end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/update.sh000066400000000000000000001051641517265720000224740ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/update.rb # HOMEBREW_API_DOMAIN, HOMEBREW_CURLRC, HOMEBREW_DEBUG, HOMEBREW_DEVELOPER, HOMEBREW_GIT_EMAIL, HOMEBREW_GIT_NAME, # HOMEBREW_GITHUB_API_TOKEN, HOMEBREW_NO_ENV_HINTS, HOMEBREW_NO_INSTALL_CLEANUP, HOMEBREW_NO_INSTALL_FROM_API, # HOMEBREW_UPDATE_TO_TAG are from the user environment # HOMEBREW_LIBRARY, HOMEBREW_PREFIX, HOMEBREW_REPOSITORY are set by bin/brew # HOMEBREW_API_DEFAULT_DOMAIN, HOMEBREW_AUTO_UPDATE_CASK_TAP, HOMEBREW_AUTO_UPDATE_CORE_TAP, # HOMEBREW_AUTO_UPDATE_SECS, HOMEBREW_BREW_DEFAULT_GIT_REMOTE, HOMEBREW_BREW_GIT_REMOTE, HOMEBREW_CACHE, # HOMEBREW_CASK_REPOSITORY, HOMEBREW_CELLAR, HOMEBREW_CORE_DEFAULT_GIT_REMOTE, HOMEBREW_CORE_GIT_REMOTE, # HOMEBREW_CORE_REPOSITORY, HOMEBREW_CURL, HOMEBREW_DEV_CMD_RUN, HOMEBREW_FORCE_BREWED_CA_CERTIFICATES, # HOMEBREW_FORCE_BREWED_CURL, HOMEBREW_FORCE_BREWED_GIT, # HOMEBREW_SYSTEM_CURL_TOO_OLD, HOMEBREW_USER_AGENT_CURL are set by brew.sh # shellcheck disable=SC2154 source "${HOMEBREW_LIBRARY}/Homebrew/utils/lock.sh" macos_version_name() { # NOTE: Changes to this list must match `SYMBOLS` in `macos_version.rb`. if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "260000" ]] then echo "tahoe" elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "150000" ]] then echo "sequoia" elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "140000" ]] then echo "sonoma" elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "130000" ]] then echo "ventura" elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "120000" ]] then echo "monterey" elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "110000" ]] then # odisabled: remove support for Big Sur and macOS x86_64 September (or later) 2027 echo "big_sur" elif [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "101500" ]] then # odisabled: remove support for Catalina September (or later) 2026 echo "catalina" fi } bottle_tag() { if [[ -n "${HOMEBREW_MACOS}" && "${HOMEBREW_PHYSICAL_PROCESSOR}" == "x86_64" ]] then macos_version_name elif [[ -n "${HOMEBREW_MACOS}" ]] then echo "${HOMEBREW_PHYSICAL_PROCESSOR}_$(macos_version_name)" elif [[ -n "${HOMEBREW_LINUX}" ]] then echo "${HOMEBREW_PHYSICAL_PROCESSOR}_linux" fi } # Replaces the function in Library/Homebrew/brew.sh to cache the Curl/Git executable to # provide speedup when using Curl/Git repeatedly (as update.sh does). curl() { if [[ -z "${CURL_EXECUTABLE}" ]] then CURL_EXECUTABLE="$("${HOMEBREW_LIBRARY}/Homebrew/shims/shared/curl" --homebrew=print-path)" if [[ -z "${CURL_EXECUTABLE}" ]] then odie "Can't find a working Curl!" fi fi "${CURL_EXECUTABLE}" "$@" } git() { if [[ -z "${GIT_EXECUTABLE}" ]] then GIT_EXECUTABLE="$("${HOMEBREW_LIBRARY}/Homebrew/shims/shared/git" --homebrew=print-path)" if [[ -z "${GIT_EXECUTABLE}" ]] then odie "Can't find a working Git!" fi fi "${GIT_EXECUTABLE}" "$@" } git_init_if_necessary() { safe_cd "${HOMEBREW_REPOSITORY}" if [[ ! -d ".git" ]] then set -e trap '{ rm -rf .git; exit 1; }' EXIT git init git config --bool core.autocrlf false git config --bool core.symlinks true if [[ "${HOMEBREW_BREW_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_BREW_GIT_REMOTE}" ]] then echo "HOMEBREW_BREW_GIT_REMOTE set: using ${HOMEBREW_BREW_GIT_REMOTE} as the Homebrew/brew Git remote." fi git config remote.origin.url "${HOMEBREW_BREW_GIT_REMOTE}" git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*" git config fetch.prune true git fetch --force --tags origin git remote set-head origin --auto >/dev/null git reset --hard origin/HEAD SKIP_FETCH_BREW_REPOSITORY=1 set +e trap - EXIT fi [[ -d "${HOMEBREW_CORE_REPOSITORY}" ]] || return safe_cd "${HOMEBREW_CORE_REPOSITORY}" if [[ ! -d ".git" ]] then set -e trap '{ rm -rf .git; exit 1; }' EXIT git init git config --bool core.autocrlf false git config --bool core.symlinks true if [[ "${HOMEBREW_CORE_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_CORE_GIT_REMOTE}" ]] then echo "HOMEBREW_CORE_GIT_REMOTE set: using ${HOMEBREW_CORE_GIT_REMOTE} as the Homebrew/homebrew-core Git remote." fi git config remote.origin.url "${HOMEBREW_CORE_GIT_REMOTE}" git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*" git config fetch.prune true git fetch --force origin git remote set-head origin --auto >/dev/null git reset --hard origin/HEAD SKIP_FETCH_CORE_REPOSITORY=1 set +e trap - EXIT fi } repository_var_suffix() { local repository_directory="${1}" local repository_var_suffix if [[ "${repository_directory}" == "${HOMEBREW_REPOSITORY}" ]] then repository_var_suffix="" else repository_var_suffix="${repository_directory#"${HOMEBREW_LIBRARY}/Taps"}" repository_var_suffix="$(echo -n "${repository_var_suffix}" | tr -C "A-Za-z0-9" "_" | tr "[:lower:]" "[:upper:]")" fi echo "${repository_var_suffix}" } upstream_branch() { local upstream_branch upstream_branch="$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null)" if [[ -z "${upstream_branch}" ]] then git remote set-head origin --auto >/dev/null upstream_branch="$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null)" fi upstream_branch="${upstream_branch#refs/remotes/origin/}" [[ -z "${upstream_branch}" ]] && upstream_branch="main" echo "${upstream_branch}" } read_current_revision() { git rev-parse -q --verify HEAD } pop_stash() { [[ -z "${STASHED}" ]] && return if [[ -n "${HOMEBREW_VERBOSE}" ]] then echo "Restoring your stashed changes to ${DIR}..." git stash pop else git stash pop "${QUIET_ARGS[@]}" 1>/dev/null fi unset STASHED } pop_stash_message() { [[ -z "${STASHED}" ]] && return echo "To restore the stashed changes to ${DIR}, run:" echo " cd ${DIR} && git stash pop" unset STASHED } reset_on_interrupt() { if [[ "${INITIAL_BRANCH}" != "${UPSTREAM_BRANCH}" && -n "${INITIAL_BRANCH}" ]] then git checkout "${INITIAL_BRANCH}" "${QUIET_ARGS[@]}" fi if [[ -n "${INITIAL_REVISION}" ]] then git rebase --abort &>/dev/null git merge --abort &>/dev/null git reset --hard "${INITIAL_REVISION}" "${QUIET_ARGS[@]}" fi if [[ -n "${HOMEBREW_NO_UPDATE_CLEANUP}" ]] then pop_stash else pop_stash_message fi exit 130 } # Used for testing purposes, e.g. for testing formula migration after # renaming it in the currently checked-out branch. To test run # "brew update --simulate-from-current-branch" simulate_from_current_branch() { local DIR local TAP_VAR local UPSTREAM_BRANCH local CURRENT_REVISION DIR="$1" cd "${DIR}" || return TAP_VAR="$2" UPSTREAM_BRANCH="$3" CURRENT_REVISION="$4" INITIAL_REVISION="$(git rev-parse -q --verify "${UPSTREAM_BRANCH}")" export HOMEBREW_UPDATE_BEFORE"${TAP_VAR}"="${INITIAL_REVISION}" export HOMEBREW_UPDATE_AFTER"${TAP_VAR}"="${CURRENT_REVISION}" if [[ "${INITIAL_REVISION}" != "${CURRENT_REVISION}" ]] then HOMEBREW_UPDATED="1" fi if ! git merge-base --is-ancestor "${INITIAL_REVISION}" "${CURRENT_REVISION}" then odie "Your ${DIR} HEAD is not a descendant of ${UPSTREAM_BRANCH}!" fi } merge_or_rebase() { if [[ -n "${HOMEBREW_VERBOSE}" ]] then echo "Updating ${DIR}..." fi local DIR local TAP_VAR local UPSTREAM_BRANCH DIR="$1" cd "${DIR}" || return TAP_VAR="$2" UPSTREAM_BRANCH="$3" unset STASHED trap reset_on_interrupt SIGINT if [[ "${DIR}" == "${HOMEBREW_REPOSITORY}" && -n "${HOMEBREW_UPDATE_TO_TAG}" ]] then UPSTREAM_TAG="$( git tag --list --sort=-version:refname | grep -m 1 '^[0-9]*\.[0-9]*\.[0-9]*$' )" else UPSTREAM_TAG="" fi if [[ -n "${UPSTREAM_TAG}" ]] then REMOTE_REF="refs/tags/${UPSTREAM_TAG}" UPSTREAM_BRANCH="stable" else REMOTE_REF="origin/${UPSTREAM_BRANCH}" fi if [[ -n "$(git status --untracked-files=all --porcelain 2>/dev/null)" ]] then if [[ -n "${HOMEBREW_VERBOSE}" ]] then echo "Stashing uncommitted changes to ${DIR}..." fi git merge --abort &>/dev/null git rebase --abort &>/dev/null git reset --mixed "${QUIET_ARGS[@]}" if ! git -c "user.email=brew-update@localhost" \ -c "user.name=brew update" \ stash save --include-untracked "${QUIET_ARGS[@]}" then odie </dev/null then git checkout --force "${UPSTREAM_BRANCH}" "${QUIET_ARGS[@]}" else if [[ -n "${UPSTREAM_TAG}" && "${UPSTREAM_BRANCH}" != "master" && "${UPSTREAM_BRANCH}" != "main" ]] && [[ "${INITIAL_BRANCH}" != "master" && "${INITIAL_BRANCH}" != "main" ]] then local detected_upstream_branch detected_upstream_branch="$(upstream_branch)" git branch --force "${detected_upstream_branch}" "origin/${detected_upstream_branch}" "${QUIET_ARGS[@]}" fi git checkout --force -B "${UPSTREAM_BRANCH}" "${REMOTE_REF}" "${QUIET_ARGS[@]}" fi fi INITIAL_REVISION="$(read_current_revision)" export HOMEBREW_UPDATE_BEFORE"${TAP_VAR}"="${INITIAL_REVISION}" # ensure we don't munge line endings on checkout git config --bool core.autocrlf false # make sure symlinks are saved as-is git config --bool core.symlinks true if [[ -z "${HOMEBREW_MERGE}" ]] then # Work around bug where git rebase --quiet is not quiet if [[ -z "${HOMEBREW_VERBOSE}" ]] then git rebase "${QUIET_ARGS[@]}" "${REMOTE_REF}" >/dev/null else git rebase "${QUIET_ARGS[@]}" "${REMOTE_REF}" fi else git merge --no-edit --ff "${QUIET_ARGS[@]}" "${REMOTE_REF}" \ --strategy=recursive \ --strategy-option=ours \ --strategy-option=ignore-all-space fi CURRENT_REVISION="$(read_current_revision)" export HOMEBREW_UPDATE_AFTER"${TAP_VAR}"="${CURRENT_REVISION}" if [[ "${INITIAL_REVISION}" != "${CURRENT_REVISION}" ]] then HOMEBREW_UPDATED="1" fi trap '' SIGINT if [[ -n "${HOMEBREW_NO_UPDATE_CLEANUP}" ]] then if [[ -z "${MAIN_MIGRATION_REQUIRED}" && "${INITIAL_BRANCH}" != "${UPSTREAM_BRANCH}" && -n "${INITIAL_BRANCH}" ]] && [[ ! "${INITIAL_BRANCH}" =~ ^v[0-9]+\.[0-9]+\.[0-9]|stable$ ]] then git checkout "${INITIAL_BRANCH}" "${QUIET_ARGS[@]}" fi pop_stash else pop_stash_message fi if [[ -n "${MAIN_MIGRATION_REQUIRED}" ]] then if [[ -n "$(git config branch.main.remote 2>/dev/null || true)" ]] then git branch -d "${QUIET_ARGS[@]}" master else opoo "$( cat <>"${update_failed_file}" fi } homebrew-update() { local option local DIR local UPSTREAM_BRANCH for option in "$@" do case "${option}" in -\? | -h | --help | --usage) brew help update exit $? ;; --verbose) HOMEBREW_VERBOSE=1 ;; --debug) HOMEBREW_DEBUG=1 ;; --quiet) HOMEBREW_QUIET=1 ;; --merge) shift HOMEBREW_MERGE=1 ;; --force) HOMEBREW_UPDATE_FORCE=1 ;; --simulate-from-current-branch) shift HOMEBREW_SIMULATE_FROM_CURRENT_BRANCH=1 ;; --auto-update) export HOMEBREW_UPDATE_AUTO=1 ;; --*) onoe "Unknown option: ${option}" brew help update exit 1 ;; -*) [[ "${option}" == *v* ]] && HOMEBREW_VERBOSE=1 [[ "${option}" == *q* ]] && HOMEBREW_QUIET=1 [[ "${option}" == *d* ]] && HOMEBREW_DEBUG=1 [[ "${option}" == *f* ]] && HOMEBREW_UPDATE_FORCE=1 ;; *) opoo "Use \`brew upgrade $*\` to upgrade formulae; running it instead." exec "${HOMEBREW_BREW_FILE}" upgrade "$@" ;; esac done if [[ -n "${HOMEBREW_DEBUG}" ]] then set -x fi if [[ -z "${HOMEBREW_UPDATE_TO_TAG}" ]] then if [[ -n "${HOMEBREW_DEVELOPER}" || -n "${HOMEBREW_DEV_CMD_RUN}" ]] then export HOMEBREW_NO_UPDATE_CLEANUP="1" else export HOMEBREW_UPDATE_TO_TAG="1" fi fi # check permissions if [[ -e "${HOMEBREW_CELLAR}" && ! -w "${HOMEBREW_CELLAR}" ]] then odie </dev/null || [[ -n "${HOMEBREW_FORCE_BREWED_GIT}" && ! -x "${HOMEBREW_PREFIX}/opt/git/bin/git" ]] then # we cannot install a Homebrew Git if homebrew/core is unavailable. if [[ -z "${HOMEBREW_CORE_AVAILABLE}" ]] || ! brew install git then odie "'git' must be installed and in your PATH!" fi setup_git fi [[ -f "${HOMEBREW_CORE_REPOSITORY}/.git/shallow" ]] && HOMEBREW_CORE_SHALLOW=1 [[ -f "${HOMEBREW_CASK_REPOSITORY}/.git/shallow" ]] && HOMEBREW_CASK_SHALLOW=1 if [[ -n "${HOMEBREW_CORE_SHALLOW}" && -n "${HOMEBREW_CASK_SHALLOW}" ]] then SHALLOW_COMMAND_PHRASE="These commands" SHALLOW_REPO_PHRASE="repositories" else SHALLOW_COMMAND_PHRASE="This command" SHALLOW_REPO_PHRASE="repository" fi if [[ -n "${HOMEBREW_CORE_SHALLOW}" || -n "${HOMEBREW_CASK_SHALLOW}" ]] then odie </dev/null)" == "true" ]] then export HOMEBREW_FETCH_EXECUTABLES_TXT=1 fi # if an older system had a newer curl installed, change each repo's remote URL from git to https if [[ -n "${HOMEBREW_SYSTEM_CURL_TOO_OLD}" && -x "${HOMEBREW_PREFIX}/opt/curl/bin/curl" ]] && [[ "$(git config remote.origin.url)" =~ ^git:// ]] then git config remote.origin.url "${HOMEBREW_BREW_GIT_REMOTE}" git config -f "${HOMEBREW_CORE_REPOSITORY}/.git/config" remote.origin.url "${HOMEBREW_CORE_GIT_REMOTE}" fi # kill all of subprocess on interrupt trap '{ /usr/bin/pkill -P $$; wait; exit 130; }' SIGINT local update_failed_file="${HOMEBREW_REPOSITORY}/.git/UPDATE_FAILED" local missing_remote_ref_dirs_file="${HOMEBREW_REPOSITORY}/.git/FAILED_FETCH_DIRS" rm -f "${update_failed_file}" rm -f "${missing_remote_ref_dirs_file}" for DIR in "${HOMEBREW_REPOSITORY}" "${HOMEBREW_LIBRARY}"/Taps/*/* do if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" ]] && [[ -n "${HOMEBREW_UPDATE_AUTO}" || (-z "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_DEV_CMD_RUN}") ]] && [[ -n "${HOMEBREW_UPDATE_AUTO}" && (("${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" && -z "${HOMEBREW_AUTO_UPDATE_CORE_TAP}") || ("${DIR}" == "${HOMEBREW_CASK_REPOSITORY}" && -z "${HOMEBREW_AUTO_UPDATE_CASK_TAP}")) ]] then continue fi [[ -d "${DIR}/.git" ]] || continue cd "${DIR}" || continue if [[ "${DIR}" = "${HOMEBREW_REPOSITORY}" && "${HOMEBREW_REPOSITORY}" = "${HOMEBREW_PREFIX}" ]] then # Git's fsmonitor prevents the release of our locks git config --bool core.fsmonitor false fi if ! git config --local --get remote.origin.url &>/dev/null then opoo "No remote 'origin' in ${DIR}, skipping update!" continue fi if [[ -n "${HOMEBREW_VERBOSE}" ]] then echo "Checking if we need to fetch ${DIR}..." fi TAP_VAR="$(repository_var_suffix "${DIR}")" UPSTREAM_BRANCH_DIR="$(upstream_branch)" declare UPSTREAM_BRANCH"${TAP_VAR}"="${UPSTREAM_BRANCH_DIR}" declare PREFETCH_REVISION"${TAP_VAR}"="$(git rev-parse -q --verify refs/remotes/origin/"${UPSTREAM_BRANCH_DIR}")" if [[ -n "${GITHUB_ACTIONS}" && -n "${HOMEBREW_UPDATE_SKIP_BREW}" && "${DIR}" == "${HOMEBREW_REPOSITORY}" ]] then continue fi # Force a full update if we don't have any tags. if [[ "${DIR}" == "${HOMEBREW_REPOSITORY}" && -z "$(git tag --list)" ]] then HOMEBREW_UPDATE_FORCE=1 fi if [[ -z "${HOMEBREW_UPDATE_FORCE}" ]] then [[ -n "${SKIP_FETCH_BREW_REPOSITORY}" && "${DIR}" == "${HOMEBREW_REPOSITORY}" ]] && continue [[ -n "${SKIP_FETCH_CORE_REPOSITORY}" && "${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" ]] && continue fi if [[ -z "${UPDATING_MESSAGE_SHOWN}" ]] then if [[ -n "${HOMEBREW_UPDATE_AUTO}" ]] then # Outputting a command but don't want to run it, hence single quotes. # shellcheck disable=SC2016 ohai 'Auto-updating Homebrew...' >&2 if [[ -z "${HOMEBREW_NO_ENV_HINTS}" && -z "${HOMEBREW_AUTO_UPDATE_SECS}" ]] then # shellcheck disable=SC2016 echo 'Adjust how often this is run with `$HOMEBREW_AUTO_UPDATE_SECS` or disable with' >&2 # shellcheck disable=SC2016 echo '`$HOMEBREW_NO_AUTO_UPDATE=1`. Hide these hints with `$HOMEBREW_NO_ENV_HINTS=1` (see `man brew`).' >&2 fi else ohai 'Updating Homebrew...' >&2 fi UPDATING_MESSAGE_SHOWN=1 fi # The upstream repository's default branch may not be main or master; # check refs/remotes/origin/HEAD to see what the default # origin branch name is, and use that. If not set, fall back to "main". # the refspec ensures that the default upstream branch gets updated ( UPSTREAM_REPOSITORY_URL="$(git config remote.origin.url)" unset UPSTREAM_REPOSITORY unset UPSTREAM_REPOSITORY_TOKEN # HOMEBREW_UPDATE_FORCE and HOMEBREW_UPDATE_AUTO aren't modified here so ignore subshell warning. # shellcheck disable=SC2030 if [[ "${UPSTREAM_REPOSITORY_URL}" == "https://github.com/"* ]] then UPSTREAM_REPOSITORY="${UPSTREAM_REPOSITORY_URL#https://github.com/}" UPSTREAM_REPOSITORY="${UPSTREAM_REPOSITORY%.git}" elif [[ "${DIR}" != "${HOMEBREW_REPOSITORY}" ]] && [[ "${UPSTREAM_REPOSITORY_URL}" =~ https://([[:alnum:]_:]+)@github.com/(.*)$ ]] then UPSTREAM_REPOSITORY="${BASH_REMATCH[2]%.git}" UPSTREAM_REPOSITORY_TOKEN="${BASH_REMATCH[1]#*:}" fi MAIN_MIGRATION_REQUIRED= if [[ "${UPSTREAM_BRANCH_DIR}" == "master" && ("${DIR}" == "${HOMEBREW_REPOSITORY}" || "${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" || "${DIR}" == "${HOMEBREW_CASK_REPOSITORY}") ]] then # Migrate master to main for Homebrew/brew, homebrew-core or homebrew-cask MAIN_MIGRATION_REQUIRED=1 UPSTREAM_BRANCH_DIR="main" declare UPSTREAM_BRANCH"${TAP_VAR}"="main" fi if [[ -n "${UPSTREAM_REPOSITORY}" ]] then # UPSTREAM_REPOSITORY_TOKEN is parsed (if exists) from UPSTREAM_REPOSITORY_URL # HOMEBREW_GITHUB_API_TOKEN is optionally defined in the user environment. # shellcheck disable=SC2153 if [[ -n "${UPSTREAM_REPOSITORY_TOKEN}" ]] then CURL_GITHUB_API_ARGS=("--header" "Authorization: token ${UPSTREAM_REPOSITORY_TOKEN}") elif [[ -n "${HOMEBREW_GITHUB_API_TOKEN}" ]] then CURL_GITHUB_API_ARGS=("--header" "Authorization: token ${HOMEBREW_GITHUB_API_TOKEN}") else CURL_GITHUB_API_ARGS=() fi if [[ "${DIR}" == "${HOMEBREW_REPOSITORY}" && -n "${HOMEBREW_UPDATE_TO_TAG}" ]] then # Only try to `git fetch` when the upstream tags have changed # (so the API does not return 304: unmodified). GITHUB_API_ETAG="$(sed -n 's/^ETag: "\([a-f0-9]\{32\}\)".*/\1/p' ".git/GITHUB_HEADERS" 2>/dev/null)" GITHUB_API_ACCEPT="application/vnd.github+json" GITHUB_API_ENDPOINT="tags" else # Only try to `git fetch` when the upstream branch is at a different SHA # (so the API does not return 304: unmodified). GITHUB_API_ETAG="$(git rev-parse "refs/remotes/origin/${UPSTREAM_BRANCH_DIR}")" GITHUB_API_ACCEPT="application/vnd.github.sha" GITHUB_API_ENDPOINT="commits/${UPSTREAM_BRANCH_DIR}" fi # HOMEBREW_CURL is set by brew.sh (and isn't misspelt here) # shellcheck disable=SC2153 UPSTREAM_SHA_HTTP_CODE="$( curl \ "${CURL_DISABLE_CURLRC_ARGS[@]}" \ "${CURL_GITHUB_API_ARGS[@]}" \ --silent --max-time 3 \ --location --no-remote-time --output /dev/null --write-out "%{http_code}" \ --dump-header "${DIR}/.git/GITHUB_HEADERS" \ --user-agent "${HOMEBREW_USER_AGENT_CURL}" \ --header "X-GitHub-Api-Version:2022-11-28" \ --header "Accept: ${GITHUB_API_ACCEPT}" \ --header "If-None-Match: \"${GITHUB_API_ETAG}\"" \ "https://api.github.com/repos/${UPSTREAM_REPOSITORY}/${GITHUB_API_ENDPOINT}" )" # Touch FETCH_HEAD to confirm we've checked for an update. [[ -f "${DIR}/.git/FETCH_HEAD" ]] && touch "${DIR}/.git/FETCH_HEAD" [[ -z "${HOMEBREW_UPDATE_FORCE}" ]] && [[ "${UPSTREAM_SHA_HTTP_CODE}" == "304" ]] && exit fi # HOMEBREW_VERBOSE isn't modified here so ignore subshell warning. # shellcheck disable=SC2030 if [[ -n "${HOMEBREW_VERBOSE}" ]] then echo "Fetching ${DIR}..." fi local tmp_failure_file="${DIR}/.git/TMP_FETCH_FAILURES" rm -f "${tmp_failure_file}" if ! git fetch --tags --force "${QUIET_ARGS[@]}" origin \ "refs/heads/${UPSTREAM_BRANCH_DIR}:refs/remotes/origin/${UPSTREAM_BRANCH_DIR}" 2>>"${tmp_failure_file}" then if [[ -f "${tmp_failure_file}" ]] then local git_errors git_errors="$(cat "${tmp_failure_file}")" # Attempt migration from master to main branch. if [[ "${git_errors}" == *"couldn't find remote ref refs/heads/master"* ]] then if git fetch --tags --force "${QUIET_ARGS[@]}" origin \ "refs/heads/main:refs/remotes/origin/main" 2>>"${tmp_failure_file}" then rm -f "${DIR}/.git/refs/remotes/origin/HEAD" "${DIR}/.git/refs/remotes/origin/master" UPSTREAM_BRANCH_DIR="$(upstream_branch)" declare UPSTREAM_BRANCH"${TAP_VAR}"="${UPSTREAM_BRANCH_DIR}" git branch -m master main "${QUIET_ARGS[@]}" git branch -u origin/main main "${QUIET_ARGS[@]}" rm -f "${tmp_failure_file}" exit fi fi rm -f "${tmp_failure_file}" fi # Don't output errors if HOMEBREW_UPDATE_AUTO is set. if [[ -n "${HOMEBREW_UPDATE_AUTO}" ]] then exit fi # Reprint fetch errors to stderr [[ -n "${git_errors}" ]] && echo "${git_errors}" 1>&2 if [[ "${UPSTREAM_SHA_HTTP_CODE}" == "404" ]] then TAP="${DIR#"${HOMEBREW_LIBRARY}"/Taps/}" echo "${TAP} does not exist! Run \`brew untap ${TAP}\` to remove it." >>"${update_failed_file}" else echo "Fetching ${DIR} failed!" >>"${update_failed_file}" if [[ -f "${tmp_failure_file}" ]] && [[ "$(cat "${tmp_failure_file}")" == "fatal: couldn't find remote ref refs/heads/${UPSTREAM_BRANCH_DIR}" ]] then echo "${DIR}" >>"${missing_remote_ref_dirs_file}" fi fi fi if [[ -n "${MAIN_MIGRATION_REQUIRED}" ]] then git remote set-head origin --auto >/dev/null fi rm -f "${tmp_failure_file}" ) & done wait trap - SIGINT if [[ -f "${missing_remote_ref_dirs_file}" ]] then HOMEBREW_MISSING_REMOTE_REF_DIRS="$(cat "${missing_remote_ref_dirs_file}")" rm -f "${missing_remote_ref_dirs_file}" export HOMEBREW_MISSING_REMOTE_REF_DIRS fi for DIR in "${HOMEBREW_REPOSITORY}" "${HOMEBREW_LIBRARY}"/Taps/*/* do if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" ]] && [[ -n "${HOMEBREW_UPDATE_AUTO}" || (-z "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_DEV_CMD_RUN}") ]] && [[ -n "${HOMEBREW_UPDATE_AUTO}" && (("${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" && -z "${HOMEBREW_AUTO_UPDATE_CORE_TAP}") || ("${DIR}" == "${HOMEBREW_CASK_REPOSITORY}" && -z "${HOMEBREW_AUTO_UPDATE_CASK_TAP}")) ]] then continue fi [[ -d "${DIR}/.git" ]] || continue cd "${DIR}" || continue if ! git config --local --get remote.origin.url &>/dev/null then # No need to display a (duplicate) warning here continue fi TAP_VAR="$(repository_var_suffix "${DIR}")" UPSTREAM_BRANCH_VAR="UPSTREAM_BRANCH${TAP_VAR}" UPSTREAM_BRANCH="${!UPSTREAM_BRANCH_VAR}" CURRENT_REVISION="$(read_current_revision)" PREFETCH_REVISION_VAR="PREFETCH_REVISION${TAP_VAR}" PREFETCH_REVISION="${!PREFETCH_REVISION_VAR}" POSTFETCH_REVISION="$(git rev-parse -q --verify refs/remotes/origin/"${UPSTREAM_BRANCH}")" # HOMEBREW_UPDATE_FORCE and HOMEBREW_VERBOSE weren't modified in subshell. # shellcheck disable=SC2031 if [[ -n "${HOMEBREW_SIMULATE_FROM_CURRENT_BRANCH}" ]] then simulate_from_current_branch "${DIR}" "${TAP_VAR}" "${UPSTREAM_BRANCH}" "${CURRENT_REVISION}" elif [[ -z "${HOMEBREW_UPDATE_FORCE}" && "${PREFETCH_REVISION}" == "${POSTFETCH_REVISION}" && "${CURRENT_REVISION}" == "${POSTFETCH_REVISION}" ]] || [[ -n "${GITHUB_ACTIONS}" && -n "${HOMEBREW_UPDATE_SKIP_BREW}" && "${DIR}" == "${HOMEBREW_REPOSITORY}" ]] then export HOMEBREW_UPDATE_BEFORE"${TAP_VAR}"="${CURRENT_REVISION}" export HOMEBREW_UPDATE_AFTER"${TAP_VAR}"="${CURRENT_REVISION}" else merge_or_rebase "${DIR}" "${TAP_VAR}" "${UPSTREAM_BRANCH}" fi done if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" ]] then if [[ -n "${HOMEBREW_USE_INTERNAL_API}" ]] then api_files=("internal/formula.$(bottle_tag)" "internal/cask.$(bottle_tag)") else api_files=(formula cask formula_tap_migrations cask_tap_migrations) fi for json in "${api_files[@]}" do local filename="${json}.jws.json" fetch_api_file "${filename}" "${update_failed_file}" done if [[ -n "${HOMEBREW_USE_INTERNAL_API}" ]] then # Remove files only downloaded by the regular API rm -f "${HOMEBREW_CACHE}/api/formula.jws.json" "${HOMEBREW_CACHE}/api/cask.jws.json" rm -f "${HOMEBREW_CACHE}/api/formula_tap_migrations.jws.json" "${HOMEBREW_CACHE}/api/cask_tap_migrations.jws.json" else # Remove files only downloaded by the internal API rm -f "${HOMEBREW_CACHE}/api/internal/formula.$(bottle_tag).jws.json" rm -f "${HOMEBREW_CACHE}/api/internal/cask.$(bottle_tag).jws.json" fi # Not a typo, these are the files we used to download that no longer need so should cleanup. rm -f "${HOMEBREW_CACHE}/api/formula.json" "${HOMEBREW_CACHE}/api/cask.json" else if [[ -n "${HOMEBREW_VERBOSE}" ]] then echo "HOMEBREW_NO_INSTALL_FROM_API set: skipping API JSON downloads." fi fi # Update executables.txt if the user has ever run `brew which-formula` before. if [[ -n "${HOMEBREW_FETCH_EXECUTABLES_TXT}" ]] then fetch_api_file "internal/executables.txt" "${update_failed_file}" fi if [[ -f "${update_failed_file}" ]] then onoe <"${update_failed_file}" rm -f "${update_failed_file}" export HOMEBREW_UPDATE_FAILED="1" fi safe_cd "${HOMEBREW_REPOSITORY}" # HOMEBREW_UPDATE_AUTO wasn't modified in subshell. # shellcheck disable=SC2031 if [[ -n "${HOMEBREW_UPDATED}" ]] || [[ -n "${HOMEBREW_UPDATE_FAILED}" ]] || [[ -n "${HOMEBREW_MISSING_REMOTE_REF_DIRS}" ]] || [[ -n "${HOMEBREW_UPDATE_FORCE}" ]] || [[ -d "${HOMEBREW_LIBRARY}/LinkedKegs" ]] || [[ ! -f "${HOMEBREW_CACHE}/all_commands_list.txt" ]] || [[ -n "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_UPDATE_AUTO}" ]] then brew update-report "$@" return $? elif [[ -z "${HOMEBREW_UPDATE_AUTO}" && -z "${HOMEBREW_QUIET}" ]] then echo "Already up-to-date." fi } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/upgrade.rb000066400000000000000000000523761517265720000226400ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula_installer" require "install" require "upgrade" require "cask/utils" require "cask/upgrade" require "api" require "reinstall" module Homebrew module Cmd class UpgradeCmd < AbstractCommand class FormulaeUpgradeContext < T::Struct const :formulae_to_install, T::Array[Formula] const :formulae_installer, T::Array[FormulaInstaller] const :dependants, Homebrew::Upgrade::Dependents end cmd_args do description <<~EOS Upgrade outdated casks and outdated, unpinned formulae using the same options they were originally installed with, plus any appended brew formula options. If or are specified, upgrade only the given or kegs (unless they are pinned; see `pin`, `unpin`). Unless `$HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for outdated dependents and dependents with broken linkage, respectively. Unless `$HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the upgraded formulae or, every 30 days, for all formulae. EOS switch "-d", "--debug", description: "If brewing fails, open an interactive debugging session with access to IRB " \ "or a shell inside the temporary build directory." switch "--display-times", description: "Print install times for each package at the end of the run.", env: :display_install_times switch "-f", "--force", description: "Install formulae without checking for previously installed keg-only or " \ "non-migrated versions. When installing casks, overwrite existing files " \ "(binaries and symlinks are excluded, unless originally from the same cask)." switch "-v", "--verbose", description: "Print the verification and post-install steps." switch "-n", "--dry-run", description: "Show what would be upgraded, but do not actually upgrade anything." switch "--ask", description: "Ask for confirmation before downloading and upgrading formulae. " \ "Print download, install and net install sizes of bottles and dependencies.", env: :ask [ [:switch, "--formula", "--formulae", { description: "Treat all named arguments as formulae. If no named arguments " \ "are specified, upgrade only outdated formulae.", }], [:switch, "-s", "--build-from-source", { description: "Compile from source even if a bottle is available.", }], [:switch, "-i", "--interactive", { description: "Download and patch , then open a shell. This allows the user to " \ "run `./configure --help` and otherwise determine how to turn the software " \ "package into a Homebrew package.", }], [:switch, "--force-bottle", { description: "Install from a bottle if it exists for the current or newest version of " \ "macOS, even if it would not normally be used for installation.", }], [:switch, "--fetch-HEAD", { description: "Fetch the upstream repository to detect if the HEAD installation of the " \ "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \ "updates when a new stable or development version has been released.", }], [:switch, "--keep-tmp", { description: "Retain the temporary files created during installation.", }], [:switch, "--debug-symbols", { depends_on: "--build-from-source", description: "Generate debug symbols on build. Source will be retained in a cache directory.", }], [:switch, "--overwrite", { description: "Delete files that already exist in the prefix while linking.", }], ].each do |args| options = args.pop send(*args, **options) conflicts "--cask", args.last end formula_options [ [:switch, "--cask", "--casks", { description: "Treat all named arguments as casks. If no named arguments " \ "are specified, upgrade only outdated casks.", }], [:switch, "--skip-cask-deps", { description: "Skip installing cask dependencies.", }], [:switch, "-g", "--greedy", { description: "Also include casks with `version :latest` and `auto_updates true` casks " \ "that would otherwise be skipped.", env: :upgrade_greedy, }], [:switch, "--greedy-latest", { description: "Also include casks with `version :latest`.", }], [:switch, "--greedy-auto-updates", { description: "Also include `auto_updates true` casks that would otherwise be skipped.", }], [:switch, "--[no-]binaries", { description: "Disable/enable linking of helper executables (default: enabled).", env: :cask_opts_binaries, }], [:switch, "--require-sha", { description: "Require all casks to have a checksum.", env: :cask_opts_require_sha, }], [:switch, "--[no-]quarantine", { env: :cask_opts_quarantine, odisabled: true, }], ].each do |args| options = args.pop send(*args, **options) conflicts "--formula", args.last end cask_options conflicts "--build-from-source", "--force-bottle" named_args [:installed_formula, :installed_cask] end sig { override.void } def run if args.build_from_source? && args.named.empty? raise ArgumentError, "`--build-from-source` requires at least one formula" end formulae = T.let([], T::Array[Formula]) casks = T.let([], T::Array[Cask::Cask]) unavailable_errors = T.let( [], T::Array[T.any(FormulaOrCaskUnavailableError, NoSuchKegError)], ) @prefetched_formulae_upgrade_context = T.let(nil, T.nilable(FormulaeUpgradeContext)) prefetched_formulae_names = T.let([], T::Array[String]) prefetched_formulae_upgrades = T.let([], T::Array[String]) prefetched_cask_names = T.let([], T::Array[String]) prefetched_cask_upgrades = T.let([], T::Array[String]) if args.named.present? args.named.to_formulae_and_casks_and_unavailable(method: :resolve).each do |item| case item when FormulaOrCaskUnavailableError, NoSuchKegError unavailable_errors << item when Formula formulae << item when Cask::Cask casks << item end end end # If one or more formulae are specified, but no casks were # specified, we want to make note of that so we don't # try to upgrade all outdated casks. # # When names were given, we must also prevent empty resolved lists # from triggering the "upgrade all" path (which happens when all # names failed resolution). named_given = args.named.present? only_upgrade_formulae = (named_given && casks.blank?) || (formulae.present? && casks.blank?) only_upgrade_casks = (named_given && formulae.blank?) || (casks.present? && formulae.blank?) formulae = Homebrew::Attestation.sort_formulae_for_install(formulae) if Homebrew::Attestation.enabled? prefetched_casks = T.let(false, T::Boolean) shared_download_queue = T.let(nil, T.nilable(Homebrew::DownloadQueue)) if !args.dry_run? && !only_upgrade_formulae && !only_upgrade_casks shared_download_queue = Homebrew::DownloadQueue.new(pour: true) begin upgrade_outdated_formulae!( formulae, prefetch_only: true, download_queue: shared_download_queue, prefetch_names: prefetched_formulae_names, prefetch_upgrades: prefetched_formulae_upgrades, show_upgrade_summary: false, show_downloads_heading: false, ) prefetched_casks = prefetch_outdated_casks!( casks, download_queue: shared_download_queue, prefetch_names: prefetched_cask_names, prefetch_upgrades: prefetched_cask_upgrades, show_downloads_heading: false, ) Cask::Upgrade.show_upgrade_summary( prefetched_formulae_upgrades + prefetched_cask_upgrades, dry_run: args.dry_run?, ) Install.show_combined_fetch_downloads_heading( formula_names: prefetched_formulae_names, cask_names: prefetched_cask_names, ) shared_download_queue.fetch ensure shared_download_queue.shutdown end end upgrade_outdated_formulae!(formulae, use_prefetched: true) unless only_upgrade_casks unless only_upgrade_formulae upgrade_outdated_casks!( casks, skip_prefetch: prefetched_casks, download_queue: nil, ) end unavailable_errors.each { |e| ofail e } Cleanup.periodic_clean!(dry_run: args.dry_run?) Homebrew::Reinstall.reinstall_pkgconf_if_needed!(dry_run: args.dry_run?) Homebrew.messages.display_messages(display_times: args.display_times?) end private sig { params(formulae: T::Array[Formula], show_upgrade_summary: T::Boolean).returns(T.nilable(FormulaeUpgradeContext)) } def formulae_upgrade_context(formulae, show_upgrade_summary: true) if args.build_from_source? unless DevelopmentTools.installed? raise BuildFlagsError.new(["--build-from-source"], bottled: formulae.all?(&:bottled?)) end unless Homebrew::EnvConfig.developer? opoo "building from source is not supported!" puts "You're on your own. Failures are expected so don't create any issues, please!" end end if formulae.blank? outdated = Formula.installed.select do |f| f.outdated?(fetch_head: args.fetch_HEAD?) end else outdated, not_outdated = formulae.partition do |f| f.outdated?(fetch_head: args.fetch_HEAD?) end not_outdated.each do |f| latest_keg = f.installed_kegs.max_by(&:scheme_and_version) if latest_keg.nil? ofail "#{f.full_specified_name} not installed" else opoo "#{f.full_specified_name} #{latest_keg.version} already installed" unless args.quiet? end end end return if outdated.blank? pinned = outdated.select(&:pinned?) outdated -= pinned formulae_to_install = outdated.map do |f| f_latest = f.latest_formula if f_latest.latest_version_installed? f else f_latest end end if pinned.any? message = "Not upgrading #{pinned.count} pinned #{Utils.pluralize("package", pinned.count)}:" # only fail when pinned formulae are named explicitly if formulae.any? ofail message else opoo message end puts pinned.map { |f| "#{f.full_specified_name} #{f.pkg_version}" } * ", " end if formulae_to_install.empty? oh1 "No packages to upgrade" if show_upgrade_summary elsif show_upgrade_summary verb = args.dry_run? ? "Would upgrade" : "Upgrading" oh1 "#{verb} #{formulae_to_install.count} outdated #{Utils.pluralize("package", formulae_to_install.count)}:" puts formula_upgrade_descriptions(formulae_to_install).join("\n") unless args.ask? end Install.perform_preinstall_checks_once formulae_installer = Upgrade.formula_installers( formulae_to_install, flags: args.flags_only, dry_run: args.dry_run?, force_bottle: args.force_bottle?, build_from_source_formulae: args.build_from_source_formulae, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, overwrite: args.overwrite?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose?, ) return if formulae_installer.blank? dependants = Upgrade.dependants( formulae_to_install, flags: args.flags_only, dry_run: args.dry_run?, ask: args.ask?, force_bottle: args.force_bottle?, build_from_source_formulae: args.build_from_source_formulae, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose?, ) # Main block: if asking the user is enabled, show dependency and size information. Install.ask_formulae(formulae_installer, dependants, args: args) if args.ask? FormulaeUpgradeContext.new( formulae_to_install:, formulae_installer: formulae_installer, dependants:, ) end sig { params(formulae: T::Array[Formula]).returns(T::Array[String]) } def formula_upgrade_descriptions(formulae) formulae.map do |formula| if formula.optlinked? "#{formula.full_specified_name} #{Keg.new(formula.opt_prefix).version} -> #{formula.pkg_version}" else "#{formula.full_specified_name} #{formula.pkg_version}" end end end sig { params( formulae: T::Array[Formula], prefetch_only: T::Boolean, use_prefetched: T::Boolean, download_queue: T.nilable(Homebrew::DownloadQueue), prefetch_names: T.nilable(T::Array[String]), prefetch_upgrades: T.nilable(T::Array[String]), show_upgrade_summary: T::Boolean, show_downloads_heading: T::Boolean, ).returns(T::Boolean) } def upgrade_outdated_formulae!(formulae, prefetch_only: false, use_prefetched: false, download_queue: nil, prefetch_names: nil, prefetch_upgrades: nil, show_upgrade_summary: true, show_downloads_heading: true) return false if args.cask? use_prefetched_context = use_prefetched && @prefetched_formulae_upgrade_context context = if use_prefetched_context @prefetched_formulae_upgrade_context else formulae_upgrade_context(formulae, show_upgrade_summary:) end return false if context.blank? if prefetch_only prefetch_download_queue = download_queue || Homebrew.default_download_queue valid_formula_installers = Install.enqueue_formulae(context.formulae_installer, download_queue: prefetch_download_queue) if show_downloads_heading Install.show_combined_fetch_downloads_heading( formula_names: valid_formula_installers.map { |fi| fi.formula.name }, ) end prefetch_names&.replace(valid_formula_installers.map { |fi| fi.formula.name }) prefetch_upgrades&.replace(formula_upgrade_descriptions(valid_formula_installers.map(&:formula))) @prefetched_formulae_upgrade_context = FormulaeUpgradeContext.new( formulae_to_install: context.formulae_to_install, formulae_installer: valid_formula_installers, dependants: context.dependants, ) return valid_formula_installers.present? end Upgrade.upgrade_formulae( context.formulae_installer, dry_run: args.dry_run?, verbose: args.verbose?, fetch: !use_prefetched_context, ) Upgrade.upgrade_dependents( context.dependants, context.formulae_to_install, flags: args.flags_only, dry_run: args.dry_run?, force_bottle: args.force_bottle?, build_from_source_formulae: args.build_from_source_formulae, interactive: args.interactive?, keep_tmp: args.keep_tmp?, debug_symbols: args.debug_symbols?, force: args.force?, debug: args.debug?, quiet: args.quiet?, verbose: args.verbose? ) @prefetched_formulae_upgrade_context = nil if use_prefetched_context true end sig { params(casks: T::Array[Cask::Cask], download_queue: Homebrew::DownloadQueue, prefetch_names: T.nilable(T::Array[String]), prefetch_upgrades: T.nilable(T::Array[String]), show_downloads_heading: T::Boolean) .returns(T::Boolean) } def prefetch_outdated_casks!(casks, download_queue:, prefetch_names: nil, prefetch_upgrades: nil, show_downloads_heading: true) return false if args.formula? outdated_casks = Cask::Upgrade.outdated_casks( casks, args:, force: args.force?, quiet: true, greedy: args.greedy?, greedy_latest: args.greedy_latest?, greedy_auto_updates: args.greedy_auto_updates?, ) return false if outdated_casks.empty? manual_installer_casks = outdated_casks.select do |cask| cask.artifacts.any? do |artifact| artifact.is_a?(Cask::Artifact::Installer) && artifact.manual_install end end outdated_casks -= manual_installer_casks return false if outdated_casks.empty? require "cask/installer" fetchable_cask_installers = outdated_casks.map do |cask| Cask::Installer.new( cask, binaries: args.binaries?, verbose: args.verbose?, force: args.force?, skip_cask_deps: args.skip_cask_deps?, require_sha: args.require_sha?, upgrade: true, quarantine: args.quarantine?, download_queue:, defer_fetch: true, ) end cask_names = outdated_casks.map(&:full_name) Install.enqueue_cask_installers(fetchable_cask_installers) prefetch_names&.replace(cask_names) prefetch_upgrades&.replace( outdated_casks.map { |cask| "#{cask.full_name} #{cask.installed_version} -> #{cask.version}" }, ) Install.show_combined_fetch_downloads_heading(cask_names:) if show_downloads_heading true rescue => e ofail e false end sig { params(casks: T::Array[Cask::Cask], skip_prefetch: T::Boolean, download_queue: T.nilable(Homebrew::DownloadQueue)) .returns(T::Boolean) } def upgrade_outdated_casks!(casks, skip_prefetch: false, download_queue: nil) return false if args.formula? Install.ask_casks casks if args.ask? Cask::Upgrade.upgrade_casks!( *casks, force: args.force?, greedy: args.greedy?, greedy_latest: args.greedy_latest?, greedy_auto_updates: args.greedy_auto_updates?, dry_run: args.dry_run?, binaries: args.binaries?, quarantine: args.quarantine?, require_sha: args.require_sha?, skip_cask_deps: args.skip_cask_deps?, verbose: args.verbose?, quiet: args.quiet?, skip_prefetch:, show_upgrade_summary: !skip_prefetch, download_queue:, args:, ) rescue => e ofail e false end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/uses.rb000066400000000000000000000162201517265720000221540ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "cask/caskroom" require "dependencies_helpers" module Homebrew module Cmd # `brew uses foo bar` returns formulae that use both foo and bar # If you want the union, run the command twice and concatenate the results. # The intersection is harder to achieve with shell tools. class Uses < AbstractCommand include DependenciesHelpers class UnavailableFormula < T::Struct const :name, String const :full_name, String end cmd_args do description <<~EOS Show formulae and casks that specify as a dependency; that is, show dependents of . When given multiple formula arguments, show the intersection of formulae that use . By default, `uses` shows all formulae and casks that specify as a required or recommended dependency for their stable builds. *Note:* `--missing` and `--skip-recommended` have precedence over `--include-*`. EOS switch "--recursive", description: "Resolve more than one level of dependencies." switch "--installed", description: "Only list formulae and casks that are currently installed." switch "--missing", description: "Only list formulae and casks that are not currently installed." switch "--eval-all", description: "Evaluate all available formulae and casks, whether installed or not, to show " \ "their dependents.", env: :eval_all switch "--include-implicit", description: "Include formulae that have as an implicit dependency for " \ "downloading and unpacking source files." switch "--include-build", description: "Include formulae that specify as a `:build` dependency." switch "--include-test", description: "Include formulae that specify as a `:test` dependency." switch "--include-optional", description: "Include formulae that specify as an `:optional` dependency." switch "--skip-recommended", description: "Skip all formulae that specify as a `:recommended` dependency." switch "--formula", "--formulae", description: "Include only formulae." switch "--cask", "--casks", description: "Include only casks." conflicts "--formula", "--cask" conflicts "--installed", "--eval-all" conflicts "--missing", "--installed" named_args :formula, min: 1 end sig { override.void } def run Formulary.enable_factory_cache! used_formulae_missing = false used_formulae = begin args.named.to_formulae rescue FormulaUnavailableError => e opoo e used_formulae_missing = true # If the formula doesn't exist: fake the needed formula object name. args.named.map { |name| UnavailableFormula.new name:, full_name: name } end use_runtime_dependents = args.installed? && !used_formulae_missing && !args.include_implicit? && !args.include_build? && !args.include_test? && !args.include_optional? && !args.skip_recommended? uses = intersection_of_dependents(use_runtime_dependents, used_formulae) return if uses.empty? puts Formatter.columns(uses.map(&:full_name).sort) odie "Missing formulae should not have dependents!" if used_formulae_missing end private sig { params(use_runtime_dependents: T::Boolean, used_formulae: T::Array[T.any(Formula, UnavailableFormula)]) .returns(T::Array[T.any(Formula, CaskDependent)]) } def intersection_of_dependents(use_runtime_dependents, used_formulae) recursive = args.recursive? show_formulae_and_casks = !args.formula? && !args.cask? includes, ignores = args_includes_ignores(args) deps = [] if use_runtime_dependents # We can only get here if `used_formulae_missing` is false, thus there are no UnavailableFormula. used_formulae = T.cast(used_formulae, T::Array[Formula]) if show_formulae_and_casks || args.formula? deps += T.must(used_formulae.map(&:runtime_installed_formula_dependents) .reduce(&:&)) .select(&:any_version_installed?) end if show_formulae_and_casks || args.cask? deps += select_used_dependents( dependents(Cask::Caskroom.casks), used_formulae, recursive, includes, ignores ) end deps else eval_all = args.eval_all? if !args.installed? && !eval_all raise UsageError, "`brew uses` needs `--installed` or `--eval-all` passed or `HOMEBREW_EVAL_ALL=1` set!" end if show_formulae_and_casks || args.formula? deps += args.installed? ? Formula.installed : Formula.all(eval_all:) end if show_formulae_and_casks || args.cask? deps += args.installed? ? Cask::Caskroom.casks : Cask::Cask.all(eval_all:) end if args.missing? deps.reject! do |dep| case dep when Formula dep.any_version_installed? when Cask::Cask dep.installed? end end ignores.delete(:satisfied?) end select_used_dependents(dependents(deps), used_formulae, recursive, includes, ignores) end end sig { params( dependents: T::Array[T.any(Formula, CaskDependent)], used_formulae: T::Array[T.any(Formula, UnavailableFormula)], recursive: T::Boolean, includes: T::Array[Symbol], ignores: T::Array[Symbol], ).returns(T::Array[T.any(Formula, CaskDependent)]) } def select_used_dependents(dependents, used_formulae, recursive, includes, ignores) dependents.select do |d| deps = if recursive recursive_dep_includes(d, includes, ignores) else select_includes(d.deps, ignores, includes) end used_formulae.all? do |ff| deps.any? do |dep| match = case dep when Dependency dep.to_formula.full_name == ff.full_name if dep.name.include?("/") when Requirement nil else T.absurd(dep) end next match unless match.nil? dep.name == ff.name end rescue FormulaUnavailableError # Silently ignore this case as we don't care about things used in # taps that aren't currently tapped. next end end end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/vendor-install.rb000066400000000000000000000006001517265720000241310ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "shell_command" module Homebrew module Cmd class VendorInstall < AbstractCommand include ShellCommand cmd_args do description <<~EOS Install Homebrew's portable Ruby. EOS named_args :target hide_from_man_page! end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/vendor-install.sh000066400000000000000000000302301517265720000241420ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/vendor-install.rb # HOMEBREW_ARTIFACT_DOMAIN, HOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK, HOMEBREW_BOTTLE_DOMAIN, HOMEBREW_CACHE, # HOMEBREW_CURLRC, HOMEBREW_DEVELOPER, HOMEBREW_DEBUG, HOMEBREW_VERBOSE are from the user environment # HOMEBREW_PORTABLE_RUBY_VERSION is set by utils/ruby.sh # HOMEBREW_LIBRARY, HOMEBREW_PREFIX are set by bin/brew # HOMEBREW_CURL, HOMEBREW_GITHUB_PACKAGES_AUTH, HOMEBREW_LINUX, HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION, HOMEBREW_MACOS, # HOMEBREW_PHYSICAL_PROCESSOR, HOMEBREW_PROCESSOR, HOMEBREW_USER_AGENT_CURL are set by brew.sh # shellcheck disable=SC2154 source "${HOMEBREW_LIBRARY}/Homebrew/utils/lock.sh" source "${HOMEBREW_LIBRARY}/Homebrew/utils/ruby.sh" VENDOR_DIR="${HOMEBREW_LIBRARY}/Homebrew/vendor" brew-rs-vendor-up-to-date() { local brew_rs_source_dir="${HOMEBREW_LIBRARY}/Homebrew/rust/brew-rs" local vendor_root="${VENDOR_DIR}/brew-rs" local vendor_binary="${vendor_root}/bin/brew-rs" local cargo_lock_path="${brew_rs_source_dir}/Cargo.lock" if [[ -x "${vendor_root}/brew-rs" && -x "${vendor_binary}" && "${brew_rs_source_dir}/Cargo.toml" -ot "${vendor_binary}" && (! -f "${cargo_lock_path}" || "${cargo_lock_path}" -ot "${vendor_binary}") && -z "$(find "${brew_rs_source_dir}/src" -type f -newer "${vendor_binary}" -print -quit)" ]] then return 0 fi return 1 } set_ruby_variables() { # Handle the case where /usr/local/bin/brew is run under arm64. # It's a x86_64 installation there (we refuse to install arm64 binaries) so # use a x86_64 Portable Ruby. if [[ -n "${HOMEBREW_MACOS}" && "${VENDOR_PHYSICAL_PROCESSOR}" == "arm64" && "${HOMEBREW_PREFIX}" == "/usr/local" ]] then ruby_PROCESSOR="x86_64" ruby_OS="darwin" else ruby_PROCESSOR="${VENDOR_PHYSICAL_PROCESSOR}" if [[ -n "${HOMEBREW_MACOS}" ]] then ruby_OS="darwin" elif [[ -n "${HOMEBREW_LINUX}" ]] then ruby_OS="linux" fi fi ruby_PLATFORMINFO="${HOMEBREW_LIBRARY}/Homebrew/vendor/portable-ruby-${ruby_PROCESSOR}-${ruby_OS}" if [[ -f "${ruby_PLATFORMINFO}" && -r "${ruby_PLATFORMINFO}" ]] then # ruby_TAG and ruby_SHA will be set via the sourced file if it exists # shellcheck disable=SC1090 source "${ruby_PLATFORMINFO}" fi # Dynamic variables can't be detected by shellcheck # shellcheck disable=SC2034 if [[ -n "${ruby_TAG}" && -n "${ruby_SHA}" ]] then ruby_FILENAME="portable-ruby-${HOMEBREW_PORTABLE_RUBY_VERSION}.${ruby_TAG}.bottle.tar.gz" ruby_URLs=() if [[ -n "${HOMEBREW_ARTIFACT_DOMAIN}" ]] then ruby_URLs+=("${HOMEBREW_ARTIFACT_DOMAIN}/v2/homebrew/core/portable-ruby/blobs/sha256:${ruby_SHA}") if [[ -n "${HOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK}" ]] then ruby_URL="${ruby_URLs[0]}" return fi fi if [[ -n "${HOMEBREW_BOTTLE_DOMAIN}" ]] then ruby_URLs+=("${HOMEBREW_BOTTLE_DOMAIN}/${ruby_FILENAME}") fi ruby_URLs+=( "https://ghcr.io/v2/homebrew/core/portable-ruby/blobs/sha256:${ruby_SHA}" ) ruby_URL="${ruby_URLs[0]}" fi } check_linux_glibc_version() { if [[ -z "${HOMEBREW_LINUX}" || -z "${HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION}" ]] then return 0 fi local glibc_version local glibc_version_major local glibc_version_minor local minimum_required_major="${HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION%.*}" local minimum_required_minor="${HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION#*.}" if [[ "$(/usr/bin/ldd --version)" =~ \ [0-9]\.[0-9]+ ]] then glibc_version="${BASH_REMATCH[0]// /}" glibc_version_major="${glibc_version%.*}" glibc_version_minor="${glibc_version#*.}" if ((glibc_version_major < minimum_required_major || glibc_version_minor < minimum_required_minor)) then odie "Vendored tools require system Glibc ${HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION} or later (yours is ${glibc_version})." fi else odie "Failed to detect system Glibc version." fi } fetch() { local -a curl_args local url local sha local first_try=1 local vendor_locations local temporary_path local curl_exit_code=0 curl_args=() # do not load .curlrc unless requested (must be the first argument) # HOMEBREW_CURLRC isn't misspelt here # shellcheck disable=SC2153 if [[ -z "${HOMEBREW_CURLRC}" ]] then curl_args[${#curl_args[*]}]="-q" elif [[ "${HOMEBREW_CURLRC}" == /* ]] then curl_args+=("-q" "--config" "${HOMEBREW_CURLRC}") fi # Authorization is needed for GitHub Packages but harmless on GitHub Releases curl_args+=( --fail --remote-time --location --user-agent "${HOMEBREW_USER_AGENT_CURL}" ) if [[ -n "${HOMEBREW_GITHUB_PACKAGES_AUTH}" ]] then curl_args[${#curl_args[*]}]="--header" curl_args[${#curl_args[*]}]="Authorization: ${HOMEBREW_GITHUB_PACKAGES_AUTH}" fi if [[ -n "${HOMEBREW_QUIET}" ]] then curl_args[${#curl_args[*]}]="--silent" elif [[ -z "${HOMEBREW_VERBOSE}" ]] then curl_args[${#curl_args[*]}]="--progress-bar" fi temporary_path="${CACHED_LOCATION}.incomplete" mkdir -p "${HOMEBREW_CACHE}" [[ -n "${HOMEBREW_QUIET}" ]] || ohai "Downloading ${VENDOR_URL}" >&2 if [[ -f "${CACHED_LOCATION}" ]] then [[ -n "${HOMEBREW_QUIET}" ]] || echo "Already downloaded: ${CACHED_LOCATION}" >&2 else for url in "${VENDOR_URLs[@]}" do [[ -n "${HOMEBREW_QUIET}" || -n "${first_try}" ]] || ohai "Downloading ${url}" >&2 first_try='' if [[ -f "${temporary_path}" ]] then # HOMEBREW_CURL is set by brew.sh (and isn't misspelt here) # shellcheck disable=SC2153 "${HOMEBREW_CURL}" "${curl_args[@]}" -C - "${url}" -o "${temporary_path}" curl_exit_code="$?" if [[ "${curl_exit_code}" -eq 33 ]] then [[ -n "${HOMEBREW_QUIET}" ]] || echo "Trying a full download" >&2 rm -f "${temporary_path}" "${HOMEBREW_CURL}" "${curl_args[@]}" "${url}" -o "${temporary_path}" curl_exit_code="$?" fi else "${HOMEBREW_CURL}" "${curl_args[@]}" "${url}" -o "${temporary_path}" curl_exit_code="$?" fi [[ -f "${temporary_path}" ]] && break done if [[ "${curl_exit_code}" -ne 0 ]] then rm -f "${temporary_path}" fi if [[ ! -f "${temporary_path}" ]] then vendor_locations="$(printf " - %s\n" "${VENDOR_URLs[@]}")" odie <&2 tar "${tar_args}" "${CACHED_LOCATION}" if [[ "${VENDOR_PROCESSOR}" != "${HOMEBREW_PROCESSOR}" ]] || [[ "${VENDOR_PHYSICAL_PROCESSOR}" != "${HOMEBREW_PHYSICAL_PROCESSOR}" ]] then return 0 fi safe_cd "${VENDOR_DIR}/portable-${VENDOR_NAME}" if "./${VENDOR_VERSION}/bin/${VENDOR_NAME}" --version >/dev/null then ln -sfn "${VENDOR_VERSION}" current if [[ -d "${VENDOR_VERSION}.reinstall" ]] then rm -rf "${VENDOR_VERSION}.reinstall" fi else rm -rf "${VENDOR_VERSION}" if [[ -d "${VENDOR_VERSION}.reinstall" ]] then mv "${VENDOR_VERSION}.reinstall" "${VENDOR_VERSION}" fi odie "Failed to install ${VENDOR_NAME} ${VENDOR_VERSION}!" fi trap - SIGINT } homebrew-vendor-install() { local option local url_var local sha_var local cargo_lock_path local cargo_path local vendor_binary local vendor_root unset VENDOR_PHYSICAL_PROCESSOR unset VENDOR_PROCESSOR for option in "$@" do case "${option}" in -\? | -h | --help | --usage) brew help vendor-install exit $? ;; --verbose) HOMEBREW_VERBOSE=1 ;; --quiet) HOMEBREW_QUIET=1 ;; --debug) HOMEBREW_DEBUG=1 ;; --*) ;; -*) [[ "${option}" == *v* ]] && HOMEBREW_VERBOSE=1 [[ "${option}" == *q* ]] && HOMEBREW_QUIET=1 [[ "${option}" == *d* ]] && HOMEBREW_DEBUG=1 ;; *) if [[ -n "${VENDOR_NAME}" ]] then if [[ -n "${HOMEBREW_DEVELOPER}" ]] then if [[ -n "${PROCESSOR_TARGET}" ]] then odie "This command does not take more than vendor and processor targets!" else VENDOR_PHYSICAL_PROCESSOR="${option}" VENDOR_PROCESSOR="${option}" fi else odie "This command does not take multiple vendor targets!" fi else VENDOR_NAME="${option}" fi ;; esac done [[ -z "${VENDOR_NAME}" ]] && odie "This command requires a vendor target!" [[ -n "${HOMEBREW_DEBUG}" ]] && set -x if [[ "${VENDOR_NAME}" == "brew-rs" ]] then [[ -n "${HOMEBREW_DEVELOPER:-}" && -n "${HOMEBREW_EXPERIMENTAL_RUST_FRONTEND:-}" ]] || odie "brew-rs vendor-install requires HOMEBREW_DEVELOPER=1 and HOMEBREW_EXPERIMENTAL_RUST_FRONTEND=1." cargo_path="$(PATH="${HOMEBREW_PATH:-${PATH}}" command -v cargo)" [[ -x "${cargo_path}" ]] || odie "brew-rs vendor-install requires 'cargo' from the 'rust' formula." brew_rs_source_dir="${HOMEBREW_LIBRARY}/Homebrew/rust/brew-rs" vendor_root="${VENDOR_DIR}/brew-rs" if brew-rs-vendor-up-to-date then return 0 fi lock "vendor-install ${VENDOR_NAME}" if brew-rs-vendor-up-to-date then return 0 fi [[ -n "${HOMEBREW_QUIET}" ]] || ohai "Building brew-rs" >&2 PATH="${HOMEBREW_PATH:-${PATH}}" "${cargo_path}" install --path "${brew_rs_source_dir}" --locked --force --root "${vendor_root}" \ 2> >(grep -Fv "be sure to add" >&2) || odie "Failed to build brew-rs!" ln -sfn "bin/brew-rs" "${vendor_root}/brew-rs" return 0 fi if [[ -z "${VENDOR_PHYSICAL_PROCESSOR}" ]] then VENDOR_PHYSICAL_PROCESSOR="${HOMEBREW_PHYSICAL_PROCESSOR}" fi if [[ -z "${VENDOR_PROCESSOR}" ]] then VENDOR_PROCESSOR="${HOMEBREW_PROCESSOR}" fi set_ruby_variables check_linux_glibc_version filename_var="${VENDOR_NAME}_FILENAME" sha_var="${VENDOR_NAME}_SHA" url_var="${VENDOR_NAME}_URL" VENDOR_FILENAME="${!filename_var}" VENDOR_SHA="${!sha_var}" VENDOR_URL="${!url_var}" VENDOR_VERSION="$(cat "${VENDOR_DIR}/portable-${VENDOR_NAME}-version")" if [[ -z "${VENDOR_URL}" || -z "${VENDOR_SHA}" ]] then odie "No Homebrew ${VENDOR_NAME} ${VENDOR_VERSION} available for ${HOMEBREW_PROCESSOR} processors!" fi # Expand the name to an array of variables # The array name must be "${VENDOR_NAME}_URLs"! Otherwise substitution errors will occur! # shellcheck disable=SC2086 read -r -a VENDOR_URLs <<<"$(eval "echo "\$\{${url_var}s[@]\}"")" CACHED_LOCATION="${HOMEBREW_CACHE}/${VENDOR_FILENAME}" lock "vendor-install ${VENDOR_NAME}" fetch install } Homebrew-brew-d7f73ce/Library/Homebrew/cmd/version-install.rb000066400000000000000000000120651517265720000243310ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "abstract_command" require "formula" require "formulary" require "tap" require "utils/github" require "utils/user" module Homebrew module Cmd class VersionInstall < AbstractCommand DEFAULT_TAP_REPOSITORY = "versions" private_constant :DEFAULT_TAP_REPOSITORY cmd_args do usage_banner "`version-install` [@] []" description <<~EOS Extract a specific of into a personal tap and install it. The default tap is /#{DEFAULT_TAP_REPOSITORY}. uses the GitHub username if available and the local username otherwise. EOS named_args [:formula, :version], min: 1, max: 2 end sig { override.void } def run formula_input = args.named.fetch(0) version_input = args.named[1] if version_input.nil? || formula_input.include?("@") unless formula_input.include?("@") raise UsageError, "Specify a version with or @." end formula_base, _, version_from_input = formula_input.rpartition("@") odie "Invalid formula reference: #{formula_input}" if formula_base.empty? || version_from_input.empty? version_input ||= version_from_input odie "Version mismatch: #{formula_input} != #{version_input}" if version_from_input != version_input versioned_ref = formula_input formula_input = formula_base end tap_with_name = Tap.with_formula_name(formula_input) tap, base_name = tap_with_name || [nil, formula_input] base_name = base_name.downcase .sub(/\b@(.*)\z\b/i, "") normalized_version = version_input.to_s .sub(/\D*(.+?)\D*$/, "\\1") .gsub(/\D+/, ".") versioned_name = "#{base_name}@#{normalized_version}" versioned_ref ||= if tap "#{tap}/#{versioned_name}" else versioned_name end installed_formula_names = Formula.installed_formula_names if installed_formula_names.include?(versioned_name) ohai "#{versioned_name} is already installed" return end existing_tap = Tap.installed .sort_by(&:name) .find { |tap| tap.formula_files_by_name.key?(versioned_name) } install_target = "#{existing_tap}/#{versioned_name}" if existing_tap versioned_formula = begin Formulary.factory(versioned_ref, warn: false) rescue TapFormulaAmbiguityError, FormulaUnavailableError, TapFormulaUnavailableError, TapFormulaUnreadableError nil end if install_target.nil? install_target = if versioned_formula versioned_formula.full_name else current_formula = begin Formulary.factory(formula_input, warn: false) rescue FormulaUnavailableError, TapFormulaUnavailableError, TapFormulaUnreadableError nil end if current_formula && current_formula.version.to_s == version_input if installed_formula_names.include?(current_formula.name) ohai "#{current_formula.full_name} is already installed" return end current_formula.full_name end end end # Pretend we've run a dev command to avoid making it seem like the user # has done so manually. ENV["HOMEBREW_DEV_CMD_RUN"] = "1" if install_target.nil? username = if !Homebrew::EnvConfig.no_github_api? && GitHub::API.credentials_type != :none begin GitHub.user["login"].presence rescue *GitHub::API::ERRORS nil end end username ||= User.current&.to_s username ||= ENV.fetch("USER") odie "Unable to determine a username for tap creation." if username.blank? tap = Tap.fetch("#{username}/homebrew-#{DEFAULT_TAP_REPOSITORY}") unless tap.installed? ohai "Creating #{tap.name} tap for storing versioned formulae..." safe_system HOMEBREW_BREW_FILE, "tap-new", "--no-git", tap.name end ohai "Extracting #{formula_input}@#{version_input} into #{tap.name}..." safe_system HOMEBREW_BREW_FILE, "extract", formula_input, tap.name, "--version=#{version_input}" install_target = "#{tap}/#{versioned_name}" opoo <<~EOS You are responsible for maintaining this #{install_target}! It will not receive any bugfix/security updates. Homebrew cannot support it for you because we cannot maintain every formula at every version or fix older versions in our Git history. EOS end ohai "Installing #{install_target}..." safe_system HOMEBREW_BREW_FILE, "install", install_target end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/which-formula.rb000077500000000000000000000016271517265720000237520ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true # License: MIT # The license text can be found in Library/Homebrew/command-not-found/LICENSE require "abstract_command" require "api" require "shell_command" module Homebrew module Cmd class WhichFormula < AbstractCommand ENDPOINT = "internal/executables.txt" DATABASE_FILE = T.let((Homebrew::API::HOMEBREW_CACHE_API/ENDPOINT).freeze, Pathname) include ShellCommand cmd_args do description <<~EOS Show which formula(e) provides the given command. EOS switch "--explain", description: "Output explanation of how to get by installing one of the providing formulae." switch "--skip-update", description: "Skip updating the executables database if any version exists on disk, no matter how old." named_args :command, min: 1 end end end end Homebrew-brew-d7f73ce/Library/Homebrew/cmd/which-formula.sh000066400000000000000000000072501517265720000237540ustar00rootroot00000000000000# Documentation defined in Library/Homebrew/cmd/which-formula.rb # HOMEBREW_CACHE is set by utils/ruby.sh # HOMEBREW_LIBRARY is set by bin/brew # HOMEBREW_API_DEFAULT_DOMAIN HOMEBREW_CURL_SPEED_LIMIT HOMEBREW_CURL_SPEED_TIME HOMEBREW_USER_AGENT_CURL are set by brew.sh # shellcheck disable=SC2154 ENDPOINT="internal/executables.txt" DATABASE_FILE="${HOMEBREW_CACHE}/api/${ENDPOINT}" is_formula_installed() { local name="$1" if [[ -d "${HOMEBREW_CELLAR}/${name}" ]] then return 0 else return 1 fi } is_file_fresh() { if [[ -n "${HOMEBREW_MACOS}" ]] then STAT_PRINTF=("/usr/bin/stat" "-f") else STAT_PRINTF=("/usr/bin/stat" "-c") fi local file_mtime local current_time local auto_update_secs file_mtime=$("${STAT_PRINTF[@]}" %m "${DATABASE_FILE}") current_time=$(date +%s) auto_update_secs=${HOMEBREW_API_AUTO_UPDATE_SECS:-450} [[ $((current_time - auto_update_secs)) -lt ${file_mtime} ]] } download_and_cache_executables_file() { source "${HOMEBREW_LIBRARY}/Homebrew/utils/helpers.sh" if [[ -s "${DATABASE_FILE}" ]] && ([[ -n "${HOMEBREW_SKIP_UPDATE}" ]] || is_file_fresh) then return else local url url="${HOMEBREW_API_DEFAULT_DOMAIN}/${ENDPOINT}" if [[ -n "${CI}" ]] then max_time="" retries="3" else max_time=10 retries=0 fi mkdir -p "${DATABASE_FILE%/*}" ${HOMEBREW_CURL} \ --compressed \ --speed-limit "${HOMEBREW_CURL_SPEED_LIMIT}" --speed-time "${HOMEBREW_CURL_SPEED_TIME}" \ --location --remote-time --output "${DATABASE_FILE}" \ ${max_time:+--max-time "${max_time}"} \ ${retries:+--retry "${retries}" --retry-delay 0 --retry-max-time 60} \ --user-agent "${HOMEBREW_USER_AGENT_CURL}" \ "${url}" touch "${DATABASE_FILE}" git config --file="${HOMEBREW_REPOSITORY}/.git/config" --bool homebrew.commandnotfound true 2>/dev/null fi } homebrew-which-formula() { local args=() while [[ "$#" -gt 0 ]] do case "$1" in --explain) HOMEBREW_EXPLAIN=1 shift ;; --skip-update) HOMEBREW_SKIP_UPDATE=1 shift ;; --*) echo "Unknown option: $1" >&2 brew help which-formula return 1 ;; *) args+=("$1") shift ;; esac done if [[ ${#args[@]} -eq 0 ]] then brew help which-formula exit 1 fi for cms in "${args[@]}" do download_and_cache_executables_file cmd="$(echo "${cms}" | tr '[:upper:]' '[:lower:]')" local formulae=() local formula cmds_text while IFS=':' read -r formula cmds_text do [[ -z "${formula}" ]] && continue [[ -z "${cmds_text}" ]] && continue if [[ " ${cmds_text} " == *" ${cmd} "* ]] then formula="${formula%\(*}" formulae+=("${formula}") fi done <"${DATABASE_FILE}" 2>/dev/null [[ ${#formulae[@]} -eq 0 ]] && return 1 if [[ -n ${HOMEBREW_EXPLAIN} ]] then local filtered_formulae=() for formula in "${formulae[@]}" do if ! is_formula_installed "${formula}" then filtered_formulae+=("${formula}") fi done if [[ ${#filtered_formulae[@]} -eq 0 ]] then return 1 fi if [[ ${#filtered_formulae[@]} -eq 1 ]] then echo "The program '${cmd}' is currently not installed. You can install it by typing:" echo " brew install ${filtered_formulae[0]}" else echo "The program '${cmd}' can be found in the following formulae:" printf " * %s\n" "${filtered_formulae[@]}" echo "Try: brew install " fi else printf '%s\n' "${formulae[@]}" fi done } Homebrew-brew-d7f73ce/Library/Homebrew/command-not-found/000077500000000000000000000000001517265720000234315ustar00rootroot00000000000000Homebrew-brew-d7f73ce/Library/Homebrew/command-not-found/LICENSE000066400000000000000000000020551517265720000244400ustar00rootroot00000000000000Copyright © 2014-2018 Homebrew contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Homebrew-brew-d7f73ce/Library/Homebrew/command-not-found/handler.fish000066400000000000000000000011641517265720000257230ustar00rootroot00000000000000# See https://docs.brew.sh/Command-Not-Found for current setup instructions # License: MIT # The license text can be found in Library/Homebrew/command-not-found/LICENSE function fish_command_not_found set -l cmd $argv[1] set -l txt if not contains -- "$cmd" "-h" "--help" "--usage" "-?" set txt (brew which-formula --skip-update --explain $cmd 2> /dev/null) end if test -z "$txt" __fish_default_command_not_found_handler $cmd else string collect $txt end end function __fish_command_not_found_handler --on-event fish_command_not_found fish_command_not_found $argv end Homebrew-brew-d7f73ce/Library/Homebrew/command-not-found/handler.sh000066400000000000000000000037241517265720000254100ustar00rootroot00000000000000# # Homebrew command-not-found script for macOS # # Usage: Source it somewhere in your .bashrc (bash) or .zshrc (zsh) # # Author: Baptiste Fontaine # License: MIT # The license text can be found in Library/Homebrew/command-not-found/LICENSE if ! command -v brew >/dev/null; then return; fi homebrew_command_not_found_handle() { local cmd="$1" if [[ -n "${ZSH_VERSION}" ]] then autoload is-at-least fi # The code below is based off this Linux Journal article: # http://www.linuxjournal.com/content/bash-command-not-found # do not run when inside Midnight Commander or within a Pipe, except if CI # HOMEBREW_COMMAND_NOT_FOUND_CI is defined in the CI environment # MC_SID is defined when running inside Midnight Commander. # shellcheck disable=SC2154 if test -z "${HOMEBREW_COMMAND_NOT_FOUND_CI}" && test -n "${MC_SID}" -o ! -t 1 then [[ -n "${BASH_VERSION}" ]] && TEXTDOMAIN=command-not-found echo $"${cmd}: command not found" # Zsh versions 5.3 and above don't print this for us. [[ -n "${ZSH_VERSION}" ]] && is-at-least "5.2" "${ZSH_VERSION}" && echo "zsh: command not found: ${cmd}" >&2 return 127 fi if [[ "${cmd}" != "-h" ]] && [[ "${cmd}" != "--help" ]] && [[ "${cmd}" != "--usage" ]] && [[ "${cmd}" != "-?" ]] then local txt txt="$(brew which-formula --skip-update --explain "${cmd}" 2>/dev/null)" fi if [[ -z "${txt}" ]] then [[ -n "${BASH_VERSION}" ]] && TEXTDOMAIN=command-not-found echo $"${cmd}: command not found" # Zsh versions 5.3 and above don't print this for us. [[ -n "${ZSH_VERSION}" ]] && is-at-least "5.2" "${ZSH_VERSION}" && echo "zsh: command not found: ${cmd}" >&2 else echo "${txt}" fi return 127 } if [[ -n "${BASH_VERSION}" ]] then command_not_found_handle() { homebrew_command_not_found_handle "$*" return $? } elif [[ -n "${ZSH_VERSION}" ]] then command_not_found_handler() { homebrew_command_not_found_handle "$*" return $? } fi Homebrew-brew-d7f73ce/Library/Homebrew/command_path.sh000066400000000000000000000023561517265720000231000ustar00rootroot00000000000000# does the quickest output of brew command possible for the basic cases of an # official Bash or Ruby normal or dev-cmd command. # HOMEBREW_LIBRARY is set by brew.sh # shellcheck disable=SC2154 homebrew-command-path() { case "$1" in # check we actually have command and not e.g. commandsomething command) ;; command*) return 1 ;; *) ;; esac local first_command found_command for arg in "$@" do if [[ -z "${first_command}" && "${arg}" == "command" ]] then first_command=1 continue elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/cmd/${arg}.sh" ]] then echo "${HOMEBREW_LIBRARY}/Homebrew/cmd/${arg}.sh" found_command=1 elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${arg}.sh" ]] then echo "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${arg}.sh" found_command=1 elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/cmd/${arg}.rb" ]] then echo "${HOMEBREW_LIBRARY}/Homebrew/cmd/${arg}.rb" found_command=1 elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${arg}.rb" ]] then echo "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${arg}.rb" found_command=1 else return 1 fi done if [[ -n "${found_command}" ]] then return 0 else return 1 fi } Homebrew-brew-d7f73ce/Library/Homebrew/commands.rb000066400000000000000000000221671517265720000222420ustar00rootroot00000000000000# typed: strict # frozen_string_literal: true require "homebrew" # Helper functions for commands. module Commands HOMEBREW_CMD_PATH = T.let((HOMEBREW_LIBRARY_PATH/"cmd").freeze, Pathname) HOMEBREW_DEV_CMD_PATH = T.let((HOMEBREW_LIBRARY_PATH/"dev-cmd").freeze, Pathname) # If you are going to change anything in below hash, # be sure to also update appropriate case statement in brew.sh HOMEBREW_INTERNAL_COMMAND_ALIASES = T.let({ "ls" => "list", "homepage" => "home", "-S" => "search", "up" => "update", "ln" => "link", "instal" => "install", # gem does the same "uninstal" => "uninstall", "post_install" => "postinstall", "rm" => "uninstall", "remove" => "uninstall", "abv" => "info", "dr" => "doctor", "--repo" => "--repository", "environment" => "--env", "--config" => "config", "-v" => "--version", "lc" => "livecheck", "tc" => "typecheck", }.freeze, T::Hash[String, String]) # This pattern is used to split descriptions at full stops. We only consider a # dot as a full stop if it is either followed by a whitespace or at the end of # the description. In this way we can prevent cutting off a sentence in the # middle due to dots in URLs or paths. DESCRIPTION_SPLITTING_PATTERN = /\.(?>\s|$)/ sig { params(cmd: String).returns(T::Boolean) } def self.valid_internal_cmd?(cmd) Homebrew.require?(HOMEBREW_CMD_PATH/cmd) end sig { params(cmd: String).returns(T::Boolean) } def self.valid_internal_dev_cmd?(cmd) Homebrew.require?(HOMEBREW_DEV_CMD_PATH/cmd) end sig { params(cmd: String).returns(T::Boolean) } def self.valid_ruby_cmd?(cmd) (valid_internal_cmd?(cmd) || valid_internal_dev_cmd?(cmd) || external_ruby_v2_cmd_path(cmd).present?) && (Homebrew::AbstractCommand.command(cmd)&.ruby_cmd? == true) end sig { params(cmd: String).returns(Symbol) } def self.method_name(cmd) cmd.to_s .tr("-", "_") .downcase .to_sym end sig { params(cmd_path: Pathname).returns(Symbol) } def self.args_method_name(cmd_path) cmd_path_basename = basename_without_extension(cmd_path) cmd_method_prefix = method_name(cmd_path_basename) :"#{cmd_method_prefix}_args" end sig { params(cmd: String).returns(T.nilable(Pathname)) } def self.internal_cmd_path(cmd) [ HOMEBREW_CMD_PATH/"#{cmd}.rb", HOMEBREW_CMD_PATH/"#{cmd}.sh", ].find(&:exist?) end sig { params(cmd: String).returns(T.nilable(Pathname)) } def self.internal_dev_cmd_path(cmd) [ HOMEBREW_DEV_CMD_PATH/"#{cmd}.rb", HOMEBREW_DEV_CMD_PATH/"#{cmd}.sh", ].find(&:exist?) end # Ruby commands which can be `require`d without being run. sig { params(cmd: String).returns(T.nilable(Pathname)) } def self.external_ruby_v2_cmd_path(cmd) path = which("#{cmd}.rb", tap_cmd_directories) path if Homebrew.require?(path) end # Ruby commands which are run by being `require`d. sig { params(cmd: String).returns(T.nilable(Pathname)) } def self.external_ruby_cmd_path(cmd) which("brew-#{cmd}.rb", PATH.new(ENV.fetch("PATH")).append(tap_cmd_directories)) end sig { params(cmd: String).returns(T.nilable(Pathname)) } def self.external_cmd_path(cmd) which("brew-#{cmd}", PATH.new(ENV.fetch("PATH")).append(tap_cmd_directories)) end sig { params(cmd: String).returns(T.nilable(Pathname)) } def self.path(cmd) internal_cmd = HOMEBREW_INTERNAL_COMMAND_ALIASES.fetch(cmd, cmd) path ||= internal_cmd_path(internal_cmd) path ||= internal_dev_cmd_path(internal_cmd) path ||= external_ruby_v2_cmd_path(cmd) path ||= external_ruby_cmd_path(cmd) path ||= external_cmd_path(cmd) path end sig { params(external: T::Boolean, aliases: T::Boolean).returns(T::Array[String]) } def self.commands(external: true, aliases: false) cmds = internal_commands cmds += internal_developer_commands cmds += external_commands if external cmds += internal_commands_aliases if aliases cmds.sort end # An array of all tap cmd directory {Pathname}s. sig { returns(T::Array[Pathname]) } def self.tap_cmd_directories Pathname.glob HOMEBREW_TAP_DIRECTORY/"*/*/cmd" end sig { returns(T::Array[Pathname]) } def self.internal_commands_paths find_commands HOMEBREW_CMD_PATH end sig { returns(T::Array[Pathname]) } def self.internal_developer_commands_paths find_commands HOMEBREW_DEV_CMD_PATH end sig { returns(T::Array[String]) } def self.internal_commands find_internal_commands(HOMEBREW_CMD_PATH).map(&:to_s) end sig { returns(T::Array[String]) } def self.internal_developer_commands find_internal_commands(HOMEBREW_DEV_CMD_PATH).map(&:to_s) end sig { returns(T::Array[String]) } def self.internal_commands_aliases HOMEBREW_INTERNAL_COMMAND_ALIASES.keys end sig { params(path: Pathname).returns(T::Array[String]) } def self.find_internal_commands(path) find_commands(path).map(&:basename) .map { |basename| basename_without_extension(basename) } .uniq end sig { returns(T::Array[String]) } def self.external_commands tap_cmd_directories.flat_map do |path| find_commands(path).select(&:executable?) .map { |basename| basename_without_extension(basename) } .map { |p| p.to_s.delete_prefix("brew-").strip } end.map(&:to_s) .sort end sig { params(path: Pathname).returns(String) } def self.basename_without_extension(path) path.basename(path.extname).to_s end sig { params(path: Pathname).returns(T::Array[Pathname]) } def self.find_commands(path) Pathname.glob("#{path}/*") .select(&:file?) .sort end sig { void } def self.rebuild_internal_commands_completion_list require "completions" cmds = internal_commands + internal_developer_commands + internal_commands_aliases cmds.reject! { |cmd| Homebrew::Completions::COMPLETIONS_EXCLUSION_LIST.include? cmd } file = HOMEBREW_REPOSITORY/"completions/internal_commands_list.txt" file.atomic_write("#{cmds.sort.join("\n")}\n") end sig { void } def self.rebuild_commands_completion_list require "completions" # Ensure that the cache exists so we can build the commands list HOMEBREW_CACHE.mkpath cmds = commands(aliases: true) - Homebrew::Completions::COMPLETIONS_EXCLUSION_LIST all_commands_file = HOMEBREW_CACHE/"all_commands_list.txt" external_commands_file = HOMEBREW_CACHE/"external_commands_list.txt" all_commands_file.atomic_write("#{cmds.sort.join("\n")}\n") external_commands_file.atomic_write("#{external_commands.sort.join("\n")}\n") end sig { params(command: String).returns(T.nilable(T::Array[[String, String]])) } def self.command_options(command) return if command == "help" path = self.path(command) return if path.blank? if (cmd_parser = Homebrew::CLI::Parser.from_cmd_path(path)) cmd_parser.processed_options.filter_map do |short, long, desc, hidden| next if hidden [T.must(long || short), desc] end else options = [] comment_lines = path.read.lines.grep(/^#:/) return options if comment_lines.empty? # skip the comment's initial usage summary lines comment_lines.slice(2..-1)&.each do |line| match_data = / (?