Excluir diretórios contendo apenas arquivos .directory

Você mencionou find -empty, então seu findprovavelmente é GNU find. Nesta resposta, usarei vários recursos não portáteis do GNU find.

Por favor, teste minha solução em um diretório expensable primeiro. A solução é:

find . -type d \( -empty -delete -o -exec sh -c '
   special=".directory"
   test -f "$1/$special" \
   && find "$1" -mindepth 1 -maxdepth 1 ! -name "$special" | { ! grep -q .; } \
   && rm "$1/$special"
' find-sh {} \; -delete \) -print

Funciona assim:

• Porque -deleteimplica -depth, o comando processará um diretório somente após processar tudo nele. Isso é bom, pois queremos que ele processe e possivelmente exclua subdiretórios mais profundos primeiro, então quando ele chegar a um pai, há uma chance de que ele tenha ficado vazio ou quase vazio.

• O comando atua em arquivos do tipo diretório ( -type d).

• Se o diretório atualmente considerado estiver vazio, o comando tenta excluí-lo ( -empty -delete).

• Caso contrário (ou seja, se o diretório não estiver vazio), um trecho de código shell é executado. Francamente, ele será executado também se o diretório estiver vazio e a exclusão falhar; mas, neste caso, o trecho deve ser inofensivo, então está tudo bem.

  O código shell usa &&, então cada próximo passo é executado se e somente se seu passo precedente for bem-sucedido. Os passos são:

  • Teste se há um arquivo regular com nosso nome "especial" lá ( test -f …).
  • Comece a encontrar arquivos diretamente no diretório ( -mindepth 1 -maxdepth 1) com nomes diferentes do nome "especial". Se a saída do inner findestiver vazia, então grep -q .sairá com status de saída diferente de zero, então ! grep …nos dará um sucesso…
  • E então rmserá executado para remover o arquivo "especial".

  Somente se isso rmfor bem-sucedido, o -execteste será considerado verdadeiro para o diretório e o último -deleteserá tentado.

• -printimprimirá os nomes dos caminhos dos diretórios para os quais -delete(o primeiro ou o segundo) foram bem-sucedidos.

Notas:

• Nos meus testes -deletenão apagou .nem quando estava vazio, embora tenha conseguido formalmente.
• -namepega um padrão. Em geral, se o nome "especial" contiver *, ?ou [então você precisa ajustar o código. .directoryé seguro nesse assunto.

Dada a complexidade de algumas das respostas, eu diria que Perl ou Python são as ferramentas certas para percorrer uma árvore de diretórios, obter uma lista de entradas de diretório e verificar se ela é exatamente igual a uma lista de 1 elemento contendo .directory(e se é um arquivo regular).

Ter findum comando complexo fork/exec sh -cpara cada subdiretório parece um desperdício, e meus olhos estão vidrados tentando seguir a lógica na resposta de Kamil. Supondo que uma listagem de diretório recursiva de toda a árvore caberá facilmente na RAM do seu sistema, ferramentas simples são o caminho a seguir.

Perl temFile::Find que recursivamente depth-first, o que é bom, mas ele quer chamar sua função de retorno de chamada em cada entrada de diretório. Então, se você quisesse uma listagem de diretório, você teria que fazer isso sozinho em cima disso. Não é um showstopper, mas não é o ideal, então eu olhei para Python.

A função de biblioteca padrão do Python directory walk é os.walk, que é a respiração primeiro. Mas, curiosamente, ela produz um iterador de root, dirs, files( exemplo de uso que copiei ), onde os dois últimos são listas do conteúdo do diretório root, divididos em arquivos de diretório e não diretório. É exatamente isso que queremos; ou seria em uma busca em profundidade primeiro.

Para seu caso de uso, provavelmente não há problema em remover o .directoryarquivo em um diretório contendo apenas outros diretórios? Se sim, podemos fazer isso com Python, então use find -depth -type d -empty -delete (ou -print -deletepara ver quais diretórios mataremos).

#!/usr/bin/python

import os
import sys

if (len(sys.argv) != 2):
    print ("usage: dir-remove path")
    exit(1)       # not really needed; sys[1] errors on its own if there aren't enough args, and I haven't implemented looping over multiple args.  But make sure 

for root, dirs, files in os.walk(sys.argv[1]):
    print (root, dirs, files)
    if (files == [".directory"]):
        # only one non-directory file and it's called .directory
        print("os.unlink " + os.path.join(root, ".directory") )       # debug
        #os.unlink (os.path.join(root, ".directory") )                  # for real

Configuração de teste:

$ mkdir -p foo/bar/baz
$ touch foo/bar/baz/.directory  foo/bar/.directory  foo/{a.txt,.directory}
$ find foo -exec ls -dn {} +
drwxr-xr-x 3 1000 1000 100 Dec  7 00:35 foo
-rw-r--r-- 1 1000 1000   0 Dec  7 00:05 foo/a.txt
drwxr-xr-x 3 1000 1000  80 Dec  7 00:35 foo/bar
drwxr-xr-x 2 1000 1000  60 Dec  7 00:35 foo/bar/baz
-rw-r--r-- 1 1000 1000   0 Dec  7 00:35 foo/bar/baz/.directory
-rw-r--r-- 1 1000 1000   0 Dec  7 00:35 foo/bar/.directory
-rw-r--r-- 1 1000 1000   0 Dec  7 00:05 foo/.directory

uso, versão de depuração-impressão:

./dir-remove.py /tmp/foo
/tmp/foo ['bar'] ['a.txt', '.directory']
/tmp/foo/bar ['baz'] ['.directory']
os.unlink /tmp/foo/bar/.directory
/tmp/foo/bar/baz [] ['.directory']
os.unlink /tmp/foo/bar/baz/.directory

Uso, para valer: execute o script Python para remover .directoryarquivos, depois find ... -deletepara remover diretórios vazios depth-first. Eu poderia ter tido Python exec finddepois do loop se quisesse construir uma solução mais reutilizável.

$ ./dir-remove.py foo   # with both prints commented, os.unlink uncommented
$ find foo
foo/a.txt
foo/.directory
foo/bar
foo/bar/baz

$ find foo -depth -type d -empty -print -delete
foo/bar/baz
foo/bar

Tudo o que resta é foo/a.txte foo/.directory(e o diretório fooem si, é claro).

Limitação: foo/bar/.directoryteria sido removido mesmo se foo/bar/baznão estivesse vazio e não acabou sendo removido. Não vejo uma solução trivial para isso sem fazer minha própria busca em profundidade em Python, ou voltar para Perl e usar its File::Finde fazer uma listagem de diretórios eu mesmo.

Eu só sei um pouco de Python, mas mesmo assim foi muito fácil fazer isso, e estou contando com bibliotecas padrão para o trabalho pesado, então espero que seja robusto.

Não tenho certeza se entendi completamente o que você está dizendo, mas isso faz o que você está perguntando?

$ find tmp
tmp/
tmp/a
tmp/1
tmp/1/2
tmp/1/2/.directory
tmp/1/2/c
tmp/1/2/3
tmp/1/2/3/.directory
tmp/1/2/3/d
tmp/1/b

Então execute:

$ find -depth -empty -name .directory -exec rm -vrf {} \;
removed directory './tmp/1/2/.directory'
removed directory './tmp/1/2/3/.directory'

O que então produzirá:

$ find tmp/
tmp/
tmp/a
tmp/1
tmp/1/2
tmp/1/2/c
tmp/1/2/3
tmp/1/2/3/d
tmp/1/b