ansible_role_package/tasks/main.yml

# vim: set filetype=yaml.ansible :
---
- name: Set installation facts
  ansible.builtin.set_fact:
    paths: "{% if use_local %}{{ localpaths }}{% else %}{{ syspaths }}{% endif %}"
    appimages: [] # appimages to install
    cargopkgs: [] # rust packages from cargo
    cargoversioned: [] # versioned rust packages from cargo
    caskpkgs: [] # homebrew casks
    flatpkgs: [] # flatpaks
    gopkgs: [] # go applications
    npmpkgs: [] # npm commands
    pipxpkgs: [] # pipx packages
    srcpkgs: [] # packages built from source
    syspkgs: [] # system package manager packages
    tappkgs: [] # homebrew tap packages
    brewtaps: [] # homebrew taps
    fpremotes: # flatpak remotes
      - name: flathub
        url: https://dl.flathub.org/repo/flathub.flatpakrepo

- name: Determine OS and set facts for it
  block:
    - name: Set macOS facts
      when: ansible_os_family == 'Darwin'
      ansible.builtin.set_fact:
        syspkg_become: false

    - name: Set Linux facts
      when: ansible_system == 'Linux'
      ansible.builtin.set_fact:
        syspkg_become: true

- name: Generate package installation lists
  ansible.builtin.include_tasks:
    file: addpkg.yml
  loop: "{{ packages | unique }}"
  loop_control:
    loop_var: pkg

- name: Install syspkgs list
  become: "{{ syspkg_become }}"
  ansible.builtin.package:
    name: "{{ syspkgs | unique }}"
    state: present

- name: Redhat based OS
  when: ansible_os_family == 'RedHat'
  block:
    - name: Install dnf packages
      become: true
      when:
        - syspkgs|length > 0
      ansible.builtin.dnf:
        name: "{{ syspkgs | unique }}"
        state: present

- name: Debian based OS
  when: ansible_os_family == 'Debian'
  block:
    - name: Install apt packages
      ansible.builtin.apt:
        name: "{{ syspkgs | unique }}"
        state: "{{ install_state }}"
      become: true
      when:
        - syspkgs|length > 0

- name: Darwin/macOS based OS
  when: ansible_os_family == 'Darwin'
  block:
    - name: Upgrade homebrew packages
      community.general.homebrew:
        name: "*"
        state: latest
      when: full_upgrade

    - name: Tap homebrew taps
      community.general.homebrew_tap:
        name: "{{ brewtaps | unique }}"
        state: present
      when: brewtaps|length > 0

    - name: Install homebrew packages
      community.general.homebrew:
        name: "{{ syspkgs | unique }}"
        state: "{{ install_state }}"
      when: syspkgs|length > 0

    - name: Install homebrew casks
      community.general.homebrew_cask:
        name: "{{ caskpkgs | unique }}"
        state: "{{ install_state }}"
      when: caskpkgs|length > 0

    - name: Workaround to install homebrew taps
      ansible.builtin.command:
        cmd: "brew install {{ tappkg }}"
      loop: "{{ tappkgs | unique }}"
      loop_control:
        loop_var: tappkg
      # TODO: fix the need to have this workaround

- name: Install flatpaks on Linux Systems
  when:
    - ansible_system == 'Linux'
    - flatpkgs|length > 0
  block:
    - name: Add flatpak repos
      become: true
      loop: "{{ fpremotes | unique }}"
      loop_control:
        loop_var: remote
      when:
        - fpremotes|length > 0
        - flatpkgs|length > 0
      community.general.flatpak_remote:
        enabled: true
        method: system
        state: present
        flatpakrepo_url: "{{ remote.url }}"
        name: "{{ remote.name }}"

    - name: Install flatpaks
      become: true
      loop: "{{ flatpkgs | unique }}"
      loop_control:
        loop_var: flatpkg
      when:
        - flatpkgs|length > 0
      community.general.flatpak:
        state: latest
        method: system
        name: "{{ flatpkg.name }}"
        remote: "{{ flatpkg.remote | default('flathub') }}"

- name: Ensure /usr/local/bin exists
  ansible.builtin.file:
    state: directory
    path: /usr/local/bin
    owner: root
    mode: '0755'
  become: true

- name: Install srcpkgs
  ansible.builtin.include_tasks:
    file: "src/{{ srcpkg }}.yml"
  loop: "{{ srcpkgs | unique }}"
  loop_control:
    loop_var: srcpkg
  when: srcpkgs|length > 0

- name: Install cargo packages at specific version
  community.general.cargo:
    name: "{{ cargopkg.name }}"
    version: "{{ cargopkg.version }}"
    path: "{{ cargopkg.path | default(default_install_prefix) }}"
    locked: "{{ cargopkg.locked | default(false) }}"
  become: true
  when: cargoversioned|length > 0
  loop: "{{ cargoversioned | unique }}"
  loop_control:
    loop_var: cargopkg

- name: Install cargo packages at latest version
  community.general.cargo:
    name: "{{ cargopkg }}"
    state: latest
    locked: "{{ cargopkg.locked | default(false) }}"
  when: cargopkgs|length > 0
  loop: "{{ cargopkgs | unique }}"
  loop_control:
    loop_var: cargopkg

- name: Install local go packages
  loop: "{{ gopkgs | unique }}"
  loop_control:
    loop_var: gopkg
  when: gopkgs|length > 0
  environment:
    GOROOT: /usr/local/go
    PATH: /usr/local/go/bin:$PATH
  ansible.builtin.command:
    cmd: "go install {{ gopkg }}"
  #TODO: figure out how to check if the gopkg is already installed

- name: Install local npm packages
  loop: "{{ npmpkgs | unique }}"
  loop_control:
    loop_var: npmpkg
  when: npmpkgs|length > 0
  community.general.npm:
    global: true
    name: "{{ npmpkg }}"
    state: latest

- name: Install python pipx packages for user
  loop: "{{ pipxpkgs | unique }}"
  loop_control:
    loop_var: pipxpkg
  when: pipxpkgs|length > 0
  community.general.pipx:
    executable: "{% if ansible_os_family == 'Darwin' %}/opt/homebrew/bin/pipx{% else %}/usr/bin/pipx{% endif %}"
    name: "{{ pipxpkg }}"
    state: latest