Establish a policy for spawning releases

[luigi-asprino]

We currently have a workflow in place for releasing a major release at the end of each milestone. We usually close a milestone once a significant number of issues have been resolved.
However, it would also be useful to publish intermediate snapshots for testing the current status of the tool, or to have a 'living' executable JAR file based on the latest commit.
One option would be to set up a workflow that is triggered when an issue is closed and publishes a snapshot as a release. However, this could result in many unnecessary releases. I think we could filter out issues with a specific label.
Do you have any suggestions?

[MathiasVDA]

I think a "nightly build" would be the first step. That's a scheduled build of the active dev branch and a publishing of it to some artifact repository such as maven or github releases.
You could also have a build triggered when an issue is closed. Either all issues or ones that are tagged with a specific label.
Or you could manually trigger such a build&deploy workflow.

The most important thing is to manage the proper tagging of those artifacts. For releases it's simply tagging with the release version. For nightly builds I think the term 'snapshot' would be appropriate. I guess you could use the same term for builds after closure of an issue.

[MathiasVDA]

You might want to think about how this would fit in with how you use branches. In the case of this repo, the branch name changes depending on the milestone that you aim to achieve. So all workflow files should take that into account and you might want to write down how you name branches in the future to keep any CI working

[luigi-asprino]

I would go for a nightly build triggered at the close of specific labels (i.e. bug, new feature, improvement, dependency, security) and a scheduled build (e.g. every night). Do you have any examples of workflows to get me started?

[MathiasVDA]

I could work on this and make a PR if you'd like. I'm not entirely sure what you'd like as a strategy and output so we might want to discuss a little first.

Here's an example of what I would submit for:

• nightly build off the default branch (so it will follow the branch when you change milestones)
• creation of prereleases
• retention of 7 prereleases
• publish to maven with a stable SNAPSHOT tag
• add artifacts to the prerelease (but the link to the release file will of course have a timestamp)

name: Nightly Snapshot Build

on:
  # Run nightly at 2 AM UTC
  schedule:
    - cron: '0 2 * * *'
  # Allow manual trigger
  workflow_dispatch:

jobs:
  build-and-publish:
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          # Get the default development branch (can change based on the milestone as needed)
          ref: ${{ github.event.repository.default_branch }}
      
      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      
      - name: Set up Maven Central Repository
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
          server-id: 'central'
          server-username: MAVEN_USERNAME
          server-password: MAVEN_PASSWORD
      
      - name: Get current date for snapshot naming
        id: date
        run: echo "date=$(date +'%Y%m%d-%H%M%S')" >> $GITHUB_OUTPUT
      
      - name: Get branch name
        id: branch
        run: |
          BRANCH=${GITHUB_REF#refs/heads/}
          echo "branch=${BRANCH}" >> $GITHUB_OUTPUT
          echo "branch_safe=${BRANCH//\//-}" >> $GITHUB_OUTPUT
      
      - name: Get base version from pom
        id: version
        run: |
          BASE_VERSION=$(mvn help:evaluate -Dexpression=revision -q -DforceStdout)
          # Strip -SNAPSHOT if it exists and add -NIGHTLY-SNAPSHOT for stable reference
          CLEAN_VERSION=${BASE_VERSION%-SNAPSHOT}
          SNAPSHOT_VERSION="${CLEAN_VERSION}-NIGHTLY-SNAPSHOT"
          echo "snapshot_version=${SNAPSHOT_VERSION}" >> $GITHUB_OUTPUT
          echo "Maven snapshot version: ${SNAPSHOT_VERSION}"
      
      - name: Build with Maven
        run: mvn clean package -DskipTests -Drevision=${{ steps.version.outputs.snapshot_version }}
      
      - name: Publish to Maven Central (Snapshots)
        run: |
          echo -e "Publishing snapshot ${SNAPSHOT_VERSION} to Maven Central"
          gpg --version
          mvn -version
          export GPG_TTY=$(tty)
          echo -e "${{ secrets.OSSRH_GPG_SECRET_KEY }}" | gpg --batch --import 
          gpg --list-secret-keys --keyid-format LONG
          mvn --batch-mode deploy -DskipTests -Drevision=${{ steps.version.outputs.snapshot_version }} -Dgpg.passphrase=${{ secrets.OSSRH_GPG_SECRET_KEY_PASSWORD }}
        env:
          MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
          MAVEN_PASSWORD: ${{ secrets.OSSRH_TOKEN }}
          SNAPSHOT_VERSION: ${{ steps.version.outputs.snapshot_version }}
      
      - name: Find JAR file
        id: find-jar
        run: |
          JAR_PATH=$(find sparql-anything-cli/target -name "*-with-dependencies.jar" | head -n 1)
          JAR_NAME=$(basename "$JAR_PATH")
          echo "jar_path=${JAR_PATH}" >> $GITHUB_OUTPUT
          echo "jar_name=${JAR_NAME}" >> $GITHUB_OUTPUT
          echo "Found JAR: ${JAR_PATH}"
      
      - name: Create snapshot release
        uses: softprops/action-gh-release@v1
        with:
          tag_name: snapshot-${{ steps.date.outputs.date }}
          name: Nightly Snapshot (${{ steps.branch.outputs.branch }}) - ${{ steps.date.outputs.date }}
          body: |
            ## 🌙 Nightly Snapshot Build
            
            **Branch:** `${{ steps.branch.outputs.branch }}`
            **Commit:** ${{ github.sha }}
            **Build Date:** ${{ steps.date.outputs.date }}
            **Maven Version:** `${{ steps.version.outputs.snapshot_version }}`
            
            This is an automated snapshot build for testing purposes.
            
            ⚠️ **Warning:** This is a development snapshot and may be unstable. Use at your own risk.
            
            ### Installation
            
            **Option 1: Download JAR**
            Download the JAR file and run:
            ```bash
            java -jar ${{ steps.find-jar.outputs.jar_name }}
            ```
            
            **Option 2: Maven Dependency (Stable Reference)**
            Add to your `pom.xml`:
            ```xml
            <dependency>
                <groupId>io.github.sparql-anything</groupId>
                <artifactId>sparql-anything-cli</artifactId>
                <version>${{ steps.version.outputs.snapshot_version }}</version>
            </dependency>
            ```
            
            And add the snapshot repository:
            ```xml
            <repositories>
                <repository>
                    <id>ossrh-snapshots</id>
                    <url>https://s01.oss.sonatype.org/content/repositories/snapshots</url>
                    <snapshots>
                        <enabled>true</enabled>
                    </snapshots>
                </repository>
            </repositories>
            ```
            
            ### Latest Changes
            See [commit history](https://github.com/${{ github.repository }}/commits/${{ steps.branch.outputs.branch }}) for details.
          files: ${{ steps.find-jar.outputs.jar_path }}
          draft: false
          prerelease: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      
      - name: Clean up old snapshots
        uses: dev-drprasad/delete-older-releases@v0.3.2
        with:
          keep_latest: 7
          delete_tag_pattern: snapshot-
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}