Como preparar apenas parte de um novo arquivo com o git?

Eu amo o git add --interactive . Agora faz parte do meu fluxo de trabalho diário.

O problema parece que não funciona com arquivos não rastreados. O que eu quero fazer é rastrear um novo arquivo, mas apenas adicionar parte dele, ou seja, algumas partes desse novo arquivo ainda não estão prontas para serem preparadas.

Por exemplo, com o git add -i, eu posso escolher a opção de patch e até editar blocos individuais, a fim de preparar partes do novo código, deixando os comentários do código de depuração em estágios. Adoro trabalhar dessa maneira, porque torna óbvio em que locais do mega patch em que estou trabalhando ainda precisam de trabalho.

Infelizmente, parece que não consigo fazer o mesmo com um arquivo não rastreado. Ou eu preparo o arquivo inteiro, ou nada. A solução alternativa que estou usando é a preparação ou até a confirmação de um novo arquivo quando ele estiver vazio e, em seguida, a realização de alterações individuais da maneira usual. Mas essa solução parece um truque sujo e, quando esqueço, ou mudo de idéia, cria mais problemas do que deveria.

Portanto, a pergunta é: como preparar apenas parte de um novo arquivo, para que esse novo arquivo seja rastreado, mas deixando o todo ou parte do seu conteúdo sem palco?

Whoa, tudo isso update-indexe os hash-objectnegócios parecem excessivamente complicados. Que tal isso:

git add -N new_file
git add -i

De git help add:

-N, --intent-to-add
    Record only the fact that the path will be added later.  An entry
    for the path is placed in the index with no content.  This is useful
    for, among other things, showing the unstaged content of such files
    with git diff and committing them with git commit -a.

A maneira mais fácil de fazer isso (e imho teste interativo em geral) é git gui. Ele vem com o git e deve funcionar em quase todas as plataformas suportadas pelo git.

Basta executar git guie uma interface gráfica do usuário será aberta, permitindo blocos de teste e de teste e até linhas únicas de arquivos rastreados e não rastreados.

git update-index --add --cacheinfo 100644 $(git hash-object -w /dev/null) newfile
git add --interactive newfile

Demonstração simples:

mkdir /tmp/demo
cd /tmp/demo
git init .

echo hello > newfile
git update-index --add --cacheinfo 100644 $(git hash-object -w /dev/null) newfile

• _{Dica Se você tem certeza de que o blob 'vazio' já existe no seu banco de dados de objetos git, você pode codificar o hash e69de29bb2d1d6434b8b29ae775ad8c2e48c5391. Eu não recomendo fazer isso_}
• _{Dica Se você estiver no Windows, provavelmente poderá usar apenas em NUL:vez de /dev/null. Caso contrário, use algo comoecho -n '' | git hash-object --stdin -w}

Agora, o índice conterá newfilecomo o blob vazio e o blob vazio foi inserido no banco de dados do objeto se ainda não existia:

$ find .git/objects/ -type f 
.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391

$ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#   new file:   newfile
#
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#   modified:   newfile
#

$ git diff
diff --git a/newfile b/newfile
index e69de29..ce01362 100644
--- a/newfile
+++ b/newfile
@@ -0,0 +1 @@
+hello

Isso deve ser exatamente o que você deseja. Também posso recomendar o plugin fugitivo vim para gerenciamento de índice muito inteligente (consulte Better git add -p? )

Edit: isso não parece estar funcionando agora. Tenho certeza de que era antes (no git 1.7.1). Caso isso não funcione, sugiro a preparação, /dev/nullcomo sugere acima:

git update-index --add --cacheinfo 100644 $(git hash-object -w /dev/null) newfile

Se você estiver no Windows (sem /dev/null), poderá substituí-lo pelo caminho para um arquivo vazio.

Resposta original

Você quer

git add -p # (or --patch)

Isso adiciona arquivos não rastreados para mim. Na página do manual:

Escolha interativamente pedaços de patch entre o índice e a árvore de trabalho e adicione-os ao índice. Isso permite ao usuário revisar a diferença antes de adicionar conteúdo modificado ao índice.

Isso efetivamente executa add --interactive, mas ignora o menu de comando inicial e salta diretamente para o subcomando do patch. Consulte "Modo interativo" para obter detalhes.

Só para registrar uma outra possibilidade: eu uso

git add -N file
git add -p file

E então você pode montar pedaços ou editá-los no lugar.