Git

Crear un projecte

git init

git config --global user.name "nomusuari"
git config --global user.email "email@gmail.com"
git config --global color.ui true # No és necessari, però és millor visualment

Traballar en grup

Per treballar en grup, cal que tots els usaris estigui en el mateix grup d'usuaris del servidor. Tots els usaris el seu gid ha de ser "users".

Per fer un push, es important que cada usuari després del clone, afegeixi el seu nom i correu.

git config --global user.name "nomusuari"
git config --global user.email "email@gmail.com"

Pel tema de permisos, al fitxer .profile de cada usuari del servidor, deixarem unmask 222

Traballar en una còpia local

git clone 192.168.0.5:/home/cuina/django/nomdelprojecte

Si el repo té més d'una branca, quan fem git branch només ens mostrarà la branca master. Això és degut a que la resta de branques són considerades remotes. Per veure les branques remotes farem:

git branch -r

Per poder canviar a una branca "remota" farem git checkout nom_branca (com sempre), aleshores "es crearà la còpia local" i quan fem un git branch ja apareixerà, ja que això només passa el primer cop que fem un checkout de la branca. Per veure totes les branques (locals i remotes) farem: git branch -a

git add nomfitxer
git commit -a -m "[ADD] Comentari"

git push <- fa el push de totes les branques al repositori remot (especificat al fitxer .git/config del nostre repo)
git push origin branch_name <- fa el push dels canvis de la branca branch_name al repo especificat (origin)

git fetch <- fa el fetch de les noves dades de totes les branques per fer el merge manual. Aquestes branques remotes es diuen p. ex. origin/development
git pull <- fa un fetch i després un merge de la current branch

Actualitzar projecte servidor

Haurem de fer un checkout (no un pull)

git checkout -f

Per que ens ho apliqui, al fitxer config del projecte: bare = true, ja que no treballe en tree

Treballar amb branques

En el nostre cas ens permetrà crear projectes fills (webs) i vagin en harmonia amb el projecte pare (Zoook)

Zoook -------------
   web1 -----------
   web2 -----------
         web3------

La branca principal que ens crea és "master".

Les comandes per treballar amb branques són:

git branch nomdelabranca <- Creem una nova branca
git checkout nomdelabranca <- canviem a la branca nomdelabranca
git checkout -b nomdelabranca <- Crea la branca i canviem a ella. És equivalent a: git branch nomdelabranca; git checkout nomdelabranca
git branch <- mostra les branques diponibles i l'activa
git mergetool -t meld <- Diferencies i solució
git diff --stat master nomdelabranca
git branch -d nomdelabranca <- Eliminem la branca

Per unir dos branques:

1- Ens col·locarem a la branca a on volem aplicar els canvis, per exemple 
git checkout nomdelabranca
2- git merge master <- Ens unirà els canvis de master a la nostra branca del web

Cas especial de Fast-forward merge sense commit nou:

"Normally, a merge results in a merge commit with two parents, one for each of the two lines of development that were merged. However, if the current branch has not diverged from the other--so every commit present in the current branch is already contained in the other--then git just performs a "fast forward"; the head of the current branch is moved forward to point at the head of the merged-in branch, without any new commits being created".

Agafar modificacions d'altres branques

git log origin/nom_branca

git cherry-pick <hashdelcommit>

Diferencies

Diferència entre els 2 últims commits (HEAD respecte HEAD^):

git diff HEAD^ HEAD

Diferència entre el que hi ha a l'índex i un fitxer:

git diff fitxer

Diferència entre l'últim commit i un fitxer:

git diff HEAD fitxer

git ignore

A l'arrel del projecte podem crear el fitxer .gitignore per ometre certs fitxers

*pyc
config.py
.gitignore

Descartar certs directoris del merge

Abans de fer el merge, si alguns directoris no volem que ens els fusioni, els haurem d'eliminar, que no estigui com a repositori de versions.

git rm  --cached nomdirecotori

gitHub

Per fer un commit a github aplicarem les següents comandes:

git commit -a -m "Descripció"
git push -u origin master

Moure master d'un servidor a un altre

Si tenim problemes al fer un push (git 1.7.0) http://www.bitflop.com/document/111 You can simply convert your remote repository to bare repository ( There is no working copy in the bare repository - the folder contains only the actual repository data ) .

git config --bool core.bare true

Ens canviarà el fitxer de configuració:

[core]
        repositoryformatversion = 0
        filemode = true
        bare = true
        logallrefupdates = true

Actualitzar branques a partir del fork

git remote add zikzakmedia https://github.com/zikzakmedia/python-easyimap
git remote show
git push zikzakmedia master

# Add the remote, call it "upstream":
git remote add upstream git://github.com/whoever/whatever.git

# Fetch all the branches of that remote into remote-tracking branches,
# such as upstream/master:
git fetch upstream

# Make sure that you're on your master branch:
git checkout master

# Rewrite your master branch so that any commits of yours that
# aren't already in upstream/master are replayed on top of that
# other branch:
git rebase upstream/master

git merge upstream/master

Llistat de comandes

git init #iniciar projecte
git add dir/file
git commit -m "four commit"
git checkout -- test2 #desfer els canvis fets
git log
git diff test2

git clone 192.168.0.3:/home/zikzak/django/test <- test is git project
git pull <- pull the newest version from the repository
git commit -a -m "aqui el missatge" # El paràmetre -a serveix perquè s'actualitzin al commit els fitxers modificats
git push <- push the changes to the repository

Al servidor, per descarregar la branca:
git checkout
git checkout master

Desfer canvis de tota la branca (amb --hard es modifica el working trie, sinó, només es modifica el HEAD i índex):
git reset --hard HEAD # torna a l'últim commit
git reset --hard HEAD^ # la penúltima versió
git reset --hard HEAD~2 # eliminar dues versions
git reset --hard HEAD~3 # eliminar tres versions

Desfer canvis a un fitxer abans del commit:
git checkout fitxer # deixa el fitxer com a l'índex --> git diff no retorna res
git checkout HEAD fitxer # deixa el fitxer com estava a l'últim commit --> git diff & git diff --cached no retornen res

Per eliminar l'últim commit hi ha dues maneres:
1) Recomanada, crea un commit nou (fast forward)
git revert HEAD
2) No recomanada, modifica l'últim commit amb el que hi hagi a l'índex (non fast-forward)
git commit --amend -a -m "Fixing last commit"
git push --force

git clone /home/resteve/hello-word
git clone git://git.kernel.org/.../git.git my.git

Crear branques
git branch #Per veure les branques
git branch experimental # ens crea una branca
git checkout experimental #canviar de branca
git merge experimental #unir branca experimental a la master

Treure un fitxer de l'índex abans del commit:
git reset HEAD fitxer # Serveix per desfer l'add

Llista dels fitxers a l'índex:
git ls-files

Svn a git

Guia comandes svn i git

Usage Scenarios of Git Reset and Revert

Git revert only works on work that you have committed and not if you have code that is "not checked in" yet.

For git revert, a typical usage scenario is when you get a new idea or you think you are going to refactor some code, and after you commit your supposedly "better" code, you discover that oops, it broke other areas and the refactoring was more involved that you had thought.

In that case, the proper git command to use is git revert HEAD which simply tells git to move the HEAD and index and working state to the previous state and record this revert as a new commit for records keeping.

For git reset --hard, a typical usage is the same as the above scenario but this time, you haven't commited your supposed improvements yet. Also, you just want to trash your changes. As I explained, this command will move the implied HEAD pointer (you don't have to type it at the command line) to the last commit. The --hard option will align your working directory and index with it too. So you will lose your changes and bring back the last commited one.

Another scenario is when you want to move the pointer HEAD to some old commit in the past where you want to start fresh. This is not a likely scenario as you should've used the powerful git branch features, never the less, this demonstrates the "random" access to your commits of the reset command.

Git (last edited 2013-12-20 15:58:57 by jmartin)

Contenidos creados por el equipo de Zikzakmedia. Creative Commons By-NC-SA

PythonZikzakmedia