deploy.yml

name: Deploy documentation

# Trois déclencheurs :
#   - un push sur main (édition de la doc) ;
#   - un repository_dispatch émis par la release du compilateur, pour que la
#     doc soit reconstruite quand une nouvelle version de TypR sort ;
#   - manuellement.
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  repository_dispatch:
    types: [typr-release]
  workflow_dispatch:

permissions:
  contents: write

concurrency:
  group: pages
  cancel-in-progress: false

jobs:
  # ---------------------------------------------------------------------------
  # Les exemples de la doc sont compilés par le vrai compilateur, avant tout
  # build. Une doc qui ment coûte plus cher qu'une doc absente : on bloque.
  #
  # L'oracle est la *release* de `we-data-ch/typr`, pas `develop` — c'est la
  # version que le lecteur a réellement installée. Le préavis sur le langage à
  # venir est le rôle du workflow `examples-develop.yml`, qui n'avertit
  # qu'en `::warning` et ne bloque personne.
  # ---------------------------------------------------------------------------
  examples:
    name: Check typr examples
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      # Sur un repository_dispatch, la release qui nous réveille porte déjà son
      # numéro : on la vise directement plutôt que de faire confiance à
      # « latest », qui peut ne pas encore avoir basculé.
      - name: Install the released TypR compiler
        env:
          DISPATCH_VERSION: ${{ github.event.client_payload.version }}
        run: |
          set -euo pipefail
          if [ -n "${DISPATCH_VERSION:-}" ]; then
            TAG="v$DISPATCH_VERSION"
          else
            # En deux temps : `grep -m1` ferme le tube et ferait échouer curl
            # sous `pipefail`.
            LATEST=$(curl -sSfL https://api.github.com/repos/we-data-ch/typr/releases/latest)
            TAG=$(printf '%s' "$LATEST" | grep '"tag_name"' | head -1 | cut -d'"' -f4)
          fi
          [ -n "$TAG" ] || { echo "::error::aucune release trouvée pour we-data-ch/typr"; exit 1; }
          echo "Compilateur de référence : $TAG"
          echo "TYPR_TAG=$TAG" >> "$GITHUB_ENV"

          mkdir -p "$RUNNER_TEMP/typr-bin"
          curl -sSfL \
            "https://github.com/we-data-ch/typr/releases/download/$TAG/typr-$TAG-x86_64-unknown-linux-gnu.tar.gz" \
            | tar -xz -C "$RUNNER_TEMP/typr-bin"
          chmod +x "$RUNNER_TEMP/typr-bin/typr"
          echo "$RUNNER_TEMP/typr-bin" >> "$GITHUB_PATH"

      # `typr check` n'a pas besoin de R : il se contente d'un avertissement
      # quand Rscript est absent. Rien à installer de plus.
      - name: Check every ```typr block
        run: |
          echo "::notice title=Exemples vérifiés::oracle = compilateur TypR $TYPR_TAG"
          npm run check:examples

      # Le manifeste de syntaxe n'existe pas comme fichier dans le dépôt du
      # compilateur — il n'est que la sortie de `typr syntax --json`. On ne peut
      # donc pas le récupérer par `raw.githubusercontent.com` comme la
      # grammaire ; on le redemande au binaire, qui est déjà là.
      #
      # Simple avertissement, comme pour la grammaire : entre deux releases, la
      # copie a le droit d'être en retard. Ce qui bloque, c'est la cohérence
      # entre le manifeste *commité* et les pages (`check:syntax`, job `build`).
      - name: Manifeste de syntaxe — vérifier qu'il suit la release
        run: |
          UPSTREAM=$(mktemp)
          if ! typr syntax --json > "$UPSTREAM" 2>/dev/null; then
            echo "::notice title=Manifeste non vérifié::le compilateur $TYPR_TAG ne connaît pas encore « typr syntax »."
            exit 0
          fi
          if diff -q "$UPSTREAM" syntaxes/typr.syntax.json > /dev/null; then
            echo "syntaxes/typr.syntax.json est identique au manifeste de $TYPR_TAG."
          else
            echo "::warning title=Manifeste décalé::syntaxes/typr.syntax.json diffère de « typr syntax --json » sous $TYPR_TAG. La release le repousse normalement toute seule ; sinon, voir syntaxes/README.md."
            diff "$UPSTREAM" syntaxes/typr.syntax.json | head -40 || true
          fi

  build:
    name: Build and deploy
    needs: examples
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: npm

      - run: npm ci

      - name: Fetch TypR version from develop
        run: |
          VERSION=$(curl -sf https://raw.githubusercontent.com/we-data-ch/typr/develop/Cargo.toml \
            | grep '^version = ' | head -1 | sed 's/.*"\(.*\)".*/\1/')
          echo "TYPR_VERSION=$VERSION" >> "$GITHUB_ENV"

      - name: Sync version in homepage
        run: |
          sed -i "s/version [0-9]*\.[0-9]*\.[0-9]*/version $TYPR_VERSION/" src/pages/index.tsx

      # Les inventaires de syntaxe des pages de référence sont *dérivés* du
      # manifeste, pas recopiés à la main. Bloquant, et à raison : ici rien ne
      # dépend du réseau ni d'une release, seulement de deux fichiers du dépôt.
      # Un échec veut dire qu'un mot-clé a bougé sans que sa ligne de doc suive.
      - name: Inventaires de syntaxe — vérifier qu'ils suivent le manifeste
        run: npm run check:syntax

      # `syntaxe.md` est la carte de syntaxe autoritative (elle prime sur
      # `docs/` en cas de désaccord) et elle est le miroir de celle du
      # compilateur. Deux copies d'un même fichier finissent toujours par
      # diverger si personne ne regarde ; on regarde.
      - name: syntaxe.md — vérifier le miroir du dépôt du compilateur
        run: |
          UPSTREAM=$(mktemp)
          if ! curl -sfL -o "$UPSTREAM" \
            https://raw.githubusercontent.com/we-data-ch/typr/develop/syntaxe.md; then
            echo "::warning title=syntaxe.md non vérifié::impossible de récupérer la copie du compilateur."
            exit 0
          fi
          if diff -q "$UPSTREAM" syntaxe.md > /dev/null; then
            echo "syntaxe.md est identique à we-data-ch/typr@develop."
          else
            echo "::warning title=syntaxe.md décalé::syntaxe.md diffère de we-data-ch/typr@develop. Les deux copies doivent bouger ensemble quand le langage change."
            diff "$UPSTREAM" syntaxe.md | head -40 || true
          fi

      # La grammaire est un fichier *généré* par le compilateur et recopié ici
      # par sa release ; l'éditer à la main ferait revivre la divergence que le
      # manifeste a supprimée. On ne bloque pas le build pour autant : entre deux
      # releases, la copie a le droit d'être en retard sur `develop`.
      - name: Grammaire TypR — vérifier qu'elle n'a pas été éditée à la main
        run: |
          UPSTREAM=$(mktemp)
          if ! curl -sfL -o "$UPSTREAM" \
            https://raw.githubusercontent.com/we-data-ch/typr/develop/editors/vscode/syntaxes/typr.tmLanguage.json; then
            echo "::warning title=Grammaire non vérifiée::impossible de récupérer la grammaire de référence."
            exit 0
          fi
          if diff -q "$UPSTREAM" syntaxes/typr.tmLanguage.json > /dev/null; then
            echo "syntaxes/typr.tmLanguage.json est identique à la grammaire générée."
          else
            echo "::warning title=Grammaire décalée::syntaxes/typr.tmLanguage.json diffère de we-data-ch/typr@develop. Si ce n'est pas juste un retard entre deux releases, c'est une édition à la main : elle sera écrasée à la prochaine release. La source est crates/typr-core/src/components/syntax/mod.rs."
            diff "$UPSTREAM" syntaxes/typr.tmLanguage.json | head -40 || true
          fi
      - name: Typecheck
        run: npm run typecheck

      # La mesure d'audience (plan-phase2 §2.7) est en sommeil tant que cette
      # variable est vide : sans elle, aucun script tiers n'est injecté et le
      # site n'émet aucune requête de mesure. C'est une *variable* de dépôt et
      # pas un secret — la valeur finit dans le JavaScript public du site, la
      # ranger dans `secrets` ne masquerait que les journaux de CI.
      #
      # Elle est passée aussi aux builds de PR, sans conséquence : ceux-là ne
      # sont jamais publiés, donc jamais visités.
      - name: Build
        env:
          GOATCOUNTER_ENDPOINT: ${{ vars.GOATCOUNTER_ENDPOINT }}
        run: npm run build

      # Sur une PR on s'arrête ici : le build a validé les liens et le MDX,
      # mais rien n'est publié tant que ce n'est pas fusionné.
      - name: Deploy to gh-pages
        if: github.event_name != 'pull_request'
        uses: peaceiris/actions-gh-pages@v4
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./build
          user_name: github-actions[bot]
          user_email: github-actions[bot]@users.noreply.github.com
          commit_message: >-
            Deploy ${{ github.event_name == 'repository_dispatch'
              && format('for TypR {0}', github.event.client_payload.version)
              || github.sha }}