# Factory-Engine C'est un moteur de template, rien de plus normal :) ## Utiliser la syntaxe (Syntaxe) Factory fonctionne avec des blocks de commandes qui lui sont propres. Ces blocks sont définit via `<<` et `>>` et le code factory se trouvera entre ces flèches. ### Types de données `ovar` est une variable propre au fichier ou à ses parents
`ivar` est une variable d'un fichier enfant
`file` est le contenu du fichier donné
`req` est une requête à votre base de donnée
`block` est un morceau de code autre que Factory, mais celui-ci, peut, bien-sûr, contenir une intégration Factory via les blocks de commande ou les variables
`id` est un identifiant définit par l'utilisateur en JavaScript **Ils sont utilisés comme suit** `ovar:le_nom_de_variable`
`ivar:le_nom_de_variable`
`file:'le/chemin/vers/le/fichier'` *Précision : `./` est égal à la racine du projet, soit, le dossier dans lequel le fichier principal a été lancé.*
`req:'la_requête'` et le dernier : ```fc block:{ Le code, ici } ``` **Commandes Factory**
Certains d'entre eux peuvent avoir des identifiants
Ceux-ci sont utilisés pour définir un contenu à modifié pendant l'exécution de Factory.
Les identifiants sont défini comme suit : `$` + un entier. > `[$value=]INSERT (file:'path' | ovar:variable); Celle-ci est remplacée par le contenu de l'`ovar` ou du `file`. ``` INSERT datatype; ``` Avec un identifiant, seulement `file` peut être utilisé, où le fichier sera modifié avant de remplacer la commande par son nouveau contenu. ```fc $1 = INSERT file:'le/fichier'; ``` > `SET [$value::]variable BY (file:'path'; | block:{ } | ovar:variable;)` Celle-ci permet de remplacer une `ovar` ou une `ivar` par un autre contenu.
Trois types de données autorisés : `file`, `block` et `ovar`.
*`block` n'autorise pas de terminer par un point-virgule !* ```fc SET variable BY datatype; ``` Avec un identifiant associé, la variable du contenu désigné par l'identifiant pourr être remplacé par le nouveau contenu. ```fc SET $1::variable BY datatype; ``` > `IF(variable (== | !=) comparison); BREAK;` ***INSTABLE***
Celui-ci, permet simplement de vérifier une comparaison entre une variable `ovar` et un contenu pour exécuter ou pas le code Factory entre le mot clé `IF` et le `BREAK`.
2 types de comparaison : `==` (une égalité) et `!=` (une inégalité) ```fc IF(variable == comparison); <- Votre code -#> BREAK; ``` Où `comparison` est soit une string, un decimal, un entier, un booléen ou d'une valeur *`null`*. > `EXECUTE( (req | file | id):'content' ) [WITH (file:'path'; | block:{ })]` Celui-ci permet de soit dump le résultat (de type array\) de la ou les requêtes, ou d'itérer le résultat sur un fichier ou un block de code.
3 types sont acceptés : `req`, `file` et `id` ```fc EXECUTE(datatype); ``` Ainsi, pour l'itération : ```fc EXECUTE(datatype) WITH datatype2; ``` `datatype2` omet deux possibilités : `file` ou `block`. ## Utilisation en JavaScript ```bat npm i factory-engine ``` ```js const factory = require("factory-engine"); ``` Dès son import, 3 fonctions sont disponibles : - parse - parseFile - onDBRequest (à redéfinir) ### parse Permet de convertir un contenu Factory en un contenu HTML. > 2 arguments obligatoires > - str: un contenu, n'importe lequel, qui sera transformé si possible > - dict: les ovars insuflées dans l'interpréteur ### parseFile Permet de convertir un contenu Factory en un contenu HTML. > 2 arguments obligatoires > - str: le chemin vers le fichier selon la racine du projet > - dict: les ovars insuflées dans l'interpréteur ### onDBRequest Permet de récupérer la ou les requêtes utilisées dans le Factory (commande `EXECUTE`).
Celle-ci est à redéfinir, mais 1 argument est envoyé par Factory. > - dict: les informations de la ou les requêtes *Celle-ci oblige un return de type array\ une fois redéfinie. Ce return est le résultat de la requête.* ## Exemples Imaginons qu'une variable grlobale nommée `age` étant égale à 15. `./index.js` ```js const factory = require("factory-engine"); console.log(parseFile("./src/index.f.html", { age: 15 })); ``` *`./src/index.f.html`* ```html

{{ovar:age}}

``` Ce fichier est parsé et le résultat dans le navigateur est simplement : **Résultat** ```html

15

```
Maintenant, nous voulons passer par Factory pour passer la variable globale `age` à une `ivar`. *`./src/other.f.html`* ```html

{{ovar:integer}}

``` *`./src/index.f.html`* ```html << <# Permet de mettre le contenu de other.f.html dans l'identifiant $1 #> $1 = INSERT file:'./src/other.f.html'; <# Signifie que la variable 'integer' de l'identifiant $1 est égale à l'ovar 'age' #> SET $1::integer BY ovar:age; >> ``` **Résultat** ```html

15

```
Maintenant, nous voulons exécuter une requête et retourner le résultat `./index.js` ```js const factory = require("factory-engine"); console.log(parseFile("./src/index.f.html", {})); factory.onDBRequest = (data) => { // data.req = "SELECT * FROM ``users"; // Cette requête sera interpréter avec le module du type de base de données de votre choix return [ { "name": "Bouchetrou", "email": "bouche@gmal.com" }, { "name": "Marie", "email": "marie@domaine.com" } ]; } ``` *`./src/index.f.html`* ```html << <# Permet de dump le résultat de notre requête #> EXECUTE(req:'SELECT * FROM `users`;'); >> ``` **Résultat** ```html 
[
	{
		"name": "Bouchetrou",
		"email": "bouche@gmal.com"
	},
	{
		"name": "Marie",
		"email": "marie@domaine.com"
	}
]
``` Mais, nous voulons ordonner ces valeurs et les styliser *`./src/other.f.html`* ```html

Nom : {{ovar:name}}

Email : {{ovar:email}}
``` *`./src/index.f.html`* ```html << <# Permet d'itérer le résultat de notre requête sur le fichier other.f.html $1 #> EXECUTE(req:'SELECT * FROM `users`;') WITH file:'./src/other.f.html'; >> ``` **Résultat** ```html

Nom : Bouchetrou

Email : bouche@gmal.com

Nom : Marie

Email : marie@domaine.com
```