¿Los comodines recursivos en GNU hacen?

Ha pasado un tiempo desde que lo he usado make, así que tengan paciencia conmigo ...

Tengo un directorio flac, que contiene archivos .FLAC. Tengo un directorio correspondiente que mp3contiene archivos MP3. Si un archivo FLAC es más nuevo que el archivo MP3 correspondiente (o el archivo MP3 correspondiente no existe), entonces quiero ejecutar un montón de comandos para convertir el archivo FLAC en un archivo MP3 y copiar las etiquetas.

El truco: necesito buscar en el flacdirectorio de forma recursiva y crear los subdirectorios correspondientes en el mp3directorio. Los directorios y archivos pueden tener espacios en los nombres y se nombran en UTF-8.

Y quiero usarlo makepara conducir esto.

Intentaría algo en esta línea

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 "$@"

Un par de notas rápidas para makeprincipiantes:

• El @frente de los comandos evita que se makeimprima el comando antes de ejecutarlo.
• $(@D)es la parte del directorio del nombre del archivo de destino ( $@)
• Asegúrese de que las líneas con comandos de shell comiencen con una pestaña, no con espacios.

Incluso si esto debería manejar todos los caracteres UTF-8 y demás, fallará en los espacios en los nombres de archivos o directorios, ya que makeusa espacios para separar cosas en los archivos MAKE y no conozco una forma de evitar eso. Entonces eso te deja con solo un script de shell, me temo: - /

Puede definir su propia función comodín recursiva como esta:

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

El primer parámetro ( $1) es una lista de directorios y el segundo ( $2) es una lista de patrones que desea hacer coincidir.

Ejemplos:

Para encontrar todos los archivos C en el directorio actual:

$(call rwildcard,.,*.c)

Para encontrar todos los archivos .cy .hen src:

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

Esta función se basa en la implementación de este artículo , con algunas mejoras.

FWIW, he usado algo como esto en un Makefile :

RECURSIVE_MANIFEST = `find . -type f -print`

El ejemplo anterior buscará en el directorio actual ( '.' ) Todos los "archivos sin formato" ( '-type f' ) y establecerá la RECURSIVE_MANIFESTvariable make para cada archivo que encuentre. A continuación, puede utilizar sustituciones de patrones para reducir esta lista o, alternativamente, proporcionar más argumentos en find para reducir lo que devuelve. Consulte la página de manual para encontrar .

Mi solución se basa en la anterior, usa en sedlugar de patsubstdestrozar la salida de findY escapar de los espacios.

Pasando de flac / a ogg /

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

Advertencias:

1. Todavía barfs si hay punto y coma en el nombre del archivo, pero son bastante raros.
2. El truco $ (@ D) no funcionará (genera galimatías), ¡pero oggenc crea directorios para usted!

Aquí hay un script de Python que pirateé rápidamente para resolver el problema original: mantener una copia comprimida de una biblioteca de música. El script convertirá archivos .m4a (se supone que son ALAC) al formato AAC, a menos que el archivo AAC ya exista y sea más reciente que el archivo ALAC. Los archivos MP3 de la biblioteca se vincularán, ya que ya están comprimidos.

Solo tenga cuidado de que abortar el script (ctrl-c ) dejará un archivo a medio convertir.

Originalmente también quería escribir un Makefile para manejar esto, pero dado que no puede manejar espacios en los nombres de archivo (ver la respuesta aceptada) y porque escribir un script bash está garantizado para ponerme en un mundo de dolor, Python lo es. Es bastante sencillo y corto, por lo que debería ser fácil de ajustar a sus necesidades.

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])

Por supuesto, esto se puede mejorar para realizar la codificación en paralelo. Eso se deja como ejercicio para el lector ;-)

Si está usando Bash 4.x, puede usar una nueva opción de globbing , por ejemplo:

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

Este tipo de comodín recursivo puede encontrar todos los archivos de su interés ( .flac , .mp3 o lo que sea). O