dgit 13.14 git-debrebase_1 - en to pt translation catalogue (137 entries)

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

note: type: =head1
en: SYNOPSIS
pt: RESUMO

note: type: =head1
en: OPTIONS
pt: OPÇÕES

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

note: type: textblock
en: git-debrebase - tool to maintain series of Debian changes to upstream source
pt: git-debrebase - ferramenta para manter série de alterações Debian na fonte do autor

note: type: verbatim
en:  git-debrebase [<options...>] [-- <git-rebase options...>]
     git-debrebase [<options...>] <operation> [<operation options...>
pt:  git-debrebase [<opções...>] [-- <opções do git-rebase...>]
     git-debrebase [<opções...>] <operação> [<opções da operação...>

note: type: =head1
en: QUICK REFERENCE
pt: REFERÊNCIA RÁPIDA

note: type: textblock
en: These are most of the commands you will regularly need:
pt: Esta é a maioria dos comandos que você vai precisar regularmente:

note: type: verbatim
en:  git debrebase -i                           # edit the patch queue
     git debrebase conclude && git push         # push to eg salsa
     git debrebase conclude && dgit push-source # source-only upload
     git debrebase new-upstream 1.2.3-1 [-i]    # uses tag, eg "v1.2.3"
     dpkg-buildpackage -uc -b                   # get test debs, at any time
pt:  git debrebase -i                           # edita a fila de patch
     git debrebase conclude && git push         # empurra para por ex salsa
     git debrebase conclude && dgit push-source # envio de apenas-fonte
     git debrebase new-upstream 1.2.3-1 [-i]    # usa etiqueta, ex "v1.2.3"
     dpkg-buildpackage -uc -b                   # obtém debs de teste, a qualquer altura

note: type: textblock
en: To add patches, or edit the packaging, just make git commits.  Ignore anything that may appear in debian/patches.  Avoid using "git pull" and "git merge" without "--ff-only".
pt: Para adicionar patches, ou editar o empacotamento, apenas faça cometidos git.  Ignore tudo o que possa aparecer em debian/patches.  Evite usar "git pull" e "git merge" sem "--ff-only".

note: type: textblock
en: When sharing branches, you should usually share a fast-forwarding branch (ie, use C<git-debrebase conclude> (or C<prepush>) before pushing.
pt: Ao partilhar ramos, você deve normalmente partilhar um ramo de avanço rápido, isto é, C<git-debrebase conclude> (ou C<prepush>) antes de empurrar.

note: type: textblock
en: git-debrebase has a special branch format, so see "CONVERTING AN EXISTING PACKAGE" in L<dgit-maint-debrebase(7)>.
pt: git-debrebase tem um formato de ramo especial, assim veja "CONVERTENDO UM PACOTE EXISTENTE" em L<dgit-maint-debrebase(7)>.

note: type: =head1
en: GUIDE TO DOCUMENTATION
pt: GUIA PARA DOCUMENTAÇÃO

note: type: textblock
en: This is the command line reference.  There is also a detailed workflow tutorial at L<dgit-maint-debrebase(7)> (on which the above "QUICK REFERENCE" is based).  For background, theory of operation, and definitions see L<git-debrebase(5)>.
pt: Esta é a referência de linha de comandos.  Existe também um tutorial de fluxo de trabalho detalhado em L<dgit-maint-debrebase(7)> (no qual a "REFERÊNCIA RÁPIDA" em cima é baseada).  Para bastidores, teoria de operação, e definições veja L<git-debrebase(5)>.

note: type: textblock
en: You should read this manpage in conjunction with L<git-debrebase(5)/TERMINOLOGY>, which defines many important terms used here.
pt: Você deve ler este manual em conjunto com L<git-debrebase(5)/TERMINOLOGIA>, o qual define muitos termos importantes aqui usados.

note: type: =head1
en: PRINCIPAL OPERATIONS
pt: OPERAÇÕES PRINCIPAIS

note: type: =item
en: git-debrebase [-- <git-rebase options...>]
pt: git-debrebase [-- <opções de git-rebase...>]

note: type: =item
en: git-debrebase [-i <further git-rebase options...>]
pt: git-debrebase [-i <mais opções de git-rebase...>]

note: type: textblock
en: Unstitches and launders the branch.  (See L</UNSTITCHING AND LAUNDERING> below.)
pt: Descoser e lavar o ramo.  (veja L<DESCOSER E LAVAGEM> em baixo.)

note: type: textblock
en: Then, if any git-rebase options were supplied, edits the Debian delta queue, using git-rebase, by running
pt: Então, se algumas opções de git-rebase forem fornecidas, edita a fila delta Debian, usando o git-rebase, ao correr

note: type: verbatim
en:     git rebase <git-rebase options> <breakwater-tip>
pt:     git rebase <opções de git-rebase> <ponta-de-quebra-mar>

note: type: textblock
en: Do not pass a base branch argument: git-debrebase will supply that.  Do not use --onto, or --fork-point.  Useful git-rebase options include -i and --autosquash.
pt: Não passe o argumento de ramo base: git-debrebase irá fornecer isso.  Não use --onto, ou --fork-point.  Opções úteis do git-rebase incluem -i e --autosquash.

note: type: textblock
en: If git-rebase stops for any reason, you may git-rebase --abort, --continue, or --skip, as usual.  If you abort the git-rebase, the branch will still have been laundered, but everything in the rebase will be undone.
pt: Se o git-rebase parar por qualquer razão, você pode git-rebase --abort, --continue, ou --skip, como normal,  Se você abortar o git-rebase, o ramo irá continuar lavado, mas tudo em rebase será desfeito.

note: type: textblock
en: The options for git-rebase must either start with C<-i>, or be prececded by C<-->, to distinguish them from options for git-debrebase.
pt: As opções para git-rebase têm de ou começar com C<-i>, ou serem precedidas por C<-->, para as distinguir das opções para git-debrebase.

note: type: textblock
en: It is hazardous to use plain git-rebase on a git-debrebase branch, because git-rebase has a tendency to start the rebase too far back in history, and then drop important commits.  See L<git-debrebase(5)/ILLEGAL OPERATIONS>
pt: É perigoso usar git-rebase simples num ramo git-debrebase, porque o git-rebase tem tendência de começar a rebase demasiado atrás no histórico, e depois largar cometidos importantes.  Veja L<git-debrebase(5)/OPERAÇÕES ILEGAIS>

note: type: textblock
en: Analyses the current branch, both in terms of its contents, and the refs which are relevant to git-debrebase, and prints a human-readable summary.
pt: Analisa o ramo atual, tanto em termos de do seu conteúdo, e das referências que são relevantes para o git-debrebase, e escreve um sumário legível por humanos.

note: type: textblock
en: To examine a commit, rather than your current branch, use C<git-debrebase examine>.
pt: Para examinar um cometido, em vez do seu ramo atual, use C<git-debrebase examine>.

note: type: textblock
en: Please do not attempt to parse the output; it may be reformatted or reorganised in the future.  Instead, use one of the L<UNDERLYING AND SUPPLEMENTARY OPERATIONS> described below.
pt: Por favor não tente analisar o resultado; poderá vir a ser reformatado ou reorganizado no futuro.  Em vez disso, use uma das L<OPERAÇÕES SUBJACENTES E SUPLEMENTARES> descritas sem baixo.

note: type: textblock
en: Finishes a git-debrebase session, tidying up the branch and making it fast forward again.
pt: Termina uma sessão git-debrebase, arrumando o ramo e tornando-o de novo em avanço rápido.

note: type: textblock
en: Specifically: if the branch is unstitched, launders and restitches it, making a new pseudomerge.  Otherwise, it is an error, unless --noop-ok.
pt: Especificamente: se o ramo estiver descosido, lava-o e cose-o, fazendo uma nova pseudo-fusão.  Caso contrário, é um erro, a menos que --noop-ok.

note: type: textblock
en: Unconditionally launders and restitches the branch, consuming any ffq-prev and making a new pseudomerge.
pt: Lava e recose incondicionalmente o ramo, consumindo quaisquer ffq-prev e fazendo uma nova pseudo-fusão.

note: type: textblock
en: If the branch is already laundered and stitched, does nothing.
pt: Se o ramo já estiver lavado e recosido, não faz nada.

note: type: =item
en: git-debrebase prepush [--prose=<for commit message>]
pt: git-debrebase prepush [--prose=<para mensagem de cometido>]

note: type: textblock
en: If the branch is unstitched, stitches it, consuming ffq-prev.
pt: Se o ramo está descosido, cose-o, consumindo ffq-prev.

note: type: textblock
en: This is a good command to run before pushing to a git server.  You should consider using B<conclude> instead, because that launders the branch too.
pt: É um bom comando para correr antes de empurrar para um servidor git.  Você deve considerar usar B<conclude> em vez deste, porque também lava o ramo.

note: type: =item
en: git-debrebase stitch [--prose=<for commit message>]
pt: git-debrebase stitch [--prose=<para mensagem de cometido>]

note: type: textblock
en: Stitches the branch, consuming ffq-prev.
pt: Cose o ramo, consumindo ffq-prev.

note: type: textblock
en: If there is no ffq-prev, it is an error, unless --noop-ok.
pt: Se não existir nenhum ffq-prev, é um erro, a menos que --noop-ok.

note: type: textblock
en: You should consider using B<prepush> or B<conclude> instead.
pt: Você deve considerar usar B<prepush> ou B<conclude> em vez disto.

note: type: textblock
en: Throws away all the work since the branch was last stitched.  This is done by resetting you to ffq-prev and discarding all working tree changes.
pt: Deita fora todo o trabalho desde que o ramo foi cosido a última vez.  Isto é feito ao reiniciando-o para ffq-prev e descartando todas as alterações na árvore de trabalho.

note: type: textblock
en: If you are in the middle of a git-rebase, will abort that too.
pt: Se você estiver a meio de um git-rebase, irá abortar isso também.

note: type: =item
en: git-debrebase new-upstream <new-version> [<upstream-details>...] [--|-i <git-rebase options...>]
pt: git-debrebase new-upstream <nova-versão> [<detalhes-do-autor>...] [--|-i <opções do git-rebase...>]

note: type: textblock
en: Rebases the delta queue onto a new upstream version.  In detail:
pt: Re-baseia a fila delta na nova versão de autor. Em detalhe:

note: type: textblock
en: Firstly, checks that the proposed rebase seems to make sense: It is a snag unless the new upstream(s)  are fast forward from the previous upstream(s)  as found in the current breakwater anchor.  And, in the case of a multi-piece upstream (a multi-component upstream, in dpkg-source terminology), if the pieces are not in the same order, with the same names.
pt: Em primeiro lugar, verifica se o rebase proposto parece fazer sentido: É um estorvo a menos que a nova autoria tenha avanço rápido em relação à autoria anterior como encontrada na âncora de quebra-mar atual.  E, no caso duma autoria multi-partes (uma autoria de múltiplos componentes, em terminologia do dpkg-source), se as partes não estão na mesma ordem, com os mesmos nomes.

note: type: textblock
en: If all seems well, unstitches and launders the branch.
pt: Se tudo parecer bem, descose e lava o ramo.

note: type: textblock
en: Then, generates (in a private working area)  a new anchor merge commit, on top of the breakwater tip, and on top of that a commit to update the version number in debian/changelog.
pt: Depois gera (numa área de trabalho privada) uma nova âncora de cometido de fusão, no topo da ponta do quebra-mar, e no topo disso um cometido para atualizar o numero de versão em debian/changelog.

note: type: textblock
en: Finally, starts a git-rebase of the delta queue onto these new commits.
pt: Finalmente, arranca um git-rebase da fila delta nestes novos cometidos.

note: type: textblock
en: That git-rebase may complete successfully, or it may require your assistance, just like a normal git-rebase.
pt: Esse git-rebase pode completar com  sucesso, ou pode requerer a sua assistência, tal com um git-rebase normal.

note: type: textblock
en: If you git-rebase --abort, the whole new upstream operation is aborted, except for the laundering.
pt: Se você fizer git-rebase --abort, toda a nova operação de autor é abortada, excepto a lavagem.

note: type: textblock
en: <new-version> may be a whole new Debian version, including revision, or just the upstream part, in which case -1 will be appended to make the new Debian version.
pt: <nova-versão> pode ser a nova versão Debian completa, incluindo a revisão, ou apenas a parte do autor, que nesse caso será acrescentado -1 para fazer a nova versão Debian.

note: type: textblock
en: The <upstream-details> are, optionally, in order:
pt: Os <detalhes-do-autor> são, opcionalmente, em ordem:

note: type: textblock
en: The new upstream branch (or commit-ish).  The default is to look for one of these tags, in this order: U vU upstream/U; where U is the new upstream version.  (This is the same algorithm as L<git-deborig(1)>.)
pt: O novo ramo do autor (ou commit-ish).  A predefinição é procurar por uma destas etiquetas, nesta ordem: U vU upstream/U; onde U é a nova versão do autor.  (este é o mesmo algoritmo que L<git-deborig(1)>.)

note: type: textblock
en: It is a snag if the upstream contains a debian/ directory; if forced to proceed, git-debrebase will disregard the upstream's debian/ and take (only) the packaging from the current breakwater.
pt: E um estorvo se a autoria conter um directório debian/; se forçado a prosseguir, o git-debrebase irá desconsiderar o debian/ do autor e tomar (apenas) o empacotamento a partir do quebra-mar atual.

note: type: textblock
en: Specifies that this is a multi-piece upstream.  May be repeated.
pt: Especifica que isto é uma autoria multi-parte.  Pode ser repetido.

note: type: textblock
en: When such a pair is specified, git-debrebase will first combine the pieces of the upstream together, and then use the result as the combined new upstream.
pt: Quando tal par é especificado, o git-debrebase irá primeiro combinar as partes da autoria juntamente, e depois usar o resultado como a nova autoria combinada.

note: type: textblock
en: For each <piece-name>, the tree of the <piece-upstream-commit-ish> becomes the subdirectory <piece-name> in the combined new upstream (supplanting any subdirectory that might be there in the main upstream branch).
pt: Para cada <piece-name>, a árvore da <piece-upstream-commit-ish> torna-se o sub-directório <piece-name> na nova autoria combinada (suplantando qualquer sub-directório que possa estar no ramo de autor principal).

note: type: textblock
en: <piece-name> has a restricted syntax: it may contain only ASCII alphanumerics and hyphens.
pt: <piece-name> tem uma sintaxe restrita: só pode conter alfanuméricos ASCII e hífens.

note: type: textblock
en: The combined upstream is itself recorded as a commit, with each of the upstream pieces' commits as parents.  The combined commit contains an annotation to allow a future git-debrebase new upstream operation to make the coherency checks described above.
pt: A autoria combinada é ela própria gravada como um cometido, com cada um dos cometidos de partes de autoria como pais.  O cometido combinado contém uma anotação para permitir a uma nova operação git-debrebase de autor futura fazer as verificações de coerência descritas em cima.

note: type: =item
en: <git-rebase options>
pt: <opções do git-rebase>

note: type: textblock
en: These will be passed to git rebase.
pt: Estas serão passadas ao git rebase.

note: type: textblock
en: If the upstream rebase is troublesome, -i may be helpful.  As with plain git-debrebase, do not specify a base, or --onto, or --fork-point.
pt: Se o rebase do autor for problemático, -i pode ser uma ajuda.  Tal como com git-debrebase simples, não especifique uma base, nem --onto, nem --fork-point.

note: type: textblock
en: If you are planning to generate a .dsc, you will also need to have, or generate, actual orig tarball(s), which must be identical to the rev-spec(s)  passed to git-debrebase.  git-debrebase does not concern itself with source packages so neither helps with this, nor checks it.  L<git-deborig(1)>, L<git-archive(1)>, L<dgit(1)> and L<gbp-import-orig(1)> may be able to help.
pt: Se você planeia gerar um .dsc, também vai precisar de ter, ou gerar, tarball(s) orig reais, que têm de ser idênticos aos rev-spec(s)  passados ao git-debrebase.  O git-debrebase não se ocupa ele próprio com pacotes fonte, assim nem ajuda com isto, nem verifica.  L<git-deborig(1)>, L<git-archive(1)>, L<dgit(1)> e L<gbp-import-orig(1)> podem ser capazes de ajudar.

note: type: textblock
en: Generate patches in debian/patches/ representing the changes made to upstream files.
pt: Gera patches em debian/patches/ que representam as alterações feitas aos ficheiros do autor.

note: type: textblock
en: It is not normally necessary to run this command explicitly.  When uploading to Debian, dgit and git-debrebase will cooperate to regenerate patches as necessary.  When working with pure git remotes, the patches are not needed.
pt: Não é normalmente necessário correr este comando explicitamente.  Ao enviar para Debian, dgit e git-debrebase irão cooperar para regenerar as patches como necessário.  Quando se trabalha com remotos git puros, as patches não são necessárias.

note: type: textblock
en: Normally git-debrebase make-patches will require a laundered branch.  (A laundered branch does not contain any patches.)  But if there are already some patches made by git-debrebase make-patches, and all that has happened is that more changes to upstream files have been committed, running it again can add the missing patches.
pt: Normalmente git-debrebase make-patches irá requerer um ramo lavado.  (Um ramo lavado não contém nenhumas patches.)  Mas se já existirem algumas patches feitas por git-debrebase make-patches, e tudo o que aconteceu foi que mais alterações aos ficheiros do autor foram cometidas, correr-lo outra vez pode adicionar as patches em falta.

note: type: textblock
en: If the patches implied by the current branch are not a simple superset of those already in debian/patches, make-patches will fail with exit status 7, and an error message.  (The message can be suppressed with --quiet-would-amend.)  If the problem is simply that the existing patches were not made by git-debrebase, using dgit quilt-fixup instead should succeed.
pt: Se as patches implicadas pelo ramo atual não forem um super conjunto simples daquelas que já estão em debian/patches, make-patches irá falhar com estado de saída 7, e uma mensagem de erro.  (A mensagem pode ser suprimida com --quiet-would-amend.)  Se o problema for simplesmente que as patches existentes não foram feitas pelo git-debrebase, usar dgit quilt-fixup em vez disto deve ter sucesso.

note: type: textblock
en: Converts any of the following into a git-debrebase interchange branch:
pt: Converte qualquer um do seguinte num ramo de intercâmbio git-debrebase.

note: type: textblock
en: a gbp patches-unapplied branch (but not a gbp pq patch-queue branch)
pt: um ramo gbp de patches não aplicadas (mas não um ramo gbp de fila de patch pq)

note: type: textblock
en: a patches-unapplied git packaging branch containing debian/patches, as used with quilt
pt: um ramo de empacotamento git de patches não aplicadas contendo debian/patches, como usado com quilt

note: type: textblock
en: a git branch for a package which has no Debian delta - ie where upstream files are have not been modified in Debian, so there are no patches
pt: um ramo git para um pacote que não tem delta Debian - isto é, onde os ficheiros de autor não foram modificados em Debian, assim não existem patches

note: type: textblock
en: (These two commands operate identically and are simply aliases.)
pt: (Estes dois comandos operam de modo idêntico e são simplesmente nomes alternativos.)

note: type: textblock
en: The conversion is done by generating a new anchor merge, converting any quilt patches as a delta queue, and dropping the patches from the tree.
pt: A conversão é feita ao gerar uma nova fusão de âncora, convertendo quaisquer patches quilt numa fila delta, e descartando as patches da árvore.

note: type: textblock
en: The upstream commit-ish should correspond to the upstream branch or tag, if there is one.  It is a snag if it is not an ancestor of HEAD, or if the history between the upstream and HEAD contains commits which make changes to upstream files.  If it is not specified, the same algorithm is used as for git-debrebase new-upstream.
pt: O commit-ish do autor deve corresponder ao ramo ou etiqueta do autor, se existir um.  É um estorvo se não for um ancestral do CABEÇALHO, ou se o histórico entre o autor e o CABEÇALHO conter cometidos que fazem alterações aos ficheiros do autor.  Se não for especificado, é usado o mesmo algoritmo que para git-debrebase new-upstream.

note: type: textblock
en: It is also a snag if the specified upstream has a debian/ subdirectory.  This check exists to detect certain likely user errors, but if this situation is true and expected, forcing it is fine.
pt: É também um estorvo se a autoria especificada tiver um sub-directório debian/.  Esta verificação existe para detetar certos erros prováveis do utilizador, mas se esta situação é verdadeira e esperada, força-la é bom.

note: type: textblock
en: git-debrebase will try to look for the dgit archive view of the most recent release, and if it finds it will make a pseduomerge so that your new git-debrebase view is appropriately fast forward.
pt: git-debrebase irá tentar procurar pela vista de arquivo dgit do lançamento mais recente, e se a encontrar irá fazer uma pseudo-fusão para que a sua nova vista git-debrebase seja avançada rapidamente de modo apropriado.

note: type: textblock
en: The result is a well-formed git-debrebase interchange branch.  The result is also fast-forward from the original branch.
pt: O resultado é um ramo de intercâmbio git-debrebase bem formado.  O resultado é também de avanço-rápido a partir do ramo original.

note: type: textblock
en: It is a snag if the new branch looks like it will have diverged, just as for a laundering/unstitching call to git-debrebase; See L</Establish the current branch's ffq-prev>, below.
pt: É um estorvo se o novo ramo parecer que vai divergir, assim como para uma chamada de lavar/descoser ao git-debrebase; Veja L</Estabelecer o ffq-prev do ramo atual>, em baixo.

note: type: textblock
en: Note that it is dangerous not to know whether you are dealing with a (gbp) patches-unapplied branch containing quilt patches, or a git-debrebase interchange branch.  At worst, using the wrong tool for the branch format might result in a dropped patch queue!
pt: Note que é perigoso não saber se está a lidar com um ramo de patches não aplicas (gbp) que contém patches quilt, ou com um ramo de intercâmbio git-debrebase. Na pior das hipóteses, usar a ferramenta errada para o formato do ramo pode resultar na perda da fila de patch!

note: type: =item
en: git-debrebase examine COMMITISH
pt: git-debrebase examine COMETIDO

note: type: textblock
en: Analyses the contents of COMMITISH, and prints a human-readable summary.
pt: Analisa o conteúdo de COMETIDO, e escreve um sumário legível por humanos.

note: type: textblock
en: As with C<git-debrebase status>, please do not attempt to parse the output.
pt: Tal como com C<git-debrebase status>, por favor não tente analisar o resultado.

note: type: =head1
en: UNDERLYING AND SUPPLEMENTARY OPERATIONS
pt: OPERAÇÕES SUBJACENTES E SUPLEMENTARES

note: type: textblock
en: Prints the breakwater tip commitid.  If your HEAD branch is not fully laundered, prints the tip of the so-far-laundered breakwater.
pt: Escreve a ponta de quebra-mar cometida.  Se o seu ramo CABEÇALHO não está completamente lavado, escreve a ponta do quebra-mar lavado-até-agora.

note: type: textblock
en: Prints the breakwater anchor commitid.
pt: Escreve a âncora de quebra-mar cometida.

note: type: textblock
en: Walks the history of the current branch, most recent commit first, back until the most recent anchor, printing the commit object id, and commit type and info (ie the semantics in the git-debrebase model)  for each commit.
pt: Navega no histórico do ramo atual, os cometidos mais recentes primeiro, recua até à âncora mais recente, escrevendo o id de objeto cometido, e tipo de cometido, e informação (isto e, as semânticas no modelo git-debrebase) para cada cometido.

note: type: textblock
en: Establishes the current branch's ffq-prev, as discussed in L</UNSTITCHING AND LAUNDERING>, but does not launder the branch or move HEAD.
pt: Estabelece o ffq-prev do ramo atual, como discutido em L</DESCOSER E LAVAGEM>, mas não lava o ramo, nem move o CABEÇALHO.

note: type: textblock
en: It is an error if the ffq-prev could not be recorded.  It is also an error if an ffq-prev has already been recorded, unless --noop-ok.
pt: É um erro se o ffq-prev não pude ser gravado.  É também um erro se um ffq-prev já estiver gravado, a menos que --noop-ok.

note: type: textblock
en: Converts a laundered branch into a gbp patches-unapplied branch containing quilt patches.  The result is not fast forward from the interchange branch, and any ffq-prev is deleted.
pt: Converte um ramo lavado num ramo gbp de patches não aplicadas contendo patches quilt  O resultado não é de avanço rápido a partir do ramo de intercâmbio, e qualquer ffq-prev é apagado.

note: type: textblock
en: This is provided mostly for the test suite and for unusual situations.  It should only be used with care and with a proper understanding of the underlying theory.
pt: Isto é fornecido na maioria para a suite de teste e para situações pouco usuais.  Deve ser apenas usado com cuidado e com conhecimento apropriado da teoria subjacente.

note: type: textblock
en: Be sure to not accidentally treat the result as a git-debrebase branch, or you will drop all the patches!
pt: Certifique-se que não trata acidentalmente o resultado como um ramo git-debrebase, ou vai perder todas as patches!

note: type: =item
en: git-debrebase convert-from-dgit-view [<convert-options>] [upstream]
pt: git-debrebase convert-from-dgit-view [<opções-de-convert>] [upstream]

note: type: textblock
en: Converts any dgit-compatible git branch corresponding to a (possibly hypothetical) 3.0 quilt dsc source package into a git-debrebase-compatible branch.
pt: Converte qualquer ramo git compatível com dgit correspondente a um (possibilidade hipotética) pacote fonte 3.0 quilt dsc num ramo compatível com git-debrebase.

note: type: textblock
en: This operation should not be used if the branch is already in git-debrebase form.  Normally git-debrebase will refuse to continue in this case (or silently do nothing if the global --noop-ok option is used).
pt: Esta operação não deve ser usada se o ramo já estiver em formato git-debrebase.  Normalmente o git-debrebase irá recusar continuar neste caso (ou não faz nada em silêncio se a opção global --noop-ok for usada).

note: type: textblock
en: Some representation of the original upstream source code will be needed.  If I<upstream> is supplied, that must be a suitable upstream commit.  By default, git-debrebase will look first for git tags (as for new-upstream), and then for orig tarballs which it will ask dgit to process.
pt: Alguma representação do código fonte original do autor vai ser precisa.  Se I<upstream> for fornecido, tem de ser um cometido de autor apropriado.  Por predefinição, o git-debrebase irá procurar primeiro por etiquetas git (como para nova-autoria), e depois por tarballs orig que vai pedir ao dgit para os processar.

note: type: textblock
en: The upstream source must be exactly right and all the patches in debian/patches must be up to date.  Applying the patches from debian/patches to the upstream source must result in exactly your HEAD.
pt: A fonte do autor tem e estar exatamente certa e todas as patches em debian/patches têm de estar atualizadas.  Aplicar as patches de debian/patches na fonte do autor tem de resultar em exatamente no seu CABEÇALHO.

note: type: textblock
en: The output is laundered and stitched.  The resulting history is not particularly pretty, especially if orig tarball(s) were imported to produce a synthetic upstream commit.
pt: O resultado e lavado e cosido.  O histórico resultante não é particularmente bonito, especialmente se os tarballs orig foram importados para produzir um cometido de autor sintético.

note: type: textblock
en: The available convert-options are as follows.  (These must come after convert-from-dgit-view.)
pt: As opções de convert disponíveis sã as seguintes.  (Estas têm de vir depois de convert-from-dgit-view.)

note: type: textblock
en: Print additional error messages to help diagnose failure to find an appropriate upstream.  --no-diagnose is the default.
pt: Escreve mensagens de erro adicionais para ajudar a diagnosticar falhas para encontrar uma autoria apropriada.  --no-diagnose é a predefinição.

note: type: textblock
en: Directory to look in for orig tarballs.  The default is the git config option dgit.default.build-products-dir or failing that, C<..>.  Passed on to dgit, if git-debrebase invokes dgit.
pt: Directório onde procurar por tarballs orig.  A predefinição é a opção de configuração do git dgit.default.build-products-dir ou falhando isso, C<..>.  Passado para o dgit, se o git-debrebase invocar o dgit.

note: type: textblock
en: Whether to try to look for or use any orig tarballs.  --origs is the default.
pt: Caso se deva tentar procurar ou usar quaisquer tarballs orig.  --origs é a predefinição.

note: type: textblock
en: Whether to try to look for or use any upstream git tags.  --tags is the default.
pt: Caso se deva tentar procurar ou usar quaisquer etiquetas git do autor.  --tags é a predefinição.

note: type: textblock
en: Perform the conversion operation, producing unpleasant extra history, even if the branch seems to be in git-debrebase form already.  This should not be done unless necessary, and it should not be necessary.
pt: Efetua a operação de conversão, produzindo um histórico extra desagradável, mesmo que o ramo pareça já estar no formato do git-debrebase.  Isto não deve ser feito a menos que necessário, e não deverá ser necessário.

note: type: textblock
en: Deletes the ffq-prev and debrebase-last refs associated with this branch, that git-debrebase and dgit use to determine whether this branch is managed by git-debrebase, and what previous head may need to be stitched back in.
pt: Apaga o ffq-prev e referências debrebase-last associadas a este ramo, que o git-debrebase e o dgit usam para determinar se este ramo é gerido pelo git-debrebase, e qual cabeçalho anterior pode precisar de voltar a ser cosido.

note: type: textblock
en: This can be useful if you were just playing with git-debrebase, and have used git-reset --hard to go back to a commit before your experiments.
pt: Isto pode ser útil se você está apenas a brincar com o git-debrebase, e usou git-reset --hard para regressar a um cometido anterior às suas experiências.

note: type: textblock
en: Do not use this if you expect to run git-debrebase on the branch again.
pt: Não use isto se espera correr git-debrebase no ramo outra vez.

note: type: textblock
en: This section documents the general options to git-debrebase (ie, the ones which immediately follow git-debrebase or git debrebase on the command line).  Individual operations may have their own options which are docuented under each operation.
pt: Esta secção documenta as opções gerais para o git-debrebase (isto é, as que seguem imediatamente git-debrebase ou git debrebase na linha de comandos).  As operações individuais podem ter as suas próprias opções que as quais estão documentadas sob cada operação.

note: type: textblock
en: Turns snag(s) with id <snag-id> into warnings.
pt: Converte estorvo(s) com id <snag-id> em avisos.

note: type: textblock
en: Some troublesome things which git-debrebase encounters are B<snag>s.  (The specific instances are discussed in the text for the relevant operation.)
pt: Algumas coisas problemáticas que o git-debrebase encontra são B<estorvo>s.  (As instâncias específicas são discutidas no texto para a operação relevante.)

note: type: textblock
en: When a snag is detected, a message is printed to stderr containing the snag id (in the form C<-f<snag-idE<gt>>), along with some prose.
pt: Quando é detectado um estorvo, é escrita uma mensagem no stderr contendo o id de estorvo (no formato C<-f<snag-idE<gt>>), juntamente com alguma prosa.

note: type: textblock
en: If snags are detected, git-debrebase does not continue, unless the relevant -f<snag-id> is specified, or --force is specified.
pt: Se forem detetados estorvos, o git-debrebase não continua, a menos que seja especificada o -f<snag-id> relevante, ou seja especificado --force.

note: type: textblock
en: Turns all snags into warnings.  See the -f<snag-id> option.
pt: Transforma todos os estorvos em avisos.  Veja a opção -f<snag-id>.

note: type: textblock
en: Do not invoke git-debrebase --force in scripts and aliases; instead, specify the particular -f<snag-id> for expected snags.
pt: Não invoque git-debrebase --force em scripts e nomes alternativos; em vez disso, especifique o -f<snag-id> particular para os estorvos esperados.

note: type: textblock
en: Suppresses the error in some situations where git-debrebase does nothing, because there is nothing to do.
pt: Suprime o erro em algumas situações onde o git-debrebase não faz nada, porque não há nada para fazer.

note: type: textblock
en: The specific instances are discussed in the text for the relvant operation.
pt: As instâncias específicas são discutidas no texto para a operação relevante.

note: type: textblock
en: Treats <commit-ish> as an anchor.  This overrides the usual logic which automatically classifies commits as anchors, pseudomerges, delta queue commits, etc.
pt: Trata <commit-ish> como uma âncora.  Isto sobrepõe a lógica normal que classifica automaticamente cometidos como âncoras, pseudo-fusões, cometidos de fila delta, etc.

note: type: textblock
en: It also disables some coherency checks which depend on metadata extracted from its commit message, so it is a snag (C<-fanchor-treated>) if <commit-ish> is the anchor for the previous upstream version in git-debrebase new-upstream operations.  You have to check yourself that the new upstream is fast forward from the old one, and has the right components (as if applicable).
pt: Também desactiva algumas verificações de coerência que dependem de metadados extraídos da sua mensagem de cometido, assim é um estorvo (C<-fanchor-treated>) se <commit-ish> for a âncora para a versão de autor anterior nas operações de nova-autoria do git-debrebas.  Você tem de verificar você próprio que a nova autoria é de avanço rápido a partir da antiga, e tem os componentes certos (como se aplicável).

note: type: =item
en: --dgit=<program>
pt: --dgit=<programa>

note: type: textblock
en: Run <program>, instead of dgit from PATH, when invocation of dgit is necessary.  This is provided mostly for the benefit of the test suite.
pt: Corre <programa>, em vez do dgit a partir da PATH, quando a invocação do dgit é necessária.  Isto é fornecido maioritariamente para benefício da suite de testes.

note: type: textblock
en: Requests (more) debugging.  May be repeated.
pt: Pede (mais) depuração.  Pode ser repetido.

note: type: textblock
en: No-op option still accepted for compatibilty.
pt: Opção no-op ainda aceite para compatibilidade.

note: type: textblock
en: In previous versions this enabled attempting to handle general merges, but that attempt is now made unconditonally.
pt: Em versões anteriores isto activa a tentativa de lidar com fusões gerais, mas essa tentativa agora é feita incondicionalmente.

note: type: =head1
en: UNSTITCHING AND LAUNDERING
pt: DESCOSER E LAVAGEM

note: type: textblock
en: Several operations unstitch and launder the branch first.  In detail this means:
pt: Várias operações descosem e lavam primeiro o ramo.  Em detalhes isto significa:

note: type: =head2
en: Establish the current branch's ffq-prev
pt: Estabelecer o ffq-prev do ramo atual

note: type: textblock
en: If ffq-prev is not yet recorded, git-debrebase checks that the current branch is ahead of relevant remote tracking branches.  The relevant branches depend on the current branch (and its git configuration)  and are as follows:
pt: Se o ffq-prev ainda não estiver gravado, o git-debrebase verifica que o ramo atual está à frente dos ramos de acompanhamento remoto relevantes.  OS ramos relevantes dependem do ramo atual (e da sua configuração git) e são como se segue:

note: type: textblock
en: The branch that git would merge from (remote.<branch>.merge, remote.<branch>.remote);
pt: O ramo que o git iria fundir a partir de (remoto.<ramo>.fusão, remoto.<ramo>.remoto);

note: type: textblock
en: The branch git would push to, if different (remote.<branch>.pushRemote etc.);
pt: O ramo para onde o git iria empurrar, se diferente (remoto.<ramo>.pushRemoto etc.);

note: type: textblock
en: For local dgit suite branches, the corresponding tracking remote;
pt: Para ramos de suite dgit locais, o remoto de acompanhamento correspondente;

note: type: textblock
en: If you are on C<master>, remotes/dgit/dgit/sid.
pt: Se você está em C<master>, remotes/dgit/dgit/sid.

note: type: textblock
en: The apparently relevant ref names to check are filtered through branch.<branch>.ffq-ffrefs, which is a semicolon-separated list of glob patterns, each optionally preceded by !; first match wins.
pt: Os nomes de referência aparentemente relevantes a verificar são filtrados por ramo.  <ramo>.ffq-ffrefs, que é uma lista separada por ponto-e-vírgula de padrões glob, cada um precedido opcionalmente por !; a primeira correspondência ganha.

note: type: textblock
en: In each case it is a snag if the local HEAD is behind the checked remote, or if local HEAD has diverged from it.  All the checks are done locally using the remote tracking refs: git-debrebase does not fetch anything from anywhere.
pt: Em cada caso é um estorvo se o CABEÇALHO local está por detrás do remoto verificado, ou se o CABEÇALHO local se divergiu dele.  Todas as verificações são feitas localmente usando as referências de acompanhamento remoto: o git-debrebase não vai buscar nada de lado nenhum.

note: type: textblock
en: If these checks pass, or are forced, git-debrebse then records the current tip as ffq-prev.
pt: Se estas verificações passarem, ou se for forçado, então o git-debrebse grava a ponta atual como ffq-prev.

note: type: =head2
en: Examine the branch
pt: Examina o ramo

note: type: textblock
en: git-debrebase analyses the current HEAD's history to find the anchor in its breakwater, and the most recent breakwater tip.
pt: O git-debrebase analisa o histórico do CABEÇALHO atual para encontrar a âncora no seu quebra mar, e a ponta de quebra mar mais recente.

note: type: =head2
en: Rewrite the commits into laundered form
pt: Rescreve os cometidos em formato lavado

note: type: textblock
en: Mixed debian+upstream commits are split into two commits each.  Delta queue (upstream files) commits bubble to the top.  Pseudomerges, and quilt patch additions, are dropped.
pt: Cometidos debian+autor misturados são divididos em dois cometidos cada.  Os cometidos da fila delta (ficheiros do autor) vão borbulhar para o topo.  As pseudo-fusões, e adições de patch quilt, são largadas.

note: type: textblock
en: This rewrite will always succeed, by construction.  The result is the laundered branch.
pt: Este rescrever irá sempre ter sucesso, por construção.   O resultado é o ramo lavado.
