Closed kurmann closed 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.
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 }}
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'
$NEXT_PATCH_VERSION
wird automatisch durch die nächste Patch-Version ersetzt, basierend auf den Labels, die den Pull Requests zugeordnet sind.$TITLE
, $AUTHOR
und #$NUMBER
werden durch den Titel des Pull Requests, den Autor und die Nummer des Pull Requests ersetzt.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.
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.
main
Pull Requests: Wenn du einen Pull-Request-basierten Workflow verwendest, gibt dir das die Möglichkeit, Änderungen zu überprüfen und zu diskutieren, bevor sie in den main
-Branch gemerged werden. Release Drafter kann die Informationen aus den Pull Requests verwenden (wie Titel, Beschreibung, Labels), um detaillierte und aussagekräftige Release Notes zu generieren, die genau beschreiben, was jede Änderung bewirkt hat.
Direkte Commits: Wenn Commits direkt in den main
-Branch gepusht werden (ohne Review durch Pull Requests), ist es schwieriger, detaillierte und organisierte Release Notes zu erstellen, da oft weniger Kontext zu jedem Commit verfügbar ist. Commits könnten zum Beispiel generische oder nicht aussagekräftige Nachrichten haben.
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.
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.
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:
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.
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:
feature
, bug
, enhancement
).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.
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.
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 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)]
Einige der häufigsten Typen sind:
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...
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'
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.
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.
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'
feat
, fix
, docs
) verwenden, um die Kompatibilität mit Tools zu gewährleisten, und die eigentliche Beschreibung auf Deutsch verfassen.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.
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:
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.
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.
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.
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.
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.
Ü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!
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:
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.
Erstelle im Repository eine Konfigurationsdatei für den Release Drafter. Diese Datei wird normalerweise im .github
-Verzeichnis unter dem Namen release-drafter.yml
gespeichert.
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:
0.1.0
.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.
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 }}
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.
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:
release-drafter-config.yml
referenziert, die im Repository gespeichert werden kann.workflow_call
Ereignis, was bedeutet, dass er von anderen Workflows aus aufgerufen werden kann.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.
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:
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.
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.
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
).
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.
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'
main
:
feature
, fix
oder docs
trägt.categories
definierten Kategorien ein, basierend auf den Labels.change-template
, um für jeden Pull Request oder Commit eine Zeile im Changelog zu formatieren.template
, wobei $CHANGES
durch die gesammelten Änderungseinträge ersetzt wird.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.
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:
Machen von Conditional Commits:
feat:
, fix:
, oder docs:
. Diese sollten eine Beschreibung enthalten, die genau wiedergibt, was geändert wurde.feature
, fix
, docs
).Erstellen eines Pull Requests:
main
-Branch. Vergewissere dich, dass die Pull Requests entsprechend gelabelt sind, wenn du diese Methode zur Kategorisierung in deinem Changelog verwendest.Automatische Erstellung des Changelogs:
CHANGELOG.md
). Stattdessen generiert er einen Release-Entwurf direkt auf GitHub unter dem Abschnitt "Releases". Dort kannst du die gesammelten Änderungen als vorbereiteten Entwurf für das nächste Release sehen.Veröffentlichung des Changelogs:
Dokumentation und Kommentierung:
Incrementelle Tests:
Überprüfung des Release-Entwurfs:
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.
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.
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.
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.
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.
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.
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:
Commit gemacht:
feat:
Präfixes in der Commit-Nachricht.Pull Request erstellt:
Zusammenführung von Informationen: Der Release Drafter aggregiert Informationen basierend auf den Einstellungen in der release-drafter.yml
. Wenn sowohl Commits als auch PRs berücksichtigt werden, kann er beides zusammenführen, um ein umfassendes Changelog zu erstellen.
Formatierung: Du kannst das Format des Changelogs durch die template
und change-template
Einstellungen in der Konfigurationsdatei anpassen. Dies ermöglicht es dir, genau zu steuern, wie die Information aus den Commits und PRs präsentiert wird.
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
Commits und Pull Requests: Der Release Drafter schaut sich sowohl die Commit-Nachrichten als auch die Pull Requests an. Wenn ein Pull Request das Label "Feature" hat und Commits mit feat:
enthält, werden beide Informationen genutzt, um das Changelog zu bereichern.
Redundanzen vermeiden: Normalerweise wird der Release Drafter nicht redundant dieselbe Änderung zweimal auflisten, wenn sie aus demselben Commit und demselben Pull Request stammt, außer es ist anders in den Einstellungen festgelegt.
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.
Vorabdiskussion:
1