Update galaxy.yml

version bump

.github/workflows/galaxy.yml

@@ -0,0 +1,59 @@
+name: Build and Publish Collection to Ansible Galaxy
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+defaults:
+  run:
+    working-directory: collections/ansible_collections/kewlfft/aur
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v5
+        with:
+          path: collections/ansible_collections/kewlfft/aur
+
+      - name: Debug workflow version
+        run: echo "=== RUNNING UPDATED WORKFLOW ==="
+
+      - name: Verify version in galaxy.yml matches release tag
+        run: |
+          tag_version="${GITHUB_REF##*/}"   # e.g., v0.12.2
+          tag_version="${tag_version#v}"    # strip leading 'v' if present
+          file_version=$(awk '/^version:/ {print $2}' galaxy.yml)
+
+          if [ "${GITHUB_EVENT_NAME}" != "workflow_dispatch" ] && [ "$file_version" != "$tag_version" ]; then
+              echo "❌ galaxy.yml version ($file_version) does not match tag ($tag_version)"
+              exit 1
+          fi
+          echo "✅ Version check passed: $file_version"
+
+      - name: Build collection
+        run: |
+          path=$(ansible-galaxy collection build | awk '/Created collection/ {print $NF}')
+          echo "TARBALL=$path" >> $GITHUB_ENV
+          echo "📦 Built collection at $path"
+
+      - name: Upload built collection artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ansible-collection-tarball
+          path: ${{ env.TARBALL }}
+
+      - name: Debug tarball before publish
+        run: |
+          echo "🔎 Checking tarball path..."
+          echo "TARBALL=$TARBALL"
+          ls -l "$(dirname "$TARBALL")"
+
+      - name: Publish collection
+        if: github.event_name != 'workflow_dispatch'  # skip publish for manual testing
+        run: |
+          echo "📤 Publishing $TARBALL ..."
+          ansible-galaxy collection publish "$TARBALL" \
+            --api-key "${{ secrets.ANSIBLE_GALAXY_API_KEY }}"

.gitignore

@@ -0,0 +1,2 @@
+kewlfft-aur-*.tar.gz
+*.swp

README.md

@@ -1,111 +1,180 @@
-# Ansible AUR helper
-Ansible module to use some Arch User Repository (AUR) helpers as well as makepkg.
+# Ansible Collection - kewlfft.aur
 
+## Description
+
+This collection includes an Ansible module to manage packages from the AUR.
+
+## Installation
+
+### Install the `kewlfft.aur` collection from Ansible Galaxy
+
+To install this collection from Ansible Galaxy, run the following command:
+
+```shell
+ansible-galaxy collection install kewlfft.aur
+```
+
+Alternatively, you can include the collection in a `requirements.yml` file and then run `ansible-galaxy collection install -r requirements.yml`. Here is an example of `requirements.yml` file:
+
+```yaml
+collections:
+  - name: kewlfft.aur
+```
+
+### Install the `kewlfft.aur` collection from the AUR
+
+The `kewlfft.aur` collection is also available in the AUR as the [`ansible-collection-kewlfft-aur`](https://aur.archlinux.org/packages/ansible-collection-kewlfft-aur/) package.
+
+### Install the `kewlfft.aur` collection locally for development
+
+If you want to test changes to the source code, run the following commands from the root of this git repository to locally build and install the collection:
+
+```shell
+ansible-galaxy collection build --force
+ansible-galaxy collection install --force "./kewlfft-aur-$(cat galaxy.yml | grep version: | awk '{print $2}').tar.gz"
+```
+
+### Install the `aur` module as a local custom module
+
+Alternatively, you may manually install the `aur` module itself as a [local custom module](https://docs.ansible.com/ansible/latest/dev_guide/developing_locally.html) instead of installing the module through the `kewlfft.aur` Ansible collection. However, it is recommended to use `kewlfft.aur` collection unless you have a good reason not to. Here are the commands to install the `aur` module as a local custom module:
+
+```shell
+# Create the user custom module directory
+mkdir ~/.ansible/plugins/modules
+
+# Install the aur module into the user custom module directory
+curl -o ~/.ansible/plugins/modules/aur.py https://raw.githubusercontent.com/kewlfft/ansible-aur/master/plugins/modules/aur.py
+```
+
+## kewlfft.aur.aur Module
+
+Ansible module to use some Arch User Repository (AUR) helpers as well as makepkg.
 The following helpers are supported and automatically selected, if present, in the order listed below:
+
 - [yay](https://github.com/Jguer/yay)
+- [paru](https://github.com/Morganamilo/paru)
 - [pacaur](https://github.com/E5ten/pacaur)
 - [trizen](https://github.com/trizen/trizen)
 - [pikaur](https://github.com/actionless/pikaur)
 - [aurman](https://github.com/polygamma/aurman) (discontinued)
 
 *makepkg* will be used if no helper was found or if it is explicitly specified:
+
 - [makepkg](https://wiki.archlinux.org/index.php/makepkg)
 
-## Options
-|Parameter      |Choices/**Default**                                    |Comments|
-|---            |---                                                    |---|
-|name           |                                                       |Name or list of names of the package(s) to install or upgrade.|
-|state          |**present**, latest                                    |Desired state of the package, 'present' skips operations if the package is already installed.|
-|upgrade        |yes, **no**                                            |Whether or not to upgrade whole system.|
-|use            |**auto**, yay, pacaur, trizen, pikaur, aurman, makepkg |The tool to use, 'auto' uses the first known helper found and makepkg as a fallback.|
-|extra_args     |**null**                                               |A list of additional arguments to pass directly to the tool. Cannot be used in 'auto' mode.|
-|aur_only       |yes, **no**                                            |Limit helper operation to the AUR.|
-|skip_pgp_check |yes, **no**                                            |Only valid with makepkg. Skip PGP signatures verification of source file, useful when installing packages without GnuPG properly configured.|
-|ignore_arch    |yes, **no**                                            |Only valid with makepkg. Ignore a missing or incomplete arch field, useful when the PKGBUILD does not have the arch=('yourarch') field.|
+### Options
+
+| Parameter      | Choices/**Default**                                          | Comments                                                                                                                                     |
+| -------------- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| name           |                                                              | Name or list of names of the package(s) to install or upgrade.                                                                               |
+| state          | **present**, latest, absent                                          | Desired state of the package, 'present' skips operations if the package is already installed.                                                |
+| upgrade        | yes, **no**                                                  | Whether or not to upgrade whole system.                                                                                                      |
+| update_cache        | yes, **no**                                                  | Whether or not to refresh the packages cache |
+| use            | **auto**, yay, paru, pacaur, trizen, pikaur, aurman, makepkg | The tool to use, 'auto' uses the first known helper found and makepkg as a fallback.                                                         |
+| extra_args     | **null**                                                     | A list of additional arguments to pass directly to the tool. Cannot be used in 'auto' mode.                                                  |
+| aur_only       | yes, **no**                                                  | Limit helper operation to the AUR.                                                                                                           |
+| local_pkgbuild | Local directory with PKGBUILD, **null**                      | Only valid with makepkg or pikaur. Don't download the package from AUR. Build the package using a local PKGBUILD and the other build files.  |
+| skip_pgp_check | yes, **no**                                                  | Only valid with makepkg. Skip PGP signatures verification of source file, useful when installing packages without GnuPG properly configured. |
+| ignore_arch    | yes, **no**                                                  | Only valid with makepkg. Ignore a missing or incomplete arch field, useful when the PKGBUILD does not have the arch=('yourarch') field.      |
+
+#### Note
 
-### Note
 * Either *name* or *upgrade* is required, both cannot be used together.
 * In the *use*=*auto* mode, makepkg is used as a fallback if no known helper is found.
 
-## Installing
-### AUR package
-The [ansible-aur-git](https://aur.archlinux.org/packages/ansible-aur-git) package is available in the AUR.
-Note the module is installed in `/usr/share/ansible/plugins/modules` which is one of the default module library paths.
+### Usage
 
-### Manual installation
-Just clone the *ansible-aur* repository into your user custom-module directory:
-```
-git clone https://github.com/kewlfft/ansible-aur.git ~/.ansible/plugins/modules/aur
-```
+#### Notes
 
-### Ansible Galaxy
-*ansible-aur* is available in Galaxy which is a hub for sharing Ansible content. To download it, use:
-```
-ansible-galaxy install kewlfft.aur
-```
-
-Note that if this module is installed from Ansible Galaxy, you will need to list it explicitly in your playbook:
-```
-# playbook.yml
-- hosts: localhost
-  roles:
-  - kewlfft.aur
-  tasks:
-  - aur: name=package_name
-```
-
-or in your role:
-```
-# meta/main.yml
-dependencies:
-- kewlfft.aur
-```
-
-```
-# tasks/main.yml
-- aur: name=package_name
-```
-
-## Usage
-### Notes
 * The scope of this module is installation and update from the AUR; for package removal or for updates from the repositories, it is recommended to use the official *pacman* module.
 * The *--needed* parameter of the helper is systematically used, it means if a package is up-to-date, it is not built and reinstalled.
 
-### Create the "aur_builder" user
+#### Create the "aur_builder" user
+
 While Ansible expects to SSH as root, makepkg or AUR helpers do not allow executing operations as root, they fail with "you cannot perform this operation as root". It is therefore recommended to create a user, which is non-root but has no need for password with pacman in sudoers, let's call it *aur_builder*.
 
 This user can be created in an Ansible task with the following actions:
-```
-- user:
+
+```yaml
+- name: Create the `aur_builder` user
+  become: yes
+  ansible.builtin.user:
     name: aur_builder
+    create_home: yes
     group: wheel
-- lineinfile:
+
+- name: Allow the `aur_builder` user to run `sudo pacman` without a password
+  become: yes
+  ansible.builtin.lineinfile:
     path: /etc/sudoers.d/11-install-aur_builder
     line: 'aur_builder ALL=(ALL) NOPASSWD: /usr/bin/pacman'
     create: yes
+    mode: 0644
     validate: 'visudo -cf %s'
 ```
 
-### Examples
+#### Fully Qualified Collection Names (FQCNs)
+
+In order to use an Ansible module that is distributed in a collection, you must use its FQCN. This corresponds to "the full definition of a module, plugin, or role hosted within a collection, in the form `namespace.collection.content_name`" ([Source](https://github.com/ansible-collections/overview#terminology)). In this case, the `aur` module resides in the `aur` collection which is under the `kewlfft` namespace, so its FQCN is `kewlfft.aur.aur`.
+
+Please note that this does not apply if you installed the `aur` module as a local custom module. Due to the nature of local custom modules, you can simply use the module's short name: `aur`.
+
+#### Examples
+
 Use it in a task, as in the following examples:
-```
-# Install trizen using makepkg, skip if it is already installed
-- aur: name=trizen use=makepkg state=present
+
+```yaml
+# This task uses the module's short name instead of its FQCN (Fully Qualified Collection Name).
+# Use the short name if the module was installed as a local custom module.
+# Otherwise, if it was installed through the `kewlfft.aur` collection, this task will fail.
+- name: Install trizen using makepkg if it isn't installed already
+  aur:
+    name: trizen
+    use: makepkg
+    state: present
   become: yes
   become_user: aur_builder
 
-# Install package_name using the first known helper found
-- aur: name=package_name
+# This task uses the `aur` module's FQCN.
+- name: Install trizen using makepkg if it isn't installed already
+  kewlfft.aur.aur:
+    name: trizen
+    use: makepkg
+    state: present
   become: yes
   become_user: aur_builder
 
-# Install package_name_1 and package_name_2 using yay
-- aur:
+- name: Install package_name_1 and package_name_2 using yay
+  kewlfft.aur.aur:
     use: yay
     name:
       - package_name_1
       - package_name_2
 
-# Upgrade the system using yay, only act on AUR packages, note that dependency resolving will still include repository packages
-- aur: upgrade=yes use=yay aur_only=yes
-```
+# Note: Dependency resolution will still include repository packages.
+- name: Upgrade the system using yay, only act on AUR packages.
+  kewlfft.aur.aur:
+    upgrade: yes
+    use: yay
+    aur_only: yes
+
+# Skip if it is already installed
+- name: Install gnome-shell-extension-caffeine-git using pikaur and a local PKGBUILD.
+  kewlfft.aur.aur:
+    name: gnome-shell-extension-caffeine-git
+    use: pikaur
+    local_pkgbuild: {{ role_path }}/files/gnome-shell-extension-caffeine-git
+    state: present
+  become: yes
+  become_user: aur_builder
+
+# Remove AUR packages (state=absent)
+- name: Remove package_name_1 and package_name_2 using yay
+  kewlfft.aur.aur:
+    use: yay
+    state: absent
+    name:
+      - package_name_1
+      - package_name_2
+  become: yes
+  become_user: aur_builder

galaxy.yml

@@ -0,0 +1,70 @@
+### REQUIRED
+# The namespace of the collection. This can be a company/brand/organization or product namespace under which all
+# content lives. May only contain alphanumeric lowercase characters and underscores. Namespaces cannot start with
+# underscores or numbers and cannot contain consecutive underscores
+namespace: kewlfft
+
+# The name of the collection. Has the same character restrictions as 'namespace'
+name: aur
+
+# The version of the collection. Must be compatible with semantic versioning
+version: 0.13.0
+
+# The path to the Markdown (.md) readme file. This path is relative to the root of the collection
+readme: README.md
+
+# A list of the collection's content authors. Can be just the name or in the format 'Full Name <email> (url)
+# @nicks:irc/im.site#channel'
+authors:
+- kewl fft <kewl@alto.eu.org>
+
+
+### OPTIONAL but strongly recommended
+# A short summary description of the collection
+description: This collection includes an Ansible module to manage packages from the AUR.
+
+# Either a single license or a list of licenses for content inside of a collection. Ansible Galaxy currently only
+# accepts L(SPDX,https://spdx.org/licenses/) licenses. This key is mutually exclusive with 'license_file'
+license:
+- GPL-3.0-or-later
+
+# The path to the license file for the collection. This path is relative to the root of the collection. This key is
+# mutually exclusive with 'license'
+license_file: ''
+
+# A list of tags you want to associate with the collection for indexing/searching. A tag name has the same character
+# requirements as 'namespace' and 'name'
+tags:
+  - aur
+  - arch_user_repository
+  - arch
+  - archlinux
+  - arch_linux
+  - packaging
+  - software
+
+# Collections that this collection requires to be installed for it to be usable. The key of the dict is the
+# collection label 'namespace.name'. The value is a version range
+# L(specifiers,https://python-semanticversion.readthedocs.io/en/latest/#requirement-specification). Multiple version
+# range specifiers can be set and are separated by ','
+dependencies: {}
+
+# The URL of the originating SCM repository
+repository: https://github.com/kewlfft/ansible-aur
+
+# The URL to any online docs
+documentation: https://github.com/kewlfft/ansible-aur/blob/master/README.md
+
+# The URL to the homepage of the collection/project
+homepage: https://github.com/kewlfft/ansible-aur
+
+# The URL to the collection issue tracker
+issues: https://github.com/kewlfft/ansible-aur/issues
+
+# A list of file glob-like patterns used to filter any files or directories that should not be included in the build
+# artifact. A pattern is matched from the relative path of the file or directory of the collection directory. This
+# uses 'fnmatch' to match the files or directories. Some directories and files like 'galaxy.yml', '*.pyc', '*.retry',
+# and '.git' are always filtered
+build_ignore:
+  - .github
+  - .gitignore

library/aur.py

@@ -1,313 +0,0 @@
-#!/usr/bin/python
-
-# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
-
-from ansible.module_utils.basic import *
-from ansible.module_utils.urls import open_url
-import json
-import shlex
-import tarfile
-import os
-import os.path
-import tempfile
-import urllib.parse
-
-
-DOCUMENTATION = '''
----
-module: aur
-short_description: Manage packages from the AUR
-description:
-    - Manage packages from the Arch User Repository (AUR)
-author:
-    - Kewl <xrjy@nygb.rh.bet(rot13)>
-options:
-    name:
-        description:
-            - Name or list of names of the package(s) to install or upgrade.
-
-    state:
-        description:
-            - Desired state of the package.
-        default: present
-        choices: [ present, latest ]
-
-    upgrade:
-        description:
-            - Whether or not to upgrade whole system.
-        default: no
-        type: bool
-
-    use:
-        description:
-            - The tool to use, 'auto' uses the first known helper found and makepkg as a fallback.
-        default: auto
-        choices: [ auto, yay, pacaur, trizen, pikaur, aurman, makepkg ]
-
-    extra_args:
-        description:
-            - Arguments to pass to the tool.
-              Requires that the 'use' option be set to something other than 'auto'.
-        type: str
-
-    skip_pgp_check:
-        description:
-            - Only valid with makepkg.
-              Skip PGP signatures verification of source file.
-              This is useful when installing packages without GnuPG (properly) configured.
-              Cannot be used unless use is set to 'makepkg'.
-        type: bool
-        default: no
-
-    ignore_arch:
-        description:
-            - Only valid with makepkg.
-              Ignore a missing or incomplete arch field, useful when the PKGBUILD does not have the arch=('yourarch') field.
-              Cannot be used unless use is set to 'makepkg'.
-        type: bool
-        default: no
-
-    aur_only:
-        description:
-            - Limit helper operation to the AUR.
-        type: bool
-        default: no
-notes:
-  - When used with a `loop:` each package will be processed individually,
-    it is much more efficient to pass the list directly to the `name` option.
-'''
-
-RETURN = '''
-msg:
-    description: action that has been taken
-helper:
-    the helper that was actually used
-'''
-
-EXAMPLES = '''
-- name: Install trizen using makepkg, skip if trizen is already installed
-  aur: name=trizen use=makepkg state=present
-  become: yes
-  become_user: aur_builder
-'''
-
-def_lang = ['env', 'LC_ALL=C']
-
-use_cmd = {
-    'yay': ['yay', '-S', '--noconfirm', '--needed', '--cleanafter'],
-    'pacaur': ['pacaur', '-S', '--noconfirm', '--noedit', '--needed'],
-    'trizen': ['trizen', '-S', '--noconfirm', '--noedit', '--needed'],
-    'pikaur': ['pikaur', '-S', '--noconfirm', '--noedit', '--needed'],
-    'aurman': ['aurman', '-S', '--noconfirm', '--noedit', '--needed', '--skip_news', '--pgp_fetch', '--skip_new_locations'],
-    'makepkg': ['makepkg', '--syncdeps', '--install', '--noconfirm', '--needed']
-}
-
-has_aur_option = ['yay', 'pacaur', 'trizen', 'pikaur', 'aurman']
-
-
-def package_installed(module, package):
-    """
-    Determine if the package is already installed
-    """
-    rc, _, _ = module.run_command(['pacman', '-Q', package], check_rc=False)
-    return rc == 0
-
-
-def check_packages(module, packages):
-    """
-    Inform the user what would change if the module were run
-    """
-    would_be_changed = []
-    diff = {
-        'before': '',
-        'after': '',
-    }
-
-    for package in packages:
-        installed = package_installed(module, package)
-        if not installed:
-            would_be_changed.append(package)
-            if module._diff:
-                diff['after'] += package + "\n"
-
-    if would_be_changed:
-        status = True
-        if len(packages) > 1:
-            message = '{} package(s) would be installed'.format(len(would_be_changed))
-        else:
-            message = 'package would be installed'
-    else:
-        status = False
-        if len(packages) > 1:
-            message = 'all packages are already installed'
-        else:
-            message = 'package is already installed'
-    module.exit_json(changed=status, msg=message, diff=diff)
-
-
-def build_command_prefix(use, extra_args, skip_pgp_check=False, ignore_arch=False, aur_only=False):
-    """
-    Create the prefix of a command that can be used by the install and upgrade functions.
-    """
-    command = def_lang + use_cmd[use]
-    if skip_pgp_check:
-        command.append('--skippgpcheck')
-    if ignore_arch:
-        command.append('--ignorearch')
-    if aur_only and use in has_aur_option:
-        command.append('--aur')
-    if extra_args:
-        command += shlex.split(extra_args)
-    return command
-
-
-def install_with_makepkg(module, package, extra_args, skip_pgp_check, ignore_arch):
-    """
-    Install the specified package with makepkg
-    """
-    module.get_bin_path('fakeroot', required=True)
-    f = open_url('https://aur.archlinux.org/rpc/?v=5&type=info&arg={}'.format(urllib.parse.quote(package)))
-    result = json.loads(f.read().decode('utf8'))
-    if result['resultcount'] != 1:
-        return (1, '', 'package {} not found'.format(package))
-    result = result['results'][0]
-    f = open_url('https://aur.archlinux.org/{}'.format(result['URLPath']))
-    with tempfile.TemporaryDirectory() as tmpdir:
-        tar = tarfile.open(mode='r|*', fileobj=f)
-        tar.extractall(tmpdir)
-        tar.close()
-        command = build_command_prefix('makepkg', extra_args, skip_pgp_check=skip_pgp_check, ignore_arch=ignore_arch)
-        rc, out, err = module.run_command(command, cwd=os.path.join(tmpdir, result['Name']), check_rc=True)
-    return (rc, out, err)
-
-
-def upgrade(module, use, extra_args, aur_only):
-    """
-    Upgrade the whole system
-    """
-    assert use in use_cmd
-
-    command = build_command_prefix(use, extra_args, aur_only=aur_only)
-    command.append('-u')
-
-    rc, out, err = module.run_command(command, check_rc=True)
-
-    module.exit_json(
-        changed=not (out == '' or 'nothing to do' in out or 'No AUR updates found' in out),
-        msg='upgraded system',
-        helper=use,
-    )
-
-
-def install_packages(module, packages, use, extra_args, state, skip_pgp_check, ignore_arch, aur_only):
-    """
-    Install the specified packages
-    """
-    assert use in use_cmd
-
-    changed_iter = False
-
-    for package in packages:
-        if state == 'present':
-            if package_installed(module, package):
-                rc = 0
-                continue
-        if use == 'makepkg':
-            rc, out, err = install_with_makepkg(module, package, extra_args, skip_pgp_check, ignore_arch)
-        else:
-            command = build_command_prefix(use, extra_args, aur_only=aur_only)
-            command.append(package)
-            rc, out, err = module.run_command(command, check_rc=True)
-
-        changed_iter = changed_iter or not (out == '' or '-- skipping' in out or 'nothing to do' in out)
-
-    message = 'installed package(s)' if changed_iter else 'package(s) already installed'
-
-    module.exit_json(
-        changed=changed_iter,
-        msg=message if not rc else err,
-        helper=use,
-        rc=rc,
-    )
-
-
-def make_module():
-    module = AnsibleModule(
-        argument_spec={
-            'name': {
-                'type': 'list',
-            },
-            'state': {
-                'default': 'present',
-                'choices': ['present', 'latest'],
-            },
-            'upgrade': {
-                'type': 'bool',
-            },
-            'use': {
-                'default': 'auto',
-                'choices': ['auto'] + list(use_cmd.keys()),
-            },
-            'extra_args': {
-                'default': None,
-                'type': 'str',
-            },
-            'skip_pgp_check': {
-                'default': False,
-                'type': 'bool',
-            },
-            'ignore_arch': {
-                'default': False,
-                'type': 'bool',
-            },
-            'aur_only': {
-                'default': False,
-                'type': 'bool',
-            },
-        },
-        mutually_exclusive=[['name', 'upgrade']],
-        required_one_of=[['name', 'upgrade']],
-        supports_check_mode=True
-    )
-
-    params = module.params
-
-    use = params['use']
-
-    if use == 'auto':
-        if params['extra_args'] is not None:
-            module.fail_json(msg="'extra_args' cannot be used with 'auto', a tool must be specified.")
-        use = 'makepkg'
-        # auto: select the first helper for which the bin is found
-        for k in use_cmd:
-            if module.get_bin_path(k):
-                use = k
-                break
-
-    if use != 'makepkg' and (params['skip_pgp_check'] or params['ignore_arch']):
-        module.fail_json(msg="This option is only available with 'makepkg'.")
-
-    if params.get('upgrade', False) and use == 'makepkg':
-        module.fail_json(msg="The 'upgrade' action cannot be used with 'makepkg'.")
-
-    return module, use
-
-
-def apply_module(module, use):
-    params = module.params
-
-    if module.check_mode:
-        check_packages(module, params['name'])
-    elif params.get('upgrade', False):
-        upgrade(module, use, params['extra_args'], params['aur_only'])
-    else:
-        install_packages(module, params['name'], use, params['extra_args'], params['state'], params['skip_pgp_check'], params['ignore_arch'], params['aur_only'])
-
-
-def main():
-    module, use = make_module()
-    apply_module(module, use)
-
-
-if __name__ == '__main__':
-    main()

meta/main.yml

@@ -1,17 +0,0 @@
-galaxy_info:
-  author: kewlfft
-  role_name: aur
-  description: Ansible module to use some Arch User Repository (AUR) helpers as well as makepkg.
-  license: GPL-3.0-or-later
-  min_ansible_version: 2.0
-
-  # https://galaxy.ansible.com/api/v1/platforms/
-  platforms:
-  - name: ArchLinux
-    versions:
-    - any
-
-  galaxy_tags:
-  - aur
-
-dependencies: []

meta/runtime.yml

@@ -0,0 +1,2 @@
+---
+requires_ansible: '>=2.9.10'

plugins/modules/aur.py

@@ -0,0 +1,495 @@
+#!/usr/bin/python
+
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.urls import open_url
+import json
+import shlex
+import tarfile
+import os
+import os.path
+import shutil
+import tempfile
+import urllib.parse
+
+
+DOCUMENTATION = '''
+---
+module: aur
+short_description: Manage packages from the AUR
+description:
+    - Manage packages from the Arch User Repository (AUR)
+author:
+    - Kewl <xrjy@nygb.rh.bet(rot13)>
+options:
+    name:
+        description:
+            - Name or list of names of the package(s) to install or upgrade.
+
+    state:
+        description:
+            - Desired state of the package.
+        default: present
+        choices: [ present, latest, absent ]
+
+    upgrade:
+        description:
+            - Whether or not to upgrade whole system.
+        default: no
+        type: bool
+
+    update_cache:
+        description:
+            - Whether or not to update_cache the package cache.
+        default: no
+        type: bool
+
+    use:
+        description:
+            - The tool to use, 'auto' uses the first known helper found and makepkg as a fallback.
+        default: auto
+        choices: [ auto, yay, paru, pacaur, trizen, pikaur, aurman, makepkg ]
+
+    extra_args:
+        description:
+            - Arguments to pass to the tool.
+              Requires that the 'use' option be set to something other than 'auto'.
+        type: str
+
+    skip_pgp_check:
+        description:
+            - Only valid with makepkg.
+              Skip PGP signatures verification of source file.
+              This is useful when installing packages without GnuPG (properly) configured.
+              Cannot be used unless use is set to 'makepkg'.
+        type: bool
+        default: no
+
+    ignore_arch:
+        description:
+            - Only valid with makepkg.
+              Ignore a missing or incomplete arch field, useful when the PKGBUILD does not have the arch=('yourarch') field.
+              Cannot be used unless use is set to 'makepkg'.
+        type: bool
+        default: no
+
+    aur_only:
+        description:
+            - Limit helper operation to the AUR.
+        type: bool
+        default: no
+
+    local_pkgbuild:
+        description:
+            - Only valid with makepkg or pikaur.
+              Directory with PKGBUILD and build files.
+              Cannot be used unless use is set to 'makepkg' or 'pikaur'.
+        type: path
+        default: no
+notes:
+  - When used with a `loop:` each package will be processed individually,
+    it is much more efficient to pass the list directly to the `name` option.
+'''
+
+RETURN = '''
+msg:
+    description: action that has been taken
+helper:
+    description: the helper that was actually used
+installed:
+    description: list of packages that were newly installed
+    returned: always
+    type: list
+updated:
+    description: list of packages that were upgraded
+    returned: always
+    type: list
+'''
+
+EXAMPLES = '''
+- name: Install trizen using makepkg, skip if trizen is already installed
+  aur: name=trizen use=makepkg state=present
+  become: yes
+  become_user: aur_builder
+'''
+
+def_lang = ['env', 'LC_ALL=C', 'LANGUAGE=C']
+
+use_cmd = {
+    'yay': ['yay', '-S', '--noconfirm', '--needed', '--cleanafter'],
+    'paru': ['paru', '-S', '--noconfirm', '--needed', '--cleanafter'],
+    'pacaur': ['pacaur', '-S', '--noconfirm', '--noedit', '--needed'],
+    'trizen': ['trizen', '-S', '--noconfirm', '--noedit', '--needed'],
+    'pikaur': ['pikaur', '-S', '--noconfirm', '--noedit', '--needed'],
+    'aurman': ['aurman', '-S', '--noconfirm', '--noedit', '--needed', '--skip_news', '--pgp_fetch', '--skip_new_locations'],
+    'makepkg': ['makepkg', '--syncdeps', '--install', '--noconfirm', '--needed']
+}
+
+use_cmd_local_pkgbuild = {
+    'pikaur': ['pikaur', '-P', '--noconfirm', '--noedit', '--needed', '--install'],
+    'makepkg': ['makepkg', '--syncdeps', '--install', '--noconfirm', '--needed']
+}
+
+use_remove_cmd = {
+    'yay': ['yay', '-R', '--noconfirm'],
+    'paru': ['paru', '-R', '--noconfirm'],
+    'pacaur': ['pacaur', '-R', '--noconfirm'],
+    'trizen': ['trizen', '-R', '--noconfirm'],
+    'pikaur': ['pikaur', '-R', '--noconfirm'],
+    'aurman': ['aurman', '-R', '--noconfirm'],
+}
+
+has_aur_option = ['yay', 'paru', 'pacaur', 'trizen', 'pikaur', 'aurman']
+
+
+def package_installed(module, package):
+    """
+    Determine if the package is already installed
+    """
+    rc, _, _ = module.run_command(['pacman', '-Q', package], check_rc=False)
+    return rc == 0
+
+
+def check_packages(module, packages):
+    """
+    Inform the user what would change if the module were run
+    """
+    would_be_changed = [package for package in packages if not package_installed(module, package)]
+    diff = {'before': '', 'after': '\n'.join(package for package in would_be_changed if module._diff)}
+
+    if would_be_changed:
+        status = True
+        if len(packages) > 1:
+            message = '{} package(s) would be installed'.format(len(would_be_changed))
+        else:
+            message = 'package would be installed'
+    else:
+        status = False
+        if len(packages) > 1:
+            message = 'all packages are already installed'
+        else:
+            message = 'package is already installed'
+    module.exit_json(changed=status, msg=message, diff=diff)
+
+
+def check_packages_absent(module, packages):
+    """
+    Inform the user what would change if the module were run with state=absent
+    """
+    would_be_changed = [package for package in packages if package_installed(module, package)]
+    diff = {'before': '\n'.join(pkg for pkg in would_be_changed if module._diff), 'after': ''}
+
+    if would_be_changed:
+        status = True
+        if len(packages) > 1:
+            message = '{} package(s) would be removed'.format(len(would_be_changed))
+        else:
+            message = 'package would be removed'
+    else:
+        status = False
+        if len(packages) > 1:
+            message = 'all packages are already absent'
+        else:
+            message = 'package is already absent'
+    module.exit_json(changed=status, msg=message, diff=diff)
+
+
+def build_command_prefix(use, extra_args, skip_pgp_check=False, ignore_arch=False, aur_only=False, local_pkgbuild=None, update_cache=False):
+    """
+    Create the prefix of a command that can be used by the install and upgrade functions.
+    """
+    if local_pkgbuild:
+        command = def_lang + use_cmd_local_pkgbuild[use]
+    else:
+        command = def_lang + use_cmd[use]
+    if skip_pgp_check:
+        command.append('--skippgpcheck')
+    if ignore_arch:
+        command.append('--ignorearch')
+    if aur_only and use in has_aur_option:
+        command.append('--aur')
+    if local_pkgbuild and use != 'makepkg':
+        command.append(local_pkgbuild)
+    if update_cache:
+        command.append('-y')
+    if extra_args:
+        command += shlex.split(extra_args)
+    return command
+
+
+def install_with_makepkg(module, package, extra_args, skip_pgp_check, ignore_arch, local_pkgbuild=None):
+    """
+    Install the specified package or a local PKGBUILD with makepkg
+    """
+    if not local_pkgbuild:
+        module.get_bin_path('fakeroot', required=True)
+        f = open_url('https://aur.archlinux.org/rpc/?v=5&type=info&arg={}'.format(urllib.parse.quote(package)))
+        result = json.loads(f.read().decode('utf8'))
+        if result['resultcount'] != 1:
+            return (1, '', 'package {} not found'.format(package))
+        result = result['results'][0]
+        f = open_url('https://aur.archlinux.org/{}'.format(result['URLPath']))
+    with tempfile.TemporaryDirectory() as tmpdir:
+        if local_pkgbuild:
+            shutil.copytree(local_pkgbuild, tmpdir, dirs_exist_ok=True)
+            command = build_command_prefix('makepkg', extra_args)
+            rc, out, err = module.run_command(command, cwd=tmpdir, check_rc=True)
+        else:
+            tar = tarfile.open(mode='r|*', fileobj=f)
+            tar.extractall(tmpdir)
+            tar.close()
+            command = build_command_prefix('makepkg', extra_args, skip_pgp_check=skip_pgp_check, ignore_arch=ignore_arch)
+            rc, out, err = module.run_command(command, cwd=os.path.join(tmpdir, result['Name']), check_rc=True)
+    return (rc, out, err)
+
+
+def install_local_package(module, package, use, extra_args, local_pkgbuild):
+    """
+    Install the specified package with a local PKGBUILD
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        shutil.copytree(local_pkgbuild, tmpdir, dirs_exist_ok=True)
+        command = build_command_prefix(use, extra_args, local_pkgbuild=tmpdir + '/PKGBUILD')
+        rc, out, err = module.run_command(command, check_rc=True)
+    return (rc, out, err)
+
+
+def check_upgrade(module, use):
+    """
+    Inform user how many packages would be upgraded
+    """
+    rc, stdout, stderr = module.run_command([use, '-Qu'], check_rc=True)
+    num_packages = sum(1 for line in stdout.splitlines() if line.strip())
+    module.exit_json(
+        changed=num_packages > 0,
+        msg=f"{num_packages} package(s) would be upgraded",
+        helper=use,
+    )
+
+
+def upgrade(module, use, extra_args, aur_only, update_cache):
+    """
+    Upgrade the whole system
+    """
+    assert use in use_cmd
+
+    command = build_command_prefix(use, extra_args, aur_only=aur_only, update_cache=update_cache)
+    command.append('-u')
+
+    rc, out, err = module.run_command(command, check_rc=True)
+
+    module.exit_json(
+        changed=not (out == '' or 'nothing to do' in out.lower() or 'No AUR updates found' in out),
+        msg='upgraded system',
+        helper=use,
+    )
+
+
+def install_packages(module, packages, use, extra_args, state, skip_pgp_check, ignore_arch, aur_only, local_pkgbuild, update_cache):
+    """
+    Install the specified packages
+    """
+    if local_pkgbuild:
+        assert use in use_cmd_local_pkgbuild
+    else:
+        assert use in use_cmd
+
+    installed_pkgs = []
+    updated_pkgs = []
+
+    for package in packages:
+        was_installed = package_installed(module, package)
+        if state == 'present' and was_installed:
+            rc = 0
+            continue
+        if use == 'makepkg':
+            rc, out, err = install_with_makepkg(module, package, extra_args, skip_pgp_check, ignore_arch, local_pkgbuild)
+        elif local_pkgbuild:
+            rc, out, err = install_local_package(module, package, use, extra_args, local_pkgbuild)
+        else:
+            command = build_command_prefix(use, extra_args, aur_only=aur_only, update_cache=update_cache)
+            command.append(package)
+            rc, out, err = module.run_command(command, check_rc=True)
+
+        changed_pkg = not (out == '' or 'up-to-date -- skipping' in out or 'nothing to do' in out.lower())
+        if changed_pkg:
+            if was_installed:
+                updated_pkgs.append(package)
+            else:
+                installed_pkgs.append(package)
+
+    changed_iter = bool(installed_pkgs or updated_pkgs)
+
+    message = 'installed package(s)' if changed_iter else 'package(s) already installed'
+
+    module.exit_json(
+        changed=changed_iter,
+        msg=message if not rc else err,
+        helper=use,
+        rc=rc,
+        installed=installed_pkgs,
+        updated=updated_pkgs,
+    )
+
+
+def remove_packages(module, packages, use, extra_args):
+    """
+    Remove the specified packages
+    """
+    # Determine the base command. If a helper other than makepkg is selected, use it.
+    # If use is 'makepkg' (which has no remove capability), fallback to pacman directly.
+    def base_remove_cmd(selected_use):
+        if selected_use == 'makepkg':
+            return def_lang + ['pacman', '-R', '--noconfirm'], 'pacman'
+        else:
+            assert selected_use in use_remove_cmd
+            return def_lang + use_remove_cmd[selected_use], selected_use
+
+    changed_iter = False
+    rc = 0
+    used_helper = use
+
+    for package in packages:
+        if not package_installed(module, package):
+            continue
+        command, helper = base_remove_cmd(use)
+        used_helper = helper
+        if extra_args:
+            command += shlex.split(extra_args)
+        command.append(package)
+        rc, out, err = module.run_command(command, check_rc=True)
+        changed_iter |= (rc == 0)
+
+    message = 'removed package(s)' if changed_iter else 'package(s) already absent'
+
+    module.exit_json(
+        changed=changed_iter,
+        msg=message if not rc else err,
+        helper=used_helper,
+        rc=rc,
+    )
+
+
+def make_module():
+    module = AnsibleModule(
+        argument_spec={
+            'name': {
+                'type': 'list',
+            },
+            'state': {
+                'default': 'present',
+                'choices': ['present', 'latest', 'absent'],
+            },
+            'upgrade': {
+                'type': 'bool',
+            },
+            'update_cache': {
+                'default': False,
+                'type': 'bool',
+            },
+            'use': {
+                'default': 'auto',
+                'choices': ['auto'] + list(use_cmd.keys()),
+            },
+            'extra_args': {
+                'default': None,
+                'type': 'str',
+            },
+            'skip_pgp_check': {
+                'default': False,
+                'type': 'bool',
+            },
+            'ignore_arch': {
+                'default': False,
+                'type': 'bool',
+            },
+            'aur_only': {
+                'default': False,
+                'type': 'bool',
+            },
+            'local_pkgbuild': {
+                'default': None,
+                'type': 'path',
+            },
+        },
+        mutually_exclusive=[['name', 'upgrade']],
+        required_one_of=[['name', 'upgrade']],
+        supports_check_mode=True
+    )
+
+    params = module.params
+
+    use = params['use']
+
+    if params['name'] == []:
+        module.fail_json(msg="'name' cannot be empty.")
+
+    if use == 'auto':
+        if params['extra_args'] is not None:
+            module.fail_json(msg="'extra_args' cannot be used with 'auto', a tool must be specified.")
+        use = 'makepkg'
+        # auto: select the first helper for which the bin is found
+        for k in use_cmd:
+            if module.get_bin_path(k):
+                use = k
+                break
+
+    if use != 'makepkg' and (params['skip_pgp_check'] or params['ignore_arch']):
+        module.fail_json(msg="This option is only available with 'makepkg'.")
+
+    if not (use in use_cmd_local_pkgbuild) and params['local_pkgbuild']:
+        module.fail_json(msg="This option is not available with '%s'" % use)
+
+    if params['local_pkgbuild'] and not os.path.isdir(params['local_pkgbuild']):
+        module.fail_json(msg="Directory %s not found" % (params['local_pkgbuild']))
+
+    if params['local_pkgbuild'] and not os.access(params['local_pkgbuild'] + '/PKGBUILD', os.R_OK):
+        module.fail_json(msg="PKGBUILD inside %s not readable" % (params['local_pkgbuild']))
+
+    if params.get('upgrade', False) and use == 'makepkg':
+        module.fail_json(msg="The 'upgrade' action cannot be used with 'makepkg'.")
+
+    return module, use
+
+
+def apply_module(module, use):
+    params = module.params
+
+    if params.get('upgrade', False):
+        if module.check_mode:
+            check_upgrade(module, use)
+        else:
+            upgrade(module, use, params['extra_args'], params['aur_only'], params['update_cache'])
+    else:
+        if module.check_mode:
+            if params['state'] == 'absent':
+                check_packages_absent(module, params['name'])
+            else:
+                check_packages(module, params['name'])
+        else:
+            if params['state'] == 'absent':
+                remove_packages(module,
+                                params['name'],
+                                use,
+                                params['extra_args'])
+            else:
+                install_packages(module,
+                                 params['name'],
+                                 use,
+                                 params['extra_args'],
+                                 params['state'],
+                                 params['skip_pgp_check'],
+                                 params['ignore_arch'],
+                                 params['aur_only'],
+                                 params['local_pkgbuild'],
+                                 params['update_cache'])
+
+
+def main():
+    module, use = make_module()
+    apply_module(module, use)
+
+
+if __name__ == '__main__':
+    main()