Passando do CVS para o Git: $ Id $ equivalente?

Eu li várias perguntas sobre ferramentas simples de controle de código-fonte e o Git parecia uma escolha razoável. Eu o tenho instalado e funcionando, e funciona bem até agora. Um aspecto que eu gosto no CVS é ​​o incremento automático de um número de versão.

Entendo que isso faz menos sentido em um repositório distribuído, mas como desenvolvedor, quero / preciso de algo assim. Deixe-me explicar o porquê:

Eu uso o Emacs. Periodicamente, procuro novas versões dos arquivos de origem Lisp para pacotes de terceiros. Digamos que eu tenho um arquivo, foo.el, que, de acordo com o cabeçalho, é a versão 1.3; se eu procurar a versão mais recente e ver a versão 1.143 ou 2.6 ou o que for, sei que estou muito atrasada.

Se, em vez disso, eu vejo alguns hashes de 40 caracteres, não saberei o que é mais tarde nem faço ideia de quanto é mais tarde. Eu absolutamente odiaria se tivesse que verificar manualmente os ChangeLogs apenas para ter uma idéia de como estou desatualizado.

Como desenvolvedor, quero estender essa cortesia, a meu ver, às pessoas que usam minha saída (e talvez eu esteja brincando que alguém seja, mas vamos deixar isso de lado por um momento). Eu não quero ter que lembrar de incrementar o número maldito sempre, ou um carimbo de data / hora ou algo assim. Essa é uma verdadeira PITA, e eu sei disso por experiência própria.

Então, quais alternativas eu tenho? Se eu não conseguir um equivalente $ Id: $, de que outra forma posso fornecer o que estou procurando?

Devo mencionar que minha expectativa é que o usuário final NÃO tenha o Git instalado e, mesmo que o tenha, não terá um repositório local (de fato, espero não disponibilizá-lo dessa maneira).

O SHA é apenas uma representação de uma versão (embora canônica). O git describecomando oferece aos outros e o faz muito bem.

Por exemplo, quando executo git describena minha ramificação principal da fonte do cliente memcached Java , obtenho o seguinte:

2.2-16-gc0cd61a

Isso diz duas coisas importantes:

1. Houve exatamente 16 confirmações nesta árvore desde 2.2
2. A árvore de origem exata pode ser exibida no clone de qualquer outra pessoa.

Digamos, por exemplo, você empacotou um versionarquivo com a fonte (ou mesmo reescreveu todo o conteúdo para distribuição) para mostrar esse número. Digamos que a versão empacotada era 2.2-12-g6c4ae7a(não uma versão, mas uma versão válida).

Agora você pode ver exatamente a que distância está (4 confirmações) e pode ver exatamente quais 4 confirmações:

# The RHS of the .. can be origin/master or empty, or whatever you want.
% git log --pretty=format:"%h %an %s" 2.2-12-g6c4ae7a..2.2-16-gc0cd61a
c0cd61a Dustin Sallings More tries to get a timeout.
8c489ff Dustin Sallings Made the timeout test run on every protocol on every bui
fb326d5 Dustin Sallings Added a test for bug 35.
fba04e9 Valeri Felberg Support passing an expiration date into CAS operations.

Até agora, há suporte para $ Id: $ no Git. Para habilitá-lo para o arquivo README, você deve colocar "README ident" em .gitattributes . Caracteres curinga nos nomes de arquivo são suportados. Veja man gitattributes para detalhes.

Esta não é uma solicitação irracional do OP.

Meu caso de uso é:

1. Eu uso o Git para meu próprio código pessoal, portanto não há colaboração com outras pessoas.
2. Eu mantenho os scripts do Bash do sistema, que podem ser usados /usr/local/binquando estiverem prontos.

Eu uso três máquinas separadas com o mesmo repositório Git. Seria bom saber em qual "versão" do arquivo eu tenho atualmente /usr/local/binsem precisar fazer um manual "diff -u <repo version> <versão em / usr / local / bin>".

Para aqueles que são negativos, lembre-se de que existem outros casos de uso por aí. Nem todo mundo usa o Git para trabalho colaborativo, com os arquivos no repositório Git sendo seu local "final".

Enfim, o jeito que eu fiz foi criar um arquivo de atributos no repositório assim:

cat .git/info/attributes
# see man gitattributes
*.sh ident
*.pl ident
*.cgi ident

Em seguida, coloque $ Id $ em algum lugar do arquivo (eu gosto de colocá-lo após o shebang).

O commit. Observe que isso não faz a expansão automaticamente como eu esperava. Você precisa refazer o arquivo, por exemplo,

git commit foo.sh
rm foo.sh
git co foo.sh

E então você verá a expansão, por exemplo:

$ head foo.sh
#!/bin/sh

# $Id: e184834e6757aac77fd0f71344934b1cd774e6d4 $

Algumas boas informações estão em Como habilito a cadeia de caracteres ident para um repositório Git? .

Não tenho certeza se isso será no Git. Para citar Linus :

"Toda a noção de substituição de palavras-chave é totalmente idiota. É trivial fazer" fora "do rastreamento de conteúdo real, se você quiser tê-lo ao liberar árvores como bolas de alcatrão etc."

Porém, é muito fácil verificar o log - se você estiver rastreando a ramificação estável do foo.el, poderá ver quais novas confirmações estão no log da ramificação estável que não estão na sua cópia local. Se você deseja simular o número da versão interna do CVS, pode comparar o registro de data e hora do último commit.

Editar: você deve escrever ou usar os scripts de outra pessoa para isso, é claro, não faça isso manualmente.

Como eu escrevi antes :

A geração automática de tags de identificação que mostram um número de versão sensato é impossível com ferramentas DSCM como o Bazaar, porque a linha de desenvolvimento de todos pode ser diferente de todas as outras. Portanto, alguém pode se referir à versão "1.41" de um arquivo, mas sua versão "1.41" desse arquivo é diferente.

Basicamente, $ Id $ não faz sentido com o Bazaar, Git e outras ferramentas de gerenciamento de código-fonte distribuído.

Eu tive o mesmo problema. Eu precisava ter uma versão mais simples que uma string de hash e disponível para pessoas que usavam a ferramenta sem precisar se conectar ao repositório.

Fiz isso com um gancho de pré-confirmação do Git e alterei meu script para poder me atualizar automaticamente.

Baseei a versão no número de confirmações feitas. Essa é uma pequena condição de corrida, porque duas pessoas podem se comprometer ao mesmo tempo e ambas acham que estão comprometendo o mesmo número de versão, mas não temos muitos desenvolvedores nesse projeto.

Como exemplo, eu tenho um script que eu faço check-in em Ruby e adiciono esse código a ele - é um código bastante simples, portanto é fácil portar para idiomas diferentes se você estiver fazendo o check-in de algo em um idioma diferente (embora obviamente isso não funcionará facilmente com checkins não executáveis, como arquivos de texto). Eu já adicionei:

MYVERSION = '1.090'
## Call script to do updateVersion from .git/hooks/pre-commit
def updateVersion
  # We add 1 because the next commit is probably one more - though this is a race
  commits = %x[git log #{$0} | grep '^commit ' | wc -l].to_i + 1
  vers = "1.%0.3d" % commits

  t = File.read($0)
  t.gsub!(/^MYVERSION = '(.*)'$/, "MYVERSION = '#{vers}'")
  bak = $0+'.bak'
  File.open(bak,'w') { |f| f.puts t }
  perm = File.stat($0).mode & 0xfff
  File.rename(bak,$0)
  File.chmod(perm,$0)
  exit
end

E então adiciono uma opção de linha de comando (-updateVersion) ao script, portanto, se eu chamá-lo como "tool -updateVersion", ele chamará updateVersion da ferramenta que modifica o valor "MYVERSION" e sai (você pode também atualize outros arquivos se eles forem abertos e se você quiser).

Uma vez configurada, vou para o cabeçalho Git e crio um script bash executável de uma linha no .git/hooks/pre-commit.

O script simplesmente muda para o cabeçalho do diretório Git e chama meu script com -updateVersion.

Toda vez que eu faço check-in, o script de pré-confirmação é executado, executando meu script com -updateVersion e a variável MYVERSION é atualizada com base no número de confirmações. Magia!

Se ter $ Keywords $ é essencial para você, então você pode tentar olhar para o Mercurial ? Possui uma extensão hgkeyword que implementa o que você deseja. Mercurial é interessante como um DVCS de qualquer maneira.

Algo que é feito com os repositórios Git é usar o tagobjeto. Isso pode ser usado para marcar um commit com qualquer tipo de string e pode ser usado para marcar versões. Você pode ver essas tags em um repositório com o git tagcomando, que retorna todas as tags.

É fácil verificar uma tag. Por exemplo, se houver uma tag, v1.1você poderá verificá-la em um ramo como este:

git checkout -b v1.1

Como é um objeto de nível superior, você verá todo o histórico desse commit, além de poder executar diferenças, fazer alterações e mesclagens.

Não apenas isso, mas uma tag persiste, mesmo que a ramificação em que estava foi excluída sem ser mesclada novamente na linha principal.

Se bem entendi, basicamente, você deseja saber quantas confirmações ocorreram em um determinado arquivo desde a última atualização.

Primeiro, obtenha as alterações na origem remota, mas não as junte à sua masterramificação:

% git fetch

Em seguida, obtenha um log das alterações que ocorreram em um determinado arquivo entre sua masterfilial e o controle remoto origin/master.

% git log master..origin/master foo.el

Isso fornece as mensagens de log de todas as confirmações que ocorreram no repositório remoto desde a última vez que você foi mesclado origin/masterao seu master.

Se você quiser apenas contar as alterações, envie-o para wc. Diga, assim:

% git rev-list master..origin/master foo.el | wc -l

Se você está apenas querendo que as pessoas possam ter uma idéia de quão desatualizadas elas estão, o Git pode informá-las disso de várias maneiras bastante fáceis. Eles comparam as datas da última confirmação no tronco e no tronco, por exemplo. Eles podem usar git cherrypara ver quantos commits ocorreram no seu tronco que não estão presentes no deles.

Se é isso que você deseja, procuraria uma maneira de fornecê-lo sem um número de versão.

Além disso, eu não me incomodaria em estender a cortesia a ninguém, a menos que você tenha certeza de que eles querem. :)

Para aplicar a expansão a todos os arquivos em todos os subdiretórios do repositório, adicione um .gitattributesarquivo ao diretório de nível superior no repositório (ou seja, onde você normalmente colocaria o .gitignorearquivo) contendo:

* ident

Para que isso ocorra, é necessário fazer um checkout efetivo dos arquivos primeiro, como excluí-los ou editá-los de qualquer forma. Em seguida, restaure-os com:

git checkout .

E você deve ver $Id$substituído por algo como:

$Id: ea701b0bb744c90c620f315e2438bc6b764cdb87 $

De man gitattributes:

ident

Quando o atributo ident é definido para um caminho, o Git substitui $ Id $ no objeto blob por $ Id :, seguido pelo nome do objeto do blob hexadecimal de 40 caracteres, seguido por um sinal de dólar $ no check-out. Qualquer sequência de bytes que comece com $ Id: e termina com $ no arquivo da árvore de trabalho é substituída por $ Id $ no check-in.

Esse ID será alterado sempre que uma nova versão do arquivo for confirmada.

Os IDs RCS são bons para projetos de arquivo único, mas, para qualquer outro, o $ Id $ não diz nada sobre o projeto (a menos que você faça check-ins forçados em um arquivo de versão fictício).

Ainda pode estar interessado em obter os equivalentes de $ Author $, $ Date $, $ Revision $, $ RCSfile $, etc. em um nível por arquivo ou no nível de confirmação (como colocá-los onde estão algumas palavras-chave questão). Não tenho uma resposta para isso, mas vejo o requisito de atualizá-las, especialmente quando os arquivos (agora no Git) são originários de sistemas compatíveis com RCS (CVS).

Essas palavras-chave podem ser interessantes se as fontes forem distribuídas separadamente de qualquer repositório Git (é o que eu também faço). Minha solução é assim:

Todo projeto tem um diretório próprio e, na raiz do projeto, tenho um arquivo de texto chamado .versionqual conteúdo descreve a versão atual (o nome que será usado ao exportar as fontes).

Enquanto trabalhava para a próxima versão, um script extrai esse .versionnúmero, algum descritor de versão do Git (como git describe) e um número de compilação monotônico .build(mais host e data) em um arquivo de origem gerado automaticamente vinculado ao programa final, para que você possa encontrar de que fonte e quando foi construído.

Desenvolvo novos recursos em ramificações separadas, e a primeira coisa que faço é adicionar n(para "next") à .versionstring (vários ramos originários da mesma raiz usariam o mesmo .versionnúmero temporário ). Antes do lançamento, decido quais ramificações serão mescladas (espero que todas tenham o mesmo .version). Antes de confirmar a mesclagem, atualizo .versionpara o próximo número (atualização maior ou menor, dependendo dos recursos mesclados).

Se você deseja que as informações de confirmação do git sejam acessíveis no seu código, é necessário executar uma etapa de pré-construção para chegar lá. No bash para C / C ++, pode ser algo como isto:

prebuild.sh

#!/bin/bash
commit=$(git rev-parse HEAD)
tag=$(git describe --tags --always ${commit})
cat <<EOF >version.c
#include "version.h"
const char* git_tag="${tag}";
const char* git_commit="${commit}";
EOF

com version.haparência:

#pragma once
const char* git_tag;
const char* git_commit;

Então, onde você precisar, em seu código #include "version.h"e referência git_tagou git_commitconforme necessário.

E você Makefilepode ter algo parecido com isto:

all: package
version:
  ./prebuild.sh
package: version
  # the normal build stuff for your project

Isso tem o benefício de:

• obtendo os valores corretos atualmente para essa compilação, independentemente da ramificação, mesclando a seleção de cereja e outras coisas.

Esta implementação de prepublish.shapresenta os inconvenientes de:

• forçando uma recompilação, mesmo que o git_tag/ git_commitnão tenha mudado.
• ele não leva em consideração os arquivos modificados locais que não foram confirmados, mas afetam a construção.
  • use git describe --tags --always --dirtypara capturar esse caso de uso.
• polui o espaço para nome global.

Um criador prebuild.shque poderia evitar esses problemas é deixado como um exercício para o leitor.

Concordo com aqueles que pensam que a substituição do token pertence à construção de ferramentas, e não às ferramentas de controle de versão.

Você deve ter alguma ferramenta de release automatizada para definir os IDs da versão em suas fontes no momento em que o release está sendo marcado.

Os nomes de tags e outras informações relacionadas agora podem ser editados diretamente nos arquivos automaticamente pelo Git através do export-substrecurso de gitattributes(5). É claro que isso requer o uso de git archivepara criar releases, e somente no arquivo tar resultante as edições de substituição serão visíveis.

Por exemplo, no .gitattributesarquivo, coloque a seguinte linha:

* export-subst

Em arquivos de origem, você pode adicionar uma linha como esta:

#ident  "@(#)PROJECTNAME:FILENAME:$Format:%D:%ci:%cN:%h$"

E ele será expandido para se parecer com isso em um release criado por, por exemplo git archive v1.2.0.90:

#ident  "@(#)PROJECTNAME:FILENAME:HEAD -> master, tag: v1.2.0.90:2020-04-03 18:40:44 -0700:Greg A. Woods:e48f949"

Desde que você usa o Emacs, você pode ter sorte :)

Encontrei esta questão por coincidência, e também por coincidência, pela Lively há alguns dias, um pacote Emacs que permite ter peças vivas do Emacs Lisp em seu documento. Eu não tentei ser honesto, mas me veio à mente ao ler isso.

Eu também vim do SCCS, RCS e CVS (%W% %G% %U% ).

Eu tive um desafio semelhante. Eu queria saber qual versão de um pedaço de código estava em qualquer sistema que o executasse. O sistema pode ou não estar conectado a nenhuma rede. O sistema pode ou não ter o Git instalado. O sistema pode ou não ter o repositório GitHub instalado.

Eu queria a mesma solução para vários tipos de código (.sh, .go, .yml, .xml, etc). Eu queria que qualquer pessoa sem conhecimento do Git ou GitHub pudesse responder à pergunta "Qual versão você está executando?"

Então, escrevi o que chamo de invólucro em torno de alguns comandos do Git. Eu o uso para marcar um arquivo com um número de versão e algumas informações. Isso resolve meu desafio. Isso pode ajudá-lo.

https://github.com/BradleyA/markit

git clone https://github.com/BradleyA/markit
cd markit

Para resolver esse problema, criei um pequeno "hack" como gancho pós-confirmação:

echo | tee --append *
git checkout *

Mais detalhadamente documentado neste post no meu blog .