---
title: "Ag obair le Git agus GitHub"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/internals/contributing/writing-code/working-with-git/
canonical: https://djangodocs.dev/ga/6.0/internals/contributing/writing-code/working-with-git/
---
# Ag obair le Git agus GitHub

This section explains how the community can contribute code to Django via pull
requests. If you're interested in how [mergers](/ga/6.0/internals/organization/#mergers-team) handle
them, see [Iarrataí tarraingthe a](/ga/6.0/internals/contributing/committing-code/#handling-pull-requests).

Anseo thíos, táimid chun a thaispeáint conas iarratas tarraingthe GitHub a chruthú ina bhfuil na hathruithe ar thicéad Trac #xxxxx. Trí iarratas tarraingthe go hiomlán réidh a chruthú, déanfaidh tú post an athbhreithnitheora níos éasca, rud a chiallaíonn gur dóichí go ndéanfar d'obair a chumasc i Django.

D'fhéadfá paiste traidisiúnta a uaslódáil chuig Trac freisin, ach níl sé chomh praiticiúil le haghaidh athbhreithnithe.

## Git á shuiteáil

Úsáideann Django Git \_ chun a rialú foinse. Is féidir leat íoslódáil \_ \< <https://git-scm.com/download>\> Git, ach is minic a bhíonn sé níos éasca a shuiteáil le bainisteoir pacáiste do chórais oibriúcháin.

Óstáiltear [Stórlann Git \`\_ Django ar \`GitHub](https://github.com/django/django/), agus moltar duit oibriú ag baint úsáide as GitHub freisin.

Tar éis Git a shuiteáil, is é an chéad rud ba chóir duit a dhéanamh ná d'ainm agus ríomhphost a chur ar bun:

```shell
$ git config --global user.name "Your Real Name"
$ git config --global user.email "you@email.com"
```

Tabhair faoi deara gur chóir gurb é user.name\` d'ainm fíor, ní d'ainm GitHub. Ba chóir go mbeadh a fhios ag GitHub an ríomhphost a úsáideann tú sa réimse user.email\`, mar úsáidfear é seo chun do thiomantas a cheangal le do chuntas GitHub.

## Stóra áitiúil a bhunú

\< <https://github.com/django/django/fork>\>Nuair a bheidh do chuntas GitHub cruthaithe agat, leis an nick “GitHub\_nick”, agus stór Django forctha \_\_, cruthaigh cóip áitiúil de do fhorc:

```shell
git clone https://github.com/GitHub_nick/django.git
```

Cruthóidh sé seo eolaire nua “django”, ina bhfuil clón de do stór GitHub. Caithfear an chuid eile de na horduithe git ar an leathanach seo a reáchtáil laistigh den eolaire clónaithe, mar sin aistrigh air anois:

```shell
cd django
```

Tugfar “bunús” ar do stór GitHub i Git.

Ba chóir duit `django/django` a chur ar bun mar iargúlta “suas sruth” (is é sin, inis do git gurb é an stór tagartha Django foinse do fhorc de):

```shell
git remote add upstream https://github.com/django/django.git
git fetch upstream
```

Is féidir leat iargúlta eile a chur leis ar an gcaoi chéanna, mar shampla:

```shell
git remote add akaariai https://github.com/akaariai/django.git
```

## Ag obair ar thicéad

Agus tú ag obair ar thicéad, cruthaigh brainse nua don obair, agus bunaigh an obair sin ar upstream/main\`:

```shell
git checkout -b ticket_xxxxx upstream/main
```

Cruthaíonn an bratach -b brainse nua duit go háitiúil. Ná bíodh aon leisce ort brainsí nua a chruthú fiú do na rudaí is lú - sin a bhfuil siad ann.

Dá mbeadh tú ag obair ina ionad sin le haghaidh socrú ar an mbrainse 1.4, déanfá:

```shell
git checkout -b ticket_xxxxx_1_4 upstream/stable/1.4.x
```

Glac leis go ndéantar an obair ar an mbrainse ticket\_xxxxx. Déan roinnt athruithe agus déan iad a dhéanamh:

```shell
git commit
```

Agus an teachtaireacht gealltanais á scríobh, lean na treoirlínte commit message chun obair an chumaisc a éascú. Mura bhfuil tú compordach leis an mBéarla, déan iarracht ar a laghad cur síos beacht a dhéanamh ar a ndéanann an tiomantas.

Más gá duit obair bhreise a dhéanamh ar do bhrainse, déan tiomantas chomh minic agus is gá:

```shell
git commit -m 'Added two more tests for edge cases.'
```

### Obair fhoilsithe

Is féidir leat do chuid oibre a fhoilsiú ar GitHub trí rith:

```shell
git push origin ticket_xxxxx
```

Nuair a théann tú chuig do leathanach GitHub, tabharfaidh tú faoi deara go bhfuil brainse nua cruthaithe.

Má tá tú ag obair ar thicéad Trac, ba chóir duit a lua sa ticéad go bhfuil d'obair ar fáil ó bhrainse ticket\_xxxxx de do repo GitHub. Cuir nasc chuig do bhrainse san áireamh.

Tabhair faoi deara go dtugtar "brainse ábhar" ar an mbrainse thuas i parlance Git. Tá cead agat stair an bhrainse seo a athscríobh, trí `git rebase` a úsáid mar shampla. Níor cheart do dhaoine eile a gcuid oibre a bhunú ar bhrainse den sórt sin, mar go n-éireodh a gclón truaillithe nuair a dhéanann tú eagarthóireacht ar ghealltanais.

Tá “brainsí poiblí” ann freisin. Is brainsí iad seo atá ceaptha do dhaoine eile a fhorc, mar sin níor chóir go n-athródh stair na mbrainsí seo riamh. Is iad samplaí maithe de bhrainsí poiblí na brainsí `main` agus stable/A.B.X\` sa stór django/django\`.

Nuair a cheapann tú go bhfuil do chuid oibre réidh le tarraingt isteach i Django, ba cheart duit iarratas tarraingthe a chruthú ag GitHub. Ciallaíonn iarratas tarraingthe maith:

- commits with one logical change in each, following the
  [coding style](/ga/6.0/internals/contributing/writing-code/coding-style/),
- teachtaireachtaí dea-fhoirmithe do gach tiomantas: líne achoimre agus ansin míreanna atá fillte ag 72 carachtar ina dhiaidh sin - féach in:ref: treoirlínte tiomanta \<committing-guidelines\>\`le haghaidh tuilleadh sonraí,
- doiciméadú agus tástálacha, más gá -- bíonn tástálacha de dhíth i gcónaí, ach amháin má dhéantar athruithe ar dhoiciméid.

Caithfidh an seomra tástála pas a fháil agus ní mór na doiciméid a thógáil gan rabhadh.

Nuair a bheidh d'iarratas tarraingthe cruthaithe agat, ba cheart duit trácht a chur leis sa ticéad Trac gaolmhar ag míniú cad atá déanta agat. Go háirithe, ba chóir duit an timpeallacht inar reáchtáil tú na tástálacha a thabhairt faoi deara, mar shampla: “téann gach tástáil faoi SQLite agus MySQL”.

Níl ach dhá stát ag iarratais tarraingthe ag GitHub: oscailte agus dúnta. Níl ach dhá rogha ag an gcumasc a dhéileálfaidh le d'iarratas tarraingthe: é a chumasc nó é a dhúnadh. Ar an gcúis seo, níl sé úsáideach iarratas tarraingthe a dhéanamh go dtí go mbeidh an cód réidh le cumasc - nó gar go leor go gcríochnóidh cumaisc é féin.

### Editing commit messages

To change the message of the most recent commit, run:

```shell
git commit --amend
```

This opens an editor with the current commit message. Edit it, save, and close
to update the commit.

To change the message of an earlier commit, use the "reword" option in
interactive rebase. For example, to reword one of the last three commits:

```shell
git rebase -i HEAD~3
```

This opens an editor listing the three commits, each prefixed with the word
"pick". Change "pick" to "reword" (or "r") on the line of the commit you want
to change, then save and close. A new editor will open for each commit marked
as "reword", allowing you to update the message.

See [Treoirlínte a](/ga/6.0/internals/contributing/committing-code/#committing-guidelines) for the required commit message format.

After rewriting a commit that has already been pushed to GitHub, you will need
to force-push your branch:

```shell
git push --force-with-lease origin ticket_xxxxx
```

### Brainsí a athbhunú

In the example above, you created two commits, the "Fixed #xxxxx  -- ..."
commit and the "Added two more tests ..." commit.

Níl muid ag iarraidh stair iomlán do phróisis oibre a bheith agat i do stór. Bheadh torann neamhchabhrach do thiomantas “Cuireadh dhá thástáil eile leis”. Ina áit sin, b'fhearr linn ach tiomantas amháin a mbeadh do chuid oibre go léir ann.

Chun stair do bhrainse a athoibriú is féidir leat na gealltanais a scuabadh i gceann amháin trí athbhunú idirghníomhach a úsáid:

```shell
git rebase -i HEAD~2
```

Is gearrthóg é an HEAD ~ 2 thuas do dhá thiomantas is déanaí. Osclóidh an t-ordú thuas eagarthóir a thaispeánann an dá thiomantas, réamhshocraithe leis an bhfocal “pioc”.

Athraigh “pioc” ar an dara líne go “squash” ina ionad sin. Coinneoidh sé seo an chéad tiomantas, agus cuirfidh sé an dara tiomantas isteach sa chéad cheann. Sábháil agus scor an t-eagarthóir. Ba chóir go n-osclaíonn an dara fuinneog eagarthóra, ionas gur féidir leat an teachtaireacht tiomanta don tiomantas a athfhocal anois go bhfuil an dá chéim ann.

Is féidir leat an rogha “eagarthóireacht” a úsáid i rebase freisin. Ar an mbealach seo is féidir leat tiomantas amháin a athrú, mar shampla chun clóscríobh a shocrú i docstring:

```shell
git rebase -i HEAD~3
# Choose edit, pick, pick for the commits
# Now you are able to rework the commit (use git add normally to add changes)
# When finished, commit work with "--amend" and continue
git commit --amend
# Reword the commit message if needed
git rebase --continue
# The second and third commits should be applied.
```

Má tá do bhrainse ábhar foilsithe cheana féin ag GitHub, mar shampla má tá mionathruithe á dhéanamh agat chun athbhreithniú a chur san áireamh, beidh ort na hathruithe a bhrú go foréigeach:

```shell
git push --force-with-lease origin ticket_xxxxx
```

Tabhair faoi deara go n-athscríobfaidh sé seo stair ticket\_xxxxx - má sheiceálann tú na hashes tiomanta roimh agus tar éis na hoibríochta ag GitHub tabharfaidh tú faoi deara nach n-oireann na hashes tiomanta níos mó. Tá sé seo inghlactha, toisc gur brainse ábhar í an bhrainse, agus níor cheart d'aon duine a bheith ag bhunú a gcuid oibre air.

### Tar éis athrú suas sruth

Nuair a athraíonn suas sruth (`django/django`), ba cheart duit do chuid oibre a athbhunú. Chun seo a dhéanamh, bain úsáid as:

```shell
git fetch upstream
git rebase upstream/main
```

Déantar an obair a athbhunú go huathoibríoch ag baint úsáide as an mbrainse a rinne tú air, sa chás samplach ag baint úsáide as upstream/main\`.

Baineann an t-ordú rebase do ghealltanais áitiúla go léir go sealadach, cuireann an gealltanas in aghaidh an tsrutha i bhfeidhm, agus ansin cuireann do ghealltanas áitiúil i bhfeidhm arís ar an obair.

Má tá coinbhleachtaí cumaisc ann, beidh ort iad a réiteach agus ansin `git rebase --continue` a úsáid. Ag pointe ar bith is féidir leat `git rebase --abort` a úsáid chun filleadh ar an stát bunaidh.

Tabhair faoi deara go dteastaíonn uait\* a athbhunú\* ar an sruth, ne\*cumasch\* an suas sruth.

Is é an chúis atá leis seo ná go mbeidh do thiomantas i gcónaí\* ar bharr\* obair an tsraith, ne\*measctha la\* na hathruithe ar an sruth suas. Ar an mbealach seo ní bheidh ach gealltanais a bhaineann lena ábhar i do bhrainse, rud a fhágann go bhfuil sé níos éasca squashing.

### Tar éis léirmheas

Tá sé neamhghnách aon mhéid cód neamh-thráthúil a fháil isteach i gcroílár gan athruithe a iarrann athbhreithnithe. Sa chás seo, is minic gur smaoineamh maith é na hathruithe a chur leis mar thiomantas incriminteach amháin do do chuid oibre. Ligeann sé seo don athbhreithneoir na hathruithe atá déanta agat a sheiceáil go héasca.

Sa chás seo, déan na hathruithe a theastaíonn ón athbhreithneoir. Tiomantas chomh minic agus is gá. Sula bhfoilsíonn na hathruithe, déan do chuid oibre a athbhun Má chuir tú dhá thiomantas leis, rith tú:

```shell
git rebase -i HEAD~2
```

Squash an dara tiomantas isteach sa chéad cheann. Scríobh teachtaireacht tiomanta ar na línte de:

```text
Made changes asked in review by <reviewer>.

- Fixed whitespace errors in foobar.
- Reworded the docstring of bar().
```

Faoi dheireadh, brúigh do chuid oibre ar ais chuig do stór GitHub. Ós rud é nár chuir tú teagmháil leis na gealltanais phoiblí le linn an athbhunaithe, níor cheart go mbeadh ort brú go foréigeantach:

```shell
git push origin ticket_xxxxx
```

Ba chóir go mbeadh an tiomantas nua i d'iarratas tarraingthe anois freisin.

Tabhair faoi deara gur dócha go gcuirfidh an cumasc an gealltanas athbhreithnithe isteach sa ghealltanas roimhe seo agus an cód á ghealladh.

## Ag obair ar phaiste

Ceann de na bealaí is féidir le forbróirí cur le Django ná trí phaistí a athbhreithniú. De ghnáth beidh na paistí sin ann mar iarratais tarraingthe ar GitHub agus is féidir iad a chomhtháthú go héasca i do stór áitiúil:

```shell
git checkout -b pull_xxxxx upstream/main
curl -L https://github.com/django/django/pull/xxxxx.patch | git am
```

Cruthóidh sé seo brainse nua agus ansin cuirfidh sé na hathruithe ón iarratas tarraingthe i bhfeidhm air. Ag an bpointe seo is féidir leat na tástálacha a reáchtáil nó aon rud eile a dhéanamh a chaithfidh tú a dhéanamh chun cáilíocht an phaiste a imscrúdú.

\<handling-pull-requests\>Le haghaidh tuilleadh sonraí maidir le hoibriú le hiarratais tarraingthe féach in:ref: treoirlínte maidir le cumaisc .

## Achoimre

- Oibrigh ar GitHub más féidir leat.
- Fógraigh d'obair ar thicéad Trac trí nasc a dhéanamh le do bhrainse GitHub.
- Nuair a bhíonn rud éigin réidh agat, déan iarratas tarraingthe.
- Déan d'iarratais tarraingthe chomh maith agus is féidir leat.
- Agus tú ag déanamh ceartúcháin ar do chuid oibre, bain úsáid as `git rebase -i` chun na gealltanais a scuabadh.
- Nuair a bheidh athraithe suas sruth, déan `git fetch upstream; git rebase`.