Ignore o próprio arquivo .gitignore

Acabei de fazer um git init na raiz do meu novo projeto.

Então eu criei um arquivo .gitignore .

Agora, quando eu digito o git status , o arquivo .gitignore aparece na lista de arquivos não acompanhados. Por que é que?

O arquivo .gitignore deve estar no seu repository, então deve ser adicionado e confirmado, como sugere o git status . Tem que ser uma parte da tree do repository, para que as mudanças possam ser mescladas e assim por diante.

Então, adicione-o ao seu repository, ele não deve ser gitignored.

Se você realmente quiser, pode adicionar .gitignore ao arquivo .gitignore se não quiser que ele seja confirmado. No entanto, nesse caso, provavelmente é melhor adicionar os ignorados a .git/info/exclude , um arquivo especial de check-out local que funciona como .gitignore, mas não aparece em “git status”, pois está na pasta .git .

Veja também https://help.github.com/articles/ignoring-files

Se você quiser armazenar a lista de arquivos ignorados fora da sua tree Git, você pode usar o arquivo .git / info / exclude . É aplicado apenas ao seu checkout do repo.

Você poderia realmente colocar uma linha “.gitignore” em seu arquivo “.gitignore”. Isso faria com que o arquivo “.gitignore” fosse ignorado pelo git. Na verdade, não acho que seja uma boa ideia. Eu acho que o arquivo de ignorar deve ser controlado e controlado por versão. Eu estou apenas colocando isso para fora para a perfeição.

Você também pode ter um arquivo global user git .gitignore que será aplicado automaticamente a todos os seus repositorys. Isso é útil para arquivos IDE e editor (por exemplo, arquivos swp e *~ para o Vim). Alterar locais de diretório para o seu sistema operacional

  1. Adicione ao seu arquivo ~/.gitconfig

     [core] excludesfile = /home/username/.gitignore 
  2. Crie um arquivo ~/.gitignore com padrões de arquivo a serem ignorados

  3. Salve seus arquivos de pontos em outro repo para ter um backup (opcional).

Toda vez que você copiar, iniciar ou clonar um repository, seu arquivo global gitignore também será usado.

Depois de adicionar o arquivo .gitignore e confirmá-lo, ele não será mais exibido na lista “arquivos não acompanhados”.

 git add .gitignore git commit -m "add .gitignore file" git status 

Se alguém já adicionou um .gitignore ao seu .gitignore , mas você deseja fazer algumas alterações e ignorar essas alterações, faça o seguinte:

git update-index --assume-unchanged .gitignore

Fonte

Apenas incase alguém tem a mesma dor que nós tivemos. Queríamos excluir um arquivo que já havia sido confirmado.

Este post foi muito mais útil: trabalhar com .git / info / exclude muito tarde

Especificamente, o que você precisa para ignorar um arquivo é realmente usar o comando git remove Veja git rm ( http://www.kernel.org/pub/software/scm/git/docs/git-rm.html )

você testa isso indo

git rm --dry-run *.log
(se você disser que queria excluir todos os arquivos de log)

Isto irá mostrar o que seria excluído se você o executasse.

então

você corre, indo

git rm *.log
(ou qualquer caminho / expressão de nome de arquivo que você queira)

Em seguida, adicione uma linha *.log ao seu arquivo .gitignore .

A idéia é colocar arquivos que são específicos para o seu projeto no arquivo .gitignore e (como já mencionado) adicioná-lo ao repository. Por exemplo, arquivos .pyc e .o , logs que o testsuite cria, alguns fixtures etc.

Para arquivos criados por sua própria instalação, mas que não serão necessariamente exibidos para todos os usuários (como arquivos .swp se você usar vim, diretórios ecplise ocultos e afins), deverá usar .git/info/exclude (como já mencionado).

É claro que o arquivo .gitignore está aparecendo no status, porque não foi rastreado, e o git o vê como um novo arquivo saboroso para comer!

Já que .gitignore é um arquivo não-rastreado, no entanto, ele é um candidato a ser ignorado pelo git quando você o coloca no .gitignore!

Então, a resposta é simples: basta adicionar a linha:

 .gitignore # Ignore the hand that feeds! 

para o seu arquivo .gitignore!

E, ao contrário da resposta de agosto, devo dizer que não é que o arquivo .gitignore esteja no seu repository. Acontece que pode ser, o que geralmente é conveniente. E é provavelmente verdade que esta é a razão. O gitignore foi criado como uma alternativa ao .git / info / exclude, que não tem a opção de ser rastreado pelo repository. De qualquer forma, a maneira como você usa o seu arquivo .gitignore depende totalmente de você.

Para referência, confira a manitage gitignore (5) no kernel.org.

Primeiro de tudo, como muitos outros já disseram, o seu .gitignore deve ser rastreado pelo Git (e portanto não deve ser ignorado). Deixe-me explicar por quê.

(TL; DR: confirme o arquivo .gitignore e use um .gitignore global para ignorar os arquivos criados pelo seu IDE ou sistema operacional)

O Git é, como você provavelmente já sabe, um sistema de version control distribuído . Isso significa que ele permite alternar entre diferentes versões (mesmo que o desenvolvimento tenha divergido em diferentes ramificações) e também permite que vários desenvolvedores trabalhem no mesmo projeto.

Embora o rastreamento de seu .gitignore também tenha benefícios quando você alterna entre instantâneos, o motivo mais importante para confirmá-lo é que você desejará compartilhar o arquivo com outros desenvolvedores que estejam trabalhando no mesmo projeto. Ao cometer o arquivo para o Git, outros contribuidores obterão automaticamente o arquivo .gitignore quando .gitignore o repository, para que não tenham que se preocupar em cometer acidentalmente um arquivo que não deve ser confirmado (como arquivos de log, diretórios de cache, credenciais de database, etc.). E se, em algum momento, o projeto .gitignore for atualizado, eles poderão simplesmente .gitignore essas alterações, em vez de precisar editar o arquivo manualmente.

Claro, haverá alguns arquivos e pastas que você vai querer ignorar, mas que são específicos para você e não se aplicam a outros desenvolvedores. No entanto, esses não devem estar no projeto .gitignore . Existem dois outros lugares onde você pode ignorar arquivos e pastas:

  • Os arquivos e pastas criados pelo sistema operacional ou IDE devem ser colocados em um .gitignore global . O benefício é que este .gitignore é aplicado a todos os repositorys em seu computador, assim você não precisa repetir isto para cada repository. E não é compartilhado com outros desenvolvedores, pois eles podem estar usando um sistema operacional e / ou IDE diferente.
  • Os arquivos que não pertencem ao .gitignore do projeto, nem no .gitignore global, podem ser ignorados usando o repository explícito excluído em your_project_directory/.git/info/exclude . Este arquivo não será compartilhado com outros desenvolvedores e é específico para esse único repository

Cuidado com o seguinte “problema” Às vezes você deseja adicionar diretórios, mas não há arquivos dentro desses diretórios. A solução simples é criar um .gitignore com o seguinte conteúdo:

 * 

Isso parece funcionar bem até você perceber que o diretório não foi adicionado (como esperado para o seu repository. A razão para isso é que o .gitignore também será ignorado e, portanto, o diretório está vazio. Assim, você deve fazer algo assim :

 * !.gitignore 

Isto parece funcionar apenas para o seu diretório atual para fazer com que o Git ignore todos os arquivos do repository.

atualize este arquivo

 .git/info/exclude 

com seu curinga ou nome de arquivo

 *pyc *swp *~ 

No meu caso, quero excluir um arquivo existente. Apenas modificar .gitignore não funciona. Eu segui estes passos:

 git rm --cached dirToFile/file.php vim .gitignore git commit -a 

Dessa forma, limpei do cache o arquivo que queria excluir e depois o adicionei ao .gitignore .

Navegue até o diretório base do seu git repo e execute o seguinte comando:

 echo '\\.*' >> .gitignore 

Todos os arquivos de pontos serão ignorados, incluindo a .DS_Store irritante se você estiver usando um mac.

Se você já fez check-in de .gitignore e deseja ignorar as modificações, confira esta resposta :

Tente usar este comando:

 git update-index --assume-unchanged FILENAME_TO_IGNORE 

Para reverter isso (se você quiser fazer alterações nela), use:

 git update-index --no-assume-unchanged 

ATUALIZAÇÃO :

Veja como listar os arquivos ‘assumidos inalterados’ no diretório atual:

 git ls-files -v | grep -E "^[az]" 

Como a opção -v usará letras minúsculas para arquivos ‘assumem inalterados’.

É bem possível que um usuário final queira que o Git ignore o arquivo “.gitignore” simplesmente porque as pastas específicas do IDE criadas pelo Eclipse provavelmente não são as mesmas do NetBeans ou de outro IDE. Então, para manter o IDE do código-fonte antagônico, torna-se mais fácil ter um git ignore personalizado que não seja compartilhado com toda a equipe, pois desenvolvedores individuais podem estar usando IDEs diferentes.

Eu acho que há situações em que ignorar o .gitignore é muito útil. Por exemplo, quando você tem várias equipes ou uma grande equipe trabalhando na mesma base de código. Nesse caso, você precisa ter certas convenções, uma dessas convenções é sobre o que é ignorado no repository do git. Geralmente é sobre ignorar arquivos e diretórios criados pelo IDE ou sistema operacional, alguns logs gerados, etc.

No entanto, existe uma força que tende a introduzir alterações não convencionais no arquivo .gitignore . O arquivo .gitignore pode ser alterado por pessoa irresponsável, por engano, por uma ferramenta usada ou em outro caso.

Para ter uma força contrária, podemos fazer o seguinte:

  1. O gitignore inicial deve refletir a convenção na (s) equipe (s),
  2. Depois que ele for enviado, o .gitignore deverá ser protegido adicionando-se a input .gitignore e pressionando-o novamente. .gitignore arquivo .gitignore é ” selado ” dessa maneira.

O arquivo ” selado.gitignore pode ser alterado, apenas localmente, sem propagar os trocadores para outros membros da (s) equipe (s). No entanto, se uma mudança for amplamente aceita em toda a (s) equipe (s) do que é possível “desatá-la”, altere-a e “sele-a” novamente. Isso não pode ser feito por engano, apenas intencionalmente.

Infelizmente, você não pode estar 100% protegido da estupidez, mas desta forma você fez tudo que podia para evitar que coisas estúpidas acontecessem.

Se você tem uma equipe relativamente pequena com profissionais muito bons, isso não seria importante, mas até esses caras gostariam de ter uma coisa a menos para se preocupar.

Usando .git/info/exclude é legal quando você não pode fazer nada sobre as configurações de infra-estrutura, apenas cobrindo o seu próprio ** para não cometer um erro.

De um ponto de vista do que é certo e do que é errado, eu estou votando para ter a input do .gitignore dentro do arquivo .gitignore , dando a todos a liberdade de fazer localmente o que quiserem, mas não invadindo os outros.

Descobri que o melhor lugar para configurar um ignorar para os arquivos .DS_Store está no arquivo .DS_Store .git/info/exclude .

O IntelliJ parece fazer isso automaticamente quando você configura um repository git nele.

.gitignore é sobre ignorar outros arquivos. git é sobre arquivos, então isso é sobre ignorar arquivos. No entanto, como o git trabalha com arquivos, este arquivo precisa estar lá como o mecanismo para listar os outros nomes de arquivos.

Se fosse chamado .the_list_of_ignored_files , poderia ser um pouco mais óbvio.

Uma analogia é uma lista de itens a fazer que você NÃO deseja fazer. A menos que você os liste em algum lugar, é uma espécie de lista de tarefas que você não saberá sobre elas.