Taskfile.yaml

---
version: 3
vars:
  PROJECT_NAME:
    sh: echo ${PWD##*/}
  BRANCH:
    sh: if [ $(git rev-parse --abbrev-ref HEAD) != "main" ]; then echo $(git rev-parse --abbrev-ref HEAD); else echo main ; fi

tasks:
  do:
    desc: Select a task to run
    cmds:
      - |
        task=$(yq e '.tasks | keys' Taskfile.yaml | sed 's/^- //' | gum choose)
        task ${task}

  switch-remote:
    desc: Switch to remote branch
    cmds:
      - |
        git fetch
        branches=($(git branch -r | grep -v 'origin/HEAD' | sed 's|origin/||'))
        branch=$(printf "%s\n" "${branches[@]}" | gum choose)
        git switch -c ${branch} --track origin/${branch}
        git branch && git status

  switch-local:
    desc: Switch to local branch
    cmds:
      - |
        branches=$(git branch -a | grep -v 'remotes')
        branch=$(printf "%s\n" "${branches[@]}" | gum choose)
        git checkout ${branch} && git pull

  test:
    desc: Select test to run
    cmds:
      - |
        totest=$(gum choose "ansible" "go" "helm" "crossplane")
        echo "Selected: ${totest}"
        task test-${totest}

  release:
    desc: push new version
    cmds:
      - task: test-go
      #- task: test-helm
      - task: test-ansible
      - task: test-docker
      - task: pr
      - npx semantic-release --dry-run
      - npx semantic-release --debug --no-ci
      - echo released version $(git describe --tags --abbrev=0)

  check:
    desc: "Run pre-commit hooks"
    cmds:
      - pre-commit run -a

  create:
    desc: Create new dagger module
    cmds:
      - dagger init --sdk={{ .SDK }} --source=./{{ .MODULE_NAME }} --name={{ .MODULE_NAME }}
      - jq '.source = "."' dagger.json > tmp.json && mv tmp.json dagger.json
      - mv dagger.json ./{{ .MODULE_NAME }}/dagger.json
    vars:
      MODULE_NAME:
        sh: gum input --placeholder "Module name"
      SDK:
        sh: gum choose "go" "python"

  test-ansible:
    desc: Test ansible modules
    cmds:
      - dagger call -m ./{{ .MODULE }} run-collection-build-pipeline --src {{ .TEST_ANSIBLE_CODE }} --progress plain export --path={{ .OUTPUT_COLLECTION_FOLDER }}
      - ls -lta {{ .OUTPUT_COLLECTION_FOLDER }}
    vars:
      TEST_ANSIBLE_CODE: tests/ansible/collection # tests/ansible/collection #tests
      MODULE: ansible
      OUTPUT_COLLECTION_FOLDER: /tmp/dagger/ansible

  test-crossplane:
    desc: Test crossplame modules
    cmds:
      - dagger call -m ./{{ .MODULE }} init-package --name test --progress plain export --path={{ .OUTPUT_DIR }}
      - dagger call -m ./{{ .MODULE }} package --src {{ .TEST_PACKAGE }} --progress plain export --path={{ .OUTPUT_DIR_PACKAGE }}
      #- dagger call -m ./{{ .MODULE }} init-custom-package --name {{ .NEW_MODULE_KIND }} --progress plain export --path={{ .OUTPUT_DIR_PACKAGE }}
      - dagger call -m ./{{ .MODULE }} push --src {{ .TEST_PACKAGE }} --progress plain --username stuttgart-things --password=env:GITHUB_TOKEN --registry {{ .PACKAGE_REGISTRY }} --destination {{ .DESTINATION }}/{{ .PACKAGE_NAME }}:{{ .TAG }}
    vars:
      MODULE: crossplane
      TEST_PACKAGE: tests/registry
      OUTPUT_DIR: /tmp/crossplane
      NEW_MODULE_KIND: test
      OUTPUT_DIR_PACKAGE: "/tmp/crossplane/{{ .NEW_MODULE_KIND }}"
      PACKAGE_REGISTRY: ghcr.io
      DESTINATION: "{{ .PACKAGE_REGISTRY }}/stuttgart-things/stuttgart-things"
      PACKAGE_NAME: xplane-registry
      TAG: 2.2.7

  test-go:
    desc: Test go modules
    cmds:
      - dagger call -m ./{{ .MODULE }} lint --src {{ .TEST_GO_CODE }} --timeout 300s --progress plain || true
      - dagger call -m ./{{ .MODULE }} binary --src {{ .TEST_GO_CODE }} --goMainFile main.go --binName calc --progress plain export --path={{ .OUTPUT_DIR }} && ls -lta {{ .OUTPUT_DIR }} && rm -rf {{ .OUTPUT_DIR }}
      - dagger call -m ./{{ .MODULE }} ko-build --src {{ .TEST_GO_CODE }} --token=env:GITHUB_TOKEN --repo "{{ .KO_REPO }}" --ko-version {{ .KO_VERSION }} --push true --progress plain
      - dagger call -m ./{{ .MODULE }} security-scan --src {{ .TEST_GO_CODE }} --progress plain
      - dagger call -m ./go/ ko-build-and-scan --src {{ .TEST_GO_CODE }} --token=env:GITHUB_TOKEN --token-name GITHUB_TOKEN --repo {{ .KO_REPO }} --ko-version {{ .KO_VERSION }} --push true --output /tmp/report2.json
      # - dagger call -m ./{{ .MODULE }} internal-pipeline --src {{ .TEST_GO_CODE }} --progress plain || true
      #- dagger call -m ./{{ .MODULE }} run-workflow-entry-stage --src {{ .TEST_GO_CODE }} --lint-can-fail=true --security-scan-can-fail=true --trivy-scan-can-fail=true export --path {{ .WORKFLOW_REPORT }} --progress plain
    vars:
      MODULE: go
      TEST_GO_CODE: tests/calculator/
      OUTPUT_DIR: /tmp/calc
      KO_REPO: ttl.sh #ghcr.io/stuttgart-things/dagger
      KO_VERSION: 3979dd70544adde24d336d5b605f4cf6f0ea9479
      OUTPUT_GO_DIR: /tmp/go
      #TEST_IMG_TAR: test.tar
      WORKFLOW_REPORT: /tmp/workflow.json

  test-helm:
    desc: Test helm modules
    cmds:
      - dagger call -m {{ .MODULE }} lint --chart {{ .TEST_CHART }} --progress plain
      - dagger call -m {{ .MODULE }} render --chart {{ .TEST_CHART }} --values {{ .TEST_VALUES }} --progress plain
      #- dagger call -m {{ .MODULE }} package --src {{ .TEST_CHART }} --progress plain export --path={{ .TEST_PACKAGE }} && rm -rf {{ .TEST_PACKAGE }}
      - dagger call -m {{ .MODULE }} run-pipeline --src {{ .TEST_CHART }} --values {{ .TEST_VALUES }} --progress plain
      #- dagger call -m {{ .MODULE }} push --src {{ .TEST_CHART }} --progress plain --username {{ .USERNAME }} --password=env:GITHUB_TOKEN --registry {{ .PACKAGE_REGISTRY }} --repository {{ .USERNAME }}
    vars:
      MODULE: helm
      TEST_CHART: tests/test-chart/
      TEST_PACKAGE: tests/chart.tgz
      TEST_VALUES: tests/test-values.yaml
      PACKAGE_REGISTRY: ghcr.io
      USERNAME: stuttgart-things

  test-docker:
    desc: Test docker module
    cmds:
      - |
        dagger call -m {{ .MODULE }} \
        build-and-push \
        --source {{ .SOURCE }} \
        --repository-name {{ .REPOSITORY_NAME }} \
        --registry-url {{ .REGISTRY_URL }} \
        --version {{ .VERSION }} \
        --progress plain
    vars:
      MODULE: docker
      SOURCE: tests/docker/
      REPOSITORY_NAME: stuttgart-things/nginx-dagger
      REGISTRY_URL: ttl.sh
      VERSION: 1h

  branch:
    desc: Create branch from main
    cmds:
      - git checkout main
      - git branch
      - git pull
      - |
        echo "Enter to be created (remote) branch:"
        read BRANCH_NAME;
        git checkout -b ${BRANCH_NAME}
        git push origin ${BRANCH_NAME}
      - git branch
      - git branch --set-upstream-to=origin/main ${BRANCH_NAME}

  commit:
    desc: Commit + push code into branch
    cmds:
      - rm -rf dist/
      - git branch --set-upstream-to=origin/{{ .BRANCH }}
      - git pull
      - |
        git add *
        if [[ -n $(git status --porcelain) ]]; then
          echo "committing changes"
          echo "ENTER COMMIT MESSAGE"
          COMMIT_MESSAGE=$(echo $(gum choose "feat: {{ .BRANCH }}" "fix: {{ .BRANCH }}" "BREAKING CHANGE: {{ .BRANCH }}" "ENTER CUSTOM COMMIT MESSAGE"))

          if [ "$COMMIT_MESSAGE" == "ENTER CUSTOM COMMIT MESSAGE" ]; then
            COMMIT_MESSAGE=$(echo $(gum input --placeholder "scope" --value "commit to {{ .BRANCH }}"))
          fi

          git commit --allow-empty -a -m "$(echo ${COMMIT_MESSAGE})"
        else
          echo "no changes"
        fi
        git push origin -u {{ .BRANCH }}

  pr:
    desc: Create pull request into main
    # deps: [lint]
    cmds:
      - task: commit
      - gh pr create -t "{{ .BRANCH }}" -b "{{ .BRANCH }} branch into main"
      - sleep 20s
      #- gh pr checks $(gh pr list | grep "^[^#;]" | grep '{{ .BRANCH }}' | awk '{print $1}') --watch
      - gh pr merge $(gh pr list | grep "^[^#;]" | grep '{{ .BRANCH }}' | awk '{print $1}') --auto --rebase --delete-branch
      - git checkout main && git pull