que - ¿Cómo puedo agregar un directorio vacío a un repositorio Git?

git push origin master

Question

¿Cómo puedo agregar un directorio vacío (que no contiene archivos) a un repositorio Git?

Answer 1

¿Por qué necesitamos carpetas vacías versionadas?

Lo primero es lo primero:

Un directorio vacío no puede ser parte de un árbol bajo el sistema de versiones de Git .

Simplemente no será rastreado. Pero hay escenarios en los que los "directorios de versión vacía" pueden ser útiles, por ejemplo:

• andamiaje una estructura de carpetas predefinida , y haga que esta estructura esté disponible para cada usuario / contribuyente del repositorio; o, como un caso especializado de lo anterior, crear una carpeta para archivos temporales , como un cache/ o logs/ directorios, donde queremos proporcionar la carpeta pero .gitignore su contenido
• En relación con el aboce, algunos proyectos no funcionarán sin algunas carpetas (lo que a menudo es un indicio de un proyecto mal diseñado, pero es un escenario frecuente en el mundo real y tal vez podría haber, por ejemplo, problemas con los permisos).

Algunas soluciones sugeridas

Muchos usuarios sugieren:

1. Colocar un archivo README u otro archivo con algún contenido para hacer que el directorio no esté vacío, o
2. Crear un archivo .gitignore con una especie de "lógica inversa" (es decir, para incluir todos los archivos) que, al final, cumple el mismo propósito del enfoque # 1.

Si bien ambas soluciones seguramente funcionan , las encuentro inconsistentes con un enfoque significativo para el control de versiones de Git.

• ¿Por qué se supone que debes poner archivos falsos o README que quizás no quieras en tu proyecto?
• ¿Por qué usar .gitignore para hacer una cosa ( mantener archivos) que es lo opuesto a su significado ( excluyendo archivos), aunque sea posible?

enfoque de .git

Utilice un archivo vacío llamado .gitkeep para forzar la presencia de la carpeta en el sistema de versiones.

Aunque no parezca una gran diferencia:

• Utiliza un archivo que tiene el único propósito de mantener la carpeta. Usted no pone allí ninguna información que no quiere poner.

  Por ejemplo, debería usar READMEs como, bueno, READMEs con información útil, no como una excusa para conservar la carpeta.

  La separación de las preocupaciones siempre es algo bueno, y aún puede agregar un .gitignore para ignorar los archivos no deseados.

• .gitkeep hace muy claro y directo desde el propio nombre de archivo (y también a otros desarrolladores , lo que es bueno para un proyecto compartido y uno de los propósitos principales de un repositorio Git) de que este archivo es

  • Un archivo no relacionado con el código (debido al punto inicial y al nombre)
  • Un archivo claramente relacionado con Git.
  • Su propósito ( mantener ) está claramente establecido y es consistente y semánticamente opuesto en su significado de ignorar

Adopción

He visto el enfoque de .gitkeep adoptado por marcos muy importantes como Laravel , Angular-CLI .

Answer 2

Andy Lester tiene razón, pero si su directorio solo necesita estar vacío, y no vacío, puede colocar un archivo .gitignore vacío allí como solución alternativa.

Además, este es un problema de implementación, no un problema fundamental de diseño de almacenamiento de Git. Como se ha mencionado muchas veces en la lista de correo de Git, la razón por la que esto no se ha implementado es que a nadie le ha importado lo suficiente como para enviar un parche, no porque no se pueda o no deba hacerse.

Answer 3

Como se describe en otras respuestas, Git no puede representar directorios vacíos en su área de preparación. (Consulte las preguntas frecuentes de Git ). Sin embargo, si, para sus propósitos, un directorio está lo suficientemente vacío si solo contiene un archivo .gitignore , entonces puede crear archivos .gitignore en directorios vacíos solo a través de:

find . -type d -empty -exec touch {}/.gitignore /;

Answer 4

Como se mencionó, no es posible agregar directorios vacíos, pero aquí hay una sola línea que agrega archivos .gitignore vacíos a todos los directorios.

ruby -e ''require "fileutils" ; Dir.glob(["target_directory","target_directory/**"]).each { |f| FileUtils.touch(File.join(f, ".gitignore")) if File.directory?(f) }''

He pegado esto en un Rakefile para un fácil acceso.

Answer 5

Cree un archivo vacío llamado .gitkeep en el directorio, y agregue eso.

Answer 6

Cuando agregue un archivo .gitignore , si va a colocar cualquier cantidad de contenido (que desee que Git ignore), es posible que desee agregar una sola línea con solo un asterisco * para asegurarse de no agregar el Contenido ignorado accidentalmente.

Answer 7

Digamos que necesita un directorio vacío llamado tmp :

$ mkdir tmp
$ touch tmp/.gitignore
$ git add tmp
$ echo ''*'' > tmp/.gitignore
$ git commit -m ''Empty directory'' tmp

En otras palabras, debe agregar el archivo .gitignore al índice antes de que pueda decirle a Git que lo ignore (y todo lo demás en el directorio vacío).

Answer 8

Git no rastrea directorios vacíos. Ver las preguntas frecuentes de Git para más explicación. La solución sugerida es colocar un archivo .gitignore en el directorio vacío. No me gusta esa solución, porque el .gitignore está "oculto" por la convención de Unix. Tampoco hay explicación por qué los directorios están vacíos.

Sugiero poner un archivo README en el directorio vacío explicando por qué el directorio está vacío y por qué necesita ser rastreado en Git. Con el archivo README en su lugar, en lo que respecta a Git, el directorio ya no está vacío.

La verdadera pregunta es ¿por qué necesita el directorio vacío en git? Por lo general, tiene algún tipo de script de compilación que puede crear el directorio vacío antes de compilar / ejecutar. Si no, entonces haz uno. Esa es una solución mucho mejor que poner directorios vacíos en git.

Así que tienes alguna razón por la que necesitas un directorio vacío en git. Pon esa razón en el archivo README. De esa manera, otros desarrolladores (y usted, en el futuro) saben por qué el directorio vacío debe estar allí. También sabrá que puede eliminar el directorio vacío cuando se solucione el problema que requiere el directorio vacío.

Para listar cada directorio vacío use el siguiente comando:

find -name .git -prune -o -type d -empty -print

Para crear LECTORES de marcador de posición en cada directorio vacío:

find -name .git -prune -o -type d -empty -exec sh -c /
  "echo this directory needs to be empty because reasons > {}/README.emptydir" /;

Para ignorar todo en el directorio, excepto el archivo README, coloque las siguientes líneas en su .gitignore :

path/to/emptydir/*
!path/to/emptydir/README.emptydir
path/to/otheremptydir/*
!path/to/otheremptydir/README.emptydir

Alternativamente, puedes excluir cada archivo README de ser ignorado:

path/to/emptydir/*
path/to/otheremptydir/*
!README.emptydir

Para listar cada README después de que ya están creados:

find -name README.emptydir

Answer 9

La forma de creación de la carpeta de registro de Ruby on Rails :

mkdir log && touch log/.gitkeep && git add log/.gitkeep

Ahora el directorio de registro se incluirá en el árbol. Es muy útil cuando se implementa, por lo que no tendrá que escribir una rutina para hacer directorios de registro.

Los archivos de registro pueden mantenerse fuera de la emisión,

echo log/dev.log >> .gitignore

pero probablemente lo sabías.

Answer 10

No puedes y lamentablemente nunca podrás hacerlo. Esta es una decisión tomada por el propio Linus Torvald. Él sabe lo que es bueno para nosotros.

Hay una perorata por ahí en algún lugar que leí una vez.

Encontré Re: directorios vacíos ... , pero tal vez haya otro.

Tienes que vivir con las soluciones ... desafortunadamente.

Answer 11

Otra forma de hacer que un directorio permanezca vacío (en el repositorio) es crear un archivo .gitignore dentro de ese directorio que contiene estas cuatro líneas:

# Ignore everything in this directory
*
# Except this file
!.gitignore

Entonces, no tiene que hacer el pedido de la manera correcta en la solution de m104.

Esto también proporciona la ventaja de que los archivos de ese directorio no aparecerán como "sin seguimiento" cuando se hace un estado de git.

Haciendo persistente el comentario de @GreenAsJade :

Creo que vale la pena señalar que esta solución hace precisamente lo que la pregunta pidió, pero quizás no sea lo que muchas personas que miran esta pregunta habrán estado buscando. Esta solución garantiza que el directorio permanezca vacío. Dice "Realmente nunca quiero que los archivos se registren aquí". A diferencia de "No tengo ningún archivo para registrar aquí todavía, pero necesito el directorio aquí, los archivos pueden venir más tarde".

Answer 12

Siempre puede poner un archivo README en el directorio con una explicación de por qué quiere este directorio, en caso contrario, vacío en el repositorio.

Answer 13

Tal vez agregar un directorio vacío parece que sería la ruta de menor resistencia porque tiene scripts que esperan que ese directorio exista (tal vez porque es un objetivo para los binarios generados). Otro enfoque sería modificar sus scripts para crear el directorio según sea necesario .

mkdir --parents .generated/bin ## create a folder for storing generated binaries
mv myprogram1 myprogram2 .generated/bin ## populate the directory as needed

En este ejemplo, puede ingresar un enlace simbólico (roto) al directorio para poder acceder a él sin el prefijo ".generated" (pero esto es opcional).

ln -sf .generated/bin bin
git add bin

Cuando quieras limpiar tu árbol fuente, puedes simplemente:

rm -rf .generated ## this should be in a "clean" script or in a makefile

Si adopta el enfoque frecuentemente sugerido de registrar una carpeta casi vacía, tiene la menor complejidad de eliminar el contenido sin eliminar también el archivo ".gitignore".

Puede ignorar todos sus archivos generados agregando lo siguiente a su raíz .gitignore:

.generated

Answer 14

También he estado enfrentando el problema con directorios vacíos. El problema con el uso de archivos de marcador de posición es que necesita crearlos y eliminarlos, si ya no son necesarios (porque posteriormente se agregaron subdirectorios o archivos. Con grandes árboles de origen, administrar estos archivos de marcador de posición puede ser engorroso y erróneo propenso.

Es por eso que decidí escribir una herramienta de código abierto que pueda administrar la creación / eliminación de dichos archivos de marcadores de posición automáticamente. Está escrito para la plataforma .NET y se ejecuta bajo Mono (.NET para Linux) y Windows.

Solo eche un vistazo a: http://code.google.com/p/markemptydirs

Answer 15

Usted no puede Ver las preguntas frecuentes de Git .

Actualmente, el diseño del índice git (área de preparación) solo permite la inclusión de archivos en la lista, y nadie lo suficientemente competente para hacer el cambio para permitir que los directorios vacíos se hayan preocupado lo suficiente por esta situación para remediarlo.

Los directorios se agregan automáticamente al agregar archivos dentro de ellos. Es decir, los directorios nunca tienen que agregarse al repositorio, y no se rastrean por sí mismos.

Puede decir " git add <dir> " y agregará archivos allí.

Si realmente necesita un directorio para existir en las cajas, debe crear un archivo en él. .gitignore funciona bien para este propósito; puede dejarlo vacío o completar los nombres de los archivos que espera que aparezcan en el directorio.

Answer 16

Usted no puedeEsta es una decisión de diseño intencional por parte de los mantenedores de Git. Básicamente, el propósito de un sistema de administración de código fuente como Git es administrar el código fuente y los directorios vacíos no son código fuente. Git también se describe a menudo como un rastreador de contenido, y nuevamente, los directorios vacíos no son contenido (todo lo contrario, en realidad), por lo que no se rastrean.

Answer 17

ADVERTENCIA: Este pellizco no funciona realmente como resulta. Lo siento por los inconvenientes ocasionados.

Post original a continuación:

¡Encontré una solución jugando con Git internals!

1. Supongamos que estás en tu repositorio.

2. Crea tu directorio vacío:

   $ mkdir path/to/empty-folder

3. Agréguelo al índice usando un comando de plomería y el árbol vacío SHA-1 :

   $ git update-index --index-info
   040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder

   Escriba el comando y luego ingrese la segunda línea. Presione Entrar y luego Ctrl + D para terminar su entrada. Nota: el formato es modo [ESPACIO] tipo [ESPACIO] SHA-1hash [TAB] ruta (la pestaña es importante, el formato de la respuesta no la conserva).

4. ¡Eso es! Su carpeta vacía está en su índice. Todo lo que tienes que hacer es cometer.

Esta solución es corta y aparentemente funciona bien ( vea EDITAR ), pero no es tan fácil de recordar ...

El árbol vacío SHA-1 se puede encontrar creando un nuevo repositorio de Git vacío, cd en él y emite git write-tree , que genera el árbol vacío SHA-1.

EDITAR:

He estado usando esta solución desde que la encontré. Parece que funciona exactamente de la misma manera que creando un submódulo, excepto que ningún módulo está definido en ninguna parte. Esto conduce a errores al emitir git submodule init|update . El problema es que git update-index vuelve a escribir la parte del 040000 tree en 160000 commit .

Además, cualquier archivo colocado en esa ruta nunca será detectado por Git, ya que cree que pertenece a otro repositorio. ¡Esto es desagradable ya que puede pasarse por alto fácilmente!

Sin embargo, si no lo hace (y no usará) ningún submódulo de Git en su repositorio, y la carpeta "vacía" permanecerá vacía o si desea que Git sepa de su existencia e ignore su contenido, puede ir con este pellizco. Seguir el camino habitual con los submódulos lleva más pasos que este pellizco.

Answer 18

Añadiendo una opción más a la refriega.

Suponiendo que le gustaría agregar un directorio a giteso, para todos los propósitos relacionados con git, debe permanecer vacío y nunca se debe rastrear su contenido, .gitignoretal como se sugiere varias veces aquí, funcionará.

El formato, como se mencionó, es:

*
!.gitignore

Ahora, si desea una manera de hacer esto en la línea de comando, de una sola vez, mientras está dentro del directorio que desea agregar, puede ejecutar:

$ echo "*" > .gitignore && echo ''!.gitignore'' >> .gitignore && git add .gitignore

Yo, tengo un script de shell que uso para hacer esto. Asigne un nombre al script como desee, y agréguelo en algún lugar de su ruta de inclusión o haga referencia directamente:

#!/bin/bash

dir=''''

if [ "$1" != "" ]; then
    dir="$1/"
fi

echo "*" > $dir.gitignore && /
echo ''!.gitignore'' >> $dir.gitignore && /
git add $dir.gitignore

Con esto, puede ejecutarlo desde el directorio que desea agregar, o hacer referencia al directorio como primer y único parámetro:

$ ignore_dir ./some/directory

Otra opción (en respuesta a un comentario de @GreenAsJade), si desea realizar un seguimiento de una carpeta vacía que PUEDEN contener archivos rastreados en el futuro, pero va a estar vacío por ahora, puede ommit el *del .gitignorearchivo, y comprobar que en. Básicamente, todo lo que dice el archivo es "no me ignore ", pero de lo contrario, el directorio está vacío y rastreado.

Su .gitignorearchivo se vería como:

!.gitignore

Eso es todo, verifique eso y tiene un directorio vacío, pero rastreado, en el que puede rastrear archivos más adelante.

La razón por la que sugiero mantener esa única línea en el archivo es que da el .gitignorepropósito. De lo contrario, alguien de la línea puede pensar en eliminarlo. Puede ayudar si coloca un comentario sobre la línea.

Answer 19

La solución de Jamie Flournoy funciona muy bien. Aquí hay una versión un poco mejorada para mantener el .htaccess :

# Ignore everything in this directory
*
# Except this file
!.gitignore
!.htaccess

Con esta solución, puede enviar una carpeta vacía, por ejemplo /log , /tmp o /cache y la carpeta permanecerá vacía.

Answer 20

Me gustan las respuestas de @ Artur79 y @mjs, así que he estado usando una combinación de ambos y lo he convertido en un estándar para nuestros proyectos.

find . -type d -empty -exec touch {}/.gitkeep /;

Sin embargo, solo un puñado de nuestros desarrolladores trabajan en Mac o Linux. Mucho trabajo en Windows y no pude encontrar una línea simple equivalente para lograr lo mismo allí. Algunos tuvieron la suerte de instalar Cygwin por otros motivos, pero prescribir a Cygwin solo por esto parecía excesivo.

Entonces, dado que la mayoría de nuestros desarrolladores ya tienen instalado Ant , armé un archivo de compilación para lograr esto independientemente de la plataforma.

<?xml version="1.0" encoding="ISO-8859-1"?>
<project name="Gitkeep" basedir="." default="keep">
    <!--Apply to all subdirs of this dir-->
    <target name="keep" description="-> Add a .gitkeep file to all empty subdir''s of this dir.">

        <!--Create a ref to all the subdirs in the tree of this dir-->
        <dirset id="dirs.ref" dir="./" includes="**/*"/>
        <!--Create a list of the subdirs under this dir-->
        <property name="dirs.list" refid="dirs.ref" />

        <!--For each subdir-->
        <for list="${dirs.list}" delimiter=";" param="dir">
            <sequential>
                <!--If the subdir is empty this target will add a .gitkeep file to it-->
                <antcall target="gitkeep" inheritall="false">
                    <param name="dir" value="@{dir}"/>
                </antcall>
            </sequential>
        </for>
    </target>

    <!--Add a .gitkeep file to a directory if it''s empty-->
    <target name="gitkeep" description="-> Add a .gitkeep file to a specific subdir of this dir. Use -Ddir=relative/path/to/dir">

        <!--Create a ref of the files inside this dir-->
        <fileset dir="${dir}" id="contents.ref"/>

        <!--Create a path to the contents of this directory, ONLY if it''s not empty-->
        <pathconvert refid="contents.ref" property="contents.path" setonempty="false"/>

        <if>
            <!--If the dir is empty create the .gitkeep file-->
            <not><isset property="contents.path"/></not>
            <then>
                <!--Create the .gitkeep file-->
                <echo message="Version this dir in Git even if its empty." file="./${dir}/.gitkeep" force="true" append="false"/>
            </then>
        </if>
    </target>
</project>

Ahora puedo simplemente correr

ant -f gitkeep.xml

Y esto crea un archivo .gitkeep en cualquier subdirectorio vacío. Incluso en Windows :) Nota: este archivo de compilación requiere el tar Ant Ant .

Sigo trabajando en este concepto here .

here

Answer 21

No hay forma de hacer que Git realice un seguimiento de los directorios, por lo que la única solución es agregar un archivo de marcador de posición dentro del directorio del que desea que Git realice el seguimiento.

El archivo puede ser nombrado y contener lo que desee, pero la mayoría de las personas usa un archivo vacío llamado .gitkeep(aunque algunas personas prefieren el VCS-agnóstico .keep).

El prefijo lo .marca como un archivo oculto.

Otra idea sería agregar un READMEarchivo que explique para qué se usará el directorio.

Answer 22

Si desea agregar una carpeta que alojará una gran cantidad de datos transitorios en varios directorios semánticos, entonces un enfoque es agregar algo como esto a su raíz .gitignore ...

/app/data/**/*.* !/app/data/**/*.md

Luego, puede enviar archivos README.md descriptivos (o archivos en blanco, no importa, siempre que pueda apuntarlos de forma única como *.mden este caso) en cada directorio para asegurarse de que todos los directorios sigan siendo parte del repositorio pero el Los archivos (con extensiones) se mantienen ignorados. LIMITACIÓN: .¡No están permitidos en los nombres de directorio!

Puede llenar todos estos directorios con archivos xml / images o lo que sea y agregar más directorios a lo /app/data/largo del tiempo a medida que se desarrollen las necesidades de su aplicación (con los archivos README.md para grabar en una descripción de para qué sirve cada directorio de almacenamiento exactamente).

No hay necesidad de alterar .gitignoreo descentralizar aún más creando un .gitignorenuevo directorio para cada directorio nuevo. Probablemente no sea la solución más inteligente, pero es conciso en términos de gitignore y siempre funciona para mí. Agradable y sencillo! ;)

Answer 23

A veces tengo repositorios con carpetas que solo contendrán archivos considerados como "contenido", es decir, no son archivos que me interesen en las versiones y, por lo tanto, nunca se deben confirmar. Con el archivo .gitignore de Git, puede ignorar directorios completos. Pero hay momentos en que tener la carpeta en el repositorio sería beneficioso. Aquí hay una excelente solución para lograr esta necesidad.

Lo que he hecho en el pasado es poner un archivo .gitignore en la raíz de mi repositorio, y luego excluir la carpeta, así:

/app/some-folder-to-exclude
/another-folder-to-exclude/*

Sin embargo, estas carpetas no se convierten en parte del repositorio. Usted podría agregar algo como un archivo README allí. Pero luego tienes que decirle a tu aplicación que no se preocupe por procesar ningún archivo README.

Si su aplicación depende de que las carpetas estén allí (aunque estén vacías), simplemente puede agregar un archivo .gitignore a la carpeta en cuestión y usarlo para lograr dos objetivos:

Dígale a Git que hay un archivo en la carpeta, lo que hace que Git lo agregue al repositorio. Dígale a Git que ignore el contenido de esta carpeta, menos este archivo. Aquí está el archivo .gitignore para poner dentro de sus directorios vacíos:

*
!.gitignore

La primera línea (*) le dice a Git que ignore todo en este directorio. La segunda línea le dice a Git que no ignore el archivo .gitignore. Puede rellenar este archivo en cada carpeta vacía que desee agregar al repositorio.

Answer 24

A veces tiene que lidiar con bibliotecas o software mal escritos, que necesitan un directorio "real" vacío y existente. Poner un simple .gitignoreo .keeppodría romperlos y causar un error. Lo siguiente podría ayudar en estos casos, pero no hay garantía ...

Primero crea el directorio necesario:

mkdir empty

Luego agrega un enlace simbólico roto a este directorio (pero en cualquier otro caso que no sea el de uso descrito anteriormente, use una READMEcon una explicación):

ln -s .this.directory empty/.keep

Para ignorar los archivos en este directorio, puede agregarlo a su raíz .gitignore:

echo "/empty" >> .gitignore

Para agregar el archivo ignorado, use un parámetro para forzarlo:

git add -f empty/.keep

Después de la confirmación, tiene un enlace simbólico roto en su índice y git crea el directorio. El enlace roto tiene algunas ventajas, ya que no es un archivo normal y no apunta a un archivo normal. Así que incluso se ajusta a la parte de la pregunta "(que no contiene archivos)", no por la intención, sino por el significado, supongo:

find empty -type f

Este comando muestra un resultado vacío, ya que no hay archivos presentes en este directorio. Por lo tanto, la mayoría de las aplicaciones que obtienen todos los archivos en un directorio generalmente no ven este enlace, al menos si hacen un "archivo existe" o un "es legible". Incluso algunos scripts no encontrarán ningún archivo allí:

$ php -r "var_export(glob(''empty/.*''));"
array (
  0 => ''empty/.'',
  1 => ''empty/..'',
)

Pero recomiendo encarecidamente utilizar esta solución solo en circunstancias especiales, una buena READMEsolución es escribir una buena en un directorio vacío. (Y no sé si esto funciona con un sistema de archivos de Windows ...)

Answer 25

Aquí hay un hack, pero es gracioso que funcione (Git 2.2.1). Similar a lo que sugirió @Teka, pero más fácil de recordar:

• Agregar un submódulo a cualquier repositorio ( git submodule add path_to_repo)
• Esto agregará una carpeta y un archivo .submodules. Cometer un cambio.
• Eliminar .submodulesarchivo y confirmar el cambio.

Ahora, tiene un directorio que se crea cuando se comprueba la confirmación. Sin embargo, una cosa interesante es que si observa el contenido del objeto de árbol de este archivo obtendrá:

fatal: no es un nombre de objeto válido b64338b90b4209263b50244d18278c0999867193

Sin embargo, no recomendaría que lo use, ya que puede dejar de funcionar en las futuras versiones de Git. Lo que puede dejar tu repositorio dañado.

Answer 26

Puede guardar este código como create_readme.php y ejecutar el código PHP desde el directorio raíz de su proyecto Git.

> php create_readme.php

Agregará archivos README a todos los directorios que estén vacíos, por lo que esos directorios se agregarán al índice.

<?php
    $path = realpath(''.'');
    $objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path),       RecursiveIteratorIterator::SELF_FIRST);
    foreach($objects as $name => $object){
        if ( is_dir($name) && ! is_empty_folder($name) ){
            echo "$name/n" ;
            exec("touch ".$name."/"."README");
        }
    }

    function is_empty_folder($folder) {
        $files = opendir($folder);
        while ($file = readdir($files)) {
            if ($file != ''.'' && $file != ''..'')
                return true; // Not empty
            }
        }
?>

Entonces hazlo

git commit -m "message"
git push

Answer 27

Siempre construyo una función para verificar la estructura de carpetas deseada y la compilo para mí dentro del proyecto. Esto soluciona este problema ya que las carpetas vacías se guardan en Git por proxy.

function check_page_custom_folder_structure () {
    if (!is_dir(TEMPLATEPATH."/page-customs"))
        mkdir(TEMPLATEPATH."/page-customs");    
    if (!is_dir(TEMPLATEPATH."/page-customs/css"))
        mkdir(TEMPLATEPATH."/page-customs/css");
    if (!is_dir(TEMPLATEPATH."/page-customs/js"))
        mkdir(TEMPLATEPATH."/page-customs/js");
}

Esto está en PHP, pero estoy seguro de que la mayoría de los idiomas admiten la misma funcionalidad, y como la aplicación se encarga de la creación de las carpetas, las carpetas siempre estarán allí.

Answer 28

touch .keep

En Linux, esto crea un archivo vacío llamado .keep . Este nombre se prefiere sobre .gitkeep ya que el primero es agnóstico para Git, mientras que el último es específico para Git. En segundo lugar, como lo señaló otro usuario, la convención de prefijo .git debe reservarse para los archivos y directorios que Git utiliza.

Como alternativa, como se indica en otra answer , el directorio puede contener un archivo README o README.md descriptivo en README.md lugar.

Por supuesto, esto requiere que la presencia del archivo no cause que la aplicación se rompa.