kurmann / GitHub.Workflows

Zentrale Sammelstelle für Reusable GitHub-Workflows.
Apache License 2.0
0 stars 0 forks source link

Release-Drafter einführen #2

Closed kurmann closed 5 months ago

kurmann commented 5 months ago

Vorabdiskussion:

kurmann commented 5 months ago

Herzlichen Dank für den Hinweis mit Release Drafter. Ich habe mir das angeschaut und entschieden, dass ich einen Versuch damit starten will.

Und zwar gleich im Projekt "kurmann/GitHub.Workflows" selbst. Dieses Projekt soll nützliche Workflows anbieten für meine Zwecke. Und diese Workflows werden selbst natürlich auch wieder versioniert.

Hier ist die Doku von Release Drafter zur Anwendung. Wie würdest du nun den Release Drafter konfigurieren anhand unserem Gesprächsverlaufs?

name: Release Drafter

on:
  push:
    # branches to consider in the event; optional, defaults to all
    branches:
      - master
  # pull_request event is required only for autolabeler
  pull_request:
    # Only following types are handled by the action, but one can default to all as well
    types: [opened, reopened, synchronize]
  # pull_request_target event is required for autolabeler to support PRs from forks
  # pull_request_target:
  #   types: [opened, reopened, synchronize]

permissions:
  contents: read

jobs:
  update_release_draft:
    permissions:
      # write permission is required to create a github release
      contents: write
      # write permission is required for autolabeler
      # otherwise, read permission is required at least
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
      # (Optional) GitHub Enterprise requires GHE_HOST variable set
      #- name: Set GHE_HOST
      #  run: |
      #    echo "GHE_HOST=${GITHUB_SERVER_URL##https:\/\/}" >> $GITHUB_ENV

      # Drafts your next Release notes as Pull Requests are merged into "master"
      - uses: release-drafter/release-drafter@v5
        # (Optional) specify config name to use, relative to .github/. Default: release-drafter.yml
        # with:
        #   config-name: my-config.yml
        #   disable-autolabeler: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Um den Release Drafter effektiv in deinem Projekt "kurmann/GitHub.Workflows" zu integrieren, basierend auf unserem Gesprächsverlauf, sind hier einige Schritte und Konfigurationen, die du vornehmen solltest. Ich werde die Konfiguration so anpassen, dass sie deinen Anforderungen entspricht, einschließlich der Verwendung von Pull Requests zur Generierung von Release Notes.

Schritt 1: Konfiguration des Release Drafter Workflows

Zunächst musst du sicherstellen, dass der Workflow-Trigger richtig gesetzt ist. Du verwendest den main-Branch (statt master), also sollte dies reflektiert werden:

name: Release Drafter

on:
  push:
    branches:
      - main  # Achten darauf, dass du "main" verwendest, falls dies dein Hauptbranch ist
  pull_request:
    types: [opened, reopened, synchronize]
  pull_request_target:
    types: [opened, reopened, synchronize]

permissions:
  contents: read
  pull-requests: write

jobs:
  update_release_draft:
    runs-on: ubuntu-latest
    steps:
      - uses: release-drafter/release-drafter@v5
        with:
          # Optional: Pfad zur Konfigurationsdatei anpassen, falls nötig
          config-name: 'release-drafter.yml'
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Schritt 2: Erstellung einer Konfigurationsdatei für Release Drafter

Erstelle eine Datei namens release-drafter.yml im Verzeichnis .github/. Diese Datei wird die Konfigurationen für Release Drafter enthalten. Hier ist ein Beispiel, wie du diese Datei konfigurieren könntest, basierend auf unseren vorherigen Diskussionen über die automatisierte Generierung von Release Notes, die die tatsächlichen Beiträge widerspiegeln:

name-template: 'v$NEXT_PATCH_VERSION'
tag-template: 'v$NEXT_PATCH_VERSION'
categories:
  - title: '🚀 Features'
    labels:
      - 'feature'
  - title: '🐛 Bug Fixes'
    labels:
      - 'bug'
  - title: '📝 Documentation'
    labels:
      - 'documentation'
  - title: '🧰 Maintenance'
    labels:
      - 'maintenance'
change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
template: |
  ## What's Changed
  $CHANGES
version-resolver:
  major:
    labels:
      - 'major'
  minor:
    labels:
      - 'minor'
  patch:
    labels:
      - 'patch'

Erläuterung der Konfiguration:

Schritt 3: Überprüfung und Test

Nachdem du alles eingerichtet hast, teste den Workflow durch das Mergen eines Pull Requests in deinen main-Branch. Überprüfe, ob der Release Drafter die Release Notes entsprechend deiner Konfiguration aktualisiert.

Durch diese Schritte kannst du sicherstellen, dass deine Releases gut dokumentiert sind und die Release Notes automatisch generiert werden, was dir Zeit spart und den Überblick über die Änderungen in deinem Projekt verbessert.

kurmann commented 5 months ago

Danke für die Zusammenstellung. Eine Frage. Warum ist die Konfiguration basierend auf Pool-Requests ebenfalls? Ich hätte erwartet, dass es nur um den Main-Branch geht und auch nur, wenn diese mit Version-Tags versehen sind.


Das ist eine ausgezeichnete Frage! Der Grund, warum der Release Drafter oft so konfiguriert wird, dass er auf Pull Requests reagiert, liegt darin, dass viele Teams ihre Release Notes basierend auf den Änderungen vorbereiten, die durch Pull Requests in den main-Branch eingeführt werden. Der Vorteil dieses Ansatzes ist, dass du kontinuierlich und automatisch eine Dokumentation deiner Änderungen erhältst, sobald sie in den Hauptbranch integriert werden, was den Release-Prozess transparenter und nachvollziehbarer macht.

Pull Requests vs. Direkte Commits auf main

Integration von Version-Tags

Dein Ansatz, Release Notes nur dann zu generieren, wenn Änderungen mit Version-Tags versehen sind, ist ebenfalls gültig und wird oft in Umgebungen verwendet, wo Releases weniger häufig oder nur nach sorgfältiger Planung erfolgen. In diesem Fall könntest du den Release Drafter so konfigurieren, dass er ausschließlich auf das Pushen von Tags reagiert:

on:
  push:
    tags:
      - 'v*'

Mit dieser Konfiguration würde der Release Drafter nur dann ausgelöst, wenn ein neuer Tag, der mit v beginnt (z.B. v1.0.0), gepusht wird. Dies könnte besser zu einem Workflow passen, bei dem du manuell entscheidest, wann ein Release fertig ist und ein entsprechendes Tag setzt.

Entscheidung für den passenden Workflow

Die Entscheidung zwischen einem Pull-Request-basierten oder einem Tag-basierten Ansatz hängt von mehreren Faktoren ab:

Letztendlich ist es wichtig, einen Ansatz zu wählen, der zu deinen spezifischen Bedürfnissen passt und der es dir ermöglicht, deine Software effektiv und effizient zu verwalten.

kurmann commented 5 months ago

Im Moment arbeite ich alleine. Ich brauche den Pull-Request nicht, ausser er eröffnet mir tatsächlich die Möglichkeit, die Änderungen, die ich im dazugehörigen Feature gemacht habe, zu übertragen. Mir ist immer noch nicht ganz klar, wie der Ablauf jetzt ist. Grundsätzlich möchte ich einen Ort haben, beispielsweise bei einem Pull-Request von einem Feature auf den Main-Branch. Welche Informationen bzw. welche Änderungen es dort gegeben hat, statt sie in irgendwelchen Release-Nodes zu verfassen. Ich möchte ja die Release-Nodes schliesslich automatisieren. Verstehst du mich, was ich meine und was mein Ziel ist?


Ja, ich verstehe dein Ziel jetzt besser. Du möchtest einen effizienten und automatisierten Prozess schaffen, der die Änderungen, die durch Feature-Branches in den main-Branch eingeführt werden, direkt in die Release-Notes integriert, ohne dass du diese Informationen manuell zusammentragen musst. Da du alleine arbeitest, kann der Prozess vereinfacht werden, indem Pull Requests als zentraler Ort für die Dokumentation dieser Änderungen genutzt werden.

Hier ist eine klare Beschreibung, wie du das umsetzen könntest:

Schritt 1: Pull Request als Dokumentation verwenden

Wenn du einen Feature-Branch entwickelst und fertig bist, erstellst du einen Pull Request, um diesen Branch in den main-Branch zu mergen. In diesem Pull Request kannst du eine detaillierte Beschreibung aller wichtigen Änderungen angeben, die du vorgenommen hast. Das kann auch automatisch passieren, wenn du sinnvolle Commit-Nachrichten verwendest, die dann in den Pull Request übernommen werden.

Schritt 2: Release Drafter konfigurieren

Release Drafter kann automatisch diese Informationen aus den Pull Requests sammeln und vorbereiten, um sie in den Release Notes zu verwenden. Die Konfiguration des Release Drafters erfolgt über eine .github/release-drafter.yml Datei in deinem Repository. Hier ist ein Beispiel, wie diese Konfiguration aussehen könnte:

name-template: 'v$NEXT_MINOR_VERSION'
tag-template: 'v$NEXT_MINOR_VERSION'
categories:
  - title: 'New Features'
    labels:
      - 'feature'
  - title: 'Bug Fixes'
    labels:
      - 'bug'
  - title: 'Improvements'
    labels:
      - 'enhancement'
template: |
  ## Changes
  $CHANGES

In diesem Fall:

Schritt 3: Automatische Triggerung durch Tags

Wenn du bereit bist, ein neues Release zu erstellen, kannst du einen Tag in deinem main-Branch setzen, der den Release Drafter auslöst, um die vorbereiteten Release Notes zu verwenden und ein offizielles GitHub Release zu erstellen.

Schritt 4: GitHub Action für den Release Drafter

Stelle sicher, dass du eine GitHub Action hast, die den Release Drafter jedes Mal ausführt, wenn ein Pull Request gemerged wird oder ein Tag gepusht wird. Hier ist, wie deine GitHub Action aussehen könnte:

name: Release Drafter

on:
  push:
    branches:
      - main
    tags:
      - 'v*'
  pull_request:
    types: [closed]

jobs:
  update_release_draft:
    runs-on: ubuntu-latest
    steps:
      - uses: release-drafter/release-drafter@v5
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Mit diesem Setup kannst du einen automatisierten Workflow erstellen, der es dir ermöglicht, effizient und ohne manuellen Aufwand Releases zu verwalten. Jeder Pull Request liefert die notwendigen Informationen für die Release Notes, und der Release Drafter kümmert sich um die Zusammenstellung und Veröffentlichung dieser Notizen, sobald du bereit bist, ein Release zu taggen.

kurmann commented 5 months ago

Jetzt wird es noch spannender. In der Tat habe ich für ein Feature mehrere Commits. Die meisten Commits sind natürlich ganz kleine Commits, denn ich verfolge den Ansatz Commit offen, also häufiges Committen. Gleichzeitig habe ich oft eine Art finalisierenden Commit, also im Prinzip der Commit, wo ich dann sage, ja, dieses Feature ist für mich beendet, beziehungsweise die Vorabversion von dessen. Hier möchte ich vielleicht eine Art spezielle GitHub-Commit-Nachricht verfassen, vielleicht auch in Kombination mit einem Tag, die dann quasi in die Release-Notes des Features übernommen werden und die natürlich dann in die Gesamt-Release-Notes, also die von MainBridge, übernommen werden. Vielleicht ist das ein praktikabler Ansatz und vielleicht hast du auch andere Ansätze. Ich möchte grundsätzlich etwas haben, das für mich passt, aber gleichzeitig nicht fernab jeglicher Norm ist.


Es klingt, als ob du eine sehr strukturierte Herangehensweise an deine Git-Commits und Release-Notes hast, was hervorragend ist. Eine Möglichkeit, deine Commits so zu gestalten, dass sie effektiv in automatisierte Release-Notes einfließen können, ist die Verwendung von Conventional Commits. Dies ist ein Konventionssystem für Commit-Nachrichten, das die Erstellung von aussagekräftigen und automatisch generierbaren Release-Notes ermöglicht.

Conventional Commits

Conventional Commits bieten ein leicht verständliches Set von Regeln für das Verfassen klarer Commit-Nachrichten. Jede Nachricht beginnt mit einem Typ, der den Zweck des Commits beschreibt, gefolgt von einem optionalen Scope und einer Beschreibung:

<type>(<scope>): <description>

[optional body]

[optional footer(s)]

Typen von Conventional Commits

Einige der häufigsten Typen sind:

Integration in Release-Notes

Du kannst einen finalisierenden Commit für ein Feature kennzeichnen, indem du einen speziellen Typ oder Scope verwendest, z.B. feat für neue Features oder finalize für deinen abschließenden Commit. Zum Beispiel:

feat: add new user profile features

This commit adds new user profile features including...

oder

finalize(profile): complete major overhaul of user profiles

This commit represents the completion of the major user profile enhancements including...

Automatisierung mit Release Drafter

Mit Release Drafter kannst du dann diese Conventional Commit-Nachrichten nutzen, um automatisch strukturierte Release-Notes zu generieren, die nach Typ sortiert sind und klare Beschreibungen der Änderungen bieten. Hier ist, wie du Release Drafter konfigurieren könntest, um diese Nachrichten zu nutzen:

name-template: 'v$NEXT_MINOR_VERSION'
tag-template: 'v$NEXT_MINOR_VERSION'
categories:
  - title: 'Features'
    labels:
      - 'feat'
  - title: 'Bug Fixes'
    labels:
      - 'fix'
  - title: 'Documentation'
    labels:
      - 'docs'
change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
template: |
  ## What's Changed
  $CHANGES
version-resolver:
  major:
    labels:
      - 'BREAKING CHANGE'
  minor:
    labels:
      - 'feat'
  patch:
    labels:
      - 'fix'
      - 'refactor'
      - 'docs'

Zusammenfassung

Diese Strategie hilft dir dabei, kleine, iterative Commits zu machen, während der abschließende Commit eines Features klar in den Release-Notes hervorgehoben wird. Sie passt gut zu automatisierten Tools und erleichtert die Nachvollziehbarkeit der Änderungen, die in jeder Version vorgenommen wurden.

kurmann commented 5 months ago

Ich arbeite bisher immer mit Deutschsprachigen Release Notes und möchte diese aktuell auch so beibehalten, um auch die deutsche Sprache etwas zu fördern und weil ich grundsätzlich bis auf Weiteres alleine arbeite. Ist das ein Problem in diesem Zusammenhang?


Die Verwendung von deutschsprachigen Release Notes ist absolut kein Problem und lässt sich gut in deinen Entwicklungs- und Veröffentlichungsprozess integrieren. Die Sprache der Dokumentation, einschließlich der Release Notes, sollte das Publikum widerspiegeln, das du ansprechen möchtest. Da du vorhast, vorerst alleine zu arbeiten und die deutsche Sprache zu fördern, ist es eine passende Wahl.

Anpassung der Release Notes auf Deutsch

Wenn du Automatisierungstools wie Release Drafter verwendest, kannst du einfach die Vorlagen und Kategorien auf Deutsch anpassen. Hier ein Beispiel, wie du deine release-drafter.yml Konfiguration für deutschsprachige Release Notes anpassen könntest:

name-template: 'v$NEXT_MINOR_VERSION'
tag-template: 'v$NEXT_MINOR_VERSION'
categories:
  - title: 'Neue Funktionen'
    labels:
      - 'feat'
  - title: 'Fehlerbehebungen'
    labels:
      - 'fix'
  - title: 'Dokumentation'
    labels:
      - 'docs'
change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
template: |
  ## Was hat sich geändert
  $CHANGES
version-resolver:
  major:
    labels:
      - 'BREAKING CHANGE'
  minor:
    labels:
      - 'feat'
  patch:
    labels:
      - 'fix'
      - 'refactor'
      - 'docs'

Vorteile der Nutzung der deutschen Sprache in Release Notes

  1. Zielgruppenansprache: Durch die Verwendung der deutschen Sprache kannst du sicherstellen, dass deine Dokumentation für deutschsprachige Nutzer oder Kunden klar und verständlich ist.
  2. Konsistenz: Wenn deine Code-Kommentare und internen Dokumentationen ebenfalls auf Deutsch sind, sorgt das für eine durchgängige Sprachnutzung.
  3. Lokalisierung: Die Anpassung der Sprache an den Kulturraum kann die Benutzererfahrung verbessern und zeigt eine Wertschätzung der lokalen Kultur und Sprache.

Hinweise zur Umsetzung

Indem du diese Aspekte beachtest, kannst du einen effizienten und automatisierten Release-Workflow auf Deutsch erstellen, der gut zu deinem Arbeitsstil passt und die deutsche Sprache in deinem Projekt fördert.

kurmann commented 5 months ago

Ich denke, wir fahren genauso fort mit den Conventional Commits, wie du vorgeschlagen hast, auch mit den englischen Kurzbezeichnungen.


Das klingt nach einem sehr guten Plan! Die Verwendung von Conventional Commits mit englischen Kurzbezeichnungen bietet mehrere Vorteile, insbesondere in Bezug auf die Automatisierung und die Skalierbarkeit deines Projekts. Hier sind einige Tipps, um den Übergang zu diesem System zu erleichtern und es effektiv zu nutzen:

1. Einrichten eines klaren Commit-Nachrichtenformats

Stelle sicher, dass jede Commit-Nachricht einem einheitlichen Format folgt, das den Typ der Änderung (wie feat, fix, docs usw.), den betroffenen Bereich und eine kurze, klare Beschreibung umfasst. Beispiel:

feat(login): add captcha to login form

Dies erleichtert das spätere Durchsuchen des Git-Verlaufs und die automatische Generierung von Release Notes.

2. Automatisierung der Release-Notes

Integriere Tools wie Release Drafter in deinen GitHub-Workflow, um auf Basis deiner Conventional Commits automatisch Release Notes zu generieren. Diese Tools können die Commit-Nachrichten analysieren und entsprechend formatierte und kategorisierte Release Notes erstellen.

3. Verwendung von Commit-Linting-Tools

Erwäge die Verwendung von Tools wie commitlint, die dabei helfen, die Einhaltung der Conventional Commit-Konventionen zu überwachen. Dies kann besonders hilfreich sein, um Konsistenz zu wahren, wenn das Projekt wächst oder wenn mehr Entwickler beteiligt sind.

4. Schulung und Dokumentation

Da du derzeit alleine arbeitest, ist es einfacher, neue Prozesse einzuführen. Dennoch ist es eine gute Idee, eine Dokumentation zu erstellen, die deine Commit-Konventionen und den Release-Prozess erklärt. Dies wird zukünftigen Mitarbeitern oder dir selbst helfen, die getroffenen Entscheidungen und Prozesse nachzuvollziehen.

5. Integration in den CI/CD-Workflow

Stelle sicher, dass deine Continuous Integration (CI) und Continuous Deployment (CD) Pipelines gut mit den Conventional Commits harmonieren. Du könntest zum Beispiel automatische Versionssprünge oder das Deployment basierend auf dem Typ der Commits konfigurieren.

6. Regelmäßige Überprüfungen und Anpassungen

Überprüfe regelmäßig die Effektivität deiner Conventional Commit-Strategie und passe sie bei Bedarf an. Dies könnte bedeuten, neue Typen hinzuzufügen, die Beschreibungen zu verfeinern oder die Automatisierung zu erweitern.

Durch die Verwendung von Conventional Commits legst du ein starkes Fundament für ein nachhaltiges Projektmanagement, das sowohl automatisierte Prozesse unterstützt als auch die manuelle Last bei der Verwaltung von Releases reduziert. Wenn du noch Fragen hast oder Unterstützung bei der Implementierung benötigst, stehe ich dir gerne zur Verfügung!

kurmann commented 5 months ago

Ich möchte nun schrittweise implementieren und mit der Einführung des Release-Drafters beginnen, noch ohne automatische Versionierung, also der erste Release wäre 0.1.0. Kannst du mir helfen? Ich möchte gleich zu Beginn einen Reusable Workflow haben der mir ein deutschsprachiges Changelog zusammenstellt mit dem Release-Drafter - und zwar immer wenn ich auf den Main-Branch gehe.


Um mit dem Release Drafter zu beginnen und einen wiederverwendbaren Workflow zu implementieren, der bei jedem Push auf den main-Branch ein deutschsprachiges Changelog erstellt, folgen hier die notwendigen Schritte:

1. Vorbereitung des Repositories

Bevor du den Release Drafter einrichtest, stelle sicher, dass dein Repository auf GitHub bereit ist und dass du die notwendigen Berechtigungen hast, um Workflows und Konfigurationen hinzuzufügen.

2. Konfiguration des Release Drafters

Erstelle im Repository eine Konfigurationsdatei für den Release Drafter. Diese Datei wird normalerweise im .github-Verzeichnis unter dem Namen release-drafter.yml gespeichert.

Beispielkonfiguration für den Release Drafter

name-template: 'v$NEXT_PATCH_VERSION'
tag-template: 'v$NEXT_PATCH_VERSION'
categories:
  - title: 'Features'
    labels:
      - 'feature'
  - title: 'Bug Fixes'
    labels:
      - 'fix'
  - title: 'Dokumentation'
    labels:
      - 'docs'
change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
template: |
  ## Änderungen
  $CHANGES
version-template: '0.1.$PATCH'

Diese Konfiguration:

3. Einrichtung des wiederverwendbaren Workflows

Um den Release Drafter als wiederverwendbaren Workflow zu konfigurieren, erstelle eine Workflow-Datei im .github/workflows-Verzeichnis deines Repositories. Hier ist ein einfacher Workflow, der bei jedem Push auf main den Release Drafter auslöst.

Beispiel-Workflow release-drafter-workflow.yml

name: Release Drafter

on:
  push:
    branches:
      - main

jobs:
  update_release_draft:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Release Drafter
        uses: release-drafter/release-drafter@v5
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

4. Wiederverwendbarkeit des Workflows

Um diesen Workflow wiederverwendbar zu machen, kannst du ihn so anpassen, dass er auf workflow_call-Ereignisse hört, sodass er von anderen Workflows oder Repositories aufgerufen werden kann.

Anpassung für Wiederverwendbarkeit

name: Reusable Release Drafter

on:
  workflow_call:

jobs:
  update_release_draft:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Release Drafter
        uses: release-drafter/release-drafter@v5
        with:
          config-name: 'release-drafter-config.yml'
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

In diesem angepassten Workflow:

Durch die Einrichtung des Release Drafters und die Erstellung eines wiederverwendbaren Workflows kannst du automatisch ein deutschsprachiges Changelog generieren, das die Änderungen klar dokumentiert und für jede Veröffentlichung bereit ist.

kurmann commented 5 months ago

Sehr gut. Ich mache nun einen Test mit dem Release Drafter (noch ohne Wiederverwendbarkeit).

Wie stellt mit dieser Konfiguration der Release Drafter sein Changelog zusammen?


Der Release Drafter sammelt Informationen über die Änderungen in deinem Repository, indem er die Commit-Nachrichten oder die Labels von Pull Requests analysiert, die seit dem letzten Release auf den main-Branch gemerged wurden. Basierend auf dieser Analyse erstellt er einen Entwurf für das Release-Changelog, der die Änderungen kategorisiert und formatiert auflistet. Hier ist, wie das genau funktioniert mit der Konfiguration, die du einrichten möchtest:

Schritte zur Erstellung des Changelogs durch Release Drafter

  1. Identifikation von Commits und Pull Requests: Release Drafter betrachtet alle Commits und/oder Pull Requests, die seit dem letzten Release auf den Zielbranch (typischerweise main) gepusht wurden.

  2. Kategorisierung basierend auf Labels: Wenn du Labels in deinen Pull Requests verwendest, kann Release Drafter diese nutzen, um Änderungen zu kategorisieren. In deiner Konfigurationsdatei kannst du spezifische Labels den Kategorien wie "Features", "Bug Fixes" oder "Dokumentation" zuweisen. Jedes Mal, wenn ein Pull Request mit einem dieser Labels gemerged wird, fügt der Release Drafter den Pull Request in die entsprechende Kategorie im Changelog ein.

  3. Changelog Format: Du hast die Möglichkeit, das Format des Changelogs durch Vorlagen in der Konfigurationsdatei anzupassen. Zum Beispiel hast du eine Vorlage, die bestimmt, wie jede Änderung aufgelistet wird (change-template), und eine allgemeine Vorlage, die das Layout des gesamten Changelogs bestimmt (template).

  4. Automatische Versionserhöhung: Abhängig von der Konfiguration kannst du festlegen, wie die Versionsnummer für das nächste Release erhöht werden soll. In deinem Fall könntest du eine einfache inkrementelle Logik haben, wie 0.1.$PATCH, die einfach die Patch-Nummer erhöht.

Beispiel der Release Drafter Konfiguration und Prozess

Angenommen, deine Konfigurationsdatei release-drafter.yml sieht wie folgt aus:

name-template: 'v$NEXT_PATCH_VERSION'
tag-template: 'v$NEXT_PATCH_VERSION'
categories:
  - title: 'Features'
    labels:
      - 'feature'
  - title: 'Bug Fixes'
    labels:
      - 'fix'
  - title: 'Dokumentation'
    labels:
      - 'docs'
change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
template: |
  ## Änderungen
  $CHANGES
version-template: '0.1.$PATCH'

Funktionsweise:

Resultat:

Durch den Einsatz von Release Drafter in deinem Entwicklungsprozess kannst du den Aufwand für die Erstellung und Pflege von Changelogs deutlich reduzieren und gleichzeitig sicherstellen, dass dein Projekt eine klare und nachvollziehbare Release-Historie hat.

kurmann commented 5 months ago

Ich finde das grossartig. Wenn ich also das testen möchte, müsste ich einen Conditional Commit machen damit ich "Futter" für den Changelog erhalte?

Die Changelog-Datei muss bereits bestehen oder wird diese erstellt?


Um den Release Drafter effektiv zu testen, ist es in der Tat hilfreich, Commits zu machen, die Conventional Commits Konventionen folgen oder entsprechende Labels auf Pull Requests zu verwenden, sodass der Release Drafter diese Änderungen in das Changelog einfügen kann. Hier sind einige Schritte und Hinweise, wie du dabei vorgehen kannst:

Testen des Release Drafters

  1. Machen von Conditional Commits:

    • Stelle sicher, dass du Commits mit einer klaren Struktur machst, zum Beispiel mit Präfixen wie feat:, fix:, oder docs:. Diese sollten eine Beschreibung enthalten, die genau wiedergibt, was geändert wurde.
    • Alternativ, wenn du Pull Requests verwendest, kannst du diese mit Labels versehen, die du in deiner Release Drafter Konfiguration definiert hast (zum Beispiel feature, fix, docs).
  2. Erstellen eines Pull Requests:

    • Erstelle einen Pull Request auf GitHub, der diese Commits enthält, und merge ihn in deinen main-Branch. Vergewissere dich, dass die Pull Requests entsprechend gelabelt sind, wenn du diese Methode zur Kategorisierung in deinem Changelog verwendest.

Changelog-Datei und Release Drafter

Best Practices für den Test

Durch diesen Ansatz kannst du sicherstellen, dass der Release Drafter korrekt konfiguriert ist und effektiv mit deinen Projektanforderungen zusammenarbeitet, um den Release-Prozess zu vereinfachen und zu automatisieren.

kurmann commented 5 months ago

Jetzt verstehe ich. Der Output des Release Drifters ist also ein Release-Entwurf auf GitHub?


Genau, das hast du richtig verstanden. Der Release Drafter erstellt automatisch einen Release-Entwurf auf GitHub, basierend auf den Änderungen, die seit dem letzten Release durchgeführt wurden. Dieser Entwurf wird im Bereich "Releases" deines GitHub-Repositories angezeigt und kann dort überprüft und bearbeitet werden, bevor er offiziell veröffentlicht wird.

Wie der Release Drafter funktioniert:

  1. Analyse der Commits/Pull Requests: Der Release Drafter durchläuft alle Commits oder Pull Requests, die seit dem letzten veröffentlichten Release gemacht wurden und kategorisiert sie anhand der festgelegten Regeln in der Konfigurationsdatei (release-drafter.yml). Diese Regeln können auf Labels, Commit-Nachrichten und andere Kriterien basieren.

  2. Erstellung des Release-Entwurfs: Basierend auf dieser Analyse erstellt der Release Drafter einen Entwurf für das Changelog, das Teil des nächsten GitHub-Releases wird. Dieser Entwurf umfasst die Versionsnummer (die gemäß der Konfiguration bestimmt wird), eine Zusammenfassung der Änderungen und alle sonstigen relevanten Informationen, die in der Konfigurationsdatei festgelegt wurden.

  3. Bearbeitung und Veröffentlichung: Der Entwurf ist auf der GitHub-Seite deines Projekts unter "Releases" als "Draft" (Entwurf) gekennzeichnet. Du kannst diesen Entwurf vor der Veröffentlichung bearbeiten, um sicherzustellen, dass alle Informationen korrekt sind und das Changelog deinen Erwartungen entspricht. Sobald du den Entwurf überprüft und für gut befunden hast, kannst du ihn veröffentlichen. Das veröffentlichte Release enthält dann das Changelog und die entsprechende Versionsnummer.

Vorteile des Release Drafter:

Tipps für die Nutzung:

Der Release Drafter ist ein mächtiges Werkzeug, das dir hilft, den Überblick über die Entwicklungen in deinem Projekt zu behalten und den Prozess der Release-Erstellung zu vereinfachen und zu standardisieren.

kurmann commented 5 months ago

Frage: Was ist wenn ich jetzt einen Conditional Commit mache mit "feat: Einführung des Release Drafters" und dann im Pull Request nochmals ein "Feature"-Tag einfüge? Aggregiert er das zusammen und falls ja, wie?


Der Release Drafter nutzt sowohl Commit-Nachrichten als auch Tags (Labels) auf Pull Requests, um das Changelog zu generieren. Wie er mit diesen Informationen umgeht, hängt davon ab, wie du deine Konfiguration (release-drafter.yml) eingestellt hast. Hier sind einige Szenarien, wie der Release Drafter mit deinen Commits und den Tags auf Pull Requests umgehen könnte:

Szenario: Commit und Pull Request Label

  1. Commit gemacht:

    • Wenn du einen Commit machst mit der Nachricht "feat: Einführung des Release Drafters", identifiziert der Release Drafter dies als ein Feature aufgrund des feat: Präfixes in der Commit-Nachricht.
  2. Pull Request erstellt:

    • Wenn du dann einen Pull Request erstellst, der diesen Commit enthält und diesem PR das Label "Feature" hinzufügst, wird der Release Drafter dieses Label nutzen, um den PR unter der Kategorie "Features" im Changelog zu listen, vorausgesetzt, du hast diese Kategorisierung in der Konfigurationsdatei definiert.

Aggregation der Informationen

Beispiel für eine Release Drafter Konfiguration

name-template: 'v$NEXT_MINOR_VERSION'
tag-template: 'v$NEXT_MINOR_VERSION'
categories:
  - title: 'Features'
    labels:
      - 'feature'
change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
template: |
  ## Änderungen
  $CHANGES

Wie das Changelog zusammengestellt wird

Best Practices

Indem du sowohl die Labels in deinen Pull Requests als auch die Conventional Commit Nachrichten in deinen Commits klug nutzt, kannst du den Release Drafter effektiv einsetzen, um dein Changelog automatisch zu generieren und gleichzeitig die Übersichtlichkeit und Genauigkeit deiner Projekt-Dokumentation zu erhöhen.