Strumento per creare file di testo da un modello

Devo creare regolarmente oltre 100 file di testo dai modelli.
Attualmente uso uno script di shell eccessivamente complicato. Penso che ci sia un modo più intelligente di gestirlo, ma non so come.

Ho un "database":

# 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 un file di configurazione:

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

I modelli sono file di testo con segnaposto come %% data2 %% (il modulo segnaposto può essere modificato).

Qualcuno conosce uno strumento per automatizzare questo meglio che con uno script di shell complicato?

Probabilmente ci sono migliaia di tali linguaggi modello e software associato. Un esempio popolare è ERB , che fa parte del rubino alla vaniglia. Dopo aver installato Ruby puoi avviare irbo un editor e semplicemente incollare l'esempio canonico per avere un'idea:

require 'erb'

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

Puoi anche considerare:

• lo strumento GNU chiamato m4che è un elaboratore di testi che emette il testo che vuoi prendere come input un modello con le parti da cambiare. Sarebbe sicuramente più semplice della shell script. (funziona di più o come un preprocessore C con #define macro IIRC).

• lo strumento GNU xsltprocche applica una trasformazione e ti dà l'output. Il modello è in xml, ed xsltè il formato delle cose di trasformazione da fare al xmlfine di generare testo.

Personalmente preferisco xslt, ma nel tuo caso non si adatterebbe ai campi nel modulo %DATA1% %DATA2%. Ha bisogno di xml, quindi odierei cambiare i tuoi modelli.

Quindi dovresti davvero dare un'occhiata m4.

• Come altra scelta, mi è stato detto che il Haskelllinguaggio di programmazione è davvero bravo a trasformare i flussi. Sto solo prendendo in considerazione questa idea perché gli amanti di Haskell parlano del meraviglioso Parsecpacchetto, che consente l'analisi naturale dei flussi di stringhe. Molto meglio di xslt, che è già buono. Li ripeto solo perché sto solo imparando Haskell, e non ho la sola idea di come trasformare il testo con esso per ora .

Penso che sarebbe meglio guardare un vero linguaggio di scripting, come PHP, Perl o Python, per fare qualcosa del genere per te, specialmente se davvero non vuoi entrare in script shell complessi su larga scala.

Non so perché lo fai, ma hai due modelli qui. Uno è il tuo "database" e uno è il tuo modello reale. Entrambi sono facili da maneggiare con shtpl . (mio progetto privato, quindi non ampiamente utilizzato, ma sviluppato per risolvere effettivamente quel tipo di problemi)

Con shtpl faresti qualcosa del genere:

Contenuto del file 'configurazione':

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

Contenuto del file "database" (ho ipotizzato che il delimitatore sia 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

Contenuto di 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

Contenuto di main.txt (other.txt è abbastanza lo stesso):

main.txt template
$data1
$data2
$data3

Quindi eseguendo generatetemplates.sh

$ bash generatetemplates.sh "./configuration"

ci genera 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

Piccola spiegazione: in generatetemplates.sh è innanzitutto il "database" necessario generato dal tuo file di configurazione. E in secondo luogo per ogni tupel nel database, infine, il corrispondente file Out dal tuo modello In.

Nota: lettura di dati vuoti [123]. Quindi non è possibile con questo approccio.

Quindi, spero che questo sia abbastanza semplice per le tue esigenze.

Divertiti!

Di recente ho pubblicato un progetto open source che realizza proprio questo usando una sintassi di modello simile a jinja. Si chiama cookie . Ecco una demo:

Scopri tcat.sh . Supponi di avere un file modello:

hello ${name}

poi

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

Produzione:

hello world