Republic / Artiklar /

Artikeln uppdaterad 2025-02-05.
Skriven av Christofer Sandin.

Det här är en lite äldre artikel, så vissa referenser och länkar kan vara föråldrade. Ha det i åtanke när du läser. Tack!

Versions­hantering med Git

Vi hade använt Subversion under en ganska lång tid, och det fungerade väldigt bra, men eftersom alla de tuffa grabbarna och tjejerna kör distribuerade versionshanteringssystem som Git eller Mercurial så tänkte jag att vi skulle kika på hur man kommer igång med Git.

Detta är ingen komplett guide, utan snarare en lathund med de vanligaste kommandona och koncepten. Jag förutsätter att du kan installera Git på egen hand och att du har lite koll på hur man använder terminalen. Artikeln skrevs alltså framförallt för vår egen del under tiden vi bytte till Git, men om någon annan får lite hjälp av den på samma gång är det givetvis bara roligt.

En bättre miljö

En stor fördel med Git är att det är relativt enkelt att skapa olika grenar (branches) i ett projekt. Det kan till exempel vara bra att ha en gren där du utvecklar en ny funktion medan du har en gren där du bara gör buggfixar under tiden. När du sedan är färdig med den nya funktionen kan du slå ihop dessa två grenar, genom en så kallad merge, och på så sätt få med både buggfixarna och den nya funktionen.

En mer informativ prompt

En bra start är därför att se till så du enkelt kan hålla reda på vilken branch du arbetar med för tillfället. Jag tycker att Devot:ee har en bra beskrivning av hur du får en mer informativ prompt en bit ner i deras artikel om Git.

Även NetTuts har en bra artikel om du vill göra om din prompt.

Inställningar

Sitter du som jag på en Mac och jobbar i TextMate är det lika bra att du även ser till så att TextMate är din förvalda editor:

git config --global core.editor "mate -w"

Jobbar du i Sublime Text så är det följande som gäller:

git config --global core.editor "subl -n -w"

Passa även på att lägga till ditt namn och din e-postadress:

git config --global user.name "Your Name"
git config --global user.email "your@email.com"

Skapa ett repository lokalt

Det går utmärkt att använda Git lokalt på din dator när du utvecklar egna projekt. Även om Git givetvis kommer ännu mer till sin rätt i någon form av nätverk där flera personer eller åtminstone olika datorer är inblandade är ett lokalt repository ett bra sätt att lära sig.

Skapa ett nytt projekt

I terminalen byter du till den katalog som du vill skapa ditt projekt i och kör:

git init

Nu initieras projektet och det skapas en katalog som heter .git. Till skillnad från Subversion som skapar en .svn-katalog i varje projekt-katalog så finns det bara en .git-katalog i projektets rot-katalog. Vill du ta bort versionshanteringen är det bara att ta bort den här dolda katalogen.

Ignorera vissa filer i projektet med .gitignore

Skapa en fil som heter .gitignore i rotkatalogen och lägg till alla filer du vill exkludera i denna. För ett ExpressionEngine-projekt kan den se ut såhär:

# cache files
.DS_Store
admin/expressionengine/cache/**/*

# config files
admin/expressionengine/config/config.php
admin/expressionengine/config/database.php

# uploaded images
images/avatars/uploads
images/captchas
images/member_photos
images/pm_attachments
images/signature_attachments
images/uploads

Håll koll med status

För att se vilka filer som är tillagda, borttagna och redigerade sedan föregående commit används kommandot status:

git status

Lägga till filer i Gits index med add innan commit

När du sedan arbetat med dina filer är det dags att lägga till dessa i Gits så kallade index innan du kan göra en commit. Detta är ett extra steg jämfört med Subversion, men är ganska praktiskt då du enkelt kan välja ut vilka filer som skall ingå i samma commit.

För att lägga till alla filer skriver du en punkt efter add:

git add .

Eller om du vill vara mer specifik kan du givetvis vara det:

git add .gitignore
git add *.php

För att även få med filer som du raderat i projektet kan du använda flaggan -u, annars kommer dessa filer att synas varje gång du kör en status:

git add -u

För att ta bort en eller flera filer som du lagt till med använder du:

git reset HEAD file1 file2 …

Därefter, dags för en första commit

När filerna du vill lägga till är adderade med add så är det dags att göra en commit. Detta görs genom: 

git commit -m "This is a commit message"

En ny koll med status visar att det nu inte finns några rapporterade ändringar sedan senaste commit. Här är ett exempel på detta:

~/Sites/project (master): git status
# On branch master
nothing to commit (working directory clean)
~/Sites/project (master):

Skapa och slå ihop grenar

Som jag skrev inledningsvis så är en av de mest uppskattade funktionerna i Git möjligheten att enkelt skapa och slå ihop olika grenar av koden. Här är de grundläggande kommandona. Vanligtvis heter de

Skapa en gren med bransch

För att skapa en ny gren, eller bransch som det heter på engelska, så kör du:

git branch branchname

För att byta till en annan gren används:

git checkout branchname

Detta gör också att alla filer i din arbetskatalog ändras och du får en representation av den aktuella grenens filer. För att se vilka olika grenar som finns och vilken du arbetar med för tillfället är det bara att knappa in:

git branch

Lägg också märke till att den aktuella grenen hela tiden finns med i din prompt:

~/Sites/project (master): git checkout branchname
~/Sites/project (branchname): git checkout master
~/Sites/project (master):

Slå ihop

För att sedan slå ihop en gren med den aktuella grenen du arbetar med så använder du kommandot merge på detta sätt:

~/Sites/project (master): git merge branchname

Detta skulle alltså slå ihop grenen branchname med den aktuella grenen master.

Och, slutligen, ta bort en gren som inte används längre

~/Sites/project (master): git branch -d branchname

Lägg upp ett repository på en server som alla i projektet kan komma åt

Vi använder en extern server för vissa av våra projekt. Tjänster som Beanstalk och Springloops gör det enkelt för de som inte gillar kommandoraden att logga in i webbgränssnittet och se vad som händer.

För att lägga upp det repository du skapat lokalt lägger du först till ett nytt projekt i Beanstalk.

Lokalt lägger du sedan till Beanstalks server i ditt git-projekt:

git remote add beanstalk git@republicfactory.beanstalkapp.com:/project.git

vilket lägger till följande rader i din .git/config-fil:

[remote "beanstalk"]
url = git@republicfactory.beanstalkapp.com:/project.git
fetch = +refs/heads/*:refs/remotes/beanstalk/*

Nu kan du alltså använda beanstalk istället för git@republicfactory. beanstalkapp.com:/project.git.

När du sedan gjort ändringar lokalt, kört add och commit kan du nu köra push för att lägga till dina ändringar till ditt repository hos Beanstalk. Detta fungerar precis på samma sätt till vilken annan server som helst.

git push beanstalk master

Klona ett repository till en annan server

Har man sedan en utvecklingsserver som går att komma åt via SSH så är det bara att logga in där, skapa en ny katalog och klona projektet från Beanstalk. Detta kan jämföras med att man ”checkar ut” ett repository med Git:

git clone git@republicfactory.beanstalkapp.com:/project.git .

Punkten på slutet gör så att du skapar .git-katalogen i den katalog där du står istället för att det repository du checkar ut hamnar i en egen katalog. För att sedan hålla utvecklingsservern uppdaterad med de ändringar som är commitade till Beanstalk är det bara att köra:

git pull

Du kan givetvis också klona ett repository på din lokala dator och hålla detta uppdaterat genom git pull.

Referenser

Jag har inte använt Git under någon längre tid och den här lilla lathunden kommer att uppdateras då och då. Det är på långa vägar inte allt som man kan göra, men det ger i alla fall en liten introduktion. Nedan finns en lista med intressanta artiklar om du vill läsa mer om Git.