NOME¶

git-debrebase - ferramenta para manter série de alterações Debian na fonte do autor

RESUMO¶

 git-debrebase [<opções...>] [-- <opções do git-rebase...>]
 git-debrebase [<opções...>] <operação> [<opções da operação...>

REFERÊNCIA RÁPIDA¶

Esta é a maioria dos comandos que você vai precisar regularmente:

 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

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".

Ao partilhar ramos, você deve normalmente partilhar um ramo de avanço rápido, isto é, "git-debrebase conclude" (ou "prepush") antes de empurrar.

git-debrebase tem um formato de ramo especial, assim veja "CONVERTENDO UM PACOTE EXISTENTE" em dgit-maint-debrebase(7).

GUIA PARA DOCUMENTAÇÃO¶

Esta é a referência de linha de comandos. Existe também um tutorial de fluxo de trabalho detalhado em dgit-maint-debrebase(7) (no qual a "REFERÊNCIA RÁPIDA" em cima é baseada). Para bastidores, teoria de operação, e definições veja git-debrebase(5).

Você deve ler este manual em conjunto com "TERMINOLOGIA" in git-debrebase(5), o qual define muitos termos importantes aqui usados.

OPERAÇÕES PRINCIPAIS¶

git-debrebase [-- <opções de git-rebase...>]

git-debrebase [-i <mais opções de git-rebase...>]

Descoser e lavar o ramo. (veja "DESCOSER E LAVAGEM" em baixo.)

Então, se algumas opções de git-rebase forem fornecidas, edita a fila delta Debian, usando o git-rebase, ao correr

    git rebase <opções de git-rebase> <ponta-de-quebra-mar>
    

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.

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.

As opções para git-rebase têm de ou começar com "-i", ou serem precedidas por "--", para as distinguir das opções para git-debrebase.

É 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 "OPERAÇÕES ILEGAIS" in git-debrebase(5)

git-debrebase status

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.

To examine a commit, rather than your current branch, use "git-debrebase examine".

Por favor não tente analisar o resultado; poderá vir a ser reformatado ou reorganizado no futuro. Em vez disso, use uma das "OPERAÇÕES SUBJACENTES E SUPLEMENTARES" descritas sem baixo.

git-debrebase conclude

Termina uma sessão git-debrebase, arrumando o ramo e tornando-o de novo em avanço rápido.

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.

git-debrebase quick

Lava e recose incondicionalmente o ramo, consumindo quaisquer ffq-prev e fazendo uma nova pseudo-fusão.

Se o ramo já estiver lavado e recosido, não faz nada.

git-debrebase prepush [--prose=<para mensagem de cometido>]

Se o ramo está descosido, cose-o, consumindo ffq-prev.

É um bom comando para correr antes de empurrar para um servidor git. Você deve considerar usar conclude em vez deste, porque também lava o ramo.

git-debrebase stitch [--prose=<para mensagem de cometido>]

Cose o ramo, consumindo ffq-prev.

Se não existir nenhum ffq-prev, é um erro, a menos que --noop-ok.

Você deve considerar usar prepush ou conclude em vez disto.

git-debrebase scrap

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.

Se você estiver a meio de um git-rebase, irá abortar isso também.

git-debrebase new-upstream <nova-versão> [<detalhes-do-autor>...] [--|-i <opções do git-rebase...>]

Re-baseia a fila delta na nova versão de autor. Em detalhe:

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.

Se tudo parecer bem, descose e lava o ramo.

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.

Finalmente, arranca um git-rebase da fila delta nestes novos cometidos.

Esse git-rebase pode completar com sucesso, ou pode requerer a sua assistência, tal com um git-rebase normal.

Se você fizer git-rebase --abort, toda a nova operação de autor é abortada, excepto a lavagem.

<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.

Os <detalhes-do-autor> são, opcionalmente, em ordem:

git-debrebase make-patches [--quiet-would-amend]

Gera patches em debian/patches/ que representam as alterações feitas aos ficheiros do autor.

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.

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.

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.

git-debrebase convert-from-unapplied [<upstream-commit-ish>]

git-debrebase convert-from-gbp [<upstream-commit-ish>]

Converte qualquer um do seguinte num ramo de intercâmbio git-debrebase.

git-debrebase examine COMMITISH

Analyses the contents of COMMITISH, and prints a human-readable summary.

As with "git-debrebase status", please do not attempt to parse the output.

OPERAÇÕES SUBJACENTES E SUPLEMENTARES¶

git-debrebase breakwater

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.

git-debrebase anchor

Escreve a âncora de quebra-mar cometida.

git-debrebase analyse

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.

git-debrebase record-ffq-prev

Estabelece o ffq-prev do ramo atual, como discutido em "DESCOSER E LAVAGEM", mas não lava o ramo, nem move o CABEÇALHO.

É 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.

git-debrebase convert-to-gbp

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.

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.

Certifique-se que não trata acidentalmente o resultado como um ramo git-debrebase, ou vai perder todas as patches!

git-debrebase convert-from-dgit-view [<opções-de-convert>] [upstream]

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.

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).

Alguma representação do código fonte original do autor vai ser precisa. Se 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.

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.

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.

As opções de convert disponíveis sã as seguintes. (Estas têm de vir depois de convert-from-dgit-view.)

git-debrebase forget-was-ever-debrebase

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.

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.

Não use isto se espera correr git-debrebase no ramo outra vez.

OPÇÕES¶

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.

-f<snag-id>

Converte estorvo(s) com id <snag-id> em avisos.

Algumas coisas problemáticas que o git-debrebase encontra são estorvos. (As instâncias específicas são discutidas no texto para a operação relevante.)

Quando é detectado um estorvo, é escrita uma mensagem no stderr contendo o id de estorvo (no formato "-f<snag-id>"), juntamente com alguma prosa.

Se forem detetados estorvos, o git-debrebase não continua, a menos que seja especificada o -f<snag-id> relevante, ou seja especificado --force.

--force

Transforma todos os estorvos em avisos. Veja a opção -f<snag-id>.

Não invoque git-debrebase --force em scripts e nomes alternativos; em vez disso, especifique o -f<snag-id> particular para os estorvos esperados.

--noop-ok

Suprime o erro em algumas situações onde o git-debrebase não faz nada, porque não há nada para fazer.

As instâncias específicas são discutidas no texto para a operação relevante.

--anchor=<commit-ish>

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.

Também desactiva algumas verificações de coerência que dependem de metadados extraídos da sua mensagem de cometido, assim é um estorvo ("-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).

--dgit=<programa>

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.

-D

Pede (mais) depuração. Pode ser repetido.

--experimental-merge-resolution

Opção no-op ainda aceite para compatibilidade.

Em versões anteriores isto activa a tentativa de lidar com fusões gerais, mas essa tentativa agora é feita incondicionalmente.

DESCOSER E LAVAGEM¶

Várias operações descosem e lavam primeiro o ramo. Em detalhes isto significa:

VEJA TAMBÉM¶

git-debrebase(5), dgit-maint-debrebase(7), dgit(1), gitglossary(7)