it-swarm-pt.tech

Como faço para ignorar arquivos em um diretório no Git?

Qual é a sintaxe apropriada para o arquivo .gitignore ignorar arquivos em um diretório?

Seria

config/databases.yml
cache/*
log/*
data/sql/*
lib/filter/base/*
lib/form/base/*
lib/model/map/*
lib/model/om/*

ou

/config/databases.yml
/cache/*
/log/*
/data/sql/*
/lib/filter/base/*
/lib/form/base/*
/lib/model/map/*
/lib/model/om/*

?

518
Chris McKnight

FORMATO DE PADRÃO

  • Uma linha em branco não corresponde a nenhum arquivo, portanto, pode servir como um separador para facilitar a leitura.

  • Uma linha que começa com # serve como um comentário.

  • Um prefixo opcional ! que nega o padrão; qualquer arquivo correspondente excluído por um padrão anterior será incluído novamente. Se um padrão negado corresponder, isso substituirá as origens de padrões de precedência mais baixos.

  • Se o padrão terminar com uma barra, ele será removido para o propósito da descrição a seguir, mas só encontrará uma correspondência com um diretório. Em outras palavras, foo/ irá corresponder a um diretório foo e caminhos abaixo dele, mas não corresponderá a um arquivo regular ou a um link simbólico foo (isso é consistente com a maneira como o pathspec funciona em geral no git).

  • Se o padrão não contiver uma barra /, o git o tratará como um padrão shell glob e verificará uma correspondência com o nome do caminho em relação ao local do arquivo .gitignore (em relação ao nível superior da árvore de trabalho, se não de um arquivo .gitignore) .

  • Caso contrário, o git trata o padrão como um shell glob adequado para consumo por fnmatch(3) com o flag FNM_PATHNAME: os wildcards no padrão não corresponderão a um / no nome do caminho. Por exemplo, Documentation/*.html corresponde a Documentation/git.html mas não a Documentation/ppc/ppc.html ou tools/perf/Documentation/perf.html.

  • Uma barra adiantada corresponde ao início do nome do caminho. Por exemplo, /*.c corresponde a cat-file.c mas não a mozilla-sha1/sha1.c.

Você pode encontrar mais aqui

git help gitignore
ou
man gitignore

356
Op De Cirkel

Seria o primeiro. Vá por extensões também em vez de estrutura de pastas.

Ou seja meu exemplo c # development ignore file:

#OS junk files
[Tt]humbs.db
*.DS_Store

#Visual Studio files
*.[Oo]bj
*.user
*.aps
*.pch
*.vspscc
*.vssscc
*_i.c
*_p.c
*.ncb
*.suo
*.tlb
*.tlh
*.bak
*.[Cc]ache
*.ilk
*.log
*.lib
*.sbr
*.sdf
ipch/
obj/
[Bb]in
[Dd]ebug*/
[Rr]elease*/
Ankh.NoLoad

#Tooling
_ReSharper*/
*.resharper
[Tt]est[Rr]esult*

#Project files
[Bb]uild/

#Subversion files
.svn

# Office Temp Files
~$*

Atualizar

Eu pensei em fornecer uma atualização dos comentários abaixo. Embora não responda diretamente à pergunta do OP, veja o seguinte para mais exemplos da sintaxe .gitignore.

Wiki da comunidade (constantemente atualizado):

.gitignore para projetos e soluções do Visual Studio

Mais exemplos com linguagem específica podem ser encontrados aqui (graças ao comentário de Chris McKnight):

https://github.com/github/gitignore

176
Luke Hutton

Os caminhos que contêm barras são considerados relativos ao diretório que contém o arquivo .gitignore - geralmente o nível superior do seu repositório, embora você também possa colocá-los em subdiretórios.

Então, como em todos os exemplos que você dá, os caminhos contêm barras, as duas versões são idênticas. A única vez que você precisa colocar uma barra na frente é quando há não um no caminho já. Por exemplo, para ignorar foo apenas no nível superior do repositório, use /foo. Simplesmente escrever foo ignoraria qualquer coisa chamada foo em qualquer lugar no repositório.

Seus curingas também são redundantes. Se você quiser ignorar um diretório inteiro, basta nomeá-lo:

lib/model/om

A única razão para usar curingas do jeito que você tem é se você pretende, a princípio, des-ignorar algo no diretório:

lib/model/om/*      # ignore everything in the directory
!lib/model/om/foo   # except foo
125
Cascabel

Uma barra invertida indica que a entrada ignore deve ser válida apenas em relação ao diretório no qual o arquivo .gitignore reside. Especificar *.o ignoraria todos os arquivos .o neste diretório e todos os subdiretórios, enquanto /*.o os ignoraria naquele diretório, enquanto que novamente, /foo/*.o os ignoraria apenas em /foo/*.o.

76
jørgensen

Se você quiser colocar um arquivo .gitignore no nível superior e fazê-lo funcionar para qualquer pasta abaixo, use /**/.

Por exemplo. para ignorar todos os arquivos *.map em uma pasta /src/main/ e sub-pastas use:

/src/main/**/*.map
30
petrsyn

Ambos os exemplos na questão são, na verdade, exemplos muito ruins que podem levar à perda de dados!

Meu conselho: nunca acrescente /* aos diretórios nos arquivos .gitignore, a menos que você tenha um bom motivo!

Uma boa razão seria, por exemplo, o que Jefromi escreveu: "se você pretende sub-ignorar algo no diretório" .

A razão pela qual de outra forma não deveria ser feito é que acrescentar /* aos diretórios, por um lado, funciona da maneira que ele ignora todo o conteúdo do diretório, mas por outro lado, tem um efeito colateral perigoso:

Se você executar git stash -u (para armazenar temporariamente arquivos rastreados e não rastreados) ou git clean -df (para excluir arquivos não acompanhados mas manterão arquivos ignorados) em seu repositório, todos os diretórios ignorados com um /* anexado serão excluídos irreversivelmente!

Algum fundo

Eu tive que aprender isso da maneira mais difícil. Alguém da minha equipe estava anexando /* a alguns diretórios em nosso .gitignore. Ao longo do tempo, tive ocasiões em que certos diretórios desapareciam de repente. Diretórios com gigabytes de dados locais necessários ao nosso aplicativo. Ninguém poderia explicar isso e eu sempre faço o download de todos os dados. Depois de um tempo, percebi que isso poderia ter a ver com git stash. Um dia eu queria limpar meu repositório local (mantendo arquivos ignorados) e eu estava usando git clean -df e novamente meus dados tinham desaparecido. Desta vez eu tive o suficiente e investiguei o assunto. Eu finalmente percebi que o motivo é o /* anexado.

Eu suponho que isso pode ser explicado de alguma forma pelo fato de que directory/* ignora todo o conteúdo do diretório, mas não o próprio diretório. Assim, não é considerado rastreado nem ignorado quando as coisas são deletadas. Mesmo que git status e git status --ignored mostrem uma imagem ligeiramente diferente.

Como se reproduzir

Aqui está como reproduzir o comportamento. Atualmente estou usando o Git 2.8.4.

Um diretório chamado localdata/ com um arquivo fictício nele (important.dat) será criado em um repositório git local e o conteúdo será ignorado colocando /localdata/* no arquivo .gitignore. Quando um dos dois comandos git mencionados for executado agora, o diretório será (inesperadamente) perdido.

mkdir test
cd test
git init
echo "/localdata/*" >.gitignore
git add .gitignore
git commit -m "Add .gitignore."
mkdir localdata
echo "Important data" >localdata/important.dat
touch untracked-file

Se você fizer um git status --ignored aqui, você terá:

On branch master
Untracked files:
  (use "git add <file>..." to include in what will be committed)

  untracked-file

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

  localdata/

Agora quer fazer

git stash -u
git stash pop

ou

git clean -df

Em ambos os casos, o diretório supostamente ignorado localdata será removido!

Não tenho certeza se isso pode ser considerado um bug, mas eu acho que é pelo menos um recurso que ninguém precisa.

Vou relatar isso para a lista de desenvolvimento do git e ver o que eles pensam sobre isso.

28
jox

O primeiro. Esses caminhos de arquivo são relativos de onde seu arquivo .gitignore está.

14
Unixmonkey

Seria:

config/databases.yml
cache
log
data/sql
lib/filter/base
lib/form/base
lib/model/map
lib/model/om

ou possivelmente até:

config/databases.yml
cache
log
data/sql
lib/*/base
lib/model/map
lib/model/om

no caso de filter e form serem os únicos diretórios em lib que possuem um subdiretório base que precisa ser ignorado (veja-o como um exemplo do que você pode fazer com o asterics).

14
aefxx

Estou mantendo um serviço baseado em GUI e CLI que permite gerar modelos .gitignore com muita facilidade em https://www.gitignore.io .

Você pode digitar os modelos que deseja no campo de pesquisa ou instalar o alias de linha de comando e executar

$ gi Swift,osx

4
Joe

Um arquivo de amostra .gitignore pode ser semelhante a um abaixo para um projeto do Android Studio

# built application files
*.apk
*.ap_

# files for the dex VM
*.dex

# Java class files
*.class

# generated files
bin/
gen/

# Local configuration file (sdk path, etc)
local.properties


#Eclipse
*.pydevproject
.project
.metadata
bin/**
tmp/**
tmp/**/*
*.tmp
*.bak
*.swp
*~.nib
local.properties
.classpath
.settings/
.loadpath
YourProjetcName/.gradle/
YourProjetcName/app/build/
*/YourProjetcName/.gradle/
*/YourProjetcName/app/build/

# External tool builders
.externalToolBuilders/

# Locally stored "Eclipse launch configurations"
*.launch

# CDT-specific
.cproject

# PDT-specific
.buildpath

# Proguard folder generated by Eclipse
proguard/

# Intellij project files
*.iml
*.ipr
*.iws
.idea/
/build
build/
*/build/
*/*/build/
*/*/*/build/
*.bin
*.lock
YourProjetcName/app/build/
.gradle
/local.properties
/.idea/workspace.xml
/.idea/libraries
.DS_Store
.gradle/
app/build/
*app/build/

# Local configuration file (sdk path, etc)
local.properties
/YourProjetcName/build/intermediates/lint-cache/api-versions-6-23.1.bin
appcompat_v7_23_1_1.xml
projectFilesBackup
build.gradle
YourProjetcName.iml
YourProjetcName.iml
gradlew
gradlew.bat
local.properties
settings.gradle
.gradle
.idea
Android
build
gradle
0
Shirish Herwade