Templating with Linux in a Shell Shell ?

Je pourrais peut-être susciter votre intérêt pour un script supérieur à tous les autres script qui ont, jusqu'à présent, été suggérés ici.

Étant donné un modèle.txt :

Hello, {{person}}!

Veuillez exécuter :

$ person=Bob ./render template.txt

Et vous verrez le résultat

Hello, Bob!

Vous pouvez l'écrire dans un fichier en redirigeant stdout comme suit :

$ person=Bob ./render template.txt > rendered.txt

Vous pouvez également déclarer vos variables dans un fichier, puis l'utiliser comme source. Il est préférable de le faire à l'intérieur d'un script :

#!/usr/bin/env bash
source ./myvalues
./render template.txt > rendered.txt

L'avantage de ce moteur de rendu par rapport à tous les autres est qu'il ne développe pas de variables telles que $foo o ${bar} ce qui est très utile si ce que vous essayez de rendre est, lui-même, un script ! De plus, ce moteur de rendu est testé à l'unité et a reçu des demandes de la part de la communauté.

On m'a dit que je devais déclarer que j'avais écrit ce script moi-même. Je vais donc mentionner que je l'ai écrit et qu'il est disponible sur GitHub à l'adresse suivante https://github.com/relaxdiego/renderest

Quelques statistiques script si cela vous intéresse :

-------------------------
| Effective LOCs |  20  |
| Test Coverage  | 100% |
| Test LOCs      |  50  |
-------------------------

J'ai créé un Shell templating Shell également nommé shtpl (tout comme zstegi (je ne le savais pas, désolé !). Mon shtpl utilise une syntaxe de type jinja qui m'est assez familière, maintenant que j'utilise beaucoup ansible :

$ cat /tmp/test
{{ aux=4 }}
{{ myarray=( a b c d ) }}
{{ A_RANDOM=$RANDOM }}
$A_RANDOM
{% if $(( $A_RANDOM%2 )) == 0 %}
$A_RANDOM is even
{% else %}
$A_RANDOM is odd
{% endif %}
{% if $(( $A_RANDOM%2 )) == 0 %}
{% for n in 1 2 3 $aux %}
\$myarray[$((n-1))]: ${myarray[$((n-1))]}
/etc/passwd field #$n: $(grep $USER /etc/passwd | cut -d: -f$n)
{% endfor %}
{% else %}
{% for n in {1..4} %}
\$myarray[$((n-1))]: ${myarray[$((n-1))]}
/etc/group field #$n: $(grep ^$USER /etc/group | cut -d: -f$n)
{% endfor %}
{% endif %}

$ ./shtpl < /tmp/test
6535
6535 is odd
$myarray[0]: a
/etc/group field #1: myusername
$myarray[1]: b
/etc/group field #2: x
$myarray[2]: c
/etc/group field #3: 1001
$myarray[3]: d
/etc/group field #4: 

Plus d'informations sur mon github

Une solution rapide et pratique qui supporte en toute sécurité les scripts Shell.

template.sh

#!/bin/sh

EOF=EOF
exec cat <<EOF | sh
cat <<EOF
$(cat $1 | \
    sed 's|`|\\`|g' | \
    sed 's|\$|\\\$|g' | \
    sed "s|${OPEN:-<%}|\`eval echo |g" | \
    sed "s|${CLOSE:-%>}|\`|g")
$EOF
EOF

Il suffit d'exécuter la commande suivante sur le fichier que vous souhaitez modéliser.

sh template.sh file.txt.tmpl

file.txt.tmpl

uname: <% $(uname) %>
pwd: <% `pwd` %>
ls: $(ls)
df: `df`
SHELL: <% $SHELL %>
HOME: <% ${HOME} %>
USER: $USER
PATH: ${PATH}

Le résultat ressemblerait à ce qui suit.

uname: Linux
pwd: /home/clayrisser
ls: $(ls)
df: `df`
SHELL: /usr/bin/zsh
HOME: /home/clayrisser
USER: $USER
PATH: ${PATH}

Si vous souhaitez écrire le fichier modèle, redirigez simplement la sortie vers un nouveau fichier.

sh template.sh file.txt.tmpl > file.txt

Vous pouvez modifier les caractères d'ouverture et de fermeture en paramétrant OPEN y CLOSE .

file.txt.tmpl

uname: {{ $(uname) }}
pwd: {{ `pwd` }}
ls: $(ls)
df: `df`
SHELL: {{ $SHELL }}
HOME: {{ ${HOME} }}
USER: $USER
PATH: ${PATH}

OPEN="{{" CLOSE="}}" sh template.sh file.txt.tmpl