Tool zum Erstellen von Textdateien aus einer Vorlage

Ich muss regelmäßig mehr als 100 Textdateien aus Vorlagen erstellen.
Ich verwende derzeit ein übermäßig kompliziertes Shell-Skript. Ich denke, es gibt eine intelligentere Möglichkeit, damit umzugehen, aber ich weiß nicht wie.

Ich habe eine "Datenbank":

# 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

Und eine Konfigurationsdatei:

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

Die Vorlagen sind Textdateien mit Platzhaltern wie %% data2 %% (das Platzhalterformular kann geändert werden).

Kennt jemand ein Tool, um dies besser zu automatisieren als mit einem komplizierten Shell-Skript?

Es gibt wahrscheinlich Tausende solcher Vorlagensprachen und zugehöriger Software. Ein beliebtes Beispiel ist ERB , das Teil von Vanilla Ruby ist. Nach der Installation von Ruby können Sie irbeinen Editor oder einen Editor starten und einfach das kanonische Beispiel einfügen, um ein Gefühl dafür zu bekommen:

require 'erb'

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

Sie könnten auch berücksichtigen:

• Das aufgerufene GNU-Tool m4ist ein Textprozessor, der den gewünschten Text als Eingabe einer Vorlage mit den zu ändernden Teilen ausgibt. Es wäre sicherlich einfacher als Shell-Skript. (Es funktioniert mehr oder mehr wie ein C-Präprozessor mit #define macro IIRC).

• das GNU-Tool xsltproc, das eine Transformation anwendet und Ihnen die Ausgabe gibt. Die Vorlage befindet sich in xmlund xsltist das Format der Transformationsvorgänge, die Sie xmlausführen müssen, um Text auszugeben.

Persönlich habe ich eine Präferenz für xslt, aber in Ihrem Fall würde es nicht zu Feldern im Formular passen %DATA1% %DATA2%. Es braucht XML, also würden Sie es hassen, Ihre Vorlagen zu ändern.

Also solltest du dir das mal ansehen m4.

• Als weitere Wahl wurde mir gesagt, dass HaskellProgrammiersprache wirklich sehr gut darin ist, Streams zu transformieren. Ich denke nur über diese Idee nach, weil Haskell-Liebhaber über das wunderbare ParsecPaket sprechen , das das natürliche Parsen von String-Streams ermöglicht. Viel besser als xslt, was schon gut ist. Ich wiederhole sie nur, weil ich gerade Haskell lerne und ich nicht die einzige Idee habe, wie ich Text damit transformieren kann .

Ich denke, Sie sollten sich besser eine echte Skriptsprache wie PHP, Perl oder Python ansehen, um so etwas für Sie zu tun, insbesondere wenn Sie wirklich nicht in komplexe Shell-Skripte in großem Maßstab einsteigen möchten.

Ich weiß nicht, warum Sie das tun, aber Sie haben hier zwei Vorlagen. Eine ist Ihre 'Datenbank' und eine ist Ihre echte Vorlage. Beide sind mit shtpl einfach zu handhaben . (privates Projekt von mir, also nicht weit verbreitet, aber entwickelt, um tatsächlich diese Art von Problemen zu lösen)

Mit shtpl würden Sie so etwas tun:

Inhalt der Datei 'Konfiguration':

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

Inhalt der Datei 'Datenbank' (ich nahm an, dass das Trennzeichen tab (\ t) ist):

#% . "$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

Inhalt von 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

Inhalt von main.txt (other.txt ist ziemlich gleich):

main.txt template
$data1
$data2
$data3

Führen Sie also generatetemplates.sh aus

$ bash generatetemplates.sh "./configuration"

generiert uns first.txt, second.txt und 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

Kleine Erklärung: In generatetemplates.sh wird zuerst die benötigte 'Datenbank' aus Ihrer Konfigurationsdatei generiert. Und zweitens für jedes Tupel in der Datenbank schließlich die entsprechende Out-Datei aus Ihrer In-Vorlage.

Hinweis: Leere Daten [123] können nicht gelesen werden. Mit diesem Ansatz ist dies also nicht möglich.

Hoffen Sie also, dass dies für Ihre Bedürfnisse einfach genug ist.

Habe Spaß!

Ich habe kürzlich ein Open-Source-Projekt veröffentlicht, das genau das mit einer jinja-ähnlichen Vorlagensyntax erreicht. Es heißt Cookie . Hier ist eine Demo:

Schauen Sie sich tcat.sh an . Angenommen, Sie haben eine Vorlagendatei:

hello ${name}

dann

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

Ausgabe:

hello world