version_check.yml

name: Check Turing.jl version consistency
on:
  push:
    branches:
      - master
      - backport-*
  pull_request:
    branches:
      - master
      - backport-*
  workflow_dispatch:

jobs:
  check-version:
    runs-on: ubuntu-latest

    permissions:
      contents: write
      pull-requests: write

    env:
      # Determine whether the target branch is master (i.e. this is a push to
      # master or a PR to master).
      TARGET_IS_MASTER: ${{ (github.event_name == 'push' && github.ref_name == 'master') || (github.event_name == 'pull_request' && github.base_ref == 'master') }}
      # Disable precompilation as it takes a long time and is not needed for this workflow
      JULIA_PKG_PRECOMPILE_AUTO: 0

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Julia
        uses: julia-actions/setup-julia@v2
        
      - name: Log GitHub context variables
        run: |
          echo github.event_name: ${{ github.event_name }}
          echo github.ref_name: ${{ github.ref_name }}
          echo github.base_ref: ${{ github.base_ref }}
          echo TARGET_IS_MASTER: ${{ env.TARGET_IS_MASTER }}

      - name: Check version consistency
        shell: julia --color=yes --project=. {0}
        run: |
          using Pkg
          Pkg.activate(temp=true)
          Pkg.add(["YAML", "TOML", "JSON", "HTTP"])
          import YAML
          import TOML
          import JSON
          import HTTP

          PROJECT_TOML_PATH = "Project.toml"
          QUARTO_YML_PATH = "_quarto.yml"
          MANIFEST_TOML_PATH = "Manifest.toml"

          function major_minor_match(vs...)
              for v in vs
                  if v.:major != vs[1].:major || v.:minor != vs[1].:minor
                      return false
                  end
              end
              return true
          end

          function major_minor_patch_match(vs...)
              for v in vs
                  if v.:major != vs[1].:major || v.:minor != vs[1].:minor || v.:patch != vs[1].:patch
                      return false
                  end
              end
              return true
          end

          function update_project_toml(fname, target_version)
              # Don't deserialise/serialise as this will scramble lines
              lines = readlines(fname)
              open(fname, "w") do io
                  for line in lines
                      if occursin(r"^Turing\s*=\s*\"\d+\.\d+\"\s*$", line)
                          println(io, "Turing = \"$(target_version.:major).$(target_version.:minor)\"")
                      else
                          println(io, line)
                      end
                  end
              end
          end

          function update_quarto_yml(fname, target_version)
              # Don't deserialise/serialise as this will scramble lines
              lines = readlines(fname)
              open(fname, "w") do io
                  for line in lines
                      m = match(r"^(\s+)- text:\s*\"v\d+\.\d+\"\s*$", line)
                      if m !== nothing
                          println(io, "$(m[1])- text: \"v$(target_version.:major).$(target_version.:minor)\"")
                      else
                          println(io, line)
                      end
                  end
              end
          end

          # Retain the original version number string for error messages, as
          # VersionNumber() will tack on a patch version of 0
          quarto_yaml = YAML.load_file(QUARTO_YML_PATH)
          quarto_version_str = quarto_yaml["website"]["navbar"]["right"][1]["text"]
          quarto_version = VersionNumber(quarto_version_str)
          println("_quarto.yml version: ", quarto_version_str)

          project_toml = TOML.parsefile(PROJECT_TOML_PATH)
          project_version_str = project_toml["compat"]["Turing"]
          project_version = VersionNumber(project_version_str)
          println("Project.toml version: ", project_version_str)

          manifest_toml = TOML.parsefile(MANIFEST_TOML_PATH)
          manifest_version = VersionNumber(manifest_toml["deps"]["Turing"][1]["version"])
          println("Manifest.toml version: ", manifest_version)

          if ENV["TARGET_IS_MASTER"] == "true"
              # Fetch the latest version from GitHub and update files to match this version
              # if necessary.

              resp = HTTP.get("https://api.github.com/repos/TuringLang/Turing.jl/releases/latest")
              latest_version = VersionNumber(JSON.parse(String(resp.body))["tag_name"])
              println("Latest Turing.jl version: ", latest_version)

              if !major_minor_match(latest_version, project_version)
                  println("$(PROJECT_TOML_PATH) is out of date; updating")
                  update_project_toml(PROJECT_TOML_PATH, latest_version)
              end

              if !major_minor_match(latest_version, quarto_version)
                  println("$(QUARTO_YML_PATH) is out of date; updating")
                  update_quarto_yml(QUARTO_YML_PATH, latest_version)
              end

              if !major_minor_patch_match(latest_version, manifest_version)
                  # Attempt to automatically update Manifest
                  println("$(MANIFEST_TOML_PATH) is out of date; updating")
                  old_env = Pkg.project().path
                  Pkg.activate(".")
                  Pkg.update()
                  # Check if versions match now, error if not
                  Pkg.activate(old_env)
                  manifest_toml = TOML.parsefile(MANIFEST_TOML_PATH)
                  manifest_version = VersionNumber(manifest_toml["deps"]["Turing"][1]["version"])
                  if !major_minor_patch_match(latest_version, manifest_version)
                      error("Failed to update Manifest.toml to match latest Turing.jl version")
                  end
              end

          else
              # Don't attempt to fetch the latest version; just check for consistency
              # and error if versions don't match.
              if !major_minor_match(quarto_version, project_version, manifest_version)
                  error("The minor versions of Turing.jl in _quarto.yml, Project.toml, and Manifest.toml are inconsistent:
                 - _quarto.yml: $quarto_version_str
                 - Project.toml: $project_version_str
                 - Manifest.toml: $manifest_version
                        ")
              end
          end

      - name: Create a PR with suggested changes
        if: env.TARGET_IS_MASTER
        uses: peter-evans/create-pull-request@v6
        with:
          base: ${{ github.event_name == 'pull_request' && github.head_ref || github.ref_name }}
          commit-message: "Update Turing.jl version to match latest release"
          title: "Update Turing.jl version to match latest release"