Informatik/Mathematik / Software Engineering

Ziel: Vertiefung der Zusammenarbeit im Team mit Hilfe von Code-Reviews als Möglichkeit der Pull-/Merge-Requests von Git und GitHub

Praktikumsaufgaben Teil 8 - Zusammenarbeit 3

In diesem Aufgabenteil werden Pull-/Merge-Requests als Variante eines Code-Reviews, das Filtern von Issues und das Organisieren von Issues angelehnt am OpenUP betrachtet.

Hinweise zum Praktikum in den Windows-Laboren

Aufgrund der nicht gespeicherten Nutzer-Profile in den Windows-Laboren, sind zu jedem Praktikumsbeginn folgende Schritte durchzuführen:

Schritte zur Vorbereitung des Praktikums
  1. Git-Konfiguration C:\Users\<username>\.gitconfig wiederherstellen oder anpassen:

    per Editor in der .gitconfig
    [user]
    	name = Vorname Nachname
    	email = s00000@htw-dresden.de
    [safe]
        directory = *
    [http]
    	proxy = http://www-cache.htw-dresden.de:3128
    oder per PowerShell und Git-Kommandos
    > git config --global user.name "Vorname Nachname"
    > git config --global user.email s00000@informatik.htw-dresden.de
    > git config --global --add safe.directory *
    > git config --global http.proxy http://www-cache.htw-dresden.de:3128
  2. Visual Studio Code: Anpassen der AsciiDoc-Einstellungen:

    • Asciidoc > Preview: Use Editor Style: (deaktiviert)

    • Asciidoc > Extensions: Enable Kroki: (aktiviert)

  3. GitHub Login mit gespeichertem oder neuem Personal Access Token über die PowerShell bekanntgeben:

    Repository vorhanden
    > U:
    > cd path/to/repository/<repo-name>/
    > git pull
    Authentifizierung ...
    Repository nicht vorhanden (Home-/SAMBA-Laufwerk)
    > U:
    > cd path/to/repository/
    > git clone https://github.com/.../<repo-name>
    Authentifizierung ...
    Repository nicht vorhanden (TEMP-Laufwerk)
    > T:
    > git clone https://github.com/.../<repo-name>
    Authentifizierung ...


1. Code-Review (Pull-/Merge-Request)

Geek&Poke: Dev Cycle (Friday Evening Edition)

Für qualitativ guten Code sind Code-Reviews unabdingbar. Plattformen wie Github (oder bspw. GitLab) bieten dafür die Möglichkeit von Pull-/Merge-Requests.

Code-Review

Ist die gezielte Überprüfung des Quellcodes auf Fehler, Schwachstellen, die Einhaltung von Richtlinien und die Vollständigkeit/Lauffähigkeit mit dem Ziel, die Softwarequalität zu sichern. Code-Reviews sind eine Möglichkeit der Qualitätssicherung in der Softwareentwicklung.

Pull-/Merge-Request

Ist die Anfrage auf eine Überprüfung, Diskussion bzw. Genehmigung zum mergen eines Branches (bspw. feature-Branch) in einen anderen Branch (bspw. main-Branch). (In GitHub wird es Pull-Request und in GitLab Merge-Request genannt.)

Pull Request Workflow
Abbildung 1. Pull Request Workflow
1 feature-Branch erstellen und bearbeiten
2 Pull-Request anfordern
3 Code-Review mit Diskussion und ergänzenden Commits
4 Merge des Pull-Requests in den main-Branch
Ein beispielhaftes Anwenden von Pull-Requests mit GitHub
Person A
  1. Lokal: Lokale Änderungen im feature-XYZ-Branch aufnehmen und veröffentlichen:

    $ git branch
    * main
    $ git switch -c feature-XYZ
    $ git branch
    * feature-XYZ
      main
    $ git push -u origin feature-XYZ
    $   vi feature-XYZ.txt → git add . → git commit -m "..."
    $   vi feature-XYZ.txt → git add . → git commit -m "..."
    $ git push
  2. GitHub: Pull-Request anlegen:

    1. In der "Code"-Ansicht in den Branch: feature-XYZ wechseln

    2. New pull request auswählen: base: maincompare: feature-XYZ

    3. Title, Kommentar und (optional) Reviewers, Assignees hinzufügen

    4. Create pull request ausführen


Person B
  1. Code-Review durchführen:

    1. Änderungen auf GitHub oder Lokal untersuchen:

      • Variante GitHub: Im Reiter "Commits" sich die Änderungen und Unterschiede anschauen.

      • Variante Lokal:

        • Die Änderungen aus dem Pull-Request mit dem zugehörigen feature-XYZ-Branch in das lokale Repository aufnehmen und untersuchen und testen:

          $ git fetch
          $ git switch feature-XYZ

          Alternative Variante unter Angabe des entsprechenden Remote-Repositories, wenn mehrere verwendet werden:

          $ git fetch origin
          $ git switch -c feature-XYZ origin/feature-XYZ
        • Zusätzlich kann der main-Branch in den feature-XYZ-Branch gemerged werden, um die Lauffähigkeit bzw. den konfliktfreien Merge mit der aktuellen stabilen Version (main-Branch) zu testen:

          $ git switch feature-XYZ
          $ git merge main
    2. Auf GitHub im Reiter "Conversation" sich ergebene Anmerkungen und Nachbesserungen per Kommentar kommunizieren/diskutieren.


Person A
  1. GitHub: Sich über neue Kommentare im Pull-Request informieren.

  2. Lokal: Gewünschte Nachbesserungen lokal im feature-XYZ-Branch durchführen und veröffentlichen. Der Pull-Request wird automatisch aktualisiert:

    $ git switch feature-XYZ
    $   vi feature-XYZ.txt → git add . → git commit -m "..."
    $ git push

Person B
  1. Code-Review durchführen und in GitHub Merge erlauben:

    1. Änderungen wiederholt auf GitHub oder Lokal untersuchen (Siehe 3.).

      • Lokal: Neue zwischenzeitliche Änderungen im Pull-Request laden:

        $ git switch feature-XYZ
        $ git pull
        ...
    2. Wenn okay, im Reiter "Conversation" Merge pull request starten.

    3. Commit-Nachricht und erweiterte Beschreibung angeben und mit Confirm merge den Merge veranlassen.


Person A
  1. Der nicht mehr benötigte feature-XYZ-Branch kann jetzt auf GitHub und Lokal gelöscht werden.:

    • GitHub: Im abgeschlossenen Pull-Request über Delete branch oder im Reiter "Code" → branch → Papierkorbsymbol

    • Lokal: Im lokalen Workspace mit:

      $ git switch main
      $ git pull
      $ git branch -d feature-XYZ
Links zur Verwendung von Pull-Requests mit GitHub


Aufgabe 1.1 - Pull-Request durchführen

Bearbeiten Sie in Ihrem Team-Repository eine Änderung in einem extra Branch. Veröffentlichen Sie diesen, legen einen Pull-Request an und weisen Sie diesem ein Teammitglied zur Begutachtung (Code-Review) und anschließendem Merge zu.

  1. Legen Sie in Ihrem Team-Repository einen neuen feature-sXXXXX-Branch mit ihrer S-Nummer oder GitHub-Login an und nehmen Sie ein paar beispielhafte Änderungen als neue Versionen (Commits) auf.

  2. Veröffentlichen Sie Ihren feature-sXXXXX-Branch mit den erstellten Versionen in das zugehörige remote-Repository.

  3. Eröffnen Sie auf GitHub einen Pull-Request, um den feature-sXXXXX-Branch in den main-Branch mergen zu lassen.

  4. Weisen Sie Ihrem eben veröffentlichten Pull-Request ein Teammitglied zur Begutachtung (Code-Review) zu.

  5. Schauen Sie sich die Änderungen eines Ihnen zugewiesenen Pull-Requests auf GitHub an, hinterlassen einen Kommentar und wenn okay, veranlassen Sie GitHub den Merge vorzunehmen.

  6. Ist Ihr Pull-Request in Ihrem Team-Repository erfolgreich von einem anderen Teammitglied gemerged wurden, entfernen Sie den feature-sXXXXX-Branch im remote-Repository und in Ihrem lokalen Repository.

Wenn kein Teammitglied vorhanden ist, können Sie in Teilaufgabe 5. sich den Pull-Request auch selber zuweisen und bearbeiten.


2. Fork (Pull-/Merge-Request)

Mit Hilfe eines Forks kann einem öffentlichen Repository eine Änderung als Pull-/Merge-Request, ähnlich einer Code-Review, vorgeschlagen werden.

Mehrere von Forks genehmigte Pull Requests
Abbildung 2. Mehrere von Forks genehmigte Pull Requests
Fork

Eine Fork ist eine Kopie eines existierenden (öffentlichen) Repositories unter Ihrem eigenen Account. In diesem Repository können Sie frei mit Änderungen experimentieren, ohne das ursprüngliche Projekt zu beeinflussen.
Am häufigsten werden Forks verwendet, um entweder Änderungen am Projekt eines anderen vorzuschlagen oder um das Projekt eines anderen als Ausgangspunkt für Ihre eigene Idee zu verwenden.

Hinweise: Erzeugen eines Fork mit zugehörigem Pull-Request

Es gibt zwei Möglichkeiten einen Fork zu erzeugen, um Ihren Änderungsvorschlag als Pull-Request im originalen Repository zu hinterlassen.

Variante 1 - Bearbeitung lokal
  1. Erstellen Sie auf GitHub von einem öffentlichen Repository über den entsprechenden Button Fork einen Fork.

    Fork-Button auf GitHub
    Abbildung 3. Fork-Button auf GitHub
  2. Clonen Sie das in Ihrem Account als Kopie entstandene Repository auf Ihren lokalen Rechner.

  3. (optional) Erstellen Sie lokal einen neuen Branch, bspw. patch-fix-XYZ, wechseln in diesen.

  4. Nehmen die gewünschte Änderung bzw. Korrektur vor.

  5. Nehmen Sie Ihre Änderungen als neue Version auf und pushen diese (samt zugehörigem patch-fix-XYZ-Branch) in Ihr remote-Repository auf GitHub.

  6. Erstellen Sie einen Pull-Request für Ihre Änderung:

    1. Im Reiter Code sehen Sie jetzt, dass Ihr Repo um mindestens einen neueren Commit voraus ist. Klicken Sie hier auf Contribute und anschließend auf Open pull request.

      Pull-Request erstellen - Schritt 1
      Abbildung 4. Pull-Request erstellen - Schritt 1
    2. Jetzt sehen Sie, auf welche beide Repositories und Branches sich der Pull-Request beziehen soll. Erstellen Sie ihn mit dem Create pull request-Button.

      Pull-Request erstellen - Schritt 2
      Abbildung 5. Pull-Request erstellen - Schritt 2
    3. Vergeben Sie eine Beschreibung für Ihren Änderungsvorschlages. Als Standard wird die (letzte) Commit-Message übernommen. Zusätzliche Details können in dem Kommentarfeld hinterlassen werden.

      Pull-Request erstellen - Schritt 3
      Abbildung 6. Pull-Request erstellen - Schritt 3

      Mit dem Button Create pull request wird jetzt Ihre Änderung als Pull-Request vorgeschlagen und kann vom originalen Repository-Besitzer bearbeitet werden.

Variante 2 - Bearbeitung auf GitHub
  1. Kleinere Änderungen, wie bspw. Schreibfehler, können in der Quelldatei direkt auf GitHub über die Editieren-Funktion bearbeitet werden.

    Editieren direkt in GitHub
    Abbildung 7. Editieren direkt in GitHub
  2. GitHub stellt fest, dass Sie keine Schreibrechte für das Repository haben und legt für Sie einen Fork mit zugehörigem Patch-Branch und Pull-Request an.

    You’re making changes in a project you don’t have write access to. We’ve created a fork of this project for you to commit your proposed changes to. Submitting a change will write it to a new branch in your fork, so you can send a pull request.
  3. Nach dem Editieren der Datei und der Vergabe einer kurzen Beschreibung, kann mit dem Button Propose Changes die Änderung als Pull-Request vorgeschlagen werden.

    Änderungen Vorschlagen nach Bearbeitung direkt auf GitHub
    Abbildung 8. Änderungen Vorschlagen nach Bearbeitung direkt auf GitHub
Hinweise: Finden, Bearbeitungsstand und Nachbessern eines Pull-Requests
Finden

Ihre erstellten Pull-Requests findet Sie in der oberen Leiste neben der Suche mit einem Klick auf Pull requests:

Pull-Requests auf GitHub finden
Abbildung 9. Pull-Requests auf GitHub finden
Bearbeitungsstand

Klicken Sie in den Suchergebnissen auf den Kommentartitel des betreffenden Pull-Request und man kann mögliche Kommentare und Reaktionen sehen.

Nachbessern

Wird der Pull-Request (über Kommentare) beanstandet, korrigieren Sie dies und laden es als neue Version in Ihr geforktes Repository. Der neue Commit taucht automatisch im Pull-Request auf, so dass der Repo-Eigentümer es erneut anschauen und übernehmen kann.

Hinweise: Aktualisieren eines Fork

Sind im Quellrepository, von dem sie geforkt haben, (zwischenzeitlich) neue Versionen entstanden, muss Ihr Fork erst auf den neuesten Stand aktualisiert werden. Erst danach können Sie neue oder merge-konfliktfrei Pull-Requests für Ihre vorgeschlagenen Änderungen erstellen.

Variante: Fork löschen und neu forken
  1. nach abgeschlossenem Pull-Request löschen

  2. für neue Änderungsvorschläge das Quellrepository erneut forken

Variante: GitHub - Fetch upstream ohne Merge-Konflikt

Mit Fetch upstream gefolgt von einem Fetch and merge kann der Fork auf die aktuelle Version des Quellrepository aktualisiert werden.

Fork aktualisieren
Abbildung 10. Fork aktualisieren
Variante: GitHub - Fetch upstream mit Merge-Konflikt TODO
  1. Falls noch nicht vorhanden den Fork lokal clonen:

    $ git clone ...
  2. Den durch GitHub erstellten Pull-Request tigion-main-Branch lokal bereitstellen:

    $ git checkout -b tigion-main main
    $ git pull https://github.com/tigion/htw-playground-fork-colors.git main
  3. In den eigenen main-Branch wechseln und den tigion-main-Branch hinein mergen:

    $ git switch main
    $ git merge --no-ff tigion-main
  4. Die auftretenden merge-Konflikte lösen.

  5. Den main-Branch zu GitHub pushen:

    $ git push origin main
Variante: GitHub - Pull-Request und Rebase im eigenen Fork TODO
  1. Mit Fetch upstream gefolgt von einem Compare

  2. switching the base | compare across forks and switch manually

  3. Create pull request

  4. wechsle Merge pull requestRebase und merge

  5. Confirm rebase and merge

Variante: Lokal - upstream-Remote und Rebase im lokalen Repository TODO
  1. add remote as "upstream":

    % git remote add upstream https://github.com/user/public-repo.git

  2. fetch branches of remote into remote-tracking branches:

    % git fetch upstream

  3. switch to your main-branch:

    % git switch main

  4. Rewrite your main branch:

    % git rebase upstream/main

Hinweise: Lokaler Code-Review eines Fork Pull-Requests

Möchte man einen Pull-Request aus einem externen Fork lokal testen, kann man dies wie folgt tun:

  1. Als erstes sucht man sich auf GitHub über den Reiter Pull Requests die ID des betreffenden Pull-Requests heraus. Lautet die ID #11 ist die Nummer 11 relevant, welche ich folgend beispielhaft verwende.

  2. Jetzt erzeugen wir auf Grundlage der Referenz zur Pull-Request ID-Nummer einen neuen Branch. Ich nenne den neuen Branch pr-11.

    % git branch
    * main
    % git fetch origin pull/11/head:pr-11
    % git branch
    * main
      pr-11
  3. Wir wechseln in den neuen pr-11-Branch und können den Inhalt des Pull-Requests jetzt lokal testen und untersuchen.

    % git switch pr-11
    % git branch
      main
    * pr-11
  4. Sind wir fertig, können wir den pr-11-Branch, der nur zum Testen des Pull-Requests diente, wieder löschen und anschließend den Pull-Request auf GitHub weiter bearbeiten.

    % git switch main
    % git branch -D pr-11
Ist der Pull-Request vom Repository-Eigentümer erfolgreich übernommen bzw. abgelehnt worden, kann das geforkte Repository bei keiner weiteren Verwendung aus dem eigenen Account über GitHub und lokal gelöscht werden.


Aufgabe 2.1 - Fork mit Pull-Request

In dieser Aufgabe wollen wir eine Änderung an einem öffentlichen (public) Repository auf GitHub vornehmen bzw. vorschlagen, in welchem wir keine Bearbeitungsrechte haben. Dazu benötigen wir einen Fork des betreffenden Repositories.

Als Beispiel soll das Demo-Projekt htw-playground-fork-colors dienen, welches anhand einer JSON-Datei Farbkreise auf der Webseite Fork Colors darstellt.

  1. Legen Sie auf GitHub über den Fork-Button einen Fork vom htw-playground-fork-colors Projekt an.

  2. Clonen Sie die in Ihrem Account entstandene Kopie lokal auf Ihren Rechner.

  3. (optional) Erstellen Sie einen extra Branch für diese Änderung und wechseln Sie in diesen.

  4. Nehmen Sie lokal eine Änderung laut README entsprechend Ihres Platzes im Praktikum (siehe _comment-Attribute) in der Datei /data/colors.json vor.

    Die Beachtung der Platznummer verhindert unnötige Merge-Konflikte. Alternativ müssten Sie Ihren Fork erst aktualisieren und ihn für eine neue Version händisch auflösen.
  5. Nehmen Sie die Änderung als neue Version in Ihr Repository auf und pushen Sie in Ihr remote-Repository auf GitHub.

  6. Erzeugen Sie jetzt einen Pull-Request auf das ursprüngliche Repository.

  7. Nach erfolgreicher Übernahme Ihrer Änderung, erscheint auf Fork Colors (Demo Seite) ein zusätzlicher Farbkreis mit Ihren Angaben.

  8. (optional) Jetzt können Sie den Fork auf GitHub und lokal löschen.

Seitenübersicht