Taskfile.yml

# yaml-language-server: $schema=https://taskfile.dev/schema.json

version: '3'

vars:
  BIN_NAME: gotpm
  GO_URL:
    sh: go list -m
  BUILD_OS:
    sh: go env GOOS
  BUILD_ARCH:
    sh: go env GOARCH
  LATEST_TAG:
    sh: git describe --tags --dirty --always --abbrev=0
  COMMIT_HASH:
    sh: git rev-parse --short HEAD
  INSTALLER:
    sh: echo "${INSTALLER:-source}"
  VCS:
    sh: 'if [ -d .jj ]; then echo jj; else echo git; fi'
  LDFLAGS: >-
    -s -w
    -X {{.GO_URL}}/cmd.gitTag={{.LATEST_TAG}}
    -X {{.GO_URL}}/cmd.gitCommit={{.COMMIT_HASH}}
    -X {{.GO_URL}}/cmd.buildOS={{.BUILD_OS}}
    -X {{.GO_URL}}/cmd.buildARCH={{.BUILD_ARCH}}
    -X {{.GO_URL}}/cmd.installer={{.INSTALLER}}

env:
  CGO_ENABLED: '0'

tasks:
  default:
    cmds:
      - task --list
    silent: true

  mod:
    desc: Download and tidy Go modules
    aliases: [m]
    cmds:
      - go mod download
      - go mod tidy
      - go mod vendor

  lint:
    desc: Run golangci-lint
    aliases: [l]
    sources:
      - '**/*.go'
      - .golangci.yml
      - go.mod
    cmds:
      - golangci-lint run

  lint:fix:
    desc: Run golangci-lint and fix any issues
    sources:
      - '**/*.go'
      - .golangci.yml
      - go.mod
    cmds:
      - golangci-lint run --fix

  format:
    desc: Run golangci-lint and format any Go files
    aliases: [fmt, f]
    sources:
      - '**/*.go'
      - .golangci.yml
    cmds:
      - golangci-lint fmt

  test:install:
    internal: True
    preconditions:
      - command -v gotestsum
    cmds:
      - go install gotest.tools/gotestsum@latest

  test:
    desc: Run the test suite
    deps: [test:install]
    aliases: [t]
    sources:
      - '**/*.go'
    cmds:
      - gotestsum {{.CLI_ARGS}} ./...

  test:cover:
    desc: Run test suite with code coverage
    sources:
      - '**/*.go'
    cmds:
      - go test -coverprofile=c.out ./...
      - go tool cover -html=c.out

  crap:
    desc: Run CRAP (Change Risk Anti-Pattern) analysis
    cmds:
      - go run github.com/unclebob/crap4go/cmd/crap4go@latest

  ci:
    desc: Run Tests and Linter
    cmds:
      - task: lint
      - task: test

  build:
    desc: Build the binary
    aliases: [b]
    sources:
      - '**/*.go'
      - go.mod
    cmds:
      - go build -ldflags="{{.LDFLAGS}}" -o {{.BIN_NAME}}

  install:
    desc: Install gotpm
    aliases: [i]
    sources:
      - './**/*.go'
      - go.mod
    cmds:
      - go install -ldflags="{{.LDFLAGS}}"

  docs:cli:
    desc: Generate the CLI help snippets included by the docs
    summary: |
      The snippets are build output, not source: they are gitignored and
      regenerated on every docs build, so they are never fingerprinted.
    cmds:
      - ./scripts/gen-cli-docs.sh

  docs:serve:
    desc: Serve the documentation locally
    aliases: [d]
    deps: [docs:cli]
    cmds:
      - zensical serve

  docs:build:
    desc: Build the documentation site
    deps: [docs:cli]
    cmds:
      - zensical build --clean

  clean:
    desc: Clean repo from generated files
    aliases: [c]
    cmds:
      - rm -fr site/
      - rm -fr docs/includes/cli
      - rm -fr .task/
      - rm -fr .cache/
      - rm -fr lib.typ
      - rm -fr typst.toml
      - rm -fr gotpm.lock

  release-test:
    desc: Build a local snapshot release with GoReleaser (no publish, no signing)
    summary: |
      Runs GoReleaser's build/archive/checksum/homebrew-cask steps against the
      current commit without publishing anything, so you can sanity-check the
      release config before actually tagging. Signing is skipped: it needs a
      CI OIDC identity that doesn't exist locally. Output lands in dist/.
    cmds:
      - goreleaser release --snapshot --clean --skip=sign

  release-notes-test:
    desc: Generate the Release Notes for unreleased changes
    aliases: [notes]
    cmds:
      - git cliff --latest --no-exec --strip header --unreleased

  release:*:
    desc: Prepare the project for a new release
    summary: |
      This task will do the following:

      - Update the CHANGELOG.md file
      - Commit the changes
      - Create a new tag

      To use the task, run "task release:<version>" where "<version>" is is one of:

      - "major" - Bumps the major number
      - "minor" - Bumps the minor number
      - "patch" - Bumps the patch number
      - "next"  - Bumps the version automatically

      Pass PRE=<suffix> to cut a prerelease, e.g. "task release:patch PRE=rc.1"
      tags v1.2.4-rc.1. <suffix> is passed straight through to svu's
      --prerelease flag.
    vars:
      VERSION:
        sh: "svu {{index .MATCH 0}}{{if .PRE}} --prerelease {{.PRE}}{{end}}"
    cmds:
      - task: "release-internal:{{.VCS}}"
        vars:
          VERSION: '{{.VERSION}}'

  changelog:
    internal: true
    cmds:
      - "git-cliff -o --tag {{.VERSION}}"

  release-internal:jj:
    internal: true
    desc: Cuts the release in a colocated jj repo.
    vars:
      COMPLETE_MESSAGE: |
        Release complete. Run the following:

        jj git push --bookmark master --tag {{.VERSION}}
    preconditions:
      - sh: 'test -d .git'
        msg: "This jj repo is not colocated: git-cliff and svu need .git to release"
      - sh: 'test -n "$(jj log --no-graph -r ''@ & empty()'' -T commit_id)"'
        msg: "The working copy must be empty to release"
      - sh: 'test "$(jj log --no-graph --ignore-working-copy -r @- -T commit_id)" = "$(jj log --no-graph --ignore-working-copy -r master -T commit_id)"'
        msg: "The working copy must sit directly on the master bookmark to release"
      - sh: 'test -z "$(jj log --no-graph --ignore-working-copy -r @ -T description)"'
        msg: "The working copy must have no description to release"
    prompt: "Are you sure you want to release version {{.VERSION}}?"
    cmds:
      - cmd: echo "Releasing {{.VERSION}}"
        silent: true
      - task: changelog
        vars:
          VERSION: '{{.VERSION}}'
      - "jj describe -m 'chore(release): {{.VERSION}}'"
      - "jj bookmark set master -r @"
      - "git tag -a {{.VERSION}} -m {{.VERSION}} $(jj log --no-graph -r master -T commit_id)"
      - cmd: printf "%s" '{{.COMPLETE_MESSAGE}}'
        silent: true

  release-internal:git:
    internal: true
    desc: |
      Cuts the release in a plain git repo: changelog, commit onto master, tag.
    vars:
      COMPLETE_MESSAGE: |
        Release complete. Run the following:

        git push && git push --tags
    preconditions:
      - sh: 'test "$(git rev-parse --abbrev-ref HEAD)" = "master"'
        msg: "You must be on the master branch to release"
      - sh: 'test -z "$(git status --porcelain)"'
        msg: "You must have a clean working tree to release"
    prompt: "Are you sure you want to release version {{.VERSION}}?"
    cmds:
      - cmd: echo "Releasing {{.VERSION}}"
        silent: true
      - task: changelog
        vars:
          VERSION: '{{.VERSION}}'
      - "git add CHANGELOG.md"
      - "git commit -m 'chore(release): {{.VERSION}}'"
      - "git tag -a {{.VERSION}} -m {{.VERSION}}"
      - cmd: printf "%s" '{{.COMPLETE_MESSAGE}}'
        silent: true