Herramienta para crear archivos de texto a partir de una plantilla.

Tengo que crear regularmente más de 100 archivos de texto a partir de plantillas.
Actualmente uso un script de shell demasiado complicado. Creo que hay una forma más inteligente de manejar esto, pero no sé cómo.

Tengo una "base de datos":

# outputfile      template            data1   data2    data3
first.txt         $template_main      $text1  abcd     1234
second.txt        $template_main      $text2  efgh     5678
third.txt         $template_other     $text1  ij       90

Y un archivo de configuración:

template_main=main.txt
template_other=other.txt
text1=whatever
text2=blah

Las plantillas son archivos de texto con marcadores de posición como %% data2 %% (el formulario de marcador de posición se puede cambiar).

¿Alguien conoce una herramienta para automatizar esto mejor que con un script de shell complicado?

Probablemente hay miles de dichos lenguajes de plantilla y software asociado. Un ejemplo popular es ERB , que es parte de Vanilla Ruby. Después de instalar Ruby, puede iniciar irbo un editor y simplemente pegar el ejemplo canónico para tener una idea:

require 'erb'

x = 42
template = ERB.new <<-EOF
  The value of x is: <%= x %>
EOF
puts template.result(binding)

También podrías considerar:

• la herramienta GNU llamada, m4que es un procesador de texto que genera el texto que desea tomar como entradas una plantilla con las partes para cambiar. Seguramente sería más simple que el script de shell. (funciona más o como un preprocesador C con #define macro IIRC).

• la herramienta GNU xsltprocque aplica una transformación y te da el resultado. La plantilla está en xml, y xsltes el formato de las cosas de transformación que debes hacer xmlpara generar texto.

Personalmente tengo preferencia por xslt, pero en su caso, aunque no encajaría con los campos en el formulario %DATA1% %DATA2%. Necesita xml, por lo que odiaría cambiar sus plantillas.

Por lo tanto, realmente debería echar un vistazo m4.

• Como otra opción, me han dicho que el Haskelllenguaje de programación es realmente bueno para transformar las transmisiones. Solo estoy considerando esta idea porque los amantes de Haskell hablan sobre el Parsecpaquete maravilloso , que permite el análisis natural de secuencias de cadenas. Mucho mejor que xslt, que ya es bueno. Solo los repito, porque estoy aprendiendo Haskell y no tengo la sola idea de cómo transformar el texto con él por ahora .

Creo que sería mejor mirar un lenguaje de scripting real, como PHP, Perl o Python, para hacer algo como esto por usted, especialmente si realmente no quiere entrar en scripts de shell complejos a gran escala.

No sé por qué haces eso, pero tienes dos plantillas aquí. Una es su 'base de datos' y la otra es su plantilla real. Ambos son fáciles de manejar con shtpl . (proyecto privado mío, por lo que no se usa mucho, pero se desarrolló para resolver realmente ese tipo de problemas)

Con shtpl harías algo como esto:

Contenido del archivo 'configuración':

template_main=main.txt
template_other=other.txt
text1=whatever
text2=blah

Contenido del archivo 'base de datos' (supuse que el delimitador es tab (\ t)):

#% . "$CONFFile"
#% if [ -z "$template_main" ] || [ -z "$template_other" ] || \
#%    [ -z "$text1" ]         || [ -z "$text2" ]; then
#%   printf "database could not be generated!\n" > /dev/stderr
#%   exit 1
#% fi
#%# outputfile  template        data1   data2   data3
first.txt       $template_main  $text1  abcd    1234
second.txt      $template_main  $text2  efgh    5678
third.txt       $template_other $text1  ij      90

Contenido de generatetemplates.sh:

#!/bin/bash

if [ ! -s "$CONFFile" ]; then
 if [ ! -s "$1" ]; then
   printf "CONFfile is not set or empty!\n"
   exit 1
 else
   export CONFFile="$1"
 fi
fi

DB="$( bash -c "$( shtpl database )" )"
if [ -z "$DB" ]; then
  printf "Database is empty! Abort.\n"
  exit 2
fi
IFS=$'\t'
printf "%s" "$DB" | while read "Out" "In" "data1" "data2" "data3"; do

  data1="$data1" data2="$data2" data3="$data3" \
  bash -c "$( shtpl "$In" )" > "$Out"

done

Contenido de main.txt (other.txt es muy parecido):

main.txt template
$data1
$data2
$data3

Entonces ejecutando generatetemplates.sh

$ bash generatetemplates.sh "./configuration"

nos genera first.txt, second.txt y third.txt.

$ cat first.txt    | $ cat second.txt   | $ cat third.txt
main.txt template  | main.txt template  | other.txt template
whatever           | blah               | whatever
abcd               | efgh               | ij
1234               | 5678               | 90

Pequeña explicación: en generatetemplates.sh se encuentra primero la 'base de datos' necesaria generada a partir de su archivo de configuración. Y en segundo lugar, para cada tupel en la base de datos, finalmente, el correspondiente Out-file de su In-template.

Nota: Un problema de datos vacíos [123] es leído. Por lo tanto, no es posible con este enfoque.

Entonces, espero que esto sea lo suficientemente simple para sus necesidades.

¡Que te diviertas!

Recientemente publiqué un proyecto de código abierto que logra eso usando una sintaxis de plantilla similar a un jinja. Se llama cookie . Aquí hay una demostración:

Salida tcat.sh . Digamos que tiene un archivo de plantilla:

hello ${name}

entonces

$ export name=world # or load and export from a properties file.
$ ./tcat.sh template-file

Salida:

hello world