release.yml

name: Release

on:
  push:
    # Release tags: release_1.3.0 (the update checker parses the three-part version).
    tags: ['release_*']
  workflow_dispatch:
    inputs:
      version:
        description: Version to package (for example 1.3.0)
        required: true
        type: string

# The tag run creates the GitHub release with the packaged zips.
permissions:
  contents: write

env:
  DOTNET_NOLOGO: true
  DOTNET_CLI_TELEMETRY_OPTOUT: true
  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true

jobs:
  verify:
    name: verify version and tests
    runs-on: windows-latest
    timeout-minutes: 30
    outputs:
      version: ${{ steps.version.outputs.version }}
    steps:
      - uses: actions/checkout@v7

      - name: Resolve and verify version
        id: version
        shell: pwsh
        run: |
          if ('${{ github.event_name }}' -eq 'workflow_dispatch') {
            $version = '${{ inputs.version }}'
          } else {
            $version = '${{ github.ref_name }}' -replace '^release_', ''
          }

          if ($version -notmatch '^\d+\.\d+\.\d+$') {
            throw "Invalid version '$version'. Use a three-part version such as 1.3.0."
          }

          [xml]$project = Get-Content -LiteralPath SimpleXisoDrive/SimpleXisoDrive.csproj
          $assemblyVersion = $project.Project.PropertyGroup.AssemblyVersion | Select-Object -First 1
          if ($assemblyVersion -ne $version) {
            throw "Version mismatch: '$version' does not match <AssemblyVersion> '$assemblyVersion' in SimpleXisoDrive.csproj."
          }

          "version=$version" | Out-File -FilePath $env:GITHUB_OUTPUT -Append

      - name: Setup .NET
        # 10.0.x, not `global-json-file`: the repo pins `10.0.0` with
        # rollForward latestMajor, which setup-dotnet cannot resolve.
        uses: actions/setup-dotnet@v6
        with:
          dotnet-version: 10.0.x
          cache: true
          cache-dependency-path: |
            **/*.csproj
            global.json

      - name: Restore
        run: dotnet restore CSharp_SimpleXisoDrive.sln

      - name: Build
        run: dotnet build CSharp_SimpleXisoDrive.sln --no-restore --configuration Release

      - name: Test
        run: >-
          dotnet test CSharp_SimpleXisoDrive.sln
          --no-build --configuration Release
          --blame-hang-timeout 15m
          --blame-hang-dump-type none

  package:
    name: package ${{ matrix.rid }}
    # Each runtime is packaged on its own operating system so the native apphost
    # matches the target (Dokan on Windows, FUSE 3 on Linux and macOS).
    runs-on: ${{ matrix.os }}
    timeout-minutes: 30
    needs: verify
    strategy:
      # Package every runtime even when one fails; the release job waits for all.
      fail-fast: false
      matrix:
        include:
          - rid: win-x64
            os: windows-latest
            project: SimpleXisoDrive/SimpleXisoDrive.csproj
            binary: SimpleXisoDrive.exe
          - rid: win-arm64
            os: windows-latest
            project: SimpleXisoDrive/SimpleXisoDrive.csproj
            binary: SimpleXisoDrive.exe
          - rid: linux-x64
            os: ubuntu-latest
            project: SimpleXisoDrive.Unix/SimpleXisoDrive.Unix.csproj
            binary: SimpleXisoDrive
          - rid: linux-arm64
            os: ubuntu-latest
            project: SimpleXisoDrive.Unix/SimpleXisoDrive.Unix.csproj
            binary: SimpleXisoDrive
          - rid: osx-x64
            os: macos-latest
            project: SimpleXisoDrive.Unix/SimpleXisoDrive.Unix.csproj
            binary: SimpleXisoDrive
          - rid: osx-arm64
            os: macos-latest
            project: SimpleXisoDrive.Unix/SimpleXisoDrive.Unix.csproj
            binary: SimpleXisoDrive
    steps:
      - uses: actions/checkout@v7

      - name: Setup .NET
        uses: actions/setup-dotnet@v6
        with:
          dotnet-version: 10.0.x
          cache: true
          cache-dependency-path: |
            **/*.csproj
            global.json

      - name: Publish
        # Framework-dependent single-file executable, matching the local release
        # bundles: one executable per zip, no runtime included.
        run: >-
          dotnet publish ${{ matrix.project }}
          --configuration Release
          --runtime ${{ matrix.rid }}
          --self-contained false
          -p:PublishSingleFile=true
          --output publish/${{ matrix.rid }}

      - name: Package release zip
        # Each zip contains the single-file executable plus ReadMe.md,
        # WhatsNew.md and LICENSE.txt, matching the local release bundles.
        # Built with the .NET ZipArchive API (portable across the runner OSes)
        # so the Unix executable mode can be stored explicitly.
        shell: pwsh
        run: |
          $zip = "release_${{ needs.verify.outputs.version }}_${{ matrix.rid }}.zip"
          $staging = "bundle/${{ matrix.rid }}"
          New-Item -ItemType Directory -Path $staging -Force | Out-Null
          Copy-Item -LiteralPath "publish/${{ matrix.rid }}/${{ matrix.binary }}" -Destination $staging
          Copy-Item -LiteralPath ReadMe.md, WhatsNew.md, LICENSE.txt -Destination $staging

          Add-Type -AssemblyName System.IO.Compression
          Add-Type -AssemblyName System.IO.Compression.FileSystem
          $archive = [System.IO.Compression.ZipFile]::Open($zip, [System.IO.Compression.ZipArchiveMode]::Create)
          try {
            foreach ($file in Get-ChildItem -LiteralPath $staging -File) {
              $entry = $archive.CreateEntry($file.Name, [System.IO.Compression.CompressionLevel]::Optimal)
              $entry.LastWriteTime = $file.LastWriteTime
              if (-not $IsWindows) {
                # 0o100755 for the executable, 0o100644 for the documentation.
                $entry.ExternalAttributes = if ($file.Name -eq '${{ matrix.binary }}') { 0x81ED0000 } else { 0x81A40000 }
              }

              $source = [System.IO.File]::OpenRead($file.FullName)
              try {
                $target = $entry.Open()
                try {
                  $source.CopyTo($target)
                } finally {
                  $target.Dispose()
                }
              } finally {
                $source.Dispose()
              }
            }
          } finally {
            $archive.Dispose()
          }

          Get-Item -LiteralPath $zip | Select-Object Name, Length

      - name: Upload package
        uses: actions/upload-artifact@v7
        with:
          name: release-${{ matrix.rid }}
          path: release_*.zip
          if-no-files-found: error

  github-release:
    name: create GitHub release
    # Manual runs stop at packaged artifacts; only a tag creates the release.
    if: startsWith(github.ref, 'refs/tags/')
    runs-on: ubuntu-latest
    timeout-minutes: 15
    needs: [verify, package]
    steps:
      - name: Checkout
        uses: actions/checkout@v7
        with:
          # Full history and tags so the previous release tag can be found for
          # the Full Changelog link.
          fetch-depth: 0

      - name: Build release notes
        # Curated release body: prerequisites (the downloads are
        # framework-dependent and need the .NET runtime plus a mount driver)
        # followed by the version's section from WhatsNew.md.
        shell: pwsh
        env:
          VERSION: ${{ needs.verify.outputs.version }}
        run: |
          $whatsNew = Get-Content -LiteralPath WhatsNew.md -Raw
          $marker = "# What's New in $env:VERSION"
          $start = $whatsNew.IndexOf($marker, [StringComparison]::Ordinal)
          if ($start -lt 0) {
            throw "WhatsNew.md has no '$marker' section."
          }

          $next = $whatsNew.IndexOf("# What's New in ", $start + $marker.Length, [StringComparison]::Ordinal)
          $section = if ($next -lt 0) { $whatsNew.Substring($start) } else { $whatsNew.Substring($start, $next - $start) }

          # Demote the section headings by one level so the release body hierarchy stays intact.
          $section = ($section -replace '(?m)^(#{1,5}) ', '$1# ').Trim()

          $previous = ""
          try {
            $previous = (git describe --tags --abbrev=0 HEAD^ 2>$null).Trim()
          } catch {
            $previous = ""
          }

          # Single-quoted here-string: the Markdown backticks stay literal.
          $template = @'
          Read-only mounting of original Xbox ISO/XISO/CISO images, Xbox ISO CHD images and ZArchive files on Windows, Linux and macOS. The downloads are framework-dependent single-file executables, so the .NET runtime and the platform mount driver must be installed first.

          ## Before you start

          | Platform | What to install |
          | --- | --- |
          | All | [.NET 10.0 Runtime](https://dotnet.microsoft.com/download/dotnet/10.0) - the base runtime is enough (the Desktop Runtime is not required). |
          | Windows | [Dokan 2.x](https://github.com/dokan-dev/dokany/releases) - restart Windows after installing so the driver loads. |
          | Linux | FUSE 3: `libfuse3` plus the `fuse3` tools, for example `sudo apt install libfuse3-3 fuse3` (Fedora: `sudo dnf install fuse3 fuse3-libs`; Arch: `sudo pacman -S fuse3`). Make sure `/dev/fuse` exists (`sudo modprobe fuse`) and `fusermount3` is on `PATH`. |
          | macOS | [macFUSE](https://macfuse.io) - allow the system extension when prompted. macOS 15.4 or later can use the FSKit backend, which needs no kernel extension. |

          ## Downloads

          | Bundle | Platform |
          | --- | --- |
          | `release_{VERSION}_win-x64.zip`, `release_{VERSION}_win-arm64.zip` | Windows x64 / ARM64 (Dokan) |
          | `release_{VERSION}_linux-x64.zip`, `release_{VERSION}_linux-arm64.zip` | Linux x64 / ARM64 (FUSE 3) |
          | `release_{VERSION}_osx-x64.zip`, `release_{VERSION}_osx-arm64.zip` | macOS Intel / Apple silicon (macFUSE) |

          Each zip contains the single-file executable plus `ReadMe.md`, `LICENSE.txt` and `WhatsNew.md`. On Linux and macOS the executable bit is already set, so extract and run `./SimpleXisoDrive`. On Windows run `SimpleXisoDrive.exe`.
          '@

          $template = $template.Replace('{VERSION}', $env:VERSION)
          $compare = if ($previous) {
            "`n`n---`n`n**Full Changelog**: https://github.com/$env:GITHUB_REPOSITORY/compare/$previous...release_$env:VERSION`n"
          } else {
            "`n"
          }

          $notes = $template.TrimEnd() + "`n`n" + $section + $compare
          Set-Content -LiteralPath release-notes.md -Value $notes -Encoding utf8
          Write-Output "release-notes.md written ($($notes.Length) chars, previous tag: '$previous')"

      - name: Download packages
        uses: actions/download-artifact@v8
        with:
          pattern: release-*
          merge-multiple: true
          path: assets

      - name: Create release
        shell: bash
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          VERSION: ${{ needs.verify.outputs.version }}
        run: >-
          gh release create "${GITHUB_REF_NAME}"
          --repo "${GITHUB_REPOSITORY}"
          --title "SimpleXisoDrive ${VERSION}"
          --notes-file release-notes.md
          assets/release_*.zip