Merge pull request #46 from ckotte/pkgbuild

Add pkgbuild option to build local package

README.md

@@ -1,34 +1,38 @@
 # Ansible AUR helper
 Ansible module to use some Arch User Repository (AUR) helpers as well as makepkg.
 
-The following helpers are supported and automatically selected in the order they are listed:
+The following helpers are supported and automatically selected, if present, in the order listed below:
-- [aurman](https://github.com/polygamma/aurman)
 - [yay](https://github.com/Jguer/yay)
-- [pacaur](https://github.com/rmarquis/pacaur)
+- [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's specified explicitly.
+*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      |required |default |choices                                            |comments|
+|Parameter      |Choices/**Default**                                    |Comments|
-|---            |---      |---     |---                                                |---|
+|---            |---                                                    |---|
-|name           |no       |        |                                                   |Name or list of names of the package(s) to install or upgrade.|
+|name           |                                                       |Name or list of names of the package(s) to install or upgrade.|
-|upgrade        |no       |no      |yes, no                                            |Whether or not to upgrade whole system.|
+|state          |**present**, latest                                    |Desired state of the package, 'present' skips operations if the package is already installed.|
-|use            |no       |auto    |auto, aurman, yay, pacaur, trizen, pikaur, makepkg |The helper to use, 'auto' uses the first known helper found and makepkg as a fallback.|
+|upgrade        |yes, **no**                                            |Whether or not to upgrade whole system.|
-|skip_installed |no       |no      |yes, no                                            |Skip operations if the package is present.|
+|use            |**auto**, yay, pacaur, trizen, pikaur, aurman, makepkg |The tool to use, 'auto' uses the first known helper found and makepkg as a fallback.|
-|skip_pgp_check |no       |no      |yes, no                                            |Skip verification of PGP signatures. This is useful when installing packages on a host without GnuPG (properly) configured. Only valid with makepkg.|
+|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
 * Either *name* or *upgrade* is required, both cannot be used together.
-* *skip_installed* cannot be used with *upgrade*.
 * In the *use*=*auto* mode, makepkg is used as a fallback if no known helper is found.
 
 ## Installing
 ### AUR package
-The [aur-ansible-git](https://aur.archlinux.org/packages/ansible-aur-git) package is available in the AUR.
+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.
+
+Note: The module is installed in `/usr/share/ansible/plugins/modules` which is one of the default module library paths.
 
 ### Manual installation
 Just clone the *ansible-aur* repository into your user custom-module directory:
@@ -36,39 +40,43 @@ 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
 ```
 
-## Usage
+### Ansible Galaxy
-### Note
+*ansible-aur* is available in Galaxy which is a hub for sharing Ansible content. To download it, use:
-* This module aims to cover the AUR, for package removal or system upgrade with the repositories, it is recommended to use the official *pacman* module,
+```
-* A package is reinstalled only if an update is available, using the *--needed* parameter, except for *yay* which does not support it and systematically reinstalls.
+ansible-galaxy install kewlfft.aur
-
-### Examples
-Use it in a task, as in the following examples:
 ```
-# Install trizen using makepkg, skip if trizen is already installed
-- aur: name=trizen use=makepkg skip_installed=true
-  become: yes
-  become_user: aur_builder
 
-# Install package_name using the first known helper found
+Note: 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
-  ...
-
-# Install package_name_1 and package_name_2 using trizen
-- aur:
-    use: trizen
-    name:
-      - package_name_1
-      - package_name_2
-  ...
-
-# Upgrade - using pacaur
-- aur: upgrade=yes use=pacaur
-  ...
 ```
 
+## 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
-While Ansible expects to SSH as root, AUR helpers do not allow executing operations as root, they all fail with "you cannot perform this operation as root". It is therefore recommended to create a user, that we will call for example *aur_builder*, that has no need for password with pacman in sudoers.
+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 can be done in Ansible with the following actions:
+
+This user can be created in an Ansible task with the following actions:
 ```
 - user:
     name: aur_builder
@@ -79,3 +87,38 @@ This can be done in Ansible with the following actions:
     create: yes
     validate: 'visudo -cf %s'
 ```
+
+### 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
+  become: yes
+  become_user: aur_builder
+
+# Install package_name using the first known helper found
+- aur: name=package_name
+  become: yes
+  become_user: aur_builder
+
+# Install package_name_1 and package_name_2 using yay
+- aur:
+    use: yay
+    name:
+      - package_name_1
+      - package_name_2
+
+# Upgrade the system using yay, only act on AUR packages.
+# Note: Dependency resolving will still include repository packages.
+- aur: upgrade=yes use=yay aur_only=yes
+
+# Install gnome-shell-extension-caffeine-git using pikaur and a local PKGBUILD.
+# Skip if it is already installed
+- 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
+```

aur.py

@@ -1,246 +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 tarfile
-import os
-import os.path
-import tempfile
-
-
-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.
-
-    upgrade:
-        description:
-            - Whether or not to upgrade whole system.
-        type: bool
-        default: no
-
-    use:
-        description:
-            - The helper to use, 'auto' uses the first known helper found and makepkg as a fallback.
-        default: auto
-        choices: [ auto, aurman, pacaur, trizen, pikaur, yay, makepkg ]
-
-    skip_installed:
-        description:
-            - Skip operations if the package is present.
-        type: bool
-        default: no
-
-    skip_pgp_check:
-        description:
-            - Skip verification of PGP signatures.
-              This is useful when installing packages on a host without GnuPG (properly) configured.
-              Only valid with makepkg.
-        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 skip_installed=true
-  become: yes
-  become_user: aur_builder
-'''
-
-
-def_lang = ['env', 'LC_ALL=C']
-
-use_cmd = {
-    'aurman': ['aurman', '-S', '--noconfirm', '--noedit', '--needed'],
-    'yay': ['yay', '-S', '--noconfirm', '--needed'],
-    'pacaur': ['pacaur', '-S', '--noconfirm', '--noedit', '--needed'],
-    'trizen': ['trizen', '-S', '--noconfirm', '--noedit', '--needed'],
-    'pikaur': ['pikaur', '-S', '--noconfirm', '--noedit', '--needed'],
-    'makepkg': ['makepkg', '--syncdeps', '--install', '--noconfirm', '--needed']
-}
-# optional: aurman, pacaur, trizen have a --aur option, do things only for aur
-
-
-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 = []
-
-    for package in packages:
-        installed = package_installed(module, package)
-        if not installed:
-            would_be_changed.append(package)
-
-    if would_be_changed:
-        status = True
-        if (len(packages) > 1):
-            message = '%s package(s) would be installed' % str(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)
-
-
-def install_with_makepkg(module, package):
-    """
-    Install the specified package with makepkg
-    """
-    f = open_url('https://aur.archlinux.org/rpc/?v=5&type=info&arg={}'.format(package))
-    result = json.loads(f.read().decode('utf8'))
-    if result['resultcount'] != 1:
-        return (1, '', 'package not found')
-    result = result['results'][0]
-    f = open_url('https://aur.archlinux.org/{}'.format(result['URLPath']))
-    current_path = os.getcwd()
-    with tempfile.TemporaryDirectory() as tmpdir:
-        os.chdir(tmpdir)
-        tar_file = '{}.tar.gz'.format(result['Name'])
-        with open(tar_file, 'wb') as out:
-            out.write(f.read())
-        tar = tarfile.open(tar_file)
-        tar.extractall()
-        tar.close()
-        os.chdir(format(result['Name']))
-        if module.params['skip_pgp_check']:
-            use_cmd['makepkg'].append('--skippgpcheck')
-        rc, out, err = module.run_command(use_cmd['makepkg'], check_rc=True)
-        os.chdir(current_path)
-    return (rc, out, err)
-
-
-def upgrade(module, use):
-    """
-    Upgrade the whole system
-    """
-    assert use in use_cmd
-
-    rc, out, err = module.run_command(def_lang + use_cmd[use] + ['-u'], 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, skip_installed):
-    """
-    Install the specified packages
-    """
-    assert use in use_cmd
-
-    changed_iter = False
-
-    for package in packages:
-        if skip_installed:
-            if package_installed(module, package):
-                rc = 0
-                continue
-        if use == 'makepkg':
-            rc, out, err = install_with_makepkg(module, package)
-        else:
-            rc, out, err = module.run_command(def_lang + use_cmd[use] + [package], check_rc=True)
-
-        changed_iter = changed_iter or not (out == '' or '-- skipping' in out or 'nothing to do' in out)
-
-    if changed_iter:
-        message = 'installed package(s)'
-    else:
-        message = 'package(s) already installed'
-
-    module.exit_json(
-        changed=changed_iter,
-        msg=message if not rc else err,
-        helper=use,
-        rc=rc,
-    )
-
-
-def main():
-    module = AnsibleModule(
-        argument_spec={
-            'name': {
-                'type': 'list',
-            },
-            'upgrade': {
-                'default': False,
-                'type': 'bool',
-            },
-            'use': {
-                'default': 'auto',
-                'choices': ['auto', 'aurman', 'pacaur', 'trizen', 'pikaur', 'yaourt', 'yay', 'makepkg'],
-            },
-            'skip_installed': {
-                'default': False,
-                'type': 'bool',
-            },
-            'skip_pgp_check': {
-                'default': False,
-                'type': 'bool',
-            },
-        },
-        required_one_of=[['name', 'upgrade']],
-        supports_check_mode=True
-    )
-
-    params = module.params
-
-    if module.check_mode:
-        check_packages(module, params['name'])
-
-    if params['use'] == 'auto':
-        use = 'makepkg'
-        # auto: select the first helper for which the bin is found
-        for k in use_cmd:
-            if module.get_bin_path(k, False):
-                use = k
-                break
-    else:
-        use = params['use']
-
-    if params['upgrade'] and (params['name'] or params['skip_installed'] or use == 'makepkg'):
-        module.fail_json(msg="Upgrade cannot be used with this option.")
-    else:
-        if params['upgrade']:
-            upgrade(module, use)
-        else:
-            install_packages(module, params['name'], use, params['skip_installed'])
-
-
-if __name__ == '__main__':
-    main()

library/aur.py

@@ -0,0 +1,393 @@
+#!/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 ]
+
+    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
+
+    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:
+    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']
+}
+
+use_cmd_local_pkgbuild = {
+    'pikaur': ['pikaur', '-P', '--noconfirm', '--noedit', '--needed', '--install'],
+    '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, local_pkgbuild=None):
+    """
+    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 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)
+    data = stdout.split('\n')
+    data.remove('')
+    module.exit_json(
+        changed=len(data) > 0,
+        msg="{} package(s) would be upgraded".format(len(data)),
+        helper=use,
+    )
+
+
+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, local_pkgbuild):
+    """
+    Install the specified packages
+    """
+    if local_pkgbuild:
+        assert use in use_cmd_local_pkgbuild
+    else:
+        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, 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)
+            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',
+            },
+            '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 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'])
+    else:
+        if module.check_mode:
+            check_packages(module, params['name'])
+        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'])
+
+
+def main():
+    module, use = make_module()
+    apply_module(module, use)
+
+
+if __name__ == '__main__':
+    main()

meta/main.yml

@@ -0,0 +1,17 @@
+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: []