Remova as tags git locais que não estão mais no repositório remoto

Usamos tags no git como parte de nosso processo de implantação. Periodicamente, queremos limpar essas tags removendo-as do nosso repositório remoto.

Isso é bem direto. Um usuário exclui a marca local e a marca remota em um conjunto de comandos. Temos um pequeno script de shell que combina as duas etapas.

O segundo (terceiro, quarto, ...) usuário agora tem tags locais que não são mais refletidas no controle remoto.

Estou procurando um comando semelhante ao git remote prune originqual limpa as ramificações de rastreamento local para as quais a ramificação remota foi excluída.

Como alternativa, um comando simples para listar tags remotas pode ser usado para comparar com as tags locais retornadas por git tag -l.

Boa pergunta. :) Eu não tenho uma resposta completa ...

Dito isto, você pode obter uma lista de tags remotas via git ls-remote. Para listar as tags no repositório referenciado por origin, você deve executar:

git ls-remote --tags origin

Isso retorna uma lista de hashes e nomes de tags amigáveis, como:

94bf6de8315d9a7b22385e86e1f5add9183bcb3c        refs/tags/v0.1.3
cc047da6604bdd9a0e5ecbba3375ba6f09eed09d        refs/tags/v0.1.4
...
2f2e45bedf67dedb8d1dc0d02612345ee5c893f2        refs/tags/v0.5.4

Você certamente poderia montar um script bash para comparar as tags geradas por esta lista com as que você possui localmente. Dê uma olhada git show-ref --tags, que gera os nomes das tags da mesma forma que git ls-remote).

Como um aparte, git show-reftem uma opção que faz o oposto do que você gostaria. O comando a seguir listaria todas as tags na ramificação remota que você não possui localmente:

git ls-remote --tags origin | git show-ref --tags --exclude-existing

Esta é uma ótima pergunta, eu estava pensando a mesma coisa.

Como não queria escrever um script, procurei uma solução diferente. A chave é descobrir que você pode excluir uma marca localmente e usar o git fetch para "recuperá-la" do servidor remoto. Se a tag não existir no controle remoto, ela permanecerá excluída.

Portanto, você precisa digitar duas linhas em ordem:

git tag -l | xargs git tag -d
git fetch --tags

Estes:

1. Exclua todas as tags do repositório local. FWIW, xargs coloca cada tag de saída por "tag -l" na linha de comando para "tag -d". Sem isso, o git não excluirá nada porque não lê stdin (git bobo).

2. Busque todas as tags ativas no repositório remoto.

Isso funciona mesmo no Windows.

Do Git v1.7.8 para v1.8.5.6, você pode usar isto:

git fetch <remote> --prune --tags

Atualizar

Isso não funciona nas versões mais recentes do git (começando na v1.9.0) devido ao commit e66ef7ae6f31f2 . Eu realmente não quero excluí-lo, já que funcionou para algumas pessoas.

Conforme sugerido por "Chad Juliano", com todas as versões do Git desde a v1.7.8, você pode usar o seguinte comando:

git fetch --prune <remote> +refs/tags/*:refs/tags/*

Pode ser necessário incluir a parte de tags entre aspas (no Windows, por exemplo) para evitar a expansão de caracteres curinga:

git fetch --prune <remote> "+refs/tags/*:refs/tags/*"

Se você deseja apenas as tags existentes no controle remoto, basta excluir todas as tags locais:

$ git tag -d $(git tag)

E, em seguida, busque todas as tags remotas:

$ git fetch --tags

Parece que as versões recentes do Git (estou no git v2.20) permitem simplesmente dizer

git fetch --prune --prune-tags

Muito mais limpo!

https://git-scm.com/docs/git-fetch#_pruning

Você também pode configurar o git para remover sempre as tags ao buscar:

git config fetch.pruneTags true

Se você desejar remover tags ao buscar em um controle remoto específico, poderá usar a remote.<remote>.pruneTagsopção Por exemplo, para sempre remover tags ao buscar na origem, mas não em outros controles remotos,

git config remote.origin.pruneTags true

Todas as versões do Git desde a v1.7.8 são compreendidas git fetchcom um refspec, enquanto que desde a v1.9.0 a --tagsopção substitui a --pruneopção. Para uma solução de uso geral, tente o seguinte:

$ git --version
git version 2.1.3

$ git fetch --prune origin "+refs/tags/*:refs/tags/*"
From ssh://xxx
 x [deleted]         (none)     -> rel_test

Para ler mais sobre como o comportamento "--tags" com "--prune" mudou no Git v1.9.0, consulte: https://github.com/git/git/commit/e66ef7ae6f31f246dead62f574cc2acb75fd001c

O Git suporta nativamente a limpeza de tags locais:

git fetch --tags --prune

Este comando extrai as tags mais recentes e remove todas as tags excluídas.

este é um bom método:

git tag -l | xargs git tag -d && git fetch -t

Fonte: demisx.GitHub.io

Mostre a diferença entre tags locais e remotas:

diff <(git tag | sort) <( git ls-remote --tags origin | cut -f2 | grep -v '\^' | sed 's#refs/tags/##' | sort)

• git tag fornece a lista de tags locais
• git ls-remote --tags fornece a lista de caminhos completos para tags remotas
• cut -f2 | grep -v '\^' | sed 's#refs/tags/##' analisa apenas o nome da marca na lista de caminhos de marca remota
• Finalmente, classificamos cada uma das duas listas e as diferenciamos

As linhas que começam com "<" são suas tags locais que não estão mais no repositório remoto. Se forem poucos, você poderá removê-los manualmente, um por um, se forem muitos, você fará mais grep-ing e tubulação para automatizá-lo.

Acabei de adicionar um comando git sync-local-tags ao pivotal_git_scripts fork do Gem no GitHub:

https://github.com/kigster/git_scripts

Instale a gema e execute "git sync-local-tags" em seu repositório para excluir as marcações locais que não existem no controle remoto.

Como alternativa, você pode instalar este script abaixo e chamá-lo de "git-sync-local-tags":

#!/usr/bin/env ruby

# Delete tags from the local Git repository, which are not found on 
# a remote origin
#
# Usage: git sync-local-tags [-n]
#        if -n is passed, just print the tag to be deleted, but do not 
#        actually delete it.
#
# Author: Konstantin Gredeskoul (http://tektastic.com)
#
#######################################################################

class TagSynchronizer
  def self.local_tags
    `git show-ref --tags | awk '{print $2}'`.split(/\n/)
  end

  def self.remote_tags
    `git ls-remote --tags origin | awk '{print $2}'`.split(/\n/)
  end

  def self.orphaned_tags
    self.local_tags - self.remote_tags
  end

  def self.remove_unused_tags(print_only = false)
    self.orphaned_tags.each do |ref|
      tag = ref.gsub /refs\/tags\//, ''
      puts "deleting local tag #{tag}"
      `git tag -d #{tag}` unless print_only
    end
  end
end

unless File.exists?(".git")
  puts "This doesn't look like a git repository."
  exit 1
end

print_only = ARGV.include?("-n")
TagSynchronizer.remove_unused_tags(print_only)

Eu sei que estou atrasado para a festa, mas agora há uma resposta rápida para isso:

git fetch --prune --prune-tags # or just git fetch -p -P

Sim, agora é uma opção para buscar.

Se você não deseja buscar e apenas poda:

git remote prune origin

Que tal isso - largue todas as tags locais e depois busque novamente? Considerando que seu repo pode conter submódulos:

git submodule foreach --recursive  'git tag | xargs git tag -d'
(alternatively, "for i in `find .git  -type d -name '*tags*'`; do rm -f $i/*;  done")
git fetch -t
git submodule foreach --recursive git fetch -t

O TortoiseGit pode comparar tags agora.

O registro esquerdo está no controle remoto, o direito está no local.

Usando o recurso Tags de comparação da caixa de diálogo Sincronizar:

Veja também a edição 2973 do TortoiseGit

A mesma resposta que @Richard W, mas para Windows (PowerShell)

git tag | foreach-object -process { git tag -d $_ }
git fetch -t

Eu adiciono o comando SourceTreecomo uma Ação personalizada no meu MacOS.

Definir Custom Actionspor Sourcetree-> Preferences...->Custom Actions

Script to runtem que ser o gitcaminho.

Eu uso git fetch --prune --prune-tags originpara sincronizar tags de remoto para local.

Na nova versão do git (como v2.26.2)

-P, --prune-tags Antes de buscar, remova as tags locais que não existem mais no controle remoto se --prune estiver ativado. Esta opção deve ser usada com mais cuidado, ao contrário do --prune, ele removerá todas as referências locais (tags locais) que foram criadas. Esta opção é um atalho para fornecer a tag explsp refspec junto com --prune, consulte a discussão sobre isso em sua documentação.

Então você precisaria executar:

git fetch august --prune --prune-tags