Writing your first contribution for Django¶
Introdução¶
Interessado em retribuir um pouco para a comunidade? Talvez você tenha encontrado uma falha no Django que você gostaria de ver corrigida, ou talvez exista uma pequena funcionalidade que poderia ser adicionada.
A melhor maneira de ver os seus problemas serem resolvidos é contribuindo com o Django. Pode parecer intimidador no começo, mas é um caminho que dá para ser percorrido com a documentação, ferramentas e uma comunidade para suporte. Nós lhe guiaremos por todo o processo para que você possa aprender através de exemplos.
Para quem se destina este tutorial?¶
Ver também
Se você está procurando por uma referência sobre os detalhes de fazer contribuições de código, veja a documentação Enviando patches.
For this tutorial, we expect that you have at least a basic understanding of how Django works. This means you should be comfortable going through the existing tutorials on writing your first Django app. In addition, you should have a good understanding of Python itself. But if you don’t, Dive Into Python is a fantastic (and free) online book for beginning Python programmers.
Aqueles que não estão familiarizados com sistemas de controle de versão e Trac irão encontrar neste tutorial, e seus links inclusos, informações suficientes para iniciar. Entretanto, se você esta planejando contribuir com o Django regularmente, provavelmente você vai querer ler mais a respeito das destas diferentes ferramentas.
Para a maior parte, porém, este tutorial tenta explicar o máximo possível, tal que possa ser usado por um público mais amplo.
Onde obter ajuda:
If you’re having trouble going through this tutorial, please post a message on the Django Forum, django-developers, or drop by `#django-dev on irc.libera.chat`__ to chat with other Django users who might be able to help.
O que este tutorial cobre?¶
We’ll be walking you through contributing to Django for the first time. By the end of this tutorial, you should have a basic understanding of both the tools and the processes involved. Specifically, we’ll be covering the following:
- Instalando Git.
- Baixando uma cópia da versão de desenvolvimento do Django.
- Executando suite de testes do Django.
- Writing a test for your changes.
- Writing the code for your changes.
- Testing your changes.
- Submetendo um pull request.
- Onde encontrar mais informações.
Uma vez que você terminar este tutorial, você pode olhar o restante da Documentação do Django sobre contribuição Ela contém muitas informações úteis e deve ser lida por quem deseja se tornar um contribuidor do Django. Caso tenha perguntas, a documentação provavelmente contem as respostas.
Python 3 é requerido!
A versão atual do Django não suporta Python 2.7. Baixe o Python 3 na página de downloads do Python <https://www.python.org/downloads/> ou no gerenciador de pacotes do seu sistema operacional.
Para usuários do Windows
Consulte a documentação do Instalando Python no Windows para obter orientações adicionais.
Código de Conduta¶
Como um contribuidor, você pode nos ajudar a manter a comunidade Django aberta e solidária. Por favor, leia e siga nosso ‘Código de conduta’ <https://www.djangoproject.com/conduct/>`_.
Instalando Git¶
For this tutorial, you’ll need Git installed to download the current development version of Django and to generate a branch for the changes you make.
Para verificar se o Git está instalado ou não no seu sistema, digite git na linha de comando. Se o resultado for uma mensagem dizendo que o comando não pode ser encontrado, você terá que fazer o download e instalar o Git. Dê uma olhada em `Git's download page`__.
Caso não esteja familiar com o Git, você sempre pode achar mais sobre seus comandos (uma vez que estiver instalado) digitando “git help” na linha de comando.
Obtendo uma cópia da versão de desenvolvimento do Django¶
O primeiro passo para contribuir com o Django é ter uma cópia dos arquivos do código fonte. Primeiro, faça um fork do projeto Django no GitHub. Então, a aprtir da linha de comando, use o comando cd para ir até o diretório onde você quer que fique sua cópia do projeto Django.
Baixe o código fonte do repositório do Django usando o seguinte comando:
$ git clone https://github.com/YourGitHubName/django.git
...\> git clone https://github.com/YourGitHubName/django.git
Conexão com baixa largura de banda?
Você pode adicionar o argumento --depth 1 ao executar git clone para evitar baixar todo o histórico de commits do Django, o que pode reduzir os dados transferidos de ~250MB para ~70MB.
Agora que você tem uma cópia local do Django, você pode instalá-lo da mesma forma que você instalaria qualquer pacote usando pip. A maneira mais conveniente de fazer isso é usando um ambiente virtual que é um recurso embutido no Python que permite que você mantenha um diretório separado para os pacotes instalados de cada um dos seus projetos para que uns não interfiram com os outros.
É uma boa ideia manter todos os seus virtualenvs em um lugar, por exemplo em .virtualenvs/ no seu diretório pessoal.
Crie um novo ambiente virtual executando:
$ python3 -m venv ~/.virtualenvs/djangodev
...\> py -m venv %HOMEPATH%\.virtualenvs\djangodev
O caminho é o local onde o novo ambiente será salvo em seu computador.
O último passo para configurar o seu ambiente virtual é ativá-lo:
$ source ~/.virtualenvs/djangodev/bin/activate
Se o comando source não estiver disponível, você pode tentar usar um ponto em vez disso:
$ . ~/.virtualenvs/djangodev/bin/activate
Você precisa ativar o ambiente virtual sempre que abrir uma nova janela do terminal.
Para usuários do Windows
Para ativar seu ambiente virtual no Windows, execute:
...\> %HOMEPATH%\.virtualenvs\djangodev\Scripts\activate.bat
O nome do ambiente virtual atualmente ativado é mostrado na linha de comando para ajudar você a acompanhar qual deles você está usando. Qualquer coisa que você instalar através do pip enquanto esse nome é exibido será instalado nesse ambiente virtual, isolado de outros ambientes e dos pacotes globais do sistema.
Vá em frente e instale a cópia anteriormente clonada do Django:
$ python -m pip install -e /path/to/your/local/clone/django/
...\> py -m pip install -e \path\to\your\local\clone\django\
The installed version of Django is now pointing at your local copy by installing in editable mode. You will immediately see any changes you make to it, which is of great help when writing your first contribution.
Criando projetos com uma cópia local do Django.¶
It may be helpful to test your local changes with a Django project. First you have to create a new virtual environment, install the previously cloned local copy of Django in editable mode, and create a new Django project outside of your local copy of Django. You will immediately see any changes you make to Django in your new project, which is of great help when writing your first contribution, especially if testing any changes to the UI.
You can follow the tutorial for help in creating a Django project.
Executando a suíte de testes do Django pela primeira vez¶
Ao contribuir com o Django é muito importante que as suas mudanças de código não criem bugs nas outras áreas do projeto. Uma forma de verificar é testar se tudo continua funcionando depois de suas alterações, executando a suíte de testes do Django. Se todos os testes passarem, tudo indica que suas mudanças não quebraram outras partes do Django. Se você nunca executou a suíte de testes do Django antes, é uma boa ideia testar de antemão para se familiarizar com suas saídas.
Antes de executar os testes, entre no diretório tests/ usando o comando cd tests e instale as dependências de teste executando o seguinte:
$ python -m pip install -r requirements/py3.txt
...\> py -m pip install -r requirements\py3.txt
Se você encontrar algum erro durante a instalação, talvez esteja faltando no seu sistema alguma dependência de um ou mais pacotes do Python. Consulte a documentação dos pacotes com falha ou faça uma busca na web com a mensagem de erro que você encontrou.
Agora nós estamos prontos para usar a suíte de testes. Se você estiver usando GNU/Linux, macOS ou algum outro tipo de Unix, execute:
$ ./runtests.py
...\> runtests.py
Agora, sente-se e relaxe. A suíte de testes completa do Django tem milhares de testes e leva pelo menos alguns minutos para executar, dependendo da velocidade do seu computador.
Enquanto a suíte de testes do Django estiver sendo executada, você verá um fluxo de caracteres representando o status de cada teste, conforme vão sendo executados. “E” indica que foi lançado um erro durante o teste, “F” indica que as asserções do teste falharam. Ambos são considerados como se o teste tivesse falhado. Enquanto que “x” e “s” indicam falhas esperadas e testes ignorados, respectivamente. Pontos indicam que o teste passou.
Normalmente testes são pulados quando faltam bibliotecas externas necessárias para executar o teste; veja Rodando todos os testes para uma lista de dependências e para se certificar de instalar qualquer dependência relacionada com suas mudanças (nós não necessitamos de nenhuma para este tutorial). Alguns testes são específicos para um banco de dados de backend e serão ignorados se não testado com aquele backend. SQLite é o banco de dados do backend padrão nas configurações. Para executar os testes usando diferentes backends, veja Usando outro módulo settings.
Assim que os testes são finalizados, você deveria ser notificado com uma mensagem informando se a suíte de testes passou ou falhou. Uma vez que você não realizou mudanças no código do Django, toda a suíte de testes deveria passar. Se você receber notificação de falhas ou erros certifique-se de que você seguiu todos os passos anteriores de maneira apropriada. Ver executando-testes-de-unidade para mais informações.
Note que a mais recente branch “main” pode nem sempre estar estável. Quando estiver desenvolvendo na branch “main”, você pode checar os builds de integração contínua do Django para determinar se as falhas ocorrem especificamente na sua máquina ou se elas também estão presentes nos builds oficiais do Django. Se você clicar para ver um build em particular, você pode ver a “Configuration Matrix” que mostra as falhas divididas por versões do Python e banco de dados backend.
Nota
For this tutorial and the ticket we’re working on, testing against SQLite is sufficient, however, it’s possible (and sometimes necessary) to run the tests using a different database. When making UI changes, you will need to run the Selenium tests.
Trabalhando em um recurso¶
Para este tutorial, nós iremos trabalhar em um “ticket falso” como um caso de estudo. Aqui estão os detalhes imaginários.
Ticket #99999 – Permitir fazer torradas.
Django deve prover uma função django.shortcuts.make_toast() que retorna 'toast'.
Nós iremos agora implementar este recurso e seus testes associados.
Creating a branch¶
Antes de fazer qualquer alteração, crie uma nova branch para o ticket:
$ git checkout -b ticket_99999
...\> git checkout -b ticket_99999
Você pode escolher qualquer nome que queira para um branch, “ticket_99999”é um exemplo. Todas as mudanças feitas neste branch serão específicas do ticket e não irão afetar a cópia principal do código que clonamos mais cedo.
Escrevendo alguns testes para o seu ticket¶
In most cases, for a contribution to be accepted into Django it has to include tests. For bug fix contributions, this means writing a regression test to ensure that the bug is never reintroduced into Django later on. A regression test should be written in such a way that it will fail while the bug still exists and pass once the bug has been fixed. For contributions containing new features, you’ll need to include tests which ensure that the new features are working correctly. They too should fail when the new feature is not present, and then pass once it has been implemented.
A good way to do this is to write your new tests first, before making any changes to the code. This style of development is called `test-driven development`__ and can be applied to both entire projects and single changes. After writing your tests, you then run them to make sure that they do indeed fail (since you haven’t fixed that bug or added that feature yet). If your new tests don’t fail, you’ll need to fix them so that they do. After all, a regression test that passes regardless of whether a bug is present is not very helpful at preventing that bug from reoccurring down the road.
Agora para nosso exemplo mão-na-massa.
Escrevendo um teste para o ticket #99999¶
Para resolver este ticket, adicionaremos uma função make_toast() ao módulo django.shortcuts. Primeiro vamos escrever um teste que tente usar a função e verificar se sua saída está correta.
Navegue para a pasta tests/shortcuts/ do Django e crie um arquivo test_make_toast.py. Adicione o código a seguir:
from django.shortcuts import make_toast
from django.test import SimpleTestCase
class MakeToastTests(SimpleTestCase):
def test_make_toast(self):
self.assertEqual(make_toast(), "toast")
Este testa verifica que o make_toast() returna 'toast'.
Mas esse lance de testar parece difícil…
Caso você nunca tenha lidado com testes anteriormente, num primeiro momento eles podem parecer um pouco difíceis de escrever . Felizmente, testes são um assunto muito extenso em programação de computadores, então existe muita informção por aí:
- Uma boa introdução em testes para Django pode ser encontrada na documentação Writing and running tests.
- Megulhando no Python (um livro gratuito online para desenvolvedores iniciantes de Python) inclui uma ótima `introdução ao Teste de Unidade`__.
- Após essa leitura, se desejar algo a mais para se aprofundar, sempre há a documentação do Python sobre
unittest.
Executando o seu novo teste¶
Como ainda não fizemos nenhuma modificação no django.shortcuts, nosso teste deve falhar. Vamos rodar todos os testes na pasta shortcuts para ter certeza de que isso realmente acontece. cd para o diretório tests/ e execute:
$ ./runtests.py shortcuts
...\> runtests.py shortcuts
If the tests ran correctly, you should see one failure corresponding to the test method we added, with this error:
ImportError: cannot import name 'make_toast' from 'django.shortcuts'
Se todos os testes passaram, depois irá querer ter certeza de que você adicionou o novo teste mostrado acima na pasta e arquivo apropriados.
Escrevendo o código para o seu ticket¶
Em seguida nós adicionaremos a função make_toast().
Navegue até a pasta django/ e abra o arquivo shortcuts.py. No seu final adicione:
def make_toast():
return "toast"
Agora precisamos nos assegurar de que o teste que escrevemos mais cedo passa, então podemos verificar se o código que adicionamos está funcionando corretamente. Novamente, vá para o diretório tests/ do Django e execute.
$ ./runtests.py shortcuts
...\> runtests.py shortcuts
Tudo deve passar. Caso contrário, certifique-se de que você adicionou corretamente a função ao arquivo correto.
Executando a suíte de testes do Django pela segunda vez¶
Once you’ve verified that your changes and test are working correctly, it’s a good idea to run the entire Django test suite to verify that your change hasn’t introduced any bugs into other areas of Django. While successfully passing the entire test suite doesn’t guarantee your code is bug free, it does help identify many bugs and regressions that might otherwise go unnoticed.
Para executar toda a suíte de testes do Django, `` cd`` no diretório `` testes / `` do Django e execute:
$ ./runtests.py
...\> runtests.py
Escrevendo Documentação¶
This is a new feature, so it should be documented. Open the file
docs/topics/http/shortcuts.txt and add the following at the end of the
file:
``make_toast()``
================
.. function:: make_toast()
.. versionadded:: 2.2
Returns ``'toast'``.
Since this new feature will be in an upcoming release it is also added to the
release notes for the next version of Django. Open the release notes for the
latest version in docs/releases/, which at time of writing is 2.2.txt.
Add a note under the “Minor Features” header:
:mod:`django.shortcuts`
~~~~~~~~~~~~~~~~~~~~~~~
* The new :func:`django.shortcuts.make_toast` function returns ``'toast'``.
Para mais informações sobre escrita de documentação, incluindo uma explicação sobre o que versionadded significa, verifique Escrevendo a documentação. Essa página também inclui uma explicação sobre como construir uma cópia local da documentação, de maneira que você possa pré-visualizar o HTML que será gerado.
Visualizando suas alterações¶
Now it’s time to review the changes made in the branch. To stage all the changes ready for commit, run:
$ git add --all
...\> git add --all
Then display the differences between your current copy of Django (with your changes) and the revision that you initially checked out earlier in the tutorial with:
$ git diff --cached
...\> git diff --cached
Use as teclas direcionais para mover para cima e para baixo.
diff --git a/django/shortcuts.py b/django/shortcuts.py
index 7ab1df0e9d..8dde9e28d9 100644
--- a/django/shortcuts.py
+++ b/django/shortcuts.py
@@ -156,3 +156,7 @@ def resolve_url(to, *args, **kwargs):
# Finally, fall back and assume it's a URL
return to
+
+
+def make_toast():
+ return 'toast'
diff --git a/docs/releases/2.2.txt b/docs/releases/2.2.txt
index 7d85d30c4a..81518187b3 100644
--- a/docs/releases/2.2.txt
+++ b/docs/releases/2.2.txt
@@ -40,6 +40,11 @@ database constraints. Constraints are added to models using the
Minor features
--------------
+:mod:`django.shortcuts`
+~~~~~~~~~~~~~~~~~~~~~~~
+
+* The new :func:`django.shortcuts.make_toast` function returns ``'toast'``.
+
:mod:`django.contrib.admin`
~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/docs/topics/http/shortcuts.txt b/docs/topics/http/shortcuts.txt
index 7b3a3a2c00..711bf6bb6d 100644
--- a/docs/topics/http/shortcuts.txt
+++ b/docs/topics/http/shortcuts.txt
@@ -271,3 +271,12 @@ This example is equivalent to::
my_objects = list(MyModel.objects.filter(published=True))
if not my_objects:
raise Http404("No MyModel matches the given query.")
+
+``make_toast()``
+================
+
+.. function:: make_toast()
+
+.. versionadded:: 2.2
+
+Returns ``'toast'``.
diff --git a/tests/shortcuts/test_make_toast.py b/tests/shortcuts/test_make_toast.py
new file mode 100644
index 0000000000..6f4c627b6e
--- /dev/null
+++ b/tests/shortcuts/test_make_toast.py
@@ -0,0 +1,7 @@
+from django.shortcuts import make_toast
+from django.test import SimpleTestCase
+
+
+class MakeToastTests(SimpleTestCase):
+ def test_make_toast(self):
+ self.assertEqual(make_toast(), 'toast')
When you’re done previewing the changes, hit the q key to return to the
command line. If the diff looked okay, it’s time to commit the changes.
Committing the changes¶
Para cometer as alterações:
$ git commit
...\> git commit
Isso abre um editor de texto para digitar a mensagem do commit. Siga o guia de mensagens de commits e escreva uma mensagem tipo:
Fixed #99999 -- Added a shortcut function to make toast.
Enviando o commit e fazendo um pull request¶
After committing the changes, send it to your fork on GitHub (substitute “ticket_99999” with the name of your branch if it’s different):
$ git push origin ticket_99999
...\> git push origin ticket_99999
Você pode criar um pull request visitando a página do Django no GitHub. Você verá sua branch abaixo de “Your recently pushed branches”. Clique em “Compare & pull request” depois.
Please don’t do it for this tutorial, but on the next page that displays a preview of the changes, you would click “Create pull request”.
Próximos passos¶
Parabéns, você aprendeu como fazer um pull request para Django! Detalhes de técnicas mais avançadas que você pode precisar estão em Trabalhando com Git e GitHub.
Agora você pode contribuir para ajudar a melhorar a base de código do Django.
Mais informações para novos contribuidores¶
Before you get too into contributing to Django, there’s a little more information on contributing that you should probably take a look at:
- You should make sure to read Django’s documentation on claiming tickets and submitting pull requests. It covers Trac etiquette, how to claim tickets for yourself, expected coding style (both for code and docs), and many other important details.
- Os contribuidores de primeira viagem devem ler o documentação sobre contribuidores de primeira viagem. Ele tem muitos bons conselhos para aqueles que são novos para ajudar com Django.
- Depois disso, se você ainda estiver ansioso para obter mais informações sobre como contribuir, você sempre pode navegar pelo resto da documentação do Django em contribuição. Ele contém um monte de informações úteis e deve ser sua primeira fonte para responder quaisquer perguntas que você possa ter.
Encontrando o seu primeiro ticket¶
Once you’ve looked through some of that information, you’ll be ready to go out and find a ticket of your own to contribute to. Pay special attention to tickets with the “easy pickings” criterion. These tickets are often much simpler in nature and are great for first time contributors. Once you’re familiar with contributing to Django, you can start working on more difficult and complicated tickets.
If you just want to get started already (and nobody would blame you!), try taking a look at the list of `easy tickets without a branch`__ and the `easy tickets that have branches which need improvement`__. If you’re familiar with writing tests, you can also look at the list of `easy tickets that need tests`__. Remember to follow the guidelines about claiming tickets that were mentioned in the link to Django’s documentation on claiming tickets and submitting branches.
O que vem depois de criar um pull request?¶
After a ticket has a branch, it needs to be reviewed by a second set of eyes. After submitting a pull request, update the ticket metadata by setting the flags on the ticket to say “has patch”, “doesn’t need tests”, etc, so others can find it for review. Contributing doesn’t necessarily always mean writing code from scratch. Reviewing open pull requests is also a very helpful contribution. See Triagem de tickets for details.
