Escrevendo a documentação

Nós damos uma grande importância a consistência e legibilidade de nossa documentação. Afinal, Django foi criado em um ambiente jornalístico! Então nós tratamos a nossa documentação como nós tratamos o nosso código: nós tentamos melhorá-lo sempre que possível.

Mudanças na documentação geralmente aparecem de duas formas:

  • Melhorias gerais: correção de ortografia, correções de erros e melhores explicações através de escrita clara e mais exemplos.

  • Novas funcionalidades: documentação de funcionalidades que foram adicionadas ao framework desde a última release.

Esta seção explica como os escritores podem construir suas mudanças na documentação de forma mais eficiente e menos suscetível a erros.

Obtendo a documentação bruta

Embora a documentação Django seja feita focando a leitura no formato HTML em https://docs.djangoproject.com/, nós editamos ela como uma coleção de arquivos de texto para maximizar a flexibilidade. Esses arquivos são armazenados no diretório docs/ da release Django.

Se você gostaria de contribuir com a nossa documentação, pegue a versão de desenvolvimento do Django do nosso repositório de código (veja Instalando a versão de desenvolvimento.). A versão de desenvolvimento possui a melhor e mais recente versão da documentação, assim como possui a melhor e mais recente versão do código. Nós também fazemos backport de correções e melhorias na documentação, dependendo da discrição do committer, para a branch da última release. Isto porque é extremamente vantajoso possuir a documentação para a última release correta e atualizada (see Diferenças entre versões).

Começando trabalhar com o Sphinx

A documentação do Django usa o sistema de documentação Sphinx, que por sua vez é baseado no docutils. A ideia básica é que uma documentação em texto plano com formatação simples é transformada em HTML, PDF, e muitos outros formatos.

Pra efetivamente construir a documentação localmente, você provavelmente terá que instalar o Sphinx – pip install Sphinx deve ser o suficiente.

A partir desse momento, gerar o HTML é simples; basta executar o comando make html (ou make.bat html no Windows) de dentro do diretório docs.

Para começar a contribuir, você vai querer ler o reStructuredText Primer. Depois disso, você vai querer ler sobre Sphinx-specific markup que é usado para gerenciar metadados, indexação e referências cruzadas.

Como a documentação é organizada

A documentação é organizada em vários categorias:

  • Tutorials pega o leitor pelas mãos e o leva através de uma série de passos para criar algo.

    O importante em um tutorial é ajudar o leitor a fazer algo útil, preferencialmente o mais rápido possível, para que ele passe a ganhar confiança.

    Explique a natureza do problema que estamos tentando resolver, de modo que o leitor entenda o que nós estamos tentando alcançar. Não sinta que você precisa começar com explicações de como as coisas funcionam - o que importa é que o leitor fará, não o que você explica. Pode ser útil lembrar o que você já fez e explicar posteriormente.

  • Topic guides buscam explicar um conceito ou um assunto de modo bem abrangente.

    Faça links para referências ao invés de repeti-las. Utilize exemplos e não seja relutante em explicar coisas que pareçam muito básicas para você - essa pode ser a explicação que outra pessoa precisa.

    Contextualizar ajuda os novatos a ligar o assunto a coisas que eles já sabem.

  • Reference guides contém referências técnicas para as APIs. Eles descrevem o funcionamento do maquinário interno do Django e instruem em sua utilização.

    Mantenha o material de referência focado estritamente no assunto. Assuma que o leitor já entende os conceitos básicos envolvidos mas precisa saber ou ser lembrado de como o Django faz isso.

    Guias de referência não são o local para explicações genéricas. Se você se encontrar explicando conceitos básicos, você deve querer mover o material para um guia em um assunto em específico.

  • How-to guides são receitas que levam o leitor através de uma série de passos em assuntos chave.

    O que importa mais em um guia how-to é o que um usuário deseja alcançar. Um how-to deve sempre estar orientado a resultados ao invés de focado em detalhes internos de como o Django implementa o que quer que esteja sendo discutido.

    Esses guias são mais avançados que tutoriais e assumem algum conhecimento sobre como o Django trabalha. Assuma que o leitor seguiu os tutoriais e não hesite em enviar o leitor de volta para o tutorial apropriado ao invés de repetir o mesmo material.

Estilo de escrita

Quando usar pronomes em referência a uma pessoa hipotética, tais como “um usuário com um cookie de sessão”, pronomes neutros (eles/seus/lhes) devem ser utilizados. Ao invés de:

  • ele ou ela... utilize eles.

  • Dele ou dela... utilize deles.

  • Dele ou dela... utilize deles.

  • dele ou dela... use deles.

  • ele mesmo ou ela mesma... use eles mesmos.

Termos usados com frequência

Aqui vão algumas orientações de estilo para termos usados comumente por toda a documentação:

  • Django – quando estiver se referindo ao framework, deve começar com letra maiúscula. Ele só deve ser escrito em letras minúsculas no código Python e no logo de djangoproject.com.

  • email – sem hífen.

  • MySQL, PostgreSQL, SQLite
  • SQL – quando estiver se referindo ao SQL, a pronunciação esperada deve ser “Ess Queue Ell” e não “sequel”. Portanto, em uma frase como “Retorna uma expressão SQL”, “SQL” deve ser precedido por “um” e não por “a”.

  • Python – quando estiver se referindo a linguagem, use letra maiúscula.

  • realize, customize, initialize, etc. – use o padrão Americano “ize” suffix, não “ise”

  • subclass – É uma única palavra sem o hífen, tanto para o verbo (“subclassear o modelo”) quanto para o substântivo (“criar uma subclasse”).

  • Web, World Wide Web, the Web – note que Web é sempre maiúsculo quando se referir a World Wide Web.

  • website – utilize uma palavra, tudo em minúsculas.

Terminologia específica do Django

  • model – não tem maiúsculas.

  • template – não tem maiúsculas.

  • URLconf – utilize três as letras primeiras letras maiúsculas, sem espaço antes de “conf.”

  • view – não tem maiúsculas.

Orientações gerais para arquivos do tipo reStructuredText

Estas regras regulam o formato de nossa documentação em reST (reStructuredText):

  • Na seção de títulos, só deixe em maiúsculas palavras iniciais e pronomes próprios.

  • Restrinja a documentação em até 80 caracteres de comprimento, a não ser que o código de exemplo seja significativamente mais difícil de ler quando quebrado em duas linhas, ou por outra boa razão.

  • A principal coisa a se manter em mente enquanto você escreve e edita documentos é que quanto mais marcação semântica você puder adicionar melhor. Então:

    Add ``django.contrib.auth`` to your ``INSTALLED_APPS``...
    

    Não é nem de perto melhor do que:

    Add :mod:`django.contrib.auth` to your :setting:`INSTALLED_APPS`...
    

    Isso porque o Sphinx irá gerar os links apropriados para depois, o que beneficia enormemente os leitores. Praticamente não existem limites para a quantidade de marcação útil que você pode adicionar.

  • Utilize intersphinx para referenciar a documentação do Python e do Sphinx.

  • Utilize esses estilos de cabeçalhos:

    ===
    One
    ===
    
    Two
    ===
    
    Three
    -----
    
    Four
    ~~~~
    
    Five
    ^^^^
    

Marcação específica do Django

Besides the Sphinx built-in markup, Django’s docs defines some extra description units:

  • Settings:

    .. setting:: INSTALLED_APPS
    

    Para redirecionar para uma configuração, utilize :setting:`INSTALLED_APPS`.

  • Tags de templates:

    .. templatetag:: regroup
    

    Para redirecionar, utilize :ttag:`regroup`.

  • Filtros de templates:

    .. templatefilter:: linebreaksbr
    

    Para redirecionar, utilize :tfilter:`linebreaksbr`.

  • Busca de campos (por exemplo, Foo.objects.filter(bar__exact=qualquercoisa)`):

    .. fieldlookup:: exact
    

    Para redirecionar, utilize :lookup:`exact`.

  • Comandos do django-admin:

    .. django-admin:: migrate
    

    Para redirecionar, utilize :djadmin:`migrate`.

  • Opções de linha de comando do django-admin:

    .. django-admin-option:: --traceback
    

    Para redirecionar, utilize :option:`command_name --traceback` (ou omita command_name para as opções compartilhadas por todos os comandos como --verbosity).

  • Redirecionar para os tickets do Trac (tipicamente reservado a notas de releases de patches):

    :ticket:`12345`
    

Documentando novas funcionalidades

Nossa política para novas funcionalidades é:

Toda a documentação de novas funcionalidades devem ser escritas de forma que fique claro que as funcionalidade só estão disponíveis na versão de desenvolvimento do Django. Assuma que os leitores da documentação estão usando a última release, e não a última versão de desenvolvimento.

Nossa forma preferida de marcar novas funcionalidades é adicionando um prefixo na documentação de novas funcionalidades com “.. versionadded:: X.Y”, seguidas de uma linha em branco mandatória e uma descrição opcional (identada).

Melhorias gerais, ou outras mudanças para as APIs que deveriam ser enfatizadas devem usar a diretiva “.. versionchanged:: X.Y” (com o mesmo formato de versionadded mencionado acima.

Esses blocos versionadded e versionchanged devem ser “auto contidos”. Em outras palavras, já que nós só vamos manter essas anotações por volta de duas releases, é um bom poder remover a anotação e seus conteúdo sem ter que re-escoar, re-identar ou editar o texto ao redor. Por exemplo, ao invés de colocar a descrição inteira de uma mudança ou de uma nova funcionalidade em um block, faça algo como a seguir:

.. class:: Author(first_name, last_name, middle_name=None)

    A person who writes books.

    ``first_name`` is ...

    ...

    ``middle_name`` is ...

    .. versionchanged:: A.B

        The ``middle_name`` argument was added.

Coloque as considerações referentes as mudanças anotadas no final das seções, não no topo.

Além disso, evite mencionar uma versão específica do Django fora dos blocos versionadded ou versionchanged. Mesmo dentro de um bloco, Ainda costuma ser redundantes fazer isso já que essas anotações irão renderizar como “Novo no Django A.B” e “Alterado no Django A.B”, respectivamente.

Se a função, atributo, etc. é adicionado, também pode ser usado uma anotação versionadded como a seguir:

.. attribute:: Author.middle_name

    .. versionadded:: A.B

    An author's middle name.

Nós podemos simplesmente remover a anotação .. versionadded:: A.B sem quaisquer mudanças de identação quando a hora chegar.

Minimizando imagens

Otimize a compressão das imagens quando possível. Para arquivos PNG, utilize OptiPNG e o “advpng” da AdvanceCOMP:

$ cd docs/
$ optipng -o7 -zm1-9 -i0 -strip all `find . -type f -not -path "./_build/*" -name "*.png"`
$ advpng -z4 `find . -type f -not -path "./_build/*" -name "*.png"`

Isso é baseado na versão 0.7.5 do OptiPNG. Versões mais antigas podem reclamar da opção --strip all dizendo que existirá perda de qualidade.

Um exemplo

Para um rápido exemplo de como tudo se encaixa, considere este exemplo hipotético:

  • Primeiro, o documento ref/settings.txt pode ter um leiaute geral como esse:

    ========
    Settings
    ========
    
    ...
    
    .. _available-settings:
    
    Available settings
    ==================
    
    ...
    
    .. _deprecated-settings:
    
    Deprecated settings
    ===================
    
    ...
    
  • Depois, o documento topics/settings.txt pode ser algo assim:

    You can access a :ref:`listing of all available settings
    <available-settings>`. For a list of deprecated settings see
    :ref:`deprecated-settings`.
    
    You can find both in the :doc:`settings reference document
    </ref/settings>`.
    

    Nós usamos o elmento de referência cruzada do Sphinx doc quando nós queremos redirecionar para outro documento como um todo e o elemento ref quando queremos redirecionar para uma localização arbitrária dentro do documento.

  • Depois, repare em como os settings são anotados:

    .. setting:: ADMINS
    
    ADMINS
    ======
    
    Default: ``[]`` (Empty list)
    
    A list of all the people who get code error notifications. When
    ``DEBUG=False`` and a view raises an exception, Django will email these people
    with the full exception information. Each member of the list should be a tuple
    of (Full name, email address). Example::
    
        [('John', 'john@example.com'), ('Mary', 'mary@example.com')]
    
    Note that Django will email *all* of these people whenever an error happens.
    See :doc:`/howto/error-reporting` for more information.
    

    Isso marca o próximo cabeçalho como o alvo “canônico” para o setting ADMINS. Isto significa que sempre que eu falar sobre ADMINS, eu posso redirecionar para ele usando :setting:`ADMINS`.

Isso é basicamente como tudo se encaixa.

Melhorando a documentação

Algumas pequenas melhorias podem ser feitas para melhorar o visual e a leitura da documentação.

  • A maioria dos vários documentos index.txt têm uma introdução bem curta ou simplesmente nenhuma introdução. Cada um desses documentos precisam de uma boa e curta introdução para o conteúdo posterior a ela.

  • O glossário é muito superficial. Ele precisa ser preenchido.

  • Adicione mais alvos de metadados. A maioria dos locais está dessa forma:

    ``File.close()``
    ~~~~~~~~~~~~~~~~
    

    ... eles deveriam ser assim:

    .. method:: File.close()
    

    Ou seja, utilize metadados ao invés de títulos.

  • Quando possível, utilize links. Ou seja, use :setting:`ADMINS` ao invés de ``ADMINS``.

  • Utilize as diretivas quando apropriado. Algumas diretivas (por exemplo: .. setting::) são diretivas com prefixos; eles vão antes da unidade que eles descrevem. Essas diretivas são conhecidas como diretivas “crossref”. Outras (por exemplo: .. class::) geram a sua própria marcação; essas devem ir dentro da seção que estão descrevendo. Essas diretivas são chamads de “unidades descritivas”.

    Você pode descobrir quais são de qual tipo olhando em _ext/djangodocs.py; ele registra os perfis aos quais cada uma delas pertence.

  • Adicione .. code-block:: <lang> para blocos literais para eles sejam destacados.

  • Quando estiver referenciando classes/funções/módulos, etc., você vai querer usar o fully-qualified-name do alvo (:class:`django.contrib.contenttypes.models.ContentType`).

    Já que isso não parece nem um pouco legal na saída – ele te mostra o caminho completo até o objeto – você pode prefixar o algo com ~ (isso é um til) para pegar apenas a “última parte” do caminho. Então :class:`~django.contrib.contenttypes.models.ContentType` irá exibir apenas um link com o título “ContentType”.

Verificador ortográfico

Antes de fazer o commit das suas documentações, é uma boa ideia rodar o verificador ortográfico. Você terá que instalar alguns pacotes primeiro:

Depois de instalá-los e de dentro do diretório docs, rode o comando make spelling. Palavras erradas (se existirem) além do arquivo e o número da linha onde eles ocorream serão salvos em _build/spelling/output.txt.

Se você encontrar falso-positivos (erros que na verdade estão corretos), faça uma das coisas a seguir:

  • Coloque em volta o código ou nomes de marcas/tecnologias acentos graves (`).

  • Encontre um sinônimo que o verificador ortográfico reconheça.

  • Se, e somente se, você tiver certeza que a palavra que você está usando está correta - adicione ela em docs/spelling_wordlist (por favor mantenha a lista em ordem alfabética).

Traduzindo a documentação

Veja Localizing the Django documentation Se você quer ajudar a traduzir a documentação para outras linguagens.

Página man do django-admin

O Sphinx pode gerar uma página de manual para o comando django-admin. Isso é configurado em docs/conf.py. Diferentemente de outras documentações geradas, essa página man deve ser incluída no repositório do Django e de suas releases em docs/man/django-admin.1. Não existe a necessidade de atualizar esse arquivo quando estiver atualizando a documentação, já que ele é atualizado durante o processo de release.

Para gerar uma versão atualizada da página man, roda o comando make man dentro do diretório docs. A nova página man será escrita em docs/_build/man/django-admin.1.

Back to Top