Ferramenta para criar arquivos de texto a partir de um modelo

Eu tenho que criar regularmente mais de 100 arquivos de texto a partir de modelos.
Atualmente, uso um shell script excessivamente complicado. Eu acho que existe uma maneira mais inteligente de lidar com isso, mas não sei como.

Eu tenho um "banco de dados":

# 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

E um arquivo de configuração:

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

Os modelos são arquivos de texto com espaços reservados como %% data2 %% (o formulário do espaço reservado pode ser alterado).

Alguém conhece uma ferramenta para automatizar isso melhor do que com um script de shell complicado?

Provavelmente existem milhares dessas linguagens de modelos e software associado. Um exemplo popular é o ERB , que faz parte do Ruby de baunilha. Depois de instalar o Ruby, você pode iniciar irbum editor ou simplesmente colar o exemplo canônico para ter uma ideia:

require 'erb'

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

Você também pode considerar:

• a ferramenta GNU chamada, m4que é um processador de texto que gera o texto que você deseja que seja inserido como um modelo com as partes a serem alteradas. Certamente seria mais simples que o shell script. (funciona mais ou como um pré-processador C com #define macro IIRC).

• a ferramenta GNU xsltprocque aplica uma transformação e fornece a saída. O modelo está dentro xml, e xslté o formato das coisas de transformação a serem feitas, de xmlmodo a gerar texto.

Pessoalmente, eu tenho uma preferência por xslt, mas no seu caso, embora não caiba nos campos do formulário %DATA1% %DATA2%. Ele precisa de xml, então você detestaria alterar seus modelos.

Assim, você realmente deve dar uma olhada m4.

• Como outra opção, me disseram que a Haskelllinguagem de programação é realmente muito boa em transformar fluxos. Estou apenas considerando essa idéia porque os amantes de Haskell falam sobre o maravilhoso Parsecpacote, que permite a análise natural dos fluxos de strings. Muito melhor que o xslt, que já é bom. Eu apenas os repito, porque estou apenas aprendendo Haskell e não tenho a única idéia de como transformar texto com ele por enquanto .

Eu acho que seria melhor procurar uma linguagem de script real, como PHP, Perl ou Python, para fazer algo assim por você, especialmente se você realmente não quiser entrar em scripts de shell complexos em larga escala.

Não sei por que você faz isso, mas você tem dois modelos aqui. Um é o seu 'banco de dados' e o outro é o seu modelo real. Ambos são fáceis de manusear com shtpl . (projeto particular meu, que não é amplamente utilizado, mas foi desenvolvido para resolver esse tipo de problema)

Com o shtpl, você faria algo assim:

Conteúdo do arquivo 'configuração':

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

Conteúdo do arquivo 'database' (presumi que o delimitador seja 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

Conteúdo 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

O conteúdo do main.txt (other.txt é o mesmo):

main.txt template
$data1
$data2
$data3

Então, executando generatetemplates.sh

$ bash generatetemplates.sh "./configuration"

nos gera first.txt, second.txt e 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

Pouca explicação: em generatetemplates.sh é primeiro o 'banco de dados' necessário gerado a partir do seu arquivo de configuração. E, em segundo lugar, para cada tupel no banco de dados, finalmente o arquivo de saída correspondente do seu In-template.

Nota: Um problema de dados [123] vazios é lido. Portanto, não é possível com essa abordagem.

Portanto, espero que isso seja simples o suficiente para suas necessidades.

Diverta-se!

Publiquei recentemente um projeto de código aberto que realiza exatamente isso usando uma sintaxe de modelo semelhante a um jinja. Chama-se cookie . Aqui está uma demonstração:

Confira tcat.sh . Digamos que você tenha um arquivo de modelo:

hello ${name}

então

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

Resultado:

hello world