git-debrebase(1)

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.

    Para examinar um cometido, em vez do seu ramo atual, 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.

    Se não existir nada para deitar fora, é um erro, a menos que --noop-ok.

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:

    <upstream-commit-ish>
        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 git-deborig(1).)

        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.

    <piece-name> <piece-upstream-commit-ish>
        Especifica que isto é uma autoria multi-parte. Pode ser repetido.

        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.

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

        <piece-name> tem uma sintaxe restrita: só pode conter alfanuméricos ASCII e hífens.

        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.

    <opções do git-rebase>
        Estas serão passadas ao git rebase.

        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.

    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. git-deborig(1), git-archive(1), dgit(1) e gbp-import-orig(1) podem ser capazes de ajudar.

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.

    Se não existirem mais patches a fazer, é um erro, a menos que --noop-ok.

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.

    •   um ramo gbp de patches não aplicadas (mas não um ramo gbp de fila de patch pq)

    •   um ramo de empacotamento git de patches não aplicadas contendo debian/patches, como usado com quilt

    •   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

    (Estes dois comandos operam de modo idêntico e são simplesmente nomes alternativos.)

    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.

    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.

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

    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.

    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.

    É um estorvo se o novo ramo parecer que vai divergir, assim como para uma chamada de lavar/descoser ao git-debrebase; Veja "Estabelecer o ffq-prev do ramo atual", em baixo.

    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!

git-debrebase examine COMETIDO
    Analisa o conteúdo de COMETIDO, e escreve um sumário legível por humanos.

    Tal como com "git-debrebase status", por favor não tente analisar o resultado.

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

    --[no-]diagnose
        Escreve mensagens de erro adicionais para ajudar a diagnosticar falhas para encontrar uma autoria apropriada. --no-diagnose é a predefinição.

    --build-products-dir
        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, "..". Passado para o dgit, se o git-debrebase invocar o dgit.

    --[no-]origs
        Caso se deva tentar procurar ou usar quaisquer tarballs orig. --origs é a predefinição.

    --[no-]tags
        Caso se deva tentar procurar ou usar quaisquer etiquetas git do autor. --tags é a predefinição.

    --always-convert-anyway
        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.

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:

  Estabelecer o ffq-prev do ramo atual
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:

•   O ramo que o git iria fundir a partir de (remoto.<ramo>.fusão, remoto.<ramo>.remoto);

•   O ramo para onde o git iria empurrar, se diferente (remoto.<ramo>.pushRemoto etc.);

•   Para ramos de suite dgit locais, o remoto de acompanhamento correspondente;

•   Se você está em "master", remotes/dgit/dgit/sid.

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.

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.

Se estas verificações passarem, ou se for forçado, então o git-debrebse grava a ponta atual como ffq-prev.

  Examina o ramo
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.

  Rescreve os cometidos em formato lavado
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.

Este rescrever irá sempre ter sucesso, por construção. O resultado é o ramo lavado.

VEJA TAMBÉM
git-debrebase(5), dgit-maint-debrebase(7), dgit(1), gitglossary(7)