Qual é a maneira mais fácil de cometer e apertar um único arquivo, deixando outras modificações sozinho?

Question

Eu sou relativamente novo para Mercurial e minha equipe está tentando com isso agora como um substituto para o Subversion.

Como posso cometer e apertar um único arquivo para outro repositório, deixando outras modificações no meu diretório de trabalho não confirmada (ou pelo menos não empurrou para o outro repositório)?

Isso acontece para nós com as migrações de banco de dados. Queremos comprometer a migração para o controle de origem para um DBA pode visualizar e editá-lo enquanto estamos trabalhando nas modificações do código para ir junto com que a migração do banco de dados. As mudanças ainda não estão prontos para ir para que não quer empurrar todos eles fora.

Em subversão, eu simplesmente fazer:

svn add my_migration.sql  
# commit only the migration, but not the other files I'm working on
svn commit -m "migration notes" my_mygration.sql

e continuar a trabalhar no local.

Isso não funciona com mercurial como quando eu estou empurrando-o para fora para o outro repositório, se houver alterações a ele que eu não ter puxado para baixo, ele quer que eu puxá-los para baixo, fundi-los, e se comprometer que mesclagem para o repositório. Compromete após uma mesclagem não permitem arquivos omitir por isso o obriga a cometer tudo em seu repositório local.

A coisa mais fácil que eu posso descobrir é cometer o arquivo para meu repositório local, clonar meu repositório local, buscar quaisquer novas alterações do repositório real, fundi-los e cometer esse merge, e eles empurrar as minhas alterações para fora.

hg add my_migration.sql 
hg commit -m "migration notes" my_migration.sql 
cd ..
hg clone project project-clone
cd project-clone
hg fetch http://hg/project
hg push  http://hg/project

Isso funciona, mas parece que eu estou sentindo falta de algo mais fácil, alguns maneira de dizer mercurial ignorar os arquivos já no meu diretório de trabalho, basta fazer o merge e enviar os arquivos junto. Eu suspeito filas mercuriais pode fazer isso, mas eu não Grokar mq totalmente ainda.

Answer 1

Há uma característica Mercurial que implementos engavetar e comandos Unshelve, que lhe dão uma forma interactiva para especificar mudanças para armazenar afastado até um momento posterior: Shelve .

Então você pode hg shelve e hg unshelve para temporariamente armazenar as alterações de distância. Ele permite que você trabalhe no nível "remendo pedaço" de escolher os itens para arquivar distância. Ele não aparecer para arquivar um arquivo tinha listado para adicionar, única já arquivos no repo com modificações.

Ele está incluído com Mercurial como uma "extensão", que apenas significa que você tem que habilitá-lo no seu arquivo de configuração hg.

---

Nota para versões muito antigas do Mercurial (antes de prateleira foi incluído - isso não é mais necessário):

Eu não vi qualquer grande instruções de instalação com algum googling, então aqui é o material combinado que eu usei para fazê-lo funcionar:

Comece com:

hg clone http://freehg.org/u/tksoh/hgshelve/ hgshelve

O único arquivo (atualmente) no projeto é o arquivo hgshelve.py.

Modificar seu ~ / .hgrc de adicionar a extensão prateleira, apontando para onde clonado o repo:

[extensions] 
hgshelve=/Users/ted/Documents/workspace/hgshelve/hgshelve.py

Answer 2

Já faz quase dois anos desde que eu originalmente colocou esta questão. Eu faria isso de forma diferente agora (como eu mencionei em um comentário sobre a questão acima). O que eu faria agora seria a vez comprometer as minhas alterações para o arquivo no meu repo local (você pode usar a extensão recorde hg apenas comprometer peças de um arquivo):

hg commit -m "commit message" filename

Em seguida, basta empurrar para fora.

hg push

Se houver um conflito, porque outras mudanças foram feitas para o repo que eu preciso para mesclar primeiro, eu atualizar para a revisão pai (visto com "pais hg -r." Se você não sabe o que é ), comprometer as minhas outras mudanças lá, então eu tenho 2 cabeças. Em seguida, volta reverter para o arquivo original único cometer e pull / mesclar as alterações dessa versão. Em seguida, empurre as mudanças com

hg push --rev .

Para empurrar para fora apenas o arquivo único e da fusão de revisão. Então você pode mesclar as duas cabeças que você tem localmente.

Desta forma, se livrar das coisas mq eo potencial de pedaços rejeitados e mantém tudo monitorado por controle de origem. Você pode também revisões "tira hg" off se você decidir mais tarde que você não quer que eles.

Answer 3

tl; dr: Meus olhares explicação originais complicado, mas espero que totalmente explica como usar uma fila de patch. Aqui está a versão curta:

$ hg qnew -m "migration notes" -f migration my_migration.sql
$ hg qnew -f working-code
# make some changes to your code
$ hg qrefresh # update the patch with the changes you just made
$ hg qfinish -a # turn all the applied patches into normal hg commits

---

Mercurial Filas faz esse tipo de coisa uma brisa, e torna a manipulação mais complexo de changesets possíveis. Vale a pena aprender.

Nesta situação, primeiro você provavelmente gostaria de salvar o que está em seu diretório atual antes de puxar para baixo as alterações:

# create a patch called migration containing your migration
$ hg qnew -m "migration notes" -f migration.patch my_migration.sql
$ hg qseries -v # the current state of the patch queue, A means applied
0 A migration.patch
$ hg qnew -f working-code.patch # put the rest of the code in a patch
$ hg qseries -v
0 A migration.patch
1 A working-code.patch

Agora vamos fazer algum trabalho adicional no código de trabalho. Vou continuar fazendo qseries apenas para ser explícito, mas uma vez que você construir um modelo mental de filas de patch, você não terá que manter olhando para a lista.

$ hg qtop # show the patch we're currently editing
working-code.patch
$ ...hack, hack, hack...
$ hg diff # show the changes that have not been incorporated into the patch
blah, blah
$ hg qrefresh # update the patch with the changes you just made
$ hg qdiff # show the top patch's diff

Como todo o seu trabalho é salvo na fila remendo agora, você pode cancelar a aplicação dessas mudanças e restaurá-los depois de ter puxado as alterações remotas. Normalmente a Ignorar Tudo manchas, basta fazer hg qpop -a. Só para mostrar o efeito sobre o patch fila eu vou pop-los um de cada vez.

$ hg qpop # unapply the top patch, U means unapplied
$ hg qseries -v
0 A migration.patch
1 U working-code.patch
$ hg qtop
migration.patch
$ hg qpop
$ hg qseries -v
0 U migration.patch
1 U working-code.patch

Neste ponto, é como se não há mudanças em seu diretório. Faça o hg fetch. Agora você pode empurrar sua fila de patch muda novamente, e fundi-los se existem conflitos. Esta é conceitualmente um pouco semelhante ao rebase do git.

$ hg qpush # put the first patch back on
$ hg qseries -v
0 A migration.patch
1 U working-code.patch
$ hg qfinish -a # turn all the applied patches into normal hg commits
$ hg qseries -v
0 U working-code.patch
$ hg out
migration.patch commit info... blah, blah
$ hg push # push out your changes

Neste ponto, você empurrado para fora a migração, mantendo suas outras mudanças locais. Os seus outras alterações estão em um remendo na fila. Eu faço a maioria do meu desenvolvimento pessoal usando uma fila patch para me ajudar a estruturar as minhas alterações melhor. Se você quiser se livrar da fila de patch e voltar a um estilo normal, você vai ter que exportar suas alterações e reimportar-los em "normal" mercurial.

$ hg qpush
$ hg qseries -v
0 A working-code.patch
$ hg export qtip > temp.diff
$ rm -r .hg/patches # get rid of mq from the repository entirely
$ hg import --no-commit temp.diff # apply the changes to the working directory
$ rm temp.diff

---

Estou extremamente viciado em filas de patch para o desenvolvimento e mq é uma das implementações mais agradáveis ??lá fora. A capacidade de criar várias alterações em simultâneo realmente melhorar a forma como concentrado e limpar seus commits são. Demora um pouco para se acostumar, mas vai incrivelmente bem com um DVCS fluxo de trabalho.

Answer 4

Outra opção se você não quer contar com extensões é manter um clone de seu repositório montante localmente que você use somente para esses tipos de tarefas de integração.

No seu exemplo, você poderia simplesmente puxar / mesclar sua mudança para a integração repositório / a montante e empurrá-lo diretamente para o servidor remoto.

Answer 5

O que eu uso geralmente é usado para cometer um único arquivo:

 hg commit -m "commit message" filename

No caso mais tarde, eu tenho um conflito de mesclagem e eu ainda não estou pronto para cometer as minhas alterações, siga estes passos:

1) Crie um arquivo de patch.

hg diff > changes.patch

2) Reverter todas as suas notáveis ??alterações não confirmadas, somente após a verificação de seu arquivo de patch.

hg revert --all

3) Pull, atualização e mesclagem para última revisão

hg pull -u
hg merge
hg commit -m "local merge"

4) Agora, basta importar seu patch para trás e obter as alterações.

hg import --no-commit changes.patch

Lembre-se de usar -no-cometer bandeira da auto submeter as alterações.

Answer 6

Uma vez que você disse mais fácil, muitas vezes eu uso hg commit -i (--interactive) mesmo quando cometer arquivos inteiros. Com --interactive você pode apenas selecionar o arquivo (s) que você quer em vez de digitar o seu caminho inteiro (s) na linha de comando. Como um bônus adicionado você pode até mesmo incluir seletivamente / excluir pedaços dentro dos arquivos.

E depois é só hg push empurrar esse recém-criado cometer.

Eu coloquei mais detalhes sobre o uso hg commit --interactive nesta resposta: https://stackoverflow.com/a/47931672/255961