Caracteres curinga recursivos no GNU make?

Já faz um tempo desde que eu uso make, então tenha paciência comigo ...

Eu tenho um diretório flac,, contendo arquivos .FLAC. Eu tenho um diretório correspondente, mp3contendo arquivos MP3. Se um arquivo FLAC for mais recente que o arquivo MP3 correspondente (ou o arquivo MP3 correspondente não existir), quero executar vários comandos para converter o arquivo FLAC em MP3 e copiar as tags.

O kicker: eu preciso pesquisar o flacdiretório recursivamente e criar subdiretórios correspondentes no mp3diretório. Os diretórios e arquivos podem ter espaços nos nomes e são nomeados em UTF-8.

E eu quero usar makepara dirigir isso.

Eu tentaria algo nesse sentido

FLAC_FILES = $(shell find flac/ -type f -name '*.flac')
MP3_FILES = $(patsubst flac/%.flac, mp3/%.mp3, $(FLAC_FILES))

.PHONY: all
all: $(MP3_FILES)

mp3/%.mp3: flac/%.flac
    @mkdir -p "$(@D)"
    @echo convert "$<" to "$@"

Algumas notas rápidas para makeiniciantes:

• O @na frente dos comandos impede a makeimpressão do comando antes de realmente executá-lo.
• $(@D)é a parte do diretório do nome do arquivo de destino ( $@)
• Certifique-se de que as linhas com comandos shell começam com uma tabulação, não com espaços.

Mesmo que isso deva lidar com todos os caracteres UTF-8 e outras coisas, ele falhará em espaços nos nomes de arquivo ou diretório, pois makeusa espaços para separar coisas nos makefiles e não estou ciente de uma maneira de contornar isso. Então isso deixa você com apenas um script de shell, infelizmente: - /

Você pode definir sua própria função curinga recursiva assim:

rwildcard=$(foreach d,$(wildcard $(1:=/*)),$(call rwildcard,$d,$2) $(filter $(subst *,%,$2),$d))

O primeiro parâmetro ( $1) é uma lista de diretórios e o segundo ( $2) é uma lista de padrões que você deseja corresponder.

Exemplos:

Para encontrar todos os arquivos C no diretório atual:

$(call rwildcard,.,*.c)

Para encontrar todas as .ce .harquivos em src:

$(call rwildcard,src,*.c *.h)

Esta função é baseada na implementação deste artigo , com algumas melhorias.

FWIW, usei algo assim em um Makefile :

RECURSIVE_MANIFEST = `find . -type f -print`

O exemplo acima irá pesquisar no diretório atual ( '.' ) Por todos os "arquivos simples" ( '-tipo f' ) e definir a RECURSIVE_MANIFESTvariável make para cada arquivo que encontrar. Você pode então usar substituições de padrão para reduzir essa lista ou, alternativamente, fornecer mais argumentos em find para restringir o que ela retorna. Veja a página do manual para encontrar .

Minha solução é baseada na acima, usa ao sedinvés de patsubstmangle a saída de findAND escapar dos espaços.

Indo de flac / para ogg /

OGGS = $(shell find flac -type f -name "*.flac" | sed 's/ /\\ /g;s/flac\//ogg\//;s/\.flac/\.ogg/' )

Ressalvas:

1. Ainda barfs se houver ponto e vírgula no nome do arquivo, mas eles são muito raros.
2. O truque $ (@ D) não funcionará (gera gibberish), mas oggenc cria diretórios para você!

Aqui está um script Python que eu criei rapidamente para resolver o problema original: mantenha uma cópia compactada de uma biblioteca de música. O script converterá os arquivos .m4a (supostamente do ALAC) para o formato AAC, a menos que o arquivo AAC já exista e seja mais recente que o arquivo ALAC. Os arquivos MP3 na biblioteca serão vinculados, uma vez que já estão compactados.

Apenas tome cuidado, pois abortar o script ( ctrl-c) deixará um arquivo convertido pela metade.

Originalmente, eu também queria escrever um Makefile para lidar com isso, mas como ele não pode lidar com espaços em nomes de arquivos (veja a resposta aceita) e porque escrever um script bash certamente me colocará em um mundo de dor, Python é. É bastante simples e curto e, portanto, deve ser fácil de ajustar às suas necessidades.

from __future__ import print_function


import glob
import os
import subprocess


UNCOMPRESSED_DIR = 'Music'
COMPRESSED = 'compressed_'

UNCOMPRESSED_EXTS = ('m4a', )   # files to convert to lossy format
LINK_EXTS = ('mp3', )           # files to link instead of convert


for root, dirs, files in os.walk(UNCOMPRESSED_DIR):
    out_root = COMPRESSED + root
    if not os.path.exists(out_root):
        os.mkdir(out_root)
    for file in files:
        file_path = os.path.join(root, file)
        file_root, ext = os.path.splitext(file_path)
        if ext[1:] in LINK_EXTS:
            if not os.path.exists(COMPRESSED + file_path):
                print('Linking {}'.format(file_path))
                link_source = os.path.relpath(file_path, out_root)
                os.symlink(link_source, COMPRESSED + file_path)
            continue
        if ext[1:] not in UNCOMPRESSED_EXTS:
            print('Skipping {}'.format(file_path))
            continue
        out_file_path = COMPRESSED + file_path
        if (os.path.exists(out_file_path)
            and os.path.getctime(out_file_path) > os.path.getctime(file_path)):
            print('Up to date: {}'.format(file_path))
            continue
        print('Converting {}'.format(file_path))
        subprocess.call(['ffmpeg', '-y', '-i', file_path,
                         '-c:a', 'libfdk_aac', '-vbr', '4',
                         out_file_path])

Claro, isso pode ser aprimorado para realizar a codificação em paralelo. Isso é deixado como um exercício para o leitor ;-)

Se você estiver usando o Bash 4.x, poderá usar uma nova opção de globbing , por exemplo:

SHELL:=/bin/bash -O globstar
list:
  @echo Flac: $(shell ls flac/**/*.flac)
  @echo MP3: $(shell ls mp3/**/*.mp3)

Este tipo de curinga recursivo pode localizar todos os arquivos de seu interesse ( .flac , .mp3 ou qualquer outro). O