Ferramenta para criar arquivos de texto a partir de um modelo

Question

Eu tenho que criar regularmente mais de 100 arquivos de texto a partir de modelos.
Eu atualmente uso um script de shell excessivamente complicado. Eu acho que há uma maneira mais inteligente de lidar com isso, mas eu 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 de espaço reservado pode ser alterado).

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

    

Answer 1

Você também pode considerar:

• a ferramenta GNU chamada m4 , que é um processador de texto que gera o texto que você deseja, tomando como entrada 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 xsltproc que aplica uma transformação e fornece a saída. O modelo está em xml e xslt é o formato das coisas da transformação a serem feitas no seu xml , de modo a gerar o texto.

Pessoalmente, tenho uma preferência por xslt , mas no seu caso, embora não se encaixasse nos campos no formulário %DATA1% %DATA2% . Ele precisa de xml, então você odiaria mudar seus modelos.

Assim, você deve dar uma olhada em m4 .

• Como outra escolha, me disseram que a linguagem de programação Haskell é muito boa em transformar fluxos. Eu só estou considerando essa idéia porque os amantes do Haskell falam sobre o maravilhoso pacote Parsec , que permite a análise natural de streams de strings. Muito melhor que xslt, o que já é bom. Eu apenas os repito, porque estou apenas aprendendo Haskell, e não tenho a única ideia de como transformar o texto com ele por enquanto .

Answer 2

Existem provavelmente milhares dessas linguagens de modelo e software associado. Um exemplo popular é o ERB , que faz parte do vanilla Ruby. Depois de instalar o Ruby, você pode iniciar irb ou um editor e 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)

    

Answer 3

Eu acho que seria melhor você olhar para uma linguagem de script real, como PHP, Perl ou Python, para fazer algo assim para você, especialmente se você realmente não quer entrar em um shell complexo de grande escala. scripts.

    

Answer 4

Eu não sei porque você faz isso, mas você tem dois modelos aqui. Um é o seu 'banco de dados' e um é o seu modelo real. Ambos são fáceis de manusear com o shtpl . (meu projeto privado, portanto, não é amplamente usado, mas foi desenvolvido para resolver realmente 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' (eu assumi que o delimitador é 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

Conteúdo do main.txt (outro.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

Pequena 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 Out correspondente do seu In-template.

Nota: problemas de dados vazios [123] são lidos. Por isso, não é possível com essa abordagem.

Então, espere que isso seja simples o suficiente para as suas necessidades.

Divirta-se!

    

Answer 5

Eu publiquei recentemente um projeto de código aberto que realiza apenas isso usando uma sintaxe de modelo semelhante a jinja. É chamado de cookie . Aqui está uma demonstração: