Merge branch 'master' of https://github.com/juce-framework/JUCE

Author: timothyschoen

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -48,10 +48,11 @@ body:
       multiple: true
       options:
         - x86_64
-        - ARM
-        - Other
-        - 64-bit
-        - 32-bit
+        - Arm64/aarch64
+        - Arm64EC (Windows)
+        - x86 (Windows, Android)
+        - 32 bit Arm (Linux, Android)
+        - Unsupported
     validations:
       required: true
   - type: textarea

.github/actions/download_artifacts/action.yaml

@@ -0,0 +1,50 @@
+name: Download Artifacts
+description: Download artifacts preserving file permissions
+inputs:
+  keys:
+    description: The artifact keys
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Download artifacts
+      shell: python3 {0}
+      run: |
+        import sys
+        import os
+        sys.path.append(os.path.abspath('.github/workflows'))
+
+        from configure_logger import configure_logger
+        from github_api_request import json_github_api_request, download_github_api_request
+
+        from logging import getLogger
+        from os import environ
+        from zipfile import ZipFile
+        import tarfile
+
+        logger = getLogger(__name__)
+        configure_logger(logger)
+
+        input_keys = """${{ inputs.keys }}"""
+        logger.debug(f'Input keys: {input_keys}')
+        artifact_keys = list(filter(None, [x.strip() for x in input_keys.split('\n')]))
+        logger.info(f'Downloading keys: {artifact_keys}')
+
+        api_prefix = 'actions'
+        artifacts_info = json_github_api_request(f'{api_prefix}/runs/{environ["GITHUB_RUN_ID"]}/artifacts')
+
+        for key in artifact_keys:
+            artifact_id = [x['id'] for x in artifacts_info['artifacts'] if x['name'] == key][0]
+            logger.debug(f'Artifact id for {key}: {artifact_id}')
+            zip_file = f'{key}.zip'
+            download_github_api_request(zip_file, f'{api_prefix}/artifacts/{artifact_id}/zip')
+            logger.debug(f'Unzipping: {zip_file}')
+            with ZipFile(zip_file) as archive:
+                archive.extractall()
+            os.remove(zip_file)
+            tar_file = f'{key}.tar'
+            logger.debug(f'Extracting: {tar_file}')
+            with tarfile.open(tar_file, 'r') as tar:
+                tar.extractall()
+            os.remove(tar_file)
+

.github/actions/job_wrapper/action.yaml

@@ -0,0 +1,26 @@
+name: Job Wrapper
+description: Setup and cleanup for build jobs
+inputs:
+  artifacts:
+    description: Required artifacts
+    required: false
+    default: ''
+  command:
+    description: The build command
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Get artifacts
+      uses: ./.github/actions/download_artifacts
+      with:
+        keys: |
+          JUCE-utils
+          ${{ inputs.artifacts }}
+    - run: ${{ inputs.command }}
+      shell: ${{ runner.os == 'Windows' && 'powershell' || 'bash' }}
+    - name: Handle job failure
+      if: failure()
+      run: python3 JUCE-utils/.github/workflows/post_job.py
+      shell: ${{ runner.os == 'Windows' && 'powershell' || 'bash' }}
+

.github/actions/upload_artifact/action.yaml

@@ -0,0 +1,50 @@
+name: Upload Artifact
+description: Upload an artifact preserving file permissions
+inputs:
+  key:
+    description: The artifact key
+    required: true
+  paths:
+    description: The artifact paths
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Create tarball
+      shell: python3 {0}
+      run: |
+        import sys
+        import os
+        sys.path.append(os.path.abspath('.github/workflows'))
+
+        from configure_logger import configure_logger
+
+        from logging import getLogger
+        from os import mkdir
+        import tarfile
+
+        logger = getLogger(__name__)
+        configure_logger(logger)
+
+        input_paths = """${{ inputs.paths }}"""
+        logger.debug(f'Input paths: {input_paths}')
+        paths = filter(None, [x.strip() for x in input_paths.split('\n')])
+        logger.info(f'Uploading paths: {paths}')
+        mkdir('tmp_artifact_upload')
+        archive_path = 'tmp_artifact_upload/${{ inputs.key }}.tar'
+        logger.debug(f'Creating archive: {archive_path}')
+        with tarfile.open('tmp_artifact_upload/${{ inputs.key }}.tar', 'w') as tar:
+            for path in paths:
+                logger.debug(f'Adding path to archive archive: {path}')
+                tar.add(path)
+    - uses: actions/upload-artifact@v4.6.0
+      with:
+        name: ${{ inputs.key }}
+        path: tmp_artifact_upload
+        retention-days: 1
+    - name: Clean up
+      shell: python3 {0}
+      run: |
+        from shutil import rmtree
+        rmtree('tmp_artifact_upload')
+

.github/workflows/check-cla.yml

@@ -7,6 +7,7 @@ jobs:
       PR_NUMBER: ${{ github.event.number }}
     steps:
       - name: check-CLA
+        if: github.repository == 'juce-framework/JUCE'
         run: |
           import urllib.request
           import json
@@ -18,6 +19,7 @@ jobs:
               with urllib.request.urlopen(req) as response:
                   return json.loads(response.read().decode('utf-8'))
           prCommits = jsonRequest('https://api.github.com/repos/juce-framework/JUCE/pulls/${{ github.event.number }}/commits')
+          print(f'Commit info:\n{json.dumps(prCommits, indent=4)}')
           allAuthors = [commit[authorType]['login'] for authorType in ['author', 'committer'] for commit in prCommits if commit[authorType]]
           uniqueAuthors = [name for name in list(set(allAuthors)) if name != 'web-flow']
           if (len(uniqueAuthors) == 0):

.github/workflows/configure_logger.py

@@ -0,0 +1,13 @@
+import logging
+from os import getenv
+from sys import stdout
+
+def configure_logger(logger):
+    handler = logging.StreamHandler(stdout)
+    formatter = logging.Formatter('[%(name)s] %(message)s')
+    handler.setFormatter(formatter)
+    level = logging.DEBUG if (getenv('RUNNER_DEBUG', '0').lower() not in ('0', 'f', 'false')) else logging.INFO
+    logger.setLevel(level)
+    handler.setLevel(level)
+    logger.addHandler(handler)
+

.github/workflows/github_api_request.py

@@ -0,0 +1,55 @@
+from configure_logger import configure_logger
+
+from logging import getLogger
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError, URLError
+from json import dumps, loads
+from os import environ
+from shutil import copyfileobj
+from time import sleep
+
+logger = getLogger(__name__)
+configure_logger(logger)
+
+def github_api_request(path, method='GET', data=None):
+    url = f'https://api.github.com/repos/{environ["GITHUB_REPOSITORY"]}/{path}'
+    logger.debug(f'Requesting GitHub API: {url}')
+    serialised_data = dumps(data).encode('utf-8') if data else None
+    if serialised_data:
+        logger.debug(f'Data: {serialised_data}')
+    req = Request(
+        url=url,
+        method=method,
+        headers={
+          'Accept': 'application/vnd.github+json',
+          'X-GitHub-Api-Version': '2022-11-28'
+        },
+        data=serialised_data
+    )
+    req.add_unredirected_header('Authorization', f'Bearer {environ["GITHUB_API_TOKEN"]}')
+    num_attempts = 0
+    while True:
+        response = None
+        try:
+            response = urlopen(req)
+            return response
+        except (HTTPError, URLError) as e:
+            num_attempts += 1
+            if num_attempts == 3:
+                logger.warning(f'GitHub API access failed\n{e.reason}\n{e.headers}\n{e.fp.read()}')
+                raise e
+            logger.debug(f'Request attempt {num_attempts} failed, retrying')
+            sleep(10)
+
+def json_github_api_request(path, method='GET', data=None):
+    with github_api_request(path, method, data) as response:
+        result = loads(response.read().decode('utf-8'))
+    logger.debug(f'GitHub API result: {result}')
+    return result
+
+def download_github_api_request(filename, path, method='GET', data=None):
+    with github_api_request(path, method, data) as response:
+        with open(filename, 'wb') as f:
+            copyfileobj(response, f)
+    logger.debug(f'Downloaded to: {filename}')
+

.github/workflows/juce_private_build.yml

@@ -0,0 +1,113 @@
+name: JUCE Private Build
+
+on:
+  workflow_dispatch:
+    inputs:
+      triggerer:
+        required: false
+        type: string
+        default: ''
+        description: The GitHub ID to receive email notifications (leave blank)
+      nightly-targets:
+        required: false
+        type: string
+        default: "[]"
+        description: A list of nightly build targets in JSON format
+      cpp-std:
+        required: false
+        type: string
+        default: ""
+        description: The C++ standard to use (optional [20, 23])
+
+env:
+  target_url: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+
+run-name: "[${{ inputs.triggerer && inputs.triggerer || github.event.sender.login }}] ${{ github.sha }}"
+
+jobs:
+  setup:
+    if: ${{ (inputs.nightly-targets == '[]') && (inputs.cpp-std == '') }}
+    name: Check and set CI commit status
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    outputs:
+      build: ${{ steps.status_check.outputs.build }}
+    steps:
+      - uses: actions/checkout@v4.2.2
+        with:
+          fetch-depth: 0
+          sparse-checkout: |
+            .github/workflows
+      - id: status_check
+        shell: python
+        run: |
+          import sys
+          import os
+          sys.path.append(os.path.abspath('.github/workflows'))
+          from github_api_request import json_github_api_request
+          sha = os.environ["GITHUB_SHA"]
+          statuses_response = json_github_api_request(f'commits/{sha}/statuses')
+          status = next(filter(lambda x: x['context'] == 'CI', statuses_response), None)
+          if (status is None) or (status['state'] != 'success'):
+            with open(os.environ['GITHUB_OUTPUT'], 'a') as f:
+              f.write(f'build=1\n')
+            data = {
+              'state': 'pending',
+              'context': 'CI',
+              'target_url': os.environ['target_url'],
+            }
+            post_response = json_github_api_request(f'statuses/{sha}', 'POST', data)
+            print(post_response)
+  build:
+    if: ${{ !cancelled() && (success() || needs.setup.result == 'skipped') && (inputs.nightly-targets != '[]' || inputs.cpp-std != '' || needs.setup.outputs.build == '1' || contains(fromJSON('["master"]'), github.ref_name)) }}
+    needs: [setup]
+    name: .
+    # Not having the ability to do a dynamic 'uses' call is a real pain. To
+    # test some new CI configuration you must set the branch in both places
+    # below.
+    uses: juce-framework/JUCE-utils/.github/workflows/main.yml@master
+    with:
+      juce-utils-branch: master
+      nightly-targets: ${{ inputs.nightly-targets }}
+      triggerer: ${{ inputs.triggerer && inputs.triggerer || github.event.sender.login }}
+      cpp-std: ${{ inputs.cpp-std }}
+    secrets: inherit
+  deploy:
+    if: ${{ !cancelled() && (success() || needs.build.result == 'skipped') && contains(fromJSON('["master", "develop"]'), github.ref_name) && inputs.cpp-std == '' && inputs.nightly-targets == '[]' }}
+    needs: [build]
+    name: Deploy
+    uses: juce-framework/JUCE-utils/.github/workflows/deploy.yml@master
+    secrets: inherit
+  docs:
+    if: ${{ !cancelled() && (success() || needs.deploy.result == 'success') && contains(fromJSON('["master", "develop"]'), github.ref_name) && inputs.cpp-std == '' && inputs.nightly-targets == '[]' }}
+    needs: [deploy]
+    name: Docs
+    uses: juce-framework/JUCE-utils/.github/workflows/docs.yml@master
+    secrets: inherit
+  set-commit-status:
+    if: ${{ always() && (inputs.nightly-targets == '[]') && (inputs.cpp-std == '') }}
+    needs: [setup, build, deploy, docs]
+    name: Set CI commit status
+    runs-on: ubuntu-latest
+    env:
+      result: ${{ contains(needs.*.result, 'cancelled') && 'cancelled' || (contains(needs.*.result, 'failure') && 'failure' || 'success') }}
+    steps:
+      - uses: myrotvorets/set-commit-status-action@master
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          sha: ${{ github.sha }}
+          status: ${{ contains(fromJSON('["cancelled", "failure"]'), env.result) && 'failure' || env.result }}
+          context: CI
+          description: ${{ env.result }}
+          targetUrl: ${{ env.target_url }}
+  notify:
+    if: ${{ always() && !contains(needs.*.result, 'cancelled') }}
+    needs: [setup, build, deploy, docs]
+    name: Notify
+    uses: juce-framework/JUCE-utils/.github/workflows/notify.yml@master
+    with:
+      juce-utils-branch: master
+      triggerer: ${{ inputs.triggerer && inputs.triggerer || github.event.sender.login }}
+      context: ${{ toJson(needs) }}
+    secrets: inherit

.github/workflows/juce_private_github_publish.yml

@@ -0,0 +1,16 @@
+name: JUCE Private GitHub Publish
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        required: true
+        type: string
+        description: The tag to publish ("5.4.5")
+
+jobs:
+  publish-github-release:
+    uses: juce-framework/JUCE-utils/.github/workflows/github_publish.yml@master
+    with:
+      tag: ${{ inputs.tag }}
+    secrets: inherit

.github/workflows/juce_private_nightly_trigger.yml

@@ -0,0 +1,32 @@
+name: JUCE Private Nightly Trigger
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 3 * * *'
+env:
+  GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  TRIGGER_WORKFLOW_REF: develop
+jobs:
+  juce-private-nightly-trigger:
+    if: github.repository == 'juce-framework/JUCE-dev'
+    name: JUCE Nightly Trigger
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4.2.2
+        with:
+          sparse-checkout: ./.github/workflows
+      - env:
+          TRIGGER_WORKFLOW_INPUTS: |
+            {"triggerer":"Nightly Build Targets","nightly-targets":${{ vars.NIGHTLY_BUILD_TARGETS }}}
+        run: python3 ./.github/workflows/trigger_workflow.py
+      - if: ${{ contains(fromJSON(vars.NIGHTLY_BUILD_TARGETS), 'cpp20') }}
+        env:
+          TRIGGER_WORKFLOW_INPUTS: |
+            {"triggerer":"Nightly Build C++20","cpp-std":"20"}
+        run: python3 ./.github/workflows/trigger_workflow.py
+      - if: ${{ contains(fromJSON(vars.NIGHTLY_BUILD_TARGETS), 'cpp23') }}
+        env:
+          TRIGGER_WORKFLOW_INPUTS: |
+            {"triggerer":"Nightly Build C++23","cpp-std":"23"}
+        run: python3 ./.github/workflows/trigger_workflow.py
+