Variables y Plantillas

Los Rulebooks pueden hacer uso de un sistema de reemplazo de variables y plantillas basado en ClaJS, un intérprete JavaScript muy rápido que viene incluido con Clarive.

• ${myvar} - análisis simple de variables
• {{ myvar }} - análisis de variables JavaScript

Sus reglas pueden usar cualquiera de los dos en el código.

Definir variables en una regla

Para definir variables en una regla, escríbalas en la sección vars al principio del rulebook.

vars:
   - logfile: /tmp/mylogfile.log
do:
   - $ echo "what an error" > {{logfile}}

vars:
   - logdir: /tmp
   - logfile: "{{logdir}}/mylogfile.log"
do:
   - $ echo "what an error" > {{logfile}}

vars es un array de definiciones de variables.

Establecer variables con var

Opcionalmente, las vars pueden definirse a medida que avanza en su código de regla.

do:
   - var:
       foo: world
   - echo: hello {{ foo }}

Para asignar valores que van más allá de una sola línea, use cadenas multilínea de YAML con el operador pipe.

vars:
   - mytext: |
        this is
        a very long value
do:
   - write_file:
        body: "{{ mytext }}"
        file: /tmp/myfile.txt

Establecimiento en línea con =

Hay una notación corta muy conveniente para establecer variables usando el operador igual =.

do:
   - cmd =: npm
   - package =: yaml
   - ${cmd} install ${package}

El operador igual puede usarse con cualquier cosa que devuelva un valor, como un op definido con def o un comando shell.

def:
   package_list:
      - return:
           - haml
           - sass
do:
   - packages = package_list:
   - foreach:
        var: pkg
        in: ${packages}
        do:
           - gem install ${pkg} --install-dir /tmp/gems

Los resultados de comandos shell también pueden asignarse a variables, pero debe haber un signo de dólar $ adicional prefijado al comando. Esto es para que el analizador del rulebook pueda diferenciar correctamente entre variables de regla y variables de shell. Si el comando falla al ser asignado a una variable, el error no se lanza y en su lugar se devuelve a la variable.

do:
   - results = shell: ls /tmp/
   - foreach:
        var: line
        in: "{{ results.output.split('\\n') }}"
        do:
           - echo: LINE=${line}

Establecer variables con el op set

Puede usar el op set para establecer variables. La diferencia con otros métodos de establecimiento de variables es que set le permite hacer que el nombre de la variable en sí sea variable.

do:
   - set:
        var: package
        value: react
   - echo: "Ready to install ${package}..."
   - npm install ${package}

Escapar variables para que no se analicen

En caso de que desee evitar que el analizador de cadenas analice una variable en una cadena:

do:
   - write_file:
       file: subdir/foobar.txt
       body: "this is dollar-pie: $${pie}" # "this is dollar-pie ${pie}"

   # o digamos que quiere usar variables bash en un shell:

   - |
       MYVAR=/tmp
       ls $${MYVAR}

Importar variables desde un archivo

No tiene que mantener todas sus vars en un archivo .clarive.yml. Pueden almacenarse por separado en archivos de variables y cargarse en la regla usando el op parse.

# .clarive/myvars.yml
foo: bar
logdir: /var/logs
logfile: "{{ logdir }}/mylog.log"

Luego cargue el archivo con parse y asígnelo a la variable myvars:

do:
   - myvars = parse:
       file: .clarive/myvars.yml
   - echo: imported {{ myvars.foo }}

Tenga en cuenta que YAML interpreta lo siguiente:

var:
   foo: {{ myvar }}

Como la asignación de un hash mal definido { ... } a la variable foo. Tiene que poner comillas alrededor de los handlebars, o usar una cadena multilínea | para que el analizador YAML lo trate como válido.

Configurar variables de proyecto, entorno o globales

Si desea mantener variables de proyecto o globales en la base de datos en lugar de en sus archivos de proyecto, use la interfaz de usuario de variables de rulebook

Este método es ideal para almacenar claves secretas.

Las variables guardadas en la base de datos de Clarive con la interfaz de usuario de Variables pueden accederse a través de las funciones ctx.var(varname).

Clarive detectará el contexto desde el que se está llamando a la función ctx.var() e intentará encontrar una variable que coincida. De lo contrario, se devuelve una cadena en blanco.