.devcontainer/Dockerfile

@@ -1,26 +0,0 @@
-# Use the jguer/yay-builder image as a parent image with archlinux
-FROM docker.io/jguer/yay-builder
-
-# Install extra packages (pacman-contrib and fish)
-RUN sudo pacman -Syu --noconfirm pacman-contrib fish git-delta openssh bat go
-
-# Set passwordless sudo for the docker user
-RUN echo "docker ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/docker
-
-# Create a non-root user and switch to it
-USER docker
-
-# Install xgotext
-RUN go install github.com/leonelquinteros/gotext/cli/xgotext@latest
-
-# Add /app/bin to the PATH
-ENV PATH="/app/bin:$PATH"
-
-# add /home/docker/go/bin to the PATH
-ENV PATH="/home/docker/go/bin:$PATH"
-
-# Set the working directory
-WORKDIR /workspace
-
-# Command to run when starting the container
-CMD ["bash"]

.devcontainer/devcontainer.json

@@ -1,14 +0,0 @@
-{
-	"name": "Existing Dockerfile",
-	"build": {
-		"context": "..",
-		"dockerfile": "../.devcontainer/Dockerfile"
-	},
-	"customizations": {
-		"vscode": {
-			"extensions": [
-				"golang.go"
-			]
-		}
-	}
-}

.dockerignore

@@ -1,9 +0,0 @@
-*
-!*.go
-!pkg
-!go.mod
-!go.sum
-!Makefile
-!po
-!doc
-!completions

.github/CODEOWNERS

@@ -1 +0,0 @@
-*       @Jguer

.github/CONTRIBUTING.md

@@ -1,22 +1,4 @@
-# Contributing to yay
-
-## Translation
-
-[Transifex](https://www.transifex.com/yay-1/yay/)
-
-## Quality Assurance
-
-```sh
-pacman -S --needed git base-devel
-git clone https://aur.archlinux.org/yay-git.git
-cd yay-git
-makepkg -si
-```
-
-Installing `yay-git` and using issues to help determine what's broken is already
-a very big help.
-
-## Development
+## Contributing to yay
 
 Contributors are always welcome!
 
@@ -25,15 +7,6 @@ on, we suggest opening an issue detailing your ideas first.
 
 Otherwise send us a pull request and we will be happy to review it.
 
-### Vision
-
-Yay is based on the design of [yaourt](https://github.com/archlinuxfr/yaourt), [apacman](https://github.com/oshazard/apacman) and [pacaur](https://github.com/rmarquis/pacaur). It is developed with these objectives in mind:
-
-- Provide an interface for pacman
-- Yaourt-style interactive search/install
-- Minimal dependencies
-- Minimize user input
-
 ### Dependencies
 
 Yay depends on:
@@ -41,15 +14,27 @@ Yay depends on:
 - go (make only)
 - git
 - base-devel
-- pacman
 
-Note: Yay also depends on a few other projects, these are pulled as go modules.
+Note: Yay also depends on a few other projects (as vendored dependencies). These
+projects are stored in `vendor/`, are built into yay at build time, and do not
+need to be installed separately. These files are managed as go modules and should not be modified manually.
+
+Following are the dependencies managed as go modules:
+
+- https://github.com/Jguer/go-alpm
+- https://github.com/Morganamilo/go-srcinfo
+- https://github.com/Morganamilo/go-pacmanconf
+- https://github.com/mikkeloscar/aur
 
 ### Building
 
 Run `make` to build Yay. This command will generate a binary called `yay` in
 the same directory as the Makefile.
 
+Note: Yay's Makefile sources its dependencies from `vendor/`. When
+building manually, dependencies will instead be sourced from `GOPATH`. To
+build against `vendor/` you must specify `-mod=vendor` in the build command.
+
 #### Docker Release
 
 `make docker-release` will build the release packages for `aarch64` and for `x86_64`.
@@ -70,9 +55,6 @@ All code should be formatted through `go fmt`. This tool will automatically
 format code for you. We recommend, however, that you write code in the proper
 style and use `go fmt` only to catch mistakes.
 
-Use [pre-commit](https://pre-commit.com/) to validate your commits against the various
-linters configured for this repository.
-
 ### Testing
 
 Run `make test` to test Yay. This command will verify that the code is

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: [Jguer]

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,21 @@
+#### Affected Version
+<!-- Please ensure you are using the latest yay-git package -->
+<!-- Use `yay -V` to get installed version -->
+<!-- Example: `yay v8.1139.r0.g9ac4ab6 - libalpm v11.0.1` -->
+
+#### Issue
+
+
+<!-- The following sections may be left out if not relevant -->
+#### Steps to reproduce
+<!-- Use exact commands where applicable -->
+1.
+2.
+3.
+
+#### Output
+<!-- Include the FULL output -->
+<!-- Include any relevant commands/configs -->
+<!-- The current yay config can be printed with `yay -Pg` -->
+<!-- Use code blocks -->
+<!-- Paste services are only needed for excessive output (>500 lines) -->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,44 +0,0 @@
----
-name: Bug report
-about: Report a malfunction to help us improve
-title: ""
-labels: "Status: Triage, Type: Bug"
-assignees: ""
----
-
-### Affected Version
-
-<!-- Please ensure you are using the latest yay-git package
-Use `yay -V` to get installed version
-Example: `yay v8.1139.r0.g9ac4ab6 - libalpm v11.0.1` -->
-
-### Describe the bug
-
-<!-- A clear and concise description of the bug. -->
-
-### Reproduction Steps
-
-1.
-2.
-3.
-
-### Expected behavior
-
-<!-- A clear and concise description of what you expected to happen. -->
-
-### Output
-
-<!--
-Include the FULL output of any relevant commands/configs
-The current yay config can be printed with `yay -Pg`
-Paste services are only needed for excessive output (>500 lines)
-Use --debug to add pacman and yay debug logs 
-or add the following key to your ~/.config/yay/config.json to only get yay debug logs
-{
-  "debug": true
-}
--->
-
-```sh
-
-```

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,23 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ""
-labels: "Type: Feature Request, Status: Discussion Open"
-assignees: ""
----
-
-### Is your feature request related to a problem? Please describe.
-
-<!-- A clear and concise description of the problem, e.g. I'm always frustrated when ... -->
-
-### Describe the solution you'd like
-
-<!-- A clear and concise description of what you want to happen. -->
-
-### Describe alternatives you've considered
-
-<!-- A clear and concise description of any alternative solutions or features you've considered. -->
-
-### Additional context
-
-<!-- Add any other context or screenshots about the feature request here. -->

.github/dependabot.yml

@@ -1,15 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "gomod" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"
-    groups:
-      go-all:
-        patterns:
-          - '*'

.github/stale.yml

@@ -1,20 +0,0 @@
-# Number of days of inactivity before an issue becomes stale
-daysUntilStale: 120
-# Number of days of inactivity before a stale issue is closed
-daysUntilClose: 40
-# Issues with these labels will never be considered stale
-exemptLabels:
-  - "Status: In Progress"
-  - "Status: Confirmed"
-  - "Status: Approved"
-  - "Status: Triage"
-  - "Type: Bug"
-# Label to use when marking an issue as stale
-staleLabel: stale
-# Comment to post when marking an issue as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs. Thank you
-  for your contributions.
-# Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: false

.github/workflows/builder-image.yml

@@ -1,143 +0,0 @@
-name: Builder Image
-
-on:
-  schedule:
-    - cron: "0 3 * * 1"  # Every Monday at 3 AM
-  push:
-    paths:
-      - "ci.Dockerfile"
-      - ".github/workflows/builder-image.yml"
-
-env:
-  REGISTRY_IMAGE: jguer/yay-builder
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - linux/amd64
-          - linux/arm/v7
-          - linux/arm64
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            ${{ env.REGISTRY_IMAGE }}
-            ghcr.io/${{ env.REGISTRY_IMAGE }}
-          tags: |
-            type=raw,value=latest
-            type=sha,format=long
-
-      - name: Build and push by digest
-        id: build
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: ci.Dockerfile
-          platforms: ${{ matrix.platform }}
-          labels: ${{ steps.meta.outputs.labels }}
-          outputs: type=image,name=${{ env.REGISTRY_IMAGE }},push-by-digest=true,name-canonical=true,push=true
-
-      - name: Export digest
-        run: |
-          mkdir -p /tmp/digests
-          digest="${{ steps.build.outputs.digest }}"
-          echo -n "$digest" > "/tmp/digests/$(echo "${{ matrix.platform }}" | tr '/' '_')"
-
-      - name: Upload digest
-        uses: actions/upload-artifact@v4
-        with:
-          name: digest-${{ matrix.platform == 'linux/amd64' && 'amd64' || matrix.platform == 'linux/arm/v7' && 'armv7' || 'arm64' }}
-          path: /tmp/digests/*
-          if-no-files-found: error
-          retention-days: 1
-
-  merge:
-    needs: [build]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download digests
-        uses: actions/download-artifact@v4
-        with:
-          pattern: digest-*
-          merge-multiple: true
-          path: /tmp/digests
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            ${{ env.REGISTRY_IMAGE }}
-            ghcr.io/${{ env.REGISTRY_IMAGE }}
-          tags: |
-            type=raw,value=latest
-            type=sha,format=short
-
-      - name: Create and push manifest list
-        env:
-          DOCKER_CLI_EXPERIMENTAL: enabled
-        run: |
-          # Extract Docker Hub tags
-          DH_TAGS=$(echo '${{ steps.meta.outputs.tags }}' | grep -v "^ghcr.io" | xargs -I {} echo "-t {}")
-          
-          # Extract GitHub Container Registry tags
-          GHCR_TAGS=$(echo '${{ steps.meta.outputs.tags }}' | grep "^ghcr.io" | xargs -I {} echo "-t {}")
-          
-          # Create a manifest list using the image digests from /tmp/digests/*
-          DIGESTS=$(for file in /tmp/digests/*; do
-            echo -n "${{ env.REGISTRY_IMAGE }}@$(cat $file) "
-          done)
-          
-          # Create the manifest list for Docker Hub
-          docker buildx imagetools create $DH_TAGS $DIGESTS
-          
-          # Create the manifest list for GitHub Container Registry
-          docker buildx imagetools create $GHCR_TAGS $DIGESTS
-
-      - name: Inspect image
-        run: |
-          docker buildx imagetools inspect ${{ env.REGISTRY_IMAGE }}:latest

.github/workflows/docker-ci.yml

@@ -0,0 +1,25 @@
+name: Build
+# This workflow is triggered on pushes to the repository.
+on:
+  push:
+    paths-ignore:
+    - 'doc/**'
+    - 'README.md'
+    - '.gitignore'
+  pull_request:
+
+jobs:
+  build:
+    name: Lint and test yay
+    # This job runs on Linux
+    runs-on: ubuntu-latest
+    container: samip537/archlinux:devel
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+      - name: Run Build and tests
+        run: | 
+          pacman -Sy --noconfirm go
+          curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v1.23.6
+          ./bin/golangci-lint run ./...
+          make test

.github/workflows/docker-multiarch-tag.yml

@@ -0,0 +1,127 @@
+name: Release
+on:
+  push:
+    branches:
+      - master
+
+
+jobs:
+  tag:
+    name: Tag release
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: mathieudutour/github-tag-action@v4
+      id: tag_version
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        tag_prefix: 'v'
+    - name: share variables
+      shell: bash
+      run: |
+        mkdir env
+        echo ${{ steps.tag_version.outputs.new_version }} > env/new_version
+        echo ${{ steps.tag_version.outputs.new_tag }} > env/new_tag
+        echo "${{ steps.tag_version.outputs.changelog }}" > env/changelog
+    - uses: actions/upload-artifact@v1
+      with:
+        name: env
+        path: env
+  build-releases:
+    strategy:
+      matrix:
+        arch: ['x86_64', 'armv7h', 'aarch64']
+    name: Build ${{ matrix.arch }}
+    runs-on: ubuntu-latest
+    needs: [tag]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v1
+      - uses: actions/download-artifact@v1
+        with:
+          name: env
+      - name: Read info
+        id: tags
+        shell: bash
+        run: |
+          echo ::set-output name=VERSION::$(cat env/new_version)
+      - name: Install dependencies
+        run: sudo apt update -y && sudo apt install -y qemu qemu-user-static
+      - name: Setup qemu-user-static
+        run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+      - name: Build ${{ matrix.arch }} release
+        run: |
+          mkdir artifacts
+          make docker-release-${{ matrix.arch }} ARCH=${{ matrix.arch }} VERSION=${{ steps.tags.outputs.version }}
+          mv *.tar.gz artifacts
+      - uses: actions/upload-artifact@master
+        with:
+          name: yay_${{ matrix.arch }}
+          path: artifacts
+  create_release:
+    name: Create release from this build
+    needs: [build-releases]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@master
+      - uses: actions/download-artifact@v1
+        with:
+          name: env
+      - name: Read info
+        id: tags
+        shell: bash
+        run: |
+          echo ::set-output name=VERSION::$(cat env/new_version)
+          echo ::set-output name=TAG::$(cat env/new_tag)
+          echo ::set-output name=CHANGELOG::$(cat env/changelog)
+      - uses: actions/download-artifact@master
+        with:
+          name: yay_x86_64
+      - uses: actions/download-artifact@master
+        with:
+          name: yay_armv7h
+      - uses: actions/download-artifact@master
+        with:
+          name: yay_aarch64
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.tags.outputs.tag }}
+          release_name: ${{ steps.tags.outputs.tag }}
+          body: ${{ steps.tags.outputs.changelog }}
+          draft: false
+          prerelease: false
+      - name: Upload x86_64 asset
+        id: upload-release-asset-x86_64
+        uses: actions/upload-release-asset@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./yay_x86_64/yay_${{ steps.tags.outputs.version }}_x86_64.tar.gz
+          asset_name: yay_${{ steps.tags.outputs.version }}_x86_64.tar.gz
+          asset_content_type: application/tar+gzip
+      - name: Upload armv7h asset
+        id: upload-release-asset-armv7h
+        uses: actions/upload-release-asset@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./yay_armv7h/yay_${{ steps.tags.outputs.version }}_armv7h.tar.gz
+          asset_name: yay_${{ steps.tags.outputs.version }}_armv7h.tar.gz
+          asset_content_type: application/tar+gzip
+      - name: Upload aarch64 asset
+        id: upload-release-asset-aarch64
+        uses: actions/upload-release-asset@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./yay_aarch64/yay_${{ steps.tags.outputs.version }}_aarch64.tar.gz
+          asset_name: yay_${{ steps.tags.outputs.version }}_aarch64.tar.gz
+          asset_content_type: application/tar+gzip

.github/workflows/multiarch-build.yml

@@ -1,93 +0,0 @@
-name: Build Release
-
-on:
-  push:
-    tags:
-      - v*
-
-jobs:
-  build-releases:
-    strategy:
-      matrix:
-        arch: ["linux/amd64 x86_64", "linux/arm/v7 armv7h", "linux/arm64 aarch64"]
-    name: Build ${{ matrix.arch }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Read info
-        id: tags
-        run: |
-          echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
-          echo "TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-          arch="${{ matrix.arch }}"
-          echo "PLATFORM=${arch%% *}" >> $GITHUB_OUTPUT
-          echo "ARCH=${arch##* }" >> $GITHUB_OUTPUT
-
-      - name: Build ${{ matrix.arch }} release
-        run: |
-          mkdir artifacts
-          docker buildx build --platform ${{ steps.tags.outputs.platform }} \
-            --build-arg VERSION=${{ steps.tags.outputs.version }} \
-            --build-arg ARCH=${{ steps.tags.outputs.arch }} \
-            --build-arg PREFIX="/usr" \
-            -t yay:${{ steps.tags.outputs.arch }} . --load
-          make docker-release ARCH=${{ steps.tags.outputs.arch }} VERSION=${{ steps.tags.outputs.version }} PREFIX="/usr"
-          mv *.tar.gz artifacts
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: yay_${{ steps.tags.outputs.arch }}
-          path: artifacts
-
-  create_release:
-    name: Create release from this build
-    needs: [build-releases]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Read info
-        id: tags
-        run: |
-          echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
-          echo "TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: yay_*
-          merge-multiple: true
-
-      - name: Create Release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh release create ${{ steps.tags.outputs.tag }} \
-            --title "${{ steps.tags.outputs.tag }}" \
-            --generate-notes \
-            ./yay_${{ steps.tags.outputs.version }}_*.tar.gz
-
-      - name: Release Notary Action
-        uses: docker://aevea/release-notary:latest
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/testing-git.yml

@@ -1,39 +0,0 @@
-name: Test against pacman-git
-on:
-  pull_request:
-    paths-ignore:
-      - "doc/**"
-      - "**/*.po"
-      - "README.md"
-      - ".gitignore"
-
-jobs:
-  build:
-    name: Lint and test yay (-git)
-    runs-on: ubuntu-latest
-    container:
-      image: ghcr.io/jguer/yay-builder:latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v3
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-      - uses: actions/cache@v3
-        with:
-          path: /home/runner/work/yay/yay/pacman-git
-          key: ${{ runner.os }}-pacman-${{ hashFiles('/home/runner/work/yay/yay/pacman-git/PKGBUILD') }}
-          restore-keys: |
-            ${{ runner.os }}-pacman-
-      - name: checkout pacman-git
-        run: |
-          git -C ./pacman-git pull || git clone https://aur.archlinux.org/pacman-git
-          useradd github
-          echo 'github ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers
-          chmod -R 777 pacman-git
-          su github -c 'cd pacman-git; yes | makepkg -i --nocheck'
-      - name: Run Build and Tests with pacman-git
-        run: |
-          make test

.github/workflows/testing.yml

@@ -1,44 +0,0 @@
-name: Test against pacman
-on:
-  pull_request:
-
-jobs:
-  build:
-    name: Lint and test yay
-    runs-on: ubuntu-latest
-    container:
-      image: ghcr.io/jguer/yay-builder:latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v3
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-      - name: Lint
-        env:
-          GOFLAGS: -buildvcs=false -tags=next
-        run: /app/bin/golangci-lint run -v ./...
-      - name: Run Build and Tests
-        run: make test
-
-      - name: Run Integration Tests
-        continue-on-error: true
-        run: |
-          useradd -m yay &&
-          chown -R yay:yay . &&
-          cp -r ~/go/ /home/yay/go/ &&
-          chown -R yay:yay /home/yay/go/ &&
-            su yay -c "make test-integration"
-      - name: Build yay Artifact
-        env:
-          GOFLAGS: -buildvcs=false -tags=next
-        run: make
-      - name: Upload yay Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: yay
-          path: ./yay
-          if-no-files-found: error
-          overwrite: true

.gitignore

@@ -6,7 +6,10 @@
 # Folders
 _obj
 _test
-.vscode
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
 
 *.cgo1.go
 *.cgo2.c
@@ -22,13 +25,3 @@ yay_*/
 *.tar.gz
 qemu-*
 .go
-
-# Locale
-*.mo
-*.pot
-*.po~
-*.pprof
-
-node_modules/
-xgotext
-.devcontainer/

.golangci.yml

@@ -1,94 +0,0 @@
-version: "2"
-run:
-  go: "1.20"
-linters:
-  default: none
-  enable:
-    - bodyclose
-    - dogsled
-    - dupl
-    - errcheck
-    - errorlint
-    - gochecknoinits
-    - gocritic
-    - goprintffuncname
-    - gosec
-    - govet
-    - ineffassign
-    - lll
-    - misspell
-    - nakedret
-    - noctx
-    - nolintlint
-    - staticcheck
-    - unconvert
-    - unparam
-    - unused
-    - whitespace
-  settings:
-    dupl:
-      threshold: 100
-    funlen:
-      lines: 100
-      statements: 50
-    goconst:
-      min-len: 3
-      min-occurrences: 4
-    gocritic:
-      enabled-tags:
-        - diagnostic
-        - experimental
-        - opinionated
-        - performance
-        - style
-    gocyclo:
-      min-complexity: 15
-    lll:
-      line-length: 140
-    misspell:
-      locale: US
-    nolintlint:
-      require-explanation: false
-      require-specific: false
-      allow-unused: false
-  exclusions:
-    generated: lax
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    rules:
-      - linters:
-          - dupl
-          - errcheck
-          - errorlint
-          - gochecknoinits
-          - gocritic
-          - godot
-          - govet
-          - lll
-          - revive
-          - staticcheck
-          - wsl
-        path: (.+)_test.go
-      - path: (.+)\.go$
-        text: G204
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
-formatters:
-  enable:
-    - gofmt
-    - goimports
-  settings:
-    goimports:
-      local-prefixes:
-        - github.com/Jguer/yay/v12
-  exclusions:
-    generated: lax
-    paths:
-      - third_party$
-      - builtin$
-      - examples$

.pre-commit-config.yaml

@@ -1,29 +0,0 @@
-default_stages: [commit]
-
-repos:
-  - repo: https://github.com/dnephin/pre-commit-golang
-    rev: v0.5.1
-    hooks:
-      - id: go-fmt
-      - id: golangci-lint
-      - id: go-unit-tests
-      - id: go-build
-
-  - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v4.0.0-alpha.8 # Use the sha or tag you want to point at
-    hooks:
-      - id: prettier
-
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0 # Use the ref you want to point at
-    hooks:
-      - id: trailing-whitespace
-      - id: check-json
-      - id: check-yaml
-      - id: check-added-large-files
-
-  - repo: https://github.com/commitizen-tools/commitizen
-    rev: v3.15.0
-    hooks:
-      - id: commitizen
-        stages: [commit-msg]

.vscode/settings.json

@@ -1,7 +0,0 @@
-{
-    "go.lintTool": "golangci-lint",
-    "gopls": {
-        "formatting.gofumpt": true,
-        "formatting.local": "github.com/Jguer/yay/v12"
-    }
-}

Dockerfile

@@ -1,12 +1,12 @@
-FROM ghcr.io/jguer/yay-builder:latest
-LABEL maintainer="Jguer,docker@jguer.space"
-
-ARG VERSION
-ARG PREFIX
-ARG ARCH
+ARG BUILD_TAG=devel
+FROM samip537/archlinux:${BUILD_TAG}
+LABEL maintainer="Jguer,joaogg3 at google mail"
 
 WORKDIR /app
 
-COPY . .
+RUN pacman -Sy --overwrite=* --needed --noconfirm \
+    go git
 
-RUN make release VERSION=${VERSION} PREFIX=${PREFIX} ARCH=${ARCH}
+
+ENV ARCH=x86_64
+COPY . .

Makefile

@@ -1,6 +1,5 @@
 export GO111MODULE=on
-GOPROXY ?= https://proxy.golang.org,direct
-export GOPROXY
+export GOPROXY=https://proxy.golang.org
 
 BUILD_TAG = devel
 ARCH ?= $(shell uname -m)
@@ -10,29 +9,18 @@ GO ?= go
 PKGNAME := yay
 PREFIX := /usr/local
 
-MAJORVERSION := 12
-MINORVERSION := 0
-PATCHVERSION := 0
+MAJORVERSION := 9
+MINORVERSION := 4
+PATCHVERSION := 2
 VERSION ?= ${MAJORVERSION}.${MINORVERSION}.${PATCHVERSION}
 
-LOCALEDIR := po
-SYSTEMLOCALEPATH := $(PREFIX)/share/locale/
-
-# ls -1 po | sed -e 's/\.po$//' | paste -sd " "
-LANGS := ca cs de en es eu fr_FR he id it_IT ja ko pl_PL pt_BR pt ru_RU ru sv tr uk zh_CN zh_TW
-POTFILE := default.pot
-POFILES := $(addprefix $(LOCALEDIR)/,$(addsuffix .po,$(LANGS)))
-MOFILES := $(POFILES:.po=.mo)
-
-FLAGS ?= -trimpath -mod=readonly -modcacherw
-EXTRA_FLAGS ?= -buildmode=pie
-LDFLAGS := -X "main.yayVersion=${VERSION}" -X "main.localePath=${SYSTEMLOCALEPATH}" -linkmode=external -compressdwarf=false
+GOFLAGS := -v -mod=mod
+EXTRA_GOFLAGS ?=
+LDFLAGS := $(LDFLAGS) -X "main.version=${VERSION}"
 
 RELEASE_DIR := ${PKGNAME}_${VERSION}_${ARCH}
 PACKAGE := $(RELEASE_DIR).tar.gz
-SOURCES ?= $(shell find . -name "*.go" -type f)
-
-.PRECIOUS: ${LOCALEDIR}/%.po
+SOURCES ?= $(shell find . -name "*.go" -type f ! -path "./vendor/*")
 
 .PHONY: default
 default: build
@@ -42,19 +30,14 @@ all: | clean release
 
 .PHONY: clean
 clean:
-	$(GO) clean $(FLAGS) -i ./...
+	$(GO) clean $(GOFLAGS) -i ./...
 	rm -rf $(BIN) $(PKGNAME)_*
 
-.PHONY: test_lint
-test_lint: test lint
-
 .PHONY: test
 test:
-	$(GO) test -race -covermode=atomic $(FLAGS) ./...
-
-.PHONY: test-integration
-test-integration:
-	$(GO) test -tags=integration $(FLAGS) ./...
+	$(GO) vet $(GOFLAGS) ./...
+	@test -z "$$(gofmt -l *.go)" || (echo "Files need to be linted. Use make fmt" && false)
+	$(GO) test $(GOFLAGS) --race -covermode=atomic . ./pkg/...
 
 .PHONY: build
 build: $(BIN)
@@ -62,42 +45,76 @@ build: $(BIN)
 .PHONY: release
 release: $(PACKAGE)
 
+$(BIN): $(SOURCES)
+	$(GO) build $(GOFLAGS) -ldflags '-s -w $(LDFLAGS)' $(EXTRA_GOFLAGS) -o $@
+
+$(RELEASE_DIR):
+	mkdir $(RELEASE_DIR)
+
+$(PACKAGE): $(BIN) $(RELEASE_DIR)
+	cp -t $(RELEASE_DIR) ${BIN} doc/${PKGNAME}.8 completions/*
+	tar -czvf $(PACKAGE) $(RELEASE_DIR)
+
 .PHONY: docker-release-all
 docker-release-all:
 	make docker-release-armv7h ARCH=armv7h
 	make docker-release-x86_64 ARCH=x86_64
 	make docker-release-aarch64 ARCH=aarch64
 
-docker-release:
-	docker create --name yay-$(ARCH) yay:${ARCH} /bin/sh
+.PHONY: docker-release-armv7h
+docker-release-armv7h:
+	docker build --build-arg="BUILD_TAG=arm32v7-devel" -t yay-$(ARCH):${VERSION} .
+	docker run -e="ARCH=$(ARCH)" --name yay-$(ARCH) yay-$(ARCH):${VERSION} make release VERSION=${VERSION}
+	docker cp yay-$(ARCH):/app/${PACKAGE} $(PACKAGE)
+	docker container rm yay-$(ARCH)
+
+.PHONY: docker-release-aarch64
+docker-release-aarch64:
+	docker build --build-arg="BUILD_TAG=arm64v8-devel" -t yay-$(ARCH):${VERSION} .
+	docker run -e="ARCH=$(ARCH)" --name yay-$(ARCH) yay-$(ARCH):${VERSION} make release VERSION=${VERSION}
+	docker cp yay-$(ARCH):/app/${PACKAGE} $(PACKAGE)
+	docker container rm yay-$(ARCH)
+
+.PHONY: docker-release-x86_64
+docker-release-x86_64:
+	docker build --build-arg="BUILD_TAG=devel" -t yay-$(ARCH):${VERSION} .
+	docker run -e="ARCH=$(ARCH)" --name yay-$(ARCH) yay-$(ARCH):${VERSION} make release VERSION=${VERSION}
 	docker cp yay-$(ARCH):/app/${PACKAGE} $(PACKAGE)
 	docker container rm yay-$(ARCH)
 
 .PHONY: docker-build
 docker-build:
 	docker build -t yay-$(ARCH):${VERSION} .
-	docker run -e="ARCH=$(ARCH)" --name yay-$(ARCH) yay-$(ARCH):${VERSION} make build VERSION=${VERSION} PREFIX=${PREFIX}
+	docker run -e="ARCH=$(ARCH)" --name yay-$(ARCH) yay-$(ARCH):${VERSION} make build VERSION=${VERSION}
 	docker cp yay-$(ARCH):/app/${BIN} $(BIN)
 	docker container rm yay-$(ARCH)
 
+.PHONY: test-vendor
+test-vendor: vendor
+	@diff=$$(git diff vendor/); \
+	if [ -n "$$diff" ]; then \
+		echo "Please run 'make vendor' and commit the result:"; \
+		echo "$${diff}"; \
+		exit 1; \
+	fi;
+
 .PHONY: lint
 lint:
-	GOFLAGS="$(FLAGS)" golangci-lint run ./...
+	golangci-lint run
+	golint -set_exit_status . ./pkg/...
 
 .PHONY: fmt
 fmt:
-	go fmt ./...
+	#go fmt -mod=vendor $(GOFILES) ./... Doesn't work yet but will be supported soon
+	gofmt -s -w $(SOURCES)
 
 .PHONY: install
-install: build ${MOFILES}
+install:
 	install -Dm755 ${BIN} $(DESTDIR)$(PREFIX)/bin/${BIN}
 	install -Dm644 doc/${PKGNAME}.8 $(DESTDIR)$(PREFIX)/share/man/man8/${PKGNAME}.8
 	install -Dm644 completions/bash $(DESTDIR)$(PREFIX)/share/bash-completion/completions/${PKGNAME}
 	install -Dm644 completions/zsh $(DESTDIR)$(PREFIX)/share/zsh/site-functions/_${PKGNAME}
 	install -Dm644 completions/fish $(DESTDIR)$(PREFIX)/share/fish/vendor_completions.d/${PKGNAME}.fish
-	for lang in ${LANGS}; do \
-		install -Dm644 ${LOCALEDIR}/$${lang}.mo $(DESTDIR)$(PREFIX)/share/locale/$$lang/LC_MESSAGES/${PKGNAME}.mo; \
-	done
 
 .PHONY: uninstall
 uninstall:
@@ -106,29 +123,3 @@ uninstall:
 	rm -f $(DESTDIR)$(PREFIX)/share/bash-completion/completions/${PKGNAME}
 	rm -f $(DESTDIR)$(PREFIX)/share/zsh/site-functions/_${PKGNAME}
 	rm -f $(DESTDIR)$(PREFIX)/share/fish/vendor_completions.d/${PKGNAME}.fish
-	for lang in ${LANGS}; do \
-		rm -f $(DESTDIR)$(PREFIX)/share/locale/$$lang/LC_MESSAGES/${PKGNAME}.mo; \
-	done
-
-$(BIN): $(SOURCES)
-	$(GO) build $(FLAGS) -ldflags '$(LDFLAGS)' $(EXTRA_FLAGS) -o $@
-
-$(RELEASE_DIR):
-	mkdir $(RELEASE_DIR)
-
-$(PACKAGE): $(BIN) $(RELEASE_DIR) ${MOFILES}
-	strip ${BIN}
-	cp -t $(RELEASE_DIR) ${BIN} doc/${PKGNAME}.8 completions/* ${MOFILES}
-	tar -czvf $(PACKAGE) $(RELEASE_DIR)
-
-locale:
-	xgotext -in . -out po
-	mv po/default.pot po/en.po
-	for lang in ${LANGS}; do \
-		test -f po/$$lang.po || msginit --no-translator -l po/$$lang.po -i po/${POTFILE} -o po/$$lang.po; \
-		msgmerge -U po/$$lang.po po/${POTFILE}; \
-		touch po/$$lang.po; \
-	done
-
-${LOCALEDIR}/%.mo: ${LOCALEDIR}/%.po
-	msgfmt $< -o $@

README.md

@@ -1,162 +1,48 @@
-[![yay](https://img.shields.io/aur/version/yay?color=1793d1&label=yay&logo=arch-linux&style=for-the-badge)](https://aur.archlinux.org/packages/yay/)
-[![yay-bin](https://img.shields.io/aur/version/yay-bin?color=1793d1&label=yay-bin&logo=arch-linux&style=for-the-badge)](https://aur.archlinux.org/packages/yay-bin/)
-[![yay-git](https://img.shields.io/aur/version/yay-git?color=1793d1&label=yay-git&logo=arch-linux&style=for-the-badge)](https://aur.archlinux.org/packages/yay-git/)
-![AUR votes](https://img.shields.io/aur/votes/yay?color=333333&style=for-the-badge)
-[![GitHub license](https://img.shields.io/github/license/jguer/yay?color=333333&style=for-the-badge)](https://github.com/Jguer/yay/blob/master/LICENSE)
-
 # Yay
 
 Yet Another Yogurt - An AUR Helper Written in Go
 
-### Help translate yay: [Transifex](https://www.transifex.com/yay-1/yay/)
+#### Packages
+
+[![yay](https://img.shields.io/aur/version/yay.svg?label=yay)](https://aur.archlinux.org/packages/yay/) [![yay-bin](https://img.shields.io/aur/version/yay-bin.svg?label=yay-bin)](https://aur.archlinux.org/packages/yay-bin/) [![yay-git](https://img.shields.io/aur/version/yay-git.svg?label=yay-git)](https://aur.archlinux.org/packages/yay-git/) [![GitHub license](https://img.shields.io/github/license/jguer/yay.svg)](https://github.com/Jguer/yay/blob/master/LICENSE)
+
+## Objectives
+
+There's a point in everyone's life when you feel the need to write an AUR helper because there are only about 20 of them.
+So say hi to 20+1.
+
+Yay is based on the design of [yaourt](https://github.com/archlinuxfr/yaourt), [apacman](https://github.com/oshazard/apacman) and [pacaur](https://github.com/rmarquis/pacaur). It is developed with these objectives in mind:
+
+- Provide an interface for pacman
+- Yaourt-style interactive search/install
+- Minimal dependencies
+- Minimize user input
+- Know when git packages are due for upgrades
 
 ## Features
 
-- Advanced dependency solving
-- PKGBUILD downloading from ABS or AUR
-- Completions for AUR packages
+- Perform advanced dependency solving
+- Download PKGBUILDs from ABS or AUR
+- Tab-complete the AUR
 - Query user up-front for all input (prior to starting builds)
-- Narrow search (`yay linux header` will first search `linux` and then narrow on `header`)
+- Narrow search terms (`yay linux header` will first search `linux` and then narrow on `header`)
 - Find matching package providers during search and allow selection
 - Remove make dependencies at the end of the build process
-- Build local PKGBUILDs with AUR dependencies
-- Un/Vote for packages
-
-[![asciicast](https://asciinema.org/a/399431.svg)](https://asciinema.org/a/399431)
-
-[![asciicast](https://asciinema.org/a/399433.svg)](https://asciinema.org/a/399433)
+- Run without sourcing PKGBUILD
 
 ## Installation
 
 If you are migrating from another AUR helper, you can simply install Yay with that helper.
 
-> [!WARNING]  
-> We are using `sudo` in these examples, you can switch that out for a different privilege escalation tool.
-
-### Source
-
-The initial installation of Yay can be done by cloning the PKGBUILD and
+Alternatively, the initial installation of Yay can be done by cloning the PKGBUILD and
 building with makepkg:
 
-We make sure we have the `base-devel` package group installed.
-
 ```sh
-sudo pacman -S --needed git base-devel
 git clone https://aur.archlinux.org/yay.git
 cd yay
 makepkg -si
 ```
 
-If you want to do all of this at once, we can chain the commands like so:
-
-```sh
-sudo pacman -S --needed git base-devel && git clone https://aur.archlinux.org/yay.git && cd yay && makepkg -si
-```
-
-### Binary
-
-If you do not want to compile yay yourself you can use the builds generated by
-GitHub Actions.
-
-```sh
-sudo pacman -S --needed git base-devel
-git clone https://aur.archlinux.org/yay-bin.git
-cd yay-bin
-makepkg -si
-```
-
-If you want to do all of this at once, we can chain the commands like so:
-
-```sh
-sudo pacman -S --needed git base-devel && git clone https://aur.archlinux.org/yay-bin.git && cd yay-bin && makepkg -si
-```
-
-### Other distributions
-
-If you're using Manjaro or [another distribution that packages `yay`](https://repology.org/project/yay/versions)
-you can simply install yay using pacman (as root):
-
-```sh
-pacman -S --needed git base-devel yay
-```
-> [!WARNING]  
-> distributions sometimes lag updating yay on their repositories.
-
-## First Use
-
-#### Development packages upgrade
-
-- Use `yay -Y --gendb` to generate a development package database for `*-git`
-  packages that were installed without yay.
-  This command should only be run once.
-
-- `yay -Syu --devel` will then check for development package updates
-
-- Use `yay -Y --devel --save` to make development package updates permanently
-  enabled (`yay` and `yay -Syu` will then always check dev packages)
-
-## Examples of Custom Operations
-
-| Command                           | Description                                                                                                |
-| --------------------------------- | ---------------------------------------------------------------------------------------------------------- |
-| `yay`                             | Alias to `yay -Syu`.                                                                                       |
-| `yay <Search Term>`               | Present package-installation selection menu.                                                               |
-| `yay -Bi <dir>`                   | Install dependencies and build a local PKGBUILD.                                                           |
-| `yay -G <AUR Package>`            | Download PKGBUILD from ABS or AUR. (yay v12.0+)                                                            |
-| `yay -Gp <AUR Package>`           | Print to stdout PKGBUILD from ABS or AUR.                                                                  |
-| `yay -Ps`                         | Print system statistics.                                                                                   |
-| `yay -Syu --devel`                | Perform system upgrade, but also check for development package updates.                                    |
-| `yay -Syu --timeupdate`           | Perform system upgrade and use PKGBUILD modification time (not version number) to determine update.        |
-| `yay -Wu <AUR Package>`           | Unvote for package (Requires setting `AUR_USERNAME` and `AUR_PASSWORD` environment variables) (yay v11.3+) |
-| `yay -Wv <AUR Package>`           | Vote for package (Requires setting `AUR_USERNAME` and `AUR_PASSWORD` environment variables). (yay v11.3+)  |
-| `yay -Y --combinedupgrade --save` | Make combined upgrade the default mode.                                                                    |
-| `yay -Y --gendb`                  | Generate development package database used for devel update.                                               |
-| `yay -Yc`                         | Clean unneeded dependencies.                                                                               |
-
-## Frequently Asked Questions
-
-- **Yay does not display colored output. How do I fix it?**
-
-  Make sure you have the `Color` option in your `/etc/pacman.conf`
-  (see issue [#123](https://github.com/Jguer/yay/issues/123)).
-
-- **Sometimes diffs are printed to the terminal, and other times they are paged via less. How do I fix this?**
-
-  Yay uses `git diff` to display diffs, which by default tells less not to
-  page if the output can fit into one terminal length. This behavior can be
-  overridden by exporting your own flags (`export LESS=SRX`).
-
-- **Yay is not asking me to edit PKGBUILDS, and I don't like the diff menu! What can I do?**
-
-  `yay --editmenu --diffmenu=false --save`
-
-- **How can I tell Yay to act only on AUR packages, or only on repo packages?**
-
-  `yay -{OPERATION} --aur`
-  `yay -{OPERATION} --repo`
-
-- **A `Flagged Out Of Date AUR Packages` message is displayed. Why doesn't Yay update them?**
-
-  This message does not mean that updated AUR packages are available. It means
-  the packages have been flagged out of date on the AUR, but
-  their maintainers have not yet updated the `PKGBUILD`s
-  (see [outdated AUR packages](https://wiki.archlinux.org/index.php/Arch_User_Repository#Foo_in_the_AUR_is_outdated.3B_what_should_I_do.3F)).
-
-- **Yay doesn't install dependencies added to a PKGBUILD during installation.**
-
-  Yay resolves all dependencies ahead of time. You are free to edit the
-  PKGBUILD in any way, but any problems you cause are your own and should not be
-  reported unless they can be reproduced with the original PKGBUILD.
-
-- **I know my `-git` package has updates but yay doesn't offer to update it**
-
-  Yay uses a hash cache for development packages. Normally it is updated at the end of the package install with the message `Found git repo`.
-  If you transition between aur helpers and did not install the devel package using yay at some point, it is possible it never got added to the cache. `yay -Y --gendb` will fix the current version of every devel package and start checking from there.
-
-- **I want to help out!**
-
-  Check [CONTRIBUTING.md](./CONTRIBUTING.md) for more information.
-
 ## Support
 
 All support related to Yay should be requested via GitHub issues. Since Yay is not
@@ -165,25 +51,84 @@ forums, AUR comments or other official channels.
 
 A broken AUR package should be reported as a comment on the package's AUR page.
 A package may only be considered broken if it fails to build with makepkg.
-
 Reports should be made using makepkg and include the full output as well as any
 other relevant information. Never make reports using Yay or any other external
 tools.
 
+## Frequently Asked Questions
+
+#### Yay does not display colored output. How do I fix it?
+
+Make sure you have the `Color` option in your `/etc/pacman.conf`
+(see issue [#123](https://github.com/Jguer/yay/issues/123)).
+
+#### Yay is not prompting to skip packages during system upgrade.
+
+The default behavior was changed after
+[v8.918](https://github.com/Jguer/yay/releases/tag/v8.918)
+(see [3bdb534](https://github.com/Jguer/yay/commit/3bdb5343218d99d40f8a449b887348611f6bdbfc)
+and issue [#554](https://github.com/Jguer/yay/issues/554)).
+To restore the package-skip behavior use `--combinedupgrade` (make
+it permanent by appending `--save`). Note: skipping packages will leave your
+system in a
+[partially-upgraded state](https://wiki.archlinux.org/index.php/System_maintenance#Partial_upgrades_are_unsupported).
+
+#### Sometimes diffs are printed to the terminal, and other times they are paged via less. How do I fix this?
+
+Yay uses `git diff` to display diffs, which by default tells less not to
+page if the output can fit into one terminal length. This behavior can be
+overridden by exporting your own flags (`export LESS=SRX`).
+
+#### Yay is not asking me to edit PKGBUILDS, and I don't like the diff menu! What can I do?
+
+`yay --editmenu --nodiffmenu --save`
+
+#### How can I tell Yay to act only on AUR packages, or only on repo packages?
+
+`yay -{OPERATION} --aur`
+`yay -{OPERATION} --repo`
+
+#### An `Out Of Date AUR Packages` message is displayed. Why doesn't Yay update them?
+
+This message does not mean that updated AUR packages are available. It means
+the packages have been flagged out of date on the AUR, but
+their maintainers have not yet updated the `PKGBUILD`s
+(see [outdated AUR packages](https://wiki.archlinux.org/index.php/Arch_User_Repository#Foo_in_the_AUR_is_outdated.3B_what_should_I_do.3F)).
+
+#### Yay doesn't install dependencies added to a PKGBUILD during installation.
+
+Yay resolves all dependencies ahead of time. You are free to edit the
+PKGBUILD in any way, but any problems you cause are your own and should not be
+reported unless they can be reproduced with the original PKGBUILD.
+
+#### I know my `-git` package has updates but yay doesn't offer to update it
+
+Yay uses an hash cache for development packages. Normally it is updated at the end of the package install with the message `Found git repo`.
+If you transition between aur helpers and did not install the devel package using yay at some point, it is possible it never got added to the cache. `yay -Y --gendb` will fix the current version of every devel package and start checking from there.
+
+#### I want to help out!
+
+Check `CONTRIBUTING.md` for more information.
+
+## Examples of Custom Operations
+
+| Command                         | Description                                                                                                                                         |
+| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `yay <Search Term>`             | Present package-installation selection menu.                                                                                                        |
+| `yay -Ps`                       | Print system statistics.                                                                                                                            |
+| `yay -Yc`                       | Clean unneeded dependencies.                                                                                                                        |
+| `yay -G <AUR Package>`          | Download PKGBUILD from ABS or AUR.                                                                                                                  |
+| `yay -Y --gendb`                | Generate development package database used for devel update.                                                                                        |
+| `yay -Syu --devel --timeupdate` | Perform system upgrade, but also check for development package updates and use PKGBUILD modification time (not version number) to determine update. |
+
 ## Images
 
-<p align="center">
-  <img src="https://raw.githubusercontent.com/Jguer/jguer.github.io/refs/heads/master/yay/yay.png" width="42%">
-  <img src="https://raw.githubusercontent.com/Jguer/jguer.github.io/refs/heads/master/yay/yay-s.png" width="42%">
+<p float="left">
+<img src="https://rawcdn.githack.com/Jguer/jguer.github.io/77647f396cb7156fd32e30970dbeaf6d6dc7f983/yay/yay.png" width="42%"/>
+<img src="https://rawcdn.githack.com/Jguer/jguer.github.io/77647f396cb7156fd32e30970dbeaf6d6dc7f983/yay/yay-s.png" width="42%"/>
 </p>
 
-<p align="center">
-  <img src="https://raw.githubusercontent.com/Jguer/jguer.github.io/refs/heads/master/yay/yay-y.png" width="42%">
-  <img src="https://raw.githubusercontent.com/Jguer/jguer.github.io/refs/heads/master/yay/yay-ps.png" width="42%">
+<p float="left">
+<img src="https://rawcdn.githack.com/Jguer/jguer.github.io/77647f396cb7156fd32e30970dbeaf6d6dc7f983/yay/yay-y.png" width="42%"/> 
+<img src="https://rawcdn.githack.com/Jguer/jguer.github.io/77647f396cb7156fd32e30970dbeaf6d6dc7f983/yay/yay-ps.png" width="42%"/> 
 </p>
-
-### Other AUR helpers/tools
-
-- [paru](https://github.com/morganamilo/paru)
-- [aurutils](https://github.com/AladW/aurutils)
-- [pikaur](https://github.com/actionless/pikaur)

SECURITY.md

@@ -1,13 +0,0 @@
-# Security Policy
-
-Thank you for helping keep yay secure!
-
-## Supported Versions
-
-We only provide security updates and support for the latest released version of yay. Please ensure you are using the most up-to-date version before reporting vulnerabilities.
-
-## Reporting a Vulnerability
-
-If you discover a security vulnerability, please email us at [security@jguer.space](mailto:security@jguer.space). We will respond as quickly as possible and coordinate a fix.
-
-We appreciate responsible disclosure and your help in making this project safe for everyone. 

callbacks.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+
+	alpm "github.com/Jguer/go-alpm"
+)
+
+func questionCallback(question alpm.QuestionAny) {
+	if qi, err := question.QuestionInstallIgnorepkg(); err == nil {
+		qi.SetInstall(true)
+	}
+
+	qp, err := question.QuestionSelectProvider()
+	if err != nil {
+		return
+	}
+
+	if hideMenus {
+		return
+	}
+
+	size := 0
+
+	_ = qp.Providers(alpmHandle).ForEach(func(pkg alpm.Package) error {
+		size++
+		return nil
+	})
+
+	fmt.Print(bold(cyan(":: ")))
+	str := bold(fmt.Sprintf(bold("There are %d providers available for %s:"), size, qp.Dep()))
+
+	size = 1
+	var db string
+
+	_ = qp.Providers(alpmHandle).ForEach(func(pkg alpm.Package) error {
+		thisDB := pkg.DB().Name()
+
+		if db != thisDB {
+			db = thisDB
+			str += bold(cyan("\n:: ")) + bold("Repository "+db+"\n    ")
+		}
+		str += fmt.Sprintf("%d) %s ", size, pkg.Name())
+		size++
+		return nil
+	})
+
+	fmt.Println(str)
+
+	for {
+		fmt.Print("\nEnter a number (default=1): ")
+
+		if config.NoConfirm {
+			fmt.Println()
+			break
+		}
+
+		reader := bufio.NewReader(os.Stdin)
+		numberBuf, overflow, err := reader.ReadLine()
+
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			break
+		}
+
+		if overflow {
+			fmt.Fprintln(os.Stderr, "Input too long")
+			continue
+		}
+
+		if string(numberBuf) == "" {
+			break
+		}
+
+		num, err := strconv.Atoi(string(numberBuf))
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%s invalid number: %s\n", red("error:"), string(numberBuf))
+			continue
+		}
+
+		if num < 1 || num > size {
+			fmt.Fprintf(os.Stderr, "%s invalid value: %d is not between %d and %d\n", red("error:"), num, 1, size)
+			continue
+		}
+
+		qp.SetUseIndex(num - 1)
+		break
+	}
+}
+
+func logCallback(level alpm.LogLevel, str string) {
+	switch level {
+	case alpm.LogWarning:
+		fmt.Print(bold(yellow(smallArrow)), " ", str)
+	case alpm.LogError:
+		fmt.Print(bold(red(smallArrow)), " ", str)
+	}
+}

ci.Dockerfile

@@ -1,15 +0,0 @@
-FROM docker.io/ljmf00/archlinux:devel
-LABEL maintainer="Jguer,docker@jguer.space"
-
-ENV GO111MODULE=on
-WORKDIR /app
-
-RUN sed -i '/^\[community\]/,/^\[/ s/^/#/' /etc/pacman.conf
-
-COPY go.mod .
-
-RUN pacman-key --init && pacman -Sy && pacman -S --overwrite=* --noconfirm archlinux-keyring && \
-    pacman -Su --overwrite=* --needed --noconfirm pacman doxygen meson asciidoc go git gcc make sudo base-devel && \
-    rm -rfv /var/cache/pacman/* /var/lib/pacman/sync/* && \
-    curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v2.1.5 && \
-    go mod download 

clean.go

@@ -1,122 +1,128 @@
 package main
 
 import (
-	"context"
+	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 
-	"github.com/Jguer/aur"
-	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
+	"github.com/Jguer/yay/v9/pkg/stringset"
 )
 
-// CleanDependencies removes all dangling dependencies in system.
-func cleanDependencies(ctx context.Context, cfg *settings.Configuration,
-	cmdBuilder exe.ICmdBuilder, cmdArgs *parser.Arguments, dbExecutor db.Executor,
-	removeOptional bool,
-) error {
-	hanging := hangingPackages(removeOptional, dbExecutor)
+// GetPkgbuild gets the pkgbuild of the package 'pkg' trying the ABS first and then the AUR trying the ABS first and then the AUR.
+
+// RemovePackage removes package from VCS information
+func removeVCSPackage(pkgs []string) {
+	updated := false
+
+	for _, pkgName := range pkgs {
+		if _, ok := savedInfo[pkgName]; ok {
+			delete(savedInfo, pkgName)
+			updated = true
+		}
+	}
+
+	if updated {
+		err := saveVCSInfo()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}
+}
+
+// CleanDependencies removes all dangling dependencies in system
+func cleanDependencies(removeOptional bool) error {
+	hanging, err := hangingPackages(removeOptional)
+	if err != nil {
+		return err
+	}
+
 	if len(hanging) != 0 {
-		return cleanRemove(ctx, cfg, cmdBuilder, cmdArgs, hanging)
+		return cleanRemove(hanging)
 	}
 
 	return nil
 }
 
-// CleanRemove sends a full removal command to pacman with the pkgName slice.
-func cleanRemove(ctx context.Context, cfg *settings.Configuration,
-	cmdBuilder exe.ICmdBuilder, cmdArgs *parser.Arguments, pkgNames []string,
-) error {
+// CleanRemove sends a full removal command to pacman with the pkgName slice
+func cleanRemove(pkgNames []string) error {
 	if len(pkgNames) == 0 {
 		return nil
 	}
 
-	arguments := cmdArgs.CopyGlobal()
-	if err := arguments.AddArg("R", "s", "u"); err != nil {
-		return err
-	}
-	arguments.AddTarget(pkgNames...)
+	arguments := cmdArgs.copyGlobal()
+	_ = arguments.addArg("R")
+	arguments.addTarget(pkgNames...)
 
-	return cmdBuilder.Show(
-		cmdBuilder.BuildPacmanCmd(ctx,
-			arguments, cfg.Mode, settings.NoConfirm))
+	return show(passToPacman(arguments))
 }
 
-func syncClean(ctx context.Context, run *runtime.Runtime, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
+func syncClean(parser *arguments) error {
+	var err error
 	keepInstalled := false
 	keepCurrent := false
 
-	_, removeAll, _ := cmdArgs.GetArg("c", "clean")
+	_, removeAll, _ := parser.getArg("c", "clean")
 
-	for _, v := range run.PacmanConf.CleanMethod {
-		switch v {
-		case "KeepInstalled":
+	for _, v := range pacmanConf.CleanMethod {
+		if v == "KeepInstalled" {
 			keepInstalled = true
-		case "KeepCurrent":
+		} else if v == "KeepCurrent" {
 			keepCurrent = true
 		}
 	}
 
-	if run.Cfg.Mode.AtLeastRepo() {
-		if err := run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, run.Cfg.Mode, settings.NoConfirm)); err != nil {
+	if mode == modeRepo || mode == modeAny {
+		if err := show(passToPacman(parser)); err != nil {
 			return err
 		}
 	}
 
-	if !run.Cfg.Mode.AtLeastAUR() {
+	if !(mode == modeAUR || mode == modeAny) {
 		return nil
 	}
 
 	var question string
 	if removeAll {
-		question = gotext.Get("Do you want to remove ALL AUR packages from cache?")
+		question = "Do you want to remove ALL AUR packages from cache?"
 	} else {
-		question = gotext.Get("Do you want to remove all other AUR packages from cache?")
+		question = "Do you want to remove all other AUR packages from cache?"
 	}
 
-	run.Logger.Println(gotext.Get("\nBuild directory:"), run.Cfg.BuildDir)
+	fmt.Printf("\nBuild directory: %s\n", config.BuildDir)
 
-	if run.Logger.ContinueTask(question, true, settings.NoConfirm) {
-		if err := cleanAUR(ctx, run, keepInstalled, keepCurrent, removeAll, dbExecutor); err != nil {
-			return err
-		}
+	if continueTask(question, true) {
+		err = cleanAUR(keepInstalled, keepCurrent, removeAll)
 	}
 
-	if removeAll {
-		return nil
+	if err != nil || removeAll {
+		return err
 	}
 
-	if run.Logger.ContinueTask(gotext.Get("Do you want to remove ALL untracked AUR files?"), true, settings.NoConfirm) {
-		return cleanUntracked(ctx, run)
+	if continueTask("Do you want to remove ALL untracked AUR files?", true) {
+		return cleanUntracked()
 	}
 
 	return nil
 }
 
-func cleanAUR(ctx context.Context, run *runtime.Runtime,
-	keepInstalled, keepCurrent, removeAll bool, dbExecutor db.Executor,
-) error {
-	run.Logger.Println(gotext.Get("removing AUR packages from cache..."))
+func cleanAUR(keepInstalled, keepCurrent, removeAll bool) error {
+	fmt.Println("removing AUR packages from cache...")
 
-	installedBases := mapset.NewThreadUnsafeSet[string]()
-	inAURBases := mapset.NewThreadUnsafeSet[string]()
+	installedBases := make(stringset.StringSet)
+	inAURBases := make(stringset.StringSet)
 
-	remotePackages := dbExecutor.InstalledRemotePackages()
+	_, remotePackages, _, _, err := filterPackages()
+	if err != nil {
+		return err
+	}
 
-	files, err := os.ReadDir(run.Cfg.BuildDir)
+	files, err := ioutil.ReadDir(config.BuildDir)
 	if err != nil {
 		return err
 	}
 
 	cachedPackages := make([]string, 0, len(files))
-
 	for _, file := range files {
 		if !file.IsDir() {
 			continue
@@ -130,23 +136,21 @@ func cleanAUR(ctx context.Context, run *runtime.Runtime,
 	// Querying the AUR is slow and needs internet so don't do it if we
 	// don't need to.
 	if keepCurrent {
-		info, errInfo := run.AURClient.Get(ctx, &aur.Query{
-			Needles: cachedPackages,
-		})
-		if errInfo != nil {
-			return errInfo
+		info, err := aurInfo(cachedPackages, &aurWarnings{})
+		if err != nil {
+			return err
 		}
 
-		for i := range info {
-			inAURBases.Add(info[i].PackageBase)
+		for _, pkg := range info {
+			inAURBases.Set(pkg.PackageBase)
 		}
 	}
 
 	for _, pkg := range remotePackages {
 		if pkg.Base() != "" {
-			installedBases.Add(pkg.Base())
+			installedBases.Set(pkg.Base())
 		} else {
-			installedBases.Add(pkg.Name())
+			installedBases.Set(pkg.Name())
 		}
 	}
 
@@ -156,29 +160,28 @@ func cleanAUR(ctx context.Context, run *runtime.Runtime,
 		}
 
 		if !removeAll {
-			if keepInstalled && installedBases.Contains(file.Name()) {
+			if keepInstalled && installedBases.Get(file.Name()) {
 				continue
 			}
 
-			if keepCurrent && inAURBases.Contains(file.Name()) {
+			if keepCurrent && inAURBases.Get(file.Name()) {
 				continue
 			}
 		}
 
-		dir := filepath.Join(run.Cfg.BuildDir, file.Name())
-		run.Logger.Debugln("removing", dir)
-		if err = os.RemoveAll(dir); err != nil {
-			run.Logger.Warnln(gotext.Get("Unable to remove %s: %s", dir, err))
+		err = os.RemoveAll(filepath.Join(config.BuildDir, file.Name()))
+		if err != nil {
+			return nil
 		}
 	}
 
 	return nil
 }
 
-func cleanUntracked(ctx context.Context, run *runtime.Runtime) error {
-	run.Logger.Println(gotext.Get("removing untracked AUR files from cache..."))
+func cleanUntracked() error {
+	fmt.Println("removing Untracked AUR files from cache...")
 
-	files, err := os.ReadDir(run.Cfg.BuildDir)
+	files, err := ioutil.ReadDir(config.BuildDir)
 	if err != nil {
 		return err
 	}
@@ -188,20 +191,39 @@ func cleanUntracked(ctx context.Context, run *runtime.Runtime) error {
 			continue
 		}
 
-		dir := filepath.Join(run.Cfg.BuildDir, file.Name())
-		run.Logger.Debugln("cleaning", dir)
-		if isGitRepository(dir) {
-			if err := run.CmdBuilder.Show(run.CmdBuilder.BuildGitCmd(ctx, dir, "clean", "-fx")); err != nil {
-				run.Logger.Warnln(gotext.Get("Unable to clean:"), dir)
-				return err
-			}
+		dir := filepath.Join(config.BuildDir, file.Name())
+		if err := show(passToGit(dir, "clean", "-fx")); err != nil {
+			return err
 		}
 	}
 
 	return nil
 }
 
-func isGitRepository(dir string) bool {
-	_, err := os.Stat(filepath.Join(dir, ".git"))
-	return !os.IsNotExist(err)
+func cleanAfter(bases []Base) {
+	fmt.Println("removing Untracked AUR files from cache...")
+
+	for i, base := range bases {
+		dir := filepath.Join(config.BuildDir, base.Pkgbase())
+
+		fmt.Printf(bold(cyan("::")+" Cleaning (%d/%d): %s\n"), i+1, len(bases), cyan(dir))
+		_, stderr, err := capture(passToGit(dir, "reset", "--hard", "HEAD"))
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "error resetting %s: %s", base.String(), stderr)
+		}
+
+		if err := show(passToGit(dir, "clean", "-fx")); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}
+}
+
+func cleanBuilds(bases []Base) {
+	for i, base := range bases {
+		dir := filepath.Join(config.BuildDir, base.Pkgbase())
+		fmt.Printf(bold(cyan("::")+" Deleting (%d/%d): %s\n"), i+1, len(bases), cyan(dir))
+		if err := os.RemoveAll(dir); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}
 }

clean_test.go

@@ -1,116 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"os/exec"
-	"strings"
-	"testing"
-
-	"github.com/Jguer/go-alpm/v2"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/Jguer/yay/v12/pkg/db/mock"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-)
-
-func TestCleanHanging(t *testing.T) {
-	pacmanBin := t.TempDir() + "/pacman"
-
-	t.Parallel()
-
-	testCases := []struct {
-		name     string
-		args     []string
-		wantShow []string
-	}{
-		{
-			name:     "clean",
-			args:     []string{"Y", "c"},
-			wantShow: []string{"pacman", "-R", "-s", "-u", "--config", "/etc/pacman.conf", "--", "lsp-plugins"},
-		},
-		{
-			name:     "clean double",
-			args:     []string{"Y", "c", "c"},
-			wantShow: []string{"pacman", "-R", "-s", "-u", "--config", "/etc/pacman.conf", "--", "lsp-plugins", "linux-headers"},
-		},
-	}
-
-	dbExc := &mock.DBExecutor{
-		PackageOptionalDependsFn: func(i alpm.IPackage) []alpm.Depend {
-			if i.Name() == "linux" {
-				return []alpm.Depend{
-					{
-						Name: "linux-headers",
-					},
-				}
-			}
-
-			return []alpm.Depend{}
-		},
-		PackageProvidesFn: func(p alpm.IPackage) []alpm.Depend { return []alpm.Depend{} },
-		PackageDependsFn:  func(p alpm.IPackage) []alpm.Depend { return []alpm.Depend{} },
-		LocalPackagesFn: func() []mock.IPackage {
-			return []mock.IPackage{
-				&mock.Package{
-					PReason: alpm.PkgReasonExplicit,
-					PName:   "linux",
-				},
-				&mock.Package{
-					PReason: alpm.PkgReasonDepend,
-					PName:   "lsp-plugins",
-				},
-				&mock.Package{
-					PReason: alpm.PkgReasonDepend,
-					PName:   "linux-headers",
-				},
-			}
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			mockRunner := &exe.MockRunner{
-				CaptureFn: func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
-					return "", "", nil
-				},
-				ShowFn: func(cmd *exec.Cmd) error { return nil },
-			}
-			cmdBuilder := &exe.CmdBuilder{
-				SudoBin:          "su",
-				PacmanBin:        pacmanBin,
-				PacmanConfigPath: "/etc/pacman.conf",
-				GitBin:           "git",
-				Runner:           mockRunner,
-				SudoLoopEnabled:  false,
-			}
-
-			run := &runtime.Runtime{CmdBuilder: cmdBuilder, Cfg: &settings.Configuration{}}
-			cmdArgs := parser.MakeArguments()
-			cmdArgs.AddArg(tc.args...)
-
-			err := handleCmd(context.Background(),
-				run, cmdArgs, dbExc,
-			)
-
-			require.NoError(t, err)
-
-			for i, call := range mockRunner.ShowCalls {
-				show := call.Args[0].(*exec.Cmd).String()
-				show = strings.ReplaceAll(show, pacmanBin, "pacman")
-
-				// options are in a different order on different systems and on CI root user is used
-				assert.Subset(t, strings.Split(show, " "),
-					strings.Split(tc.wantShow[i], " "),
-					fmt.Sprintf("%d - %s", i, show))
-			}
-		})
-	}
-}

cmd.go

@@ -2,32 +2,19 @@ package main
 
 import (
 	"bufio"
-	"context"
-	"errors"
 	"fmt"
 	"net/http"
-	"strings"
+	"os"
 
-	alpm "github.com/Jguer/go-alpm/v2"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/completion"
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/download"
-	"github.com/Jguer/yay/v12/pkg/intrange"
-	"github.com/Jguer/yay/v12/pkg/news"
-	"github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/text"
-	"github.com/Jguer/yay/v12/pkg/upgrade"
-	"github.com/Jguer/yay/v12/pkg/vcs"
+	alpm "github.com/Jguer/go-alpm"
+	"github.com/Jguer/yay/v9/pkg/completion"
+	"github.com/Jguer/yay/v9/pkg/intrange"
 )
 
-func usage(logger *text.Logger) {
-	logger.Println(`Usage:
+var cmdArgs = makeArguments()
+
+func usage() {
+	fmt.Println(`Usage:
     yay
     yay <operation> [...]
     yay <package(s)>
@@ -44,17 +31,15 @@ operations:
     yay {-U --upgrade}     [options] <file(s)>
 
 New operations:
-    yay {-B --build}       [options] [dir]
-    yay {-G --getpkgbuild} [options] [package(s)]
-    yay {-P --show}        [options]
-    yay {-W --web}         [options] [package(s)]
     yay {-Y --yay}         [options] [package(s)]
+    yay {-P --show}        [options]
+    yay {-G --getpkgbuild} [package(s)]
 
-If no operation is specified 'yay -Syu' will be performed
-If no operation is specified and targets are provided -Y will be assumed
+If no arguments are provided 'yay -Syu' will be performed
+If no operation is provided -Y will be assumed
 
 New options:
-    -N --repo             Assume targets are from the repositories
+       --repo             Assume targets are from the repositories
     -a --aur              Assume targets are from the AUR
 
 Permanent configuration options:
@@ -62,8 +47,8 @@ Permanent configuration options:
                           config file when used
 
     --aururl      <url>   Set an alternative AUR URL
-    --aurrpcurl   <url>   Set an alternative URL for the AUR /rpc endpoint
     --builddir    <dir>   Directory used to download and run PKGBUILDS
+    --absdir      <dir>   Directory used to store downloads from the ABS
     --editor      <file>  Editor to use when editing PKGBUILDs
     --editorflags <flags> Pass arguments to editor
     --makepkg     <file>  makepkg command to use
@@ -78,7 +63,7 @@ Permanent configuration options:
     --nomakepkgconf       Use the default makepkg.conf
 
     --requestsplitn <n>   Max amount of packages to query per AUR request
-    --completioninterval  <n> Time in days to refresh completion cache
+    --completioninterval  <n> Time in days to to refresh completion cache
     --sortby    <field>   Sort AUR results by a specific field during search
     --searchby  <field>   Search for packages using a specified field
     --answerclean   <a>   Set a predetermined answer for the clean build menu
@@ -92,19 +77,22 @@ Permanent configuration options:
     --cleanmenu           Give the option to clean build PKGBUILDS
     --diffmenu            Give the option to show diffs for build files
     --editmenu            Give the option to edit/view PKGBUILDS
+    --upgrademenu         Show a detailed list of updates with the option to skip any
+    --nocleanmenu         Don't clean build PKGBUILDS
+    --nodiffmenu          Don't show diffs for build files
+    --noeditmenu          Don't edit/view PKGBUILDS
+    --noupgrademenu       Don't show the upgrade menu
     --askremovemake       Ask to remove makedepends after install
-    --askyesremovemake    Ask to remove makedepends after install("Y" as default)
     --removemake          Remove makedepends after install
     --noremovemake        Don't remove makedepends after install
 
     --cleanafter          Remove package sources after successful install
-    --keepsrc             Keep pkg/ and src/ after building packages
+    --nocleanafter        Do not remove package sources after successful build
     --bottomup            Shows AUR's packages first and then repository's
     --topdown             Shows repository's packages first and then AUR's
-    --singlelineresults   List each search result on its own line
-    --doublelineresults   List each search result on two lines, like pacman
 
     --devel               Check development packages during sysupgrade
+    --nodevel             Do not check development packages
     --rebuild             Always build target packages
     --rebuildall          Always build all AUR packages
     --norebuild           Skip package build if in cache and up to date
@@ -113,14 +101,23 @@ Permanent configuration options:
     --noredownload        Skip pkgbuild download if in cache and up to date
     --redownloadall       Always download pkgbuilds of all AUR packages
     --provides            Look for matching providers when searching for packages
+    --noprovides          Just look for packages by pkgname
     --pgpfetch            Prompt to import PGP keys from PKGBUILDs
+    --nopgpfetch          Don't prompt to import PGP keys
     --useask              Automatically resolve conflicts using pacman's ask flag
+    --nouseask            Confirm conflicts manually during the install
+    --combinedupgrade     Refresh then perform the repo and AUR upgrade together
+    --nocombinedupgrade   Perform the repo upgrade and AUR upgrade separately
+    --batchinstall        Build multiple AUR packages then install them together
+    --nobatchinstall      Build and install each AUR package one by one
 
     --sudo                <file>  sudo command to use
     --sudoflags           <flags> Pass arguments to sudo
     --sudoloop            Loop sudo calls in the background to avoid timeout
+    --nosudoloop          Do not loop sudo calls in the background
 
     --timeupdate          Check packages' AUR page for changes during sysupgrade
+    --notimeupdate        Do not check packages' AUR page for changes
 
 show specific options:
     -c --complete         Used for completions
@@ -130,309 +127,306 @@ show specific options:
     -w --news             Print arch news
 
 yay specific options:
-    -c --clean            Remove unneeded dependencies (-cc to ignore optdepends)
+    -c --clean            Remove unneeded dependencies
        --gendb            Generates development package DB used for updating
 
 getpkgbuild specific options:
-    -f --force            Force download for existing ABS packages
-    -p --print            Print pkgbuild of packages`)
+    -f --force            Force download for existing ABS packages`)
 }
 
-func handleCmd(ctx context.Context, run *runtime.Runtime,
-	cmdArgs *parser.Arguments, dbExecutor db.Executor,
-) error {
-	if cmdArgs.ExistsArg("h", "help") {
-		return handleHelp(ctx, run, cmdArgs)
+func handleCmd() (err error) {
+	if cmdArgs.existsArg("h", "help") {
+		err = handleHelp()
+		return
 	}
 
-	if run.Cfg.SudoLoop && cmdArgs.NeedRoot(run.Cfg.Mode) {
-		run.CmdBuilder.SudoLoop()
+	if config.SudoLoop && cmdArgs.needRoot() {
+		sudoLoopBackground()
 	}
 
-	switch cmdArgs.Op {
+	switch cmdArgs.op {
 	case "V", "version":
-		handleVersion(run.Logger)
-		return nil
+		handleVersion()
 	case "D", "database":
-		return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, run.Cfg.Mode, settings.NoConfirm))
+		err = show(passToPacman(cmdArgs))
 	case "F", "files":
-		return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, run.Cfg.Mode, settings.NoConfirm))
+		err = show(passToPacman(cmdArgs))
 	case "Q", "query":
-		return handleQuery(ctx, run, cmdArgs, dbExecutor)
+		err = handleQuery()
 	case "R", "remove":
-		return handleRemove(ctx, run, cmdArgs, run.VCSStore)
+		err = handleRemove()
 	case "S", "sync":
-		return handleSync(ctx, run, cmdArgs, dbExecutor)
+		err = handleSync()
 	case "T", "deptest":
-		return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, run.Cfg.Mode, settings.NoConfirm))
+		err = show(passToPacman(cmdArgs))
 	case "U", "upgrade":
-		return handleUpgrade(ctx, run, cmdArgs)
-	case "B", "build":
-		return handleBuild(ctx, run, dbExecutor, cmdArgs)
+		err = show(passToPacman(cmdArgs))
 	case "G", "getpkgbuild":
-		return handleGetpkgbuild(ctx, run, cmdArgs, dbExecutor)
+		err = handleGetpkgbuild()
 	case "P", "show":
-		return handlePrint(ctx, run, cmdArgs, dbExecutor)
-	case "Y", "yay":
-		return handleYay(ctx, run, cmdArgs, run.CmdBuilder,
-			dbExecutor, run.QueryBuilder)
-	case "W", "web":
-		return handleWeb(ctx, run, cmdArgs)
+		err = handlePrint()
+	case "Y", "--yay":
+		err = handleYay()
+	default:
+		//this means we allowed an op but not implement it
+		//if this happens it an error in the code and not the usage
+		err = fmt.Errorf("unhandled operation")
 	}
 
-	return errors.New(gotext.Get("unhandled operation"))
+	return
 }
 
-// getFilter returns filter function which can keep packages which were only
-// explicitly installed or ones installed as dependencies for showing available
-// updates or their count.
-func getFilter(cmdArgs *parser.Arguments) (upgrade.Filter, error) {
-	deps, explicit := cmdArgs.ExistsArg("d", "deps"), cmdArgs.ExistsArg("e", "explicit")
+func handleQuery() error {
+	if cmdArgs.existsArg("u", "upgrades") {
+		return printUpdateList(cmdArgs)
+	}
+	return show(passToPacman(cmdArgs))
+}
 
+func handleHelp() error {
+	if cmdArgs.op == "Y" || cmdArgs.op == "yay" {
+		usage()
+		return nil
+	}
+	return show(passToPacman(cmdArgs))
+}
+
+func handleVersion() {
+	fmt.Printf("yay v%s - libalpm v%s\n", version, alpm.Version())
+}
+
+func handlePrint() (err error) {
 	switch {
-	case deps && explicit:
-		return nil, errors.New(gotext.Get("invalid option: '--deps' and '--explicit' may not be used together"))
-	case deps:
-		return func(pkg *upgrade.Upgrade) bool {
-			return pkg.Reason == alpm.PkgReasonDepend
-		}, nil
-	case explicit:
-		return func(pkg *upgrade.Upgrade) bool {
-			return pkg.Reason == alpm.PkgReasonExplicit
-		}, nil
+	case cmdArgs.existsArg("d", "defaultconfig"):
+		tmpConfig := defaultSettings()
+		tmpConfig.expandEnv()
+		fmt.Printf("%v", tmpConfig)
+	case cmdArgs.existsArg("g", "currentconfig"):
+		fmt.Printf("%v", config)
+	case cmdArgs.existsArg("n", "numberupgrades"):
+		err = printNumberOfUpdates()
+	case cmdArgs.existsArg("u", "upgrades"):
+		err = printUpdateList(cmdArgs)
+	case cmdArgs.existsArg("w", "news"):
+		err = printNewsFeed()
+	case cmdArgs.existsDouble("c", "complete"):
+		err = completion.Show(alpmHandle, config.AURURL, cacheHome, config.CompletionInterval, true)
+	case cmdArgs.existsArg("c", "complete"):
+		err = completion.Show(alpmHandle, config.AURURL, cacheHome, config.CompletionInterval, false)
+	case cmdArgs.existsArg("s", "stats"):
+		err = localStatistics()
+	default:
+		err = nil
 	}
-
-	return func(pkg *upgrade.Upgrade) bool {
-		return true
-	}, nil
+	return err
 }
 
-func handleQuery(ctx context.Context, run *runtime.Runtime, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
-	if cmdArgs.ExistsArg("u", "upgrades") {
-		filter, err := getFilter(cmdArgs)
-		if err != nil {
-			return err
+func handleYay() error {
+	//_, options, targets := cmdArgs.formatArgs()
+	if cmdArgs.existsArg("gendb") {
+		return createDevelDB()
+	}
+	if cmdArgs.existsDouble("c") {
+		return cleanDependencies(true)
+	}
+	if cmdArgs.existsArg("c", "clean") {
+		return cleanDependencies(false)
+	}
+	if len(cmdArgs.targets) > 0 {
+		return handleYogurt()
+	}
+	return nil
+}
+
+func handleGetpkgbuild() error {
+	return getPkgbuilds(cmdArgs.targets)
+}
+
+func handleYogurt() error {
+	config.SearchMode = numberMenu
+	return displayNumberMenu(cmdArgs.targets)
+}
+
+func handleSync() error {
+	targets := cmdArgs.targets
+
+	if cmdArgs.existsArg("s", "search") {
+		if cmdArgs.existsArg("q", "quiet") {
+			config.SearchMode = minimal
+		} else {
+			config.SearchMode = detailed
 		}
-
-		return printUpdateList(ctx, run, cmdArgs, dbExecutor,
-			cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
+		return syncSearch(targets)
 	}
-
-	if err := run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, run.Cfg.Mode, settings.NoConfirm)); err != nil {
-		if str := err.Error(); strings.Contains(str, "exit status") {
-			// yay -Qdt should not output anything in case of error
-			return fmt.Errorf("")
-		}
-
-		return err
+	if cmdArgs.existsArg("p", "print", "print-format") {
+		return show(passToPacman(cmdArgs))
+	}
+	if cmdArgs.existsArg("c", "clean") {
+		return syncClean(cmdArgs)
+	}
+	if cmdArgs.existsArg("l", "list") {
+		return syncList(cmdArgs)
+	}
+	if cmdArgs.existsArg("g", "groups") {
+		return show(passToPacman(cmdArgs))
+	}
+	if cmdArgs.existsArg("i", "info") {
+		return syncInfo(targets)
+	}
+	if cmdArgs.existsArg("u", "sysupgrade") {
+		return install(cmdArgs)
+	}
+	if len(cmdArgs.targets) > 0 {
+		return install(cmdArgs)
+	}
+	if cmdArgs.existsArg("y", "refresh") {
+		return show(passToPacman(cmdArgs))
 	}
-
 	return nil
 }
 
-func handleHelp(ctx context.Context, run *runtime.Runtime, cmdArgs *parser.Arguments) error {
-	usage(run.Logger)
-	switch cmdArgs.Op {
-	case "Y", "yay", "G", "getpkgbuild", "P", "show", "W", "web", "B", "build":
-		return nil
-	}
-
-	run.Logger.Println("\npacman operation specific options:")
-	return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, run.Cfg.Mode, settings.NoConfirm))
-}
-
-func handleVersion(logger *text.Logger) {
-	logger.Printf("yay v%s - libalpm v%s\n", yayVersion, alpm.Version())
-}
-
-func handlePrint(ctx context.Context, run *runtime.Runtime, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
-	switch {
-	case cmdArgs.ExistsArg("d", "defaultconfig"):
-		tmpConfig := settings.DefaultConfig(yayVersion)
-		run.Logger.Printf("%v", tmpConfig)
-
-		return nil
-	case cmdArgs.ExistsArg("g", "currentconfig"):
-		run.Logger.Printf("%v", run.Cfg)
-
-		return nil
-	case cmdArgs.ExistsArg("w", "news"):
-		double := cmdArgs.ExistsDouble("w", "news")
-		quiet := cmdArgs.ExistsArg("q", "quiet")
-
-		return news.PrintNewsFeed(ctx, run.HTTPClient, run.Logger,
-			dbExecutor.LastBuildTime(), run.Cfg.BottomUp, double, quiet)
-	case cmdArgs.ExistsArg("c", "complete"):
-		return completion.Show(ctx, run.HTTPClient, dbExecutor,
-			run.Cfg.AURURL, run.Cfg.CompletionPath, run.Cfg.CompletionInterval, cmdArgs.ExistsDouble("c", "complete"))
-	case cmdArgs.ExistsArg("s", "stats"):
-		return localStatistics(ctx, run, dbExecutor)
-	}
-
-	return nil
-}
-
-func handleYay(ctx context.Context, run *runtime.Runtime,
-	cmdArgs *parser.Arguments, cmdBuilder exe.ICmdBuilder,
-	dbExecutor db.Executor, queryBuilder query.Builder,
-) error {
-	switch {
-	case cmdArgs.ExistsArg("gendb"):
-		return createDevelDB(ctx, run, dbExecutor)
-	case cmdArgs.ExistsDouble("c"):
-		return cleanDependencies(ctx, run.Cfg, cmdBuilder, cmdArgs, dbExecutor, true)
-	case cmdArgs.ExistsArg("c", "clean"):
-		return cleanDependencies(ctx, run.Cfg, cmdBuilder, cmdArgs, dbExecutor, false)
-	case len(cmdArgs.Targets) > 0:
-		return displayNumberMenu(ctx, run, cmdArgs.Targets, dbExecutor, queryBuilder, cmdArgs)
-	}
-
-	return nil
-}
-
-func handleWeb(ctx context.Context, run *runtime.Runtime, cmdArgs *parser.Arguments) error {
-	switch {
-	case cmdArgs.ExistsArg("v", "vote"):
-		return handlePackageVote(ctx, cmdArgs.Targets, run.AURClient, run.Logger,
-			run.VoteClient, true)
-	case cmdArgs.ExistsArg("u", "unvote"):
-		return handlePackageVote(ctx, cmdArgs.Targets, run.AURClient, run.Logger,
-			run.VoteClient, false)
-	}
-
-	return nil
-}
-
-func handleGetpkgbuild(ctx context.Context, run *runtime.Runtime, cmdArgs *parser.Arguments, dbExecutor download.DBSearcher) error {
-	if cmdArgs.ExistsArg("p", "print") {
-		return printPkgbuilds(dbExecutor, run.AURClient,
-			run.HTTPClient, run.Logger, cmdArgs.Targets, run.Cfg.Mode, run.Cfg.AURURL)
-	}
-
-	return getPkgbuilds(ctx, dbExecutor, run.AURClient, run,
-		cmdArgs.Targets, cmdArgs.ExistsArg("f", "force"))
-}
-
-func handleUpgrade(ctx context.Context,
-	run *runtime.Runtime, cmdArgs *parser.Arguments,
-) error {
-	return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, run.Cfg.Mode, settings.NoConfirm))
-}
-
-// -B* options
-func handleBuild(ctx context.Context,
-	run *runtime.Runtime, dbExecutor db.Executor, cmdArgs *parser.Arguments,
-) error {
-	if cmdArgs.ExistsArg("i", "install") {
-		return installLocalPKGBUILD(ctx, run, cmdArgs, dbExecutor)
-	}
-
-	return nil
-}
-
-func handleSync(ctx context.Context, run *runtime.Runtime, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
-	targets := cmdArgs.Targets
-
-	switch {
-	case cmdArgs.ExistsArg("s", "search"):
-		return syncSearch(ctx, targets, dbExecutor, run.QueryBuilder, !cmdArgs.ExistsArg("q", "quiet"))
-	case cmdArgs.ExistsArg("p", "print", "print-format"):
-		return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, run.Cfg.Mode, settings.NoConfirm))
-	case cmdArgs.ExistsArg("c", "clean"):
-		return syncClean(ctx, run, cmdArgs, dbExecutor)
-	case cmdArgs.ExistsArg("l", "list"):
-		return syncList(ctx, run, run.HTTPClient, cmdArgs, dbExecutor)
-	case cmdArgs.ExistsArg("g", "groups"):
-		return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, run.Cfg.Mode, settings.NoConfirm))
-	case cmdArgs.ExistsArg("i", "info"):
-		return syncInfo(ctx, run, cmdArgs, targets, dbExecutor)
-	case cmdArgs.ExistsArg("u", "sysupgrade") || len(cmdArgs.Targets) > 0:
-		return syncInstall(ctx, run, cmdArgs, dbExecutor)
-	case cmdArgs.ExistsArg("y", "refresh"):
-		return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, run.Cfg.Mode, settings.NoConfirm))
-	}
-
-	return nil
-}
-
-func handleRemove(ctx context.Context, run *runtime.Runtime, cmdArgs *parser.Arguments, localCache vcs.Store) error {
-	err := run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-		cmdArgs, run.Cfg.Mode, settings.NoConfirm))
+func handleRemove() error {
+	err := show(passToPacman(cmdArgs))
 	if err == nil {
-		localCache.RemovePackages(cmdArgs.Targets)
+		removeVCSPackage(cmdArgs.targets)
 	}
 
 	return err
 }
 
 // NumberMenu presents a CLI for selecting packages to install.
-func displayNumberMenu(ctx context.Context, run *runtime.Runtime, pkgS []string, dbExecutor db.Executor,
-	queryBuilder query.Builder, cmdArgs *parser.Arguments,
-) error {
-	queryBuilder.Execute(ctx, dbExecutor, pkgS)
+func displayNumberMenu(pkgS []string) (err error) {
+	var (
+		aurErr, repoErr error
+		aq              aurQuery
+		pq              repoQuery
+		lenaq, lenpq    int
+	)
 
-	if err := queryBuilder.Results(dbExecutor, query.NumberMenu); err != nil {
-		return err
+	pkgS = removeInvalidTargets(pkgS)
+
+	if mode == modeAUR || mode == modeAny {
+		aq, aurErr = narrowSearch(pkgS, true)
+		lenaq = len(aq)
+	}
+	if mode == modeRepo || mode == modeAny {
+		pq, repoErr = queryRepo(pkgS)
+		lenpq = len(pq)
+		if repoErr != nil {
+			return err
+		}
 	}
 
-	if queryBuilder.Len() == 0 {
-		// no results were found
-		return nil
+	if lenpq == 0 && lenaq == 0 {
+		return fmt.Errorf("No packages match search")
 	}
 
-	run.Logger.Infoln(gotext.Get("Packages to install (eg: 1 2 3, 1-3 or ^4)"))
+	switch config.SortMode {
+	case topDown:
+		if mode == modeRepo || mode == modeAny {
+			pq.printSearch()
+		}
+		if mode == modeAUR || mode == modeAny {
+			aq.printSearch(lenpq + 1)
+		}
+	case bottomUp:
+		if mode == modeAUR || mode == modeAny {
+			aq.printSearch(lenpq + 1)
+		}
+		if mode == modeRepo || mode == modeAny {
+			pq.printSearch()
+		}
+	default:
+		return fmt.Errorf("Invalid Sort Mode. Fix with yay -Y --bottomup --save")
+	}
 
-	numberBuf, err := run.Logger.GetInput("", false)
+	if aurErr != nil {
+		fmt.Fprintf(os.Stderr, "Error during AUR search: %s\n", aurErr)
+		fmt.Fprintln(os.Stderr, "Showing repo packages only")
+	}
+
+	fmt.Println(bold(green(arrow + " Packages to install (eg: 1 2 3, 1-3 or ^4)")))
+	fmt.Print(bold(green(arrow + " ")))
+
+	reader := bufio.NewReader(os.Stdin)
+
+	numberBuf, overflow, err := reader.ReadLine()
 	if err != nil {
 		return err
 	}
-
-	include, exclude, _, otherExclude := intrange.ParseNumberMenu(numberBuf)
-
-	targets, err := queryBuilder.GetTargets(include, exclude, otherExclude)
-	if err != nil {
-		return err
+	if overflow {
+		return fmt.Errorf("Input too long")
 	}
 
-	// modify the arguments to pass for the install
-	cmdArgs.Targets = targets
+	include, exclude, _, otherExclude := intrange.ParseNumberMenu(string(numberBuf))
+	arguments := cmdArgs.copyGlobal()
 
-	if len(cmdArgs.Targets) == 0 {
-		run.Logger.Println(gotext.Get(" there is nothing to do"))
+	isInclude := len(exclude) == 0 && len(otherExclude) == 0
+
+	for i, pkg := range pq {
+		var target int
+		switch config.SortMode {
+		case topDown:
+			target = i + 1
+		case bottomUp:
+			target = len(pq) - i
+		default:
+			return fmt.Errorf("Invalid Sort Mode. Fix with yay -Y --bottomup --save")
+		}
+
+		if (isInclude && include.Get(target)) || (!isInclude && !exclude.Get(target)) {
+			arguments.addTarget(pkg.DB().Name() + "/" + pkg.Name())
+		}
+	}
+
+	for i, pkg := range aq {
+		var target int
+
+		switch config.SortMode {
+		case topDown:
+			target = i + 1 + len(pq)
+		case bottomUp:
+			target = len(aq) - i + len(pq)
+		default:
+			return fmt.Errorf("Invalid Sort Mode. Fix with yay -Y --bottomup --save")
+		}
+
+		if (isInclude && include.Get(target)) || (!isInclude && !exclude.Get(target)) {
+			arguments.addTarget("aur/" + pkg.Name)
+		}
+	}
+
+	if len(arguments.targets) == 0 {
+		fmt.Println("There is nothing to do")
 		return nil
 	}
 
-	return syncInstall(ctx, run, cmdArgs, dbExecutor)
+	if config.SudoLoop {
+		sudoLoopBackground()
+	}
+
+	err = install(arguments)
+
+	return err
 }
 
-func syncList(ctx context.Context, run *runtime.Runtime,
-	httpClient *http.Client, cmdArgs *parser.Arguments, dbExecutor db.Executor,
-) error {
+func syncList(parser *arguments) error {
 	aur := false
 
-	for i := len(cmdArgs.Targets) - 1; i >= 0; i-- {
-		if cmdArgs.Targets[i] == "aur" && run.Cfg.Mode.AtLeastAUR() {
-			cmdArgs.Targets = append(cmdArgs.Targets[:i], cmdArgs.Targets[i+1:]...)
+	for i := len(parser.targets) - 1; i >= 0; i-- {
+		if parser.targets[i] == "aur" && (mode == modeAny || mode == modeAUR) {
+			parser.targets = append(parser.targets[:i], parser.targets[i+1:]...)
 			aur = true
 		}
 	}
 
-	if run.Cfg.Mode.AtLeastAUR() && (len(cmdArgs.Targets) == 0 || aur) {
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, run.Cfg.AURURL+"/packages.gz", http.NoBody)
+	if (mode == modeAny || mode == modeAUR) && (len(parser.targets) == 0 || aur) {
+		localDB, err := alpmHandle.LocalDB()
 		if err != nil {
 			return err
 		}
 
-		resp, err := httpClient.Do(req)
+		resp, err := http.Get(config.AURURL + "/packages.gz")
 		if err != nil {
 			return err
 		}
@@ -441,26 +435,24 @@ func syncList(ctx context.Context, run *runtime.Runtime,
 		scanner := bufio.NewScanner(resp.Body)
 
 		scanner.Scan()
-
 		for scanner.Scan() {
 			name := scanner.Text()
-			if cmdArgs.ExistsArg("q", "quiet") {
-				run.Logger.Println(name)
+			if cmdArgs.existsArg("q", "quiet") {
+				fmt.Println(name)
 			} else {
-				run.Logger.Printf("%s %s %s", text.Magenta("aur"), text.Bold(name), text.Bold(text.Green(gotext.Get("unknown-version"))))
+				fmt.Printf("%s %s %s", magenta("aur"), bold(name), bold(green("unknown-version")))
 
-				if dbExecutor.LocalPackage(name) != nil {
-					run.Logger.Print(text.Bold(text.Blue(gotext.Get(" [Installed]"))))
+				if localDB.Pkg(name) != nil {
+					fmt.Print(bold(blue(" [Installed]")))
 				}
 
-				run.Logger.Println()
+				fmt.Println()
 			}
 		}
 	}
 
-	if run.Cfg.Mode.AtLeastRepo() && (len(cmdArgs.Targets) != 0 || !aur) {
-		return run.CmdBuilder.Show(run.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, run.Cfg.Mode, settings.NoConfirm))
+	if (mode == modeAny || mode == modeRepo) && (len(parser.targets) != 0 || !aur) {
+		return show(passToPacman(parser))
 	}
 
 	return nil

cmd_test.go

@@ -1,140 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"strings"
-	"testing"
-
-	"github.com/Jguer/aur"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/Jguer/yay/v12/pkg/db/mock"
-	mockaur "github.com/Jguer/yay/v12/pkg/dep/mock"
-	"github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/text"
-	"github.com/Jguer/yay/v12/pkg/vcs"
-)
-
-func TestYogurtMenuAURDB(t *testing.T) {
-	t.Skip("skip until Operation service is an interface")
-	t.Parallel()
-	makepkgBin := t.TempDir() + "/makepkg"
-	pacmanBin := t.TempDir() + "/pacman"
-	gitBin := t.TempDir() + "/git"
-	f, err := os.OpenFile(makepkgBin, os.O_RDONLY|os.O_CREATE, 0o755)
-	require.NoError(t, err)
-	require.NoError(t, f.Close())
-
-	f, err = os.OpenFile(pacmanBin, os.O_RDONLY|os.O_CREATE, 0o755)
-	require.NoError(t, err)
-	require.NoError(t, f.Close())
-
-	f, err = os.OpenFile(gitBin, os.O_RDONLY|os.O_CREATE, 0o755)
-	require.NoError(t, err)
-	require.NoError(t, f.Close())
-
-	captureOverride := func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
-		return "", "", nil
-	}
-
-	showOverride := func(cmd *exec.Cmd) error {
-		return nil
-	}
-
-	mockRunner := &exe.MockRunner{CaptureFn: captureOverride, ShowFn: showOverride}
-	cmdBuilder := &exe.CmdBuilder{
-		MakepkgBin:       makepkgBin,
-		SudoBin:          "su",
-		PacmanBin:        pacmanBin,
-		PacmanConfigPath: "/etc/pacman.conf",
-		GitBin:           "git",
-		Runner:           mockRunner,
-		SudoLoopEnabled:  false,
-	}
-
-	cmdArgs := parser.MakeArguments()
-	cmdArgs.AddArg("Y")
-	cmdArgs.AddTarget("yay")
-
-	db := &mock.DBExecutor{
-		AlpmArchitecturesFn: func() ([]string, error) {
-			return []string{"x86_64"}, nil
-		},
-		RefreshHandleFn: func() error {
-			return nil
-		},
-		ReposFn: func() []string {
-			return []string{"aur"}
-		},
-		SyncPackagesFn: func(s ...string) []mock.IPackage {
-			return []mock.IPackage{
-				&mock.Package{
-					PName:    "yay",
-					PBase:    "yay",
-					PVersion: "10.0.0",
-					PDB:      mock.NewDB("aur"),
-				},
-			}
-		},
-		LocalPackageFn: func(s string) mock.IPackage {
-			return nil
-		},
-	}
-	aurCache := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{
-				{
-					Name:        "yay",
-					PackageBase: "yay",
-					Version:     "10.0.0",
-				},
-			}, nil
-		},
-	}
-	logger := text.NewLogger(io.Discard, os.Stderr, strings.NewReader("1\n"), true, "test")
-
-	run := &runtime.Runtime{
-		Cfg: &settings.Configuration{
-			RemoveMake: "no",
-		},
-		Logger:     logger,
-		CmdBuilder: cmdBuilder,
-		VCSStore:   &vcs.Mock{},
-		QueryBuilder: query.NewSourceQueryBuilder(aurCache, logger, "votes", parser.ModeAny, "name",
-			true, false, true),
-		AURClient: aurCache,
-	}
-	err = handleCmd(context.Background(), run, cmdArgs, db)
-	require.NoError(t, err)
-
-	wantCapture := []string{}
-	wantShow := []string{
-		"pacman -S -y --config /etc/pacman.conf --",
-		"pacman -S -y -u --config /etc/pacman.conf --",
-	}
-
-	require.Len(t, mockRunner.ShowCalls, len(wantShow))
-	require.Len(t, mockRunner.CaptureCalls, len(wantCapture))
-
-	for i, call := range mockRunner.ShowCalls {
-		show := call.Args[0].(*exec.Cmd).String()
-		show = strings.ReplaceAll(show, makepkgBin, "makepkg")
-		show = strings.ReplaceAll(show, pacmanBin, "pacman")
-		show = strings.ReplaceAll(show, gitBin, "pacman")
-
-		// options are in a different order on different systems and on CI root user is used
-		assert.Subset(t, strings.Split(show, " "), strings.Split(wantShow[i], " "), fmt.Sprintf("%d - %s", i, show))
-	}
-}

completions/bash

@@ -51,7 +51,7 @@ _pacman_repo_list() {
 _yay() {
   compopt -o default
   local common core cur database files prev query remove sync upgrade o
-  local yays show getpkgbuild web
+  local yays show getpkgbuild
   local cur prev words cword
 
   _init_completion || return
@@ -61,29 +61,28 @@ _yay() {
           search unrequired upgrades' 'c e g i k l m n o p s t u')
   remove=('cascade dbonly nodeps assume-installed nosave print recursive unneeded' 'c n p s u')
   sync=('asdeps asexplicit clean dbonly downloadonly overwrite groups ignore ignoregroup
-         info list needed nodeps assume-installed print refresh recursive search sysupgrade aur repo'
-    'c g i l p s u w y a N')
+         info list needed nodeps assume-installed print refresh recursive search sysupgrade'
+    'c g i l p s u w y')
   upgrade=('asdeps asexplicit overwrite needed nodeps assume-installed print recursive' 'p')
   core=('database files help query remove sync upgrade version' 'D F Q R S U V h')
 
   ##yay stuff
   common=('arch cachedir color config confirm dbpath debug gpgdir help hookdir logfile
           noconfirm noprogressbar noscriptlet quiet root verbose
-          makepkg pacman git gpg gpgflags config requestsplitn sudoloop
-          redownload noredownload redownloadall rebuild rebuildall rebuildtree norebuild sortby
-          singlelineresults doublelineresults answerclean answerdiff answeredit answerupgrade noanswerclean noanswerdiff
-          noansweredit noanswerupgrade cleanmenu diffmenu editmenu cleanafter keepsrc
-          provides pgpfetch
-          useask combinedupgrade aur repo makepkgconf
-          nomakepkgconf askremovemake askyesremovemake removemake noremovemake completioninterval aururl aurrpcurl
-          searchby batchinstall'
+          makepkg pacman git gpg gpgflags config requestsplitn sudoloop nosudoloop
+          redownload noredownload redownloadall rebuild rebuildall rebuildtree norebuild
+          sortby answerclean answerdiff answeredit answerupgrade noanswerclean noanswerdiff
+          noansweredit noanswerupgrade cleanmenu diffmenu editmenu upgrademenu cleanafter nocleanafter
+          nocleanmenu nodiffmenu noupgrademenu provides noprovides pgpfetch nopgpfetch
+          useask nouseask combinedupgrade nocombinedupgrade aur repo makepkgconf
+          nomakepkgconf askremovemake removemake noremovemake completioninterval aururl
+          searchby batchinstall nobatchinstall'
     'b d h q r v')
   yays=('clean gendb' 'c')
-  show=('complete defaultconfig currentconfig stats news' 'c d g s w')
-  getpkgbuild=('force print' 'f p')
-  web=('vote unvote' 'v u')
+  show=('complete defaultconfig currentconfig stats  news' 'c d g s w')
+  getpkgbuild=('force' 'f')
 
-  for o in 'D database' 'F files' 'Q query' 'R remove' 'S sync' 'U upgrade' 'Y yays' 'P show' 'G getpkgbuild' 'W web'; do
+  for o in 'D database' 'F files' 'Q query' 'R remove' 'S sync' 'U upgrade' 'Y yays' 'P show' 'G getpkgbuild'; do
     _arch_incomp "$o" && break
   done
 
@@ -120,9 +119,6 @@ _yay() {
       G)
         _yay_pkg
         ;;
-      W)
-        _yay_pkg
-        ;;
       esac
   fi
   true
@@ -130,7 +126,7 @@ _yay() {
 
 _pacman_file() {
   compopt -o filenames
-  _filedir 'pkg.*'
+  _filedir 'pkg.tar*'
 }
 
 complete -F _yay yay

completions/fish

@@ -5,10 +5,10 @@
 set -l progname yay
 
 # Yay constants
+set -l noopt 'not __fish_contains_opt -s Y -s G -s V -s P -s S -s D -s Q -s R -s U -s T -s F database query sync remove upgrade deptest files version'
 set -l listall "(yay -Pc)"
 set -l listpacman "(__fish_print_packages)"
 set -l yayspecific '__fish_contains_opt -s Y yay'
-set -l webspecific '__fish_contains_opt -s W web'
 set -l show '__fish_contains_opt -s P show'
 set -l getpkgbuild '__fish_contains_opt -s G getpkgbuild'
 
@@ -16,8 +16,6 @@ set -l getpkgbuild '__fish_contains_opt -s G getpkgbuild'
 set -l listinstalled "(pacman -Q | string replace ' ' \t)"
 set -l listrepos "(__fish_print_pacman_repos)"
 set -l listgroups "(pacman -Sg)\t'Package Group'"
-
-set -l noopt 'not __fish_contains_opt -s S -s D -s Q -s R -s U -s T -s F -s Y -s W -s P -s G database query sync remove upgrade deptest files show getpkgbuild web yay'
 set -l database '__fish_contains_opt -s D database'
 set -l query '__fish_contains_opt -s Q query'
 set -l remove '__fish_contains_opt -s R remove'
@@ -25,8 +23,6 @@ set -l sync '__fish_contains_opt -s S sync'
 set -l upgrade '__fish_contains_opt -s U upgrade'
 set -l files '__fish_contains_opt -s F files'
 
-
-
 complete -c $progname -e
 complete -c $progname -f
 # HACK: We only need these two to coerce fish to stop file completion and complete options
@@ -39,9 +35,9 @@ complete -c $progname -s Q -f -l query -n "$noopt" -d 'Query the package databas
 complete -c $progname -s R -f -l remove -n "$noopt" -d 'Remove packages from the system'
 complete -c $progname -s S -f -l sync -n "$noopt" -d 'Synchronize packages'
 complete -c $progname -s T -f -l deptest -n "$noopt" -d 'Check dependencies'
-complete -c $progname -s U -l upgrade -n "$noopt" -d 'Upgrade or add a local package'
+complete -c $progname -s U -f -l upgrade -n "$noopt" -d 'Upgrade or add a local package'
 complete -c $progname -s F -f -l files -n "$noopt" -d 'Query the files database'
-complete -c $progname -s V -f -l version -d 'Display version and exit'
+complete -c $progname -s V -f -l version -n "$noopt" -d 'Display version and exit'
 complete -c $progname -s h -f -l help -d 'Display help'
 
 # General options
@@ -52,7 +48,7 @@ complete -c $progname -n "not $noopt" -s v -l verbose -d 'Output more status mes
 complete -c $progname -n "not $noopt" -l arch -d 'Alternate architecture' -f
 complete -c $progname -n "not $noopt" -l cachedir -d 'Alternate package cache location' -xa "(__fish_complete_directories)"
 complete -c $progname -n "not $noopt" -l color -d 'Colorize the output' -fa '{auto,always,never}'
-complete -c $progname -n "not $noopt" -l config -d 'Alternate config file' -rF
+complete -c $progname -n "not $noopt" -l config -d 'Alternate config file' -r
 complete -c $progname -n "not $noopt" -l confirm -d 'Always ask for confirmation' -f
 complete -c $progname -n "not $noopt" -l debug -d 'Display debug messages' -f
 complete -c $progname -n "not $noopt" -l disable-download-timeout -d 'Use relaxed timeouts for download' -f
@@ -100,7 +96,7 @@ for condition in sync upgrade
     complete -c $progname -n "$$condition" -l ignore -d 'Ignore a package upgrade (can be used more than once)' -xa "$listall"
     complete -c $progname -n "$$condition" -l ignoregroup -d 'Ignore a group upgrade (can be used more than once)' -xa "$listgroups"
     complete -c $progname -n "$$condition" -l needed -d 'Do not reinstall up to date packages' -f
-    complete -c $progname -n "$$condition" -l overwrite -d 'Overwrite conflicting files (can be used more than once)' -rF
+    complete -c $progname -n "$$condition" -l overwrite -d 'Overwrite conflicting files (can be used more than once)' -r
 end
 
 # Database options
@@ -114,7 +110,7 @@ complete -c $progname -n "$has_db_opt; and $database" -xa "$listinstalled"
 # File options - since pacman 5
 complete -c $progname -n "$files" -s x -l regex -d 'Interpret each query as a regular expression' -f
 complete -c $progname -n "$files" -l machinereadable -d 'Print each match in a machine readable output format' -f
-complete -c $progname -n "$files" -d Package -xa "$listpacman"
+complete -c $progname -n "$files" -d 'Package' -xa "$listpacman"
 
 # Query options
 complete -c $progname -n "$query" -s c -l changelog -d 'View the change log of PACKAGE' -f
@@ -124,8 +120,8 @@ complete -c $progname -n "$query" -s i -l info -d 'View PACKAGE [backup files] i
 complete -c $progname -n "$query" -s k -l check -d 'Check that PACKAGE files exist' -f
 complete -c $progname -n "$query" -s m -l foreign -d 'List installed packages not found in sync database' -f
 complete -c $progname -n "$query" -s n -l native -d 'list installed packages only found in sync database' -f
-complete -c $progname -n "$query" -s o -l owns -d 'Query the package that owns FILE' -rF
-complete -c $progname -n "$query" -s p -l file -d 'Query a package file instead of the database' -rF
+complete -c $progname -n "$query" -s o -l owns -d 'Query the package that owns FILE' -r
+complete -c $progname -n "$query" -s p -l file -d 'Query a package file instead of the database' -r
 complete -c $progname -n "$query" -s s -l search -d 'Search locally-installed packages for regexp' -f
 complete -c $progname -n "$query" -s t -l unrequired -d 'List only unrequired packages [and optdepends]' -f
 complete -c $progname -n "$query" -s u -l upgrades -d 'List only out-of-date packages' -f
@@ -149,24 +145,18 @@ complete -c $progname -n "$sync" -xa "$listall $listgroups"
 
 # Upgrade options
 # Theoretically, pacman reads packages in all formats that libarchive supports
-# In practice, it's going to be tar.xz, tar.gz, tar.zst, or just pkg.tar (uncompressed pkg)
-complete -c $progname -n "$upgrade" -xa '(__fish_complete_suffix pkg.tar.zst; __fish_complete_suffix pkg.tar.xz; __fish_complete_suffix pkg.tar.gz; __fish_complete_suffix pkg.tar;)' -d 'Package file'
+# In practice, it's going to be tar.xz, tar.gz or tar.zst
+complete -c $progname -n "$upgrade" -xa '(__fish_complete_suffix pkg.tar.zst; __fish_complete_suffix pkg.tar.xz; __fish_complete_suffix pkg.tar.gz)' -d 'Package file'
 
 
 # Yay operations
 complete -c $progname -s Y -f -l yay -n "$noopt" -d 'Yay specific operations'
 complete -c $progname -s P -f -l show -n "$noopt" -d 'Print information'
 complete -c $progname -s G -f -l getpkgbuild -n "$noopt" -d 'Get PKGBUILD from ABS or AUR'
-complete -c $progname -s W -f -l web -n "$noopt" -d 'Web operations'
-
-# Web options
-complete -c $progname -n "$webspecific" -s v -l vote -d 'Vote for AUR packages' -f
-complete -c $progname -n "$webspecific" -s u -l unvote -d 'Unvote for AUR packages' -f
-complete -c $progname -n "$webspecific" -xa "$listall"
 
 # New options
-complete -c $progname -n "not $noopt" -s a -l aur -d 'Assume targets are from the AUR' -f
-complete -c $progname -n "not $noopt" -s N -l repo -d 'Assume targets are from the repositories' -f
+complete -c $progname -n "not $noopt" -l repo -d 'Assume targets are from the AUR' -f
+complete -c $progname -n "not $noopt" -s a -l aur -d 'Assume targets are from the repositories' -f
 
 # Yay options
 complete -c $progname -n "$yayspecific" -s c -l clean -d 'Remove unneeded dependencies' -f
@@ -184,13 +174,12 @@ complete -c $progname -n "$show" -s q -l quiet -d 'Do not print news description
 # Getpkgbuild options
 complete -c $progname -n "$getpkgbuild" -s f -l force -d 'Force download for existing ABS packages' -f
 complete -c $progname -n "$getpkgbuild" -xa "$listall"
-complete -c $progname -n "$getpkgbuild" -s p -l print -d 'Print pkgbuild of packages' -f
 
-# Permanent configuration settings
+# Premenent configuration settings
 complete -c $progname -n "not $noopt" -l save -d 'Save current arguments to yay permanent configuration' -f
 complete -c $progname -n "not $noopt" -l aururl -d 'Set an alternative AUR URL' -f
-complete -c $progname -n "not $noopt" -l aurrpcurl -d 'Set an alternative URL for the AUR /rpc endpoint' -f
 complete -c $progname -n "not $noopt" -l builddir -d 'Directory to use for Building AUR Packages' -r
+complete -c $progname -n "not $noopt" -l absdir -d 'Directory used to store downloads from the ABS' -r
 complete -c $progname -n "not $noopt" -l editor -d 'Editor to use' -f
 complete -c $progname -n "not $noopt" -l editorflags -d 'Editor flags to use' -f
 complete -c $progname -n "not $noopt" -l makepkg -d 'Makepkg command to use' -f
@@ -216,26 +205,35 @@ complete -c $progname -n "not $noopt" -l noanswerupgrade -d 'Unset the answer fo
 complete -c $progname -n "not $noopt" -l cleanmenu -d 'Give the option to clean build PKGBUILDS' -f
 complete -c $progname -n "not $noopt" -l diffmenu -d 'Give the option to show diffs for build files' -f
 complete -c $progname -n "not $noopt" -l editmenu -d 'Give the option to edit/view PKGBUILDS' -f
+complete -c $progname -n "not $noopt" -l upgrademenu -d 'Show a detailed list of updates with the option to skip any' -f
+complete -c $progname -n "not $noopt" -l nocleanmenu -d 'Do not clean build PKGBUILDS' -f
+complete -c $progname -n "not $noopt" -l nodiffmenu -d 'Do not show diffs for build files' -f
+complete -c $progname -n "not $noopt" -l noeditmenu -d 'Do not edit/view PKGBUILDS' -f
+complete -c $progname -n "not $noopt" -l noupgrademenu -d 'Do not show the upgrade menu' -f
 complete -c $progname -n "not $noopt" -l askremovemake -d 'Ask to remove make deps after install' -f
-complete -c $progname -n "not $noopt" -l askyesremovemake -d 'Ask to remove make deps after install(with "Y" as default)' -f
 complete -c $progname -n "not $noopt" -l removemake -d 'Remove make deps after install' -f
 complete -c $progname -n "not $noopt" -l noremovemake -d 'Do not remove make deps after install' -f
 complete -c $progname -n "not $noopt" -l topdown -d 'Shows repository packages first and then aur' -f
 complete -c $progname -n "not $noopt" -l bottomup -d 'Shows aur packages first and then repository' -f
-complete -c $progname -n "not $noopt" -l singlelineresults -d 'List each search result on its own line' -f
-complete -c $progname -n "not $noopt" -l doublelineresults -d 'List each search result on two lines, like pacman' -f
 complete -c $progname -n "not $noopt" -l devel -d 'Check -git/-svn/-hg development version' -f
+complete -c $progname -n "not $noopt" -l nodevel -d 'Disable development version checking' -f
 complete -c $progname -n "not $noopt" -l cleanafter -d 'Clean package sources after successful build' -f
-complete -c $progname -n "not $noopt" -l keepsrc -d 'Keep pkg/ and src/ after building packages' -f
+complete -c $progname -n "not $noopt" -l nocleanafter -d 'Disable package sources cleaning' -f
 complete -c $progname -n "not $noopt" -l timeupdate -d 'Check package modification date and version' -f
+complete -c $progname -n "not $noopt" -l notimeupdate -d 'Check only package version change' -f
 complete -c $progname -n "not $noopt" -l redownload -d 'Redownload PKGBUILD of package even if up-to-date' -f
 complete -c $progname -n "not $noopt" -l redownloadall -d 'Redownload PKGBUILD of package and deps even if up-to-date' -f
 complete -c $progname -n "not $noopt" -l noredownload -d 'Do not redownload up-to-date PKGBUILDs' -f
 complete -c $progname -n "not $noopt" -l provides -d 'Look for matching providers when searching for packages' -f
+complete -c $progname -n "not $noopt" -l noprovides -d 'Just look for packages by pkgname' -f
 complete -c $progname -n "not $noopt" -l pgpfetch -d 'Prompt to import PGP keys from PKGBUILDs' -f
+complete -c $progname -n "not $noopt" -l nopgpfetch -d 'Do not prompt to import PGP keys' -f
 complete -c $progname -n "not $noopt" -l useask -d 'Automatically resolve conflicts using pacmans ask flag' -f
+complete -c $progname -n "not $noopt" -l nouseask -d 'Confirm conflicts manually during the install' -f
 complete -c $progname -n "not $noopt" -l combinedupgrade -d 'Refresh then perform the repo and AUR upgrade together' -f
+complete -c $progname -n "not $noopt" -l nocombinedupgrade -d 'Perform the repo upgrade and AUR upgrade separately' -f
 complete -c $progname -n "not $noopt" -l batchinstall -d 'Build multiple AUR packages then install them together' -f
+complete -c $progname -n "not $noopt" -l nobatchinstall -d 'Build and install each AUR package one by one' -f
 complete -c $progname -n "not $noopt" -l rebuild -d 'Always build target packages' -f
 complete -c $progname -n "not $noopt" -l rebuildall -d 'Always build all AUR packages' -f
 complete -c $progname -n "not $noopt" -l rebuildtree -d 'Always build all AUR packages even if installed' -f
@@ -243,3 +241,4 @@ complete -c $progname -n "not $noopt" -l norebuild -d 'Skip package build if in
 complete -c $progname -n "not $noopt" -l mflags -d 'Pass the following options to makepkg' -f
 complete -c $progname -n "not $noopt" -l gpgflags -d 'Pass the following options to gpg' -f
 complete -c $progname -n "not $noopt" -l sudoloop -d 'Loop sudo calls in the background to avoid timeout' -f
+complete -c $progname -n "not $noopt" -l nosudoloop -d 'Do not loop sudo calls in the background' -f

completions/zsh

@@ -1,5 +1,5 @@
 #compdef yay
-# vim:tabstop=2 shiftwidth=2 filetype=zsh
+# vim:fdm=marker foldlevel=0 tabstop=2 shiftwidth=2 filetype=zsh
 
 typeset -A opt_args
 setopt extendedglob
@@ -16,17 +16,15 @@ _pacman_opts_commands=(
 	{-T,--deptest}'[Check if dependencies are installed]'
 	{-U,--upgrade}'[Upgrade a package]'
 	{-Y,--yay}'[Yay specific options]'
-	{-W,--web}'[web options]'
 	{-V,--version}'[Display version and exit]'
 	'(-h --help)'{-h,--help}'[Display usage]'
 )
 
 # options for passing to _arguments: options common to all commands
 _pacman_opts_common=(
-	{-N,--repo}'[Assume targets are from the repositories]'
+	'--repo[Assume targets are from the repositories]'
 	{-a,--aur}'[Assume targets are from the AUR]'
 	'--aururl[Set an alternative AUR URL]:url'
-	'--aurrpcurl[Set an alternative URL for the AUR /rpc endpoint]:url'
 	'--arch[Set an alternate architecture]'
 	{-b,--dbpath}'[Alternate database location]:database_location:_files -/'
 	'--color[colorize the output]:color options:(always never auto)'
@@ -38,7 +36,7 @@ _pacman_opts_common=(
 	'--makepkgconf[makepkg.conf file to use]:config file:_files'
 	'--nomakepkgconf[Use the default makepkg.conf]'
 	'--requestsplitn[Max amount of packages to query per AUR request]:number'
-	'--completioninterval[Time in days to refresh completion cache]:number'
+	'--completioninterval[Time in days to to refresh completion cache]:number'
 	'--confirm[Always ask for confirmation]'
 	'--debug[Display debug messages]'
 	'--gpgdir[Set an alternate directory for GnuPG (instead of /etc/pacman.d/gnupg)]: :_files -/'
@@ -70,36 +68,46 @@ _pacman_opts_common=(
 	'--cleanmenu[Give the option to clean build PKGBUILDS]'
 	'--diffmenu[Give the option to show diffs for build files]'
 	'--editmenu[Give the option to edit/view PKGBUILDS]'
+	'--upgrademenu[Show a detailed list of updates with the option to skip any]'
+	"--nocleanmenu[Don't clean build PKGBUILDS]"
+	"--nodiffmenu[Don't show diffs for build files]"
+	"--noeditmenu[Don't edit/view PKGBUILDS]"
+	"--noupgrademenu[Don't show the upgrade menu]"
 	"--askremovemake[Ask to remove makedepends after install]"
-	"--askyesremovemake[Ask to remove makedepends after install(with "Y" as default)]"
 	"--removemake[Remove makedepends after install]"
 	"--noremovemake[Don't remove makedepends after install]"
 
 	'--bottomup[Show AUR packages first]'
 	'--topdown[Show repository packages first]'
-	'--singlelineresults[List each search result on its own line]'
-	'--doublelineresults[List each search result on two lines, like pacman]'
 	'--devel[Check -git/-svn/-hg development version]'
+	'--nodevel[Disable development version checking]'
 	'--cleanafter[Clean package sources after successful build]'
-	'--keepsrc[Keep pkg/ and src/ after building packages]'
+	'--nocleanafter[Disable package sources cleaning after successful build]'
 	'--timeupdate[Check packages modification date and version]'
+	'--notimeupdate[Check only package version change]'
 	'--redownload[Always download pkgbuilds of targets]'
 	'--redownloadall[Always download pkgbuilds of all AUR packages]'
 	'--noredownload[Skip pkgbuild download if in cache and up to date]'
 	'--rebuild[Always build target packages]'
 	'--rebuildall[Always build all AUR packages]'
 	'--provides[Look for matching providers when searching for packages]'
+	'--noprovides[Just look for packages by pkgname]'
 	'--pgpfetch[Prompt to import PGP keys from PKGBUILDs]'
+	"--nopgpfetch[Don't prompt to import PGP keys]"
 	"--useask[Automatically resolve conflicts using pacman's ask flag]"
+	'--nouseask[Confirm conflicts manually during the install]'
 	'--combinedupgrade[Refresh then perform the repo and AUR upgrade together]'
+	'--nocombinedupgrade[Perform the repo upgrade and AUR upgrade separately]'
 	'--rebuildtree[Always build all AUR packages even if installed]'
 	'--norebuild[Skip package build if in cache and up to date]'
 	'--mflags[Pass arguments to makepkg]:mflags'
 	'--gpgflags[Pass arguments to gpg]:gpgflags'
 	'--sudoloop[Loop sudo calls in the background to avoid timeout]'
+	'--nosudoloop[Do not loop sudo calls in the background]'
 	'--searchby[Search for packages using a specified field]'
 	'--sortby[Sort AUR results by a specific field during search]'
 	'--batchinstall[Build multiple AUR packages then install them together]'
+	'--nobatchinstall[Build and install each AUR package one by one]'
 )
 
 # options for passing to _arguments: options for --upgrade commands
@@ -152,13 +160,6 @@ _pacman_opts_yay_modifiers=(
 # -G
 _pacman_opts_getpkgbuild_modifiers=(
 	{-f,--force}'[Force download for existing ABS packages]'
-	{-p,--print}'[Print PKGBUILDs]:package:_pacman_completions_all_packages'
-)
-
-# -W
-_pacman_opts_web_modifiers=(
-	{-u,--unvote}'[Unvote AUR package]:package:_pacman_completions_all_packages'
-	{-v,--vote}'[Vote AUR package]:package:_pacman_completions_all_packages'
 )
 
 # -P
@@ -500,19 +501,16 @@ _pacman_zsh_comp() {
 				"$_pacman_opts_query_modifiers[@]" \
 				'*:package file:_files -g "*.pkg.tar*~*.sig(.,@)"'
 			;;
+		T*)
+			_pacman_action_deptest
+			;;
 		Q*)
 			_pacman_action_query
 			;;
 		P*)
 			 _arguments -s : \
-				'-P' \
 				"$_pacman_opts_print_modifiers[@]"
 			;;
-		W*)
-			 _arguments -s : \
-				'-W' \
-				"$_pacman_opts_web_modifiers[@]"
-			;;
 		R*)
 			_pacman_action_remove
 			;;
@@ -543,7 +541,10 @@ _pacman_zsh_comp() {
 			_pacman_action_sync
 			;;
 		T*)
-			_pacman_action_deptest
+			 _arguments -s : \
+				'-T' \
+				"$_pacman_opts_common[@]" \
+				":packages:_pacman_all_packages"
 			;;
 		U*)
 			_pacman_action_upgrade
@@ -553,12 +554,10 @@ _pacman_zsh_comp() {
 			;;
 		Y*)
 			_arguments -s : \
-				'-Y' \
 				"$_pacman_opts_yay_modifiers[@]"
 			;;
 		G*)
 			_arguments -s : \
-				'-G' \
 				"$_pacman_opts_getpkgbuild_modifiers[@]"
 			;;
 

config.go

@@ -0,0 +1,441 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	alpm "github.com/Jguer/go-alpm"
+	pacmanconf "github.com/Morganamilo/go-pacmanconf"
+)
+
+// Verbosity settings for search
+const (
+	numberMenu = iota
+	detailed
+	minimal
+)
+
+const (
+	// Describes Sorting method for numberdisplay
+	bottomUp = iota
+	topDown
+)
+
+const (
+	modeAUR targetMode = iota
+	modeRepo
+	modeAny
+)
+
+type targetMode int
+
+// Configuration stores yay's config.
+type Configuration struct {
+	AURURL             string `json:"aururl"`
+	BuildDir           string `json:"buildDir"`
+	ABSDir             string `json:"absdir"`
+	Editor             string `json:"editor"`
+	EditorFlags        string `json:"editorflags"`
+	MakepkgBin         string `json:"makepkgbin"`
+	MakepkgConf        string `json:"makepkgconf"`
+	PacmanBin          string `json:"pacmanbin"`
+	PacmanConf         string `json:"pacmanconf"`
+	ReDownload         string `json:"redownload"`
+	ReBuild            string `json:"rebuild"`
+	BatchInstall       bool   `json:"batchinstall"`
+	AnswerClean        string `json:"answerclean"`
+	AnswerDiff         string `json:"answerdiff"`
+	AnswerEdit         string `json:"answeredit"`
+	AnswerUpgrade      string `json:"answerupgrade"`
+	GitBin             string `json:"gitbin"`
+	GpgBin             string `json:"gpgbin"`
+	GpgFlags           string `json:"gpgflags"`
+	MFlags             string `json:"mflags"`
+	SortBy             string `json:"sortby"`
+	SearchBy           string `json:"searchby"`
+	GitFlags           string `json:"gitflags"`
+	RemoveMake         string `json:"removemake"`
+	SudoBin            string `json:"sudobin"`
+	SudoFlags          string `json:"sudoflags"`
+	RequestSplitN      int    `json:"requestsplitn"`
+	SearchMode         int    `json:"-"`
+	SortMode           int    `json:"sortmode"`
+	CompletionInterval int    `json:"completionrefreshtime"`
+	SudoLoop           bool   `json:"sudoloop"`
+	TimeUpdate         bool   `json:"timeupdate"`
+	NoConfirm          bool   `json:"-"`
+	Devel              bool   `json:"devel"`
+	CleanAfter         bool   `json:"cleanAfter"`
+	Provides           bool   `json:"provides"`
+	PGPFetch           bool   `json:"pgpfetch"`
+	UpgradeMenu        bool   `json:"upgrademenu"`
+	CleanMenu          bool   `json:"cleanmenu"`
+	DiffMenu           bool   `json:"diffmenu"`
+	EditMenu           bool   `json:"editmenu"`
+	CombinedUpgrade    bool   `json:"combinedupgrade"`
+	UseAsk             bool   `json:"useask"`
+}
+
+var version = "9.4.3"
+
+// configFileName holds the name of the config file.
+const configFileName string = "config.json"
+
+// vcsFileName holds the name of the vcs file.
+const vcsFileName string = "vcs.json"
+
+// useColor enables/disables colored printing
+var useColor bool
+
+// configHome handles config directory home
+var configHome string
+
+// cacheHome handles cache home
+var cacheHome string
+
+// savedInfo holds the current vcs info
+var savedInfo vcsInfo
+
+// configfile holds yay config file path.
+var configFile string
+
+// vcsfile holds yay vcs info file path.
+var vcsFile string
+
+// shouldSaveConfig holds whether or not the config should be saved
+var shouldSaveConfig bool
+
+// YayConf holds the current config values for yay.
+var config *Configuration
+
+// AlpmConf holds the current config values for pacman.
+var pacmanConf *pacmanconf.Config
+
+// AlpmHandle is the alpm handle used by yay.
+var alpmHandle *alpm.Handle
+
+// Mode is used to restrict yay to AUR or repo only modes
+var mode = modeAny
+
+var hideMenus = false
+
+// SaveConfig writes yay config to file.
+func (config *Configuration) saveConfig() error {
+	marshalledinfo, err := json.MarshalIndent(config, "", "\t")
+	if err != nil {
+		return err
+	}
+	in, err := os.OpenFile(configFile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		return err
+	}
+	defer in.Close()
+	if _, err = in.Write(marshalledinfo); err != nil {
+		return err
+	}
+	return in.Sync()
+}
+
+func defaultSettings() *Configuration {
+	config := &Configuration{
+		AURURL:             "https://aur.archlinux.org",
+		BuildDir:           "$HOME/.cache/yay",
+		ABSDir:             "$HOME/.cache/yay/abs",
+		CleanAfter:         false,
+		Editor:             "",
+		EditorFlags:        "",
+		Devel:              false,
+		MakepkgBin:         "makepkg",
+		MakepkgConf:        "",
+		NoConfirm:          false,
+		PacmanBin:          "pacman",
+		PGPFetch:           true,
+		PacmanConf:         "/etc/pacman.conf",
+		GpgFlags:           "",
+		MFlags:             "",
+		GitFlags:           "",
+		SortMode:           bottomUp,
+		CompletionInterval: 7,
+		SortBy:             "votes",
+		SearchBy:           "name-desc",
+		SudoLoop:           false,
+		GitBin:             "git",
+		GpgBin:             "gpg",
+		SudoBin:            "sudo",
+		SudoFlags:          "",
+		TimeUpdate:         false,
+		RequestSplitN:      150,
+		ReDownload:         "no",
+		ReBuild:            "no",
+		BatchInstall:       false,
+		AnswerClean:        "",
+		AnswerDiff:         "",
+		AnswerEdit:         "",
+		AnswerUpgrade:      "",
+		RemoveMake:         "ask",
+		Provides:           true,
+		UpgradeMenu:        true,
+		CleanMenu:          true,
+		DiffMenu:           true,
+		EditMenu:           false,
+		UseAsk:             false,
+		CombinedUpgrade:    false,
+	}
+
+	if os.Getenv("XDG_CACHE_HOME") != "" {
+		config.BuildDir = "$XDG_CACHE_HOME/yay"
+	}
+
+	return config
+}
+
+func (config *Configuration) expandEnv() {
+	config.AURURL = os.ExpandEnv(config.AURURL)
+	config.ABSDir = os.ExpandEnv(config.ABSDir)
+	config.BuildDir = os.ExpandEnv(config.BuildDir)
+	config.Editor = os.ExpandEnv(config.Editor)
+	config.EditorFlags = os.ExpandEnv(config.EditorFlags)
+	config.MakepkgBin = os.ExpandEnv(config.MakepkgBin)
+	config.MakepkgConf = os.ExpandEnv(config.MakepkgConf)
+	config.PacmanBin = os.ExpandEnv(config.PacmanBin)
+	config.PacmanConf = os.ExpandEnv(config.PacmanConf)
+	config.GpgFlags = os.ExpandEnv(config.GpgFlags)
+	config.MFlags = os.ExpandEnv(config.MFlags)
+	config.GitFlags = os.ExpandEnv(config.GitFlags)
+	config.SortBy = os.ExpandEnv(config.SortBy)
+	config.SearchBy = os.ExpandEnv(config.SearchBy)
+	config.GitBin = os.ExpandEnv(config.GitBin)
+	config.GpgBin = os.ExpandEnv(config.GpgBin)
+	config.SudoBin = os.ExpandEnv(config.SudoBin)
+	config.SudoFlags = os.ExpandEnv(config.SudoFlags)
+	config.ReDownload = os.ExpandEnv(config.ReDownload)
+	config.ReBuild = os.ExpandEnv(config.ReBuild)
+	config.AnswerClean = os.ExpandEnv(config.AnswerClean)
+	config.AnswerDiff = os.ExpandEnv(config.AnswerDiff)
+	config.AnswerEdit = os.ExpandEnv(config.AnswerEdit)
+	config.AnswerUpgrade = os.ExpandEnv(config.AnswerUpgrade)
+	config.RemoveMake = os.ExpandEnv(config.RemoveMake)
+}
+
+// Editor returns the preferred system editor.
+func editor() (string, []string) {
+	switch {
+	case config.Editor != "":
+		editor, err := exec.LookPath(config.Editor)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		} else {
+			return editor, strings.Fields(config.EditorFlags)
+		}
+		fallthrough
+	case os.Getenv("EDITOR") != "":
+		editorArgs := strings.Fields(os.Getenv("EDITOR"))
+		editor, err := exec.LookPath(editorArgs[0])
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		} else {
+			return editor, editorArgs[1:]
+		}
+		fallthrough
+	case os.Getenv("VISUAL") != "":
+		editorArgs := strings.Fields(os.Getenv("VISUAL"))
+		editor, err := exec.LookPath(editorArgs[0])
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		} else {
+			return editor, editorArgs[1:]
+		}
+		fallthrough
+	default:
+		fmt.Fprintln(os.Stderr)
+		fmt.Fprintln(os.Stderr, bold(red(arrow)), bold(cyan("$EDITOR")), bold("is not set"))
+		fmt.Fprintln(os.Stderr, bold(red(arrow))+bold(" Please add ")+bold(cyan("$EDITOR"))+bold(" or ")+bold(cyan("$VISUAL"))+bold(" to your environment variables."))
+
+		for {
+			fmt.Print(green(bold(arrow + " Edit PKGBUILD with: ")))
+			editorInput, err := getInput("")
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				continue
+			}
+
+			editorArgs := strings.Fields(editorInput)
+			if len(editorArgs) == 0 {
+				continue
+			}
+
+			editor, err := exec.LookPath(editorArgs[0])
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				continue
+			}
+			return editor, editorArgs[1:]
+		}
+	}
+}
+
+// ContinueTask prompts if user wants to continue task.
+//If NoConfirm is set the action will continue without user input.
+func continueTask(s string, cont bool) bool {
+	if config.NoConfirm {
+		return cont
+	}
+
+	var response string
+	var postFix string
+	yes := "yes"
+	no := "no"
+	y := string([]rune(yes)[0])
+	n := string([]rune(no)[0])
+
+	if cont {
+		postFix = fmt.Sprintf(" [%s/%s] ", strings.ToUpper(y), n)
+	} else {
+		postFix = fmt.Sprintf(" [%s/%s] ", y, strings.ToUpper(n))
+	}
+
+	fmt.Print(bold(green(arrow)+" "+s), bold(postFix))
+
+	if _, err := fmt.Scanln(&response); err != nil {
+		return cont
+	}
+
+	response = strings.ToLower(response)
+	return response == yes || response == y
+}
+
+func getInput(defaultValue string) (string, error) {
+	if defaultValue != "" || config.NoConfirm {
+		fmt.Println(defaultValue)
+		return defaultValue, nil
+	}
+
+	reader := bufio.NewReader(os.Stdin)
+
+	buf, overflow, err := reader.ReadLine()
+	if err != nil {
+		return "", err
+	}
+
+	if overflow {
+		return "", fmt.Errorf("Input too long")
+	}
+
+	return string(buf), nil
+}
+
+func (config Configuration) String() string {
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetIndent("", "\t")
+	if err := enc.Encode(config); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+	}
+	return buf.String()
+}
+
+func toUsage(usages []string) alpm.Usage {
+	if len(usages) == 0 {
+		return alpm.UsageAll
+	}
+
+	var ret alpm.Usage
+	for _, usage := range usages {
+		switch usage {
+		case "Sync":
+			ret |= alpm.UsageSync
+		case "Search":
+			ret |= alpm.UsageSearch
+		case "Install":
+			ret |= alpm.UsageInstall
+		case "Upgrade":
+			ret |= alpm.UsageUpgrade
+		case "All":
+			ret |= alpm.UsageAll
+		}
+	}
+
+	return ret
+}
+
+func configureAlpm(conf *pacmanconf.Config) error {
+
+	// TODO: set SigLevel
+	//sigLevel := alpm.SigPackage | alpm.SigPackageOptional | alpm.SigDatabase | alpm.SigDatabaseOptional
+	//localFileSigLevel := alpm.SigUseDefault
+	//remoteFileSigLevel := alpm.SigUseDefault
+
+	for _, repo := range pacmanConf.Repos {
+		// TODO: set SigLevel
+		db, err := alpmHandle.RegisterSyncDB(repo.Name, 0)
+		if err != nil {
+			return err
+		}
+
+		db.SetServers(repo.Servers)
+		db.SetUsage(toUsage(repo.Usage))
+
+	}
+
+	if err := alpmHandle.SetCacheDirs(pacmanConf.CacheDir); err != nil {
+		return err
+	}
+
+	// add hook directories 1-by-1 to avoid overwriting the system directory
+	for _, dir := range pacmanConf.HookDir {
+		if err := alpmHandle.AddHookDir(dir); err != nil {
+			return err
+		}
+	}
+
+	if err := alpmHandle.SetGPGDir(pacmanConf.GPGDir); err != nil {
+		return err
+	}
+
+	if err := alpmHandle.SetLogFile(pacmanConf.LogFile); err != nil {
+		return err
+	}
+
+	if err := alpmHandle.SetIgnorePkgs(pacmanConf.IgnorePkg); err != nil {
+		return err
+	}
+
+	if err := alpmHandle.SetIgnoreGroups(pacmanConf.IgnoreGroup); err != nil {
+		return err
+	}
+
+	if err := alpmHandle.SetArch(pacmanConf.Architecture); err != nil {
+		return err
+	}
+
+	if err := alpmHandle.SetNoUpgrades(pacmanConf.NoUpgrade); err != nil {
+		return err
+	}
+
+	if err := alpmHandle.SetNoExtracts(pacmanConf.NoExtract); err != nil {
+		return err
+	}
+
+	/*if err := alpmHandle.SetDefaultSigLevel(sigLevel); err != nil {
+		return err
+	}
+
+	if err := alpmHandle.SetLocalFileSigLevel(localFileSigLevel); err != nil {
+		return err
+	}
+
+	if err := alpmHandle.SetRemoteFileSigLevel(remoteFileSigLevel); err != nil {
+		return err
+	}*/
+
+	if err := alpmHandle.SetUseSyslog(pacmanConf.UseSyslog); err != nil {
+		return err
+	}
+
+	return alpmHandle.SetCheckSpace(pacmanConf.CheckSpace)
+}

config_test.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func expect(t *testing.T, field string, a interface{}, b interface{}, err error) {
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(a, b) {
+		t.Errorf("%s expected: %s got %s", field, a, b)
+	}
+}
+
+func TestConfig(t *testing.T) {
+	config = &Configuration{}
+	config.PacmanConf = "./testdata/pacman.conf"
+
+	err := initAlpm()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h := alpmHandle
+
+	root, err := h.Root()
+	expect(t, "RootDir", "/", root, err)
+
+	cache, err := h.CacheDirs()
+	expect(t, "CacheDir", []string{"/cachedir/", "/another/"}, cache.Slice(), err)
+
+	log, err := h.LogFile()
+	expect(t, "LogFile", "/logfile", log, err)
+
+	gpg, err := h.GPGDir()
+	expect(t, "GPGDir", "/gpgdir/", gpg, err)
+
+	hook, err := h.HookDirs()
+	expect(t, "HookDir", []string{"/usr/share/libalpm/hooks/", "/hookdir/"}, hook.Slice(), err)
+
+	arch, err := h.Arch()
+	expect(t, "Architecture", "8086", arch, err)
+
+	ignorePkg, err := h.IgnorePkgs()
+	expect(t, "IgnorePkg", []string{"ignore", "this", "package"}, ignorePkg.Slice(), err)
+
+	ignoreGroup, err := h.IgnoreGroups()
+	expect(t, "IgnoreGroup", []string{"ignore", "this", "group"}, ignoreGroup.Slice(), err)
+
+	noUp, err := h.NoUpgrades()
+	expect(t, "NoUpgrade", []string{"noupgrade"}, noUp.Slice(), err)
+
+	noEx, err := h.NoExtracts()
+	expect(t, "NoExtract", []string{"noextract"}, noEx.Slice(), err)
+
+	check, err := h.CheckSpace()
+	expect(t, "CheckSpace", true, check, err)
+}

dep.go

@@ -0,0 +1,174 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	alpm "github.com/Jguer/go-alpm"
+	rpc "github.com/mikkeloscar/aur"
+)
+
+type providers struct {
+	lookfor string
+	Pkgs    []*rpc.Pkg
+}
+
+func makeProviders(name string) providers {
+	return providers{
+		name,
+		make([]*rpc.Pkg, 0),
+	}
+}
+
+func (q providers) Len() int {
+	return len(q.Pkgs)
+}
+
+func (q providers) Less(i, j int) bool {
+	if q.lookfor == q.Pkgs[i].Name {
+		return true
+	}
+
+	if q.lookfor == q.Pkgs[j].Name {
+		return false
+	}
+
+	return LessRunes([]rune(q.Pkgs[i].Name), []rune(q.Pkgs[j].Name))
+}
+
+func (q providers) Swap(i, j int) {
+	q.Pkgs[i], q.Pkgs[j] = q.Pkgs[j], q.Pkgs[i]
+}
+
+func splitDep(dep string) (string, string, string) {
+	mod := ""
+
+	split := strings.FieldsFunc(dep, func(c rune) bool {
+		match := c == '>' || c == '<' || c == '='
+
+		if match {
+			mod += string(c)
+		}
+
+		return match
+	})
+
+	if len(split) == 0 {
+		return "", "", ""
+	}
+
+	if len(split) == 1 {
+		return split[0], "", ""
+	}
+
+	return split[0], mod, split[1]
+}
+
+func pkgSatisfies(name, version, dep string) bool {
+	depName, depMod, depVersion := splitDep(dep)
+
+	if depName != name {
+		return false
+	}
+
+	return verSatisfies(version, depMod, depVersion)
+}
+
+func provideSatisfies(provide, dep string) bool {
+	depName, depMod, depVersion := splitDep(dep)
+	provideName, provideMod, provideVersion := splitDep(provide)
+
+	if provideName != depName {
+		return false
+	}
+
+	// Unversioned provieds can not satisfy a versioned dep
+	if provideMod == "" && depMod != "" {
+		return false
+	}
+
+	return verSatisfies(provideVersion, depMod, depVersion)
+}
+
+func verSatisfies(ver1, mod, ver2 string) bool {
+	switch mod {
+	case "=":
+		return alpm.VerCmp(ver1, ver2) == 0
+	case "<":
+		return alpm.VerCmp(ver1, ver2) < 0
+	case "<=":
+		return alpm.VerCmp(ver1, ver2) <= 0
+	case ">":
+		return alpm.VerCmp(ver1, ver2) > 0
+	case ">=":
+		return alpm.VerCmp(ver1, ver2) >= 0
+	}
+
+	return true
+}
+
+func satisfiesAur(dep string, pkg *rpc.Pkg) bool {
+	if pkgSatisfies(pkg.Name, pkg.Version, dep) {
+		return true
+	}
+
+	for _, provide := range pkg.Provides {
+		if provideSatisfies(provide, dep) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func satisfiesRepo(dep string, pkg *alpm.Package) bool {
+	if pkgSatisfies(pkg.Name(), pkg.Version(), dep) {
+		return true
+	}
+
+	if pkg.Provides().ForEach(func(provide alpm.Depend) error {
+		if provideSatisfies(provide.String(), dep) {
+			return fmt.Errorf("")
+		}
+
+		return nil
+	}) != nil {
+		return true
+	}
+
+	return false
+}
+
+//split apart db/package to db and package
+func splitDBFromName(pkg string) (string, string) {
+	split := strings.SplitN(pkg, "/", 2)
+
+	if len(split) == 2 {
+		return split[0], split[1]
+	}
+	return "", split[0]
+}
+
+func getBases(pkgs []*rpc.Pkg) []Base {
+	basesMap := make(map[string]Base)
+	for _, pkg := range pkgs {
+		basesMap[pkg.PackageBase] = append(basesMap[pkg.PackageBase], pkg)
+	}
+
+	bases := make([]Base, 0, len(basesMap))
+	for _, base := range basesMap {
+		bases = append(bases, base)
+	}
+
+	return bases
+}
+
+func isDevelName(name string) bool {
+	for _, suffix := range []string{"git", "svn", "hg", "bzr", "nightly"} {
+		if strings.HasSuffix(name, "-"+suffix) {
+			return true
+		}
+	}
+
+	return strings.Contains(name, "-always-")
+}

depCheck.go

@@ -0,0 +1,297 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+
+	alpm "github.com/Jguer/go-alpm"
+	"github.com/Jguer/yay/v9/pkg/stringset"
+)
+
+func (dp *depPool) checkInnerConflict(name string, conflict string, conflicts stringset.MapStringSet) {
+	for _, pkg := range dp.Aur {
+		if pkg.Name == name {
+			continue
+		}
+
+		if satisfiesAur(conflict, pkg) {
+			conflicts.Add(name, pkg.Name)
+		}
+	}
+
+	for _, pkg := range dp.Repo {
+		if pkg.Name() == name {
+			continue
+		}
+
+		if satisfiesRepo(conflict, pkg) {
+			conflicts.Add(name, pkg.Name())
+		}
+	}
+}
+
+func (dp *depPool) checkForwardConflict(name string, conflict string, conflicts stringset.MapStringSet) {
+	_ = dp.LocalDB.PkgCache().ForEach(func(pkg alpm.Package) error {
+		if pkg.Name() == name || dp.hasPackage(pkg.Name()) {
+			return nil
+		}
+
+		if satisfiesRepo(conflict, &pkg) {
+			n := pkg.Name()
+			if n != conflict {
+				n += " (" + conflict + ")"
+			}
+			conflicts.Add(name, n)
+		}
+
+		return nil
+	})
+}
+
+func (dp *depPool) checkReverseConflict(name string, conflict string, conflicts stringset.MapStringSet) {
+	for _, pkg := range dp.Aur {
+		if pkg.Name == name {
+			continue
+		}
+
+		if satisfiesAur(conflict, pkg) {
+			if name != conflict {
+				name += " (" + conflict + ")"
+			}
+
+			conflicts.Add(pkg.Name, name)
+		}
+	}
+
+	for _, pkg := range dp.Repo {
+		if pkg.Name() == name {
+			continue
+		}
+
+		if satisfiesRepo(conflict, pkg) {
+			if name != conflict {
+				name += " (" + conflict + ")"
+			}
+
+			conflicts.Add(pkg.Name(), name)
+		}
+	}
+}
+
+func (dp *depPool) checkInnerConflicts(conflicts stringset.MapStringSet) {
+	for _, pkg := range dp.Aur {
+		for _, conflict := range pkg.Conflicts {
+			dp.checkInnerConflict(pkg.Name, conflict, conflicts)
+		}
+	}
+
+	for _, pkg := range dp.Repo {
+		_ = pkg.Conflicts().ForEach(func(conflict alpm.Depend) error {
+			dp.checkInnerConflict(pkg.Name(), conflict.String(), conflicts)
+			return nil
+		})
+	}
+}
+
+func (dp *depPool) checkForwardConflicts(conflicts stringset.MapStringSet) {
+	for _, pkg := range dp.Aur {
+		for _, conflict := range pkg.Conflicts {
+			dp.checkForwardConflict(pkg.Name, conflict, conflicts)
+		}
+	}
+
+	for _, pkg := range dp.Repo {
+		_ = pkg.Conflicts().ForEach(func(conflict alpm.Depend) error {
+			dp.checkForwardConflict(pkg.Name(), conflict.String(), conflicts)
+			return nil
+		})
+	}
+}
+
+func (dp *depPool) checkReverseConflicts(conflicts stringset.MapStringSet) {
+	_ = dp.LocalDB.PkgCache().ForEach(func(pkg alpm.Package) error {
+		if dp.hasPackage(pkg.Name()) {
+			return nil
+		}
+
+		_ = pkg.Conflicts().ForEach(func(conflict alpm.Depend) error {
+			dp.checkReverseConflict(pkg.Name(), conflict.String(), conflicts)
+			return nil
+		})
+
+		return nil
+	})
+}
+
+func (dp *depPool) CheckConflicts() (stringset.MapStringSet, error) {
+	var wg sync.WaitGroup
+	innerConflicts := make(stringset.MapStringSet)
+	conflicts := make(stringset.MapStringSet)
+	wg.Add(2)
+
+	fmt.Println(bold(cyan("::") + bold(" Checking for conflicts...")))
+	go func() {
+		dp.checkForwardConflicts(conflicts)
+		dp.checkReverseConflicts(conflicts)
+		wg.Done()
+	}()
+
+	fmt.Println(bold(cyan("::") + bold(" Checking for inner conflicts...")))
+	go func() {
+		dp.checkInnerConflicts(innerConflicts)
+		wg.Done()
+	}()
+
+	wg.Wait()
+
+	if len(innerConflicts) != 0 {
+		fmt.Println()
+		fmt.Println(bold(red(arrow)), bold("Inner conflicts found:"))
+
+		for name, pkgs := range innerConflicts {
+			str := red(bold(smallArrow)) + " " + name + ":"
+			for pkg := range pkgs {
+				str += " " + cyan(pkg) + ","
+			}
+			str = strings.TrimSuffix(str, ",")
+
+			fmt.Println(str)
+		}
+
+	}
+
+	if len(conflicts) != 0 {
+		fmt.Println()
+		fmt.Println(bold(red(arrow)), bold("Package conflicts found:"))
+
+		for name, pkgs := range conflicts {
+			str := red(bold(smallArrow)) + " Installing " + cyan(name) + " will remove:"
+			for pkg := range pkgs {
+				str += " " + cyan(pkg) + ","
+			}
+			str = strings.TrimSuffix(str, ",")
+
+			fmt.Println(str)
+		}
+
+	}
+
+	// Add the inner conflicts to the conflicts
+	// These are used to decide what to pass --ask to (if set) or don't pass --noconfirm to
+	// As we have no idea what the order is yet we add every inner conflict to the slice
+	for name, pkgs := range innerConflicts {
+		conflicts[name] = make(stringset.StringSet)
+		for pkg := range pkgs {
+			conflicts[pkg] = make(stringset.StringSet)
+		}
+	}
+
+	if len(conflicts) > 0 {
+		if !config.UseAsk {
+			if config.NoConfirm {
+				return nil, fmt.Errorf("Package conflicts can not be resolved with noconfirm, aborting")
+			}
+
+			fmt.Fprintln(os.Stderr)
+			fmt.Fprintln(os.Stderr, bold(red(arrow)), bold("Conflicting packages will have to be confirmed manually"))
+			fmt.Fprintln(os.Stderr)
+		}
+	}
+
+	return conflicts, nil
+}
+
+type missing struct {
+	Good    stringset.StringSet
+	Missing map[string][][]string
+}
+
+func (dp *depPool) _checkMissing(dep string, stack []string, missing *missing) {
+	if missing.Good.Get(dep) {
+		return
+	}
+
+	if trees, ok := missing.Missing[dep]; ok {
+		for _, tree := range trees {
+			if stringSliceEqual(tree, stack) {
+				return
+			}
+		}
+		missing.Missing[dep] = append(missing.Missing[dep], stack)
+		return
+	}
+
+	aurPkg := dp.findSatisfierAur(dep)
+	if aurPkg != nil {
+		missing.Good.Set(dep)
+		for _, deps := range [3][]string{aurPkg.Depends, aurPkg.MakeDepends, aurPkg.CheckDepends} {
+			for _, aurDep := range deps {
+				if _, err := dp.LocalDB.PkgCache().FindSatisfier(aurDep); err == nil {
+					missing.Good.Set(aurDep)
+					continue
+				}
+
+				dp._checkMissing(aurDep, append(stack, aurPkg.Name), missing)
+			}
+		}
+
+		return
+	}
+
+	repoPkg := dp.findSatisfierRepo(dep)
+	if repoPkg != nil {
+		missing.Good.Set(dep)
+		_ = repoPkg.Depends().ForEach(func(repoDep alpm.Depend) error {
+			if _, err := dp.LocalDB.PkgCache().FindSatisfier(repoDep.String()); err == nil {
+				missing.Good.Set(repoDep.String())
+				return nil
+			}
+
+			dp._checkMissing(repoDep.String(), append(stack, repoPkg.Name()), missing)
+			return nil
+		})
+
+		return
+	}
+
+	missing.Missing[dep] = [][]string{stack}
+}
+
+func (dp *depPool) CheckMissing() error {
+	missing := &missing{
+		make(stringset.StringSet),
+		make(map[string][][]string),
+	}
+
+	for _, target := range dp.Targets {
+		dp._checkMissing(target.DepString(), make([]string, 0), missing)
+	}
+
+	if len(missing.Missing) == 0 {
+		return nil
+	}
+
+	fmt.Println(bold(red(arrow+" Error: ")) + "Could not find all required packages:")
+	for dep, trees := range missing.Missing {
+		for _, tree := range trees {
+
+			fmt.Print("    ", cyan(dep))
+
+			if len(tree) == 0 {
+				fmt.Print(" (Target")
+			} else {
+				fmt.Print(" (Wanted by: ")
+				for n := 0; n < len(tree)-1; n++ {
+					fmt.Print(cyan(tree[n]), " -> ")
+				}
+				fmt.Print(cyan(tree[len(tree)-1]))
+			}
+
+			fmt.Println(")")
+		}
+	}
+
+	return fmt.Errorf("")
+}

depOrder.go

@@ -0,0 +1,140 @@
+package main
+
+import (
+	alpm "github.com/Jguer/go-alpm"
+	"github.com/Jguer/yay/v9/pkg/stringset"
+	rpc "github.com/mikkeloscar/aur"
+)
+
+// Base is an AUR base package
+type Base []*rpc.Pkg
+
+// Pkgbase returns the first base package.
+func (b Base) Pkgbase() string {
+	return b[0].PackageBase
+}
+
+// Version returns the first base package version.
+func (b Base) Version() string {
+	return b[0].Version
+}
+
+// URLPath returns the first base package URL.
+func (b Base) URLPath() string {
+	return b[0].URLPath
+}
+
+type depOrder struct {
+	Aur     []Base
+	Repo    []*alpm.Package
+	Runtime stringset.StringSet
+}
+
+func makeDepOrder() *depOrder {
+	return &depOrder{
+		make([]Base, 0),
+		make([]*alpm.Package, 0),
+		make(stringset.StringSet),
+	}
+}
+
+func getDepOrder(dp *depPool) *depOrder {
+	do := makeDepOrder()
+
+	for _, target := range dp.Targets {
+		dep := target.DepString()
+		aurPkg := dp.Aur[dep]
+		if aurPkg != nil && pkgSatisfies(aurPkg.Name, aurPkg.Version, dep) {
+			do.orderPkgAur(aurPkg, dp, true)
+		}
+
+		aurPkg = dp.findSatisfierAur(dep)
+		if aurPkg != nil {
+			do.orderPkgAur(aurPkg, dp, true)
+		}
+
+		repoPkg := dp.findSatisfierRepo(dep)
+		if repoPkg != nil {
+			do.orderPkgRepo(repoPkg, dp, true)
+		}
+	}
+
+	return do
+}
+
+func (do *depOrder) orderPkgAur(pkg *rpc.Pkg, dp *depPool, runtime bool) {
+	if runtime {
+		do.Runtime.Set(pkg.Name)
+	}
+	delete(dp.Aur, pkg.Name)
+
+	for i, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} {
+		for _, dep := range deps {
+			aurPkg := dp.findSatisfierAur(dep)
+			if aurPkg != nil {
+				do.orderPkgAur(aurPkg, dp, runtime && i == 0)
+			}
+
+			repoPkg := dp.findSatisfierRepo(dep)
+			if repoPkg != nil {
+				do.orderPkgRepo(repoPkg, dp, runtime && i == 0)
+			}
+		}
+	}
+
+	for i, base := range do.Aur {
+		if base.Pkgbase() == pkg.PackageBase {
+			do.Aur[i] = append(base, pkg)
+			return
+		}
+	}
+
+	do.Aur = append(do.Aur, Base{pkg})
+}
+
+func (do *depOrder) orderPkgRepo(pkg *alpm.Package, dp *depPool, runtime bool) {
+	if runtime {
+		do.Runtime.Set(pkg.Name())
+	}
+	delete(dp.Repo, pkg.Name())
+
+	_ = pkg.Depends().ForEach(func(dep alpm.Depend) (err error) {
+		repoPkg := dp.findSatisfierRepo(dep.String())
+		if repoPkg != nil {
+			do.orderPkgRepo(repoPkg, dp, runtime)
+		}
+
+		return nil
+	})
+
+	do.Repo = append(do.Repo, pkg)
+}
+
+func (do *depOrder) HasMake() bool {
+	lenAur := 0
+	for _, base := range do.Aur {
+		lenAur += len(base)
+	}
+
+	return len(do.Runtime) != lenAur+len(do.Repo)
+}
+
+func (do *depOrder) getMake() []string {
+	makeOnly := []string{}
+
+	for _, base := range do.Aur {
+		for _, pkg := range base {
+			if !do.Runtime.Get(pkg.Name) {
+				makeOnly = append(makeOnly, pkg.Name)
+			}
+		}
+	}
+
+	for _, pkg := range do.Repo {
+		if !do.Runtime.Get(pkg.Name()) {
+			makeOnly = append(makeOnly, pkg.Name())
+		}
+	}
+
+	return makeOnly
+}

depPool.go

@@ -0,0 +1,482 @@
+package main
+
+import (
+	"sort"
+	"strings"
+	"sync"
+
+	alpm "github.com/Jguer/go-alpm"
+	"github.com/Jguer/yay/v9/pkg/stringset"
+	rpc "github.com/mikkeloscar/aur"
+)
+
+type target struct {
+	DB      string
+	Name    string
+	Mod     string
+	Version string
+}
+
+func toTarget(pkg string) target {
+	db, dep := splitDBFromName(pkg)
+	name, mod, version := splitDep(dep)
+
+	return target{
+		db,
+		name,
+		mod,
+		version,
+	}
+}
+
+func (t target) DepString() string {
+	return t.Name + t.Mod + t.Version
+}
+
+func (t target) String() string {
+	if t.DB != "" {
+		return t.DB + "/" + t.DepString()
+	}
+
+	return t.DepString()
+}
+
+type depPool struct {
+	Targets  []target
+	Explicit stringset.StringSet
+	Repo     map[string]*alpm.Package
+	Aur      map[string]*rpc.Pkg
+	AurCache map[string]*rpc.Pkg
+	Groups   []string
+	LocalDB  *alpm.DB
+	SyncDB   alpm.DBList
+	Warnings *aurWarnings
+}
+
+func makeDepPool() (*depPool, error) {
+	localDB, err := alpmHandle.LocalDB()
+	if err != nil {
+		return nil, err
+	}
+	syncDB, err := alpmHandle.SyncDBs()
+	if err != nil {
+		return nil, err
+	}
+
+	dp := &depPool{
+		make([]target, 0),
+		make(stringset.StringSet),
+		make(map[string]*alpm.Package),
+		make(map[string]*rpc.Pkg),
+		make(map[string]*rpc.Pkg),
+		make([]string, 0),
+		localDB,
+		syncDB,
+		nil,
+	}
+
+	return dp, nil
+}
+
+// Includes db/ prefixes and group installs
+func (dp *depPool) ResolveTargets(pkgs []string) error {
+	// RPC requests are slow
+	// Combine as many AUR package requests as possible into a single RPC
+	// call
+	aurTargets := make(stringset.StringSet)
+
+	pkgs = removeInvalidTargets(pkgs)
+
+	for _, pkg := range pkgs {
+		var err error
+		target := toTarget(pkg)
+
+		// skip targets already satisfied
+		// even if the user enters db/pkg and aur/pkg the latter will
+		// still get skipped even if it's from a different database to
+		// the one specified
+		// this is how pacman behaves
+		if dp.hasPackage(target.DepString()) {
+			continue
+		}
+
+		var foundPkg *alpm.Package
+		var singleDB *alpm.DB
+
+		// aur/ prefix means we only check the aur
+		if target.DB == "aur" || mode == modeAUR {
+			dp.Targets = append(dp.Targets, target)
+			aurTargets.Set(target.DepString())
+			continue
+		}
+
+		// If there'ss a different priefix only look in that repo
+		if target.DB != "" {
+			singleDB, err = alpmHandle.SyncDBByName(target.DB)
+			if err != nil {
+				return err
+			}
+			foundPkg, err = singleDB.PkgCache().FindSatisfier(target.DepString())
+			//otherwise find it in any repo
+		} else {
+			foundPkg, err = dp.SyncDB.FindSatisfier(target.DepString())
+		}
+
+		if err == nil {
+			dp.Targets = append(dp.Targets, target)
+			dp.Explicit.Set(foundPkg.Name())
+			dp.ResolveRepoDependency(foundPkg)
+			continue
+		} else {
+			//check for groups
+			//currently we don't resolve the packages in a group
+			//only check if the group exists
+			//would be better to check the groups from singleDB if
+			//the user specified a db but there's no easy way to do
+			//it without making alpm_lists so don't bother for now
+			//db/group is probably a rare use case
+			group := dp.SyncDB.FindGroupPkgs(target.Name)
+			if !group.Empty() {
+				dp.Groups = append(dp.Groups, target.String())
+				_ = group.ForEach(func(pkg alpm.Package) error {
+					dp.Explicit.Set(pkg.Name())
+					return nil
+				})
+				continue
+			}
+		}
+
+		//if there was no db prefix check the aur
+		if target.DB == "" {
+			aurTargets.Set(target.DepString())
+		}
+
+		dp.Targets = append(dp.Targets, target)
+	}
+
+	if len(aurTargets) > 0 && (mode == modeAny || mode == modeAUR) {
+		return dp.resolveAURPackages(aurTargets, true)
+	}
+
+	return nil
+}
+
+// Pseudo provides finder.
+// Try to find provides by performing a search of the package name
+// This effectively performs -Ss on each package
+// then runs -Si on each result to cache the information.
+//
+// For example if you were to -S yay then yay -Ss would give:
+// yay-git yay-bin yay realyog pacui pacui-git ruby-yard
+// These packages will all be added to the cache in case they are needed later
+// Ofcouse only the first three packages provide yay, the rest are just false
+// positives.
+//
+// This method increases dependency resolve time
+func (dp *depPool) findProvides(pkgs stringset.StringSet) error {
+	var mux sync.Mutex
+	var wg sync.WaitGroup
+
+	doSearch := func(pkg string) {
+		defer wg.Done()
+		var err error
+		var results []rpc.Pkg
+
+		// Hack for a bigger search result, if the user wants
+		// java-envronment we can search for just java instead and get
+		// more hits.
+		words := strings.Split(pkg, "-")
+
+		for i := range words {
+			results, err = rpc.Search(strings.Join(words[:i+1], "-"))
+			if err == nil {
+				break
+			}
+		}
+
+		if err != nil {
+			return
+		}
+
+		for _, result := range results {
+			mux.Lock()
+			if _, ok := dp.AurCache[result.Name]; !ok {
+				pkgs.Set(result.Name)
+			}
+			mux.Unlock()
+		}
+	}
+
+	for pkg := range pkgs {
+		if dp.LocalDB.Pkg(pkg) != nil {
+			continue
+		}
+		wg.Add(1)
+		go doSearch(pkg)
+	}
+
+	wg.Wait()
+
+	return nil
+}
+
+func (dp *depPool) cacheAURPackages(_pkgs stringset.StringSet) error {
+	pkgs := _pkgs.Copy()
+	query := make([]string, 0)
+
+	for pkg := range pkgs {
+		if _, ok := dp.AurCache[pkg]; ok {
+			pkgs.Remove(pkg)
+		}
+	}
+
+	if len(pkgs) == 0 {
+		return nil
+	}
+
+	if config.Provides {
+		err := dp.findProvides(pkgs)
+		if err != nil {
+			return err
+		}
+	}
+
+	for pkg := range pkgs {
+		if _, ok := dp.AurCache[pkg]; !ok {
+			name, _, _ := splitDep(pkg)
+			query = append(query, name)
+		}
+	}
+
+	info, err := aurInfo(query, dp.Warnings)
+	if err != nil {
+		return err
+	}
+
+	for _, pkg := range info {
+		// Dump everything in cache just in case we need it later
+		dp.AurCache[pkg.Name] = pkg
+	}
+
+	return nil
+}
+
+func (dp *depPool) resolveAURPackages(pkgs stringset.StringSet, explicit bool) error {
+	newPackages := make(stringset.StringSet)
+	newAURPackages := make(stringset.StringSet)
+
+	err := dp.cacheAURPackages(pkgs)
+	if err != nil {
+		return err
+	}
+
+	if len(pkgs) == 0 {
+		return nil
+	}
+
+	for name := range pkgs {
+		_, ok := dp.Aur[name]
+		if ok {
+			continue
+		}
+
+		pkg := dp.findSatisfierAurCache(name)
+		if pkg == nil {
+			continue
+		}
+
+		if explicit {
+			dp.Explicit.Set(pkg.Name)
+		}
+		dp.Aur[pkg.Name] = pkg
+
+		for _, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} {
+			for _, dep := range deps {
+				newPackages.Set(dep)
+			}
+		}
+	}
+
+	for dep := range newPackages {
+		if dp.hasSatisfier(dep) {
+			continue
+		}
+
+		_, isInstalled := dp.LocalDB.PkgCache().FindSatisfier(dep) //has satisfier installed: skip
+		hm := hideMenus
+		hideMenus = isInstalled == nil
+		repoPkg, inRepos := dp.SyncDB.FindSatisfier(dep) //has satisfier in repo: fetch it
+		hideMenus = hm
+		if isInstalled == nil && (config.ReBuild != "tree" || inRepos == nil) {
+			continue
+		}
+
+		if inRepos == nil {
+			dp.ResolveRepoDependency(repoPkg)
+			continue
+		}
+
+		//assume it's in the aur
+		//ditch the versioning because the RPC can't handle it
+		newAURPackages.Set(dep)
+
+	}
+
+	err = dp.resolveAURPackages(newAURPackages, false)
+	return err
+}
+
+func (dp *depPool) ResolveRepoDependency(pkg *alpm.Package) {
+	dp.Repo[pkg.Name()] = pkg
+
+	_ = pkg.Depends().ForEach(func(dep alpm.Depend) (err error) {
+		//have satisfier in dep tree: skip
+		if dp.hasSatisfier(dep.String()) {
+			return
+		}
+
+		//has satisfier installed: skip
+		_, isInstalled := dp.LocalDB.PkgCache().FindSatisfier(dep.String())
+		if isInstalled == nil {
+			return
+		}
+
+		//has satisfier in repo: fetch it
+		repoPkg, inRepos := dp.SyncDB.FindSatisfier(dep.String())
+		if inRepos != nil {
+			return
+		}
+
+		dp.ResolveRepoDependency(repoPkg)
+
+		return nil
+	})
+}
+
+func getDepPool(pkgs []string, warnings *aurWarnings) (*depPool, error) {
+	dp, err := makeDepPool()
+	if err != nil {
+		return nil, err
+	}
+
+	dp.Warnings = warnings
+	err = dp.ResolveTargets(pkgs)
+
+	return dp, err
+}
+
+func (dp *depPool) findSatisfierAur(dep string) *rpc.Pkg {
+	for _, pkg := range dp.Aur {
+		if satisfiesAur(dep, pkg) {
+			return pkg
+		}
+	}
+
+	return nil
+}
+
+// This is mostly used to promote packages from the cache
+// to the Install list
+// Provide a pacman style provider menu if there's more than one candidate
+// This acts slightly differently from Pacman, It will give
+// a menu even if a package with a matching name exists. I believe this
+// method is better because most of the time you are choosing between
+// foo and foo-git.
+// Using Pacman's ways trying to install foo would never give you
+// a menu.
+// TODO: maybe intermix repo providers in the menu
+func (dp *depPool) findSatisfierAurCache(dep string) *rpc.Pkg {
+	depName, _, _ := splitDep(dep)
+	seen := make(stringset.StringSet)
+	providers := makeProviders(depName)
+
+	if dp.LocalDB.Pkg(depName) != nil {
+		if pkg, ok := dp.AurCache[dep]; ok && pkgSatisfies(pkg.Name, pkg.Version, dep) {
+			return pkg
+		}
+
+	}
+
+	if cmdArgs.op == "Y" || cmdArgs.op == "yay" {
+		for _, pkg := range dp.AurCache {
+			if pkgSatisfies(pkg.Name, pkg.Version, dep) {
+				for _, target := range dp.Targets {
+					if target.Name == pkg.Name {
+						return pkg
+					}
+				}
+			}
+		}
+	}
+
+	for _, pkg := range dp.AurCache {
+		if seen.Get(pkg.Name) {
+			continue
+		}
+
+		if pkgSatisfies(pkg.Name, pkg.Version, dep) {
+			providers.Pkgs = append(providers.Pkgs, pkg)
+			seen.Set(pkg.Name)
+			continue
+		}
+
+		for _, provide := range pkg.Provides {
+			if provideSatisfies(provide, dep) {
+				providers.Pkgs = append(providers.Pkgs, pkg)
+				seen.Set(pkg.Name)
+				continue
+			}
+		}
+	}
+
+	if !config.Provides && providers.Len() >= 1 {
+		return providers.Pkgs[0]
+	}
+
+	if providers.Len() == 1 {
+		return providers.Pkgs[0]
+	}
+
+	if providers.Len() > 1 {
+		sort.Sort(providers)
+		return providerMenu(dep, providers)
+	}
+
+	return nil
+}
+
+func (dp *depPool) findSatisfierRepo(dep string) *alpm.Package {
+	for _, pkg := range dp.Repo {
+		if satisfiesRepo(dep, pkg) {
+			return pkg
+		}
+	}
+
+	return nil
+}
+
+func (dp *depPool) hasSatisfier(dep string) bool {
+	return dp.findSatisfierRepo(dep) != nil || dp.findSatisfierAur(dep) != nil
+}
+
+func (dp *depPool) hasPackage(name string) bool {
+	for _, pkg := range dp.Repo {
+		if pkg.Name() == name {
+			return true
+		}
+	}
+
+	for _, pkg := range dp.Aur {
+		if pkg.Name == name {
+			return true
+		}
+	}
+
+	for _, pkg := range dp.Groups {
+		if pkg == name {
+			return true
+		}
+	}
+
+	return false
+}

doc/yay.8

@@ -1,4 +1,5 @@
-.TH "YAY" "8" "2019\-10\-21" "Yay v12.0+" "Yay Manual"
+'\ t
+.TH "YAY" "8" "2019\-10\-21" "Yay v9.4+" "Yay Manual"
 .nh
 .ad l
 .SH NAME
@@ -19,15 +20,10 @@ This manpage only covers options unique to Yay. For other options see
 \fBpacman(8)\fR.
 
 .SH YAY OPERATIONS
-
 .TP
 .B \-Y, \-\-yay
 Perform yay specific operations. This is the default if no other operation is
-selected and targets are defined.
-
-.TP
-.B \-B, \-\-build
-Build a PKGBUILD in a given directory.
+selected.
 
 .TP
 .B \-P, \-\-show
@@ -35,16 +31,13 @@ Perform yay specific print operations.
 
 .TP
 .B \-G, \-\-getpkgbuild
-Downloads PKGBUILD from ABS or AUR. The ABS can only be used for Arch Linux repositories.
-
-.TP
-.B \-W, \-\-web
-Web related operations such as voting for AUR packages.
+Downloads PKGBUILD from ABS or AUR. The ABS can only be used for Arch Linux
+repositories
 
 .RE
-If no operation is specified 'yay \-Syu' will be performed
+If no arguments are provided 'yay \-Syu' will be performed.
 
-If no operation is specified and targets are provided \-Y will be assumed
+If no operation is selected \-Y will be assumed.
 
 .SH EXTENDED PACMAN OPERATIONS
 .TP
@@ -63,7 +56,7 @@ Yay will also remove cached data about devel packages.
 
 .SH NEW OPTIONS
 .TP
-.B \-N, \-\-repo
+.B    \-\-repo
 Assume all targets are from the repositories. Additionally Actions such as
 sysupgrade will only act on repository packages.
 
@@ -82,10 +75,6 @@ packages.
 Displays a list of packages matching the search terms and prompts the user on
 which packages to install (yogurt mode).
 
-The first search term is used to query the different sources and
-the following search terms are used to narrow the search results
-through exact matching.
-
 .TP
 .B \-\-gendb
 Generate development package database. Tracks the latest commit for each
@@ -97,16 +86,16 @@ used when migrating to Yay from another AUR helper.
 .B \-c, \-\-clean
 Remove unneeded dependencies.
 
-.TP
-.B \-cc
-Remove unneeded dependencies, including packages optionally required by any other package.
-
-.SH SHOW OPTIONS (APPLY TO \-P AND \-\-show)
+.SH SHOW OPTIONS (APPLY TO \-P AND \-\-SHOW)
 .TP
 .B \-c, \-\-complete
 Print a list of all AUR and repo packages. This allows shell completion
 and is not intended to be used directly by the user.
 
+.TP
+.B \-f, \-\-fish
+During complete adjust the output for the fish shell.
+
 .TP
 .B \-d, \-\-defaultconfig
 Print default yay configuration.
@@ -115,12 +104,20 @@ Print default yay configuration.
 .B \-g, \-\-currentconfig
 Print current yay configuration.
 
+.TP
+.B \-n, \-\-numberupgrades
+Deprecated, use \fByay -Qu\fR and \fBwc -l\fR instead\%.
+
 .TP
 .B \-s, \-\-stats
 Displays information about installed packages and system health. If there are
 orphaned, or out\-of\-date packages, or packages that no longer exist on the
 AUR; warnings will be displayed.
 
+.TP
+.B \-u, \-\-upgrades
+Deprecated, use \fByay -Qu\fR instead\%.
+
 .TP
 .B \-w, \-\-news
 Print new news from the Archlinux homepage. News is considered new if it is
@@ -131,35 +128,12 @@ available news.
 .B \-q, \-\-quiet
 Only show titles when printing news.
 
-.SH BUILD OPTIONS (APPLY TO \-B AND \-\-build)
-.TP
-.B \-i, \-\-install
-Build and install a PKGBUILD in a given directory
-
-.SH GETPKGBUILD OPTIONS (APPLY TO \-G AND \-\-getpkgbuild)
+.SH GETPKGBUILD OPTIONS (APPLY TO \-G AND \-\-GETPKGBUILD)
 .TP
 .B \-f, \-\-force
 Force download for ABS packages that already exist in the current directory. This
 ensures directories are not accidentally overwritten.
 
-.TP
-.B \-p, \-\-print
-Prints the PKGBUILD of the given packages to stdout.
-
-.SH WEB OPTIONS (APPLY TO \-W AND \-\-web)
-
-.TP
-Web related operations such as voting for AUR packages.
-Requires setting AUR_USERNAME and AUR_PASSWORD environment variables.
-
-.TP
-.B \-u, \-\-unvote
-Remove vote from AUR package(s)
-
-.TP
-.B \-v, \-\-vote
-Vote for AUR package(s)
-
 .SH PERMANENT CONFIGURATION SETTINGS
 .TP
 .B \-\-save
@@ -169,21 +143,23 @@ file.
 
 .TP
 .B \-\-aururl
-Set an alternative AUR URL.
-
-.TP
-.B \-\-aurrpcurl
-Set an alternative URL for the AUR /rpc endpoint.
+Set an alternative AUR URL. This is mostly useful for users in China who wish
+to use https://aur.tuna.tsinghua.edu.cn/.
 
 .TP
 .B \-\-builddir <dir>
 Directory to use for Building AUR Packages. This directory is also used as
 the AUR cache when deciding if Yay should skip builds.
 
+.TP
+.B \-\-absdir <dir>
+Directory used to store downloads from the ABS. During \-G, the PKGBUILD
+placed in the current dir symlinks to absdir.
+
 .TP
 .B \-\-editor <command>
-Editor to use when editing PKGBUILDs. If this is not set the \fBVISUAL\fR
-environment variable will be checked, followed by \fBEDITOR\fR. If none of
+Editor to use when editing PKGBUILDs. If this is not set the \fBEDITOR\fR
+environment variable will be checked, followed by \fBVISUAL\fR. If none of
 these are set Yay will prompt the user for an editor.
 
 .TP
@@ -249,7 +225,7 @@ cache to never be refreshed.
 Sort AUR results by a specific field during search.
 
 .TP
-.B \-\-searchby <name|name-desc|maintainer|depends|checkdepends|makedepends|optdepends|provides|conflicts|replaces|groups|keywords|comaintainers>
+.B \-\-searchby <name|name-desc|maintainer|depends|checkdepends|makedepends|optdepends>
 Search for AUR packages by querying the specified field.
 
 .TP
@@ -297,9 +273,6 @@ Unset the answer for the upgrade menu.
 Show the clean menu. This menu gives you the chance to fully delete the
 downloaded build files from Yay's cache before redownloading a fresh copy.
 
-If 'cleanmenu' is enabled in the configuration file, you can temporarily disable it by
-using '--cleanmenu=false' on the command line
-
 .TP
 .B \-\-diffmenu
 Show the diff menu. This menu gives you the option to view diffs from
@@ -318,12 +291,35 @@ before building.
 recommended to edit pkgbuild variables unless you know what you are doing.
 
 .TP
-.B \-\-askremovemake
-Ask to remove makedepends after installing packages.
+.B \-\-upgrademenu
+Show a detailed list of updates in a similar format to VerbosePkgLists.
+Upgrades can also be skipped using numbers, number ranges or repo names.
+Additionally ^ can be used to invert the selection.
+
+\fBWarning\fR: It is not recommended to skip updates from the repositories as
+this can lead to partial upgrades. This feature is intended to easily skip AUR
+updates on the fly that may be broken or have a long compile time. Ultimately
+it is up to the user what upgrades they skip.
 
 .TP
-.B \-\-askyesremovemake
-Ask to remove makedepends after installing packages(with "Y" as default).
+.B \-\-nocleanmenu
+Do not show the clean menu.
+
+.TP
+.B \-\-nodiffmenu
+Do not show the diff menu.
+
+.TP
+.B \-\-noeditmenu
+Do not show the edit menu.
+
+.TP
+.B \-\-noupgrademenu
+Do not show the upgrade menu.
+
+.TP
+.B \-\-askremovemake
+Ask to remove makedepends after installing packages.
 
 .TP
 .B \-\-removemake
@@ -341,16 +337,6 @@ Display repository packages first and then AUR packages.
 .B \-\-bottomup
 Show AUR packages first and then repository packages.
 
-.TP
-.B \-\-singlelineresults
-Override pacman's usual double-line search result format and list each result
-on its own line.
-
-.TP
-.B \-\-doublelineresults
-Follow pacman's double-line search result format and list each result using
-two lines.
-
 .TP
 .B \-\-devel
 During sysupgrade also check AUR development packages for updates. Currently
@@ -363,8 +349,9 @@ checked almost instantly and not require the original pkgbuild to be downloaded.
 The slower pacaur-like devel checks can be implemented manually by piping
 a list of packages into yay (see \fBexamples\fR).
 
-If 'devel' is enabled in the configuration file, you can temporarily disable it by
-using '--devel=false' on the command line
+.TP
+.B \-\-nodevel
+Do not check for development packages updates during sysupgrade.
 
 .TP
 .B \-\-cleanafter
@@ -375,8 +362,8 @@ This allows VCS packages to easily pull an update
 instead of having to reclone the entire repo.
 
 .TP
-.B \-\-keepsrc
-Keep pkg/ and src/ after building packages
+.B \-\-nocleanafter
+Do not remove package sources after successful Install.
 
 .TP
 .B \-\-timeupdate
@@ -384,8 +371,8 @@ During sysupgrade also compare the build time of installed packages against
 the last modification time of each package's AUR page.
 
 .TP
-.B \-\-separatesources
-Separate query results by source, AUR and sync
+.B \-\-notimeupdate
+Do not consider build times during sysupgrade.
 
 .TP
 .B \-\-redownload
@@ -407,11 +394,23 @@ Look for matching providers when searching for AUR packages. When multiple
 providers are found a menu will appear prompting you to pick one. This
 increases dependency resolve time although this should not be noticeable.
 
+.TP
+.B \-\-noprovides
+Do not look for matching providers when searching for AUR packages.
+Yay will never show its provider menu but Pacman will still show its
+provider menu for repo packages.
+
 .TP
 .B \-\-pgpfetch
 Prompt to import unknown PGP keys from the \fBvalidpgpkeys\fR field of each
 PKGBUILD.
 
+.TP
+.B \-\-nopgpfetch
+Do not prompt to import unknown PGP keys. This is likely to cause a build
+failure unless using options such as \fB\-\-skippgpcheck\fR or a customized
+gpg config\%.
+
 .TP
 .B \-\-useask
 Use pacman's --ask flag to automatically confirm package conflicts. Yay lists
@@ -419,6 +418,11 @@ conflicts ahead of time. It is possible that Yay does not detect
 a conflict, causing a package to be removed without the user's confirmation.
 However, this is very unlikely.
 
+.TP
+.B \-\-nouseask
+Manually resolve package conflicts during the install. Packages which do not
+conflict will not need to be confined manually.
+
 .TP
 .B \-\-combinedupgrade
 During sysupgrade, Yay will first perform a refresh, then show
@@ -430,6 +434,12 @@ If Yay exits for any reason After the refresh without upgrading. It is then
 the user's responsibility to either resolve the reason Yay exited or run
 a sysupgrade through pacman directly.
 
+.TP
+.B \-\-nocombinedupgrade
+During sysupgrade, Pacman \-Syu will be called, then the AUR upgrade will
+start. This means the upgrade menu and pkgbuild review will be performed
+after the sysupgrade has finished.
+
 .TP
 .B \-\-batchinstall
 When building and installing AUR packages instead of installing each package
@@ -437,6 +447,10 @@ after building, queue each package for install. Then once either all packages
 are built or a package in the build queue is needed as a dependency to build
 another package, install all the packages in the install queue.
 
+.TP
+.B \-\-nobatchinstall
+Always install AUR packages immediately after building them.
+
 .TP
 .B \-\-rebuild
 Always build target packages even when a copy is available in cache.
@@ -490,6 +504,10 @@ separated list that is quoted by the shell.
 Loop sudo calls in the background to prevent sudo from timing out during long
 builds.
 
+.TP
+.B \-\-nosudoloop
+Do not loop sudo calls in the background.
+
 .SH EXAMPLES
 .TP
 yay \fIfoo\fR
@@ -594,6 +612,6 @@ See the arch wiki at https://wiki.archlinux.org/index.php/Arch_User_Repository f
 Please report bugs to our GitHub page https://github.com/Jguer/yay
 
 .SH AUTHORS
-Jguer <joguer@proton.me>
+Jguer <joaogg3@gmail.com>
 .br
-Morgan <morganamilo@archlinux.org>
+Anna <morganamilo@gmail.com>

download.go

@@ -0,0 +1,312 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	alpm "github.com/Jguer/go-alpm"
+	"github.com/Jguer/yay/v9/pkg/multierror"
+)
+
+const gitDiffRefName = "AUR_SEEN"
+
+// Update the YAY_DIFF_REVIEW ref to HEAD. We use this ref to determine which diff were
+// reviewed by the user
+func gitUpdateSeenRef(path string, name string) error {
+	_, stderr, err := capture(passToGit(filepath.Join(path, name), "update-ref", gitDiffRefName, "HEAD"))
+	if err != nil {
+		return fmt.Errorf("%s%s", stderr, err)
+	}
+	return nil
+}
+
+// Return wether or not we have reviewed a diff yet. It checks for the existence of
+// YAY_DIFF_REVIEW in the git ref-list
+func gitHasLastSeenRef(path string, name string) bool {
+	_, _, err := capture(passToGit(filepath.Join(path, name), "rev-parse", "--quiet", "--verify", gitDiffRefName))
+	return err == nil
+}
+
+// Returns the last reviewed hash. If YAY_DIFF_REVIEW exists it will return this hash.
+// If it does not it will return empty tree as no diff have been reviewed yet.
+func getLastSeenHash(path string, name string) (string, error) {
+	if gitHasLastSeenRef(path, name) {
+		stdout, stderr, err := capture(passToGit(filepath.Join(path, name), "rev-parse", gitDiffRefName))
+		if err != nil {
+			return "", fmt.Errorf("%s%s", stderr, err)
+		}
+
+		lines := strings.Split(stdout, "\n")
+		return lines[0], nil
+	}
+	return gitEmptyTree, nil
+}
+
+// Check whether or not a diff exists between the last reviewed diff and
+// HEAD@{upstream}
+func gitHasDiff(path string, name string) (bool, error) {
+	if gitHasLastSeenRef(path, name) {
+		stdout, stderr, err := capture(passToGit(filepath.Join(path, name), "rev-parse", gitDiffRefName, "HEAD@{upstream}"))
+		if err != nil {
+			return false, fmt.Errorf("%s%s", stderr, err)
+		}
+
+		lines := strings.Split(stdout, "\n")
+		lastseen := lines[0]
+		upstream := lines[1]
+		return lastseen != upstream, nil
+	}
+	// If YAY_DIFF_REVIEW does not exists, we have never reviewed a diff for this package
+	// and should display it.
+	return true, nil
+}
+
+// TODO: yay-next passes args through the header, use that to unify ABS and AUR
+func gitDownloadABS(url string, path string, name string) (bool, error) {
+	err := os.MkdirAll(path, 0755)
+	if err != nil {
+		return false, err
+	}
+
+	_, err = os.Stat(filepath.Join(path, name))
+	if os.IsNotExist(err) {
+		cmd := passToGit(path, "clone", "--no-progress", "--single-branch",
+			"-b", "packages/"+name, url, name)
+		cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
+		_, stderr, err := capture(cmd)
+		if err != nil {
+			return false, fmt.Errorf("error cloning %s: %s", name, stderr)
+		}
+
+		return true, nil
+	} else if err != nil {
+		return false, fmt.Errorf("error reading %s", filepath.Join(path, name, ".git"))
+	}
+
+	cmd := passToGit(filepath.Join(path, name), "pull", "--ff-only")
+	cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
+	_, stderr, err := capture(cmd)
+	if err != nil {
+		return false, fmt.Errorf("error fetching %s: %s", name, stderr)
+	}
+
+	return true, nil
+}
+
+func gitDownload(url string, path string, name string) (bool, error) {
+	_, err := os.Stat(filepath.Join(path, name, ".git"))
+	if os.IsNotExist(err) {
+		cmd := passToGit(path, "clone", "--no-progress", url, name)
+		cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
+		_, stderr, err := capture(cmd)
+		if err != nil {
+			return false, fmt.Errorf("error cloning %s: %s", name, stderr)
+		}
+
+		return true, nil
+	} else if err != nil {
+		return false, fmt.Errorf("error reading %s", filepath.Join(path, name, ".git"))
+	}
+
+	cmd := passToGit(filepath.Join(path, name), "fetch")
+	cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
+	_, stderr, err := capture(cmd)
+	if err != nil {
+		return false, fmt.Errorf("error fetching %s: %s", name, stderr)
+	}
+
+	return false, nil
+}
+
+func gitMerge(path string, name string) error {
+	_, stderr, err := capture(passToGit(filepath.Join(path, name), "reset", "--hard", "HEAD"))
+	if err != nil {
+		return fmt.Errorf("error resetting %s: %s", name, stderr)
+	}
+
+	_, stderr, err = capture(passToGit(filepath.Join(path, name), "merge", "--no-edit", "--ff"))
+	if err != nil {
+		return fmt.Errorf("error merging %s: %s", name, stderr)
+	}
+
+	return nil
+}
+
+func getPkgbuilds(pkgs []string) error {
+	missing := false
+	wd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	pkgs = removeInvalidTargets(pkgs)
+	aur, repo, err := packageSlices(pkgs)
+
+	if err != nil {
+		return err
+	}
+
+	for n := range aur {
+		_, pkg := splitDBFromName(aur[n])
+		aur[n] = pkg
+	}
+
+	info, err := aurInfoPrint(aur)
+	if err != nil {
+		return err
+	}
+
+	if len(repo) > 0 {
+		missing, err = getPkgbuildsfromABS(repo, wd)
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(aur) > 0 {
+		allBases := getBases(info)
+		bases := make([]Base, 0)
+
+		for _, base := range allBases {
+			name := base.Pkgbase()
+			_, err = os.Stat(filepath.Join(wd, name))
+			switch {
+			case err != nil && !os.IsNotExist(err):
+				fmt.Fprintln(os.Stderr, bold(red(smallArrow)), err)
+				continue
+			default:
+				if err = os.RemoveAll(filepath.Join(wd, name)); err != nil {
+					fmt.Fprintln(os.Stderr, bold(red(smallArrow)), err)
+					continue
+				}
+			}
+
+			bases = append(bases, base)
+		}
+
+		if _, err = downloadPkgbuilds(bases, nil, wd); err != nil {
+			return err
+		}
+
+		missing = missing || len(aur) != len(info)
+	}
+
+	if missing {
+		err = fmt.Errorf("")
+	}
+
+	return err
+}
+
+// GetPkgbuild downloads pkgbuild from the ABS.
+func getPkgbuildsfromABS(pkgs []string, path string) (bool, error) {
+	var wg sync.WaitGroup
+	var mux sync.Mutex
+	var errs multierror.MultiError
+	names := make(map[string]string)
+	missing := make([]string, 0)
+	downloaded := 0
+
+	dbList, err := alpmHandle.SyncDBs()
+	if err != nil {
+		return false, err
+	}
+
+	for _, pkgN := range pkgs {
+		var pkg *alpm.Package
+		var err error
+		var url string
+		pkgDB, name := splitDBFromName(pkgN)
+
+		if pkgDB != "" {
+			if db, err := alpmHandle.SyncDBByName(pkgDB); err == nil {
+				pkg = db.Pkg(name)
+			}
+		} else {
+			_ = dbList.ForEach(func(db alpm.DB) error {
+				if pkg = db.Pkg(name); pkg != nil {
+					return fmt.Errorf("")
+				}
+				return nil
+			})
+		}
+
+		if pkg == nil {
+			missing = append(missing, name)
+			continue
+		}
+
+		name = pkg.Base()
+		if name == "" {
+			name = pkg.Name()
+		}
+
+		// TODO: Check existence with ls-remote
+		// https://git.archlinux.org/svntogit/packages.git
+		switch pkg.DB().Name() {
+		case "core", "extra", "testing":
+			url = "https://git.archlinux.org/svntogit/packages.git"
+		case "community", "multilib", "community-testing", "multilib-testing":
+			url = "https://git.archlinux.org/svntogit/community.git"
+		default:
+			missing = append(missing, name)
+			continue
+		}
+
+		_, err = os.Stat(filepath.Join(path, name))
+		switch {
+		case err != nil && !os.IsNotExist(err):
+			fmt.Fprintln(os.Stderr, bold(red(smallArrow)), err)
+			continue
+		case os.IsNotExist(err), cmdArgs.existsArg("f", "force"):
+			if err = os.RemoveAll(filepath.Join(path, name)); err != nil {
+				fmt.Fprintln(os.Stderr, bold(red(smallArrow)), err)
+				continue
+			}
+		default:
+			fmt.Printf("%s %s %s\n", yellow(smallArrow), cyan(name), "already downloaded -- use -f to overwrite")
+			continue
+		}
+
+		names[name] = url
+	}
+
+	if len(missing) != 0 {
+		fmt.Println(yellow(bold(smallArrow)), "Missing ABS packages: ", cyan(strings.Join(missing, "  ")))
+	}
+
+	download := func(pkg string, url string) {
+		defer wg.Done()
+		if _, err := gitDownloadABS(url, config.ABSDir, pkg); err != nil {
+			errs.Add(fmt.Errorf("%s Failed to get pkgbuild: %s: %s", bold(red(arrow)), bold(cyan(pkg)), bold(red(err.Error()))))
+			return
+		}
+
+		_, stderr, err := capture(exec.Command("cp", "-r", filepath.Join(config.ABSDir, pkg, "trunk"), filepath.Join(path, pkg)))
+		mux.Lock()
+		downloaded++
+		if err != nil {
+			errs.Add(fmt.Errorf("%s Failed to link %s: %s", bold(red(arrow)), bold(cyan(pkg)), bold(red(stderr))))
+		} else {
+			fmt.Printf(bold(cyan("::"))+" Downloaded PKGBUILD from ABS (%d/%d): %s\n", downloaded, len(names), cyan(pkg))
+		}
+		mux.Unlock()
+	}
+
+	count := 0
+	for name, url := range names {
+		wg.Add(1)
+		go download(name, url)
+		count++
+		if count%25 == 0 {
+			wg.Wait()
+		}
+	}
+
+	wg.Wait()
+	return len(missing) != 0, errs.Return()
+}

errors.go

@@ -1,9 +0,0 @@
-package main
-
-import (
-	"errors"
-
-	"github.com/leonelquinteros/gotext"
-)
-
-var ErrPackagesNotFound = errors.New(gotext.Get("could not find all required packages"))

exec.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func show(cmd *exec.Cmd) error {
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
+	err := cmd.Run()
+	if err != nil {
+		return fmt.Errorf("")
+	}
+	return nil
+}
+
+func capture(cmd *exec.Cmd) (string, string, error) {
+	var outbuf, errbuf bytes.Buffer
+
+	cmd.Stdout = &outbuf
+	cmd.Stderr = &errbuf
+	err := cmd.Run()
+	stdout := strings.TrimSpace(outbuf.String())
+	stderr := strings.TrimSpace(errbuf.String())
+
+	return stdout, stderr, err
+}
+
+func sudoLoopBackground() {
+	updateSudo()
+	go sudoLoop()
+}
+
+func sudoLoop() {
+	for {
+		updateSudo()
+		time.Sleep(298 * time.Second)
+	}
+}
+
+func updateSudo() {
+	for {
+		mSudoFlags := strings.Fields(config.SudoFlags)
+		mSudoFlags = append([]string{"-v"}, mSudoFlags...)
+		err := show(exec.Command(config.SudoBin, mSudoFlags...))
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		} else {
+			break
+		}
+	}
+}
+
+// waitLock will lock yay checking the status of db.lck until it does not exist
+func waitLock() {
+	if _, err := os.Stat(filepath.Join(pacmanConf.DBPath, "db.lck")); err != nil {
+		return
+	}
+
+	fmt.Println(bold(yellow(smallArrow)), filepath.Join(pacmanConf.DBPath, "db.lck"), "is present.")
+
+	fmt.Print(bold(yellow(smallArrow)), " There may be another Pacman instance running. Waiting...")
+
+	for {
+		time.Sleep(3 * time.Second)
+		if _, err := os.Stat(filepath.Join(pacmanConf.DBPath, "db.lck")); err != nil {
+			fmt.Println()
+			return
+		}
+	}
+}
+
+func passToPacman(args *arguments) *exec.Cmd {
+	argArr := make([]string, 0)
+
+	mSudoFlags := strings.Fields(config.SudoFlags)
+
+	if args.needRoot() {
+		argArr = append(argArr, config.SudoBin)
+		argArr = append(argArr, mSudoFlags...)
+	}
+
+	argArr = append(argArr, config.PacmanBin)
+	argArr = append(argArr, cmdArgs.formatGlobals()...)
+	argArr = append(argArr, args.formatArgs()...)
+	if config.NoConfirm {
+		argArr = append(argArr, "--noconfirm")
+	}
+
+	argArr = append(argArr, "--config", config.PacmanConf)
+	argArr = append(argArr, "--")
+	argArr = append(argArr, args.targets...)
+
+	if args.needRoot() {
+		waitLock()
+	}
+	return exec.Command(argArr[0], argArr[1:]...)
+}
+
+func passToMakepkg(dir string, args ...string) *exec.Cmd {
+	mflags := strings.Fields(config.MFlags)
+	args = append(args, mflags...)
+
+	if config.MakepkgConf != "" {
+		args = append(args, "--config", config.MakepkgConf)
+	}
+
+	cmd := exec.Command(config.MakepkgBin, args...)
+	cmd.Dir = dir
+	return cmd
+}
+
+func passToGit(dir string, _args ...string) *exec.Cmd {
+	gitflags := strings.Fields(config.GitFlags)
+	args := []string{"-C", dir}
+	args = append(args, gitflags...)
+	args = append(args, _args...)
+
+	cmd := exec.Command(config.GitBin, args...)
+	return cmd
+}
+
+func isTty() bool {
+	cmd := exec.Command("test", "-t", "1")
+	cmd.Stdout = os.Stdout
+	err := cmd.Run()
+	return err == nil
+}

get.go

@@ -1,80 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"os"
-	"strings"
-
-	"github.com/Jguer/aur"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/download"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-// yay -Gp.
-func printPkgbuilds(dbExecutor download.DBSearcher, aurClient aur.QueryClient,
-	httpClient *http.Client, logger *text.Logger, targets []string,
-	mode parser.TargetMode, aurURL string,
-) error {
-	pkgbuilds, err := download.PKGBUILDs(dbExecutor, aurClient, httpClient, logger, targets, aurURL, mode)
-	if err != nil {
-		logger.Errorln(err)
-	}
-
-	for target, pkgbuild := range pkgbuilds {
-		logger.Printf("\n\n# %s\n\n%s", target, string(pkgbuild))
-	}
-
-	if len(pkgbuilds) != len(targets) {
-		missing := []string{}
-
-		for _, target := range targets {
-			if _, ok := pkgbuilds[target]; !ok {
-				missing = append(missing, target)
-			}
-		}
-
-		logger.Warnln(gotext.Get("Unable to find the following packages:"), " ", strings.Join(missing, ", "))
-
-		return fmt.Errorf("")
-	}
-
-	return nil
-}
-
-// yay -G.
-func getPkgbuilds(ctx context.Context, dbExecutor download.DBSearcher, aurClient aur.QueryClient,
-	run *runtime.Runtime, targets []string, force bool,
-) error {
-	wd, err := os.Getwd()
-	if err != nil {
-		return err
-	}
-
-	cloned, errD := download.PKGBUILDRepos(ctx, dbExecutor, aurClient,
-		run.CmdBuilder, run.Logger, targets, run.Cfg.Mode, run.Cfg.AURURL, wd, force)
-	if errD != nil {
-		run.Logger.Errorln(errD)
-	}
-
-	if len(targets) != len(cloned) {
-		missing := []string{}
-
-		for _, target := range targets {
-			if _, ok := cloned[target]; !ok {
-				missing = append(missing, target)
-			}
-		}
-
-		run.Logger.Warnln(gotext.Get("Unable to find the following packages:"), " ", strings.Join(missing, ", "))
-
-		err = fmt.Errorf("")
-	}
-
-	return err
-}

go.mod

@@ -1,35 +1,10 @@
-module github.com/Jguer/yay/v12
+module github.com/Jguer/yay/v9
 
 require (
-	github.com/Jguer/aur v1.2.3
-	github.com/Jguer/go-alpm/v2 v2.2.2
-	github.com/Jguer/votar v1.0.0
-	github.com/Morganamilo/go-pacmanconf v0.0.0-20210502114700-cff030e927a5
+	github.com/Jguer/go-alpm v0.0.0-20191122171459-5cffc6e8fc69
+	github.com/Morganamilo/go-pacmanconf v0.0.0-20180910220353-9c5265e1b14f
 	github.com/Morganamilo/go-srcinfo v1.0.0
-	github.com/adrg/strutil v0.3.1
-	github.com/bradleyjkemp/cupaloy v2.3.0+incompatible
-	github.com/deckarep/golang-set/v2 v2.8.0
-	github.com/hashicorp/go-multierror v1.1.1
-	github.com/leonelquinteros/gotext v1.7.2
-	github.com/stretchr/testify v1.10.0
-	golang.org/x/net v0.41.0
-	golang.org/x/sys v0.33.0
-	golang.org/x/term v0.32.0
-	gopkg.in/h2non/gock.v1 v1.1.2
+	github.com/mikkeloscar/aur v0.0.0-20200113170522-1cb4e2949656
 )
 
-require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/itchyny/gojq v0.12.17 // indirect
-	github.com/itchyny/timefmt-go v0.1.6 // indirect
-	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/ohler55/ojg v1.26.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)
-
-go 1.23.5
-
-toolchain go1.24.0
+go 1.13

go.sum

@@ -1,68 +1,8 @@
-github.com/Jguer/aur v1.2.3 h1:D+OGgLxnAnZnw88DsRvnRQsn0Poxsy9ng7pBcsA0krM=
-github.com/Jguer/aur v1.2.3/go.mod h1:Dahvb6L1yr0rR7svyYSDwaRJoQMeyvJblwJ3QH/7CUs=
-github.com/Jguer/go-alpm/v2 v2.2.2 h1:sPwUoZp1X5Tw6K6Ba1lWvVJfcgVNEGVcxARLBttZnC0=
-github.com/Jguer/go-alpm/v2 v2.2.2/go.mod h1:lfe8gSe83F/KERaQvEfrSqQ4n+8bES+ZIyKWR/gm3MI=
-github.com/Jguer/votar v1.0.0 h1:drPYpV5Py5BeAQS8xezmT6uCEfLzotNjLf5yfmlHKTg=
-github.com/Jguer/votar v1.0.0/go.mod h1:rc6vgVlTqNjI4nAnPbDTbdxw/N7kXkbB8BcUDjeFbYQ=
-github.com/Morganamilo/go-pacmanconf v0.0.0-20210502114700-cff030e927a5 h1:TMscPjkb1ThXN32LuFY5bEYIcXZx3YlwzhS1GxNpn/c=
-github.com/Morganamilo/go-pacmanconf v0.0.0-20210502114700-cff030e927a5/go.mod h1:Hk55m330jNiwxRodIlMCvw5iEyoRUCIY64W1p9D+tHc=
+github.com/Jguer/go-alpm v0.0.0-20191122171459-5cffc6e8fc69 h1:eNGutt8eUr37crjH7Wpvg5rTNk71hoBEXUpyJA0oheU=
+github.com/Jguer/go-alpm v0.0.0-20191122171459-5cffc6e8fc69/go.mod h1:D5SUcIS9Yiz/L8cjRzq/992eERnx6ugYmGlc4e7xdus=
+github.com/Morganamilo/go-pacmanconf v0.0.0-20180910220353-9c5265e1b14f h1:ptFKynTV1p8JCzqk81NcMj0DV0Xle+PdKxfHjPbdIOU=
+github.com/Morganamilo/go-pacmanconf v0.0.0-20180910220353-9c5265e1b14f/go.mod h1:Hk55m330jNiwxRodIlMCvw5iEyoRUCIY64W1p9D+tHc=
 github.com/Morganamilo/go-srcinfo v1.0.0 h1:Wh4nEF+HJWo+29hnxM18Q2hi+DUf0GejS13+Wg+dzmI=
 github.com/Morganamilo/go-srcinfo v1.0.0/go.mod h1:MP6VGY1NNpVUmYIEgoM9acix95KQqIRyqQ0hCLsyYUY=
-github.com/adrg/strutil v0.3.1 h1:OLvSS7CSJO8lBii4YmBt8jiK9QOtB9CzCzwl4Ic/Fz4=
-github.com/adrg/strutil v0.3.1/go.mod h1:8h90y18QLrs11IBffcGX3NW/GFBXCMcNg4M7H6MspPA=
-github.com/alexflint/go-arg v1.4.3/go.mod h1:3PZ/wp/8HuqRZMUUgu7I+e1qcpUbvmS258mRXkFH4IA=
-github.com/alexflint/go-scalar v1.1.0/go.mod h1:LoFvNMqS1CPrMVltza4LvnGKhaSpc3oyLEBUZVhhS2o=
-github.com/bradleyjkemp/cupaloy v2.3.0+incompatible h1:UafIjBvWQmS9i/xRg+CamMrnLTKNzo+bdmT/oH34c2Y=
-github.com/bradleyjkemp/cupaloy v2.3.0+incompatible/go.mod h1:Au1Xw1sgaJ5iSFktEhYsS0dbQiS1B0/XMXl+42y9Ilk=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/deckarep/golang-set/v2 v2.8.0 h1:swm0rlPCmdWn9mESxKOjWk8hXSqoxOp+ZlfuyaAdFlQ=
-github.com/deckarep/golang-set/v2 v2.8.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
-github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 h1:2VTzZjLZBgl62/EtslCrtky5vbi9dd7HrQPQIx6wqiw=
-github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542/go.mod h1:Ow0tF8D4Kplbc8s8sSb3V2oUCygFHVp8gC3Dn6U4MNI=
-github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
-github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
-github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
-github.com/itchyny/gojq v0.12.17 h1:8av8eGduDb5+rvEdaOO+zQUjA04MS0m3Ps8HiD+fceg=
-github.com/itchyny/gojq v0.12.17/go.mod h1:WBrEMkgAfAGO1LUcGOckBl5O726KPp+OlkKug0I/FEY=
-github.com/itchyny/timefmt-go v0.1.6 h1:ia3s54iciXDdzWzwaVKXZPbiXzxxnv1SPGFfM/myJ5Q=
-github.com/itchyny/timefmt-go v0.1.6/go.mod h1:RRDZYC5s9ErkjQvTvvU7keJjxUYzIISJGxm9/mAERQg=
-github.com/leonelquinteros/gotext v1.7.2 h1:bDPndU8nt+/kRo1m4l/1OXiiy2v7Z7dfPQ9+YP7G1Mc=
-github.com/leonelquinteros/gotext v1.7.2/go.mod h1:9/haCkm5P7Jay1sxKDGJ5WIg4zkz8oZKw4ekNpALob8=
-github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
-github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32 h1:W6apQkHrMkS0Muv8G/TipAy/FJl/rCYT0+EuS8+Z0z4=
-github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
-github.com/ohler55/ojg v1.26.1 h1:J5TaLmVEuvnpVH7JMdT1QdbpJU545Yp6cKiCO4aQILc=
-github.com/ohler55/ojg v1.26.1/go.mod h1:gQhDVpQLqrmnd2eqGAvJtn+NfKoYJbe/A4Sj3/Vro4o=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/h2non/gock.v1 v1.1.2 h1:jBbHXgGBK/AoPVfJh5x4r/WxIrElvbLel8TCZkkZJoY=
-gopkg.in/h2non/gock.v1 v1.1.2/go.mod h1:n7UGz/ckNChHiK05rDoiC4MYSunEC/lyaUm2WWaDva0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+github.com/mikkeloscar/aur v0.0.0-20200113170522-1cb4e2949656 h1:j679+jxcDkCFblYk+I+G71HQTFxM3PacYbVCiYmhRhU=
+github.com/mikkeloscar/aur v0.0.0-20200113170522-1cb4e2949656/go.mod h1:nYOKcK8tIj69ZZ8uDOWoiT+L25NvlOQaraDqTec/idA=

keys.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	gosrc "github.com/Morganamilo/go-srcinfo"
+)
+
+// pgpKeySet maps a PGP key with a list of PKGBUILDs that require it.
+// This is similar to stringSet, used throughout the code.
+type pgpKeySet map[string][]Base
+
+func (set pgpKeySet) toSlice() []string {
+	slice := make([]string, 0, len(set))
+	for v := range set {
+		slice = append(slice, v)
+	}
+	return slice
+}
+
+func (set pgpKeySet) set(key string, p Base) {
+	// Using ToUpper to make sure keys with a different case will be
+	// considered the same.
+	upperKey := strings.ToUpper(key)
+	set[key] = append(set[upperKey], p)
+}
+
+func (set pgpKeySet) get(key string) bool {
+	upperKey := strings.ToUpper(key)
+	_, exists := set[upperKey]
+	return exists
+}
+
+// checkPgpKeys iterates through the keys listed in the PKGBUILDs and if needed,
+// asks the user whether yay should try to import them.
+func checkPgpKeys(bases []Base, srcinfos map[string]*gosrc.Srcinfo) error {
+	// Let's check the keys individually, and then we can offer to import
+	// the problematic ones.
+	problematic := make(pgpKeySet)
+	args := append(strings.Fields(config.GpgFlags), "--list-keys")
+
+	// Mapping all the keys.
+	for _, base := range bases {
+		pkg := base.Pkgbase()
+		srcinfo := srcinfos[pkg]
+
+		for _, key := range srcinfo.ValidPGPKeys {
+			// If key already marked as problematic, indicate the current
+			// PKGBUILD requires it.
+			if problematic.get(key) {
+				problematic.set(key, base)
+				continue
+			}
+
+			cmd := exec.Command(config.GpgBin, append(args, key)...)
+			err := cmd.Run()
+			if err != nil {
+				problematic.set(key, base)
+			}
+		}
+	}
+
+	// No key issues!
+	if len(problematic) == 0 {
+		return nil
+	}
+
+	str, err := formatKeysToImport(problematic)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println()
+	fmt.Println(str)
+
+	if continueTask(bold(green("Import?")), true) {
+		return importKeys(problematic.toSlice())
+	}
+
+	return nil
+}
+
+// importKeys tries to import the list of keys specified in its argument.
+func importKeys(keys []string) error {
+	args := append(strings.Fields(config.GpgFlags), "--recv-keys")
+	cmd := exec.Command(config.GpgBin, append(args, keys...)...)
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
+
+	fmt.Printf("%s %s...\n", bold(cyan("::")), bold("Importing keys with gpg..."))
+	err := cmd.Run()
+
+	if err != nil {
+		return fmt.Errorf("%s Problem importing keys", bold(red(arrow+" Error:")))
+	}
+	return nil
+}
+
+// formatKeysToImport receives a set of keys and returns a string containing the
+// question asking the user wants to import the problematic keys.
+func formatKeysToImport(keys pgpKeySet) (string, error) {
+	if len(keys) == 0 {
+		return "", fmt.Errorf("%s No keys to import", bold(red(arrow+" Error:")))
+	}
+
+	var buffer bytes.Buffer
+	buffer.WriteString(bold(green(arrow)))
+	buffer.WriteString(bold(green(" PGP keys need importing:")))
+	for key, bases := range keys {
+		pkglist := ""
+		for _, base := range bases {
+			pkglist += base.String() + "  "
+		}
+		pkglist = strings.TrimRight(pkglist, " ")
+		buffer.WriteString(fmt.Sprintf("\n%s %s, required by: %s", yellow(bold(smallArrow)), cyan(key), cyan(pkglist)))
+	}
+	return buffer.String(), nil
+}

keys_test.go

@@ -0,0 +1,234 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path"
+	"regexp"
+	"testing"
+
+	gosrc "github.com/Morganamilo/go-srcinfo"
+	rpc "github.com/mikkeloscar/aur"
+)
+
+const (
+	// The default port used by the PGP key server.
+	gpgServerPort = 11371
+)
+
+func init() {
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		regex := regexp.MustCompile(`search=0[xX]([a-fA-F0-9]+)`)
+		matches := regex.FindStringSubmatch(r.RequestURI)
+		data := ""
+		if matches != nil {
+			data = getPgpKey(matches[1])
+		}
+		w.Header().Set("Content-Type", "application/pgp-keys")
+		_, err := w.Write([]byte(data))
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	})
+}
+
+func newPkg(basename string) *rpc.Pkg {
+	return &rpc.Pkg{Name: basename, PackageBase: basename}
+}
+
+func getPgpKey(key string) string {
+	var buffer bytes.Buffer
+
+	if contents, err := ioutil.ReadFile(path.Join("testdata", "keys", key)); err == nil {
+		buffer.WriteString("-----BEGIN PGP PUBLIC KEY BLOCK-----\n")
+		buffer.WriteString("Version: SKS 1.1.6\n")
+		buffer.WriteString("Comment: Hostname: yay\n\n")
+		buffer.Write(contents)
+		buffer.WriteString("\n-----END PGP PUBLIC KEY BLOCK-----\n")
+	}
+	return buffer.String()
+}
+
+func startPgpKeyServer() *http.Server {
+	srv := &http.Server{Addr: fmt.Sprintf("127.0.0.1:%d", gpgServerPort)}
+
+	go func() {
+		err := srv.ListenAndServe()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}()
+	return srv
+}
+
+func TestImportKeys(t *testing.T) {
+	keyringDir, err := ioutil.TempDir("/tmp", "yay-test-keyring")
+	if err != nil {
+		t.Fatalf("Unable to init test keyring %q: %v\n", keyringDir, err)
+	}
+	defer os.RemoveAll(keyringDir)
+
+	config.GpgBin = "gpg"
+	config.GpgFlags = fmt.Sprintf("--homedir %s --keyserver 127.0.0.1", keyringDir)
+
+	server := startPgpKeyServer()
+	defer func() {
+		err := server.Shutdown(context.TODO())
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}()
+
+	casetests := []struct {
+		keys      []string
+		wantError bool
+	}{
+		// Single key, should succeed.
+		// C52048C0C0748FEE227D47A2702353E0F7E48EDB: Thomas Dickey.
+		{
+			keys:      []string{"C52048C0C0748FEE227D47A2702353E0F7E48EDB"},
+			wantError: false,
+		},
+		// Two keys, should succeed as well.
+		// 11E521D646982372EB577A1F8F0871F202119294: Tom Stellard.
+		// B6C8F98282B944E3B0D5C2530FC3042E345AD05D: Hans Wennborg.
+		{
+			keys: []string{"11E521D646982372EB577A1F8F0871F202119294",
+				"B6C8F98282B944E3B0D5C2530FC3042E345AD05D"},
+			wantError: false,
+		},
+		// Single invalid key, should fail.
+		{
+			keys:      []string{"THIS-SHOULD-FAIL"},
+			wantError: true,
+		},
+		// Two invalid keys, should fail.
+		{
+			keys:      []string{"THIS-SHOULD-FAIL", "THIS-ONE-SHOULD-FAIL-TOO"},
+			wantError: true,
+		},
+		// Invalid + valid key. Should fail as well.
+		// 647F28654894E3BD457199BE38DBBDC86092693E: Greg Kroah-Hartman.
+		{
+			keys: []string{"THIS-SHOULD-FAIL",
+				"647F28654894E3BD457199BE38DBBDC86092693E"},
+			wantError: true,
+		},
+	}
+
+	for _, tt := range casetests {
+		err := importKeys(tt.keys)
+		if !tt.wantError {
+			if err != nil {
+				t.Fatalf("Got error %q, want no error", err)
+			}
+			continue
+		}
+		// Here, we want to see the error.
+		if err == nil {
+			t.Fatalf("Got no error; want error")
+		}
+	}
+}
+
+func makeSrcinfo(pkgbase string, pgpkeys ...string) *gosrc.Srcinfo {
+	srcinfo := gosrc.Srcinfo{}
+	srcinfo.Pkgbase = pkgbase
+	srcinfo.ValidPGPKeys = pgpkeys
+
+	return &srcinfo
+}
+
+func TestCheckPgpKeys(t *testing.T) {
+	keyringDir, err := ioutil.TempDir("/tmp", "yay-test-keyring")
+	if err != nil {
+		t.Fatalf("Unable to init test keyring: %v\n", err)
+	}
+	defer os.RemoveAll(keyringDir)
+
+	config.GpgBin = "gpg"
+	config.GpgFlags = fmt.Sprintf("--homedir %s --keyserver 127.0.0.1", keyringDir)
+
+	server := startPgpKeyServer()
+	defer func() {
+		err := server.Shutdown(context.TODO())
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}()
+
+	casetests := []struct {
+		pkgs      Base
+		srcinfos  map[string]*gosrc.Srcinfo
+		wantError bool
+	}{
+		// cower: single package, one valid key not yet in the keyring.
+		// 487EACC08557AD082088DABA1EB2638FF56C0C53: Dave Reisner.
+		{
+			pkgs:      Base{newPkg("cower")},
+			srcinfos:  map[string]*gosrc.Srcinfo{"cower": makeSrcinfo("cower", "487EACC08557AD082088DABA1EB2638FF56C0C53")},
+			wantError: false,
+		},
+		// libc++: single package, two valid keys not yet in the keyring.
+		// 11E521D646982372EB577A1F8F0871F202119294: Tom Stellard.
+		// B6C8F98282B944E3B0D5C2530FC3042E345AD05D: Hans Wennborg.
+		{
+			pkgs:      Base{newPkg("libc++")},
+			srcinfos:  map[string]*gosrc.Srcinfo{"libc++": makeSrcinfo("libc++", "11E521D646982372EB577A1F8F0871F202119294", "B6C8F98282B944E3B0D5C2530FC3042E345AD05D")},
+			wantError: false,
+		},
+		// Two dummy packages requiring the same key.
+		// ABAF11C65A2970B130ABE3C479BE3E4300411886: Linus Torvalds.
+		{
+			pkgs:      Base{newPkg("dummy-1"), newPkg("dummy-2")},
+			srcinfos:  map[string]*gosrc.Srcinfo{"dummy-1": makeSrcinfo("dummy-1", "ABAF11C65A2970B130ABE3C479BE3E4300411886"), "dummy-2": makeSrcinfo("dummy-2", "ABAF11C65A2970B130ABE3C479BE3E4300411886")},
+			wantError: false,
+		},
+		// dummy package: single package, two valid keys, one of them already
+		// in the keyring.
+		// 11E521D646982372EB577A1F8F0871F202119294: Tom Stellard.
+		// C52048C0C0748FEE227D47A2702353E0F7E48EDB: Thomas Dickey.
+		{
+			pkgs:      Base{newPkg("dummy-3")},
+			srcinfos:  map[string]*gosrc.Srcinfo{"dummy-3": makeSrcinfo("dummy-3", "11E521D646982372EB577A1F8F0871F202119294", "C52048C0C0748FEE227D47A2702353E0F7E48EDB")},
+			wantError: false,
+		},
+		// Two dummy packages with existing keys.
+		{
+			pkgs:      Base{newPkg("dummy-4"), newPkg("dummy-5")},
+			srcinfos:  map[string]*gosrc.Srcinfo{"dummy-4": makeSrcinfo("dummy-4", "11E521D646982372EB577A1F8F0871F202119294"), "dummy-5": makeSrcinfo("dummy-5", "C52048C0C0748FEE227D47A2702353E0F7E48EDB")},
+			wantError: false,
+		},
+		// Dummy package with invalid key, should fail.
+		{
+			pkgs:      Base{newPkg("dummy-7")},
+			srcinfos:  map[string]*gosrc.Srcinfo{"dummy-7": makeSrcinfo("dummy-7", "THIS-SHOULD-FAIL")},
+			wantError: true,
+		},
+		// Dummy package with both an invalid an another valid key, should fail.
+		// A314827C4E4250A204CE6E13284FC34C8E4B1A25: Thomas Bächler.
+		{
+			pkgs:      Base{newPkg("dummy-8")},
+			srcinfos:  map[string]*gosrc.Srcinfo{"dummy-8": makeSrcinfo("dummy-8", "A314827C4E4250A204CE6E13284FC34C8E4B1A25", "THIS-SHOULD-FAIL")},
+			wantError: true,
+		},
+	}
+
+	for _, tt := range casetests {
+		err := checkPgpKeys([]Base{tt.pkgs}, tt.srcinfos)
+		if !tt.wantError {
+			if err != nil {
+				t.Fatalf("Got error %q, want no error", err)
+			}
+			continue
+		}
+		// Here, we want to see the error.
+		if err == nil {
+			t.Fatalf("Got no error; want error")
+		}
+	}
+}

local_install.go

@@ -1,108 +0,0 @@
-// Experimental code for install local with dependency refactoring
-// Not at feature parity with install.go
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/dep"
-	"github.com/Jguer/yay/v12/pkg/multierror"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/sync"
-
-	gosrc "github.com/Morganamilo/go-srcinfo"
-	"github.com/leonelquinteros/gotext"
-)
-
-var ErrNoBuildFiles = errors.New(gotext.Get("cannot find PKGBUILD and .SRCINFO in directory"))
-
-func srcinfoExists(ctx context.Context,
-	cmdBuilder exe.ICmdBuilder, targetDir string,
-) error {
-	srcInfoDir := filepath.Join(targetDir, ".SRCINFO")
-	pkgbuildDir := filepath.Join(targetDir, "PKGBUILD")
-	if _, err := os.Stat(srcInfoDir); err == nil {
-		if _, err := os.Stat(pkgbuildDir); err == nil {
-			return nil
-		}
-	}
-
-	if _, err := os.Stat(pkgbuildDir); err == nil {
-		// run makepkg to generate .SRCINFO
-		srcinfo, stderr, err := cmdBuilder.Capture(cmdBuilder.BuildMakepkgCmd(ctx, targetDir, "--printsrcinfo"))
-		if err != nil {
-			return fmt.Errorf("unable to generate .SRCINFO: %w - %s", err, stderr)
-		}
-
-		if srcinfo == "" {
-			return fmt.Errorf("generated .SRCINFO is empty, check your PKGBUILD for errors")
-		}
-
-		if err := os.WriteFile(srcInfoDir, []byte(srcinfo), 0o600); err != nil {
-			return fmt.Errorf("unable to write .SRCINFO: %w", err)
-		}
-
-		return nil
-	}
-
-	return fmt.Errorf("%w: %s", ErrNoBuildFiles, targetDir)
-}
-
-func installLocalPKGBUILD(
-	ctx context.Context,
-	run *runtime.Runtime,
-	cmdArgs *parser.Arguments,
-	dbExecutor db.Executor,
-) error {
-	aurCache := run.AURClient
-	noCheck := strings.Contains(run.Cfg.MFlags, "--nocheck")
-
-	if len(cmdArgs.Targets) < 1 {
-		return errors.New(gotext.Get("no target directories specified"))
-	}
-
-	srcInfos := map[string]*gosrc.Srcinfo{}
-	for _, targetDir := range cmdArgs.Targets {
-		if err := srcinfoExists(ctx, run.CmdBuilder, targetDir); err != nil {
-			return err
-		}
-
-		pkgbuild, err := gosrc.ParseFile(filepath.Join(targetDir, ".SRCINFO"))
-		if err != nil {
-			return fmt.Errorf("%s: %w", gotext.Get("failed to parse .SRCINFO"), err)
-		}
-
-		srcInfos[targetDir] = pkgbuild
-	}
-
-	grapher := dep.NewGrapher(dbExecutor, aurCache, false, settings.NoConfirm,
-		cmdArgs.ExistsDouble("d", "nodeps"), noCheck, cmdArgs.ExistsArg("needed"),
-		run.Logger.Child("grapher"))
-	graph, err := grapher.GraphFromSrcInfos(ctx, nil, srcInfos)
-	if err != nil {
-		return err
-	}
-
-	opService := sync.NewOperationService(ctx, dbExecutor, run)
-	multiErr := &multierror.MultiError{}
-	targets := graph.TopoSortedLayerMap(func(name string, ii *dep.InstallInfo) error {
-		if ii.Source == dep.Missing {
-			multiErr.Add(fmt.Errorf("%w: %s %s", ErrPackagesNotFound, name, ii.Version))
-		}
-		return nil
-	})
-
-	if err := multiErr.Return(); err != nil {
-		return err
-	}
-	return opService.Run(ctx, run, cmdArgs, targets, []string{})
-}

main.go

@@ -1,154 +1,233 @@
 package main // import "github.com/Jguer/yay"
 
 import (
-	"context"
-	"errors"
+	"encoding/json"
+	"fmt"
 	"os"
-	"os/exec"
-	"runtime/debug"
+	"path/filepath"
 	"strings"
 
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/db/ialpm"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/text"
+	alpm "github.com/Jguer/go-alpm"
+	pacmanconf "github.com/Morganamilo/go-pacmanconf"
 )
 
-var (
-	yayVersion = "12.0.4"            // To be set by compiler.
-	localePath = "/usr/share/locale" // To be set by compiler.
-)
-
-func initGotext() {
-	if envLocalePath := os.Getenv("LOCALE_PATH"); envLocalePath != "" {
-		localePath = envLocalePath
-	}
-
-	if lc := os.Getenv("LANGUAGE"); lc != "" {
-		// Split LANGUAGE by ':' and prioritize the first locale
-		// Should fix in gotext to support this
-		locales := strings.Split(lc, ":")
-		if len(locales) > 0 && locales[0] != "" {
-			gotext.Configure(localePath, locales[0], "yay")
-		}
-	} else if lc := os.Getenv("LC_ALL"); lc != "" {
-		gotext.Configure(localePath, lc, "yay")
-	} else if lc := os.Getenv("LC_MESSAGES"); lc != "" {
-		gotext.Configure(localePath, lc, "yay")
+func setPaths() error {
+	if configHome = os.Getenv("XDG_CONFIG_HOME"); configHome != "" {
+		configHome = filepath.Join(configHome, "yay")
+	} else if configHome = os.Getenv("HOME"); configHome != "" {
+		configHome = filepath.Join(configHome, ".config/yay")
 	} else {
-		gotext.Configure(localePath, os.Getenv("LANG"), "yay")
+		return fmt.Errorf("XDG_CONFIG_HOME and HOME unset")
 	}
+
+	if cacheHome = os.Getenv("XDG_CACHE_HOME"); cacheHome != "" {
+		cacheHome = filepath.Join(cacheHome, "yay")
+	} else if cacheHome = os.Getenv("HOME"); cacheHome != "" {
+		cacheHome = filepath.Join(cacheHome, ".cache/yay")
+	} else {
+		return fmt.Errorf("XDG_CACHE_HOME and HOME unset")
+	}
+
+	configFile = filepath.Join(configHome, configFileName)
+	vcsFile = filepath.Join(cacheHome, vcsFileName)
+
+	return nil
+}
+
+func initConfig() error {
+	cfile, err := os.Open(configFile)
+	if !os.IsNotExist(err) && err != nil {
+		return fmt.Errorf("Failed to open config file '%s': %s", configFile, err)
+	}
+
+	defer cfile.Close()
+	if !os.IsNotExist(err) {
+		decoder := json.NewDecoder(cfile)
+		if err = decoder.Decode(&config); err != nil {
+			return fmt.Errorf("Failed to read config '%s': %s", configFile, err)
+		}
+	}
+
+	aurdest := os.Getenv("AURDEST")
+	if aurdest != "" {
+		config.BuildDir = aurdest
+	}
+
+	return nil
+}
+
+func initVCS() error {
+	vfile, err := os.Open(vcsFile)
+	if !os.IsNotExist(err) && err != nil {
+		return fmt.Errorf("Failed to open vcs file '%s': %s", vcsFile, err)
+	}
+
+	defer vfile.Close()
+	if !os.IsNotExist(err) {
+		decoder := json.NewDecoder(vfile)
+		if err = decoder.Decode(&savedInfo); err != nil {
+			return fmt.Errorf("Failed to read vcs '%s': %s", vcsFile, err)
+		}
+	}
+
+	return nil
+}
+
+func initHomeDirs() error {
+	if _, err := os.Stat(configHome); os.IsNotExist(err) {
+		if err = os.MkdirAll(configHome, 0755); err != nil {
+			return fmt.Errorf("Failed to create config directory '%s': %s", configHome, err)
+		}
+	} else if err != nil {
+		return err
+	}
+
+	if _, err := os.Stat(cacheHome); os.IsNotExist(err) {
+		if err = os.MkdirAll(cacheHome, 0755); err != nil {
+			return fmt.Errorf("Failed to create cache directory '%s': %s", cacheHome, err)
+		}
+	} else if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func initBuildDir() error {
+	if _, err := os.Stat(config.BuildDir); os.IsNotExist(err) {
+		if err = os.MkdirAll(config.BuildDir, 0755); err != nil {
+			return fmt.Errorf("Failed to create BuildDir directory '%s': %s", config.BuildDir, err)
+		}
+	} else if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func initAlpm() error {
+	var err error
+	var stderr string
+
+	root := "/"
+	if value, _, exists := cmdArgs.getArg("root", "r"); exists {
+		root = value
+	}
+
+	pacmanConf, stderr, err = pacmanconf.PacmanConf("--config", config.PacmanConf, "--root", root)
+	if err != nil {
+		return fmt.Errorf("%s", stderr)
+	}
+
+	if value, _, exists := cmdArgs.getArg("dbpath", "b"); exists {
+		pacmanConf.DBPath = value
+	}
+
+	if value, _, exists := cmdArgs.getArg("arch"); exists {
+		pacmanConf.Architecture = value
+	}
+
+	if value, _, exists := cmdArgs.getArg("ignore"); exists {
+		pacmanConf.IgnorePkg = append(pacmanConf.IgnorePkg, strings.Split(value, ",")...)
+	}
+
+	if value, _, exists := cmdArgs.getArg("ignoregroup"); exists {
+		pacmanConf.IgnoreGroup = append(pacmanConf.IgnoreGroup, strings.Split(value, ",")...)
+	}
+
+	//TODO
+	//current system does not allow duplicate arguments
+	//but pacman allows multiple cachedirs to be passed
+	//for now only handle one cache dir
+	if value, _, exists := cmdArgs.getArg("cachedir"); exists {
+		pacmanConf.CacheDir = []string{value}
+	}
+
+	if value, _, exists := cmdArgs.getArg("gpgdir"); exists {
+		pacmanConf.GPGDir = value
+	}
+
+	if err := initAlpmHandle(); err != nil {
+		return err
+	}
+
+	switch value, _, _ := cmdArgs.getArg("color"); value {
+	case "always":
+		useColor = true
+	case "auto":
+		useColor = isTty()
+	case "never":
+		useColor = false
+	default:
+		useColor = pacmanConf.Color && isTty()
+	}
+
+	return nil
+}
+
+func initAlpmHandle() error {
+	var err error
+
+	if alpmHandle != nil {
+		if err := alpmHandle.Release(); err != nil {
+			return err
+		}
+	}
+
+	if alpmHandle, err = alpm.Initialize(pacmanConf.RootDir, pacmanConf.DBPath); err != nil {
+		return fmt.Errorf("Unable to CreateHandle: %s", err)
+	}
+
+	if err := configureAlpm(pacmanConf); err != nil {
+		return err
+	}
+
+	alpmHandle.SetQuestionCallback(questionCallback)
+	alpmHandle.SetLogCallback(logCallback)
+	return nil
+}
+
+func exitOnError(err error) {
+	if err != nil {
+		if str := err.Error(); str != "" {
+			fmt.Fprintln(os.Stderr, str)
+		}
+		cleanup()
+		os.Exit(1)
+	}
+}
+
+func cleanup() int {
+	if alpmHandle != nil {
+		if err := alpmHandle.Release(); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return 1
+		}
+	}
+
+	return 0
 }
 
 func main() {
-	fallbackLog := text.NewLogger(os.Stdout, os.Stderr, os.Stdin, false, "fallback")
-	var (
-		err error
-		ctx = context.Background()
-		ret = 0
-	)
-
-	defer func() {
-		if rec := recover(); rec != nil {
-			fallbackLog.Errorln("Panic occurred:", rec)
-			fallbackLog.Errorln("Stack trace:", string(debug.Stack()))
-			ret = 1
-		}
-
-		os.Exit(ret)
-	}()
-
-	initGotext()
-
 	if os.Geteuid() == 0 {
-		fallbackLog.Warnln(gotext.Get("Avoid running yay as root/sudo."))
+		fmt.Fprintln(os.Stderr, "Please avoid running yay as root/sudo.")
 	}
 
-	configPath := settings.GetConfigPath()
-	// Parse config
-	cfg, err := settings.NewConfig(fallbackLog, configPath, yayVersion)
-	if err != nil {
-		if str := err.Error(); str != "" {
-			fallbackLog.Errorln(str)
-		}
-
-		ret = 1
-
-		return
-	}
-
-	if errS := cfg.RunMigrations(fallbackLog,
-		settings.DefaultMigrations(), configPath, yayVersion); errS != nil {
-		fallbackLog.Errorln(errS)
-	}
-
-	cmdArgs := parser.MakeArguments()
-
-	// Parse command line
-	if err = cfg.ParseCommandLine(cmdArgs); err != nil {
-		if str := err.Error(); str != "" {
-			fallbackLog.Errorln(str)
-		}
-
-		ret = 1
-
-		return
-	}
-
-	if cfg.SaveConfig {
-		if errS := cfg.Save(configPath, yayVersion); errS != nil {
-			fallbackLog.Errorln(errS)
+	exitOnError(setPaths())
+	config = defaultSettings()
+	exitOnError(initHomeDirs())
+	exitOnError(initConfig())
+	exitOnError(cmdArgs.parseCommandLine())
+	if shouldSaveConfig {
+		err := config.saveConfig()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
 		}
 	}
-
-	// Build run
-	run, err := runtime.NewRuntime(cfg, cmdArgs, yayVersion)
-	if err != nil {
-		if str := err.Error(); str != "" {
-			fallbackLog.Errorln(str)
-		}
-
-		ret = 1
-
-		return
-	}
-
-	dbExecutor, err := ialpm.NewExecutor(run.PacmanConf, run.Logger.Child("db"))
-	if err != nil {
-		if str := err.Error(); str != "" {
-			fallbackLog.Errorln(str)
-		}
-
-		ret = 1
-
-		return
-	}
-
-	defer func() {
-		if rec := recover(); rec != nil {
-			fallbackLog.Errorln("Panic occurred in DB operation:", rec)
-			fallbackLog.Errorln("Stack trace:", string(debug.Stack()))
-		}
-
-		dbExecutor.Cleanup()
-	}()
-
-	if err = handleCmd(ctx, run, cmdArgs, dbExecutor); err != nil {
-		if str := err.Error(); str != "" {
-			fallbackLog.Errorln(str)
-		}
-
-		exitError := &exec.ExitError{}
-		if errors.As(err, &exitError) {
-			// mirror pacman exit code when applicable
-			ret = exitError.ExitCode()
-			return
-		}
-
-		// fallback
-		ret = 1
-	}
+	config.expandEnv()
+	exitOnError(initBuildDir())
+	exitOnError(initVCS())
+	exitOnError(initAlpm())
+	exitOnError(handleCmd())
+	os.Exit(cleanup())
 }

parser.go

@@ -0,0 +1,920 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"html"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/Jguer/yay/v9/pkg/stringset"
+	rpc "github.com/mikkeloscar/aur"
+)
+
+// Parses command line arguments in a way we can interact with programmatically but
+// also in a way that can easily be passed to pacman later on.
+type arguments struct {
+	op      string
+	options map[string]string
+	globals map[string]string
+	doubles stringset.StringSet // Tracks args passed twice such as -yy and -dd
+	targets []string
+}
+
+func makeArguments() *arguments {
+	return &arguments{
+		"",
+		make(map[string]string),
+		make(map[string]string),
+		make(stringset.StringSet),
+		make([]string, 0),
+	}
+}
+
+func (parser *arguments) copyGlobal() (cp *arguments) {
+	cp = makeArguments()
+	for k, v := range parser.globals {
+		cp.globals[k] = v
+	}
+
+	return
+}
+
+func (parser *arguments) copy() (cp *arguments) {
+	cp = makeArguments()
+
+	cp.op = parser.op
+
+	for k, v := range parser.options {
+		cp.options[k] = v
+	}
+
+	for k, v := range parser.globals {
+		cp.globals[k] = v
+	}
+
+	cp.targets = make([]string, len(parser.targets))
+	copy(cp.targets, parser.targets)
+
+	for k, v := range parser.doubles {
+		cp.doubles[k] = v
+	}
+
+	return
+}
+
+func (parser *arguments) delArg(options ...string) {
+	for _, option := range options {
+		delete(parser.options, option)
+		delete(parser.globals, option)
+		delete(parser.doubles, option)
+	}
+}
+
+func (parser *arguments) needRoot() bool {
+	if parser.existsArg("h", "help") {
+		return false
+	}
+
+	switch parser.op {
+	case "D", "database":
+		if parser.existsArg("k", "check") {
+			return false
+		}
+		return true
+	case "F", "files":
+		if parser.existsArg("y", "refresh") {
+			return true
+		}
+		return false
+	case "Q", "query":
+		if parser.existsArg("k", "check") {
+			return true
+		}
+		return false
+	case "R", "remove":
+		if parser.existsArg("p", "print", "print-format") {
+			return false
+		}
+		return true
+	case "S", "sync":
+		if parser.existsArg("y", "refresh") {
+			return true
+		}
+		if parser.existsArg("p", "print", "print-format") {
+			return false
+		}
+		if parser.existsArg("s", "search") {
+			return false
+		}
+		if parser.existsArg("l", "list") {
+			return false
+		}
+		if parser.existsArg("g", "groups") {
+			return false
+		}
+		if parser.existsArg("i", "info") {
+			return false
+		}
+		if parser.existsArg("c", "clean") && mode == modeAUR {
+			return false
+		}
+		return true
+	case "U", "upgrade":
+		return true
+	default:
+		return false
+	}
+}
+
+func (parser *arguments) addOP(op string) (err error) {
+	if parser.op != "" {
+		err = fmt.Errorf("only one operation may be used at a time")
+		return
+	}
+
+	parser.op = op
+	return
+}
+
+func (parser *arguments) addParam(option string, arg string) (err error) {
+	if !isArg(option) {
+		return fmt.Errorf("invalid option '%s'", option)
+	}
+
+	if isOp(option) {
+		err = parser.addOP(option)
+		return
+	}
+
+	switch {
+	case parser.existsArg(option):
+		parser.doubles[option] = struct{}{}
+	case isGlobal(option):
+		parser.globals[option] = arg
+	default:
+		parser.options[option] = arg
+	}
+
+	return
+}
+
+func (parser *arguments) addArg(options ...string) (err error) {
+	for _, option := range options {
+		err = parser.addParam(option, "")
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+// Multiple args acts as an OR operator
+func (parser *arguments) existsArg(options ...string) bool {
+	for _, option := range options {
+		_, exists := parser.options[option]
+		if exists {
+			return true
+		}
+
+		_, exists = parser.globals[option]
+		if exists {
+			return true
+		}
+	}
+	return false
+}
+
+func (parser *arguments) getArg(options ...string) (arg string, double bool, exists bool) {
+	existCount := 0
+
+	for _, option := range options {
+		var value string
+
+		value, exists = parser.options[option]
+
+		if exists {
+			arg = value
+			existCount++
+			_, exists = parser.doubles[option]
+
+			if exists {
+				existCount++
+			}
+
+		}
+
+		value, exists = parser.globals[option]
+
+		if exists {
+			arg = value
+			existCount++
+			_, exists = parser.doubles[option]
+
+			if exists {
+				existCount++
+			}
+
+		}
+	}
+
+	double = existCount >= 2
+	exists = existCount >= 1
+
+	return
+}
+
+func (parser *arguments) addTarget(targets ...string) {
+	parser.targets = append(parser.targets, targets...)
+}
+
+func (parser *arguments) clearTargets() {
+	parser.targets = make([]string, 0)
+}
+
+// Multiple args acts as an OR operator
+func (parser *arguments) existsDouble(options ...string) bool {
+	for _, option := range options {
+		_, exists := parser.doubles[option]
+		if exists {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (parser *arguments) formatArgs() (args []string) {
+	var op string
+
+	if parser.op != "" {
+		op = formatArg(parser.op)
+	}
+
+	args = append(args, op)
+
+	for option, arg := range parser.options {
+		if option == "--" {
+			continue
+		}
+
+		formattedOption := formatArg(option)
+		args = append(args, formattedOption)
+
+		if hasParam(option) {
+			args = append(args, arg)
+		}
+
+		if parser.existsDouble(option) {
+			args = append(args, formattedOption)
+		}
+	}
+
+	return
+}
+
+func (parser *arguments) formatGlobals() (args []string) {
+	for option, arg := range parser.globals {
+		formattedOption := formatArg(option)
+		args = append(args, formattedOption)
+
+		if hasParam(option) {
+			args = append(args, arg)
+		}
+
+		if parser.existsDouble(option) {
+			args = append(args, formattedOption)
+		}
+	}
+
+	return
+
+}
+
+func formatArg(arg string) string {
+	if len(arg) > 1 {
+		arg = "--" + arg
+	} else {
+		arg = "-" + arg
+	}
+
+	return arg
+}
+
+func isArg(arg string) bool {
+	switch arg {
+	case "-", "--":
+	case "ask":
+	case "D", "database":
+	case "Q", "query":
+	case "R", "remove":
+	case "S", "sync":
+	case "T", "deptest":
+	case "U", "upgrade":
+	case "F", "files":
+	case "V", "version":
+	case "h", "help":
+	case "Y", "yay":
+	case "P", "show":
+	case "G", "getpkgbuild":
+	case "b", "dbpath":
+	case "r", "root":
+	case "v", "verbose":
+	case "arch":
+	case "cachedir":
+	case "color":
+	case "config":
+	case "debug":
+	case "gpgdir":
+	case "hookdir":
+	case "logfile":
+	case "noconfirm":
+	case "confirm":
+	case "disable-download-timeout":
+	case "sysroot":
+	case "d", "nodeps":
+	case "assume-installed":
+	case "dbonly":
+	case "absdir":
+	case "noprogressbar":
+	case "noscriptlet":
+	case "p", "print":
+	case "print-format":
+	case "asdeps":
+	case "asexplicit":
+	case "ignore":
+	case "ignoregroup":
+	case "needed":
+	case "overwrite":
+	case "f", "force":
+	case "c", "changelog":
+	case "deps":
+	case "e", "explicit":
+	case "g", "groups":
+	case "i", "info":
+	case "k", "check":
+	case "l", "list":
+	case "m", "foreign":
+	case "n", "native":
+	case "o", "owns":
+	case "file":
+	case "q", "quiet":
+	case "s", "search":
+	case "t", "unrequired":
+	case "u", "upgrades":
+	case "cascade":
+	case "nosave":
+	case "recursive":
+	case "unneeded":
+	case "clean":
+	case "sysupgrade":
+	case "w", "downloadonly":
+	case "y", "refresh":
+	case "x", "regex":
+	case "machinereadable":
+	//yay options
+	case "aururl":
+	case "save":
+	case "afterclean", "cleanafter":
+	case "noafterclean", "nocleanafter":
+	case "devel":
+	case "nodevel":
+	case "timeupdate":
+	case "notimeupdate":
+	case "topdown":
+	case "bottomup":
+	case "completioninterval":
+	case "sortby":
+	case "searchby":
+	case "redownload":
+	case "redownloadall":
+	case "noredownload":
+	case "rebuild":
+	case "rebuildall":
+	case "rebuildtree":
+	case "norebuild":
+	case "batchinstall":
+	case "nobatchinstall":
+	case "answerclean":
+	case "noanswerclean":
+	case "answerdiff":
+	case "noanswerdiff":
+	case "answeredit":
+	case "noansweredit":
+	case "answerupgrade":
+	case "noanswerupgrade":
+	case "gpgflags":
+	case "mflags":
+	case "gitflags":
+	case "builddir":
+	case "editor":
+	case "editorflags":
+	case "makepkg":
+	case "makepkgconf":
+	case "nomakepkgconf":
+	case "pacman":
+	case "git":
+	case "gpg":
+	case "sudo":
+	case "sudoflags":
+	case "requestsplitn":
+	case "sudoloop":
+	case "nosudoloop":
+	case "provides":
+	case "noprovides":
+	case "pgpfetch":
+	case "nopgpfetch":
+	case "upgrademenu":
+	case "noupgrademenu":
+	case "cleanmenu":
+	case "nocleanmenu":
+	case "diffmenu":
+	case "nodiffmenu":
+	case "editmenu":
+	case "noeditmenu":
+	case "useask":
+	case "nouseask":
+	case "combinedupgrade":
+	case "nocombinedupgrade":
+	case "a", "aur":
+	case "repo":
+	case "removemake":
+	case "noremovemake":
+	case "askremovemake":
+	case "complete":
+	case "stats":
+	case "news":
+	case "gendb":
+	case "currentconfig":
+	default:
+		return false
+	}
+
+	return true
+}
+
+func handleConfig(option, value string) bool {
+	switch option {
+	case "aururl":
+		config.AURURL = value
+	case "save":
+		shouldSaveConfig = true
+	case "afterclean", "cleanafter":
+		config.CleanAfter = true
+	case "noafterclean", "nocleanafter":
+		config.CleanAfter = false
+	case "devel":
+		config.Devel = true
+	case "nodevel":
+		config.Devel = false
+	case "timeupdate":
+		config.TimeUpdate = true
+	case "notimeupdate":
+		config.TimeUpdate = false
+	case "topdown":
+		config.SortMode = topDown
+	case "bottomup":
+		config.SortMode = bottomUp
+	case "completioninterval":
+		n, err := strconv.Atoi(value)
+		if err == nil {
+			config.CompletionInterval = n
+		}
+	case "sortby":
+		config.SortBy = value
+	case "searchby":
+		config.SearchBy = value
+	case "noconfirm":
+		config.NoConfirm = true
+	case "config":
+		config.PacmanConf = value
+	case "redownload":
+		config.ReDownload = "yes"
+	case "redownloadall":
+		config.ReDownload = "all"
+	case "noredownload":
+		config.ReDownload = "no"
+	case "rebuild":
+		config.ReBuild = "yes"
+	case "rebuildall":
+		config.ReBuild = "all"
+	case "rebuildtree":
+		config.ReBuild = "tree"
+	case "norebuild":
+		config.ReBuild = "no"
+	case "batchinstall":
+		config.BatchInstall = true
+	case "nobatchinstall":
+		config.BatchInstall = false
+	case "answerclean":
+		config.AnswerClean = value
+	case "noanswerclean":
+		config.AnswerClean = ""
+	case "answerdiff":
+		config.AnswerDiff = value
+	case "noanswerdiff":
+		config.AnswerDiff = ""
+	case "answeredit":
+		config.AnswerEdit = value
+	case "noansweredit":
+		config.AnswerEdit = ""
+	case "answerupgrade":
+		config.AnswerUpgrade = value
+	case "noanswerupgrade":
+		config.AnswerUpgrade = ""
+	case "gpgflags":
+		config.GpgFlags = value
+	case "mflags":
+		config.MFlags = value
+	case "gitflags":
+		config.GitFlags = value
+	case "builddir":
+		config.BuildDir = value
+	case "absdir":
+		config.ABSDir = value
+	case "editor":
+		config.Editor = value
+	case "editorflags":
+		config.EditorFlags = value
+	case "makepkg":
+		config.MakepkgBin = value
+	case "makepkgconf":
+		config.MakepkgConf = value
+	case "nomakepkgconf":
+		config.MakepkgConf = ""
+	case "pacman":
+		config.PacmanBin = value
+	case "git":
+		config.GitBin = value
+	case "gpg":
+		config.GpgBin = value
+	case "sudo":
+		config.SudoBin = value
+	case "sudoflags":
+		config.SudoFlags = value
+	case "requestsplitn":
+		n, err := strconv.Atoi(value)
+		if err == nil && n > 0 {
+			config.RequestSplitN = n
+		}
+	case "sudoloop":
+		config.SudoLoop = true
+	case "nosudoloop":
+		config.SudoLoop = false
+	case "provides":
+		config.Provides = true
+	case "noprovides":
+		config.Provides = false
+	case "pgpfetch":
+		config.PGPFetch = true
+	case "nopgpfetch":
+		config.PGPFetch = false
+	case "upgrademenu":
+		config.UpgradeMenu = true
+	case "noupgrademenu":
+		config.UpgradeMenu = false
+	case "cleanmenu":
+		config.CleanMenu = true
+	case "nocleanmenu":
+		config.CleanMenu = false
+	case "diffmenu":
+		config.DiffMenu = true
+	case "nodiffmenu":
+		config.DiffMenu = false
+	case "editmenu":
+		config.EditMenu = true
+	case "noeditmenu":
+		config.EditMenu = false
+	case "useask":
+		config.UseAsk = true
+	case "nouseask":
+		config.UseAsk = false
+	case "combinedupgrade":
+		config.CombinedUpgrade = true
+	case "nocombinedupgrade":
+		config.CombinedUpgrade = false
+	case "a", "aur":
+		mode = modeAUR
+	case "repo":
+		mode = modeRepo
+	case "removemake":
+		config.RemoveMake = "yes"
+	case "noremovemake":
+		config.RemoveMake = "no"
+	case "askremovemake":
+		config.RemoveMake = "ask"
+	default:
+		return false
+	}
+
+	return true
+}
+
+func isOp(op string) bool {
+	switch op {
+	case "V", "version":
+	case "D", "database":
+	case "F", "files":
+	case "Q", "query":
+	case "R", "remove":
+	case "S", "sync":
+	case "T", "deptest":
+	case "U", "upgrade":
+	// yay specific
+	case "Y", "yay":
+	case "P", "show":
+	case "G", "getpkgbuild":
+	default:
+		return false
+	}
+
+	return true
+}
+
+func isGlobal(op string) bool {
+	switch op {
+	case "b", "dbpath":
+	case "r", "root":
+	case "v", "verbose":
+	case "arch":
+	case "cachedir":
+	case "color":
+	case "config":
+	case "debug":
+	case "gpgdir":
+	case "hookdir":
+	case "logfile":
+	case "noconfirm":
+	case "confirm":
+	default:
+		return false
+	}
+
+	return true
+}
+
+func hasParam(arg string) bool {
+	switch arg {
+	case "dbpath", "b":
+	case "root", "r":
+	case "sysroot":
+	case "config":
+	case "ignore":
+	case "assume-installed":
+	case "overwrite":
+	case "ask":
+	case "cachedir":
+	case "hookdir":
+	case "logfile":
+	case "ignoregroup":
+	case "arch":
+	case "print-format":
+	case "gpgdir":
+	case "color":
+	//yay params
+	case "aururl":
+	case "mflags":
+	case "gpgflags":
+	case "gitflags":
+	case "builddir":
+	case "absdir":
+	case "editor":
+	case "editorflags":
+	case "makepkg":
+	case "makepkgconf":
+	case "pacman":
+	case "git":
+	case "gpg":
+	case "sudo":
+	case "sudoflags":
+	case "requestsplitn":
+	case "answerclean":
+	case "answerdiff":
+	case "answeredit":
+	case "answerupgrade":
+	case "completioninterval":
+	case "sortby":
+	case "searchby":
+	default:
+		return false
+	}
+
+	return true
+}
+
+// Parses short hand options such as:
+// -Syu -b/some/path -
+func (parser *arguments) parseShortOption(arg string, param string) (usedNext bool, err error) {
+	if arg == "-" {
+		err = parser.addArg("-")
+		return
+	}
+
+	arg = arg[1:]
+
+	for k, _char := range arg {
+		char := string(_char)
+
+		if hasParam(char) {
+			if k < len(arg)-1 {
+				err = parser.addParam(char, arg[k+1:])
+			} else {
+				usedNext = true
+				err = parser.addParam(char, param)
+			}
+
+			break
+		} else {
+			err = parser.addArg(char)
+
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+// Parses full length options such as:
+// --sync --refresh --sysupgrade --dbpath /some/path --
+func (parser *arguments) parseLongOption(arg string, param string) (usedNext bool, err error) {
+	if arg == "--" {
+		err = parser.addArg(arg)
+		return
+	}
+
+	arg = arg[2:]
+
+	switch split := strings.SplitN(arg, "=", 2); {
+	case len(split) == 2:
+		err = parser.addParam(split[0], split[1])
+	case hasParam(arg):
+		err = parser.addParam(arg, param)
+		usedNext = true
+	default:
+		err = parser.addArg(arg)
+	}
+
+	return
+}
+
+func (parser *arguments) parseStdin() error {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Split(bufio.ScanLines)
+
+	for scanner.Scan() {
+		parser.addTarget(scanner.Text())
+	}
+
+	return os.Stdin.Close()
+}
+
+func (parser *arguments) parseCommandLine() (err error) {
+	args := os.Args[1:]
+	usedNext := false
+
+	if len(args) < 1 {
+		_, err = parser.parseShortOption("-Syu", "")
+		if err != nil {
+			return
+		}
+
+	} else {
+		for k, arg := range args {
+			var nextArg string
+
+			if usedNext {
+				usedNext = false
+				continue
+			}
+
+			if k+1 < len(args) {
+				nextArg = args[k+1]
+			}
+
+			switch {
+			case parser.existsArg("--"):
+				parser.addTarget(arg)
+			case strings.HasPrefix(arg, "--"):
+				usedNext, err = parser.parseLongOption(arg, nextArg)
+			case strings.HasPrefix(arg, "-"):
+				usedNext, err = parser.parseShortOption(arg, nextArg)
+			default:
+				parser.addTarget(arg)
+			}
+
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	if parser.op == "" {
+		parser.op = "Y"
+	}
+
+	if parser.existsArg("-") {
+		var file *os.File
+		err = parser.parseStdin()
+		parser.delArg("-")
+
+		if err != nil {
+			return
+		}
+
+		file, err = os.Open("/dev/tty")
+
+		if err != nil {
+			return
+		}
+
+		os.Stdin = file
+	}
+
+	cmdArgs.extractYayOptions()
+	return
+}
+
+func (parser *arguments) extractYayOptions() {
+	for option, value := range parser.options {
+		if handleConfig(option, value) {
+			parser.delArg(option)
+		}
+	}
+
+	for option, value := range parser.globals {
+		if handleConfig(option, value) {
+			parser.delArg(option)
+		}
+	}
+
+	rpc.AURURL = strings.TrimRight(config.AURURL, "/") + "/rpc.php?"
+	config.AURURL = strings.TrimRight(config.AURURL, "/")
+}
+
+// Crude html parsing, good enough for the arch news
+// This is only displayed in the terminal so there should be no security
+// concerns
+func parseNews(str string) string {
+	var buffer bytes.Buffer
+	var tagBuffer bytes.Buffer
+	var escapeBuffer bytes.Buffer
+	inTag := false
+	inEscape := false
+
+	for _, char := range str {
+		if inTag {
+			if char == '>' {
+				inTag = false
+				switch tagBuffer.String() {
+				case "code":
+					buffer.WriteString(cyanCode)
+				case "/code":
+					buffer.WriteString(resetCode)
+				case "/p":
+					buffer.WriteRune('\n')
+				}
+
+				continue
+			}
+
+			tagBuffer.WriteRune(char)
+			continue
+		}
+
+		if inEscape {
+			if char == ';' {
+				inEscape = false
+				escapeBuffer.WriteRune(char)
+				s := html.UnescapeString(escapeBuffer.String())
+				buffer.WriteString(s)
+				continue
+			}
+
+			escapeBuffer.WriteRune(char)
+			continue
+		}
+
+		if char == '<' {
+			inTag = true
+			tagBuffer.Reset()
+			continue
+		}
+
+		if char == '&' {
+			inEscape = true
+			escapeBuffer.Reset()
+			escapeBuffer.WriteRune(char)
+			continue
+		}
+
+		buffer.WriteRune(char)
+	}
+
+	buffer.WriteString(resetCode)
+	return buffer.String()
+}

pkg/cmd/graph/main.go

@@ -1,82 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/Jguer/yay/v12/pkg/db/ialpm"
-	"github.com/Jguer/yay/v12/pkg/dep"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/text"
-
-	"github.com/Jguer/aur/metadata"
-	"github.com/leonelquinteros/gotext"
-)
-
-func handleCmd(logger *text.Logger) error {
-	cfg, err := settings.NewConfig(logger, settings.GetConfigPath(), "")
-	if err != nil {
-		return err
-	}
-
-	cmdArgs := parser.MakeArguments()
-	if errP := cfg.ParseCommandLine(cmdArgs); errP != nil {
-		return errP
-	}
-
-	run, err := runtime.NewRuntime(cfg, cmdArgs, "1.0.0")
-	if err != nil {
-		return err
-	}
-
-	dbExecutor, err := ialpm.NewExecutor(run.PacmanConf, logger)
-	if err != nil {
-		return err
-	}
-
-	aurCache, err := metadata.New(
-		metadata.WithCacheFilePath(
-			filepath.Join(cfg.BuildDir, "aur.json")))
-	if err != nil {
-		return fmt.Errorf("%s: %w", gotext.Get("failed to retrieve aur Cache"), err)
-	}
-
-	grapher := dep.NewGrapher(dbExecutor, aurCache, true, settings.NoConfirm,
-		cmdArgs.ExistsDouble("d", "nodeps"), false, false,
-		run.Logger.Child("grapher"))
-
-	return graphPackage(context.Background(), grapher, cmdArgs.Targets)
-}
-
-func main() {
-	fallbackLog := text.NewLogger(os.Stdout, os.Stderr, os.Stdin, false, "fallback")
-	if err := handleCmd(fallbackLog); err != nil {
-		fallbackLog.Errorln(err)
-		os.Exit(1)
-	}
-}
-
-func graphPackage(
-	ctx context.Context,
-	grapher *dep.Grapher,
-	targets []string,
-) error {
-	if len(targets) != 1 {
-		return errors.New(gotext.Get("only one target is allowed"))
-	}
-
-	graph, err := grapher.GraphFromAUR(ctx, nil, []string{targets[0]})
-	if err != nil {
-		return err
-	}
-
-	fmt.Fprintln(os.Stdout, graph.String())
-	fmt.Fprintln(os.Stdout, "\nlayers map\n", graph.TopoSortedLayerMap(nil))
-
-	return nil
-}

pkg/completion/completion.go

@@ -2,125 +2,74 @@ package completion
 
 import (
 	"bufio"
-	"context"
-	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"os"
-	"path"
 	"path/filepath"
-	"strings"
 	"time"
 
-	"github.com/Jguer/yay/v12/pkg/db"
+	alpm "github.com/Jguer/go-alpm"
 )
 
-type PkgSynchronizer interface {
-	SyncPackages(...string) []db.IPackage
-}
+// Show provides completion info for shells
+func Show(alpmHandle *alpm.Handle, aurURL string, cacheDir string, interval int, force bool) error {
+	path := filepath.Join(cacheDir, "completion.cache")
 
-type httpRequestDoer interface {
-	Do(req *http.Request) (*http.Response, error)
-}
-
-// Show provides completion info for shells.
-func Show(ctx context.Context, httpClient httpRequestDoer,
-	dbExecutor PkgSynchronizer, aurURL, completionPath string, interval int, force bool,
-) error {
-	err := Update(ctx, httpClient, dbExecutor, aurURL, completionPath, interval, force)
+	err := Update(alpmHandle, aurURL, cacheDir, interval, force)
 	if err != nil {
 		return err
 	}
 
-	in, err := os.OpenFile(completionPath, os.O_RDWR|os.O_CREATE, 0o644)
+	in, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
 	if err != nil {
 		return err
 	}
 	defer in.Close()
 
 	_, err = io.Copy(os.Stdout, in)
-
 	return err
 }
 
-// Update updates completion cache to be used by Complete.
-func Update(ctx context.Context, httpClient httpRequestDoer,
-	dbExecutor PkgSynchronizer, aurURL, completionPath string, interval int, force bool,
-) error {
-	info, err := os.Stat(completionPath)
+// Update updates completion cache to be used by Complete
+func Update(alpmHandle *alpm.Handle, aurURL string, cacheDir string, interval int, force bool) error {
+	path := filepath.Join(cacheDir, "completion.cache")
+	info, err := os.Stat(path)
 
 	if os.IsNotExist(err) || (interval != -1 && time.Since(info.ModTime()).Hours() >= float64(interval*24)) || force {
-		errd := os.MkdirAll(filepath.Dir(completionPath), 0o755)
+		errd := os.MkdirAll(filepath.Dir(path), 0755)
 		if errd != nil {
 			return errd
 		}
-
-		out, errf := os.Create(completionPath)
+		out, errf := os.Create(path)
 		if errf != nil {
 			return errf
 		}
 
-		if createAURList(ctx, httpClient, aurURL, out) != nil {
-			defer os.Remove(completionPath)
+		if createAURList(aurURL, out) != nil {
+			defer os.Remove(path)
 		}
-
-		erra := createRepoList(dbExecutor, out)
+		erra := createRepoList(alpmHandle, out)
 
 		out.Close()
-
 		return erra
 	}
 
 	return nil
 }
 
-// CreateAURList creates a new completion file.
-func createAURList(ctx context.Context, client httpRequestDoer, aurURL string, out io.Writer) error {
-	u, err := url.Parse(aurURL)
-	if err != nil {
-		return err
-	}
-
-	u.Path = path.Join(u.Path, "packages.gz")
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), http.NoBody)
-	if err != nil {
-		return err
-	}
-
-	resp, err := client.Do(req)
+//CreateAURList creates a new completion file
+func createAURList(aurURL string, out io.Writer) error {
+	resp, err := http.Get(aurURL + "/packages.gz")
 	if err != nil {
 		return err
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("invalid status code: %d", resp.StatusCode)
-	}
-
 	scanner := bufio.NewScanner(resp.Body)
 
 	scanner.Scan()
-
 	for scanner.Scan() {
-		text := scanner.Text()
-		if strings.HasPrefix(text, "#") {
-			continue
-		}
-
-		if _, err := io.WriteString(out, text+"\tAUR\n"); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// createRepoList appends Repo packages to completion cache.
-func createRepoList(dbExecutor PkgSynchronizer, out io.Writer) error {
-	for _, pkg := range dbExecutor.SyncPackages() {
-		_, err := io.WriteString(out, pkg.Name()+"\t"+pkg.DB().Name()+"\n")
+		_, err = io.WriteString(out, scanner.Text()+"\tAUR\n")
 		if err != nil {
 			return err
 		}
@@ -128,3 +77,20 @@ func createRepoList(dbExecutor PkgSynchronizer, out io.Writer) error {
 
 	return nil
 }
+
+//CreatePackageList appends Repo packages to completion cache
+func createRepoList(alpmHandle *alpm.Handle, out io.Writer) error {
+	dbList, err := alpmHandle.SyncDBs()
+	if err != nil {
+		return err
+	}
+
+	_ = dbList.ForEach(func(db alpm.DB) error {
+		_ = db.PkgCache().ForEach(func(pkg alpm.Package) error {
+			_, err = io.WriteString(out, pkg.Name()+"\t"+pkg.DB().Name()+"\n")
+			return err
+		})
+		return nil
+	})
+	return nil
+}

pkg/completion/completion_test.go

@@ -1,99 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package completion
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"io"
-	"net/http"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-const samplePackageResp = `
-# AUR package list, generated on Fri, 24 Jul 2020 22:05:22 GMT
-cytadela
-bitefusion
-globs-svn
-ri-li
-globs-benchmarks-svn
-dunelegacy
-lumina
-eternallands-sound
-`
-
-const expectPackageCompletion = `cytadela	AUR
-bitefusion	AUR
-globs-svn	AUR
-ri-li	AUR
-globs-benchmarks-svn	AUR
-dunelegacy	AUR
-lumina	AUR
-eternallands-sound	AUR
-`
-
-type mockDoer struct {
-	t                *testing.T
-	returnBody       string
-	returnStatusCode int
-	returnErr        error
-	wantUrl          string
-}
-
-func (m *mockDoer) Do(req *http.Request) (*http.Response, error) {
-	assert.Equal(m.t, m.wantUrl, req.URL.String())
-	return &http.Response{
-		StatusCode: m.returnStatusCode,
-		Body:       io.NopCloser(bytes.NewBufferString(m.returnBody)),
-	}, m.returnErr
-}
-
-func Test_createAURList(t *testing.T) {
-	t.Parallel()
-	doer := &mockDoer{
-		t:                t,
-		wantUrl:          "https://aur.archlinux.org/packages.gz",
-		returnStatusCode: 200,
-		returnBody:       samplePackageResp,
-		returnErr:        nil,
-	}
-	out := &bytes.Buffer{}
-	err := createAURList(context.Background(), doer, "https://aur.archlinux.org", out)
-	assert.NoError(t, err)
-	gotOut := out.String()
-	assert.Equal(t, expectPackageCompletion, gotOut)
-}
-
-func Test_createAURListHTTPError(t *testing.T) {
-	t.Parallel()
-	doer := &mockDoer{
-		t:                t,
-		wantUrl:          "https://aur.archlinux.org/packages.gz",
-		returnStatusCode: 200,
-		returnBody:       samplePackageResp,
-		returnErr:        errors.New("Not available"),
-	}
-
-	out := &bytes.Buffer{}
-	err := createAURList(context.Background(), doer, "https://aur.archlinux.org", out)
-	assert.EqualError(t, err, "Not available")
-}
-
-func Test_createAURListStatusError(t *testing.T) {
-	t.Parallel()
-	doer := &mockDoer{
-		t:                t,
-		wantUrl:          "https://aur.archlinux.org/packages.gz",
-		returnStatusCode: 503,
-		returnBody:       samplePackageResp,
-		returnErr:        nil,
-	}
-
-	out := &bytes.Buffer{}
-	err := createAURList(context.Background(), doer, "https://aur.archlinux.org", out)
-	assert.EqualError(t, err, "invalid status code: 503")
-}

pkg/db/executor.go

@@ -1,68 +0,0 @@
-package db
-
-import (
-	"time"
-
-	alpm "github.com/Jguer/go-alpm/v2"
-
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type (
-	IPackage = alpm.IPackage
-	Depend   = alpm.Depend
-)
-
-// VerCmp performs version comparison according to Pacman conventions. Return
-// value is <0 if and only if v1 is older than v2.
-func VerCmp(v1, v2 string) int {
-	return alpm.VerCmp(v1, v2)
-}
-
-type Upgrade struct {
-	Name          string
-	Base          string
-	Repository    string
-	LocalVersion  string
-	RemoteVersion string
-	Reason        alpm.PkgReason
-	Extra         string // Extra information to be displayed
-}
-
-type SyncUpgrade struct {
-	Package      alpm.IPackage
-	LocalVersion string
-	Reason       alpm.PkgReason
-}
-
-type Executor interface {
-	AlpmArchitectures() ([]string, error)
-	BiggestPackages() []IPackage
-	Cleanup()
-	InstalledRemotePackageNames() []string
-	InstalledRemotePackages() map[string]IPackage
-	InstalledSyncPackageNames() []string
-	IsCorrectVersionInstalled(string, string) bool
-	LastBuildTime() time.Time
-	LocalPackage(string) IPackage
-	LocalPackages() []IPackage
-	LocalSatisfierExists(string) bool
-	PackageDepends(IPackage) []Depend
-	PackageGroups(IPackage) []string
-	PackageOptionalDepends(IPackage) []Depend
-	PackageProvides(IPackage) []Depend
-	PackagesFromGroup(string) []IPackage
-	PackagesFromGroupAndDB(string, string) ([]IPackage, error)
-	RefreshHandle() error
-	SyncUpgrades(enableDowngrade bool) (
-		map[string]SyncUpgrade, error)
-	Repos() []string
-	SatisfierFromDB(string, string) (IPackage, error)
-	SyncPackage(string) IPackage
-	SyncPackageFromDB(string, string) IPackage
-	SyncPackages(...string) []IPackage
-	SyncSatisfier(string) IPackage
-	SyncSatisfierExists(string) bool
-
-	SetLogger(logger *text.Logger)
-}

pkg/db/ialpm/alpm.go

@@ -1,543 +0,0 @@
-package ialpm
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"strconv"
-	"time"
-
-	alpm "github.com/Jguer/go-alpm/v2"
-	pacmanconf "github.com/Morganamilo/go-pacmanconf"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type AlpmExecutor struct {
-	handle       *alpm.Handle
-	localDB      alpm.IDB
-	syncDB       alpm.IDBList
-	syncDBsCache []alpm.IDB
-	conf         *pacmanconf.Config
-	log          *text.Logger
-
-	installedRemotePkgNames []string
-	installedRemotePkgMap   map[string]alpm.IPackage
-	installedSyncPkgNames   []string
-}
-
-func NewExecutor(pacmanConf *pacmanconf.Config, logger *text.Logger) (*AlpmExecutor, error) {
-	ae := &AlpmExecutor{
-		handle:                  nil,
-		localDB:                 nil,
-		syncDB:                  nil,
-		syncDBsCache:            []alpm.IDB{},
-		conf:                    pacmanConf,
-		log:                     logger,
-		installedRemotePkgNames: nil,
-		installedRemotePkgMap:   nil,
-		installedSyncPkgNames:   nil,
-	}
-
-	if err := ae.RefreshHandle(); err != nil {
-		return nil, err
-	}
-
-	var err error
-	ae.localDB, err = ae.handle.LocalDB()
-	if err != nil {
-		return nil, err
-	}
-
-	ae.syncDB, err = ae.handle.SyncDBs()
-	if err != nil {
-		return nil, err
-	}
-
-	return ae, nil
-}
-
-func toUsage(usages []string) alpm.Usage {
-	if len(usages) == 0 {
-		return alpm.UsageAll
-	}
-
-	var ret alpm.Usage
-
-	for _, usage := range usages {
-		switch usage {
-		case "Sync":
-			ret |= alpm.UsageSync
-		case "Search":
-			ret |= alpm.UsageSearch
-		case "Install":
-			ret |= alpm.UsageInstall
-		case "Upgrade":
-			ret |= alpm.UsageUpgrade
-		case "All":
-			ret |= alpm.UsageAll
-		}
-	}
-
-	return ret
-}
-
-func configureAlpm(pacmanConf *pacmanconf.Config, alpmHandle *alpm.Handle) error {
-	for _, repo := range pacmanConf.Repos {
-		// TODO: set SigLevel
-		alpmDB, err := alpmHandle.RegisterSyncDB(repo.Name, 0)
-		if err != nil {
-			return err
-		}
-
-		alpmDB.SetServers(repo.Servers)
-		alpmDB.SetUsage(toUsage(repo.Usage))
-	}
-
-	if err := alpmHandle.SetCacheDirs(pacmanConf.CacheDir); err != nil {
-		return err
-	}
-
-	// add hook directories 1-by-1 to avoid overwriting the system directory
-	for _, dir := range pacmanConf.HookDir {
-		if err := alpmHandle.AddHookDir(dir); err != nil {
-			return err
-		}
-	}
-
-	if err := alpmHandle.SetGPGDir(pacmanConf.GPGDir); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetLogFile(pacmanConf.LogFile); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetIgnorePkgs(pacmanConf.IgnorePkg); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetIgnoreGroups(pacmanConf.IgnoreGroup); err != nil {
-		return err
-	}
-
-	if err := alpmSetArchitecture(alpmHandle, pacmanConf.Architecture); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetNoUpgrades(pacmanConf.NoUpgrade); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetNoExtracts(pacmanConf.NoExtract); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetUseSyslog(pacmanConf.UseSyslog); err != nil {
-		return err
-	}
-
-	return alpmHandle.SetCheckSpace(pacmanConf.CheckSpace)
-}
-
-func (ae *AlpmExecutor) logCallback() func(level alpm.LogLevel, str string) {
-	return func(level alpm.LogLevel, str string) {
-		switch level {
-		case alpm.LogWarning:
-			ae.log.Warn(str)
-		case alpm.LogError:
-			ae.log.Error(str)
-		}
-	}
-}
-
-func (ae *AlpmExecutor) questionCallback() func(question alpm.QuestionAny) {
-	return func(question alpm.QuestionAny) {
-		if qi, err := question.QuestionInstallIgnorepkg(); err == nil {
-			qi.SetInstall(true)
-		}
-
-		qp, err := question.QuestionSelectProvider()
-		if err != nil {
-			return
-		}
-
-		if settings.HideMenus {
-			return
-		}
-
-		size := 0
-
-		_ = qp.Providers(ae.handle).ForEach(func(pkg alpm.IPackage) error {
-			size++
-			return nil
-		})
-
-		str := text.Bold(gotext.Get("There are %[1]d providers available for %[2]s:", size, qp.Dep()))
-
-		size = 1
-
-		var dbName string
-
-		_ = qp.Providers(ae.handle).ForEach(func(pkg alpm.IPackage) error {
-			thisDB := pkg.DB().Name()
-
-			if dbName != thisDB {
-				dbName = thisDB
-				str += "\n"
-				str += ae.log.SprintOperationInfo(gotext.Get("Repository"), " ", dbName, "\n    ")
-			}
-			str += fmt.Sprintf("%d) %s ", size, pkg.Name())
-			size++
-			return nil
-		})
-
-		ae.log.OperationInfoln(str)
-
-		for {
-			ae.log.Println(gotext.Get("\nEnter a number (default=1): "))
-
-			// TODO: reenable noconfirm
-			if settings.NoConfirm {
-				ae.log.Println()
-
-				break
-			}
-
-			numberBuf, err := ae.log.GetInput("", false)
-			if err != nil {
-				ae.log.Errorln(err)
-				break
-			}
-
-			if numberBuf == "" {
-				break
-			}
-
-			num, err := strconv.Atoi(numberBuf)
-			if err != nil {
-				ae.log.Errorln(gotext.Get("invalid number: %s", numberBuf))
-				continue
-			}
-
-			if num < 1 || num > size {
-				ae.log.Errorln(gotext.Get("invalid value: %d is not between %d and %d", num, 1, size))
-				continue
-			}
-
-			qp.SetUseIndex(num - 1)
-
-			break
-		}
-	}
-}
-
-func (ae *AlpmExecutor) RefreshHandle() error {
-	if ae.handle != nil {
-		if errRelease := ae.handle.Release(); errRelease != nil {
-			return errRelease
-		}
-	}
-
-	alpmHandle, err := alpm.Initialize(ae.conf.RootDir, ae.conf.DBPath)
-	if err != nil {
-		return errors.New(gotext.Get("unable to CreateHandle: %s", err))
-	}
-
-	if errConf := configureAlpm(ae.conf, alpmHandle); errConf != nil {
-		return errConf
-	}
-
-	alpmSetQuestionCallback(alpmHandle, ae.questionCallback())
-	alpmSetLogCallback(alpmHandle, ae.logCallback())
-	ae.handle = alpmHandle
-	ae.syncDBsCache = nil
-
-	ae.syncDB, err = alpmHandle.SyncDBs()
-	if err != nil {
-		return err
-	}
-
-	ae.localDB, err = alpmHandle.LocalDB()
-
-	return err
-}
-
-func (ae *AlpmExecutor) LocalSatisfierExists(pkgName string) bool {
-	if _, err := ae.localDB.PkgCache().FindSatisfier(pkgName); err != nil {
-		return false
-	}
-
-	return true
-}
-
-func (ae *AlpmExecutor) SyncSatisfierExists(pkgName string) bool {
-	if _, err := ae.syncDB.FindSatisfier(pkgName); err != nil {
-		return false
-	}
-
-	return true
-}
-
-func (ae *AlpmExecutor) IsCorrectVersionInstalled(pkgName, versionRequired string) bool {
-	alpmPackage := ae.localDB.Pkg(pkgName)
-	if alpmPackage == nil {
-		return false
-	}
-
-	return alpmPackage.Version() == versionRequired
-}
-
-func (ae *AlpmExecutor) SyncSatisfier(pkgName string) alpm.IPackage {
-	foundPkg, err := ae.syncDB.FindSatisfier(pkgName)
-	if err != nil {
-		return nil
-	}
-
-	return foundPkg
-}
-
-func (ae *AlpmExecutor) PackagesFromGroup(groupName string) []alpm.IPackage {
-	groupPackages := []alpm.IPackage{}
-	_ = ae.syncDB.FindGroupPkgs(groupName).ForEach(func(pkg alpm.IPackage) error {
-		groupPackages = append(groupPackages, pkg)
-
-		return nil
-	})
-
-	return groupPackages
-}
-
-func (ae *AlpmExecutor) PackagesFromGroupAndDB(groupName, dbName string) ([]alpm.IPackage, error) {
-	singleDBList, err := ae.handle.SyncDBListByDBName(dbName)
-	if err != nil {
-		return nil, err
-	}
-
-	groupPackages := []alpm.IPackage{}
-	_ = singleDBList.FindGroupPkgs(groupName).ForEach(func(pkg alpm.IPackage) error {
-		groupPackages = append(groupPackages, pkg)
-
-		return nil
-	})
-
-	return groupPackages, nil
-}
-
-func (ae *AlpmExecutor) LocalPackages() []alpm.IPackage {
-	localPackages := []alpm.IPackage{}
-	_ = ae.localDB.PkgCache().ForEach(func(pkg alpm.IPackage) error {
-		localPackages = append(localPackages, pkg)
-		return nil
-	})
-
-	return localPackages
-}
-
-// SyncPackages searches SyncDB for packages or returns all packages if no search param is given.
-func (ae *AlpmExecutor) SyncPackages(pkgNames ...string) []alpm.IPackage {
-	repoPackages := []alpm.IPackage{}
-	_ = ae.syncDB.ForEach(func(alpmDB alpm.IDB) error {
-		if len(pkgNames) == 0 {
-			_ = alpmDB.PkgCache().ForEach(func(pkg alpm.IPackage) error {
-				repoPackages = append(repoPackages, pkg)
-				return nil
-			})
-		} else {
-			_ = alpmDB.Search(pkgNames).ForEach(func(pkg alpm.IPackage) error {
-				repoPackages = append(repoPackages, pkg)
-				return nil
-			})
-		}
-		return nil
-	})
-
-	return repoPackages
-}
-
-func (ae *AlpmExecutor) LocalPackage(pkgName string) alpm.IPackage {
-	pkg := ae.localDB.Pkg(pkgName)
-	if pkg == nil {
-		return nil
-	}
-
-	return pkg
-}
-
-func (ae *AlpmExecutor) syncDBs() []alpm.IDB {
-	if ae.syncDBsCache == nil {
-		ae.syncDBsCache = ae.syncDB.Slice()
-	}
-
-	return ae.syncDBsCache
-}
-
-func (ae *AlpmExecutor) SyncPackage(pkgName string) alpm.IPackage {
-	for _, db := range ae.syncDBs() {
-		if dbPkg := db.Pkg(pkgName); dbPkg != nil {
-			return dbPkg
-		}
-	}
-
-	return nil
-}
-
-func (ae *AlpmExecutor) SyncPackageFromDB(pkgName, dbName string) alpm.IPackage {
-	singleDB, err := ae.handle.SyncDBByName(dbName)
-	if err != nil {
-		return nil
-	}
-
-	return singleDB.Pkg(pkgName)
-}
-
-func (ae *AlpmExecutor) SatisfierFromDB(pkgName, dbName string) (alpm.IPackage, error) {
-	singleDBList, err := ae.handle.SyncDBListByDBName(dbName)
-	if err != nil {
-		return nil, err
-	}
-
-	foundPkg, err := singleDBList.FindSatisfier(pkgName)
-	if err != nil {
-		return nil, nil
-	}
-
-	return foundPkg, nil
-}
-
-func (ae *AlpmExecutor) PackageDepends(pkg alpm.IPackage) []alpm.Depend {
-	alpmPackage := pkg.(*alpm.Package)
-	return alpmPackage.Depends().Slice()
-}
-
-func (ae *AlpmExecutor) PackageOptionalDepends(pkg alpm.IPackage) []alpm.Depend {
-	alpmPackage := pkg.(*alpm.Package)
-	return alpmPackage.OptionalDepends().Slice()
-}
-
-func (ae *AlpmExecutor) PackageProvides(pkg alpm.IPackage) []alpm.Depend {
-	alpmPackage := pkg.(*alpm.Package)
-	return alpmPackage.Provides().Slice()
-}
-
-func (ae *AlpmExecutor) PackageGroups(pkg alpm.IPackage) []string {
-	alpmPackage := pkg.(*alpm.Package)
-	return alpmPackage.Groups().Slice()
-}
-
-// upRepo gathers local packages and checks if they have new versions.
-// Output: Upgrade type package list.
-func (ae *AlpmExecutor) SyncUpgrades(enableDowngrade bool) (
-	map[string]db.SyncUpgrade, error,
-) {
-	ups := map[string]db.SyncUpgrade{}
-	var errReturn error
-
-	localDB, errDB := ae.handle.LocalDB()
-	if errDB != nil {
-		return ups, errDB
-	}
-
-	if err := ae.handle.TransInit(alpm.TransFlagNoLock); err != nil {
-		return ups, err
-	}
-
-	defer func() {
-		errReturn = ae.handle.TransRelease()
-	}()
-
-	if err := ae.handle.SyncSysupgrade(enableDowngrade); err != nil {
-		return ups, err
-	}
-
-	_ = ae.handle.TransGetAdd().ForEach(func(pkg alpm.IPackage) error {
-		localVer := "-"
-		reason := alpm.PkgReasonExplicit
-
-		if localPkg := localDB.Pkg(pkg.Name()); localPkg != nil {
-			localVer = localPkg.Version()
-			reason = localPkg.Reason()
-		}
-
-		ups[pkg.Name()] = db.SyncUpgrade{
-			Package:      pkg,
-			Reason:       reason,
-			LocalVersion: localVer,
-		}
-
-		return nil
-	})
-
-	return ups, errReturn
-}
-
-func (ae *AlpmExecutor) BiggestPackages() []alpm.IPackage {
-	localPackages := []alpm.IPackage{}
-	_ = ae.localDB.PkgCache().SortBySize().ForEach(func(pkg alpm.IPackage) error {
-		localPackages = append(localPackages, pkg)
-		return nil
-	})
-
-	return localPackages
-}
-
-func (ae *AlpmExecutor) LastBuildTime() time.Time {
-	var lastTime time.Time
-
-	_ = ae.syncDB.ForEach(func(db alpm.IDB) error {
-		_ = db.PkgCache().ForEach(func(pkg alpm.IPackage) error {
-			thisTime := pkg.BuildDate()
-			if thisTime.After(lastTime) {
-				lastTime = thisTime
-			}
-			return nil
-		})
-		return nil
-	})
-
-	return lastTime
-}
-
-func (ae *AlpmExecutor) Cleanup() {
-	if ae.handle != nil {
-		if err := ae.handle.Release(); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-		}
-	}
-}
-
-func (ae *AlpmExecutor) Repos() (repos []string) {
-	_ = ae.syncDB.ForEach(func(db alpm.IDB) error {
-		repos = append(repos, db.Name())
-		return nil
-	})
-
-	return
-}
-
-func alpmSetArchitecture(alpmHandle *alpm.Handle, arch []string) error {
-	return alpmHandle.SetArchitectures(arch)
-}
-
-func (ae *AlpmExecutor) AlpmArchitectures() ([]string, error) {
-	architectures, err := ae.handle.GetArchitectures()
-
-	return architectures.Slice(), err
-}
-
-func alpmSetLogCallback(alpmHandle *alpm.Handle, cb func(alpm.LogLevel, string)) {
-	alpmHandle.SetLogCallback(func(ctx interface{}, lvl alpm.LogLevel, msg string) {
-		cbo := ctx.(func(alpm.LogLevel, string))
-		cbo(lvl, msg)
-	}, cb)
-}
-
-func alpmSetQuestionCallback(alpmHandle *alpm.Handle, cb func(alpm.QuestionAny)) {
-	alpmHandle.SetQuestionCallback(func(ctx interface{}, q alpm.QuestionAny) {
-		cbo := ctx.(func(alpm.QuestionAny))
-		cbo(q)
-	}, cb)
-}

pkg/db/ialpm/alpm_test.go

@@ -1,116 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package ialpm
-
-import (
-	"io"
-	"strings"
-	"testing"
-
-	alpm "github.com/Jguer/go-alpm/v2"
-	"github.com/Morganamilo/go-pacmanconf"
-	"github.com/stretchr/testify/assert"
-
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-func TestAlpmExecutor(t *testing.T) {
-	t.Parallel()
-	pacmanConf := &pacmanconf.Config{
-		RootDir:                "/",
-		DBPath:                 "/var/lib/pacman/",
-		CacheDir:               []string{"/cachedir/", "/another/"},
-		HookDir:                []string{"/hookdir/"},
-		GPGDir:                 "/gpgdir/",
-		LogFile:                "/logfile",
-		HoldPkg:                []string(nil),
-		IgnorePkg:              []string{"ignore", "this", "package"},
-		IgnoreGroup:            []string{"ignore", "this", "group"},
-		Architecture:           []string{"8086"},
-		XferCommand:            "",
-		NoUpgrade:              []string{"noupgrade"},
-		NoExtract:              []string{"noextract"},
-		CleanMethod:            []string{"KeepInstalled"},
-		SigLevel:               []string{"PackageOptional", "PackageTrustedOnly", "DatabaseOptional", "DatabaseTrustedOnly"},
-		LocalFileSigLevel:      []string(nil),
-		RemoteFileSigLevel:     []string(nil),
-		UseSyslog:              false,
-		Color:                  false,
-		UseDelta:               0,
-		TotalDownload:          true,
-		CheckSpace:             true,
-		VerbosePkgLists:        true,
-		DisableDownloadTimeout: false,
-		Repos: []pacmanconf.Repository{
-			{Name: "repo1", Servers: []string{"repo1"}, SigLevel: []string(nil), Usage: []string{"All"}},
-			{Name: "repo2", Servers: []string{"repo2"}, SigLevel: []string(nil), Usage: []string{"All"}},
-		},
-	}
-
-	aExec, err := NewExecutor(pacmanConf, text.NewLogger(io.Discard, io.Discard, strings.NewReader(""), false, "test"))
-	assert.NoError(t, err)
-
-	assert.NotNil(t, aExec.conf)
-	assert.EqualValues(t, pacmanConf, aExec.conf)
-
-	assert.NotNil(t, aExec.localDB)
-	assert.NotNil(t, aExec.syncDB)
-	assert.NotNil(t, aExec.questionCallback)
-	h := aExec.handle
-	assert.NotNil(t, h)
-
-	root, err := h.Root()
-	assert.Nil(t, err)
-	assert.Equal(t, "/", root)
-
-	dbPath, err := h.DBPath()
-	assert.Nil(t, err)
-	assert.Equal(t, "/var/lib/pacman/", dbPath)
-
-	cache, err := h.CacheDirs()
-	assert.Nil(t, err)
-	assert.Equal(t, []string{"/cachedir/", "/another/"}, cache.Slice())
-
-	log, err := h.LogFile()
-	assert.Nil(t, err)
-	assert.Equal(t, "/logfile", log)
-
-	gpg, err := h.GPGDir()
-	assert.Nil(t, err)
-	assert.Equal(t, "/gpgdir/", gpg)
-
-	hook, err := h.HookDirs()
-	assert.Nil(t, err)
-	assert.Equal(t, []string{"/usr/share/libalpm/hooks/", "/hookdir/"}, hook.Slice())
-
-	arch, err := alpmTestGetArch(h)
-	assert.Nil(t, err)
-	assert.Equal(t, []string{"8086"}, arch)
-
-	ignorePkg, err := h.IgnorePkgs()
-	assert.Nil(t, err)
-	assert.Equal(t, []string{"ignore", "this", "package"}, ignorePkg.Slice())
-
-	ignoreGroup, err := h.IgnoreGroups()
-	assert.Nil(t, err)
-	assert.Equal(t, []string{"ignore", "this", "group"}, ignoreGroup.Slice())
-
-	noUp, err := h.NoUpgrades()
-	assert.Nil(t, err)
-	assert.Equal(t, []string{"noupgrade"}, noUp.Slice())
-
-	noEx, err := h.NoExtracts()
-	assert.Nil(t, err)
-	assert.Equal(t, []string{"noextract"}, noEx.Slice())
-
-	check, err := h.CheckSpace()
-	assert.Nil(t, err)
-	assert.Equal(t, true, check)
-}
-
-func alpmTestGetArch(h *alpm.Handle) ([]string, error) {
-	architectures, err := h.GetArchitectures()
-
-	return architectures.Slice(), err
-}

pkg/db/ialpm/high_level.go

@@ -1,54 +0,0 @@
-package ialpm
-
-import (
-	alpm "github.com/Jguer/go-alpm/v2"
-
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-// GetPackageNamesBySource returns package names with and without correspondence in SyncDBS respectively.
-func (ae *AlpmExecutor) getPackageNamesBySource() {
-	if ae.installedRemotePkgMap == nil {
-		ae.installedRemotePkgMap = map[string]alpm.IPackage{}
-	}
-	for _, localpkg := range ae.LocalPackages() {
-		pkgName := localpkg.Name()
-		if ae.SyncPackage(pkgName) != nil {
-			ae.installedSyncPkgNames = append(ae.installedSyncPkgNames, pkgName)
-		} else {
-			ae.installedRemotePkgNames = append(ae.installedRemotePkgNames, pkgName)
-			ae.installedRemotePkgMap[pkgName] = localpkg
-		}
-	}
-
-	ae.log.Debugln("populating db executor package caches.",
-		"sync_len", len(ae.installedSyncPkgNames), "remote_len", len(ae.installedRemotePkgNames))
-}
-
-func (ae *AlpmExecutor) InstalledRemotePackages() map[string]alpm.IPackage {
-	if ae.installedRemotePkgMap == nil {
-		ae.getPackageNamesBySource()
-	}
-
-	return ae.installedRemotePkgMap
-}
-
-func (ae *AlpmExecutor) InstalledRemotePackageNames() []string {
-	if ae.installedRemotePkgNames == nil {
-		ae.getPackageNamesBySource()
-	}
-
-	return ae.installedRemotePkgNames
-}
-
-func (ae *AlpmExecutor) InstalledSyncPackageNames() []string {
-	if ae.installedSyncPkgNames == nil {
-		ae.getPackageNamesBySource()
-	}
-
-	return ae.installedSyncPkgNames
-}
-
-func (ae *AlpmExecutor) SetLogger(logger *text.Logger) {
-	ae.log = logger
-}

pkg/db/mock/executor.go

@@ -1,214 +0,0 @@
-package mock
-
-import (
-	"time"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/text"
-
-	"github.com/Jguer/go-alpm/v2"
-)
-
-type (
-	IPackage = alpm.IPackage
-	Depend   = alpm.Depend
-	Upgrade  = db.Upgrade
-)
-
-type DBExecutor struct {
-	db.Executor
-	AlpmArchitecturesFn           func() ([]string, error)
-	InstalledRemotePackageNamesFn func() []string
-	InstalledRemotePackagesFn     func() map[string]IPackage
-	IsCorrectVersionInstalledFn   func(string, string) bool
-	LocalPackageFn                func(string) IPackage
-	LocalPackagesFn               func() []IPackage
-	LocalSatisfierExistsFn        func(string) bool
-	PackageDependsFn              func(IPackage) []Depend
-	PackageOptionalDependsFn      func(alpm.IPackage) []alpm.Depend
-	PackageProvidesFn             func(IPackage) []Depend
-	PackagesFromGroupFn           func(string) []IPackage
-	PackagesFromGroupAndDBFn      func(string, string) ([]IPackage, error)
-	RefreshHandleFn               func() error
-	ReposFn                       func() []string
-	SyncPackageFn                 func(string) IPackage
-	SyncPackagesFn                func(...string) []IPackage
-	SyncSatisfierFn               func(string) IPackage
-	SatisfierFromDBFn             func(string, string) (IPackage, error)
-	SyncUpgradesFn                func(bool) (map[string]db.SyncUpgrade, error)
-	SetLoggerFn                   func(*text.Logger)
-}
-
-func (t *DBExecutor) InstalledRemotePackageNames() []string {
-	if t.InstalledRemotePackageNamesFn != nil {
-		return t.InstalledRemotePackageNamesFn()
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) InstalledRemotePackages() map[string]IPackage {
-	if t.InstalledRemotePackagesFn != nil {
-		return t.InstalledRemotePackagesFn()
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) AlpmArchitectures() ([]string, error) {
-	if t.AlpmArchitecturesFn != nil {
-		return t.AlpmArchitecturesFn()
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) BiggestPackages() []IPackage {
-	panic("implement me")
-}
-
-func (t *DBExecutor) Cleanup() {
-	panic("implement me")
-}
-
-func (t *DBExecutor) IsCorrectVersionInstalled(s, s2 string) bool {
-	if t.IsCorrectVersionInstalledFn != nil {
-		return t.IsCorrectVersionInstalledFn(s, s2)
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) LastBuildTime() time.Time {
-	panic("implement me")
-}
-
-func (t *DBExecutor) LocalPackage(s string) IPackage {
-	if t.LocalPackageFn != nil {
-		return t.LocalPackageFn(s)
-	}
-
-	panic("implement me")
-}
-
-func (t *DBExecutor) LocalPackages() []IPackage {
-	if t.LocalPackagesFn != nil {
-		return t.LocalPackagesFn()
-	}
-
-	panic("implement me")
-}
-
-func (t *DBExecutor) LocalSatisfierExists(s string) bool {
-	if t.LocalSatisfierExistsFn != nil {
-		return t.LocalSatisfierExistsFn(s)
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) PackageConflicts(iPackage IPackage) []Depend {
-	panic("implement me")
-}
-
-func (t *DBExecutor) PackageDepends(iPackage IPackage) []Depend {
-	if t.PackageDependsFn != nil {
-		return t.PackageDependsFn(iPackage)
-	}
-
-	panic("implement me")
-}
-
-func (t *DBExecutor) PackageGroups(iPackage IPackage) []string {
-	return []string{}
-}
-
-func (t *DBExecutor) PackageOptionalDepends(iPackage IPackage) []Depend {
-	if t.PackageOptionalDependsFn != nil {
-		return t.PackageOptionalDependsFn(iPackage)
-	}
-
-	panic("implement me")
-}
-
-func (t *DBExecutor) PackageProvides(iPackage IPackage) []Depend {
-	if t.PackageProvidesFn != nil {
-		return t.PackageProvidesFn(iPackage)
-	}
-
-	panic("implement me")
-}
-
-func (t *DBExecutor) PackagesFromGroup(s string) []IPackage {
-	if t.PackagesFromGroupFn != nil {
-		return t.PackagesFromGroupFn(s)
-	}
-
-	panic("implement me")
-}
-
-func (t *DBExecutor) PackagesFromGroupAndDB(s, s2 string) ([]IPackage, error) {
-	if t.PackagesFromGroupAndDBFn != nil {
-		return t.PackagesFromGroupAndDBFn(s, s2)
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) RefreshHandle() error {
-	if t.RefreshHandleFn != nil {
-		return t.RefreshHandleFn()
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) SyncUpgrades(b bool) (map[string]db.SyncUpgrade, error) {
-	if t.SyncUpgradesFn != nil {
-		return t.SyncUpgradesFn(b)
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) Repos() []string {
-	if t.ReposFn != nil {
-		return t.ReposFn()
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) SatisfierFromDB(s, s2 string) (IPackage, error) {
-	if t.SatisfierFromDBFn != nil {
-		return t.SatisfierFromDBFn(s, s2)
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) SyncPackage(s string) IPackage {
-	if t.SyncPackageFn != nil {
-		return t.SyncPackageFn(s)
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) SyncPackages(s ...string) []IPackage {
-	if t.SyncPackagesFn != nil {
-		return t.SyncPackagesFn(s...)
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) SyncSatisfier(s string) IPackage {
-	if t.SyncSatisfierFn != nil {
-		return t.SyncSatisfierFn(s)
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) SyncSatisfierExists(s string) bool {
-	if t.SyncSatisfierFn != nil {
-		return t.SyncSatisfierFn(s) != nil
-	}
-	panic("implement me")
-}
-
-func (t *DBExecutor) SetLogger(logger *text.Logger) {
-	if t.SetLoggerFn != nil {
-		t.SetLoggerFn(logger)
-		return
-	}
-	panic("implement me")
-}

pkg/db/mock/repo.go

@@ -1,229 +0,0 @@
-package mock
-
-import (
-	"time"
-
-	alpm "github.com/Jguer/go-alpm/v2"
-)
-
-type DependList struct {
-	Depends []Depend
-}
-
-func (d DependList) Slice() []alpm.Depend {
-	return d.Depends
-}
-
-func (d DependList) ForEach(f func(*alpm.Depend) error) error {
-	for i := range d.Depends {
-		dep := &d.Depends[i]
-		err := f(dep)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-type Package struct {
-	PBase         string
-	PBuildDate    time.Time
-	PDB           *DB
-	PDescription  string
-	PISize        int64
-	PName         string
-	PShouldIgnore bool
-	PSize         int64
-	PVersion      string
-	PReason       alpm.PkgReason
-	PDepends      alpm.IDependList
-	PProvides     alpm.IDependList
-}
-
-func (p *Package) Base() string {
-	return p.PBase
-}
-
-func (p *Package) BuildDate() time.Time {
-	return p.PBuildDate
-}
-
-func (p *Package) DB() alpm.IDB {
-	return p.PDB
-}
-
-func (p *Package) Description() string {
-	return p.PDescription
-}
-
-func (p *Package) ISize() int64 {
-	return p.PISize
-}
-
-func (p *Package) Name() string {
-	return p.PName
-}
-
-func (p *Package) ShouldIgnore() bool {
-	return p.PShouldIgnore
-}
-
-func (p *Package) Size() int64 {
-	return p.PSize
-}
-
-func (p *Package) Version() string {
-	return p.PVersion
-}
-
-func (p *Package) Reason() alpm.PkgReason {
-	return p.PReason
-}
-
-func (p *Package) FileName() string {
-	panic("not implemented")
-}
-
-func (p *Package) Base64Signature() string {
-	panic("not implemented")
-}
-
-func (p *Package) Validation() alpm.Validation {
-	panic("not implemented")
-}
-
-// Architecture returns the package target Architecture.
-func (p *Package) Architecture() string {
-	panic("not implemented")
-}
-
-// Backup returns a list of package backups.
-func (p *Package) Backup() alpm.BackupList {
-	panic("not implemented")
-}
-
-// Conflicts returns the conflicts of the package as a DependList.
-func (p *Package) Conflicts() alpm.IDependList {
-	panic("not implemented")
-}
-
-// Depends returns the package's dependency list.
-func (p *Package) Depends() alpm.IDependList {
-	if p.PDepends != nil {
-		return p.PDepends
-	}
-	return alpm.DependList{}
-}
-
-// Depends returns the package's optional dependency list.
-func (p *Package) OptionalDepends() alpm.IDependList {
-	panic("not implemented")
-}
-
-// Depends returns the package's check dependency list.
-func (p *Package) CheckDepends() alpm.IDependList {
-	panic("not implemented")
-}
-
-// Depends returns the package's make dependency list.
-func (p *Package) MakeDepends() alpm.IDependList {
-	panic("not implemented")
-}
-
-// Files returns the file list of the package.
-func (p *Package) Files() []alpm.File {
-	panic("not implemented")
-}
-
-// ContainsFile checks if the path is in the package filelist.
-func (p *Package) ContainsFile(path string) (alpm.File, error) {
-	panic("not implemented")
-}
-
-// Groups returns the groups the package belongs to.
-func (p *Package) Groups() alpm.StringList {
-	panic("not implemented")
-}
-
-// InstallDate returns the package install date.
-func (p *Package) InstallDate() time.Time {
-	panic("not implemented")
-}
-
-// Licenses returns the package license list.
-func (p *Package) Licenses() alpm.StringList {
-	panic("not implemented")
-}
-
-// SHA256Sum returns package SHA256Sum.
-func (p *Package) SHA256Sum() string {
-	panic("not implemented")
-}
-
-// MD5Sum returns package MD5Sum.
-func (p *Package) MD5Sum() string {
-	panic("not implemented")
-}
-
-// Packager returns package packager name.
-func (p *Package) Packager() string {
-	panic("not implemented")
-}
-
-// Provides returns DependList of packages provides by package.
-func (p *Package) Provides() alpm.IDependList {
-	if p.PProvides == nil {
-		return alpm.DependList{}
-	}
-	return p.PProvides
-}
-
-// Origin returns package origin.
-func (p *Package) Origin() alpm.PkgFrom {
-	panic("not implemented")
-}
-
-// Replaces returns a DependList with the packages this package replaces.
-func (p *Package) Replaces() alpm.IDependList {
-	panic("not implemented")
-}
-
-// URL returns the upstream URL of the package.
-func (p *Package) URL() string {
-	panic("not implemented")
-}
-
-// ComputeRequiredBy returns the names of reverse dependencies of a package.
-func (p *Package) ComputeRequiredBy() []string {
-	panic("not implemented")
-}
-
-// ComputeOptionalFor returns the names of packages that optionally
-// require the given package.
-func (p *Package) ComputeOptionalFor() []string {
-	panic("not implemented")
-}
-
-// SyncNewVersion checks if there is a new version of the
-// package in a given DBlist.
-func (p *Package) SyncNewVersion(l alpm.IDBList) alpm.IPackage {
-	panic("not implemented")
-}
-
-func (p *Package) Type() string {
-	panic("not implemented")
-}
-
-type DB struct {
-	alpm.IDB
-	name string
-}
-
-func NewDB(name string) *DB {
-	return &DB{name: name}
-}
-
-func (d *DB) Name() string {
-	return d.name
-}

pkg/db/types.go

@@ -1,15 +0,0 @@
-package db
-
-func ArchIsSupported(alpmArch []string, arch string) bool {
-	if arch == "any" {
-		return true
-	}
-
-	for _, a := range alpmArch {
-		if a == arch {
-			return true
-		}
-	}
-
-	return false
-}

pkg/dep/dep.go

@@ -1,87 +0,0 @@
-package dep
-
-import (
-	"strings"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	aur "github.com/Jguer/yay/v12/pkg/query"
-)
-
-func splitDep(dep string) (pkg, mod, ver string) {
-	split := strings.FieldsFunc(dep, func(c rune) bool {
-		match := c == '>' || c == '<' || c == '='
-
-		if match {
-			mod += string(c)
-		}
-
-		return match
-	})
-
-	if len(split) == 0 {
-		return "", "", ""
-	}
-
-	if len(split) == 1 {
-		return split[0], "", ""
-	}
-
-	return split[0], mod, split[1]
-}
-
-func pkgSatisfies(name, version, dep string) bool {
-	depName, depMod, depVersion := splitDep(dep)
-
-	if depName != name {
-		return false
-	}
-
-	return verSatisfies(version, depMod, depVersion)
-}
-
-func provideSatisfies(provide, dep, pkgVersion string) bool {
-	depName, depMod, depVersion := splitDep(dep)
-	provideName, provideMod, provideVersion := splitDep(provide)
-
-	if provideName != depName {
-		return false
-	}
-
-	// Unversioned provides can not satisfy a versioned dep
-	if provideMod == "" && depMod != "" {
-		provideVersion = pkgVersion // Example package: pagure
-	}
-
-	return verSatisfies(provideVersion, depMod, depVersion)
-}
-
-func verSatisfies(ver1, mod, ver2 string) bool {
-	switch mod {
-	case "=":
-		return db.VerCmp(ver1, ver2) == 0
-	case "<":
-		return db.VerCmp(ver1, ver2) < 0
-	case "<=":
-		return db.VerCmp(ver1, ver2) <= 0
-	case ">":
-		return db.VerCmp(ver1, ver2) > 0
-	case ">=":
-		return db.VerCmp(ver1, ver2) >= 0
-	}
-
-	return true
-}
-
-func satisfiesAur(dep string, pkg *aur.Pkg) bool {
-	if pkgSatisfies(pkg.Name, pkg.Version, dep) {
-		return true
-	}
-
-	for _, provide := range pkg.Provides {
-		if provideSatisfies(provide, dep, pkg.Version) {
-			return true
-		}
-	}
-
-	return false
-}

pkg/dep/dep_graph.go

@@ -1,853 +0,0 @@
-package dep
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-
-	aurc "github.com/Jguer/aur"
-	alpm "github.com/Jguer/go-alpm/v2"
-	gosrc "github.com/Morganamilo/go-srcinfo"
-	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/dep/topo"
-	"github.com/Jguer/yay/v12/pkg/intrange"
-	aur "github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type InstallInfo struct {
-	Source       Source
-	Reason       Reason
-	Version      string
-	LocalVersion string
-	SrcinfoPath  *string
-	AURBase      *string
-	SyncDBName   *string
-
-	IsGroup bool
-	Upgrade bool
-	Devel   bool
-}
-
-func (i *InstallInfo) String() string {
-	return fmt.Sprintf("InstallInfo{Source: %v, Reason: %v}", i.Source, i.Reason)
-}
-
-type (
-	Reason uint
-	Source int
-)
-
-func (r Reason) String() string {
-	return ReasonNames[r]
-}
-
-func (s Source) String() string {
-	return SourceNames[s]
-}
-
-const (
-	Explicit Reason = iota // 0
-	Dep                    // 1
-	MakeDep                // 2
-	CheckDep               // 3
-)
-
-var ReasonNames = map[Reason]string{
-	Explicit: gotext.Get("Explicit"),
-	Dep:      gotext.Get("Dependency"),
-	MakeDep:  gotext.Get("Make Dependency"),
-	CheckDep: gotext.Get("Check Dependency"),
-}
-
-const (
-	AUR Source = iota
-	Sync
-	Local
-	SrcInfo
-	Missing
-)
-
-var SourceNames = map[Source]string{
-	AUR:     gotext.Get("AUR"),
-	Sync:    gotext.Get("Sync"),
-	Local:   gotext.Get("Local"),
-	SrcInfo: gotext.Get("SRCINFO"),
-	Missing: gotext.Get("Missing"),
-}
-
-var bgColorMap = map[Source]string{
-	AUR:     "lightblue",
-	Sync:    "lemonchiffon",
-	Local:   "darkolivegreen1",
-	Missing: "tomato",
-}
-
-var colorMap = map[Reason]string{
-	Explicit: "black",
-	Dep:      "deeppink",
-	MakeDep:  "navyblue",
-	CheckDep: "forestgreen",
-}
-
-type Grapher struct {
-	logger        *text.Logger
-	providerCache map[string][]aur.Pkg
-
-	dbExecutor  db.Executor
-	aurClient   aurc.QueryClient
-	fullGraph   bool // If true, the graph will include all dependencies including already installed ones or repo
-	noConfirm   bool // If true, the graph will not prompt for confirmation
-	noDeps      bool // If true, the graph will not include dependencies
-	noCheckDeps bool // If true, the graph will not include check dependencies
-	needed      bool // If true, the graph will only include packages that are not installed
-}
-
-func NewGrapher(dbExecutor db.Executor, aurCache aurc.QueryClient,
-	fullGraph, noConfirm, noDeps, noCheckDeps, needed bool,
-	logger *text.Logger,
-) *Grapher {
-	return &Grapher{
-		dbExecutor:    dbExecutor,
-		aurClient:     aurCache,
-		fullGraph:     fullGraph,
-		noConfirm:     noConfirm,
-		noDeps:        noDeps,
-		noCheckDeps:   noCheckDeps,
-		needed:        needed,
-		providerCache: make(map[string][]aurc.Pkg, 5),
-		logger:        logger,
-	}
-}
-
-func NewGraph() *topo.Graph[string, *InstallInfo] {
-	return topo.New[string, *InstallInfo]()
-}
-
-func (g *Grapher) GraphFromTargets(ctx context.Context,
-	graph *topo.Graph[string, *InstallInfo], targets []string,
-) (*topo.Graph[string, *InstallInfo], error) {
-	if graph == nil {
-		graph = NewGraph()
-	}
-
-	aurTargets := make([]string, 0, len(targets))
-
-	for _, targetString := range targets {
-		target := ToTarget(targetString)
-
-		switch target.DB {
-		case "": // unspecified db
-			if pkg := g.dbExecutor.SyncSatisfier(target.Name); pkg != nil {
-				g.GraphSyncPkg(ctx, graph, pkg, nil)
-
-				continue
-			}
-
-			groupPackages := g.dbExecutor.PackagesFromGroup(target.Name)
-			if len(groupPackages) > 0 {
-				dbName := groupPackages[0].DB().Name()
-				g.GraphSyncGroup(ctx, graph, target.Name, dbName)
-
-				continue
-			}
-
-			fallthrough
-		case "aur":
-			aurTargets = append(aurTargets, target.Name)
-		default:
-			pkg, err := g.dbExecutor.SatisfierFromDB(target.Name, target.DB)
-			if err != nil {
-				return nil, err
-			}
-			if pkg != nil {
-				g.GraphSyncPkg(ctx, graph, pkg, nil)
-				continue
-			}
-
-			groupPackages, err := g.dbExecutor.PackagesFromGroupAndDB(target.Name, target.DB)
-			if err != nil {
-				return nil, err
-			}
-			if len(groupPackages) > 0 {
-				g.GraphSyncGroup(ctx, graph, target.Name, target.DB)
-
-				continue
-			}
-
-			g.logger.Errorln(gotext.Get("No package found for"), " ", target)
-		}
-	}
-
-	var errA error
-	graph, errA = g.GraphFromAUR(ctx, graph, aurTargets)
-	if errA != nil {
-		return nil, errA
-	}
-
-	return graph, nil
-}
-
-func (g *Grapher) pickSrcInfoPkgs(pkgs []*aurc.Pkg) ([]*aurc.Pkg, error) {
-	final := make([]*aurc.Pkg, 0, len(pkgs))
-	for i := range pkgs {
-		g.logger.Println(text.Magenta(strconv.Itoa(i+1)+" ") + text.Bold(pkgs[i].Name) +
-			" " + text.Cyan(pkgs[i].Version))
-		g.logger.Println("    " + pkgs[i].Description)
-	}
-	g.logger.Infoln(gotext.Get("Packages to exclude") + " (eg: \"1 2 3\", \"1-3\", \"^4\"):")
-
-	numberBuf, err := g.logger.GetInput("", g.noConfirm)
-	if err != nil {
-		return nil, err
-	}
-
-	include, exclude, _, otherExclude := intrange.ParseNumberMenu(numberBuf)
-	isInclude := len(exclude) == 0 && otherExclude.Cardinality() == 0
-
-	for i := 1; i <= len(pkgs); i++ {
-		target := i - 1
-
-		if isInclude && !include.Get(i) {
-			final = append(final, pkgs[target])
-		}
-
-		if !isInclude && (exclude.Get(i)) {
-			final = append(final, pkgs[target])
-		}
-	}
-
-	return final, nil
-}
-
-func (g *Grapher) addAurPkgProvides(pkg *aurc.Pkg, graph *topo.Graph[string, *InstallInfo]) {
-	for i := range pkg.Provides {
-		depName, mod, version := splitDep(pkg.Provides[i])
-		g.logger.Debugln(pkg.String() + " provides: " + depName)
-		graph.Provides(depName, &alpm.Depend{
-			Name:    depName,
-			Version: version,
-			Mod:     aurDepModToAlpmDep(mod),
-		}, pkg.Name)
-	}
-}
-
-func (g *Grapher) GraphFromSrcInfos(ctx context.Context, graph *topo.Graph[string, *InstallInfo],
-	srcInfos map[string]*gosrc.Srcinfo,
-) (*topo.Graph[string, *InstallInfo], error) {
-	if graph == nil {
-		graph = NewGraph()
-	}
-
-	aurPkgsAdded := []*aurc.Pkg{}
-	for pkgBuildDir, pkgbuild := range srcInfos {
-		pkgBuildDir := pkgBuildDir
-
-		aurPkgs, err := makeAURPKGFromSrcinfo(g.dbExecutor, pkgbuild)
-		if err != nil {
-			return nil, err
-		}
-
-		if len(aurPkgs) > 1 {
-			var errPick error
-			aurPkgs, errPick = g.pickSrcInfoPkgs(aurPkgs)
-			if errPick != nil {
-				return nil, errPick
-			}
-		}
-
-		for _, pkg := range aurPkgs {
-			pkg := pkg
-
-			reason := Explicit
-			if pkg := g.dbExecutor.LocalPackage(pkg.Name); pkg != nil {
-				reason = Reason(pkg.Reason())
-			}
-
-			graph.AddNode(pkg.Name)
-
-			g.addAurPkgProvides(pkg, graph)
-
-			g.ValidateAndSetNodeInfo(graph, pkg.Name, &topo.NodeInfo[*InstallInfo]{
-				Color:      colorMap[reason],
-				Background: bgColorMap[AUR],
-				Value: &InstallInfo{
-					Source:      SrcInfo,
-					Reason:      reason,
-					SrcinfoPath: &pkgBuildDir,
-					AURBase:     &pkg.PackageBase,
-					Version:     pkg.Version,
-				},
-			})
-		}
-
-		aurPkgsAdded = append(aurPkgsAdded, aurPkgs...)
-	}
-
-	g.AddDepsForPkgs(ctx, aurPkgsAdded, graph)
-
-	return graph, nil
-}
-
-func (g *Grapher) AddDepsForPkgs(ctx context.Context, pkgs []*aur.Pkg, graph *topo.Graph[string, *InstallInfo]) {
-	for _, pkg := range pkgs {
-		g.addDepNodes(ctx, pkg, graph)
-	}
-}
-
-func (g *Grapher) addDepNodes(ctx context.Context, pkg *aur.Pkg, graph *topo.Graph[string, *InstallInfo]) {
-	if len(pkg.MakeDepends) > 0 {
-		g.addNodes(ctx, graph, pkg.Name, pkg.MakeDepends, MakeDep)
-	}
-
-	if !g.noDeps && len(pkg.Depends) > 0 {
-		g.addNodes(ctx, graph, pkg.Name, pkg.Depends, Dep)
-	}
-
-	if !g.noCheckDeps && !g.noDeps && len(pkg.CheckDepends) > 0 {
-		g.addNodes(ctx, graph, pkg.Name, pkg.CheckDepends, CheckDep)
-	}
-}
-
-func (g *Grapher) GraphSyncPkg(ctx context.Context,
-	graph *topo.Graph[string, *InstallInfo],
-	pkg alpm.IPackage, upgradeInfo *db.SyncUpgrade,
-) *topo.Graph[string, *InstallInfo] {
-	if graph == nil {
-		graph = NewGraph()
-	}
-
-	graph.AddNode(pkg.Name())
-	_ = pkg.Provides().ForEach(func(p *alpm.Depend) error {
-		g.logger.Debugln(pkg.Name() + " provides: " + p.String())
-		graph.Provides(p.Name, p, pkg.Name())
-		return nil
-	})
-
-	dbName := pkg.DB().Name()
-	info := &InstallInfo{
-		Source:     Sync,
-		Reason:     Explicit,
-		Version:    pkg.Version(),
-		SyncDBName: &dbName,
-	}
-
-	if upgradeInfo == nil {
-		if localPkg := g.dbExecutor.LocalPackage(pkg.Name()); localPkg != nil {
-			info.Reason = Reason(localPkg.Reason())
-		}
-	} else {
-		info.Upgrade = true
-		info.Reason = Reason(upgradeInfo.Reason)
-		info.LocalVersion = upgradeInfo.LocalVersion
-	}
-
-	g.ValidateAndSetNodeInfo(graph, pkg.Name(), &topo.NodeInfo[*InstallInfo]{
-		Color:      colorMap[info.Reason],
-		Background: bgColorMap[info.Source],
-		Value:      info,
-	})
-
-	return graph
-}
-
-func (g *Grapher) GraphSyncGroup(ctx context.Context,
-	graph *topo.Graph[string, *InstallInfo],
-	groupName, dbName string,
-) *topo.Graph[string, *InstallInfo] {
-	if graph == nil {
-		graph = NewGraph()
-	}
-
-	graph.AddNode(groupName)
-
-	g.ValidateAndSetNodeInfo(graph, groupName, &topo.NodeInfo[*InstallInfo]{
-		Color:      colorMap[Explicit],
-		Background: bgColorMap[Sync],
-		Value: &InstallInfo{
-			Source:     Sync,
-			Reason:     Explicit,
-			Version:    "",
-			SyncDBName: &dbName,
-			IsGroup:    true,
-		},
-	})
-
-	return graph
-}
-
-func (g *Grapher) GraphAURTarget(ctx context.Context,
-	graph *topo.Graph[string, *InstallInfo],
-	pkg *aurc.Pkg, instalInfo *InstallInfo,
-) *topo.Graph[string, *InstallInfo] {
-	if graph == nil {
-		graph = NewGraph()
-	}
-
-	graph.AddNode(pkg.Name)
-
-	g.addAurPkgProvides(pkg, graph)
-
-	g.ValidateAndSetNodeInfo(graph, pkg.Name, &topo.NodeInfo[*InstallInfo]{
-		Color:      colorMap[instalInfo.Reason],
-		Background: bgColorMap[AUR],
-		Value:      instalInfo,
-	})
-
-	return graph
-}
-
-func (g *Grapher) GraphFromAUR(ctx context.Context,
-	graph *topo.Graph[string, *InstallInfo],
-	targets []string,
-) (*topo.Graph[string, *InstallInfo], error) {
-	if graph == nil {
-		graph = NewGraph()
-	}
-
-	if len(targets) == 0 {
-		return graph, nil
-	}
-
-	aurPkgs, errCache := g.aurClient.Get(ctx, &aurc.Query{By: aurc.Name, Needles: targets})
-	if errCache != nil {
-		g.logger.Errorln(errCache)
-	}
-
-	for i := range aurPkgs {
-		pkg := &aurPkgs[i]
-		if _, ok := g.providerCache[pkg.Name]; !ok {
-			g.providerCache[pkg.Name] = []aurc.Pkg{*pkg}
-		}
-	}
-
-	aurPkgsAdded := []*aurc.Pkg{}
-
-	for _, target := range targets {
-		if cachedProvidePkg, ok := g.providerCache[target]; ok {
-			aurPkgs = cachedProvidePkg
-		} else {
-			var errA error
-			aurPkgs, errA = g.aurClient.Get(ctx, &aurc.Query{By: aurc.Provides, Needles: []string{target}, Contains: true})
-			if errA != nil {
-				g.logger.Errorln(gotext.Get("Failed to find AUR package for"), " ", target, ":", errA)
-			}
-		}
-
-		if len(aurPkgs) == 0 {
-			g.logger.Errorln(gotext.Get("No AUR package found for"), " ", target)
-
-			continue
-		}
-
-		aurPkg := &aurPkgs[0]
-		if len(aurPkgs) > 1 {
-			chosen := g.provideMenu(target, aurPkgs)
-			aurPkg = chosen
-			g.providerCache[target] = []aurc.Pkg{*aurPkg}
-		}
-
-		reason := Explicit
-		if pkg := g.dbExecutor.LocalPackage(aurPkg.Name); pkg != nil {
-			reason = Reason(pkg.Reason())
-
-			if g.needed {
-				if db.VerCmp(pkg.Version(), aurPkg.Version) >= 0 {
-					g.logger.Warnln(gotext.Get("%s is up to date -- skipping", text.Cyan(pkg.Name()+"-"+pkg.Version())))
-					continue
-				}
-			}
-		}
-
-		graph = g.GraphAURTarget(ctx, graph, aurPkg, &InstallInfo{
-			AURBase: &aurPkg.PackageBase,
-			Reason:  reason,
-			Source:  AUR,
-			Version: aurPkg.Version,
-		})
-		aurPkgsAdded = append(aurPkgsAdded, aurPkg)
-	}
-
-	g.AddDepsForPkgs(ctx, aurPkgsAdded, graph)
-
-	return graph, nil
-}
-
-// Removes found deps from the deps mapset and returns the found deps.
-func (g *Grapher) findDepsFromAUR(ctx context.Context,
-	deps mapset.Set[string],
-) []aurc.Pkg {
-	pkgsToAdd := make([]aurc.Pkg, 0, deps.Cardinality())
-	if deps.Cardinality() == 0 {
-		return []aurc.Pkg{}
-	}
-
-	missingNeedles := make([]string, 0, deps.Cardinality())
-	for _, depString := range deps.ToSlice() {
-		if _, ok := g.providerCache[depString]; !ok {
-			depName, _, _ := splitDep(depString)
-			missingNeedles = append(missingNeedles, depName)
-		}
-	}
-
-	if len(missingNeedles) != 0 {
-		g.logger.Debugln("deps to find", missingNeedles)
-		// provider search is more demanding than a simple search
-		// try to find name match if possible and then try to find provides.
-		aurPkgs, errCache := g.aurClient.Get(ctx, &aurc.Query{
-			By: aurc.Name, Needles: missingNeedles, Contains: false,
-		})
-		if errCache != nil {
-			g.logger.Errorln(errCache)
-		}
-
-		for i := range aurPkgs {
-			pkg := &aurPkgs[i]
-			if deps.Contains(pkg.Name) {
-				g.providerCache[pkg.Name] = append(g.providerCache[pkg.Name], *pkg)
-			}
-
-			for _, val := range pkg.Provides {
-				if val == pkg.Name {
-					continue
-				}
-				if deps.Contains(val) {
-					g.providerCache[val] = append(g.providerCache[val], *pkg)
-				}
-			}
-		}
-	}
-
-	for _, depString := range deps.ToSlice() {
-		var aurPkgs []aurc.Pkg
-		depName, _, _ := splitDep(depString)
-
-		if cachedProvidePkg, ok := g.providerCache[depString]; ok {
-			aurPkgs = cachedProvidePkg
-		} else {
-			var errA error
-			aurPkgs, errA = g.aurClient.Get(ctx, &aurc.Query{By: aurc.Provides, Needles: []string{depName}, Contains: true})
-			if errA != nil {
-				g.logger.Errorln(gotext.Get("Failed to find AUR package for"), depString, ":", errA)
-			}
-		}
-
-		// remove packages that don't satisfy the dependency
-		satisfyingPkgs := make([]aurc.Pkg, 0, len(aurPkgs))
-		for i := range aurPkgs {
-			if satisfiesAur(depString, &aurPkgs[i]) {
-				satisfyingPkgs = append(satisfyingPkgs, aurPkgs[i])
-			}
-		}
-		aurPkgs = satisfyingPkgs
-
-		if len(aurPkgs) == 0 {
-			g.logger.Errorln(gotext.Get("No AUR package found for"), " ", depString)
-
-			continue
-		}
-
-		pkg := aurPkgs[0]
-		if len(aurPkgs) > 1 {
-			chosen := g.provideMenu(depString, aurPkgs)
-			pkg = *chosen
-		}
-
-		g.providerCache[depString] = []aurc.Pkg{pkg}
-		deps.Remove(depString)
-		pkgsToAdd = append(pkgsToAdd, pkg)
-	}
-
-	return pkgsToAdd
-}
-
-func (g *Grapher) ValidateAndSetNodeInfo(graph *topo.Graph[string, *InstallInfo],
-	node string, nodeInfo *topo.NodeInfo[*InstallInfo],
-) {
-	info := graph.GetNodeInfo(node)
-	if info != nil && info.Value != nil {
-		if info.Value.Reason < nodeInfo.Value.Reason {
-			return // refuse to downgrade reason
-		}
-
-		if info.Value.Upgrade {
-			return // refuse to overwrite an upgrade
-		}
-	}
-
-	graph.SetNodeInfo(node, nodeInfo)
-}
-
-func (g *Grapher) addNodes(
-	ctx context.Context,
-	graph *topo.Graph[string, *InstallInfo],
-	parentPkgName string,
-	deps []string,
-	depType Reason,
-) {
-	targetsToFind := mapset.NewThreadUnsafeSet(deps...)
-	// Check if in graph already
-	for _, depString := range targetsToFind.ToSlice() {
-		depName, _, _ := splitDep(depString)
-		if !graph.Exists(depName) && !graph.ProvidesExists(depName) {
-			continue
-		}
-
-		if graph.Exists(depName) {
-			if err := graph.DependOn(depName, parentPkgName); err != nil {
-				g.logger.Warnln(depString, parentPkgName, err)
-			}
-
-			targetsToFind.Remove(depString)
-		}
-
-		if p := graph.GetProviderNode(depName); p != nil {
-			if provideSatisfies(p.String(), depString, p.Version) {
-				if err := graph.DependOn(p.Provider, parentPkgName); err != nil {
-					g.logger.Warnln(p.Provider, parentPkgName, err)
-				}
-
-				targetsToFind.Remove(depString)
-			}
-		}
-	}
-
-	// Check installed
-	for _, depString := range targetsToFind.ToSlice() {
-		depName, _, _ := splitDep(depString)
-		if !g.dbExecutor.LocalSatisfierExists(depString) {
-			continue
-		}
-
-		if g.fullGraph {
-			g.ValidateAndSetNodeInfo(
-				graph,
-				depName,
-				&topo.NodeInfo[*InstallInfo]{Color: colorMap[depType], Background: bgColorMap[Local]})
-
-			if err := graph.DependOn(depName, parentPkgName); err != nil {
-				g.logger.Warnln(depName, parentPkgName, err)
-			}
-		}
-
-		targetsToFind.Remove(depString)
-	}
-
-	// Check Sync
-	for _, depString := range targetsToFind.ToSlice() {
-		alpmPkg := g.dbExecutor.SyncSatisfier(depString)
-		if alpmPkg == nil {
-			continue
-		}
-
-		if err := graph.DependOn(alpmPkg.Name(), parentPkgName); err != nil {
-			g.logger.Warnln("repo dep warn:", depString, parentPkgName, err)
-		}
-
-		dbName := alpmPkg.DB().Name()
-		g.ValidateAndSetNodeInfo(
-			graph,
-			alpmPkg.Name(),
-			&topo.NodeInfo[*InstallInfo]{
-				Color:      colorMap[depType],
-				Background: bgColorMap[Sync],
-				Value: &InstallInfo{
-					Source:     Sync,
-					Reason:     depType,
-					Version:    alpmPkg.Version(),
-					SyncDBName: &dbName,
-				},
-			})
-
-		if newDeps := alpmPkg.Depends().Slice(); len(newDeps) != 0 && g.fullGraph {
-			newDepsSlice := make([]string, 0, len(newDeps))
-			for _, newDep := range newDeps {
-				newDepsSlice = append(newDepsSlice, newDep.Name)
-			}
-
-			g.addNodes(ctx, graph, alpmPkg.Name(), newDepsSlice, Dep)
-		}
-
-		targetsToFind.Remove(depString)
-	}
-
-	// Check AUR
-	pkgsToAdd := g.findDepsFromAUR(ctx, targetsToFind)
-	for i := range pkgsToAdd {
-		aurPkg := &pkgsToAdd[i]
-		if err := graph.DependOn(aurPkg.Name, parentPkgName); err != nil {
-			g.logger.Warnln("aur dep warn:", aurPkg.Name, parentPkgName, err)
-		}
-
-		graph.SetNodeInfo(
-			aurPkg.Name,
-			&topo.NodeInfo[*InstallInfo]{
-				Color:      colorMap[depType],
-				Background: bgColorMap[AUR],
-				Value: &InstallInfo{
-					Source:  AUR,
-					Reason:  depType,
-					AURBase: &aurPkg.PackageBase,
-					Version: aurPkg.Version,
-				},
-			})
-
-		g.addDepNodes(ctx, aurPkg, graph)
-	}
-
-	// Add missing to graph
-	for _, depString := range targetsToFind.ToSlice() {
-		depName, mod, ver := splitDep(depString)
-		// no dep found. add as missing
-		if err := graph.DependOn(depName, parentPkgName); err != nil {
-			g.logger.Warnln("missing dep warn:", depString, parentPkgName, err)
-		}
-		graph.SetNodeInfo(depName, &topo.NodeInfo[*InstallInfo]{
-			Color:      colorMap[depType],
-			Background: bgColorMap[Missing],
-			Value: &InstallInfo{
-				Source:  Missing,
-				Reason:  depType,
-				Version: fmt.Sprintf("%s%s", mod, ver),
-			},
-		})
-	}
-}
-
-func (g *Grapher) provideMenu(dep string, options []aur.Pkg) *aur.Pkg {
-	size := len(options)
-	if size == 1 {
-		return &options[0]
-	}
-
-	str := text.Bold(gotext.Get("There are %[1]d providers available for %[2]s:", size, dep))
-	str += "\n"
-
-	size = 1
-	str += g.logger.SprintOperationInfo(gotext.Get("Repository AUR"), "\n    ")
-
-	for i := range options {
-		str += fmt.Sprintf("%d) %s ", size, options[i].Name)
-		size++
-	}
-
-	g.logger.OperationInfoln(str)
-
-	for {
-		g.logger.Println(gotext.Get("\nEnter a number (default=1): "))
-
-		if g.noConfirm {
-			g.logger.Println("1")
-
-			return &options[0]
-		}
-
-		numberBuf, err := g.logger.GetInput("", false)
-		if err != nil {
-			g.logger.Errorln(err)
-
-			return &options[0]
-		}
-
-		if numberBuf == "" {
-			return &options[0]
-		}
-
-		num, err := strconv.Atoi(numberBuf)
-		if err != nil {
-			g.logger.Errorln(gotext.Get("invalid number: %s", numberBuf))
-
-			continue
-		}
-
-		if num < 1 || num >= size {
-			g.logger.Errorln(gotext.Get("invalid value: %d is not between %d and %d",
-				num, 1, size-1))
-
-			continue
-		}
-
-		return &options[num-1]
-	}
-}
-
-func makeAURPKGFromSrcinfo(dbExecutor db.Executor, srcInfo *gosrc.Srcinfo) ([]*aur.Pkg, error) {
-	pkgs := make([]*aur.Pkg, 0, 1)
-
-	alpmArch, err := dbExecutor.AlpmArchitectures()
-	if err != nil {
-		return nil, err
-	}
-
-	alpmArch = append(alpmArch, "") // srcinfo assumes no value as ""
-
-	getDesc := func(pkg *gosrc.Package) string {
-		if pkg.Pkgdesc != "" {
-			return pkg.Pkgdesc
-		}
-
-		return srcInfo.Pkgdesc
-	}
-
-	for i := range srcInfo.Packages {
-		pkg := &srcInfo.Packages[i]
-
-		pkgs = append(pkgs, &aur.Pkg{
-			ID:            0,
-			Name:          pkg.Pkgname,
-			PackageBaseID: 0,
-			PackageBase:   srcInfo.Pkgbase,
-			Version:       srcInfo.Version(),
-			Description:   getDesc(pkg),
-			URL:           pkg.URL,
-			Depends: append(archStringToString(alpmArch, pkg.Depends),
-				archStringToString(alpmArch, srcInfo.Depends)...),
-			MakeDepends:  archStringToString(alpmArch, srcInfo.MakeDepends),
-			CheckDepends: archStringToString(alpmArch, srcInfo.CheckDepends),
-			Conflicts: append(archStringToString(alpmArch, pkg.Conflicts),
-				archStringToString(alpmArch, srcInfo.Conflicts)...),
-			Provides: append(archStringToString(alpmArch, pkg.Provides),
-				archStringToString(alpmArch, srcInfo.Provides)...),
-			Replaces: append(archStringToString(alpmArch, pkg.Replaces),
-				archStringToString(alpmArch, srcInfo.Replaces)...),
-			OptDepends: append(archStringToString(alpmArch, pkg.OptDepends),
-				archStringToString(alpmArch, srcInfo.OptDepends)...),
-			Groups:   pkg.Groups,
-			License:  pkg.License,
-			Keywords: []string{},
-		})
-	}
-
-	return pkgs, nil
-}
-
-func archStringToString(alpmArches []string, archString []gosrc.ArchString) []string {
-	pkgs := make([]string, 0, len(archString))
-
-	for _, arch := range archString {
-		if db.ArchIsSupported(alpmArches, arch.Arch) {
-			pkgs = append(pkgs, arch.Value)
-		}
-	}
-
-	return pkgs
-}
-
-func aurDepModToAlpmDep(mod string) alpm.DepMod {
-	switch mod {
-	case "=":
-		return alpm.DepModEq
-	case ">=":
-		return alpm.DepModGE
-	case "<=":
-		return alpm.DepModLE
-	case ">":
-		return alpm.DepModGT
-	case "<":
-		return alpm.DepModLT
-	}
-	return alpm.DepModAny
-}

pkg/dep/dep_graph_test.go

@@ -1,811 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package dep
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"testing"
-
-	aurc "github.com/Jguer/aur"
-	alpm "github.com/Jguer/go-alpm/v2"
-	"github.com/stretchr/testify/require"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/db/mock"
-	mockaur "github.com/Jguer/yay/v12/pkg/dep/mock"
-	aur "github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-func ptrString(s string) *string {
-	return &s
-}
-
-func getFromFile(t *testing.T, filePath string) mockaur.GetFunc {
-	f, err := os.Open(filePath)
-	require.NoError(t, err)
-
-	fBytes, err := io.ReadAll(f)
-	require.NoError(t, err)
-
-	pkgs := []aur.Pkg{}
-	err = json.Unmarshal(fBytes, &pkgs)
-	require.NoError(t, err)
-
-	return func(ctx context.Context, query *aurc.Query) ([]aur.Pkg, error) {
-		return pkgs, nil
-	}
-}
-
-func TestGrapher_GraphFromTargets_jellyfin(t *testing.T) {
-	mockDB := &mock.DBExecutor{
-		SyncPackageFn: func(string) mock.IPackage { return nil },
-		SyncSatisfierFn: func(s string) mock.IPackage {
-			switch s {
-			case "jellyfin":
-				return nil
-			case "dotnet-runtime-6.0":
-				return &mock.Package{
-					PName:    "dotnet-runtime-6.0",
-					PBase:    "dotnet-runtime-6.0",
-					PVersion: "6.0.100-1",
-					PDB:      mock.NewDB("community"),
-				}
-			case "dotnet-sdk-6.0":
-				return &mock.Package{
-					PName:    "dotnet-sdk-6.0",
-					PBase:    "dotnet-sdk-6.0",
-					PVersion: "6.0.100-1",
-					PDB:      mock.NewDB("community"),
-				}
-			}
-
-			return nil
-		},
-		PackagesFromGroupFn: func(string) []mock.IPackage { return nil },
-		LocalSatisfierExistsFn: func(s string) bool {
-			switch s {
-			case "dotnet-sdk-6.0", "dotnet-runtime-6.0", "jellyfin-server=10.8.8", "jellyfin-web=10.8.8":
-				return false
-			}
-
-			return true
-		},
-		LocalPackageFn: func(string) mock.IPackage { return nil },
-	}
-
-	mockAUR := &mockaur.MockAUR{GetFn: func(ctx context.Context, query *aurc.Query) ([]aur.Pkg, error) {
-		if query.Needles[0] == "jellyfin" {
-			jfinFn := getFromFile(t, "testdata/jellyfin.json")
-			return jfinFn(ctx, query)
-		}
-
-		if query.Needles[0] == "jellyfin-web" {
-			jfinWebFn := getFromFile(t, "testdata/jellyfin-web.json")
-			return jfinWebFn(ctx, query)
-		}
-
-		if query.Needles[0] == "jellyfin-server" {
-			jfinServerFn := getFromFile(t, "testdata/jellyfin-server.json")
-			return jfinServerFn(ctx, query)
-		}
-
-		panic(fmt.Sprintf("implement me %v", query.Needles))
-	}}
-
-	type fields struct {
-		dbExecutor  db.Executor
-		aurCache    aurc.QueryClient
-		noDeps      bool
-		noCheckDeps bool
-	}
-	type args struct {
-		targets []string
-	}
-	tests := []struct {
-		name    string
-		fields  fields
-		args    args
-		want    []map[string]*InstallInfo
-		wantErr bool
-	}{
-		{
-			name: "noDeps",
-			fields: fields{
-				dbExecutor:  mockDB,
-				aurCache:    mockAUR,
-				noDeps:      true,
-				noCheckDeps: false,
-			},
-			args: args{
-				targets: []string{"jellyfin"},
-			},
-			want: []map[string]*InstallInfo{
-				{
-					"jellyfin": {
-						Source:  AUR,
-						Reason:  Explicit,
-						Version: "10.8.8-1",
-						AURBase: ptrString("jellyfin"),
-					},
-				},
-				{
-					"dotnet-sdk-6.0": {
-						Source:     Sync,
-						Reason:     MakeDep,
-						Version:    "6.0.100-1",
-						SyncDBName: ptrString("community"),
-					},
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "deps",
-			fields: fields{
-				dbExecutor:  mockDB,
-				aurCache:    mockAUR,
-				noDeps:      false,
-				noCheckDeps: false,
-			},
-			args: args{
-				targets: []string{"jellyfin"},
-			},
-			want: []map[string]*InstallInfo{
-				{
-					"jellyfin": {
-						Source:  AUR,
-						Reason:  Explicit,
-						Version: "10.8.8-1",
-						AURBase: ptrString("jellyfin"),
-					},
-				},
-				{
-					"jellyfin-web": {
-						Source:  AUR,
-						Reason:  Dep,
-						Version: "10.8.8-1",
-						AURBase: ptrString("jellyfin"),
-					},
-					"jellyfin-server": {
-						Source:  AUR,
-						Reason:  Dep,
-						Version: "10.8.8-1",
-						AURBase: ptrString("jellyfin"),
-					},
-				},
-				{
-					"dotnet-sdk-6.0": {
-						Source:     Sync,
-						Reason:     MakeDep,
-						Version:    "6.0.100-1",
-						SyncDBName: ptrString("community"),
-					},
-					"dotnet-runtime-6.0": {
-						Source:     Sync,
-						Reason:     Dep,
-						Version:    "6.0.100-1",
-						SyncDBName: ptrString("community"),
-					},
-				},
-			},
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			g := NewGrapher(tt.fields.dbExecutor,
-				tt.fields.aurCache, false, true,
-				tt.fields.noDeps, tt.fields.noCheckDeps, false,
-				text.NewLogger(io.Discard, io.Discard, &os.File{}, true, "test"))
-			got, err := g.GraphFromTargets(context.Background(), nil, tt.args.targets)
-			require.NoError(t, err)
-			layers := got.TopoSortedLayerMap(nil)
-			require.EqualValues(t, tt.want, layers, layers)
-		})
-	}
-}
-
-func TestGrapher_GraphProvides_androidsdk(t *testing.T) {
-	mockDB := &mock.DBExecutor{
-		SyncPackageFn: func(string) mock.IPackage { return nil },
-		SyncSatisfierFn: func(s string) mock.IPackage {
-			switch s {
-			case "android-sdk":
-				return nil
-			case "jdk11-openjdk":
-				return &mock.Package{
-					PName:    "jdk11-openjdk",
-					PVersion: "11.0.12.u7-1",
-					PDB:      mock.NewDB("community"),
-					PProvides: mock.DependList{
-						Depends: []alpm.Depend{
-							{Name: "java-environment", Version: "11", Mod: alpm.DepModEq},
-							{Name: "java-environment-openjdk", Version: "11", Mod: alpm.DepModEq},
-							{Name: "jdk11-openjdk", Version: "11.0.19.u7-1", Mod: alpm.DepModEq},
-						},
-					},
-				}
-			case "java-environment":
-				panic("not supposed to be called")
-			}
-			panic("implement me " + s)
-		},
-		PackagesFromGroupFn: func(string) []mock.IPackage { return nil },
-		LocalSatisfierExistsFn: func(s string) bool {
-			switch s {
-			case "java-environment":
-				return false
-			}
-
-			switch s {
-			case "libxtst", "fontconfig", "freetype2", "lib32-gcc-libs", "lib32-glibc", "libx11", "libxext", "libxrender", "zlib", "gcc-libs":
-				return true
-			}
-
-			panic("implement me " + s)
-		},
-		LocalPackageFn: func(string) mock.IPackage { return nil },
-	}
-
-	mockAUR := &mockaur.MockAUR{GetFn: func(ctx context.Context, query *aurc.Query) ([]aur.Pkg, error) {
-		if query.Needles[0] == "android-sdk" {
-			jfinFn := getFromFile(t, "testdata/android-sdk.json")
-			return jfinFn(ctx, query)
-		}
-
-		panic(fmt.Sprintf("implement me %v", query.Needles))
-	}}
-
-	type fields struct {
-		dbExecutor  db.Executor
-		aurCache    aurc.QueryClient
-		noDeps      bool
-		noCheckDeps bool
-	}
-	type args struct {
-		targets []string
-	}
-	tests := []struct {
-		name    string
-		fields  fields
-		args    args
-		want    []map[string]*InstallInfo
-		wantErr bool
-	}{
-		{
-			name: "explicit dep",
-			fields: fields{
-				dbExecutor:  mockDB,
-				aurCache:    mockAUR,
-				noDeps:      false,
-				noCheckDeps: false,
-			},
-			args: args{
-				targets: []string{"android-sdk", "jdk11-openjdk"},
-			},
-			want: []map[string]*InstallInfo{
-				{
-					"android-sdk": {
-						Source:  AUR,
-						Reason:  Explicit,
-						Version: "26.1.1-2",
-						AURBase: ptrString("android-sdk"),
-					},
-				},
-				{
-					"jdk11-openjdk": {
-						Source:     Sync,
-						Reason:     Explicit,
-						Version:    "11.0.12.u7-1",
-						SyncDBName: ptrString("community"),
-					},
-				},
-			},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			g := NewGrapher(tt.fields.dbExecutor,
-				tt.fields.aurCache, false, true,
-				tt.fields.noDeps, tt.fields.noCheckDeps, false,
-				text.NewLogger(io.Discard, io.Discard, &os.File{}, true, "test"))
-			got, err := g.GraphFromTargets(context.Background(), nil, tt.args.targets)
-			require.NoError(t, err)
-			layers := got.TopoSortedLayerMap(nil)
-			require.EqualValues(t, tt.want, layers, layers)
-		})
-	}
-}
-
-func TestGrapher_GraphFromAUR_Deps_ceph_bin(t *testing.T) {
-	mockDB := &mock.DBExecutor{
-		SyncPackageFn:       func(string) mock.IPackage { return nil },
-		PackagesFromGroupFn: func(string) []mock.IPackage { return []mock.IPackage{} },
-		SyncSatisfierFn: func(s string) mock.IPackage {
-			switch s {
-			case "ceph-bin", "ceph-libs-bin":
-				return nil
-			case "ceph", "ceph-libs", "ceph-libs=17.2.6-2":
-				return nil
-			}
-
-			panic("implement me " + s)
-		},
-
-		LocalSatisfierExistsFn: func(s string) bool {
-			switch s {
-			case "ceph-libs", "ceph-libs=17.2.6-2":
-				return false
-			case "dep1", "dep2", "dep3", "makedep1", "makedep2", "checkdep1":
-				return true
-			}
-
-			panic("implement me " + s)
-		},
-		LocalPackageFn: func(string) mock.IPackage { return nil },
-	}
-
-	mockAUR := &mockaur.MockAUR{GetFn: func(ctx context.Context, query *aurc.Query) ([]aur.Pkg, error) {
-		mockPkgs := map[string]aur.Pkg{
-			"ceph-bin": {
-				Name:        "ceph-bin",
-				PackageBase: "ceph-bin",
-				Version:     "17.2.6-2",
-				Depends:     []string{"ceph-libs=17.2.6-2", "dep1"},
-				Provides:    []string{"ceph=17.2.6-2"},
-			},
-			"ceph-libs-bin": {
-				Name:        "ceph-libs-bin",
-				PackageBase: "ceph-bin",
-				Version:     "17.2.6-2",
-				Depends:     []string{"dep1", "dep2"},
-				Provides:    []string{"ceph-libs=17.2.6-2"},
-			},
-			"ceph": {
-				Name:         "ceph",
-				PackageBase:  "ceph",
-				Version:      "17.2.6-2",
-				Depends:      []string{"ceph-libs=17.2.6-2", "dep1"},
-				MakeDepends:  []string{"makedep1"},
-				CheckDepends: []string{"checkdep1"},
-				Provides:     []string{"ceph=17.2.6-2"},
-			},
-			"ceph-libs": {
-				Name:         "ceph-libs",
-				PackageBase:  "ceph",
-				Version:      "17.2.6-2",
-				Depends:      []string{"dep1", "dep2", "dep3"},
-				MakeDepends:  []string{"makedep1", "makedep2"},
-				CheckDepends: []string{"checkdep1"},
-				Provides:     []string{"ceph-libs=17.2.6-2"},
-			},
-		}
-
-		pkgs := []aur.Pkg{}
-		for _, needle := range query.Needles {
-			if pkg, ok := mockPkgs[needle]; ok {
-				pkgs = append(pkgs, pkg)
-			} else {
-				panic(fmt.Sprintf("implement me %v", needle))
-			}
-		}
-
-		return pkgs, nil
-	}}
-
-	installInfos := map[string]*InstallInfo{
-		"ceph-bin exp": {
-			Source:  AUR,
-			Reason:  Explicit,
-			Version: "17.2.6-2",
-			AURBase: ptrString("ceph-bin"),
-		},
-		"ceph-libs-bin exp": {
-			Source:  AUR,
-			Reason:  Explicit,
-			Version: "17.2.6-2",
-			AURBase: ptrString("ceph-bin"),
-		},
-		"ceph exp": {
-			Source:  AUR,
-			Reason:  Explicit,
-			Version: "17.2.6-2",
-			AURBase: ptrString("ceph"),
-		},
-		"ceph-libs exp": {
-			Source:  AUR,
-			Reason:  Explicit,
-			Version: "17.2.6-2",
-			AURBase: ptrString("ceph"),
-		},
-		"ceph-libs dep": {
-			Source:  AUR,
-			Reason:  Dep,
-			Version: "17.2.6-2",
-			AURBase: ptrString("ceph"),
-		},
-	}
-
-	tests := []struct {
-		name       string
-		targets    []string
-		wantLayers []map[string]*InstallInfo
-		wantErr    bool
-	}{
-		{
-			name:    "ceph-bin ceph-libs-bin",
-			targets: []string{"ceph-bin", "ceph-libs-bin"},
-			wantLayers: []map[string]*InstallInfo{
-				{"ceph-bin": installInfos["ceph-bin exp"]},
-				{"ceph-libs-bin": installInfos["ceph-libs-bin exp"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "ceph-libs-bin ceph-bin (reversed order)",
-			targets: []string{"ceph-libs-bin", "ceph-bin"},
-			wantLayers: []map[string]*InstallInfo{
-				{"ceph-bin": installInfos["ceph-bin exp"]},
-				{"ceph-libs-bin": installInfos["ceph-libs-bin exp"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "ceph",
-			targets: []string{"ceph"},
-			wantLayers: []map[string]*InstallInfo{
-				{"ceph": installInfos["ceph exp"]},
-				{"ceph-libs": installInfos["ceph-libs dep"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "ceph-bin",
-			targets: []string{"ceph-bin"},
-			wantLayers: []map[string]*InstallInfo{
-				{"ceph-bin": installInfos["ceph-bin exp"]},
-				{"ceph-libs": installInfos["ceph-libs dep"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "ceph-bin ceph-libs",
-			targets: []string{"ceph-bin", "ceph-libs"},
-			wantLayers: []map[string]*InstallInfo{
-				{"ceph-bin": installInfos["ceph-bin exp"]},
-				{"ceph-libs": installInfos["ceph-libs exp"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "ceph-libs ceph-bin (reversed order)",
-			targets: []string{"ceph-libs", "ceph-bin"},
-			wantLayers: []map[string]*InstallInfo{
-				{"ceph-bin": installInfos["ceph-bin exp"]},
-				{"ceph-libs": installInfos["ceph-libs exp"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "ceph ceph-libs-bin",
-			targets: []string{"ceph", "ceph-libs-bin"},
-			wantLayers: []map[string]*InstallInfo{
-				{"ceph": installInfos["ceph exp"]},
-				{"ceph-libs-bin": installInfos["ceph-libs-bin exp"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "ceph-libs-bin ceph (reversed order)",
-			targets: []string{"ceph-libs-bin", "ceph"},
-			wantLayers: []map[string]*InstallInfo{
-				{"ceph": installInfos["ceph exp"]},
-				{"ceph-libs-bin": installInfos["ceph-libs-bin exp"]},
-			},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			g := NewGrapher(mockDB, mockAUR,
-				false, true, false, false, false,
-				text.NewLogger(io.Discard, io.Discard, &os.File{}, true, "test"))
-			got, err := g.GraphFromTargets(context.Background(), nil, tt.targets)
-			require.NoError(t, err)
-			layers := got.TopoSortedLayerMap(nil)
-			require.EqualValues(t, tt.wantLayers, layers, layers)
-		})
-	}
-}
-
-func TestGrapher_GraphFromAUR_Deps_gourou(t *testing.T) {
-	mockDB := &mock.DBExecutor{
-		SyncPackageFn:       func(string) mock.IPackage { return nil },
-		PackagesFromGroupFn: func(string) []mock.IPackage { return []mock.IPackage{} },
-		SyncSatisfierFn: func(s string) mock.IPackage {
-			switch s {
-			case "gourou", "libzip-git":
-				return nil
-			case "libzip":
-				return &mock.Package{
-					PName:    "libzip",
-					PVersion: "1.9.2-1",
-					PDB:      mock.NewDB("extra"),
-				}
-			}
-
-			panic("implement me " + s)
-		},
-
-		LocalSatisfierExistsFn: func(s string) bool {
-			switch s {
-			case "gourou", "libzip", "libzip-git":
-				return false
-			case "dep1", "dep2":
-				return true
-			}
-
-			panic("implement me " + s)
-		},
-		LocalPackageFn: func(string) mock.IPackage { return nil },
-	}
-
-	mockAUR := &mockaur.MockAUR{GetFn: func(ctx context.Context, query *aurc.Query) ([]aur.Pkg, error) {
-		mockPkgs := map[string]aur.Pkg{
-			"gourou": {
-				Name:        "gourou",
-				PackageBase: "gourou",
-				Version:     "0.8.1",
-				Depends:     []string{"libzip"},
-			},
-			"libzip-git": {
-				Name:        "libzip-git",
-				PackageBase: "libzip-git",
-				Version:     "1.9.2.r159.gb3ac716c-1",
-				Depends:     []string{"dep1", "dep2"},
-				Provides:    []string{"libzip=1.9.2.r159.gb3ac716c"},
-			},
-		}
-
-		pkgs := []aur.Pkg{}
-		for _, needle := range query.Needles {
-			if pkg, ok := mockPkgs[needle]; ok {
-				pkgs = append(pkgs, pkg)
-			} else {
-				panic(fmt.Sprintf("implement me %v", needle))
-			}
-		}
-
-		return pkgs, nil
-	}}
-
-	installInfos := map[string]*InstallInfo{
-		"gourou exp": {
-			Source:  AUR,
-			Reason:  Explicit,
-			Version: "0.8.1",
-			AURBase: ptrString("gourou"),
-		},
-		"libzip dep": {
-			Source:     Sync,
-			Reason:     Dep,
-			Version:    "1.9.2-1",
-			SyncDBName: ptrString("extra"),
-		},
-		"libzip exp": {
-			Source:     Sync,
-			Reason:     Explicit,
-			Version:    "1.9.2-1",
-			SyncDBName: ptrString("extra"),
-		},
-		"libzip-git exp": {
-			Source:  AUR,
-			Reason:  Explicit,
-			Version: "1.9.2.r159.gb3ac716c-1",
-			AURBase: ptrString("libzip-git"),
-		},
-	}
-
-	tests := []struct {
-		name       string
-		targets    []string
-		wantLayers []map[string]*InstallInfo
-		wantErr    bool
-	}{
-		{
-			name:    "gourou",
-			targets: []string{"gourou"},
-			wantLayers: []map[string]*InstallInfo{
-				{"gourou": installInfos["gourou exp"]},
-				{"libzip": installInfos["libzip dep"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "gourou libzip",
-			targets: []string{"gourou", "libzip"},
-			wantLayers: []map[string]*InstallInfo{
-				{"gourou": installInfos["gourou exp"]},
-				{"libzip": installInfos["libzip exp"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "gourou libzip-git",
-			targets: []string{"gourou", "libzip-git"},
-			wantLayers: []map[string]*InstallInfo{
-				{"gourou": installInfos["gourou exp"]},
-				{"libzip-git": installInfos["libzip-git exp"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "libzip-git gourou (reversed order)",
-			targets: []string{"libzip-git", "gourou"},
-			wantLayers: []map[string]*InstallInfo{
-				{"gourou": installInfos["gourou exp"]},
-				{"libzip-git": installInfos["libzip-git exp"]},
-			},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			g := NewGrapher(mockDB, mockAUR,
-				false, true, false, false, false,
-				text.NewLogger(io.Discard, io.Discard, &os.File{}, true, "test"))
-			got, err := g.GraphFromTargets(context.Background(), nil, tt.targets)
-			require.NoError(t, err)
-			layers := got.TopoSortedLayerMap(nil)
-			require.EqualValues(t, tt.wantLayers, layers, layers)
-		})
-	}
-}
-
-func TestGrapher_GraphFromTargets_ReinstalledDeps(t *testing.T) {
-	mockDB := &mock.DBExecutor{
-		SyncPackageFn:       func(string) mock.IPackage { return nil },
-		PackagesFromGroupFn: func(string) []mock.IPackage { return []mock.IPackage{} },
-		SyncSatisfierFn: func(s string) mock.IPackage {
-			switch s {
-			case "gourou":
-				return nil
-			case "libzip":
-				return &mock.Package{
-					PName:    "libzip",
-					PVersion: "1.9.2-1",
-					PDB:      mock.NewDB("extra"),
-				}
-			}
-
-			panic("implement me " + s)
-		},
-		SatisfierFromDBFn: func(s, s2 string) (mock.IPackage, error) {
-			if s2 == "extra" {
-				switch s {
-				case "libzip":
-					return &mock.Package{
-						PName:    "libzip",
-						PVersion: "1.9.2-1",
-						PDB:      mock.NewDB("extra"),
-					}, nil
-				}
-			}
-
-			panic("implement me " + s2 + "/" + s)
-		},
-
-		LocalSatisfierExistsFn: func(s string) bool {
-			switch s {
-			case "gourou", "libzip":
-				return true
-			}
-
-			panic("implement me " + s)
-		},
-		LocalPackageFn: func(s string) mock.IPackage {
-			switch s {
-			case "libzip":
-				return &mock.Package{
-					PName:    "libzip",
-					PVersion: "1.9.2-1",
-					PDB:      mock.NewDB("extra"),
-					PReason:  alpm.PkgReasonDepend,
-				}
-			case "gourou":
-				return &mock.Package{
-					PName:    "gourou",
-					PVersion: "0.8.1",
-					PDB:      mock.NewDB("aur"),
-					PReason:  alpm.PkgReasonDepend,
-				}
-			}
-			return nil
-		},
-	}
-
-	mockAUR := &mockaur.MockAUR{GetFn: func(ctx context.Context, query *aurc.Query) ([]aur.Pkg, error) {
-		mockPkgs := map[string]aur.Pkg{
-			"gourou": {
-				Name:        "gourou",
-				PackageBase: "gourou",
-				Version:     "0.8.1",
-				Depends:     []string{"libzip"},
-			},
-		}
-
-		pkgs := []aur.Pkg{}
-		for _, needle := range query.Needles {
-			if pkg, ok := mockPkgs[needle]; ok {
-				pkgs = append(pkgs, pkg)
-			} else {
-				panic(fmt.Sprintf("implement me %v", needle))
-			}
-		}
-
-		return pkgs, nil
-	}}
-
-	installInfos := map[string]*InstallInfo{
-		"gourou dep": {
-			Source:  AUR,
-			Reason:  Dep,
-			Version: "0.8.1",
-			AURBase: ptrString("gourou"),
-		},
-		"libzip dep": {
-			Source:     Sync,
-			Reason:     Dep,
-			Version:    "1.9.2-1",
-			SyncDBName: ptrString("extra"),
-		},
-	}
-
-	tests := []struct {
-		name       string
-		targets    []string
-		wantLayers []map[string]*InstallInfo
-		wantErr    bool
-	}{
-		{
-			name:    "gourou libzip",
-			targets: []string{"gourou", "libzip"},
-			wantLayers: []map[string]*InstallInfo{
-				{"gourou": installInfos["gourou dep"]},
-				{"libzip": installInfos["libzip dep"]},
-			},
-			wantErr: false,
-		},
-		{
-			name:    "aur/gourou extra/libzip",
-			targets: []string{"aur/gourou", "extra/libzip"},
-			wantLayers: []map[string]*InstallInfo{
-				{"gourou": installInfos["gourou dep"]},
-				{"libzip": installInfos["libzip dep"]},
-			},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			g := NewGrapher(mockDB, mockAUR,
-				false, true, false, false, false,
-				text.NewLogger(io.Discard, io.Discard, &os.File{}, true, "test"))
-			got, err := g.GraphFromTargets(context.Background(), nil, tt.targets)
-			require.NoError(t, err)
-			layers := got.TopoSortedLayerMap(nil)
-			require.EqualValues(t, tt.wantLayers, layers, layers)
-		})
-	}
-}

pkg/dep/mock/aur.go

@@ -1,21 +0,0 @@
-package mock
-
-import (
-	"context"
-
-	"github.com/Jguer/aur"
-)
-
-type GetFunc func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error)
-
-type MockAUR struct {
-	GetFn GetFunc
-}
-
-func (m *MockAUR) Get(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-	if m.GetFn != nil {
-		return m.GetFn(ctx, query)
-	}
-
-	panic("implement me")
-}

pkg/dep/target_handler.go

@@ -1,34 +0,0 @@
-package dep
-
-import "github.com/Jguer/yay/v12/pkg/text"
-
-type Target struct {
-	DB      string
-	Name    string
-	Mod     string
-	Version string
-}
-
-func ToTarget(pkg string) Target {
-	dbName, depString := text.SplitDBFromName(pkg)
-	name, mod, depVersion := splitDep(depString)
-
-	return Target{
-		DB:      dbName,
-		Name:    name,
-		Mod:     mod,
-		Version: depVersion,
-	}
-}
-
-func (t Target) DepString() string {
-	return t.Name + t.Mod + t.Version
-}
-
-func (t Target) String() string {
-	if t.DB != "" {
-		return t.DB + "/" + t.DepString()
-	}
-
-	return t.DepString()
-}

pkg/dep/testdata/android-sdk.json

@@ -1,3 +0,0 @@
-[
-{"ID":1055234,"Name":"android-sdk","PackageBaseID":13751,"PackageBase":"android-sdk","Version":"26.1.1-2","Description":"Google Android SDK","URL":"https://developer.android.com/studio/releases/sdk-tools.html","NumVotes":1487,"Popularity":0.802316,"OutOfDate":null,"Maintainer":"dreamingincode","Submitter":null,"FirstSubmitted":1194895596,"LastModified":1647982720,"URLPath":"/cgit/aur.git/snapshot/android-sdk.tar.gz","Depends":["java-environment","libxtst","fontconfig","freetype2","lib32-gcc-libs","lib32-glibc","libx11","libxext","libxrender","zlib","gcc-libs"],"OptDepends":["android-emulator","android-sdk-platform-tools","android-udev"],"License":["custom"],"Keywords":["android","development"]}
-]

pkg/dep/testdata/jellyfin-server.json

@@ -1,3 +0,0 @@
-[
-    {"ID":1176791,"Name":"jellyfin-server","PackageBaseID":138631,"PackageBase":"jellyfin","Version":"10.8.8-1","Description":"Jellyfin server component","URL":"https://github.com/jellyfin/jellyfin","NumVotes":84,"Popularity":1.272964,"OutOfDate":null,"Maintainer":"z3ntu","Submitter":"z3ntu","FirstSubmitted":1547053171,"LastModified":1669830147,"URLPath":"/cgit/aur.git/snapshot/jellyfin-server.tar.gz","Depends":["dotnet-runtime-6.0","aspnet-runtime-6.0","ffmpeg","sqlite"],"MakeDepends":["dotnet-sdk-6.0","nodejs","npm","git"],"License":["GPL2"]}
-]

pkg/dep/testdata/jellyfin-web.json

@@ -1,3 +0,0 @@
-[
-{"ID":1176790,"Name":"jellyfin-web","PackageBaseID":138631,"PackageBase":"jellyfin","Version":"10.8.8-1","Description":"Jellyfin web client","URL":"https://github.com/jellyfin/jellyfin","NumVotes":84,"Popularity":1.272964,"OutOfDate":null,"Maintainer":"z3ntu","Submitter":"z3ntu","FirstSubmitted":1547053171,"LastModified":1669830147,"URLPath":"/cgit/aur.git/snapshot/jellyfin-web.tar.gz","MakeDepends":["dotnet-sdk-6.0","nodejs","npm","git"],"License":["GPL2"]}
-]

pkg/dep/testdata/jellyfin.json

@@ -1,3 +0,0 @@
-[
-    {"ID":1176789,"Name":"jellyfin","PackageBaseID":138631,"PackageBase":"jellyfin","Version":"10.8.8-1","Description":"The Free Software Media System","URL":"https://github.com/jellyfin/jellyfin","NumVotes":84,"Popularity":1.272964,"OutOfDate":null,"Maintainer":"z3ntu","Submitter":"z3ntu","FirstSubmitted":1547053171,"LastModified":1669830147,"URLPath":"/cgit/aur.git/snapshot/jellyfin.tar.gz","Depends":["jellyfin-web=10.8.8","jellyfin-server=10.8.8"],"MakeDepends":["dotnet-sdk-6.0","nodejs","npm","git"],"License":["GPL2"]}
-]

pkg/dep/topo/dep.go

@@ -1,371 +0,0 @@
-package topo
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/Jguer/go-alpm/v2"
-)
-
-type (
-	NodeSet[T comparable]     map[T]bool
-	ProvidesMap[T comparable] map[T]*DependencyInfo[T]
-	DepMap[T comparable]      map[T]NodeSet[T]
-)
-
-func (n NodeSet[T]) Slice() []T {
-	var slice []T
-
-	for node := range n {
-		slice = append(slice, node)
-	}
-
-	return slice
-}
-
-type NodeInfo[V any] struct {
-	Color      string
-	Background string
-	Value      V
-}
-
-type DependencyInfo[T comparable] struct {
-	Provider T
-	alpm.Depend
-}
-
-type CheckFn[T comparable, V any] func(T, V) error
-
-type Graph[T comparable, V any] struct {
-	nodes NodeSet[T]
-
-	// node info map
-	nodeInfo map[T]*NodeInfo[V]
-
-	// `provides` tracks provides -> node.
-	provides ProvidesMap[T]
-
-	// `dependencies` tracks child -> parents.
-	dependencies DepMap[T]
-	// `dependents` tracks parent -> children.
-	dependents DepMap[T]
-}
-
-func New[T comparable, V any]() *Graph[T, V] {
-	return &Graph[T, V]{
-		nodes:        make(NodeSet[T]),
-		dependencies: make(DepMap[T]),
-		dependents:   make(DepMap[T]),
-		nodeInfo:     make(map[T]*NodeInfo[V]),
-		provides:     make(ProvidesMap[T]),
-	}
-}
-
-func (g *Graph[T, V]) Len() int {
-	return len(g.nodes)
-}
-
-func (g *Graph[T, V]) Exists(node T) bool {
-	_, ok := g.nodes[node]
-
-	return ok
-}
-
-func (g *Graph[T, V]) AddNode(node T) {
-	g.nodes[node] = true
-}
-
-func (g *Graph[T, V]) ProvidesExists(provides T) bool {
-	_, ok := g.provides[provides]
-
-	return ok
-}
-
-func (g *Graph[T, V]) GetProviderNode(provides T) *DependencyInfo[T] {
-	return g.provides[provides]
-}
-
-func (g *Graph[T, V]) Provides(provides T, depInfo *alpm.Depend, node T) {
-	g.provides[provides] = &DependencyInfo[T]{
-		Provider: node,
-		Depend:   *depInfo,
-	}
-}
-
-func (g *Graph[T, V]) ForEach(f CheckFn[T, V]) error {
-	for node := range g.nodes {
-		if err := f(node, g.nodeInfo[node].Value); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (g *Graph[T, V]) SetNodeInfo(node T, nodeInfo *NodeInfo[V]) {
-	g.nodeInfo[node] = nodeInfo
-}
-
-func (g *Graph[T, V]) GetNodeInfo(node T) *NodeInfo[V] {
-	return g.nodeInfo[node]
-}
-
-func (g *Graph[T, V]) DependOn(child, parent T) error {
-	if child == parent {
-		return ErrSelfReferential
-	}
-
-	if g.DependsOn(parent, child) {
-		return ErrCircular
-	}
-
-	g.AddNode(parent)
-	g.AddNode(child)
-
-	// Add edges.
-	g.dependents.addNodeToNodeset(parent, child)
-	g.dependencies.addNodeToNodeset(child, parent)
-
-	return nil
-}
-
-func (g *Graph[T, V]) String() string {
-	var sb strings.Builder
-
-	sb.WriteString("digraph {\n")
-	sb.WriteString("compound=true;\n")
-	sb.WriteString("concentrate=true;\n")
-	sb.WriteString("node [shape = record, ordering=out];\n")
-
-	for node := range g.nodes {
-		extra := ""
-
-		if info, ok := g.nodeInfo[node]; ok {
-			if info.Background != "" || info.Color != "" {
-				extra = fmt.Sprintf("[color = %s, style = filled, fillcolor = %s]", info.Color, info.Background)
-			}
-		}
-
-		sb.WriteString(fmt.Sprintf("\t\"%v\"%s;\n", node, extra))
-	}
-
-	for parent, children := range g.dependencies {
-		for child := range children {
-			sb.WriteString(fmt.Sprintf("\t\"%v\" -> \"%v\";\n", parent, child))
-		}
-	}
-
-	sb.WriteString("}")
-
-	return sb.String()
-}
-
-func (g *Graph[T, V]) DependsOn(child, parent T) bool {
-	deps := g.Dependencies(child)
-	_, ok := deps[parent]
-
-	return ok
-}
-
-func (g *Graph[T, V]) HasDependent(parent, child T) bool {
-	deps := g.Dependents(parent)
-	_, ok := deps[child]
-
-	return ok
-}
-
-// leavesMap returns a map of leaves with the node as key and the node info value as value.
-func (g *Graph[T, V]) leavesMap() map[T]V {
-	leaves := make(map[T]V, 0)
-
-	for node := range g.nodes {
-		if _, ok := g.dependencies[node]; !ok {
-			nodeInfo := g.GetNodeInfo(node)
-			if nodeInfo == nil {
-				nodeInfo = &NodeInfo[V]{}
-			}
-
-			leaves[node] = nodeInfo.Value
-		}
-	}
-
-	return leaves
-}
-
-// TopoSortedLayerMap returns a slice of all of the graph nodes in topological sort order with their node info.
-func (g *Graph[T, V]) TopoSortedLayerMap(checkFn CheckFn[T, V]) []map[T]V {
-	layers := []map[T]V{}
-
-	// Copy the graph
-	shrinkingGraph := g.clone()
-
-	for {
-		leaves := shrinkingGraph.leavesMap()
-		if len(leaves) == 0 {
-			break
-		}
-
-		layers = append(layers, leaves)
-
-		for leafNode := range leaves {
-			if checkFn != nil {
-				if err := checkFn(leafNode, leaves[leafNode]); err != nil {
-					return nil
-				}
-			}
-			shrinkingGraph.remove(leafNode)
-		}
-	}
-
-	return layers
-}
-
-// returns if it was the last
-func (dm DepMap[T]) removeFromDepmap(key, node T) bool {
-	if nodes := dm[key]; len(nodes) == 1 {
-		// The only element in the nodeset must be `node`, so we
-		// can delete the entry entirely.
-		delete(dm, key)
-		return true
-	} else {
-		// Otherwise, remove the single node from the nodeset.
-		delete(nodes, node)
-		return false
-	}
-}
-
-// Prune removes the node,
-// its dependencies if there are no other dependents
-// and its dependents
-func (g *Graph[T, V]) Prune(node T) []T {
-	pruned := []T{node}
-	// Remove edges from things that depend on `node`.
-	for dependent := range g.dependents[node] {
-		last := g.dependencies.removeFromDepmap(dependent, node)
-		if last {
-			pruned = append(pruned, g.Prune(dependent)...)
-		}
-	}
-
-	delete(g.dependents, node)
-
-	// Remove all edges from node to the things it depends on.
-	for dependency := range g.dependencies[node] {
-		last := g.dependents.removeFromDepmap(dependency, node)
-		if last {
-			pruned = append(pruned, g.Prune(dependency)...)
-		}
-	}
-
-	delete(g.dependencies, node)
-
-	// Finally, remove the node itself.
-	delete(g.nodes, node)
-	return pruned
-}
-
-func (g *Graph[T, V]) remove(node T) {
-	// Remove edges from things that depend on `node`.
-	for dependent := range g.dependents[node] {
-		g.dependencies.removeFromDepmap(dependent, node)
-	}
-
-	delete(g.dependents, node)
-
-	// Remove all edges from node to the things it depends on.
-	for dependency := range g.dependencies[node] {
-		g.dependents.removeFromDepmap(dependency, node)
-	}
-
-	delete(g.dependencies, node)
-
-	// Finally, remove the node itself.
-	delete(g.nodes, node)
-}
-
-func (g *Graph[T, V]) Dependencies(child T) NodeSet[T] {
-	return g.buildTransitive(child, g.ImmediateDependencies)
-}
-
-func (g *Graph[T, V]) ImmediateDependencies(node T) NodeSet[T] {
-	return g.dependencies[node]
-}
-
-func (g *Graph[T, V]) Dependents(parent T) NodeSet[T] {
-	return g.buildTransitive(parent, g.immediateDependents)
-}
-
-func (g *Graph[T, V]) immediateDependents(node T) NodeSet[T] {
-	return g.dependents[node]
-}
-
-func (g *Graph[T, V]) clone() *Graph[T, V] {
-	return &Graph[T, V]{
-		dependencies: g.dependencies.copy(),
-		dependents:   g.dependents.copy(),
-		nodes:        g.nodes.copy(),
-		nodeInfo:     g.nodeInfo, // not copied, as it is not modified
-	}
-}
-
-// buildTransitive starts at `root` and continues calling `nextFn` to keep discovering more nodes until
-// the graph cannot produce any more. It returns the set of all discovered nodes.
-func (g *Graph[T, V]) buildTransitive(root T, nextFn func(T) NodeSet[T]) NodeSet[T] {
-	if _, ok := g.nodes[root]; !ok {
-		return nil
-	}
-
-	out := make(NodeSet[T])
-	searchNext := []T{root}
-
-	for len(searchNext) > 0 {
-		// List of new nodes from this layer of the dependency graph. This is
-		// assigned to `searchNext` at the end of the outer "discovery" loop.
-		discovered := []T{}
-
-		for _, node := range searchNext {
-			// For each node to discover, find the next nodes.
-			for nextNode := range nextFn(node) {
-				// If we have not seen the node before, add it to the output as well
-				// as the list of nodes to traverse in the next iteration.
-				if _, ok := out[nextNode]; !ok {
-					out[nextNode] = true
-
-					discovered = append(discovered, nextNode)
-				}
-			}
-		}
-
-		searchNext = discovered
-	}
-
-	return out
-}
-
-func (s NodeSet[T]) copy() NodeSet[T] {
-	out := make(NodeSet[T], len(s))
-	for k, v := range s {
-		out[k] = v
-	}
-
-	return out
-}
-
-func (dm DepMap[T]) copy() DepMap[T] {
-	out := make(DepMap[T], len(dm))
-	for k := range dm {
-		out[k] = dm[k].copy()
-	}
-
-	return out
-}
-
-func (dm DepMap[T]) addNodeToNodeset(key, node T) {
-	nodes, ok := dm[key]
-	if !ok {
-		nodes = make(NodeSet[T])
-		dm[key] = nodes
-	}
-
-	nodes[node] = true
-}

pkg/dep/topo/errors.go

@@ -1,9 +0,0 @@
-package topo
-
-import "errors"
-
-var (
-	ErrSelfReferential  = errors.New(" self-referential dependencies not allowed")
-	ErrConflictingAlias = errors.New(" alias already defined")
-	ErrCircular         = errors.New(" circular dependencies not allowed")
-)

pkg/download/abs.go

@@ -1,92 +0,0 @@
-package download
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"regexp"
-
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-)
-
-const (
-	MaxConcurrentFetch = 20
-	absPackageURL      = "https://gitlab.archlinux.org/archlinux/packaging/packages"
-)
-
-var (
-	ErrInvalidRepository  = errors.New(gotext.Get("invalid repository"))
-	ErrABSPackageNotFound = errors.New(gotext.Get("package not found in repos"))
-)
-
-type regexReplace struct {
-	repl  string
-	match *regexp.Regexp
-}
-
-// regex replacements for Gitlab URLs
-// info: https://gitlab.archlinux.org/archlinux/devtools/-/blob/6ce666a1669235749c17d5c44d8a24dea4a135da/src/lib/api/gitlab.sh#L84
-var gitlabRepl = []regexReplace{
-	{repl: `$1-$2`, match: regexp.MustCompile(`([a-zA-Z0-9]+)\+([a-zA-Z]+)`)},
-	{repl: `plus`, match: regexp.MustCompile(`\+`)},
-	{repl: `-`, match: regexp.MustCompile(`[^a-zA-Z0-9_\-.]`)},
-	{repl: `-`, match: regexp.MustCompile(`[_\-]{2,}`)},
-	{repl: `unix-tree`, match: regexp.MustCompile(`^tree$`)},
-}
-
-// Return format for pkgbuild
-// https://gitlab.archlinux.org/archlinux/packaging/packages/0ad/-/raw/main/PKGBUILD
-func getPackagePKGBUILDURL(pkgName string) string {
-	return fmt.Sprintf("%s/%s/-/raw/main/PKGBUILD", absPackageURL, convertPkgNameForURL(pkgName))
-}
-
-// Return format for pkgbuild repo
-// https://gitlab.archlinux.org/archlinux/packaging/packages/0ad.git
-func getPackageRepoURL(pkgName string) string {
-	return fmt.Sprintf("%s/%s.git", absPackageURL, convertPkgNameForURL(pkgName))
-}
-
-// convert pkgName for Gitlab URL path (repo name)
-func convertPkgNameForURL(pkgName string) string {
-	for _, regex := range gitlabRepl {
-		pkgName = regex.match.ReplaceAllString(pkgName, regex.repl)
-	}
-	return pkgName
-}
-
-// ABSPKGBUILD retrieves the PKGBUILD file to a dest directory.
-func ABSPKGBUILD(httpClient httpRequestDoer, dbName, pkgName string) ([]byte, error) {
-	packageURL := getPackagePKGBUILDURL(pkgName)
-
-	resp, err := httpClient.Get(packageURL)
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		return nil, ErrABSPackageNotFound
-	}
-
-	defer resp.Body.Close()
-
-	pkgBuild, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	return pkgBuild, nil
-}
-
-// ABSPKGBUILDRepo retrieves the PKGBUILD repository to a dest directory.
-func ABSPKGBUILDRepo(ctx context.Context, cmdBuilder exe.GitCmdBuilder,
-	dbName, pkgName, dest string, force bool,
-) (bool, error) {
-	pkgURL := getPackageRepoURL(pkgName)
-
-	return downloadGitRepo(ctx, cmdBuilder, pkgURL,
-		pkgName, dest, force, "--single-branch")
-}

pkg/download/abs_test.go

@@ -1,331 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package download
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-)
-
-const gitExtrasPKGBUILD = `pkgname=git-extras
-pkgver=6.1.0
-pkgrel=1
-pkgdesc="GIT utilities -- repo summary, commit counting, repl, changelog population and more"
-arch=('any')
-url="https://github.com/tj/${pkgname}"
-license=('MIT')
-depends=('git')
-source=("${pkgname}-${pkgver}.tar.gz::${url}/archive/${pkgver}.tar.gz")
-sha256sums=('7be0b15ee803d76d2c2e8036f5d9db6677f2232bb8d2c4976691ff7ae026a22f')
-b2sums=('3450edecb3116e19ffcf918b118aee04f025c06d812e29e8701f35a3c466b13d2578d41c8e1ee93327743d0019bf98bb3f397189e19435f89e3a259ff1b82747')
-
-package() {
-    cd "${srcdir}/${pkgname}-${pkgver}"
-
-    # avoid annoying interactive prompts if an alias is in your gitconfig
-    export GIT_CONFIG=/dev/null
-    make DESTDIR="${pkgdir}" PREFIX=/usr SYSCONFDIR=/etc install
-    install -Dm644 LICENSE "${pkgdir}/usr/share/licenses/${pkgname}/LICENSE"
-}`
-
-func Test_getPackageURL(t *testing.T) {
-	t.Parallel()
-	type args struct {
-		db      string
-		pkgName string
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    string
-		wantErr bool
-	}{
-		{
-			name: "extra package",
-			args: args{
-				db:      "extra",
-				pkgName: "kitty",
-			},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/kitty/-/raw/main/PKGBUILD",
-			wantErr: false,
-		},
-		{
-			name: "core package",
-			args: args{
-				db:      "core",
-				pkgName: "linux",
-			},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/linux/-/raw/main/PKGBUILD",
-			wantErr: false,
-		},
-		{
-			name: "personal repo package",
-			args: args{
-				db:      "sweswe",
-				pkgName: "zabix",
-			},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/zabix/-/raw/main/PKGBUILD",
-			wantErr: false,
-		},
-		{
-			name: "special name +",
-			args: args{
-				db:      "core",
-				pkgName: "my+package",
-			},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/my-package/-/raw/main/PKGBUILD",
-			wantErr: false,
-		},
-		{
-			name: "special name %",
-			args: args{
-				db:      "core",
-				pkgName: "my%package",
-			},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/my-package/-/raw/main/PKGBUILD",
-			wantErr: false,
-		},
-		{
-			name: "special name _-",
-			args: args{
-				db:      "core",
-				pkgName: "my_-package",
-			},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/my-package/-/raw/main/PKGBUILD",
-			wantErr: false,
-		},
-		{
-			name: "special name ++",
-			args: args{
-				db:      "core",
-				pkgName: "my++package",
-			},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/mypluspluspackage/-/raw/main/PKGBUILD",
-			wantErr: false,
-		},
-		{
-			name: "special name tree",
-			args: args{
-				db:      "sweswe",
-				pkgName: "tree",
-			},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/unix-tree/-/raw/main/PKGBUILD",
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			got := getPackagePKGBUILDURL(tt.args.pkgName)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func TestGetABSPkgbuild(t *testing.T) {
-	t.Parallel()
-
-	type args struct {
-		dbName  string
-		body    string
-		status  int
-		pkgName string
-		wantURL string
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    string
-		wantErr bool
-	}{
-		{
-			name: "found package",
-			args: args{
-				dbName:  "core",
-				body:    gitExtrasPKGBUILD,
-				status:  200,
-				pkgName: "git-extras",
-				wantURL: "https://gitlab.archlinux.org/archlinux/packaging/packages/git-extras/-/raw/main/PKGBUILD",
-			},
-			want:    gitExtrasPKGBUILD,
-			wantErr: false,
-		},
-		{
-			name: "not found package",
-			args: args{
-				dbName:  "core",
-				body:    "",
-				status:  404,
-				pkgName: "git-git",
-				wantURL: "https://gitlab.archlinux.org/archlinux/packaging/packages/git-git/-/raw/main/PKGBUILD",
-			},
-			want:    "",
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			httpClient := &testClient{
-				t:       t,
-				wantURL: tt.args.wantURL,
-				body:    tt.args.body,
-				status:  tt.args.status,
-			}
-			got, err := ABSPKGBUILD(httpClient, tt.args.dbName, tt.args.pkgName)
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-			}
-
-			assert.Equal(t, tt.want, string(got))
-		})
-	}
-}
-
-func Test_getPackageRepoURL(t *testing.T) {
-	t.Parallel()
-
-	type args struct {
-		pkgName string
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    string
-		wantErr bool
-	}{
-		{
-			name:    "extra package",
-			args:    args{pkgName: "zoxide"},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/zoxide.git",
-			wantErr: false,
-		},
-		{
-			name:    "core package",
-			args:    args{pkgName: "linux"},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/linux.git",
-			wantErr: false,
-		},
-		{
-			name:    "personal repo package",
-			args:    args{pkgName: "sweswe"},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/sweswe.git",
-			wantErr: false,
-		},
-		{
-			name:    "special name +",
-			args:    args{pkgName: "my+package"},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/my-package.git",
-			wantErr: false,
-		},
-		{
-			name:    "special name %",
-			args:    args{pkgName: "my%package"},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/my-package.git",
-			wantErr: false,
-		},
-		{
-			name:    "special name _-",
-			args:    args{pkgName: "my_-package"},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/my-package.git",
-			wantErr: false,
-		},
-		{
-			name:    "special name ++",
-			args:    args{pkgName: "my++package"},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/mypluspluspackage.git",
-			wantErr: false,
-		},
-		{
-			name:    "special name tree",
-			args:    args{pkgName: "tree"},
-			want:    "https://gitlab.archlinux.org/archlinux/packaging/packages/unix-tree.git",
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			got := getPackageRepoURL(tt.args.pkgName)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
-
-// GIVEN no previous existing folder
-// WHEN ABSPKGBUILDRepo is called
-// THEN a clone command should be formed
-func TestABSPKGBUILDRepo(t *testing.T) {
-	t.Parallel()
-	cmdRunner := &testRunner{}
-	want := "/usr/local/bin/git --no-replace-objects -C /tmp/doesnt-exist clone --no-progress --single-branch https://gitlab.archlinux.org/archlinux/packaging/packages/linux.git linux"
-	if os.Getuid() == 0 {
-		ld := "systemd-run"
-		if path, _ := exec.LookPath(ld); path != "" {
-			ld = path
-		}
-		want = fmt.Sprintf("%s --service-type=oneshot --pipe --wait --pty --quiet -p DynamicUser=yes -p CacheDirectory=yay -E HOME=/tmp  --no-replace-objects -C /tmp/doesnt-exist clone --no-progress --single-branch https://gitlab.archlinux.org/archlinux/packaging/packages/linux.git linux", ld)
-	}
-
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		want:  want,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{"--no-replace-objects"},
-		},
-	}
-	newClone, err := ABSPKGBUILDRepo(context.Background(), cmdBuilder, "core", "linux", "/tmp/doesnt-exist", false)
-	assert.NoError(t, err)
-	assert.Equal(t, true, newClone)
-}
-
-// GIVEN a previous existing folder with permissions
-// WHEN ABSPKGBUILDRepo is called
-// THEN a pull command should be formed
-func TestABSPKGBUILDRepoExistsPerms(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	os.MkdirAll(filepath.Join(dir, "linux", ".git"), 0o777)
-
-	want := fmt.Sprintf("/usr/local/bin/git --no-replace-objects -C %s/linux pull --rebase --autostash", dir)
-	if os.Getuid() == 0 {
-		ld := "systemd-run"
-		if path, _ := exec.LookPath(ld); path != "" {
-			ld = path
-		}
-		want = fmt.Sprintf("%s --service-type=oneshot --pipe --wait --pty --quiet -p DynamicUser=yes -p CacheDirectory=yay -E HOME=/tmp  --no-replace-objects -C %s/linux pull --rebase --autostash", ld, dir)
-	}
-
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		want:  want,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{"--no-replace-objects"},
-		},
-	}
-	newClone, err := ABSPKGBUILDRepo(context.Background(), cmdBuilder, "core", "linux", dir, false)
-	assert.NoError(t, err)
-	assert.Equal(t, false, newClone)
-}

pkg/download/aur.go

@@ -1,100 +0,0 @@
-package download
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"sync"
-
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/multierror"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-func AURPKGBUILD(httpClient httpRequestDoer, pkgName, aurURL string) ([]byte, error) {
-	values := url.Values{}
-	values.Set("h", pkgName)
-	pkgURL := aurURL + "/cgit/aur.git/plain/PKGBUILD?" + values.Encode()
-
-	resp, err := httpClient.Get(pkgURL)
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		return nil, ErrAURPackageNotFound{pkgName: pkgName}
-	}
-
-	defer resp.Body.Close()
-
-	pkgBuild, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	return pkgBuild, nil
-}
-
-// AURPkgbuildRepo retrieves the PKGBUILD repository to a dest directory.
-func AURPKGBUILDRepo(ctx context.Context, cmdBuilder exe.GitCmdBuilder, aurURL, pkgName, dest string, force bool) (bool, error) {
-	pkgURL := fmt.Sprintf("%s/%s.git", aurURL, pkgName)
-
-	return downloadGitRepo(ctx, cmdBuilder, pkgURL, pkgName, dest, force)
-}
-
-func AURPKGBUILDRepos(
-	ctx context.Context,
-	cmdBuilder exe.GitCmdBuilder, logger *text.Logger,
-	targets []string, aurURL, dest string, force bool,
-) (map[string]bool, error) {
-	cloned := make(map[string]bool, len(targets))
-
-	var (
-		mux  sync.Mutex
-		errs multierror.MultiError
-		wg   sync.WaitGroup
-	)
-
-	sem := make(chan uint8, MaxConcurrentFetch)
-
-	for _, target := range targets {
-		sem <- 1
-		wg.Add(1)
-
-		go func(target string) {
-			defer func() {
-				<-sem
-				wg.Done()
-			}()
-
-			newClone, err := AURPKGBUILDRepo(ctx, cmdBuilder, aurURL, target, dest, force)
-
-			mux.Lock()
-			progress := len(cloned)
-			if err != nil {
-				errs.Add(err)
-				mux.Unlock()
-				logger.OperationInfoln(
-					gotext.Get("(%d/%d) Failed to download PKGBUILD: %s",
-						progress, len(targets), text.Cyan(target)))
-				return
-			}
-
-			cloned[target] = newClone
-			progress = len(cloned)
-			mux.Unlock()
-
-			logger.OperationInfoln(
-				gotext.Get("(%d/%d) Downloaded PKGBUILD: %s",
-					progress, len(targets), text.Cyan(target)))
-		}(target)
-	}
-
-	wg.Wait()
-
-	return cloned, errs.Return()
-}

pkg/download/aur_test.go

@@ -1,165 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package download
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-)
-
-func TestGetAURPkgbuild(t *testing.T) {
-	t.Parallel()
-
-	type args struct {
-		body    string
-		status  int
-		pkgName string
-		wantURL string
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    string
-		wantErr bool
-	}{
-		{
-			name: "found package",
-			args: args{
-				body:    gitExtrasPKGBUILD,
-				status:  200,
-				pkgName: "git-extras",
-				wantURL: "https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD?h=git-extras",
-			},
-			want:    gitExtrasPKGBUILD,
-			wantErr: false,
-		},
-		{
-			name: "not found package",
-			args: args{
-				body:    "",
-				status:  404,
-				pkgName: "git-git",
-				wantURL: "https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD?h=git-git",
-			},
-			want:    "",
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			httpClient := &testClient{
-				t:       t,
-				wantURL: tt.args.wantURL,
-				body:    tt.args.body,
-				status:  tt.args.status,
-			}
-			got, err := AURPKGBUILD(httpClient, tt.args.pkgName, "https://aur.archlinux.org")
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-			}
-
-			assert.Equal(t, tt.want, string(got))
-		})
-	}
-}
-
-// GIVEN no previous existing folder
-// WHEN AURPKGBUILDRepo is called
-// THEN a clone command should be formed
-func TestAURPKGBUILDRepo(t *testing.T) {
-	t.Parallel()
-	want := "/usr/local/bin/git --no-replace-objects -C /tmp/doesnt-exist clone --no-progress https://aur.archlinux.org/yay-bin.git yay-bin"
-	if os.Getuid() == 0 {
-		ld := "systemd-run"
-		if path, _ := exec.LookPath(ld); path != "" {
-			ld = path
-		}
-		want = fmt.Sprintf("%s --service-type=oneshot --pipe --wait --pty --quiet -p DynamicUser=yes -p CacheDirectory=yay -E HOME=/tmp  --no-replace-objects -C /tmp/doesnt-exist clone --no-progress https://aur.archlinux.org/yay-bin.git yay-bin", ld)
-	}
-
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		want:  want,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{"--no-replace-objects"},
-		},
-	}
-	newCloned, err := AURPKGBUILDRepo(context.Background(), cmdBuilder, "https://aur.archlinux.org", "yay-bin", "/tmp/doesnt-exist", false)
-	assert.NoError(t, err)
-	assert.Equal(t, true, newCloned)
-}
-
-// GIVEN a previous existing folder with permissions
-// WHEN AURPKGBUILDRepo is called
-// THEN a pull command should be formed
-func TestAURPKGBUILDRepoExistsPerms(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	os.MkdirAll(filepath.Join(dir, "yay-bin", ".git"), 0o777)
-
-	want := fmt.Sprintf("/usr/local/bin/git --no-replace-objects -C %s/yay-bin pull --rebase --autostash", dir)
-	if os.Getuid() == 0 {
-		ld := "systemd-run"
-		if path, _ := exec.LookPath(ld); path != "" {
-			ld = path
-		}
-		want = fmt.Sprintf("%s --service-type=oneshot --pipe --wait --pty --quiet -p DynamicUser=yes -p CacheDirectory=yay -E HOME=/tmp  --no-replace-objects -C %s/yay-bin pull --rebase --autostash", ld, dir)
-	}
-
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		want:  want,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{"--no-replace-objects"},
-		},
-	}
-	cloned, err := AURPKGBUILDRepo(context.Background(), cmdBuilder, "https://aur.archlinux.org", "yay-bin", dir, false)
-	assert.NoError(t, err)
-	assert.Equal(t, false, cloned)
-}
-
-func TestAURPKGBUILDRepos(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	os.MkdirAll(filepath.Join(dir, "yay-bin", ".git"), 0o777)
-
-	targets := []string{"yay", "yay-bin", "yay-git"}
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		want:  "",
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{},
-		},
-	}
-	cloned, err := AURPKGBUILDRepos(context.Background(), cmdBuilder, newTestLogger(), targets, "https://aur.archlinux.org", dir, false)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string]bool{"yay": true, "yay-bin": false, "yay-git": true}, cloned)
-}

pkg/download/errors.go

@@ -1,31 +0,0 @@
-package download
-
-import (
-	"fmt"
-
-	"github.com/leonelquinteros/gotext"
-)
-
-// ErrAURPackageNotFound means that package was not found in AUR.
-type ErrAURPackageNotFound struct {
-	pkgName string
-}
-
-func (e ErrAURPackageNotFound) Error() string {
-	return fmt.Sprintln(gotext.Get("package not found in AUR"), ":", e.pkgName)
-}
-
-type ErrGetPKGBUILDRepo struct {
-	inner   error
-	pkgName string
-	errOut  string
-}
-
-func (e ErrGetPKGBUILDRepo) Error() string {
-	return fmt.Sprintln(gotext.Get("error fetching %s: %s", e.pkgName, e.errOut),
-		"\n\t context:", e.inner.Error())
-}
-
-func (e *ErrGetPKGBUILDRepo) Unwrap() error {
-	return e.inner
-}

pkg/download/unified.go

@@ -1,251 +0,0 @@
-package download
-
-import (
-	"context"
-	"net/http"
-	"os"
-	"path/filepath"
-	"sync"
-
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/aur"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/multierror"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type httpRequestDoer interface {
-	Get(string) (*http.Response, error)
-}
-
-type DBSearcher interface {
-	SyncPackage(string) db.IPackage
-	SyncPackageFromDB(string, string) db.IPackage
-}
-
-func downloadGitRepo(ctx context.Context, cmdBuilder exe.GitCmdBuilder,
-	pkgURL, pkgName, dest string, force bool, gitArgs ...string,
-) (bool, error) {
-	finalDir := filepath.Join(dest, pkgName)
-	newClone := true
-
-	switch _, err := os.Stat(filepath.Join(finalDir, ".git")); {
-	case os.IsNotExist(err) || (err == nil && force):
-		if _, errD := os.Stat(finalDir); force && errD == nil {
-			if errR := os.RemoveAll(finalDir); errR != nil {
-				return false, ErrGetPKGBUILDRepo{inner: errR, pkgName: pkgName, errOut: ""}
-			}
-		}
-
-		gitArgs = append(gitArgs, pkgURL, pkgName)
-
-		cloneArgs := make([]string, 0, len(gitArgs)+4)
-		cloneArgs = append(cloneArgs, "clone", "--no-progress")
-		cloneArgs = append(cloneArgs, gitArgs...)
-		cmd := cmdBuilder.BuildGitCmd(ctx, dest, cloneArgs...)
-
-		_, stderr, errCapture := cmdBuilder.Capture(cmd)
-		if errCapture != nil {
-			return false, ErrGetPKGBUILDRepo{inner: errCapture, pkgName: pkgName, errOut: stderr}
-		}
-	case err != nil:
-		return false, ErrGetPKGBUILDRepo{
-			inner:   err,
-			pkgName: pkgName,
-			errOut:  gotext.Get("error reading %s", filepath.Join(dest, pkgName, ".git")),
-		}
-	default:
-		cmd := cmdBuilder.BuildGitCmd(ctx, filepath.Join(dest, pkgName), "pull", "--rebase", "--autostash")
-
-		_, stderr, errCmd := cmdBuilder.Capture(cmd)
-		if errCmd != nil {
-			return false, ErrGetPKGBUILDRepo{inner: errCmd, pkgName: pkgName, errOut: stderr}
-		}
-
-		newClone = false
-	}
-
-	return newClone, nil
-}
-
-func getURLName(pkg db.IPackage) string {
-	name := pkg.Base()
-	if name == "" {
-		name = pkg.Name()
-	}
-
-	return name
-}
-
-func PKGBUILDs(dbExecutor DBSearcher, aurClient aur.QueryClient, httpClient *http.Client,
-	logger *text.Logger, targets []string, aurURL string, mode parser.TargetMode,
-) (map[string][]byte, error) {
-	pkgbuilds := make(map[string][]byte, len(targets))
-
-	var (
-		mux  sync.Mutex
-		errs multierror.MultiError
-		wg   sync.WaitGroup
-	)
-
-	sem := make(chan uint8, MaxConcurrentFetch)
-
-	for _, target := range targets {
-		// Probably replaceable by something in query.
-		dbName, name, isAUR, toSkip := getPackageUsableName(dbExecutor, aurClient, logger, target, mode)
-		if toSkip {
-			continue
-		}
-
-		sem <- 1
-
-		wg.Add(1)
-
-		go func(target, dbName, pkgName string, aur bool) {
-			var (
-				err      error
-				pkgbuild []byte
-			)
-
-			if aur {
-				pkgbuild, err = AURPKGBUILD(httpClient, pkgName, aurURL)
-			} else {
-				pkgbuild, err = ABSPKGBUILD(httpClient, dbName, pkgName)
-			}
-
-			if err == nil {
-				mux.Lock()
-				pkgbuilds[target] = pkgbuild
-				mux.Unlock()
-			} else {
-				errs.Add(err)
-			}
-
-			<-sem
-			wg.Done()
-		}(target, dbName, name, isAUR)
-	}
-
-	wg.Wait()
-
-	return pkgbuilds, errs.Return()
-}
-
-func PKGBUILDRepos(ctx context.Context, dbExecutor DBSearcher, aurClient aur.QueryClient,
-	cmdBuilder exe.GitCmdBuilder, logger *text.Logger,
-	targets []string, mode parser.TargetMode, aurURL, dest string, force bool,
-) (map[string]bool, error) {
-	cloned := make(map[string]bool, len(targets))
-
-	var (
-		mux  sync.Mutex
-		errs multierror.MultiError
-		wg   sync.WaitGroup
-	)
-
-	sem := make(chan uint8, MaxConcurrentFetch)
-
-	for _, target := range targets {
-		// Probably replaceable by something in query.
-		dbName, name, isAUR, toSkip := getPackageUsableName(dbExecutor, aurClient, logger, target, mode)
-		if toSkip {
-			continue
-		}
-
-		sem <- 1
-
-		wg.Add(1)
-
-		go func(target, dbName, pkgName string, aur bool) {
-			var (
-				err      error
-				newClone bool
-			)
-
-			if aur {
-				newClone, err = AURPKGBUILDRepo(ctx, cmdBuilder, aurURL, pkgName, dest, force)
-			} else {
-				newClone, err = ABSPKGBUILDRepo(ctx, cmdBuilder, dbName, pkgName, dest, force)
-			}
-
-			progress := 0
-
-			if err != nil {
-				errs.Add(err)
-			} else {
-				mux.Lock()
-				cloned[target] = newClone
-				progress = len(cloned)
-				mux.Unlock()
-			}
-
-			if aur {
-				logger.OperationInfoln(
-					gotext.Get("(%d/%d) Downloaded PKGBUILD: %s",
-						progress, len(targets), text.Cyan(pkgName)))
-			} else {
-				logger.OperationInfoln(
-					gotext.Get("(%d/%d) Downloaded PKGBUILD from ABS: %s",
-						progress, len(targets), text.Cyan(pkgName)))
-			}
-
-			<-sem
-
-			wg.Done()
-		}(target, dbName, name, isAUR)
-	}
-
-	wg.Wait()
-
-	return cloned, errs.Return()
-}
-
-// TODO: replace with dep.ResolveTargets.
-func getPackageUsableName(dbExecutor DBSearcher, aurClient aur.QueryClient,
-	logger *text.Logger, target string, mode parser.TargetMode,
-) (dbname, pkgname string, isAUR, toSkip bool) {
-	dbName, name := text.SplitDBFromName(target)
-	if dbName != "aur" && mode.AtLeastRepo() {
-		var pkg db.IPackage
-		if dbName != "" {
-			pkg = dbExecutor.SyncPackageFromDB(name, dbName)
-		} else {
-			pkg = dbExecutor.SyncPackage(name)
-		}
-
-		if pkg != nil {
-			name = getURLName(pkg)
-			dbName = pkg.DB().Name()
-			return dbName, name, false, false
-		}
-
-		// If the package is not found in the database and it was expected to be
-		if pkg == nil && dbName != "" {
-			return dbName, name, true, true
-		}
-	}
-
-	if mode == parser.ModeRepo {
-		return dbName, name, true, true
-	}
-
-	pkgs, err := aurClient.Get(context.Background(), &aur.Query{
-		By:       aur.Name,
-		Contains: false,
-		Needles:  []string{name},
-	})
-	if err != nil {
-		logger.Warnln(err)
-		return dbName, name, true, true
-	}
-
-	if len(pkgs) == 0 {
-		return dbName, name, true, true
-	}
-
-	return "aur", name, true, false
-}

pkg/download/unified_integration_test.go

@@ -1,106 +0,0 @@
-//go:build integration
-// +build integration
-
-package download
-
-import (
-	"context"
-	"net/http"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/Jguer/aur"
-
-	mockaur "github.com/Jguer/yay/v12/pkg/dep/mock"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-func TestIntegrationPKGBUILDReposDefinedDBClone(t *testing.T) {
-	dir := t.TempDir()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{{}}, nil // fakes a package found for all
-		},
-	}
-	targets := []string{"core/linux", "yay-bin", "yay-git"}
-
-	testLogger := text.NewLogger(os.Stdout, os.Stderr, strings.NewReader(""), true, "test")
-	cmdRunner := &exe.OSRunner{Log: testLogger}
-	cmdBuilder := &exe.CmdBuilder{
-		Runner:   cmdRunner,
-		GitBin:   "git",
-		GitFlags: []string{},
-		Log:      testLogger,
-	}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"linux": "core"},
-	}
-	cloned, err := PKGBUILDRepos(context.Background(), searcher, mockClient,
-		cmdBuilder, testLogger.Child("test"),
-		targets, parser.ModeAny, "https://aur.archlinux.org", dir, false)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string]bool{"core/linux": true, "yay-bin": true, "yay-git": true}, cloned)
-}
-
-func TestIntegrationPKGBUILDReposNotExist(t *testing.T) {
-	dir := t.TempDir()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{{}}, nil // fakes a package found for all
-		},
-	}
-	targets := []string{"core/yay", "yay-bin", "yay-git"}
-	testLogger := text.NewLogger(os.Stdout, os.Stderr, strings.NewReader(""), true, "test")
-	cmdRunner := &exe.OSRunner{Log: testLogger}
-	cmdBuilder := &exe.CmdBuilder{
-		Runner:   cmdRunner,
-		GitBin:   "git",
-		GitFlags: []string{},
-		Log:      testLogger,
-	}
-
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"yay": "core"},
-	}
-	cloned, err := PKGBUILDRepos(context.Background(), searcher, mockClient,
-		cmdBuilder, testLogger.Child("test"),
-		targets, parser.ModeAny, "https://aur.archlinux.org", dir, false)
-
-	assert.Error(t, err)
-	assert.EqualValues(t, map[string]bool{"yay-bin": true, "yay-git": true}, cloned)
-}
-
-// GIVEN 2 aur packages and 1 in repo
-// WHEN defining as specified targets
-// THEN all aur be found and cloned
-func TestIntegrationPKGBUILDFull(t *testing.T) {
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{{}}, nil
-		},
-	}
-
-	testLogger := text.NewLogger(os.Stdout, os.Stderr, strings.NewReader(""), true, "test")
-	targets := []string{"core/linux", "aur/yay-bin", "yay-git"}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"linux": "core"},
-	}
-
-	fetched, err := PKGBUILDs(searcher, mockClient, &http.Client{}, testLogger.Child("test"),
-		targets, "https://aur.archlinux.org", parser.ModeAny)
-
-	assert.NoError(t, err)
-
-	for _, target := range targets {
-		assert.Contains(t, fetched, target)
-		assert.NotEmpty(t, fetched[target])
-	}
-}

pkg/download/unified_test.go

@@ -1,281 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package download
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"gopkg.in/h2non/gock.v1"
-
-	"github.com/Jguer/aur"
-
-	mockaur "github.com/Jguer/yay/v12/pkg/dep/mock"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-func newTestLogger() *text.Logger {
-	return text.NewLogger(io.Discard, io.Discard, strings.NewReader(""), true, "test")
-}
-
-// GIVEN 2 aur packages and 1 in repo
-// GIVEN package in repo is already present
-// WHEN defining package db as a target
-// THEN all should be found and cloned, except the repo one
-func TestPKGBUILDReposDefinedDBPull(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{{}}, nil // fakes a package found for all
-		},
-	}
-
-	testLogger := text.NewLogger(os.Stdout, os.Stderr, strings.NewReader(""), true, "test")
-
-	os.MkdirAll(filepath.Join(dir, "yay", ".git"), 0o777)
-
-	targets := []string{"core/yay", "yay-bin", "yay-git"}
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{},
-			Log:      testLogger,
-		},
-	}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"yay": "core"},
-	}
-	cloned, err := PKGBUILDRepos(context.Background(), searcher, mockClient,
-		cmdBuilder, newTestLogger(),
-		targets, parser.ModeAny, "https://aur.archlinux.org", dir, false)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string]bool{"core/yay": false, "yay-bin": true, "yay-git": true}, cloned)
-}
-
-// GIVEN 2 aur packages and 1 in repo
-// WHEN defining package db as a target
-// THEN all should be found and cloned
-func TestPKGBUILDReposDefinedDBClone(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{{}}, nil // fakes a package found for all
-		},
-	}
-	targets := []string{"core/yay", "yay-bin", "yay-git"}
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{},
-		},
-	}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"yay": "core"},
-	}
-	cloned, err := PKGBUILDRepos(context.Background(), searcher, mockClient,
-		cmdBuilder, newTestLogger(),
-		targets, parser.ModeAny, "https://aur.archlinux.org", dir, false)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string]bool{"core/yay": true, "yay-bin": true, "yay-git": true}, cloned)
-}
-
-// GIVEN 2 aur packages and 1 in repo
-// WHEN defining as non specified targets
-// THEN all should be found and cloned
-func TestPKGBUILDReposClone(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{{}}, nil // fakes a package found for all
-		},
-	}
-	targets := []string{"yay", "yay-bin", "yay-git"}
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{},
-		},
-	}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"yay": "core"},
-	}
-	cloned, err := PKGBUILDRepos(context.Background(), searcher, mockClient,
-		cmdBuilder, newTestLogger(),
-		targets, parser.ModeAny, "https://aur.archlinux.org", dir, false)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string]bool{"yay": true, "yay-bin": true, "yay-git": true}, cloned)
-}
-
-// GIVEN 2 aur packages and 1 in repo but wrong db
-// WHEN defining as non specified targets
-// THEN all aur be found and cloned
-func TestPKGBUILDReposNotFound(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{{}}, nil // fakes a package found for all
-		},
-	}
-	targets := []string{"extra/yay", "yay-bin", "yay-git"}
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{},
-		},
-	}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"yay": "core"},
-	}
-	cloned, err := PKGBUILDRepos(context.Background(), searcher, mockClient,
-		cmdBuilder, newTestLogger(),
-		targets, parser.ModeAny, "https://aur.archlinux.org", dir, false)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string]bool{"yay-bin": true, "yay-git": true}, cloned)
-}
-
-// GIVEN 2 aur packages and 1 in repo
-// WHEN defining as non specified targets in repo mode
-// THEN only repo should be cloned
-func TestPKGBUILDReposRepoMode(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{}, nil // fakes a package found for all
-		},
-	}
-	targets := []string{"yay", "yay-bin", "yay-git"}
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{},
-		},
-	}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"yay": "core"},
-	}
-	cloned, err := PKGBUILDRepos(context.Background(), searcher, mockClient,
-		cmdBuilder, newTestLogger(),
-		targets, parser.ModeRepo, "https://aur.archlinux.org", dir, false)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string]bool{"yay": true}, cloned)
-}
-
-// GIVEN 2 aur packages and 1 in repo
-// WHEN defining as specified targets
-// THEN all aur be found and cloned
-func TestPKGBUILDFull(t *testing.T) {
-	t.Parallel()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{{}}, nil
-		},
-	}
-	gock.New("https://aur.archlinux.org").
-		Get("/cgit/aur.git/plain/PKGBUILD").MatchParam("h", "yay-git").
-		Reply(200).
-		BodyString("example_yay-git")
-	gock.New("https://aur.archlinux.org").
-		Get("/cgit/aur.git/plain/PKGBUILD").MatchParam("h", "yay-bin").
-		Reply(200).
-		BodyString("example_yay-bin")
-
-	gock.New("https://gitlab.archlinux.org/").
-		Get("archlinux/packaging/packages/yay/-/raw/main/PKGBUILD").
-		Reply(200).
-		BodyString("example_yay")
-
-	defer gock.Off()
-	targets := []string{"core/yay", "aur/yay-bin", "yay-git"}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"yay": "core"},
-	}
-
-	fetched, err := PKGBUILDs(searcher, mockClient, &http.Client{}, newTestLogger(),
-		targets, "https://aur.archlinux.org", parser.ModeAny)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string][]byte{
-		"core/yay":    []byte("example_yay"),
-		"aur/yay-bin": []byte("example_yay-bin"),
-		"yay-git":     []byte("example_yay-git"),
-	}, fetched)
-}
-
-// GIVEN 2 aur packages and 1 in repo
-// WHEN aur packages are not found
-// only repo should be cloned
-func TestPKGBUILDReposMissingAUR(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	mockClient := &mockaur.MockAUR{
-		GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
-			return []aur.Pkg{}, nil // fakes a package found for all
-		},
-	}
-	targets := []string{"core/yay", "aur/yay-bin", "aur/yay-git"}
-	cmdRunner := &testRunner{}
-	cmdBuilder := &testGitBuilder{
-		index: 0,
-		test:  t,
-		parentBuilder: &exe.CmdBuilder{
-			Runner:   cmdRunner,
-			GitBin:   "/usr/local/bin/git",
-			GitFlags: []string{},
-		},
-	}
-	searcher := &testDBSearcher{
-		absPackagesDB: map[string]string{"yay": "core"},
-	}
-	cloned, err := PKGBUILDRepos(context.Background(), searcher, mockClient,
-		cmdBuilder, newTestLogger(),
-		targets, parser.ModeAny, "https://aur.archlinux.org", dir, false)
-
-	assert.NoError(t, err)
-	assert.EqualValues(t, map[string]bool{"core/yay": true}, cloned)
-}

pkg/download/utils_test.go

@@ -1,120 +0,0 @@
-package download
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"os/exec"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/Jguer/go-alpm/v2"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-)
-
-type testRunner struct{}
-
-func (t *testRunner) Capture(cmd *exec.Cmd) (stdout string, stderr string, err error) {
-	return "", "", nil
-}
-
-func (t *testRunner) Show(cmd *exec.Cmd) error {
-	return nil
-}
-
-type testGitBuilder struct {
-	index         int
-	test          *testing.T
-	want          string
-	parentBuilder *exe.CmdBuilder
-}
-
-func (t *testGitBuilder) BuildGitCmd(ctx context.Context, dir string, extraArgs ...string) *exec.Cmd {
-	cmd := t.parentBuilder.BuildGitCmd(ctx, dir, extraArgs...)
-
-	if t.want != "" {
-		assert.Equal(t.test, t.want, cmd.String())
-	}
-
-	return cmd
-}
-
-func (c *testGitBuilder) Show(cmd *exec.Cmd) error {
-	return c.parentBuilder.Show(cmd)
-}
-
-func (c *testGitBuilder) Capture(cmd *exec.Cmd) (stdout, stderr string, err error) {
-	return c.parentBuilder.Capture(cmd)
-}
-
-type (
-	testDB struct {
-		alpm.IDB
-		name string
-	}
-	testPackage struct {
-		db.IPackage
-		name string
-		base string
-		db   *testDB
-	}
-	testDBSearcher struct {
-		absPackagesDB map[string]string
-	}
-
-	testClient struct {
-		t       *testing.T
-		wantURL string
-		body    string
-		status  int
-	}
-)
-
-func (d *testDB) Name() string {
-	return d.name
-}
-
-func (p *testPackage) Name() string {
-	return p.name
-}
-
-func (p *testPackage) Base() string {
-	return p.base
-}
-
-func (p *testPackage) DB() alpm.IDB {
-	return p.db
-}
-
-func (d *testDBSearcher) SyncPackage(name string) db.IPackage {
-	if v, ok := d.absPackagesDB[name]; ok {
-		return &testPackage{
-			name: name,
-			base: name,
-			db:   &testDB{name: v},
-		}
-	}
-
-	return nil
-}
-
-func (d *testDBSearcher) SyncPackageFromDB(name string, db string) db.IPackage {
-	if v, ok := d.absPackagesDB[name]; ok && v == db {
-		return &testPackage{
-			name: name,
-			base: name,
-			db:   &testDB{name: v},
-		}
-	}
-
-	return nil
-}
-
-func (t *testClient) Get(url string) (*http.Response, error) {
-	assert.Equal(t.t, t.wantURL, url)
-	return &http.Response{StatusCode: t.status, Body: io.NopCloser(strings.NewReader(t.body))}, nil
-}

pkg/intrange/intrange.go

@@ -4,34 +4,34 @@ import (
 	"strconv"
 	"strings"
 	"unicode"
+	"github.com/Jguer/yay/v9/pkg/stringset"
 
-	mapset "github.com/deckarep/golang-set/v2"
 )
 
-// IntRange stores a max and min amount for range.
+// IntRange stores a max and min amount for range
 type IntRange struct {
 	min int
 	max int
 }
 
-// IntRanges is a slice of IntRange.
+// IntRanges is a slice of IntRange
 type IntRanges []IntRange
 
-func makeIntRange(minVal, maxVal int) IntRange {
+func makeIntRange(min, max int) IntRange {
 	return IntRange{
-		min: minVal,
-		max: maxVal,
+		min,
+		max,
 	}
 }
 
 // Get returns true if the argument n is included in the closed range
-// between min and max.
+// between min and max
 func (r IntRange) Get(n int) bool {
 	return n >= r.min && n <= r.max
 }
 
 // Get returns true if the argument n is included in the closed range
-// between min and max of any of the provided IntRanges.
+// between min and max of any of the provided IntRanges
 func (rs IntRanges) Get(n int) bool {
 	for _, r := range rs {
 		if r.Get(n) {
@@ -42,35 +42,46 @@ func (rs IntRanges) Get(n int) bool {
 	return false
 }
 
+// Min returns min value between a and b
+func Min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// Max returns max value between a and b
+func Max(a, b int) int {
+	if a < b {
+		return b
+	}
+	return a
+}
+
 // ParseNumberMenu parses input for number menus split by spaces or commas
-// supports individual selection: 1 2 3 4
-// supports range selections: 1-4 10-20
-// supports negation: ^1 ^1-4
+//supports individual selection: 1 2 3 4
+//supports range selections: 1-4 10-20
+//supports negation: ^1 ^1-4
 //
-// include and excule holds numbers that should be added and should not be added
-// respectively. other holds anything that can't be parsed as an int. This is
-// intended to allow words inside of number menus. e.g. 'all' 'none' 'abort'
-// of course the implementation is up to the caller, this function mearley parses
-// the input and organizes it.
-func ParseNumberMenu(input string) (include, exclude IntRanges,
-	otherInclude, otherExclude mapset.Set[string],
-) {
-	include = make(IntRanges, 0)
-	exclude = make(IntRanges, 0)
-	otherInclude = mapset.NewThreadUnsafeSet[string]()
-	otherExclude = mapset.NewThreadUnsafeSet[string]()
+//include and excule holds numbers that should be added and should not be added
+//respectively. other holds anything that can't be parsed as an int. This is
+//intended to allow words inside of number menus. e.g. 'all' 'none' 'abort'
+//of course the implementation is up to the caller, this function mearley parses
+//the input and organizes it
+func ParseNumberMenu(input string) (IntRanges, IntRanges, stringset.StringSet, stringset.StringSet) {
+	include := make(IntRanges, 0)
+	exclude := make(IntRanges, 0)
+	otherInclude := make(stringset.StringSet)
+	otherExclude := make(stringset.StringSet)
 
 	words := strings.FieldsFunc(input, func(c rune) bool {
 		return unicode.IsSpace(c) || c == ','
 	})
 
 	for _, word := range words {
-		var (
-			num1 int
-			num2 int
-			err  error
-		)
-
+		var num1 int
+		var num2 int
+		var err error
 		invert := false
 		other := otherInclude
 
@@ -84,22 +95,22 @@ func ParseNumberMenu(input string) (include, exclude IntRanges,
 
 		num1, err = strconv.Atoi(ranges[0])
 		if err != nil {
-			other.Add(strings.ToLower(word))
+			other.Set(strings.ToLower(word))
 			continue
 		}
 
 		if len(ranges) == 2 {
 			num2, err = strconv.Atoi(ranges[1])
 			if err != nil {
-				other.Add(strings.ToLower(word))
+				other.Set(strings.ToLower(word))
 				continue
 			}
 		} else {
 			num2 = num1
 		}
 
-		mi := min(num1, num2)
-		ma := max(num1, num2)
+		mi := Min(num1, num2)
+		ma := Max(num1, num2)
 
 		if !invert {
 			include = append(include, makeIntRange(mi, ma))

pkg/intrange/intrange_test.go

@@ -1,22 +1,16 @@
-//go:build !integration
-// +build !integration
-
 package intrange
 
 import (
-	"testing"
-
-	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/stretchr/testify/assert"
+		"github.com/Jguer/yay/v9/pkg/stringset"
+"testing"
 )
 
 func TestParseNumberMenu(t *testing.T) {
-	t.Parallel()
 	type result struct {
 		Include      IntRanges
 		Exclude      IntRanges
-		OtherInclude mapset.Set[string]
-		OtherExclude mapset.Set[string]
+		OtherInclude stringset.StringSet
+		OtherExclude stringset.StringSet
 	}
 
 	inputs := []string{
@@ -35,73 +29,36 @@ func TestParseNumberMenu(t *testing.T) {
 	}
 
 	expected := []result{
-		{IntRanges{
-			makeIntRange(1, 1),
-			makeIntRange(2, 2),
-			makeIntRange(3, 3),
-			makeIntRange(4, 4),
-			makeIntRange(5, 5),
-		}, IntRanges{}, mapset.NewThreadUnsafeSet[string](), mapset.NewThreadUnsafeSet[string]()},
-		{IntRanges{
-			makeIntRange(1, 10),
-			makeIntRange(5, 15),
-		}, IntRanges{}, mapset.NewThreadUnsafeSet[string](), mapset.NewThreadUnsafeSet[string]()},
-		{IntRanges{
-			makeIntRange(5, 10),
-			makeIntRange(85, 90),
-		}, IntRanges{}, mapset.NewThreadUnsafeSet[string](), mapset.NewThreadUnsafeSet[string]()},
-		{
-			IntRanges{
-				makeIntRange(1, 1),
-				makeIntRange(99, 99),
-				makeIntRange(60, 62),
-			},
-			IntRanges{
-				makeIntRange(2, 2),
-				makeIntRange(5, 10),
-				makeIntRange(38, 40),
-				makeIntRange(123, 123),
-			},
-			mapset.NewThreadUnsafeSet[string](), mapset.NewThreadUnsafeSet[string](),
-		},
-		{IntRanges{}, IntRanges{}, mapset.NewThreadUnsafeSet("abort", "all", "none"), mapset.NewThreadUnsafeSet[string]()},
-		{IntRanges{}, IntRanges{}, mapset.NewThreadUnsafeSet("a-b"), mapset.NewThreadUnsafeSet("abort", "a-b")},
-		{IntRanges{}, IntRanges{}, mapset.NewThreadUnsafeSet("-9223372036854775809-9223372036854775809"), mapset.NewThreadUnsafeSet[string]()},
-		{IntRanges{
-			makeIntRange(1, 1),
-			makeIntRange(2, 2),
-			makeIntRange(3, 3),
-			makeIntRange(4, 4),
-			makeIntRange(5, 5),
-		}, IntRanges{}, mapset.NewThreadUnsafeSet[string](), mapset.NewThreadUnsafeSet[string]()},
-		{IntRanges{
-			makeIntRange(1, 1),
-			makeIntRange(2, 2),
-			makeIntRange(3, 3),
-			makeIntRange(4, 4),
-			makeIntRange(5, 5),
-			makeIntRange(6, 6),
-			makeIntRange(7, 7),
-			makeIntRange(8, 8),
-		}, IntRanges{}, mapset.NewThreadUnsafeSet[string](), mapset.NewThreadUnsafeSet[string]()},
-		{IntRanges{}, IntRanges{}, mapset.NewThreadUnsafeSet[string](), mapset.NewThreadUnsafeSet[string]()},
-		{IntRanges{}, IntRanges{}, mapset.NewThreadUnsafeSet[string](), mapset.NewThreadUnsafeSet[string]()},
-		{IntRanges{}, IntRanges{}, mapset.NewThreadUnsafeSet("a", "b", "c", "d", "e"), mapset.NewThreadUnsafeSet[string]()},
+		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(1, 10), makeIntRange(5, 15)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(5, 10), makeIntRange(85, 90)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(1, 1), makeIntRange(99, 99), makeIntRange(60, 62)}, IntRanges{makeIntRange(2, 2), makeIntRange(5, 10), makeIntRange(38, 40), makeIntRange(123, 123)}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, stringset.Make("abort", "all", "none"), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, stringset.Make("a-b"), stringset.Make("abort", "a-b")},
+		{IntRanges{}, IntRanges{}, stringset.Make("-9223372036854775809-9223372036854775809"), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{makeIntRange(1, 1), makeIntRange(2, 2), makeIntRange(3, 3), makeIntRange(4, 4), makeIntRange(5, 5), makeIntRange(6, 6), makeIntRange(7, 7), makeIntRange(8, 8)}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, make(stringset.StringSet), make(stringset.StringSet)},
+		{IntRanges{}, IntRanges{}, stringset.Make("a", "b", "c", "d", "e"), make(stringset.StringSet)},
 	}
 
 	for n, in := range inputs {
 		res := expected[n]
 		include, exclude, otherInclude, otherExclude := ParseNumberMenu(in)
 
-		assert.True(t, intRangesEqual(include, res.Include), "Test %d Failed: Expected: include=%+v got include=%+v", n+1, res.Include, include)
-		assert.True(t, intRangesEqual(exclude, res.Exclude), "Test %d Failed: Expected: exclude=%+v got exclude=%+v", n+1, res.Exclude, exclude)
-		assert.True(t, otherInclude.Equal(res.OtherInclude), "Test %d Failed: Expected: otherInclude=%+v got otherInclude=%+v", n+1, res.OtherInclude, otherInclude)
-		assert.True(t, otherExclude.Equal(res.OtherExclude), "Test %d Failed: Expected: otherExclude=%+v got otherExclude=%+v", n+1, res.OtherExclude, otherExclude)
+		if !intRangesEqual(include, res.Include) ||
+			!intRangesEqual(exclude, res.Exclude) ||
+			!stringset.Equal(otherInclude, res.OtherInclude) ||
+			!stringset.Equal(otherExclude, res.OtherExclude) {
+
+			t.Fatalf("Test %d Failed: Expected: include=%+v exclude=%+v otherInclude=%+v otherExclude=%+v got include=%+v excluive=%+v otherInclude=%+v otherExclude=%+v",
+				n+1, res.Include, res.Exclude, res.OtherInclude, res.OtherExclude, include, exclude, otherInclude, otherExclude)
+		}
 	}
 }
 
 func TestIntRange_Get(t *testing.T) {
-	t.Parallel()
 	type fields struct {
 		min int
 		max int
@@ -123,9 +80,7 @@ func TestIntRange_Get(t *testing.T) {
 		{name: "normal end range false", fields: fields{1, 2}, args: args{3}, want: false},
 	}
 	for _, tt := range tests {
-		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
 			r := IntRange{
 				min: tt.fields.min,
 				max: tt.fields.max,
@@ -163,7 +118,6 @@ func intRangesEqual(a, b IntRanges) bool {
 }
 
 func TestIntRanges_Get(t *testing.T) {
-	t.Parallel()
 	type args struct {
 		n int
 	}
@@ -174,8 +128,8 @@ func TestIntRanges_Get(t *testing.T) {
 		want bool
 	}{
 		{name: "normal range true", rs: IntRanges{{0, 10}}, args: args{5}, want: true},
-		{name: "normal ranges in between true", rs: IntRanges{{0, 4}, {5, 10}}, args: args{5}, want: true},
-		{name: "normal ranges in between false", rs: IntRanges{{0, 4}, {6, 10}}, args: args{5}, want: false},
+		{name: "normal ranges inbetween true", rs: IntRanges{{0, 4}, {5, 10}}, args: args{5}, want: true},
+		{name: "normal ranges inbetween false", rs: IntRanges{{0, 4}, {6, 10}}, args: args{5}, want: false},
 		{name: "normal start range true", rs: IntRanges{{0, 10}}, args: args{0}, want: true},
 		{name: "normal end range true", rs: IntRanges{{0, 10}}, args: args{10}, want: true},
 		{name: "small range true", rs: IntRanges{{1, 1}, {3, 3}}, args: args{1}, want: true},
@@ -183,9 +137,7 @@ func TestIntRanges_Get(t *testing.T) {
 		{name: "normal end range false", rs: IntRanges{{1, 2}}, args: args{3}, want: false},
 	}
 	for _, tt := range tests {
-		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
 			if got := tt.rs.Get(tt.args.n); got != tt.want {
 				t.Errorf("IntRanges.Get() = %v, want %v", got, tt.want)
 			}

pkg/menus/clean_menu.go

@@ -1,78 +0,0 @@
-// Clean Build Menu functions
-package menus
-
-import (
-	"context"
-	"io"
-	"os"
-
-	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-func anyExistInCache(pkgbuildDirs map[string]string) bool {
-	for _, dir := range pkgbuildDirs {
-		if _, err := os.Stat(dir); !os.IsNotExist(err) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func CleanFn(ctx context.Context, run *runtime.Runtime, w io.Writer,
-	pkgbuildDirsByBase map[string]string, installed mapset.Set[string],
-) error {
-	if len(pkgbuildDirsByBase) == 0 {
-		return nil // no work to do
-	}
-
-	if !anyExistInCache(pkgbuildDirsByBase) {
-		return nil
-	}
-
-	skipFunc := func(pkg string) bool {
-		dir := pkgbuildDirsByBase[pkg]
-		// TOFIX: new install engine dir will always exist, check if unclean instead
-		if _, err := os.Stat(dir); os.IsNotExist(err) {
-			return true
-		}
-
-		return false
-	}
-
-	bases := make([]string, 0, len(pkgbuildDirsByBase))
-	for pkg := range pkgbuildDirsByBase {
-		bases = append(bases, pkg)
-	}
-
-	toClean, errClean := selectionMenu(run.Logger, pkgbuildDirsByBase, bases, installed,
-		gotext.Get("Packages to cleanBuild?"),
-		settings.NoConfirm, run.Cfg.AnswerClean, skipFunc)
-	if errClean != nil {
-		return errClean
-	}
-
-	for i, base := range toClean {
-		dir := pkgbuildDirsByBase[base]
-		run.Logger.OperationInfoln(gotext.Get("Deleting (%d/%d): %s", i+1, len(toClean), text.Cyan(dir)))
-
-		if err := run.CmdBuilder.Show(run.CmdBuilder.BuildGitCmd(ctx, dir, "reset", "--hard", "origin/HEAD")); err != nil {
-			run.Logger.Warnln(gotext.Get("Unable to clean:"), dir)
-
-			return err
-		}
-
-		if err := run.CmdBuilder.Show(run.CmdBuilder.BuildGitCmd(ctx, dir, "clean", "-fdx")); err != nil {
-			run.Logger.Warnln(gotext.Get("Unable to clean:"), dir)
-
-			return err
-		}
-	}
-
-	return nil
-}

pkg/menus/diff_menu.go

@@ -1,181 +0,0 @@
-// file dedicated to diff menu
-package menus
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/multierror"
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/exe"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-const (
-	gitEmptyTree   = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
-	gitDiffRefName = "AUR_SEEN"
-)
-
-func showPkgbuildDiffs(ctx context.Context, cmdBuilder exe.ICmdBuilder, logger *text.Logger,
-	pkgbuildDirs map[string]string, bases []string,
-) error {
-	var errMulti multierror.MultiError
-
-	for _, pkg := range bases {
-		dir := pkgbuildDirs[pkg]
-
-		start, err := getLastSeenHash(ctx, cmdBuilder, dir)
-		if err != nil {
-			errMulti.Add(err)
-
-			continue
-		}
-
-		if start != gitEmptyTree {
-			hasDiff, err := gitHasDiff(ctx, cmdBuilder, dir)
-			if err != nil {
-				errMulti.Add(err)
-
-				continue
-			}
-
-			if !hasDiff {
-				logger.Warnln(gotext.Get("%s: No changes -- skipping", text.Cyan(pkg)))
-
-				continue
-			}
-		}
-
-		args := []string{
-			"diff",
-			start + "..HEAD@{upstream}", "--src-prefix",
-			dir + "/", "--dst-prefix", dir + "/", "--", ".", ":(exclude).SRCINFO",
-		}
-		if text.UseColor {
-			args = append(args, "--color=always")
-		} else {
-			args = append(args, "--color=never")
-		}
-
-		_ = cmdBuilder.Show(cmdBuilder.BuildGitCmd(ctx, dir, args...))
-	}
-
-	return errMulti.Return()
-}
-
-// Check whether or not a diff exists between the last reviewed diff and
-// HEAD@{upstream}.
-func gitHasDiff(ctx context.Context, cmdBuilder exe.ICmdBuilder, dir string) (bool, error) {
-	if gitHasLastSeenRef(ctx, cmdBuilder, dir) {
-		stdout, stderr, err := cmdBuilder.Capture(
-			cmdBuilder.BuildGitCmd(ctx, dir, "rev-parse", gitDiffRefName, "HEAD@{upstream}"))
-		if err != nil {
-			return false, fmt.Errorf("%s%w", stderr, err)
-		}
-
-		lines := strings.Split(stdout, "\n")
-		lastseen := lines[0]
-		upstream := lines[1]
-
-		return lastseen != upstream, nil
-	}
-	// If AUR_SEEN does not exists, we have never reviewed a diff for this package
-	// and should display it.
-	return true, nil
-}
-
-// Return whether or not we have reviewed a diff yet. It checks for the existence of
-// AUR_SEEN in the git ref-list.
-func gitHasLastSeenRef(ctx context.Context, cmdBuilder exe.ICmdBuilder, dir string) bool {
-	_, _, err := cmdBuilder.Capture(
-		cmdBuilder.BuildGitCmd(ctx,
-			dir, "rev-parse", "--quiet", "--verify", gitDiffRefName))
-
-	return err == nil
-}
-
-// Returns the last reviewed hash. If AUR_SEEN exists it will return this hash.
-// If it does not it will return empty tree as no diff have been reviewed yet.
-func getLastSeenHash(ctx context.Context, cmdBuilder exe.ICmdBuilder, dir string) (string, error) {
-	if gitHasLastSeenRef(ctx, cmdBuilder, dir) {
-		stdout, stderr, err := cmdBuilder.Capture(
-			cmdBuilder.BuildGitCmd(ctx,
-				dir, "rev-parse", gitDiffRefName))
-		if err != nil {
-			return "", fmt.Errorf("%s %w", stderr, err)
-		}
-
-		lines := strings.Split(stdout, "\n")
-
-		return lines[0], nil
-	}
-
-	return gitEmptyTree, nil
-}
-
-// Update the AUR_SEEN ref to HEAD. We use this ref to determine which diff were
-// reviewed by the user.
-func gitUpdateSeenRef(ctx context.Context, cmdBuilder exe.ICmdBuilder, dir string) error {
-	_, stderr, err := cmdBuilder.Capture(
-		cmdBuilder.BuildGitCmd(ctx,
-			dir, "update-ref", gitDiffRefName, "HEAD"))
-	if err != nil {
-		return fmt.Errorf("%s %w", stderr, err)
-	}
-
-	return nil
-}
-
-func updatePkgbuildSeenRef(ctx context.Context, cmdBuilder exe.ICmdBuilder, pkgbuildDirs map[string]string, bases []string) error {
-	var errMulti multierror.MultiError
-
-	for _, pkg := range bases {
-		dir := pkgbuildDirs[pkg]
-		if err := gitUpdateSeenRef(ctx, cmdBuilder, dir); err != nil {
-			errMulti.Add(err)
-		}
-	}
-
-	return errMulti.Return()
-}
-
-func DiffFn(ctx context.Context, run *runtime.Runtime, w io.Writer,
-	pkgbuildDirsByBase map[string]string, installed mapset.Set[string],
-) error {
-	if len(pkgbuildDirsByBase) == 0 {
-		return nil // no work to do
-	}
-
-	bases := make([]string, 0, len(pkgbuildDirsByBase))
-	for base := range pkgbuildDirsByBase {
-		bases = append(bases, base)
-	}
-
-	toDiff, errMenu := selectionMenu(run.Logger, pkgbuildDirsByBase, bases, installed, gotext.Get("Diffs to show?"),
-		settings.NoConfirm, run.Cfg.AnswerDiff, nil)
-	if errMenu != nil || len(toDiff) == 0 {
-		return errMenu
-	}
-
-	if errD := showPkgbuildDiffs(ctx, run.CmdBuilder, run.Logger, pkgbuildDirsByBase, toDiff); errD != nil {
-		return errD
-	}
-
-	run.Logger.Println()
-
-	if !run.Logger.ContinueTask(gotext.Get("Proceed with install?"), true, false) {
-		return settings.ErrUserAbort{}
-	}
-
-	if errUpd := updatePkgbuildSeenRef(ctx, run.CmdBuilder, pkgbuildDirsByBase, toDiff); errUpd != nil {
-		return errUpd
-	}
-
-	return nil
-}

pkg/menus/edit_menu.go

@@ -1,148 +0,0 @@
-// edit menu
-package menus
-
-import (
-	"context"
-	"errors"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-
-	gosrc "github.com/Morganamilo/go-srcinfo"
-	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/runtime"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-// Editor returns the preferred system editor.
-func editor(log *text.Logger, editorConfig, editorFlags string, noConfirm bool) (editor string, args []string) {
-	switch {
-	case editorConfig != "":
-		editor, err := exec.LookPath(editorConfig)
-		if err != nil {
-			log.Errorln(err)
-		} else {
-			return editor, strings.Fields(editorFlags)
-		}
-
-		fallthrough
-	case os.Getenv("VISUAL") != "":
-		if editorArgs := strings.Fields(os.Getenv("VISUAL")); len(editorArgs) != 0 {
-			editor, err := exec.LookPath(editorArgs[0])
-			if err != nil {
-				log.Errorln(err)
-			} else {
-				return editor, editorArgs[1:]
-			}
-		}
-
-		fallthrough
-	case os.Getenv("EDITOR") != "":
-		if editorArgs := strings.Fields(os.Getenv("EDITOR")); len(editorArgs) != 0 {
-			editor, err := exec.LookPath(editorArgs[0])
-			if err != nil {
-				log.Errorln(err)
-			} else {
-				return editor, editorArgs[1:]
-			}
-		}
-
-		fallthrough
-	default:
-		log.Errorln("\n", gotext.Get("%s is not set", text.Bold(text.Cyan("$EDITOR"))))
-		log.Warnln(gotext.Get("Add %s or %s to your environment variables", text.Bold(text.Cyan("$EDITOR")), text.Bold(text.Cyan("$VISUAL"))))
-
-		for {
-			log.Infoln(gotext.Get("Edit PKGBUILD with?"))
-
-			editorInput, err := log.GetInput("", noConfirm)
-			if err != nil {
-				log.Errorln(err)
-				continue
-			}
-
-			editorArgs := strings.Fields(editorInput)
-			if len(editorArgs) == 0 {
-				continue
-			}
-
-			editor, err := exec.LookPath(editorArgs[0])
-			if err != nil {
-				log.Errorln(err)
-				continue
-			}
-
-			return editor, editorArgs[1:]
-		}
-	}
-}
-
-func editPkgbuilds(log *text.Logger, pkgbuildDirs map[string]string, bases []string, editorConfig,
-	editorFlags string, srcinfos map[string]*gosrc.Srcinfo, noConfirm bool,
-) error {
-	pkgbuilds := make([]string, 0, len(bases))
-
-	for _, pkg := range bases {
-		dir := pkgbuildDirs[pkg]
-		pkgbuilds = append(pkgbuilds, filepath.Join(dir, "PKGBUILD"))
-
-		if srcinfos != nil {
-			for _, splitPkg := range srcinfos[pkg].SplitPackages() {
-				if splitPkg.Install != "" {
-					pkgbuilds = append(pkgbuilds, filepath.Join(dir, splitPkg.Install))
-				}
-			}
-		}
-	}
-
-	if len(pkgbuilds) > 0 {
-		editor, editorArgs := editor(log, editorConfig, editorFlags, noConfirm)
-		editorArgs = append(editorArgs, pkgbuilds...)
-		editcmd := exec.Command(editor, editorArgs...)
-		editcmd.Stdin, editcmd.Stdout, editcmd.Stderr = os.Stdin, os.Stdout, os.Stderr
-
-		if err := editcmd.Run(); err != nil {
-			return errors.New(gotext.Get("editor did not exit successfully, aborting: %s", err))
-		}
-	}
-
-	return nil
-}
-
-func EditFn(ctx context.Context, run *runtime.Runtime, w io.Writer,
-	pkgbuildDirsByBase map[string]string, installed mapset.Set[string],
-) error {
-	if len(pkgbuildDirsByBase) == 0 {
-		return nil // no work to do
-	}
-
-	bases := make([]string, 0, len(pkgbuildDirsByBase))
-	for pkg := range pkgbuildDirsByBase {
-		bases = append(bases, pkg)
-	}
-
-	toEdit, errMenu := selectionMenu(run.Logger, pkgbuildDirsByBase, bases, installed,
-		gotext.Get("PKGBUILDs to edit?"), settings.NoConfirm, run.Cfg.AnswerEdit, nil)
-	if errMenu != nil || len(toEdit) == 0 {
-		return errMenu
-	}
-
-	// TOFIX: remove or use srcinfo data
-	if errEdit := editPkgbuilds(run.Logger, pkgbuildDirsByBase,
-		toEdit, run.Cfg.Editor, run.Cfg.EditorFlags, nil, settings.NoConfirm); errEdit != nil {
-		return errEdit
-	}
-
-	run.Logger.Println()
-
-	if !run.Logger.ContinueTask(gotext.Get("Proceed with install?"), true, false) {
-		return settings.ErrUserAbort{}
-	}
-
-	return nil
-}

pkg/menus/menu.go

@@ -1,103 +0,0 @@
-package menus
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/intrange"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/text"
-
-	mapset "github.com/deckarep/golang-set/v2"
-)
-
-func pkgbuildNumberMenu(logger *text.Logger, pkgbuildDirs map[string]string,
-	bases []string, installed mapset.Set[string],
-) {
-	toPrint := ""
-
-	for n, pkgBase := range bases {
-		dir := pkgbuildDirs[pkgBase]
-		toPrint += fmt.Sprintf(text.Magenta("%3d")+" %-40s", len(pkgbuildDirs)-n,
-			text.Bold(pkgBase))
-
-		if installed.Contains(pkgBase) {
-			toPrint += text.Bold(text.Green(gotext.Get(" (Installed)")))
-		}
-
-		// TODO: remove or refactor to check if git dir is unclean
-		if _, err := os.Stat(dir); !os.IsNotExist(err) {
-			toPrint += text.Bold(text.Green(gotext.Get(" (Build Files Exist)")))
-		}
-
-		toPrint += "\n"
-	}
-
-	logger.Print(toPrint)
-}
-
-func selectionMenu(logger *text.Logger, pkgbuildDirs map[string]string, bases []string, installed mapset.Set[string],
-	message string, noConfirm bool, defaultAnswer string, skipFunc func(string) bool,
-) ([]string, error) {
-	selected := make([]string, 0)
-
-	pkgbuildNumberMenu(logger, pkgbuildDirs, bases, installed)
-
-	logger.Infoln(message)
-	logger.Infoln(gotext.Get("%s [A]ll [Ab]ort [I]nstalled [No]tInstalled or (1 2 3, 1-3, ^4)", text.Cyan(gotext.Get("[N]one"))))
-
-	selectInput, err := logger.GetInput(defaultAnswer, noConfirm)
-	if err != nil {
-		return nil, err
-	}
-
-	eInclude, eExclude, eOtherInclude, eOtherExclude := intrange.ParseNumberMenu(selectInput)
-	eIsInclude := len(eExclude) == 0 && eOtherExclude.Cardinality() == 0
-
-	if eOtherInclude.Contains("abort") || eOtherInclude.Contains("ab") {
-		return nil, settings.ErrUserAbort{}
-	}
-
-	if eOtherInclude.Contains("n") || eOtherInclude.Contains("none") {
-		return selected, nil
-	}
-
-	for i, pkgBase := range bases {
-		if skipFunc != nil && skipFunc(pkgBase) {
-			continue
-		}
-
-		anyInstalled := installed.Contains(pkgBase)
-
-		if !eIsInclude && eExclude.Get(len(bases)-i) {
-			continue
-		}
-
-		if anyInstalled && (eOtherInclude.Contains("i") || eOtherInclude.Contains("installed")) {
-			selected = append(selected, pkgBase)
-			continue
-		}
-
-		if !anyInstalled && (eOtherInclude.Contains("no") || eOtherInclude.Contains("notinstalled")) {
-			selected = append(selected, pkgBase)
-			continue
-		}
-
-		if eOtherInclude.Contains("a") || eOtherInclude.Contains("all") {
-			selected = append(selected, pkgBase)
-			continue
-		}
-
-		if eIsInclude && (eInclude.Get(len(bases)-i) || eOtherInclude.Contains(pkgBase)) {
-			selected = append(selected, pkgBase)
-		}
-
-		if !eIsInclude && (!eExclude.Get(len(bases)-i) && !eOtherExclude.Contains(pkgBase)) {
-			selected = append(selected, pkgBase)
-		}
-	}
-
-	return selected, nil
-}

pkg/multierror/multierror.go

@@ -2,13 +2,13 @@ package multierror
 
 import "sync"
 
-// MultiError type handles error accumulation from goroutines.
+// MultiError type handles error accumulation from goroutines
 type MultiError struct {
 	Errors []error
 	mux    sync.Mutex
 }
 
-// Error turns the MultiError structure into a string.
+// Error turns the MultiError structure into a string
 func (err *MultiError) Error() string {
 	str := ""
 
@@ -19,7 +19,7 @@ func (err *MultiError) Error() string {
 	return str[:len(str)-1]
 }
 
-// Add adds an error to the Multierror structure.
+// Add adds an error to the Multierror structure
 func (err *MultiError) Add(e error) {
 	if e == nil {
 		return
@@ -31,7 +31,7 @@ func (err *MultiError) Add(e error) {
 }
 
 // Return is used as a wrapper on return on whether to return the
-// MultiError Structure if errors exist or nil instead of delivering an empty structure.
+// MultiError Structure if errors exist or nil instead of delivering an empty structure
 func (err *MultiError) Return() error {
 	if len(err.Errors) > 0 {
 		return err

pkg/news/.snapshots/TestPrintNewsFeed-all-quiet

@@ -1,11 +0,0 @@
-2019-12-20 Xorg cleanup requires manual intervention
-2020-01-04 Now using Zstandard instead of xz for package compression
-2020-01-15 rsync compatibility
-2020-02-17 sshd needs restarting after upgrading to openssh-8.2p1
-2020-02-22 Planet Arch Linux migration
-2020-02-24 The Future of the Arch Linux Project Leader
-2020-03-01 firewalld>=0.8.1-2 update requires manual intervention
-2020-03-19 hplip 3.20.3-2 update requires manual intervention
-2020-04-13 nss>=3.51.1-1 and lib32-nss>=3.51.1-1 updates require manual intervention
-2020-04-14 zn_poly 0.9.2-2 update requires manual intervention
-

pkg/news/.snapshots/TestPrintNewsFeed-all-verbose

@@ -1,114 +0,0 @@
-2019-12-20 Xorg cleanup requires manual intervention
-In the process of Xorg cleanup the update requires manual
-intervention when you hit this message:
-
-:: installing xorgproto (2019.2-2) breaks dependency 'inputproto' required by lib32-libxi
-:: installing xorgproto (2019.2-2) breaks dependency 'dmxproto' required by libdmx
-:: installing xorgproto (2019.2-2) breaks dependency 'xf86dgaproto' required by libxxf86dga
-:: installing xorgproto (2019.2-2) breaks dependency 'xf86miscproto' required by libxxf86misc
-
-when updating, use: pacman -Rdd libdmx libxxf86dga libxxf86misc && pacman -Syu to perform the upgrade.
-
-2020-01-04 Now using Zstandard instead of xz for package compression
-As announced on the mailing list, on Friday, Dec 27 2019, our package compression scheme has changed from xz (.pkg.tar.xz) to zstd (.pkg.tar.zst).
-
-zstd and xz trade blows in their compression ratio. Recompressing all packages to zstd with our options yields a total ~0.8% increase in package size on all of our packages combined, but the decompression time for all packages saw a ~1300% speedup.
-
-We already have more than 545 zstd-compressed packages in our repositories, and as packages get updated more will keep rolling in. We have not found any user-facing issues as of yet, so things appear to be working.
-
-As a packager, you will automatically start building .pkg.tar.zst packages if you are using the latest version of devtools (>= 20191227).
-As an end-user no manual intervention is required, assuming that you have read and followed the news post from late last year.
-
-If you nevertheless haven't updated libarchive since 2018, all hope is not lost! Binary builds of pacman-static are available from Eli Schwartz' personal repository (or direct link to binary), signed with their Trusted User keys, with which you can perform the update.
-
-2020-01-15 rsync compatibility
-Our rsync package was shipped with bundled zlib to provide compatibility
-with the old-style --compress option up to version 3.1.0. Version 3.1.1 was
-released on 2014-06-22 and is shipped by all major distributions now.
-
-So we decided to finally drop the bundled library and ship a package with
-system zlib. This also fixes security issues, actual ones and in future. Go
-and blame those running old versions if you encounter errors with rsync
-3.1.3-3.
-
-2020-02-17 sshd needs restarting after upgrading to openssh-8.2p1
-After upgrading to openssh-8.2p1, the existing SSH daemon will be unable to accept new connections. (See FS#65517.) When upgrading remote hosts, please make sure to restart the SSH daemon using systemctl restart sshd right after running pacman -Syu. If you are upgrading to openssh-8.2p1-3 or higher, this restart will happen automatically.
-
-2020-02-22 Planet Arch Linux migration
-The software behind planet.archlinux.org was implemented in Python 2 and is no longer maintained upstream. This functionality has now been implemented in archlinux.org's archweb backend which is actively maintained but offers a slightly different experience.
-
-The most notable changes are the offered feeds and the feed location. Archweb only offers an Atom feed which is located at here.
-
-2020-02-24 The Future of the Arch Linux Project Leader
-Hello everyone,
-
-Some of you may know me from the days when I was much more involved in Arch, but most of you probably just know me as a name on the website. I’ve been with Arch for some time, taking the leadership of this beast over from Judd back in 2007. But, as these things often go, my involvement has slid down to minimal levels over time. It’s high time that changes.
-
-Arch Linux needs involved leadership to make hard decisions and direct the project where it needs to go. And I am not in a position to do this.
-
-In a team effort, the Arch Linux staff devised a new process for determining future leaders. From now on, leaders will be elected by the staff for a term length of two years. Details of this new process can be found here
-
-In the first official vote with Levente Polyak (anthraxx), Gaetan Bisson (vesath), Giancarlo Razzolini (grazzolini), and Sven-Hendrik Haase (svenstaro) as candidates, and through 58 verified votes, a winner was chosen:
-
-Levente Polyak (anthraxx) will be taking over the reins of this ship. Congratulations!
-
-Thanks for everything over all these years,
-Aaron Griffin (phrakture)
-
-2020-03-01 firewalld>=0.8.1-2 update requires manual intervention
-The firewalld package prior to version 0.8.1-2 was missing the compiled python modules. This has been fixed in 0.8.1-2, so the upgrade will need to overwrite the untracked pyc files created. If you get errors like these
-
-firewalld: /usr/lib/python3.8/site-packages/firewall/__pycache__/__init__.cpython-38.pyc exists in filesystem
-firewalld: /usr/lib/python3.8/site-packages/firewall/__pycache__/client.cpython-38.pyc exists in filesystem
-firewalld: /usr/lib/python3.8/site-packages/firewall/__pycache__/dbus_utils.cpython-38.pyc exists in filesystem
-...many more...
-
-when updating, use
-
-pacman -Suy --overwrite /usr/lib/python3.8/site-packages/firewall/\*
-
-to perform the upgrade.
-
-2020-03-19 hplip 3.20.3-2 update requires manual intervention
-The hplip package prior to version 3.20.3-2 was missing the compiled
-python modules. This has been fixed in 3.20.3-2, so the upgrade will
-need to overwrite the untracked pyc files that were created. If you get errors
-such as these
-
-hplip: /usr/share/hplip/base/__pycache__/__init__.cpython-38.pyc exists in filesystem
-hplip: /usr/share/hplip/base/__pycache__/avahi.cpython-38.pyc exists in filesystem
-hplip: /usr/share/hplip/base/__pycache__/codes.cpython-38.pyc exists in filesystem
-...many more...
-
-when updating, use
-
-pacman -Suy --overwrite /usr/share/hplip/\*
-
-to perform the upgrade.
-
-2020-04-13 nss>=3.51.1-1 and lib32-nss>=3.51.1-1 updates require manual intervention
-The nss and lib32-nss packages prior to version 3.51.1-1 were missing a soname link each. This has been fixed in 3.51.1-1, so the upgrade will need to overwrite the untracked files created by ldconfig. If you get any of these errors
-
-nss: /usr/lib/p11-kit-trust.so exists in filesystem
-lib32-nss: /usr/lib32/p11-kit-trust.so exists in filesystem
-
-when updating, use
-
-pacman -Syu --overwrite /usr/lib\*/p11-kit-trust.so
-
-to perform the upgrade.
-
-2020-04-14 zn_poly 0.9.2-2 update requires manual intervention
-The zn_poly package prior to version 0.9.2-2 was missing a soname link.
-This has been fixed in 0.9.2-2, so the upgrade will need to overwrite the
-untracked files created by ldconfig. If you get an error
-
-zn_poly: /usr/lib/libzn_poly-0.9.so  exists in filesystem
-
-when updating, use
-
-pacman -Syu --overwrite usr/lib/libzn_poly-0.9.so
-
-to perform the upgrade.
-
-

pkg/news/.snapshots/TestPrintNewsFeed-latest-quiet

@@ -1,3 +0,0 @@
-2020-04-13 nss>=3.51.1-1 and lib32-nss>=3.51.1-1 updates require manual intervention
-2020-04-14 zn_poly 0.9.2-2 update requires manual intervention
-

pkg/news/.snapshots/TestPrintNewsFeed-latest-quiet-topdown

@@ -1,3 +0,0 @@
-2020-04-14 zn_poly 0.9.2-2 update requires manual intervention
-2020-04-13 nss>=3.51.1-1 and lib32-nss>=3.51.1-1 updates require manual intervention
-

pkg/news/.snapshots/TestPrintNewsFeedSameDay

@@ -1,3 +0,0 @@
-2020-04-14 zn_poly 0.9.2-2 update requires manual intervention
-The zn_poly package prior to version 0.9.2-2 was missing a soname link.
-

pkg/news/news.go

@@ -1,174 +0,0 @@
-package news
-
-import (
-	"bytes"
-	"context"
-	"encoding/xml"
-	"html"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type item struct {
-	Title       string `xml:"title"`
-	Link        string `xml:"link"`
-	Description string `xml:"description"`
-	PubDate     string `xml:"pubDate"`
-	Creator     string `xml:"dc:creator"`
-}
-
-func (item *item) printNews(logger *text.Logger, buildTime time.Time, all, quiet bool) {
-	var fd string
-
-	date, err := time.Parse(time.RFC1123Z, item.PubDate)
-
-	if err != nil {
-		logger.Errorln(err)
-	} else {
-		fd = text.FormatTime(int(date.Unix()))
-		if !all && !buildTime.IsZero() {
-			if buildTime.After(date) {
-				return
-			}
-		}
-	}
-
-	logger.Println(text.Bold(text.Magenta(fd)), text.Bold(strings.TrimSpace(item.Title)))
-
-	if !quiet {
-		desc := strings.TrimSpace(parseNews(item.Description))
-		logger.Println(desc)
-	}
-}
-
-type channel struct {
-	Title         string `xml:"title"`
-	Link          string `xml:"link"`
-	Description   string `xml:"description"`
-	Language      string `xml:"language"`
-	Lastbuilddate string `xml:"lastbuilddate"`
-	Items         []item `xml:"item"`
-}
-
-type rss struct {
-	Channel channel `xml:"channel"`
-}
-
-func PrintNewsFeed(ctx context.Context, client *http.Client, logger *text.Logger,
-	cutOffDate time.Time, bottomUp, all, quiet bool,
-) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://archlinux.org/feeds/news", http.NoBody)
-	if err != nil {
-		return err
-	}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return err
-	}
-
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return err
-	}
-
-	rssGot := rss{}
-
-	d := xml.NewDecoder(bytes.NewReader(body))
-	if err := d.Decode(&rssGot); err != nil {
-		return err
-	}
-
-	if bottomUp {
-		for i := len(rssGot.Channel.Items) - 1; i >= 0; i-- {
-			rssGot.Channel.Items[i].printNews(logger, cutOffDate, all, quiet)
-		}
-	} else {
-		for i := 0; i < len(rssGot.Channel.Items); i++ {
-			rssGot.Channel.Items[i].printNews(logger, cutOffDate, all, quiet)
-		}
-	}
-
-	return nil
-}
-
-// Crude html parsing, good enough for the arch news
-// This is only displayed in the terminal so there should be no security
-// concerns.
-func parseNews(str string) string {
-	var (
-		buffer       bytes.Buffer
-		tagBuffer    bytes.Buffer
-		escapeBuffer bytes.Buffer
-		inTag        = false
-		inEscape     = false
-	)
-
-	for _, char := range str {
-		if inTag {
-			if char == '>' {
-				inTag = false
-
-				switch tagBuffer.String() {
-				case "code":
-					buffer.WriteString(text.CyanCode)
-				case "/code":
-					buffer.WriteString(text.ResetCode)
-				case "/p":
-					buffer.WriteRune('\n')
-				}
-
-				continue
-			}
-
-			tagBuffer.WriteRune(char)
-
-			continue
-		}
-
-		if inEscape {
-			if char == ';' {
-				inEscape = false
-
-				escapeBuffer.WriteRune(char)
-				s := html.UnescapeString(escapeBuffer.String())
-				buffer.WriteString(s)
-
-				continue
-			}
-
-			escapeBuffer.WriteRune(char)
-
-			continue
-		}
-
-		if char == '<' {
-			inTag = true
-
-			tagBuffer.Reset()
-
-			continue
-		}
-
-		if char == '&' {
-			inEscape = true
-
-			escapeBuffer.Reset()
-			escapeBuffer.WriteRune(char)
-
-			continue
-		}
-
-		buffer.WriteRune(char)
-	}
-
-	buffer.WriteString(text.ResetCode)
-
-	return buffer.String()
-}

pkg/news/news_test.go

@@ -1,179 +0,0 @@
-//go:build !integration
-// +build !integration
-
-package news
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"os"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/bradleyjkemp/cupaloy"
-	"github.com/stretchr/testify/assert"
-	"gopkg.in/h2non/gock.v1"
-
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-const lastNews = `
-<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">
-   <channel>
-      <title>Arch Linux: Recent news updates</title>
-      <link>https://www.archlinux.org/news/</link>
-      <description>The latest and greatest news from the Arch Linux distribution.</description>
-      <atom:link href="https://www.archlinux.org/feeds/news/" rel="self" />
-      <language>en-us</language>
-      <lastBuildDate>Tue, 14 Apr 2020 16:30:32 +0000</lastBuildDate>
-      <item>
-         <title>zn_poly 0.9.2-2 update requires manual intervention</title>
-         <link>https://www.archlinux.org/news/zn_poly-092-2-update-requires-manual-intervention/</link>
-         <description>&lt;p&gt;The zn_poly package prior to version 0.9.2-2 was missing a soname link.</description>
-         <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Antonio Rojas</dc:creator>
-         <pubDate>Tue, 14 Apr 2020 16:30:30 +0000</pubDate>
-         <guid isPermaLink="false">tag:www.archlinux.org,2020-04-14:/news/zn_poly-092-2-update-requires-manual-intervention/</guid>
-      </item>
-   </channel>
-</rss>
-`
-
-const sampleNews = `<?xml version="1.0" encoding="utf-8"?>
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Arch Linux: Recent news updates</title><link>https://www.archlinux.org/news/</link><description>The latest and greatest news from the Arch Linux distribution.</description><atom:link href="https://www.archlinux.org/feeds/news/" rel="self"></atom:link><language>en-us</language><lastBuildDate>Tue, 14 Apr 2020 16:30:32 +0000</lastBuildDate><item><title>zn_poly 0.9.2-2 update requires manual intervention</title><link>https://www.archlinux.org/news/zn_poly-092-2-update-requires-manual-intervention/</link><description>&lt;p&gt;The zn_poly package prior to version 0.9.2-2 was missing a soname link.
-This has been fixed in 0.9.2-2, so the upgrade will need to overwrite the
-untracked files created by ldconfig. If you get an error&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;zn_poly: /usr/lib/libzn_poly-0.9.so  exists in filesystem
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;when updating, use&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;pacman -Syu --overwrite usr/lib/libzn_poly-0.9.so
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;to perform the upgrade.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Antonio Rojas</dc:creator><pubDate>Tue, 14 Apr 2020 16:30:30 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-04-14:/news/zn_poly-092-2-update-requires-manual-intervention/</guid></item><item><title>nss&gt;=3.51.1-1 and lib32-nss&gt;=3.51.1-1 updates require manual intervention</title><link>https://www.archlinux.org/news/nss3511-1-and-lib32-nss3511-1-updates-require-manual-intervention/</link><description>&lt;p&gt;The nss and lib32-nss packages prior to version 3.51.1-1 were missing a soname link each. This has been fixed in 3.51.1-1, so the upgrade will need to overwrite the untracked files created by ldconfig. If you get any of these errors&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;nss: /usr/lib/p11-kit-trust.so exists in filesystem
-lib32-nss: /usr/lib32/p11-kit-trust.so exists in filesystem
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;when updating, use&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;pacman -Syu --overwrite /usr/lib\*/p11-kit-trust.so
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;to perform the upgrade.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Jan Alexander Steffens</dc:creator><pubDate>Mon, 13 Apr 2020 00:35:58 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-04-13:/news/nss3511-1-and-lib32-nss3511-1-updates-require-manual-intervention/</guid></item><item><title>hplip 3.20.3-2 update requires manual intervention</title><link>https://www.archlinux.org/news/hplip-3203-2-update-requires-manual-intervention/</link><description>&lt;p&gt;The hplip package prior to version 3.20.3-2 was missing the compiled
-python modules. This has been fixed in 3.20.3-2, so the upgrade will
-need to overwrite the untracked pyc files that were created. If you get errors
-such as these&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;hplip: /usr/share/hplip/base/__pycache__/__init__.cpython-38.pyc exists in filesystem
-hplip: /usr/share/hplip/base/__pycache__/avahi.cpython-38.pyc exists in filesystem
-hplip: /usr/share/hplip/base/__pycache__/codes.cpython-38.pyc exists in filesystem
-...many more...
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;when updating, use&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;pacman -Suy --overwrite /usr/share/hplip/\*
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;to perform the upgrade.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Andreas Radke</dc:creator><pubDate>Thu, 19 Mar 2020 06:53:30 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-03-19:/news/hplip-3203-2-update-requires-manual-intervention/</guid></item><item><title>firewalld&gt;=0.8.1-2 update requires manual intervention</title><link>https://www.archlinux.org/news/firewalld081-2-update-requires-manual-intervention/</link><description>&lt;p&gt;The firewalld package prior to version 0.8.1-2 was missing the compiled python modules. This has been fixed in 0.8.1-2, so the upgrade will need to overwrite the untracked pyc files created. If you get errors like these&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;firewalld: /usr/lib/python3.8/site-packages/firewall/__pycache__/__init__.cpython-38.pyc exists in filesystem
-firewalld: /usr/lib/python3.8/site-packages/firewall/__pycache__/client.cpython-38.pyc exists in filesystem
-firewalld: /usr/lib/python3.8/site-packages/firewall/__pycache__/dbus_utils.cpython-38.pyc exists in filesystem
-...many more...
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;when updating, use&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;pacman -Suy --overwrite /usr/lib/python3.8/site-packages/firewall/\*
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;to perform the upgrade.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Jan Alexander Steffens</dc:creator><pubDate>Sun, 01 Mar 2020 16:36:48 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-03-01:/news/firewalld081-2-update-requires-manual-intervention/</guid></item><item><title>The Future of the Arch Linux Project Leader</title><link>https://www.archlinux.org/news/the-future-of-the-arch-linux-project-leader/</link><description>&lt;p&gt;Hello everyone,&lt;/p&gt;
-&lt;p&gt;Some of you may know me from the days when I was much more involved in Arch, but most of you probably just know me as a name on the website. I’ve been with Arch for some time, taking the leadership of this beast over from Judd back in 2007. But, as these things often go, my involvement has slid down to minimal levels over time. It’s high time that changes.&lt;/p&gt;
-&lt;p&gt;Arch Linux needs involved leadership to make hard decisions and direct the project where it needs to go. And I am not in a position to do this.&lt;/p&gt;
-&lt;p&gt;In a team effort, the Arch Linux staff devised a new process for determining future leaders. From now on, leaders will be elected by the staff for a term length of two years. Details of this new process can be found &lt;a href="https://wiki.archlinux.org/index.php/DeveloperWiki:Project_Leader"&gt;here&lt;/a&gt;&lt;/p&gt;
-&lt;p&gt;In the first official vote with Levente Polyak (anthraxx), Gaetan Bisson (vesath), Giancarlo Razzolini (grazzolini), and Sven-Hendrik Haase (svenstaro) as candidates, and through 58 verified votes, a winner was chosen:&lt;/p&gt;
-&lt;p&gt;&lt;strong&gt;Levente Polyak (anthraxx) will be taking over the reins of this ship. Congratulations!&lt;/strong&gt;&lt;/p&gt;
-&lt;p&gt;&lt;em&gt;Thanks for everything over all these years,&lt;br /&gt;
-Aaron Griffin (phrakture)&lt;/em&gt;&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Aaron Griffin</dc:creator><pubDate>Mon, 24 Feb 2020 15:56:28 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-02-24:/news/the-future-of-the-arch-linux-project-leader/</guid></item><item><title>Planet Arch Linux migration</title><link>https://www.archlinux.org/news/planet-arch-linux-migration/</link><description>&lt;p&gt;The software behind planet.archlinux.org was implemented in Python 2 and is no longer maintained upstream. This functionality has now been implemented in archlinux.org's archweb backend which is actively maintained but offers a slightly different experience.&lt;/p&gt;
-&lt;p&gt;The most notable changes are the offered feeds and the feed location. Archweb only offers an Atom feed which is located at &lt;a href="https://archlinux.org/feeds/planet"&gt;here&lt;/a&gt;.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Jelle van der Waa</dc:creator><pubDate>Sat, 22 Feb 2020 22:43:00 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-02-22:/news/planet-arch-linux-migration/</guid></item><item><title>sshd needs restarting after upgrading to openssh-8.2p1</title><link>https://www.archlinux.org/news/sshd-needs-restarting-after-upgrading-to-openssh-82p1/</link><description>&lt;p&gt;After upgrading to openssh-8.2p1, the existing SSH daemon will be unable to accept new connections. (See &lt;a href="https://bugs.archlinux.org/task/65517"&gt;FS#65517&lt;/a&gt;.) When upgrading remote hosts, please make sure to restart the SSH daemon using &lt;code&gt;systemctl restart sshd&lt;/code&gt; right after running &lt;code&gt;pacman -Syu&lt;/code&gt;. If you are upgrading to openssh-8.2p1-3 or higher, this restart will happen automatically.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Gaetan Bisson</dc:creator><pubDate>Mon, 17 Feb 2020 01:35:04 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-02-17:/news/sshd-needs-restarting-after-upgrading-to-openssh-82p1/</guid></item><item><title>rsync compatibility</title><link>https://www.archlinux.org/news/rsync-compatibility/</link><description>&lt;p&gt;Our &lt;code&gt;rsync&lt;/code&gt; package was shipped with bundled &lt;code&gt;zlib&lt;/code&gt; to provide compatibility
-with the old-style &lt;code&gt;--compress&lt;/code&gt; option up to version 3.1.0. Version 3.1.1 was
-released on 2014-06-22 and is shipped by all major distributions now.&lt;/p&gt;
-&lt;p&gt;So we decided to finally drop the bundled library and ship a package with
-system &lt;code&gt;zlib&lt;/code&gt;. This also fixes security issues, actual ones and in future. Go
-and blame those running old versions if you encounter errors with &lt;code&gt;rsync
-3.1.3-3&lt;/code&gt;.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Christian Hesse</dc:creator><pubDate>Wed, 15 Jan 2020 20:14:43 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-01-15:/news/rsync-compatibility/</guid></item><item><title>Now using Zstandard instead of xz for package compression</title><link>https://www.archlinux.org/news/now-using-zstandard-instead-of-xz-for-package-compression/</link><description>&lt;p&gt;As announced on the &lt;a href="https://lists.archlinux.org/pipermail/arch-dev-public/2019-December/029752.html"&gt;mailing list&lt;/a&gt;, on Friday, Dec 27 2019, our package compression scheme has changed from xz (.pkg.tar.xz) to &lt;a href="https://lists.archlinux.org/pipermail/arch-dev-public/2019-December/029778.html"&gt;zstd (.pkg.tar.zst)&lt;/a&gt;.&lt;/p&gt;
-&lt;p&gt;zstd and xz trade blows in their compression ratio. Recompressing all packages to zstd with our options yields a total ~0.8% increase in package size on all of our packages combined, but the decompression time for all packages saw a ~1300% speedup.&lt;/p&gt;
-&lt;p&gt;We already have more than 545 zstd-compressed packages in our repositories, and as packages get updated more will keep rolling in. We have not found any user-facing issues as of yet, so things appear to be working.&lt;/p&gt;
-&lt;p&gt;As a packager, you will automatically start building .pkg.tar.zst packages if you are using the latest version of devtools (&amp;gt;= 20191227).&lt;br /&gt;
-As an end-user no manual intervention is required, assuming that you have read and followed the news post &lt;a href="https://www.archlinux.org/news/required-update-to-recent-libarchive/"&gt;from late last year&lt;/a&gt;.&lt;/p&gt;
-&lt;p&gt;If you nevertheless haven't updated libarchive since 2018, all hope is not lost! Binary builds of pacman-static are available from Eli Schwartz' &lt;a href="https://wiki.archlinux.org/index.php/Unofficial_user_repositories#eschwartz"&gt;personal repository&lt;/a&gt; (or direct link to &lt;a href="https://pkgbuild.com/~eschwartz/repo/x86_64-extracted/"&gt;binary&lt;/a&gt;), signed with their Trusted User keys, with which you can perform the update.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Robin Broda</dc:creator><pubDate>Sat, 04 Jan 2020 20:35:55 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2020-01-04:/news/now-using-zstandard-instead-of-xz-for-package-compression/</guid></item><item><title>Xorg cleanup requires manual intervention</title><link>https://www.archlinux.org/news/xorg-cleanup-requires-manual-intervention/</link><description>&lt;p&gt;In the process of &lt;a href="https://bugs.archlinux.org/task/64892"&gt;Xorg cleanup&lt;/a&gt; the update requires manual
-intervention when you hit this message:&lt;/p&gt;
-&lt;pre&gt;&lt;code&gt;:: installing xorgproto (2019.2-2) breaks dependency 'inputproto' required by lib32-libxi
-:: installing xorgproto (2019.2-2) breaks dependency 'dmxproto' required by libdmx
-:: installing xorgproto (2019.2-2) breaks dependency 'xf86dgaproto' required by libxxf86dga
-:: installing xorgproto (2019.2-2) breaks dependency 'xf86miscproto' required by libxxf86misc
-&lt;/code&gt;&lt;/pre&gt;
-&lt;p&gt;when updating, use: &lt;code&gt;pacman -Rdd libdmx libxxf86dga libxxf86misc &amp;amp;&amp;amp; pacman -Syu&lt;/code&gt; to perform the upgrade.&lt;/p&gt;</description><dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Andreas Radke</dc:creator><pubDate>Fri, 20 Dec 2019 13:37:40 +0000</pubDate><guid isPermaLink="false">tag:www.archlinux.org,2019-12-20:/news/xorg-cleanup-requires-manual-intervention/</guid></item></channel></rss>
-`
-
-func TestPrintNewsFeed(t *testing.T) {
-	layout := "2006-01-02"
-	str := "2020-04-13"
-	lastNewsTime, _ := time.Parse(layout, str)
-
-	type args struct {
-		cutOffDate time.Time
-		bottomUp   bool
-		all        bool
-		quiet      bool
-	}
-	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-	}{
-		{name: "all-verbose", args: args{bottomUp: true, cutOffDate: time.Now(), all: true, quiet: false}, wantErr: false},
-		{name: "all-quiet", args: args{bottomUp: true, cutOffDate: lastNewsTime, all: true, quiet: true}, wantErr: false},
-		{name: "latest-quiet", args: args{bottomUp: true, cutOffDate: lastNewsTime, all: false, quiet: true}, wantErr: false},
-		{name: "latest-quiet-topdown", args: args{bottomUp: false, cutOffDate: lastNewsTime, all: false, quiet: true}, wantErr: false},
-	}
-	t.Setenv("TZ", "UTC")
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			gock.New("https://archlinux.org").
-				Get("/feeds/news").
-				Reply(200).
-				BodyString(sampleNews)
-
-			defer gock.Off()
-
-			r, w, _ := os.Pipe()
-			logger := text.NewLogger(w, w, strings.NewReader(""), false, "logger")
-
-			err := PrintNewsFeed(context.Background(), &http.Client{}, logger,
-				tt.args.cutOffDate, tt.args.bottomUp, tt.args.all, tt.args.quiet)
-			assert.NoError(t, err)
-
-			w.Close()
-			out, _ := io.ReadAll(r)
-			cupaloy.SnapshotT(t, out)
-		})
-	}
-}
-
-// GIVEN last build time at 13h00
-// WHEN there's a news posted at 18h00
-// THEN it should still be printed
-func TestPrintNewsFeedSameDay(t *testing.T) {
-	str := "2020-04-14T13:04:05Z"
-	lastNewsTime, _ := time.Parse(time.RFC3339, str)
-
-	gock.New("https://archlinux.org").
-		Get("/feeds/news").
-		Reply(200).
-		BodyString(lastNews)
-
-	defer gock.Off()
-
-	r, w, _ := os.Pipe()
-	logger := text.NewLogger(w, w, strings.NewReader(""), false, "logger")
-
-	err := PrintNewsFeed(context.Background(), &http.Client{}, logger,
-		lastNewsTime, true, false, false)
-	assert.NoError(t, err)
-
-	w.Close()
-	out, _ := io.ReadAll(r)
-	cupaloy.SnapshotT(t, out)
-}

pkg/query/aur_warnings.go

@@ -1,110 +0,0 @@
-package query
-
-import (
-	"strings"
-
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/aur"
-	"github.com/Jguer/go-alpm/v2"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type AURWarnings struct {
-	Orphans    []string
-	OutOfDate  []string
-	Missing    []string
-	LocalNewer []string
-
-	log *text.Logger
-}
-
-func NewWarnings(logger *text.Logger) *AURWarnings {
-	return &AURWarnings{log: logger}
-}
-
-func (warnings *AURWarnings) AddToWarnings(remote map[string]alpm.IPackage, aurPkg *aur.Pkg) {
-	name := aurPkg.Name
-	pkg, ok := remote[name]
-	if !ok {
-		return
-	}
-
-	if aurPkg.Maintainer == "" && !pkg.ShouldIgnore() {
-		warnings.Orphans = append(warnings.Orphans, name)
-	}
-
-	if aurPkg.OutOfDate != 0 && !pkg.ShouldIgnore() {
-		warnings.OutOfDate = append(warnings.OutOfDate, name)
-	}
-
-	if !pkg.ShouldIgnore() && !isDevelPackage(pkg) && db.VerCmp(pkg.Version(), aurPkg.Version) > 0 {
-		left, right := GetVersionDiff(pkg.Version(), aurPkg.Version)
-
-		newerMsg := gotext.Get("%s: local (%s) is newer than AUR (%s)",
-			text.Cyan(name),
-			left, right,
-		)
-
-		warnings.LocalNewer = append(warnings.LocalNewer, newerMsg)
-	}
-}
-
-func (warnings *AURWarnings) CalculateMissing(remoteNames []string,
-	remote map[string]alpm.IPackage, aurData map[string]*aur.Pkg,
-) {
-	for _, name := range remoteNames {
-		if _, ok := aurData[name]; !ok && !remote[name].ShouldIgnore() {
-			if _, ok := aurData[strings.TrimSuffix(name, "-debug")]; !ok {
-				warnings.Missing = append(warnings.Missing, name)
-			}
-		}
-	}
-}
-
-func (warnings *AURWarnings) Print() {
-	normalMissing, debugMissing := filterDebugPkgs(warnings.Missing)
-
-	if len(normalMissing) > 0 {
-		warnings.log.Warnln(gotext.Get("Packages not in AUR:"), formatNames(normalMissing))
-	}
-
-	if len(debugMissing) > 0 {
-		warnings.log.Warnln(gotext.Get("Missing AUR Debug Packages:"), formatNames(debugMissing))
-	}
-
-	if len(warnings.Orphans) > 0 {
-		warnings.log.Warnln(gotext.Get("Orphan (unmaintained) AUR Packages:"), formatNames(warnings.Orphans))
-	}
-
-	if len(warnings.OutOfDate) > 0 {
-		warnings.log.Warnln(gotext.Get("Flagged Out Of Date AUR Packages:"), formatNames(warnings.OutOfDate))
-	}
-
-	if len(warnings.LocalNewer) > 0 {
-		for _, newer := range warnings.LocalNewer {
-			warnings.log.Warnln(newer)
-		}
-	}
-}
-
-func filterDebugPkgs(names []string) (normal, debug []string) {
-	normal = make([]string, 0, len(names))
-	debug = make([]string, 0, len(names))
-
-	for _, name := range names {
-		if strings.HasSuffix(name, "-debug") {
-			debug = append(debug, name)
-		} else {
-			normal = append(normal, name)
-		}
-	}
-
-	return
-}
-
-func formatNames(names []string) string {
-	return " " + text.Cyan(strings.Join(names, "  "))
-}

pkg/query/errors.go

@@ -1,21 +0,0 @@
-package query
-
-import (
-	"github.com/leonelquinteros/gotext"
-)
-
-// ErrAURSearch means that it was not possible to connect to the AUR.
-type ErrAURSearch struct {
-	inner error
-}
-
-func (e ErrAURSearch) Error() string {
-	return gotext.Get("Error during AUR search: %s\n", e.inner.Error())
-}
-
-// ErrNoQuery means that query was not executed.
-type ErrNoQuery struct{}
-
-func (e ErrNoQuery) Error() string {
-	return gotext.Get("no query was executed")
-}