Pull Request

💡 Den här artikeln antar att läsaren har en hum om: vad Git är, vad repository innebär, grundläggande terminalkunskaper i Bash samt har Git installerat på datorn.

Vad är en Pull Request?

En Pull Request (PR) är en begäran ifrån (oftast) en användare till (oftast) ett projekt för att projektägarna ska dra (eng. pull) förändringar ifrån användarens repository (repo) till projekt-repot. PR används för att kunna hämta in bidrag till projekt vare sig det kommer ifrån en annan branch i samma repo eller om det är ett externt bidrag ifrån någons privata repo.

Hur används Pull Request?

Pull Request används som ett sätt att på ett kontrollerat sätt låta folk komma med förbättringar och bidra till ett projekt men utan att ge dom rättigheten att direkt skicka sina förändringar till projektet.

Guide: Skapa en Pull Request

Låt oss till en början säga att du vill tillföra något till SSA-Akademins projekt på GitHub där du har registrerat en användare vid namn user. Den här guiden antar att du har språk "Engelska" på GitHub. Vi kommer inte att gå in på hur brancher fungerar här heller. Det är inte nödvändigt att kunna när det kommer till Pull Request men bra om man lär sig det senare då det hjälper ens arbetsflöde i Git oerhört mycket.

Konfigurera Git och GitHub

Innan vi gör själva Pull Request:en måste vi konfigurera Git och GitHub så att vi har ett arbetssätt där vi kan använda oss av Pull Request.

Logga in och besök projektets GitHub-sida (i vårt fall https://github.com/SverigesSandareamatorer/SSA-Akademin)
Eftersom vi inte har rättigheter att skriva till projektets repo så måste vi göra vår egen, så kallade, fork (typ klon) av projektets repo.

Klicka på knappen ”Fork” uppe till höger.
När du har gjort det så ser du upptill på sidan att det inte längre står SverigesSandareamatorer/SSA-Akademin utan att det nu står user/SSA-Akademin. Det är för att vi nu är inne på din egen fork (klon) av projektets repo. Här kan du göra vad som helst utan att det påverkar någon annan och det är en av styrkorna med Git.

Det vi har skapat nu är ett fjärrepository på GitHub som vi kan använda för att göra Pull Request (vilket vi kommer till senare) men först måste vi ansluta fjärrepot till ett repo vi har lokalt på datorn så att vi kan jobba med förändringarna. Det är viktigt att komma ihåg att dessa är två olika repon som vi flyttar förändringarna emellan genom kommandona git pull <repo> och git push <repo>.

När du är på din egen fork av projektrepot (i vårt exempel med användare user: https://github.com/user/SSA-Akademin), kolla till höger så ska det finnas en klargrön knapp med texten "Clone or Download". Klicka på knappen och kopiera länken som står där. Det borde vara någonting i den här stilen: (notera att den här adressen slutar med .git)
```
https://github.com/user/SSA-Akademin.git
```
Gå till din Git Bash och navigera dig till den mapp som du vill lägga ditt Git-repo i. Sedan är det dags att hämta hem ditt repo ifrån GitHub servern till din lokala dator.
```
git clone https://github.com/user/SSA-Akademin.git
```
Det här klonar hem din fork av projekt-repot till din lokala dator till en nyskapad mapp (som i vårt fall heter SSA-Akademin).
Gå in i den nyskapade mappen så finner du alla projektets filer och repot utcheckad i branchen master. Nu behöver vi kontrollera att vårt lokala repo är konfigurerat så att vi kan push:a de förändringar vi gör till vårt fork:ade fjärrepo på GitHub. Det kan vi göra genom att köra följande kommando i repot och kontrollera att svaret ser ut så här:
```
$ git remote -v
origin  https://github.com/user/SSA-Akademin (fetch)
origin  https://github.com/user/SSA-Akademin (push)
```
När vi klonar med git clone som vi gjorde tidigare så sätts automatiskt fjärrepot upp som "remote" origin.

Låt oss säga nu att vi har gjort förändringar som vi tror skulle gynna projektet och vill att dom ska dras in i projektet. Då ser vi till att allt är commit:at och klart innan vi skickar upp. För enkelhetens skull så säger vi att allt har gjorts i branchen master (den branchen som du börjar i och som du förmodligen fortfarande är i om du inte medvetet har ändrat branch).

Börja med att skicka upp förändringarna till servern:

git push origin

Du kommer nu att få en prompt som frågar om användarnamn och sedan om lösenord (tecknen i lösenordsfältet är osynliga men skriv på och tryck enter när du är färdig så ska du se att det fungerar). Fyll i dessa uppgifter och kör.

💡 TIPS
Det kan snabbt bli jobbigt att skriva användarnamn och lösenord om man skickar upp till servern ofta och då kan man ställa in så att Git "kommer ihåg" användarnamn och lösenord. Det görs så här: git config --global credential.helper cache git config --global credential.helper 'cache --timeout=3600' `--timeout=` specificerar hur många sekunder Git ska komma ihåg användarnamn och lösenord sedan den senaste inloggningen.

Så nu har du satt upp så att du kan skicka förändringar från ditt lokala repo på din dator till ditt fjärrepo på GitHub. Men vad händer om projektet uppdateras (vilket det förmodligen kommer att göra)? Då kommer ditt lokala repo på din dator att ligga efter projektets repo på GitHub. För att komma till stånd med det här måste vi lägga till en till git remote som vi kan använda för att hämta dom senaste förändringarna ifrån projektets repo till vårt lokala repo på datorn.

Gå in på projektets GitHub-sida (i vårt fall https://github.com/SverigesSandareamatorer/SSA-Akademin) och hämta samma länk som vi tog ifrån vår fork fast den här gången direkt ifrån projektets repo. Den finns under knappen "Clone or Download". I vårt fall, den här länken:
```
 https://github.com/SverigesSandareamatorer/SSA-Akademin
```
Nu ska vi lägga till en git remote som vi kan hämta förändringarna ifrån och det gör vi så här:
```
 git remote add upstream https://github.com/SverigesSandareamatorer/SSA-Akademin
```
Det vi gör här är att lägga till projektets repo som ligger uppströms i utvecklingen, (eng. upstream) då vi "ärver" förändringar av det repot till vår egna fork, så att vi kan hämta förändringarna.

Hämta förändringarna från projektets repo med följande kommando:

git pull upstream

💡 TIPS
Ibland kan en `git pull` resultera i följande fel: `error: Your local changes to the following files would be overwritten by merge: exempel.fil Please, commit your changes or stash them before you can merge. Aborting` Det kan vara jätteförvirrande till en början men vad det här felet innebär är att det finns filer som har konflikter i sig då du har gjort förändringar lokalt på din dator som du inte har commit:at. I de flesta fall så kan du lösa felet genom att använda dig av `git stash` som "sätter undan" dina förändringar och tillåter dig att "ta fram" dom igen vid ett senare tillfälle. Efter att du har fått det där felet så brukar det här oftast lösa det: git stash git pull upstream git stash pop Det dessa tre kommandon gör är att först lägga undan dina förändringar (stash), sedan hämta hem förändringarna uppströms ifrån projektets repo (pull) och sedan när det är gjort lägga dina förändringar "ovanpå" de som hämtades (stash pop). I de flesta fall brukar det här lösa problemet men om en konflikt uppstår som inte Git kan hantera så måste du göra en merge och det är en helt annan guide för det.

Nu är du klar! Allt är uppsatt för att kunna göra en Pull Request.

Gör en Pull Request

Här går vi igenom i runda slängar hur ett arbetssätt med Pull Request fungerar men det är viktigt att komma ihåg att det finns en massa goda principer med Git som man bör hålla sig till men dessa tar vi inte upp just nu då det skulle bli alldeles för komplicerat. Den förmodligen största förbättringen i arbetssätt är att använda brancher och det när något som jag definitiv rekommenderar att använda.

Börja med att hämta hem de senaste förändringarna uppströms ifrån projektets repo på GitHub med vår konfigurerade remote upstream:
```
git pull upstream
```
Gör förändringarna du vill bidra med och commit:a dom.
Push:a dina förändringar till ditt fork:ade fjärrepot av projektrepot:
```
git push origin
```
Gå in på GitHub-sidan för ditt fork:ade fjärrrepo (i vårt exempel med användare user: https://github.com/user/SSA-Akademin).
Klicka på "Pull Request" länken just till höger ovanför listan med filer.
I den här vyn jämför du de förändringar som du föreslår i ditt repo (head fork) med ursprungsfilerna i projektets repo (base fork). Till vänster väljer du vilket repo och branch du vill skicka Pull Requesten till (i vårt fall, projektets repo) och till höger väljer du vilket repo och branch du vill hämta förändringarna ifrån (i vårt fall, ditt fork:ade fjärrepo). I vårt fall vill vi ta förändringarna ifrån master branchen i ditt fjärrepo och skicka dom till master branchen i projektrepot. I vårt fall borde det se ut något så här:

base fork: SverigesSandareamatorer/SSA-Akademin, base: master — head fork: user/SSA-Akademin, compare master

Nedan borde du se en diff (skillnaden mellan dina förändringar i ditt fjärrepo och det som finns i projektets repo). Kontrollera och se att det stämmer överens med vad du vill skicka in för förändringar.
När du är klar med det kan du gå vidare genom att klicka "Create Pull Request".
Nu kommer du till nästa vy som tillåter dig att sätta en rubrik och en beskrivning om vad din Pull Request innehåller och varför den behövs.

Ovanför rubrik och beskrivningsfältet står det ibland följande:

Before you submit a pull request please review the contributing guidelines for this repository.

Läs dessa guidelines innan du bidrar till projektet. Dom kommer att ge dig information som hjälper dig att undvika att din Pull Request blir avfärdad omedelbart på grund av att den inte lever upp till kraven.
När det är gjort och eventuella förändringar är korrigerade genom att göra dessa och push:a upp dessa från lokalt till fjärrepot så kan du skapa din Pull Request.
Ta da! Nu har du skapat en Pull Request och diskussionen om den är öppen.

Provide feedback

Saved searches