dgit 13.12_dgit-maint-debrebase_7 - en to pt translation catalogue (148 entries)

note: type: =head1
en: NAME
pt: NOME

note: type: =head1
en: SEE ALSO
pt: VEJA TAMBÉM

note: type: =head1
en: INTRODUCTION
pt: INTRODUÇÃO

note: type: textblock
en: Benefit from dgit's safety catches.  In particular, ensure that your upload always matches exactly your git HEAD.
pt: Beneficia das capturas de segurança do dgit.  Em particular, assegura que o seu envio corresponde sempre exatamente ao seu CABEÇALHO git.

note: type: =head1
en: INITIAL DEBIANISATION
pt: A DEBIANIZAÇÃO INICIAL

note: type: textblock
en: This section explains how to start using this workflow with a new package.  It should be skipped when converting an existing package to this workflow.
pt: Esta secção explica como começar a usar este fluxo de trabalho com um novo pacote.  Deve ser saltada quando se converte um pacote existente para este fluxo de trabalho.

note: type: =head3
en: When upstream tags releases in git
pt: Quando etiquetas de autor são lançadas em git

note: type: textblock
en: Suppose that the latest stable upstream release is 1.2.2, and this has been tagged '1.2.2' by upstream.
pt: Supondo que o lançamento de autor estável mais recente é 1.2.2, e isto foi etiquetado '1.2.2' pelo autor.

note: type: textblock
en: Finally, you need an orig tarball:
pt: Finalmente, você precisa dum tarball original:

note: type: textblock
en: See git-deborig(1) if this fails.
pt: Veja git-deborig(1) se isto falhar.

note: type: textblock
en: This tarball is ephemeral and easily regenerated, so we don't commit it anywhere (e.g. with tools like pristine-tar(1)).
pt: Este tarball é efémero e facilmente regenerado, assim não o cometemos para lado nenhum (ex. com ferramentas como o pristine-tar(1)).

note: type: =head3
en: Using untagged upstream commits
pt: Usando cometidos de autor não etiquetados

note: type: textblock
en: Sometimes upstream does not tag their releases, or you want to package an unreleased git snapshot.  In such a case you can create your own upstream release tag, of the form B<upstream/>I<ver>, where I<ver> is the upstream version you plan to put in I<debian/changelog>.  The B<upstream/> prefix ensures that your tag will not clash with any tags upstream later creates.
pt: Por vezes o autor não etiqueta os seus lançamentos, ou você quer empacotar um instantâneo de git não lançado.  Em tais casos você pode criar a sua própria etiqueta de lançamento de autor, no formato B<upstream/>I<ver>, onde I<ver> é a versão de autor que você planeia colocar em I<debian/changelog>.  O prefixo B<upstream/> assegura que a sua etiqueta não vai colidir com nenhumas etiquetas que o autor crie mais tarde.

note: type: textblock
en: For example, suppose that the latest upstream release is 1.2.2 and you want to package git commit ab34c21 which was made on 2013-12-11.  A common convention is to use the upstream version number 1.2.2+git20131211.ab34c21 and so you could use
pt: Por exemplo, suponha que o lançamento mais recente do autor é 1.2.2 e você quer empacotar o cometido git ab34c21 que foi feito em 2013-12-11.  Uma convenção comum é usar a versão de autor número 1.2.2+git20131211.ab34c21 e assim você podia usar

note: type: textblock
en: to obtain a release tag, and then proceed as above.
pt: para obter a etiqueta de lançamento, e depois proceder como em cima.

note: type: =head3
en: When upstream releases only tarballs
pt: Quando o autor lança apenas tarballs

note: type: =head1
en: CONVERTING AN EXISTING PACKAGE
pt: CONVERTER UM PACOTE EXISTENTE

note: type: textblock
en: This section explains how to convert an existing Debian package to this workflow.  It should be skipped when debianising a new package.
pt: Esta secção explica como converter um pacote Debian existente para este fluxo de trabalho.  Deve ser saltada quando se está a debianizar um pacote novo.

note: type: textblock
en: To achieve this, you might need to delete I<debian/source/local-options>.  One way to have dgit check your progress is to run B<dgit build-source>.
pt: Para conseguir isto, você pode precisar de apagar I<debian/source/local-options>.  Uma maneira de ter o dgit a verificar o seu progresso é correr B<dgit build-source>.

note: type: =head1
en: BUILDING AND UPLOADING
pt: COMPILAR E ENVIAR

note: type: =head2
en: Obtaining the release
pt: Obtendo o lançamento

note: type: textblock
en: If you want to package an untagged upstream commit (because upstream does not tag releases or because you want to package an upstream development snapshot), see "Using untagged upstream commits" above.
pt: Se você quer empacotar um cometido de autor não etiquetado (porque o autor não etiqueta os lançamentos ou porque você quer empacotar um instantâneo de desenvolvimento do autor), veja "Usando cometidos de autor não etiquetados" em cima.

note: type: textblock
en: You will need the I<debian/gbp.conf> from "When upstream releases only tarballs", above.  You will also need your upstream branch.  Above, we pushed this to B<salsa.debian.org>.  You will need to clone or fetch from there, instead of relying on B<dgit clone>/B<dgit fetch> alone.
pt: Você vai precisar do I<debian/gbp.conf> de "Quando o autor lança apenas tarballs", em cima.  Você vai também precisar do seu ramo de autor.  Em cima, nós envia-mos isto para B<salsa.debian.org>.  Você vai precisar de clonar ou ir buscar de lá, em vez de confiar apenas em B<dgit clone>/B<dgit fetch>.

note: type: textblock
en: Then, either
pt: Então, ou

note: type: textblock
en: or if you have a working watch file
pt: ou se você tiver um ficheiro watch a funcionar

note: type: textblock
en: If you obtained a tarball from upstream, you are ready to try a build.  If you merged a git tag from upstream, you will first need to generate a tarball:
pt: Se você obteve um tarball a partir do autor, está pronto para tentar uma compilação.  Se você fundiu uma etiqueta git a partir do autor, você vai precisar de primeiro gerar um tarball:

note: type: =head1
en: HANDLING DFSG-NON-FREE MATERIAL
pt: MANUSEAR MATERIAL DFSG-NÃO-LIVRE

note: type: textblock
en: The easiest way to handle this is to add a B<Files-Excluded> field to I<debian/copyright>, and a B<uversionmangle> setting in I<debian/watch>.  See uscan(1).  Alternatively, see the I<--filter> option detailed in gbp-import-orig(1).
pt: A maneira mais fácil de lidar com isto é adicionar um campo B<Files-Excluded> a I<debian/copyright>, e uma definição B<uversionmangle> em I<debian/watch>.  Veja uscan(1).  Em alternativa, veja a opção I<--filter> detalhada em gbp-import-orig(1).

note: type: =head1
en: INCORPORATING NMUS
pt: INCORPORAR NMUS

note: type: =head1
en: AUTHOR
pt: AUTOR

note: type: textblock
en: This tutorial was written and is maintained by Sean Whitton <spwhitton@spwhitton.name>.  It contains contributions from other dgit contributors too - see the dgit copyright file.
pt: Este tutorial foi escrito e é mantido por Sean Whitton <spwhitton@spwhitton.name>.  Contém contributos de outros contribuidores do dgit também - veja o ficheiro copyright do dgit.

note: type: =head1
en: GIT CONFIGURATION
pt: CONFIGURAÇÃO DO GIT

note: type: textblock
en: dgit - tutorial for package maintainers, using a workflow centered around git-debrebase(1)
pt: dgit - tutorial para maintainers de pacote, usando um fluxo de trabalho centrado em redor do git-debrebase(1)

note: type: textblock
en: This document describes elements of a workflow for maintaining a non-native Debian package using B<dgit>.  We maintain the Debian delta as a series of git commits on our master branch.  We use git-debrebase(1) to shuffle our branch such that this series of git commits appears at the end of the branch.  All the public git history is fast-forwarding, i.e., we do not rewrite and force-push.
pt: Este documento descreve elementos dum fluxo de trabalho para manter um pacote Debian não-nativo usando o B<dgit>.  Nós mantemos o delta Debian como uma série de cometidos git no nosso ramo mestre.  Nós usados git-debrebase(1) para misturar o nosso ramo de tal modo que estas série de cometidos git aparecem no fim do ramo.  Todo o histórico git público é avançado-rápido, isto é, não não rescrevemos nem forçamos o empurrar.

note: type: textblock
en: Some advantages of this workflow:
pt: Algumas vantagens deste fluxo de trabalho:

note: type: textblock
en: Manipulate the delta queue using the full power of git-rebase(1), instead of relying on quilt(1), and without having to switch back and forth between patches-applied and patches-unapplied branches when committing changes and trying to build, as with gbp-pq(1).
pt: Manipular a fila delta usado o poder total do git-rebase(1), em vez de confiar em quilt(1), e sem ter que mudar para a frente e para trás entre ramos de patches-aplicadas e patches-não-aplicadas ao cometer alterações e ao tentar compilar, como com o gbp-pq(1).

note: type: textblock
en: If you are using 3.0 (quilt), provide your delta queue as a properly separated series of quilt patches in the source package that you upload to the archive (unlike with dgit-maint-merge(7)).
pt: Se você está a usar 3.0 (quilt), forneça a sua fila delta como uma série de patches quilt separadas por propriedades no pacote fonte que você enviou para o arquivo (ao contrário de com dgit-maint-merge(7)).

note: type: textblock
en: Avoid the git tree being dirtied by the application or unapplication of patches, as they are always applied.
pt: Evite que a árvore git fique suja pelo aplicar ou desaplicar de patches, pois elas são sempre aplicadas.

note: type: textblock
en: Provide your full git history in a standard format on B<dgit-repos>, where it can benefit downstream dgit users, such as people using dgit to do an NMU (see dgit-nmu-simple(7) and dgit-user(7)).
pt: Forneça um histórico git completo num formato standard em B<dgit-repos>, onde pode beneficiar os utilizadores do dgit de fluxos abaixo, tais como pessoas que usam o dgit para fazer um NMU (veja dgit-nmu-simple(7) e dgit-user(7)).

note: type: textblock
en: Minimise the amount you need to know about 3.0 (quilt) in order to maintain Debian source packages which use that format.
pt: Minimiza a quantidade de conhecimento que você precisa de ter sobre 3.0 (quilt) de modo a manter pacotes fonte Debian que usam esse formato.

note: type: textblock
en: This workflow is appropriate for packages where the Debian delta contains multiple pieces which interact, or which you don't expect to be able to upstream soon.  For packages with simple and/or short-lived Debian deltas, use of git-debrebase(1) introduces unneeded complexity.  For such packages, consider the workflow described in dgit-maint-merge(7).
pt: Este fluxo de trabalho é apropriado para pacotes onde o delta Debian contém múltiplas peças que interagem, ou os quais você não espera estar capaz de enviar ao autor em breve.  Para pacotes com deltas Debian simples e/ou de vida curta, o uso de git-debrebase(1) introduz complexidade desnecessária.  Para tais pacotes, considere o fluxo de trabalho descrito em dgit-maint-merge(7).

note: type: textblock
en: The final command detaches your master branch from the upstream remote, so that git doesn't try to push anything there, or merge unreleased upstream commits.  To maintain a copy of your packaging branch on B<salsa.debian.org> in addition to B<dgit-repos>, you can do something like this:
pt: O comando final desanexa o seu ramo mestre do remoto do autor, assim esse git não tenta enviar nada para lá, ou fundir cometidos do autor não lançados.  Para manter uma cópia do seu ramo de empacotamento em B<salsa.debian.org> adicionalmente a B<dgit-repos>, você pode fazer algo como isto:

note: type: textblock
en: Now go ahead and Debianise your package.  Make commits on the master branch, adding things in the I<debian/> directory, or patching the upstream source.  For technical reasons, B<it is essential that your first commit introduces the debian/ directory containing at least one file, and does nothing else.> In other words, make a commit introducing I<debian/> before patching the upstream source.
pt: Agora siga e Debianise o seu pacote.  Faça cometidos no ramo mestre, adicionando coisas no directório I<debian/>, ou aplicando patches na fonte do autor.  Por razões técnicas, B<é essencial que o seu primeiro cometer introduza o directório debian/ contendo pelo menos um ficheiro, e não faça mais nada.> Por outras palavras, faça um cometido a introduzir I<debian/> antes de aplicar patches à fonte do autor.

note: type: =head3
en: Comparing upstream's tarball releases
pt: Comparar lançamentos de tarball do autor

note: type: textblock
en: The above assumes that you know how to build the package from git and that doing so is straightforward.
pt: O que está em cima assume que você sabe como compilar o pacote a partir de git e que isso é feito diretamente.

note: type: textblock
en: If, as a user of the upstream source, you usually build from upstream tarball releases, rather than upstream git tags, you will sometimes find that the git tree doesn't contain everything that is in the tarball.
pt: Se, como um utilizador da fonte do autor, você geralmente compilar a partir de lançamentos em tarball do autor, em vez de etiquetas git do autor, você vai descobrir que por vezes a árvore git não contém tudo o que está no tarball.

note: type: textblock
en: Additional build steps may be needed.  For example, you may need your I<debian/rules> to run autotools.
pt: Podem ser necessários passos de compilação adicionais.  Por exemplo, você poderá precisar do seu I<debian/rules> para correr ferramentas automáticas.

note: type: textblock
en: You can compare the upstream tarball release, and upstream git tag, within git, by importing the tarball into git as described in the next section, using a different value for 'upstream-tag', and then using git-diff(1) to compare the imported tarball to the release tag.
pt: Você pode comparar o lançamento em tarball do autor, e a etiqueta git do autor, dentro do git, a importar o tarball para o git como descrito na próxima secção, usando um valor diferente para 'upstream-tag', e depois usando git-diff(1) para comparar o tarball importado com a etiqueta de lançamento.

note: type: textblock
en: One can generate such a versioned tag using git show's --pretty option. e.g.:
pt: Pode-se gerar tal etiqueta versionada usando a opção --pretty do git show, ex.:

note: type: textblock
en: Because we want to work in git, we need a virtual upstream branch with virtual release tags.  gbp-import-orig(1) can manage this for us.  To begin
pt: Porque nós queremos trabalhar em git, precisamos dum ramo de autor virtual com etiquetas de lançamento virtuais.  O gbp-import-orig(1) pode gerir isto para nós.  Para começar

note: type: textblock
en: This should leave you on the master branch.  Next, our upstream branch cannot be pushed to B<dgit-repos>, but since we will need it whenever we import a new upstream version, we must push it somewhere.  The usual choice is B<salsa.debian.org>:
pt: Isto deve deixa-lo no ramo mestre.  De seguida, o nosso ramo de autor não pode ser empurrado para B<dgit-repos>, mas como precisamos dele sempre que importamos uma nova versão de autor, temos de o meter nalgum lado.  A escolha do costume é B<salsa.debian.org>:

note: type: textblock
en: You are now ready to proceed as above, making commits to the I<debian/> directory and to the upstream source.  As above, for technical reasons, B<it is essential that your first commit introduces the debian/ directory containing at least one file, and does nothing else.> In other words, make a commit introducing I<debian/> before patching the upstream source.
pt: Você agora está pronto para prosseguir como em cima, fazendo cometidos para o directório I<debian/> e para a fonte do autor.  Como em cima, por razões técnicas, B<é essencial que o primeiro cometer introduza o directório debian/ contendo pelo menos um ficheiro, e não faça mais nada.> Por outras palavras, faça um cometido a introduzir I<debian/> antes de aplicar patches à fonte do autor.

note: type: textblock
en: A convenient way to ensure this requirement is satisfied is to start by creating I<debian/gbp.conf>:
pt: Uma maneira conveniente de assegurar que este requerimento está satisfeito é começar por criar I<debian/gbp.conf>:

note: type: textblock
en: and commit that:
pt: e cometer isso:

note: type: textblock
en: Note that we couldn't create I<debian/gbp.conf> before now for the same technical reasons which require our first commit to introduce I<debian/> without patching the upstream source.  That's why we had to pass a lot of options to our first call to gbp-import-orig(1).
pt: Note que não conseguimos criar I<debian/gbp.conf> antes de agora pelas mesmas razões técnicas que requerem que o nosso primeiro cometer introduza I<debian/> sem aplicar patches à fonte do autor.  É por isto que tivemos de passar muitas opções à nossa primeira chamada ao gbp-import-orig(1).

note: type: textblock
en: If you have an existing git history that you have pushed to an ordinary git server like B<salsa.debian.org>, we start with that.  If you don't already have it locally, you'll need to clone it, and obtain the corresponding orig.tar from the archive:
pt: Se você tem um histórico git existente que enviou para um servidor git normal como o B<salsa.debian.org>, nós começamos com isso.  Se você já não o tiver localmente, vai precisar de o clonar, e obter o orig.tar correspondente a partir do arquivo:

note: type: textblock
en: If you don't have any existing git history, or you have history only on the special B<dgit-repos> server, we start with B<dgit clone>:
pt: Se você  não tem um histórico git existente, ou tem o histórico apenas no servidor especial B<dgit-repos>, começamos com B<dgit clone>:

note: type: textblock
en: Then we make new upstream tags available:
pt: Então nós temos novas etiquetas de autor disponíveis:

note: type: textblock
en: We now use a B<git debrebase convert-from-*> command to convert your existing history to the git-debrebase(5) data model.  Which command you should use depends on some facts about your repository:
pt: Agora nós usamos um comando B<git debrebase convert-from-*> para converter o seu histórico existente para o modelo de dados git-debrebase(5).  Qual comando você deve usar depende de alguns factos sobre o seu repositório:

note: type: =item
en: (A) There is no delta queue.
pt: (A) Não existe uma fila delta.

note: type: textblock
en: If there do not exist any Debian patches, use
pt: Se não existirem nenhumas patches Debian, use

note: type: =item
en: (B) There is a delta queue, and patches are unapplied.
pt: (B) Existe uma fila delta, e as patches não estão aplicadas.

note: type: textblock
en: This is the standard git-buildpackage(1) workflow: there are Debian patches, but the upstream source is committed to git without those patches applied.  Use
pt: Este é o fluxo de trabalho standard do git-buildpackage(1): existem patches Debian, mas a fonte do autor é cometida ao git sem essas patches aplicadas.  Use

note: type: textblock
en: If you were not previously using dgit to upload your package (i.e. you were not using the workflow described in dgit-maint-gbp(7)), and you happen to have run B<dgit fetch sid> in this clone of the repository, you will need to pass I<--fdiverged> to this command.
pt: Se você não estava a usar dgit para enviar o seu pacote (isto é, você não estava a usar o fluxo de trabalho descrito em dgit-maint-gbp(7)), e você correu B<dgit fetch sid> neste clone do repositório, vai precisar de passar I<--fdiverged> a este comando.

note: type: =item
en: (C) There is a delta queue, and patches are applied.
pt: (C) Existe uma fila delta, e as patches estão aplicadas.

note: type: textblock
en: Finally, you need to ensure that your git HEAD is dgit-compatible, i.e., it is exactly what you would get if you deleted .git, invoked B<dpkg-buildpackage -S>, and then unpacked the resultant source package.
pt: Finalmente, você precisa assegurar que o seu CABEÇALHO git e compatível com dgit, isto é, é exatamente o que obteria se apagasse .git, invocasse B<dpkg-buildpackage -S>, e depois desempacotasse o pacote fonte resultante.

note: type: textblock
en: git-debrebase(1) does not yet support using B<git merge> to merge divergent branches of development (see "OTHER MERGES" in git-debrebase(5)).  You should configure git such that B<git pull> does not try to merge:
pt: O git-debrebase(1) ainda não suporta usar B<git merge> para fundir ramos divergentes de desenvolvimento (veja "OUTRAS FUSÕES" em git-debrebase(5)).  Você deve configurar o git de maneira que B<git pull> não tente a fusão:

note: type: textblock
en: Now when you pull work from other Debian contributors, git will rebase your work on top of theirs.
pt: Agora quando você puxar trabalho de outros contribuidores de Debian, o git irá re-basear o seu trabalho por cima do deles.

note: type: textblock
en: If you use this clone for upstream development in addition to Debian packaging work, you may not want to set this global setting.  Instead, see the B<branch.autoSetupRebase> and B<branch.E<lt>nameE<gt>.rebase> settings in git-config(5).
pt: Se você usar este clone para desenvolvimento de autor em adição em trabalho de empacotamento Debian, pode não querer definir esta definição global.  Em vez disto, veja as definições B<branch.autoSetupRebase> e B<branch.E<lt>nameE<gt>.rebase> em git-config(5).

note: type: =head1
en: IMPORTING NEW UPSTREAM RELEASES
pt: IMPORTAR NOVOS LANÇAMENTOS DO AUTOR

note: type: textblock
en: There are two steps: obtaining git refs that correspond to the new release, and importing that release using git-debrebase(1).
pt: Existem dois passos: obter referências git que correspondem ao novo lançamento, e importar esse lançamento usando git-debrebase(1).

note: type: =head2
en: Importing the release
pt: Importar o lançamento

note: type: textblock
en: This invocation of git-debrebase(1) involves a git rebase.  You may need to resolve conflicts if the Debian delta queue does not apply cleanly to the new upstream source.
pt: Esta invocação de git-debrebase(1) envolve um git re-base.  Você pode precisar de resolver conflitos se a fila delta Debian não se aplicar de modo limpo à nova fonte do autor.

note: type: textblock
en: If all went well, you can now review the merge of the new upstream release:
pt: Se tudo correu bem, você pode agora rever a fusão do novo lançamento do autor:

note: type: textblock
en: Also, diff with I<--name-status> and I<--diff-filter=ADR> to see just the list of added or removed files, which is useful to determine whether there are any new or deleted files that may need accounting for in your copyright file.
pt: Também, faça diff com I<--name-status> e I<--diff-filter=ADR> para ver apenas a lista de ficheiros adicionados ou removidos, o que é útil para determinar se existem ficheiros novos ou apagados que possam ter de ser declarados no seu ficheiro copyright.

note: type: =head1
en: EDITING THE DEBIAN PACKAGING
pt: EDITAR O EMPACOTAMENTO DEBIAN

note: type: textblock
en: Just make commits on master that change the contents of I<debian/>.
pt: Apenas faça cometidos em mestre que mudem o conteúdo de I<debian/>.

note: type: =head1
en: EDITING THE DELTA QUEUE
pt: EDITAR A FILA DE ESPERA DELTA

note: type: =head2
en: Adding new patches
pt: Adicionar novas patches

note: type: textblock
en: Adding new patches is straightforward: just make commits touching only files outside of the I<debian/> directory.  You can also use tools like git-revert(1), git-am(1) and git-cherry-pick(1).
pt: Adicionar novas patches é direto: apenas faça cometidos que mexam em apenas ficheiros fora do directório I<debian/>.  Você também pode usar ferramentas como git-revert(1), git-am(1) e git-cherry-pick(1).

note: type: =head2
en: Editing patches: starting a debrebase
pt: Editar patches: iniciar um debrebase

note: type: textblock
en: git-debrebase(1) is a wrapper around git-rebase(1) which allows us to edit, re-order and delete patches.  Run
pt: git-debrebase(1) é um envoltório em redor do git-rebase(1) que permite-nos editar, re-ordenar e apagar patches.  Corra

note: type: textblock
en: to start an interactive rebase.  You can edit, re-order and delete commits just as you would during B<git rebase -i>.
pt: para iniciar um rebase interativo.  Você pode editar, re-ordenar e apagar cometidos tal como fazia durante B<git rebase -i>.

note: type: =head2
en: Editing patches: finishing a debrebase
pt: Editar patches: acabar um debrebase

note: type: textblock
en: After completing the git rebase, your branch will not be a fast-forward of the git HEAD you had before the rebase.  This means that we cannot push the branch anywhere.  If you are ready to upload, B<dgit push-source> (or B<dgit push-built>) will take care of fixing this up for you.
pt: Após completar o git rebase, o seu ramo não vai estar em avanço rápido do CABEÇALHO git que tinha antes do rebase.  Isto significa que não podemos empurrar o ramo para lado nenhum.  Se você está pronto para enviar, o B<dgit push-source> (ou B<dgit push-built>) irá tratar de corrigir isto por si.

note: type: textblock
en: If you are not yet ready to upload, and want to push your branch to a git remote such as B<salsa.debian.org>,
pt: Se você ainda não está pronto para enviar, e quer empurrar o seu ramo para um git remoto tal como B<salsa.debian.org>,

note: type: textblock
en: Note that each time you conclude a debrebase you introduce a pseudomerge into your git history, which may make it harder to read.  Try to do all of the editing of the delta queue that you think will be needed for this editing session in a single debrebase, so that there is a single debrebase stitch.
pt: Note que cada vez que você conclui um debrebase você introduz em entrada de pseudo-fusão no seu histórico git, o que o pode tornar mais difícil de ler.  Tente fazer todas as sua edições da fila delta que pensa que vão ser necessárias para esta sessão de edição num único debrebase, para que haja um único ponto do debrebase.

note: type: textblock
en: You can use dpkg-buildpackage(1) for test builds.  When you are ready to build for an upload, use B<dgit sbuild>, B<dgit pbuilder> or B<dgit cowbuilder>.
pt: Você pode usar o dpkg-buildpackage(1) para compilações de teste.  Quando estiver pronto para compilar para um envio, use B<dgit sbuild>, B<dgit pbuilder> ou B<dgit cowbuilder>.

note: type: textblock
en: Upload with B<dgit push-source> or B<dgit push-built>.  Remember to pass I<--new> if the package is new in the target suite.
pt: Enviar com B<dgit push-source> ou B<dgit push-built>.  Lembre-se de passar I<--new> se o pacote for novo na suite alvo.

note: type: textblock
en: In some cases where you used B<git debrebase convert-from-gbp> since the last upload, it is not possible for dgit to make your history fast-forwarding from the history on B<dgit-repos>.  In such cases you will have to pass I<--trust-changelog> to dgit.  git-debrebase will normally tell you if this will be needed.
pt: Em alguns casos onde você usou B<git debrebase convert-from-gbp> desde o último envio, não é possível ao dgit avançar rápido o seu histórico a partir do histórico em B<dgit-repos>.  Em tais casos você vai ter que passar I<--trust-changelog> ao dgit.  O git-debrebase irá normalmente dizer-lhe se isto vai ser preciso.

note: type: textblock
en: If you want to upload with git-debpush(1), for the first upload you should pass the B<--quilt=linear> quilt mode option (see git-debpush(1)).
pt: Se você quer enviar com o git-debpush(1), para o primeiro envio você deve passar a opção de modo quilt B<--quilt=linear> (veja git-debpush(1)).

note: type: textblock
en: Right before uploading, if you did not just already do so, you might want to have git-debrebase(1) shuffle your branch such that the Debian delta queue appears right at the tip of the branch you will push:
pt: Mesmo antes do envio, se você não o fez já, você pode querer que o git-debrebase(1) baralhe o seu ramo de modo a que a fila delta Debian apareça mesmo na ponta do ramo que vai empurrar:

note: type: textblock
en: Note that this will introduce a new pseudomerge.
pt: Note que isto vai introduzir uma nova pseudo-fusão.

note: type: textblock
en: After dgit pushing, be sure to git push to B<salsa.debian.org>, if you're using that.
pt: Após o empurrar do dgit, certifique de fazer git push para B<salsa.debian.org>, se estiver a usar isso.

note: type: =head2
en: Illegal material
pt: Material ilegal

note: type: textblock
en: Here we explain how to handle material that is merely DFSG-non-free.  Material which is legally dangerous (for example, files which are actually illegal) cannot be handled this way.
pt: Aqui explicamos como lidar com material que é meramente DFSG-não-livre.  Material que é legalmente perigoso (por exemplo, ficheiros que são efectivamente ilegais) não pode ser lidado desta maneira.

note: type: verbatim
en: If you encounter possibly-legally-dangerous material in the upstream
    source code you should seek advice.  It is often best not to make a
    fuss on a public mailing list (at least, not at first).  Instead,
    email your archive administrators.  For Debian that is
     To: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org
pt: Se você encontrar material possivelmente-legalmente-perigoso no código
    fonte do autor deve procurar aconselhamento.  É geralmente melhor não
    levantar ondas numa lista de mail pública (pelo menos, não de início).  
    Em vez disso, mande email aos administradores do arquivo.  Para Debian
    isso é Para: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org

note: type: =head2
en: DFSG-non-free: When upstream tags releases in git
pt: DFSG-não-livre: Quando o autor lança etiquetas em git

note: type: textblock
en: Our approach is to maintain a DFSG-clean upstream branch, and create tags on this branch for each release that we want to import.  We then import those tags per "Importing the release", above.  In the case of a new package, we base our initial Debianisation on our first DFSG-clean tag.
pt: A nossa abordagem é manter um ramo de autor DFSG-limpo, e criar etiquetas neste ramo para cada lançamento que queremos importar.  Depois importamos essas etiquetas por "Importar o lançamento", em cima.  No caso de um pacote novo, nós baseamos a nossa Debianização inicial na nossa etiqueta DFSG-limpa.

note: type: textblock
en: For the first upstream release that requires DFSG filtering:
pt: Para o primeiro lançamento de autor que requer filtragem DFSG:

note: type: textblock
en: Now either proceed with "Importing the release" on the 1.2.3+dfsg tag, or in the case of a new package,
pt: Agora ou prosseguimos com "Importar o lançamento" na etiqueta 1.2.3+dfsg, ou no caso de um pacote novo,

note: type: textblock
en: and proceed with "INITIAL DEBIANISATION".
pt: e prosseguimos com "DEBIANIZAÇÃO INICIAL"

note: type: textblock
en: For subsequent releases (whether or not they require additional filtering):
pt: Para lançamentos subsequentes (precisem ou não de filtragem adicional):

note: type: verbatim
en:     % git checkout upstream-dfsg
        % git merge 1.2.4
        % git rm further-evil.bin # if needed
        % git commit -m "upstream version 1.2.4 DFSG-cleaned" # if needed
        % git tag -s 1.2.4+dfsg
        % git checkout master
        % # proceed with "Importing the release" on 1.2.4+dfsg tag
pt:     % git checkout upstream-dfsg
        % git merge 1.2.4
        % git rm further-evil.bin # se necessário
        % git commit -m "upstream version 1.2.4 DFSG-cleaned" # se necessário
        % git tag -s 1.2.4+dfsg
        % git checkout master
        % # proceder com "Importar o lançamento" na etiqueta 1.2.4+dfsg

note: type: textblock
en: Our upstream-dfsg branch cannot be pushed to B<dgit-repos>, but since we will need it whenever we import a new upstream version, we must push it somewhere.  Assuming that you have already set up an origin remote per the above,
pt: O nosso ramo autor-dfsg não pode ser enviado para B<dgit-repos>, mas como vamos precisar dele sempre que importamos uma nova versão de autor, temos de o empurrar para algum lado.  Assumindo que você já configurou um remoto de origem para o em cima,

note: type: =head2
en: DFSG-non-free: When upstream releases only tarballs
pt: DFSG-não-livre: Quando o autor lança apenas tarballs:

note: type: textblock
en: In the simplest case,
pt: No caso mais simples,

note: type: textblock
en: If that fails, because your branch and the NMUers' work represent divergent branches of development, you have a number of options.  Here we describe the two simplest.
pt: Se isso falhar, porque o seu ramo e o trabalho de quem faz NMU representam ramos divergentes de desenvolvimento, você tem um número de opções.  Aqui descrevemos as duas mais simples.

note: type: textblock
en: Note that you should not try to resolve the divergent branches by editing files in I<debian/patches>.  Changes there would either cause trouble, or be overwritten by git-debrebase(1).
pt: Note que você não deve tentar resolver os ramos divergentes ao editar ficheiros em I<debian/patches>.  As alterações lá ou iriam causar problemas, ou sobrescritas pelo git-debrebase(1).

note: type: =head2
en: Rebasing your work onto the NMU
pt: Re-basear o seu trabalho para o NMU

note: type: textblock
en: If the NMUer added new commits modifying the upstream source, you will probably want to debrebase before your next upload to tidy those up.
pt: Se quem fez o NMU adicionou cometidos a modificar a fonte do autor, você vai provavelmente querer fazer debrebase antes do próximo envio para arrumar as coisas.

note: type: textblock
en: For example, the NMUer might have used git-revert(1) to unapply one of your patches.  A debrebase can be used to strip both the patch and the reversion from the delta queue.
pt: Por exemplo, quem fez o NMU pode ter usado git-revert(1) para de-aplicar uma das suas patches.  Pode ser usado um debrebase para despir ambos a patch e a reversão da fila delta.

note: type: =head2
en: Manually applying the debdiff
pt: Aplicar manualmente o debdiff

note: type: textblock
en: If you cannot rebase because you have already pushed to B<salsa.debian.org>, say, you can manually apply the NMU debdiff, commit and debrebase.  The next B<dgit push> will require I<--trust-changelog>.
pt: Se não puder fazer rebase porque já empurrou para B<salsa.debian.org>, digamos, você pode aplicar manualmente o debdiff do NMU, cometer e fazer debrebase.  O próximo B<dgit push> vai requerer I<--trust-changelog>.

note: type: =head1
en: HINTS AND TIPS
pt: DICAS E SUGESTÕES

note: type: =head2
en: Minimising pseudomerges
pt: Minimizar as pseudo-fusões

note: type: textblock
en: Above we noted that each time you conclude a debrebase, you introduce a pseudomerge into your git history, which may make it harder to read.
pt: Em cima nós notamos que cada vez que você concluía um debrebase, você introduzia uma pseudo-fusão no seu histórico git, o que o pode tornar difícil de ler.

note: type: textblock
en: A simple convention you can use to minimise the number of pseudomerges is to B<git debrebase conclude> only right before you upload or push to B<salsa.debian.org>.
pt: Uma convenção simples que pode usar para minimizar o número de pseudo-fusões é fazer B<git debrebase conclude> apenas logo antes de enviar ou empurrar para B<salsa.debian.org>.

note: type: textblock
en: It is possible, though much less convenient, to reduce the number of pseudomerges yet further.  We debrebase only (i) when importing a new release, and (ii) right before uploading.  Instead of editing the existing delta queue, you append fixup commits (and reversions of commits) that alter the upstream source to the required state.  You can push and pull to and from B<salsa.debian.org> during this.  Just before uploading, you debrebase, once, to tidy everything up.
pt: É possível, apesar de muito menos conveniente, reduzir ainda mais o número de pseudo-fusões.  Fazemos debrebase apenas (1) quando importamos um novo lançamento, e (2) logo antes do envio.  Em vez de editar a fila delta existente, você acrescenta cometidos de correção (e reversões de cometidos) que alteram a fonte de autor para o estado requerido.  Você pode empurrar para e puxar de B<salsa.debian.org> durante isto.  Mesmo antes de enviar, você faz debrebase uma vez, para arrumar tudo.

note: type: =head2
en: The debian/patches directory
pt: O directório debian/patches

note: type: textblock
en: In this workflow, I<debian/patches> is purely an output of git-debrebase(1).  You should not make changes there.  They will either cause trouble, or be ignored and overwritten by git-debrebase(1).
pt: Neste fluxo de trabalho, I<debian/patches> é puramente uma saída do git-debrebase(1).  Você não deve fazer alterações lá.  Elas irão ou causar problemas, ou serem ignoradas e sobrescritas pelo git-debrebase(1).

note: type: textblock
en: I<debian/patches> will often be out-of-date because git-debrebase(1)  will only regenerate it when it needs to.  So you should not rely on the information in that directory.  When preparing patches to forward upstream, you should use git-format-patch(1) on git commits, rather than sending files from I<debian/patches>.
pt: I<debian/patches> vai estar muitas vezes desatualizado porque o git-debrebase(1) irá apenas regenera-lo quando precisa de o fazer.  Assim você não se deve basear na informação nesse directório.  Ao preparar patches para encaminhar ao autor, você deve usar git-format-patch(1) em cometidos git, em vez de enviar ficheiros de I<debian/patches>.

note: type: =head2
en: Upstream branches
pt: Ramos do autor

note: type: textblock
en: In this workflow, we specify upstream tags rather than any branches.
pt: Neste fluxo de trabalho, nós especificamos etiquetas de autor em vez de quaisquer ramos.

note: type: textblock
en: Except when (i) upstream releases only tarballs, (ii) we require DFSG filtering, or (iii) you also happen to be involved in upstream development, we do not maintain any local branch corresponding to upstream, except temporary branches used to prepare patches for forwarding, and the like.
pt: Excepto quando (1) o autor lança apenas tarballs, (2) nós requeremos filtragem DFSG, ou (3) você também está envolvido com o desenvolvimento do autor, nós não mantemos nenhum ramo local correspondente ao autor, excepto ramos temporários usados para preparar patches para encaminhar, e coisas parecidas.

note: type: textblock
en: The idea here is that from Debian's point of view, upstream releases are immutable points in history.  We want to make sure that we are basing our Debian package on a properly identified upstream version, rather than some arbitrary commit on some branch.  Tags are more useful for this.
pt: A ideia aqui é que do ponto de vista de Debian, os lançamentos do autor são pontos imutáveis na história.  Nós queremos ter certeza que estamos a basear o nosso pacote Debian numa versão do autor identificada apropriadamente, em vez de qualquer cometido arbitrário em algum ramo.  As etiquetas são mais úteis para isto.

note: type: textblock
en: Upstream's branches remain available as the git remote tracking branches for your upstream remote, e.g. I<remotes/upstream/master>.
pt: Os ramos de autor continuam disponíveis como os ramos de acompanhamento do git remoto para o seu remoto de autor, ex. I<remotes/upstream/master>.

note: type: =head2
en: The first ever dgit push
pt: O primeiro dgit push de sempre

note: type: textblock
en: If this is the first ever dgit push of the package to this suite, consider passing I<--deliberately-not-fast-forward> instead of I<--trust-changelog>.  This avoids introducing a new origin commit into your git history.  (This origin commit would represent the most recent non-dgit upload of the package, but this should already be represented in your git history.)
pt: Se este é o primeiro dgit push do pacote para esta suite, considere passar I<--deliberately-not-fast-forward> em vez de I<--trust-changelog>.  Isto evita introduzir um novo cometer de origem no seu histórico git.  (Este cometer de origem iria representar o envio não-dgit mais recente do pacote, mas isto já deve estar representado no seu histórico git.)

note: type: =head2
en: Inspecting the history
pt: Inspecionar o histórico

note: type: textblock
en: The git history made by git-debrebase can seem complicated.  Here are some suggestions for helpful invocations of gitk and git.  They can be adapted for other tools like tig(1), git-log(1), magit, etc.
pt: O histórico git criado por git-debrebase pode parecer complicado.  Aqui estão algumas sugestões para invocações de ajuda de gitk e git.  Elas podem ser adaptadas para outras ferramentas como tig(1), git-log(1), magit, etc.

note: type: textblock
en: History of package in Debian, disregarding history from upstream:
pt: História do pacote em Debian, descartando a história do autor:

note: type: textblock
en: In a laundered branch, the delta queue is at the top.
pt: Num ramo lavado, a fila delta fica no topo.

note: type: textblock
en: History of the packaging, excluding the delta queue:
pt: História do empacotamento, excluindo a fila delta:

note: type: textblock
en: Just the delta queue (i.e. Debian's changes to upstream):
pt: Apenas a fila delta (isto é, as alterações Debian à fonte do autor):

note: type: textblock
en: Full history including old versions of the delta queue:
pt: Histórico completo incluindo versões antigas da fila delta:

note: type: textblock
en: The "Declare fast forward" commits you see have an older history (usually, an older delta queue) as one parent, and a newer history as the other.  --date-order makes gitk show the delta queues in the right order.
pt: Os cometidos "Declara avanço rápido" que vê têm um histórico mais antigo (geralmente uma fila delta mais antiga) que um pai, e uma história mais recente que o outro.  --date-order faz o gitk mostrar as filas delta na ordem certa.

note: type: textblock
en: Complete diff since the last upload:
pt: Diff completo deste o último envio:

note: type: textblock
en: This includes changes to upstream files.
pt: Isto inclui alterações aos ficheiros do autor.

note: type: textblock
en: Interdiff of delta queue since last upload, if you really want it:
pt: Interdiff da fila delta desde o último envio, se você realmente o quiser:

note: type: textblock
en: And of course there is:
pt: E claro existe isto:

note: type: =head2
en: Alternative ways to start a debrebase
pt: Maneiras alternativas de arrancar um debrebase

note: type: textblock
en: Above we started an interactive debrebase by invoking git-debrebase(1)  like this:
pt: Em cima nós arrancamos um debrebase interactivo ao invocar o git-debrebase(1)  como isto:

note: type: textblock
en: It is also possible to perform a non-interactive rebase, like this:
pt: É também possível efetuar um re-base não interactivo, como isto:

note: type: verbatim
en:     % git debrebase -- [git-rebase options...]
pt:     % git debrebase -- [opções de git-rebase...]

note: type: textblock
en: A third alternative is to have git-debrebase(1) shuffle all the Debian changes to the end of your branch, and then manipulate them yourself using git-rebase(1) directly.  For example,
pt: Uma terceira alternativa é ter o git-debrebase(1) a baralhar todas as alterações Debian no fim do seu ramo, e depois manipula-los você mesmo usando o git-rebase(1) diretamente.  Por exemplo,

note: type: verbatim
en:     % git debrebase
        % git rebase -i HEAD~5      # there are 4 Debian patches
pt:     % git debrebase
        % git rebase -i HEAD~5      # existem 4 patches Debian

note: type: textblock
en: If you take this approach, you should be very careful not to start the rebase too early, including before the most recent pseudomerge.  git-rebase without a base argument will often start the rebase too early, and should be avoided.  Run git-debrebase instead.  See also "ILLEGAL OPERATIONS" in git-debrebase(5).
pt: Se você tomar esta abordagem, deve ter muito cuidado de não arrancar o rebase demasiado cedo, incluindo antes da pseudo-fusão mais recente.  O git-rebase sem um argumento base vai muitas vezes iniciar o rebase mito cedo, e deve ser evitado.  Corra git-debrebase em vez disso.  Veja também "OPERAÇÕES ILEGAIS" em git-debrebase(5).
