# Documentação Django 6.0.7

# Trabalhando com Git e GitHub

This section explains how the community can contribute code to Django via pull requests. If you’re interested in how mergers handle them, see Manipulando pull requests.

Abaixo, iremos mostrar como criar um “pull request” no GitHub, contendo as mudanças para o ticket #xxxxx do Trac. Criando um “pull request” totalmente pronto, você tornará mais fácil o trabalho dos revisores, o que quer dizer que seu trabalho está mais próximo de ser “mergeado” no Django.

Você também poderia fazer upload de um patch tradicional no Trac, mas isso é menos prático para os revisores.

## Instalando Git

Django uses Git for its source control. You can download Git, but it’s often easier to install with your operating system’s package manager.

O repositório do Django é hospedado no GitHub, e é recomendado que você também trabalhe usando o GitHub.

After installing Git, the first thing you should do is set up your name and email:

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

Note que `user.name` deve ser o seu nome real, e não o seu nick no GitHub. O GitHub deve saber o email que você usa pelo campo `user.email`, já que ele será usado para associar os seus commits com a sua conta no GitHub.

## Configurando o repositório local

When you have created your GitHub account, with the nick “GitHub_nick”, and forked Django’s repository, create a local copy of your fork:

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

This will create a new directory “django”, containing a clone of your GitHub repository. The rest of the git commands on this page need to be run within the cloned directory, so switch to it now:

    cd django

O seu repositório GitHub será chamado de “origin” no Git.

You should also set up `django/django` as an “upstream” remote (that is, tell git that the reference Django repository was the source of your fork of it):

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

You can add other remotes similarly, for example:

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

## Trabalhando em um ticket

When working on a ticket, create a new branch for the work, and base that work on `upstream/main`:

    git checkout -b ticket_xxxxx upstream/main

A flag -b cria uma nova branch para você localmente. Não hesite em criar novas branches mesmo para as coisas mais simples - esse é o motivo delas existirem.

If instead you were working for a fix on the 1.4 branch, you would do:

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

Assume the work is carried on the ticket_xxxxx branch. Make some changes and commit them:

    git commit

When writing the commit message, follow the commit message guidelines to ease the work of the merger. If you’re uncomfortable with English, try at least to describe precisely what the commit does.

If you need to do additional work on your branch, commit as often as necessary:

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

### Publicando trabalho

You can publish your work on GitHub by running:

    git push origin ticket_xxxxx

Quando acessar sua página no GitHub, irá perceber que um novo “branch” foi criado.

Se você está trabalhando em um ticket do Trac, você deve mencionar no ticket que o seu trabalho está disponível através da branch ticket_xxxxx do seu repositório no GitHub. Inclua um link para a sua branch.

Tenha em mente que a branch acima é chamada de “topic branch” no linguajar do Git. Você é livre para reescrever o histórico dessa branch, através do uso do `git rebase` por exemplo. Outras pessoas não deveriam basear o seu trabalho em uma branch como essa, porque os clones dela serão corrompidos quando você editar os seus commits.

There are also “public branches”. These are branches other people are supposed to fork, so the history of these branches should never change. Good examples of public branches are the `main` and `stable/A.B.x` branches in the `django/django` repository.

Quando você achar que o seu trabalho está pronto para ser enviado para o Django, você deve criar um pull request no GitHub. Um bom pull request significa:

- commits with one logical change in each, following the coding style,

- Mensagens bem formatadas para cada commit: uma linha de sumário e então parágrafos embutidos em até 72 caracteres depois dela – veja as regras de commit para mais detalhes.

- Documentação e testes, quando necessário – na verdade testes são sempre necessários, exceto para mudanças na documentação.

A suíte de testes deve passar e a documentação deve ser gerada sem quaisquer warnings.

Uma vez que tenha criado seu pull request, você deve adicionar um comentário no ticket do Trac relacionado explicando o que você fez. Em particular, você deve mencionar o ambiente no qual você rodou os testes, por exemplo: “all tests pass under SQLite and MySQL”.

Pull requests at GitHub have only two states: open and closed. The merger who will deal with your pull request has only two options: merge it or close it. For this reason, it isn’t useful to make a pull request until the code is ready for merging – or sufficiently close that a merger will finish it themselves.

### Editing commit messages

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

    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:

    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 Regras de commit 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:

    git push --force-with-lease origin ticket_xxxxx

### Fazendo rebase de branches

In the example above, you created two commits, the “Fixed #xxxxx – …” commit and the “Added two more tests …” commit.

Nós não queremos ter o histórico inteiro do seu processo de trabalho no seu repositório. O seu commit “Added two more tests” seria poluído e pouco amigável. Ao invés disso, nós preferimos ter apenas um commit contendo todo o seu trabalho.

To rework the history of your branch you can squash the commits into one by using interactive rebase:

    git rebase -i HEAD~2

O HEAD~2 acima é um atalho para os dois últimos commits. O comando acima irá abrir um editor mostrando os dois commits, prefixados com a palavra “pick”.

Mude “pick” na segunda linha para “squash”. Isso manterá o primeiro commit, e esmagará o segundo commit dentro do primeiro. Salve e feche o editor. Uma segunda janela do editor deverá abrir, de modo que você possa reescrever a mensagem de commit agora que ele está incluindo os seus dois passos.

You can also use the “edit” option in rebase. This way you can change a single commit, for example to fix a typo in a docstring:

    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.

If your topic branch is already published at GitHub, for example if you’re making minor changes to take into account a review, you will need to force-push the changes:

    git push --force-with-lease origin ticket_xxxxx

Note that this will rewrite history of ticket_xxxxx - if you check the commit hashes before and after the operation at GitHub you will notice that the commit hashes do not match anymore. This is acceptable, as the branch is a topic branch, and nobody should be basing their work on it.

### Depois que o upstream foi modificado

When upstream (`django/django`) has changed, you should rebase your work. To do this, use:

    git fetch upstream
    git rebase upstream/main

The work is automatically rebased using the branch you forked on, in the example case using `upstream/main`.

O comando rebase remove todos os seus commits locais temporariamente, aplica os commits do upstream, e então aplica os seus commits locais novamente.

Se houver conflitos nos “merges”, precisamos resolvê-los e então usar o `get rebase --continue`. Em qualquer momento você pode usar o `get rebase --abort` para retornar ao estado original.

Note que você quer fazer rebase no upstream, e não merge do upstream.

A razão para isso é que ao fazer o rebase, os seus commits sempre ficarão no topo do trabalho realizado no upstream e não misturado com as mudanças do upstream. Desta forma a sua topic branch irá conter somente commits relacionados a ela, o que faz com que o processo de esmagar os seus commits fique mais simples.

### Depois de revisar

É muito incomum receber qualquer porção de código não trivial incluída no core do Django sem quaisquer alterações sendo solicitadas pelos revisores. Neste caso, costuma ser uma boa ideia adicionar as mudanças na forma de um commit incremental para o seu trabalho. Isso permite que os revisores possam checar facilmente quais mudanças você fez.

In this case, do the changes required by the reviewer. Commit as often as necessary. Before publishing the changes, rebase your work. If you added two commits, you would run:

    git rebase -i HEAD~2

Squash the second commit into the first. Write a commit message along the lines of:

    Made changes asked in review by <reviewer>.

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

Finally, push your work back to your GitHub repository. Since you didn’t touch the public commits during the rebase, you should not need to force-push:

    git push origin ticket_xxxxx

O seu pull request deve agora conter um novo commit também.

Note that the merger is likely to squash the review commit into the previous commit when committing the code.

## Trabalhando em um patch

One of the ways that developers can contribute to Django is by reviewing patches. Those patches will typically exist as pull requests on GitHub and can be easily integrated into your local repository:

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

Isso irá criar uma nova branch e então aplicar as mudanças do pull request nela. Neste momento você pode rodar os testes ou fazer qualquer coisa que você precise para investigar a qualidade do patch.

For more detail on working with pull requests see the guidelines for mergers.

## Sumário

- Trabalhe no GitHub se você puder.

- Anuncie o seu trabalho no ticket do Trac adicionando um link para a sua branch no GitHub.

- Quando você tiver algo pronto, faça um pull request.

- Faça os pull requests tão bons quanto puder.

- Quando estiver fazendo correçṍes no seu trabalho, use `git rebase -i` para esmagar os commits.

- Quando o upstream tiver sido alterado, faça `git fetch upstream; git rebase`.