releases.yaml

name: Releases

on:
  push:
    tags:
      - release-*
  pull_request:
  workflow_dispatch:

# TODO: github doesn't support regex matching in if expressions for some reason,
# so these jobs all expect zero-versioned release tags...

jobs:
  wait_for_ci:
    name: Wait for CI Workflow
    runs-on: ubuntu-latest
    steps:
      - name: Wait for CI
        uses: lewagon/wait-on-check-action@v1.3.4
        if: github.event_name != 'pull_request'
        with:
          ref: ${{ github.ref }}
          check-name: "Test on Rust stable"
          repo-token: ${{ secrets.GITHUB_TOKEN }}
          wait-interval: 10

  get_version:
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    outputs:
      cli: ${{ steps.cli.outputs.version || '' }}
      vscode-ext: ${{ steps.vscode-ext.outputs.version || '' }}
    steps:
      - uses: actions/checkout@v4
      - name: Retrieve release version
        if: startsWith(github.ref, 'refs/tags/release-taplo-cli-0')
        run: echo "version=$(echo ${GITHUB_REF#refs/tags/release-taplo-cli-})" >> $GITHUB_OUTPUT
        id: cli
      - name: Retrieve release version
        if: startsWith(github.ref, 'refs/tags/release-even-better-toml-')
        run: echo "version=$(echo ${GITHUB_REF#refs/tags/release-even-better-toml-})" >> $GITHUB_OUTPUT
        id: vscode-ext

  cargo_publish_taplo:
    name: Cargo publish taplo
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - name: Install latest Rust toolchain
        run: rustup update --no-self-update
      - uses: Swatinem/rust-cache@v2
      - name: Publish to Crates.io
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd crates/taplo && cargo publish --allow-dirty --token $CRATES_IO_TOKEN
        env:
          CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}

  cargo_publish_taplo_cli:
    name: Cargo publish taplo-cli
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo-cli-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - name: Install latest Rust toolchain
        run: rustup update --no-self-update
      - uses: Swatinem/rust-cache@v2
      - name: Publish to Crates.io
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd crates/taplo-cli && cargo publish --allow-dirty --token $CRATES_IO_TOKEN
        env:
          CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}

  cargo_publish_taplo_common:
    name: Cargo publish taplo-common
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo-common-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - name: Install latest Rust toolchain
        run: rustup update --no-self-update
      - uses: Swatinem/rust-cache@v2
      - name: Publish to Crates.io
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd crates/taplo-common && cargo publish --allow-dirty --token $CRATES_IO_TOKEN
        env:
          CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}

  cargo_publish_taplo_lsp:
    name: Cargo publish taplo-lsp
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo-lsp-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - name: Install latest Rust toolchain
        run: rustup update --no-self-update
      - uses: Swatinem/rust-cache@v2
      - name: Publish to Crates.io
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd crates/taplo-lsp && cargo publish --allow-dirty --token $CRATES_IO_TOKEN
        env:
          CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}

  cargo_publish_lsp_async_stub:
    name: Cargo publish lsp-async-stub
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-lsp-async-stub-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - name: Install latest Rust toolchain
        run: rustup update --no-self-update
      - uses: Swatinem/rust-cache@v2
      - name: Publish to Crates.io
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd crates/lsp-async-stub && cargo publish --allow-dirty --token $CRATES_IO_TOKEN
        env:
          CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}

  npm_publish_taplo_core:
    name: NPM publish @taplo/core
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo__core-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: lts/*
          registry-url: "https://registry.npmjs.org"
      - name: Install latest Rust toolchain
        run: |
          rustup update --no-self-update
          rustup target add wasm32-unknown-unknown
      - uses: Swatinem/rust-cache@v2
      - name: Publish to NPM
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd js/core && yarn install && yarn publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

  npm_publish_taplo_cli:
    name: NPM publish @taplo/cli
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo__cli-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: lts/*
          registry-url: "https://registry.npmjs.org"
      - name: Install latest Rust toolchain
        run: |
          rustup update --no-self-update
          rustup target add wasm32-unknown-unknown
      - uses: Swatinem/rust-cache@v2
      - name: Build Core
        working-directory: js/core
        run: yarn install && yarn build
      - name: Publish to NPM
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd js/cli && yarn install && yarn publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

  npm_publish_taplo_lsp:
    name: NPM publish @taplo/lsp
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo__lsp-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: lts/*
          registry-url: "https://registry.npmjs.org"
      - name: Install latest Rust toolchain
        run: |
          rustup update --no-self-update
          rustup target add wasm32-unknown-unknown
      - uses: Swatinem/rust-cache@v2
      - name: Build Core
        working-directory: js/core
        run: yarn install && yarn build
      - name: Publish to NPM
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd js/lsp && yarn install && yarn publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

  npm_publish_taplo_lib:
    name: NPM publish @taplo/lib
    runs-on: ubuntu-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo__lib-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: lts/*
          registry-url: "https://registry.npmjs.org"
      - name: Install latest Rust toolchain
        run: |
          rustup update --no-self-update
          rustup target add wasm32-unknown-unknown
      - uses: Swatinem/rust-cache@v2
      - name: Build Core
        working-directory: js/core
        run: yarn install && yarn build
      - name: Publish to NPM
        uses: nick-fields/retry@v3
        if: github.event_name == 'push'
        with:
          max_attempts: 3
          retry_wait_seconds: 300
          timeout_minutes: 60
          command: cd js/lib && yarn install && yarn publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

  build_cli_windows:
    name: ${{ matrix.triple }}
    runs-on: windows-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo-cli-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    strategy:
      fail-fast: false
      matrix:
        include:
          - triple: i686-pc-windows-msvc
            platform: x86
          - triple: x86_64-pc-windows-msvc
            platform: x86_64
          - triple: aarch64-pc-windows-msvc
            platform: aarch64
    steps:
      - uses: actions/checkout@v4

      - run: rustup update
      - run: rustup target add ${{ matrix.triple }}

      - name: Build taplo
        env:
          RUSTFLAGS: '-C target-feature=+crt-static'
        run: |
          cargo build --verbose --release --bin taplo --target ${{ matrix.triple }}
          # zip
          Compress-Archive -Path ./target/${{ matrix.triple }}/release/taplo.exe -DestinationPath ./taplo-windows-${{ matrix.platform }}.zip
          # gzip
          $file = [System.IO.File]::Open('.\target\${{ matrix.triple }}\release\taplo.exe', [System.IO.FileMode]::Open)
          $archive = [System.IO.File]::Create('.\taplo-windows-${{ matrix.platform }}.gz')
          $compressor = [System.IO.Compression.GZipStream]::new($archive, [System.IO.Compression.CompressionMode]::Compress)
          $file.CopyTo($compressor)
          $compressor.Close()

      - uses: actions/upload-artifact@v4
        with:
          name: taplo-windows-${{ matrix.platform }}
          path: |
            ./taplo-*.gz
            ./taplo-*.zip
          retention-days: 1

  build_cli_linux_musl:
    name: Build linux executables
    runs-on: ubuntu-latest
    needs: ["wait_for_ci", "get_version"]
    if: startsWith(github.ref, 'refs/tags/release-taplo-cli-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    steps:
      - uses: actions/checkout@v4
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v2
      - name: Set up Docker Buildx
        run: |
          docker buildx create --driver=docker-container --use
      - name: Login to DockerHub
        uses: docker/login-action@v2
        if: ${{ github.event_name == 'push' }}
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Build
        env:
          RELEASE_TAG: ${{ needs.get_version.outputs.cli || 'dev' }}
          PUSH: ${{ github.event_name == 'push' }}
        run: |
          docker buildx bake
      - name: Rename
        run: |
          cd ./target/alpine
          mv ./linux_386/taplo ./linux_386/taplo-x86
          mv ./linux_amd64/taplo ./linux_amd64/taplo-x86_64
          mv ./linux_arm64/taplo ./linux_amd64/taplo-aarch64
          mv ./linux_arm_v7/taplo ./linux_arm_v7/taplo-armv7
      - name: Gzip files
        run: |
          gzip ./target/alpine/linux_*/taplo*
      - uses: actions/upload-artifact@v4
        with:
          name: taplo-linux
          path: |
            ./target/alpine/linux_*/taplo*.gz
          retention-days: 1

  build_cli_macos:
    name: ${{ matrix.triple }}
    runs-on: macos-latest
    needs: ["wait_for_ci"]
    if: startsWith(github.ref, 'refs/tags/release-taplo-cli-0') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    strategy:
      fail-fast: false
      matrix:
        include:
          - triple: x86_64-apple-darwin
            platform: x86_64
          - triple: aarch64-apple-darwin
            platform: aarch64
    steps:
      - uses: actions/checkout@v4

      - run: rustup update
      - run: rustup target add ${{ matrix.triple }}

      - name: Build taplo
        run: |
          cargo build --verbose --release --bins --target ${{ matrix.triple }}
          gzip -c ./target/${{ matrix.triple }}/release/taplo > ./taplo-darwin-${{ matrix.platform }}.gz

      - uses: actions/upload-artifact@v4
        with:
          name: taplo-macos-${{ matrix.platform }}
          path: |
            ./taplo-*.gz
          retention-days: 1

  publish_cli:
    name: Release Taplo CLI binaries
    needs: [build_cli_windows, build_cli_linux_musl, build_cli_macos, get_version]
    runs-on: ubuntu-latest
    env:
      GH_REPO: ${{ github.repository }}
      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      DEBUG: api
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4
      - uses: actions/download-artifact@v4
      - name: Create GitHub release
        if: github.event_name == 'push'
        run: |
          gh release create --draft ${{ needs.get_version.outputs.cli }} --title "Taplo CLI ${{ needs.get_version.outputs.cli }}" --target $GITHUB_SHA taplo-windows-*/* taplo-macos-*/* taplo-linux-*/*

  publish_vscode_extension:
    name: Publish VSCode Extension
    needs: ["wait_for_ci", "get_version"]
    if: startsWith(github.ref, 'refs/tags/release-even-better-toml-') || contains(fromJSON('["workflow_dispatch", "pull_request"]'), github.event_name)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install latest Rust toolchain
        run: |
          rustup update --no-self-update
      - uses: Swatinem/rust-cache@v2
      - name: Install Node.js
        uses: actions/setup-node@v4
        with:
          node-version: lts/*
      - name: Enable latest yarn
        run: corepack enable
        working-directory: editors/vscode
      - name: Extension NPM Install
        run: yarn
        working-directory: editors/vscode
      - name: Install vsce
        run: npm install -g @vscode/vsce
      - name: Package Extension
        run: vsce package --baseImagesUrl https://raw.githubusercontent.com/tamasfe/taplo/master/editors/vscode --no-yarn # Microsoft doesn't support anything other than npm and yarn@v1
        working-directory: editors/vscode
      - name: Publish extension to microsoft marketplace
        if: github.event_name == 'push'
        run: vsce publish --baseImagesUrl https://raw.githubusercontent.com/tamasfe/taplo/master/editors/vscode -p $VSCE_TOKEN --no-yarn
        working-directory: editors/vscode
        env:
          VSCE_TOKEN: ${{ secrets.VSCE_TOKEN }}
      - name: Install ovsx
        run: npm install -g ovsx
      - name: Publish Open VSX Extension
        if: github.event_name == 'push'
        run: ovsx publish --baseImagesUrl https://raw.githubusercontent.com/tamasfe/taplo/master/editors/vscode -p $OPEN_VSX_TOKEN "even-better-toml-${{ needs.get_version.outputs.vscode-ext }}.vsix"
        working-directory: editors/vscode
        env:
          OPEN_VSX_TOKEN: ${{ secrets.OPEN_VSX_TOKEN }}

  pypi_build_linux:
    needs: ["wait_for_ci"]
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        target:
          - x86
          - x86_64
    steps:
      - uses: actions/checkout@v4
      - if: matrix.target == 'x86_64'
        name: Build wheels (static openssl)
        uses: PyO3/maturin-action@v1
        with:
          target: ${{ matrix.target }}
          args: --release --out dist --features vendored-openssl
          sccache: "true"
          manylinux: auto
          before-script-linux: |
            yum install -y perl-IPC-Cmd
      - if: matrix.target == 'x86'
        name: Build wheels (shared openssl)
        uses: PyO3/maturin-action@v1
        with:
          target: ${{ matrix.target }}
          args: --release --out dist
          sccache: "true"
          manylinux: auto
          before-script-linux: |
            yum install -y openssl-devel
      - name: Upload wheels
        uses: actions/upload-artifact@v4
        with:
          name: wheels-${{ github.job }}-${{ matrix.target }}
          path: dist

  pypi_build_windows:
    needs: ["wait_for_ci"]
    runs-on: windows-latest
    strategy:
      fail-fast: false
      matrix:
        target:
          - x64
          - x86
    steps:
      - uses: actions/checkout@v4
      - name: Build wheels
        uses: PyO3/maturin-action@v1
        with:
          target: ${{ matrix.target }}
          args: --release --out dist
          sccache: "true"
      - name: Upload wheels
        uses: actions/upload-artifact@v4
        with:
          name: wheels-${{ github.job }}-${{ matrix.target }}
          path: dist

  pypi_build_macos:
    needs: ["wait_for_ci"]
    runs-on: macos-latest
    strategy:
      fail-fast: false
      matrix:
        target:
          - aarch64
          - x86_64
    steps:
      - uses: actions/checkout@v4
      - name: Build wheels
        uses: PyO3/maturin-action@v1
        with:
          target: ${{ matrix.target }}
          args: --release --out dist
          sccache: "true"
      - name: Upload wheels
        uses: actions/upload-artifact@v4
        with:
          name: wheels-${{ github.job }}-${{ matrix.target }}
          path: dist

  pypi_build_sdist:
    needs: ["wait_for_ci"]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build sdist
        uses: PyO3/maturin-action@v1
        with:
          command: sdist
          args: --out dist
      - name: Upload sdist
        uses: actions/upload-artifact@v4
        with:
          name: wheels-${{ github.job }}
          path: dist

  pypi_merge_wheels:
    name: Merge PyPI wheels
    runs-on: ubuntu-latest
    needs:
      - pypi_build_linux
      - pypi_build_windows
      - pypi_build_macos
      - pypi_build_sdist
    steps:
      - uses: actions/download-artifact@v4
        with:
          merge-multiple: true
          path: wheels
      - uses: actions/upload-artifact@v4
        with:
          name: wheels
          path: wheels

  pypi_test_taplo_cli:
    needs: pypi_merge_wheels
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os:
          - windows-latest
          - ubuntu-latest
          - macos-latest
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: wheels
          path: wheels
      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"
      - run: pip install taplo --no-index --find-links wheels/
      - run: taplo help

  pypi_publish_taplo_cli:
    name: Release
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/release-taplo-cli-0')
    needs: pypi_test_taplo_cli
    permissions:
      id-token: write
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: wheels
          path: dist
      - name: Publish to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1