5htp 0.6.3 → 0.6.4

package/compiler/common/babel/plugins/injection-dependances/remplacerFonction.ts

@@ -1,226 +0,0 @@
-
-import * as types from '@babel/types'
-import generate from "@babel/generator";
-
-const servicesViaContexte: {
-    [nomService: string]: string
-} = {
-    User: 'user',
-
-    Request: 'req',
-    Response: 'res',
-    NextFunction: 'next'
-} as const
-
-const debug = false
-
-export default (t: typeof types) => {
-
-    function remplacerFonction(arg: types.ArrowFunctionExpression): null | types.ArrowFunctionExpression;
-    function remplacerFonction(arg: types.ClassMethod): null | types.ClassMethod;
-    function remplacerFonction(
-        arg: types.ArrowFunctionExpression | types.ClassMethod
-    ): null | types.ArrowFunctionExpression | types.ClassMethod {
-
-        const dejaTraite = (
-            arg.params.length === 1
-            &&
-            arg.params[0].type === 'RestElement'
-        )
-        if (dejaTraite)
-            return null;
-
-        // Return null = inchangé
-        if (arg.body.type !== 'BlockStatement')
-            return null;
-
-        let declarations: types.VariableDeclarator[] = [];
-        let instanciations: types.ExpressionStatement[] = [];
-        let extractions: types.ExpressionStatement[] = [];
-
-        // Transforme les paramètres en une liste d'instanciations
-        for (let iParam = 0; iParam < arg.params.length; iParam++) {
-            const param = arg.params[iParam];
-
-            // utilisateur: User
-            if (
-                param.type === 'Identifier' && param.typeAnnotation
-                &&
-                param.typeAnnotation.type === 'TSTypeAnnotation'
-                &&
-                param.typeAnnotation.typeAnnotation.type === 'TSTypeReference'
-                &&
-                param.typeAnnotation.typeAnnotation.typeName.type === 'Identifier'
-            ) {
-
-                const typeParam = param.typeAnnotation.typeAnnotation.typeName.name;
-                const nomParam = param.name;
-
-                // Déclaration
-                declarations.push(
-                    t.variableDeclarator(
-                        t.identifier(nomParam)
-                    )
-                );
-
-                // Instanciation (quand args[0] = contexte)
-                if (typeParam in servicesViaContexte) {
-
-                    // <nomParam> = args[ 0 ][ servicesViaContexte[ typeParam ] ];
-                    instanciations.push(
-                        t.expressionStatement(
-                            t.assignmentExpression(
-                                '=',
-                                t.identifier(nomParam),
-                                t.memberExpression(
-                                    t.memberExpression(
-                                        t.identifier('args'),
-                                        t.numericLiteral(0),
-                                        true
-                                    ),
-                                    t.identifier(servicesViaContexte[typeParam])
-                                )
-                            )
-                        )
-                    )
-
-                    // Le type du paramètre est un service reconnu
-                } else if (this.servicesImportes[typeParam] !== undefined) {
-
-                    // <nomParam> = new <typeParam>( args[0] );
-                    instanciations.push(
-                        t.expressionStatement(
-                            t.assignmentExpression(
-                                '=',
-                                t.identifier(nomParam),
-                                t.newExpression(
-                                    t.identifier(typeParam),
-                                    [
-                                        t.memberExpression(
-                                            t.identifier('args'),
-                                            t.numericLiteral(0),
-                                            true
-                                        )
-                                    ]
-                                )
-                            )
-                        )
-                    );
-
-                } else {
-                    console.log(this.servicesImportes);
-                    throw new Error(`Impossible de trouver l'import associée au type portant pour nom ${typeParam} (fichier: ${this.fichier}). Liste des iportations trouvées au dessus.`)
-                }
-
-                // Extractions
-                // <nomParam> = args[ <index> ]
-                extractions.push(
-                    t.expressionStatement(
-                        t.assignmentExpression(
-                            '=',
-                            t.identifier(nomParam),
-                            t.memberExpression(
-                                t.identifier('args'),
-                                t.identifier( iParam.toString() ),
-                                true
-                            )
-                        )
-                    )
-                );
-
-            }
-        }
-
-        // Inchangé
-        if (instanciations.length === 0)
-            return null;
-
-        const conditionSiDoitInstancier = (
-            t.logicalExpression(
-                '&&',
-                t.logicalExpression(
-                    '&&',
-
-                    // args[0] !== undefined
-                    t.binaryExpression(
-                        '!==',
-                        t.memberExpression(
-                            t.identifier('args'),
-                            t.numericLiteral(0),
-                            true
-                        ),
-                        t.identifier('undefined')
-                    ),
-
-                    // typeof args[0] === 'object'
-                    t.binaryExpression(
-                        '===',
-                        t.unaryExpression(
-                            'typeof',
-                            t.memberExpression(
-                                t.identifier('args'),
-                                t.identifier('0'),
-                                true
-                            )
-                        ),
-                        t.stringLiteral('object')
-                    )
-                ),
-
-                // args[0].type === 'contexte_requete'
-                t.binaryExpression(
-                    '===',
-                    t.memberExpression(
-                        t.memberExpression(
-                            t.identifier('args'),
-                            t.identifier('0'),
-                            true
-                        ),
-                        t.identifier('type')
-                    ),
-                    t.stringLiteral('contexte_requete')
-                )
-            )
-        )
-
-        const body = t.blockStatement([
-            t.variableDeclaration('let', declarations),
-
-            // if (args[0] !== undefined && typeof args[0] === 'object' && args[0].type === 'contexte_requete')
-            t.ifStatement(
-                conditionSiDoitInstancier,
-
-                t.blockStatement(instanciations),
-
-                t.blockStatement(extractions)
-            ),
-            ...arg.body.body
-        ]);
-
-        // Remplacement paramètres et ajout des instanciations
-        const remplacement = arg.type === 'ArrowFunctionExpression'
-            ? t.arrowFunctionExpression(
-                [t.restElement( t.identifier('args') )],
-                body,
-                arg.async
-            )
-            : t.classMethod(
-                'constructor',
-                t.identifier('constructor'),
-                [t.restElement( t.identifier('args') )],
-                body
-            )
-
-        if (debug) {
-            console.log('-----------------------------');
-            console.log(generate(arg).code);
-            console.log('=>');
-            console.log(generate(remplacement).code);
-            console.log('-----------------------------');
-        }
-
-        return remplacement;
-    }
-
-    return remplacerFonction;
-}

package/compiler/common/babel/plugins/queries/index.ts

@@ -1,166 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import path from 'path';
-import { PluginObj } from '@babel/core';
-import * as types from '@babel/types'
-
-/*----------------------------------
-- REGEX
-----------------------------------*/
-const cheminClasseQuery = '@serveur/database/jsql/query/runner';
-
-const regFichierModele = /^[a-z]+\/serveur\/modeles\//i;
-
-/*----------------------------------
-- WEBPACK RULE
-----------------------------------*/
-module.exports = {// /serveur/**.ts */
-    test: /\/serveur\/(.*)\.(ts)$/i,
-    plugins: [
-        [Plugin]
-    ]
-}
-
-
-/*----------------------------------
-- PLUGIN
-----------------------------------*/
-function Plugin (babel) {
-
-    const t = babel.types as typeof types;
-
-    const plugin: PluginObj<{
-        fichier: string,
-        dossier: string
-    }> = {
-        pre(state) {
-
-            const { filename, root } = state.opts;
-
-            if (!filename)
-                throw new Error(`Impossible d'obtenir le chemin du fichier actuellement rraité par le plugin`);
-
-            if (!root)
-                throw new Error(`Impossible d'obtenir le chemin de la racine du projet`);
-
-            this.fichier = filename;
-
-            const prefixeRoot = root;
-            this.dossier = path.dirname(filename).substring(prefixeRoot.length)
-        },
-        visitor: {
-            ImportDeclaration(instruction) {
-
-                if (!(
-                    instruction.node.specifiers.length === 1
-                    &&
-                    instruction.node.specifiers[0].type === 'ImportDefaultSpecifier'
-                ))
-                    return;
-
-                const cheminImportFichier = instruction.node.source.value;
-                const importDefault = instruction.node.specifiers[0];
-
-                /* Recherche de:
-                    import PublicScope from './Public/index.sql';
-                */
-                if (
-                    // Suffise SQL = déjà traité, ou intention de garder le SQL
-                    !importDefault.local.name.endsWith('SQL')
-                    &&
-                    cheminImportFichier.endsWith('.sql')
-                ) {
-
-                    // Extraction des infos
-                    const nomVarScope = importDefault.local.name;
-                    const nomImportSql = nomVarScope + 'SQL';
-                    const cheminCompletImport = path.join(this.dossier, cheminImportFichier);
-
-                    // Génère un ID unique basé sur le chemin
-                    let cheminScope: string = cheminCompletImport;
-                    const isModelScope = regFichierModele.test(cheminCompletImport);
-                    if (isModelScope) {
-                        // Mission.Public
-                        const nomModele = path.basename(this.dossier);
-                        cheminScope = nomModele + '.' + cheminCompletImport.substring(
-                            this.dossier.length + 1, // +1 pour le dernier slash
-                        )
-                    }
-
-                    cheminScope = cheminScope
-                        .substring(0, cheminScope.length - 4) // Vire l'extension .sql
-                        .replace(/\//g, '.');
-
-                    if (cheminScope.endsWith('.index'))
-                        cheminScope = cheminScope.substring(0, cheminScope.length - 6)
-
-                    // Renommage de l'import du sql et instanciaiton de la query
-                    // NOTE: On ne skip pas, puisque les imports ont été suffixés de SQL
-                    //instruction.skip();
-                    let remplacement = []
-
-                    /* Création factory */
-                    remplacement.push(
-
-                        // + import PublicScopeSql from './Public/index.sql';
-                        t.importDeclaration(
-                            [t.importDefaultSpecifier(t.identifier(nomImportSql))],
-                            t.stringLiteral(cheminImportFichier)
-                        ),
-
-                        // + const PublicScope = new String( PublicScopeSql );
-                        t.variableDeclaration('const', [
-                            t.variableDeclarator( 
-                                t.identifier(nomVarScope), 
-                                t.newExpression(
-                                    t.identifier('String'),
-                                    [t.identifier(nomImportSql)]
-                                ) 
-                            )
-                        ]),
-
-                        // + PublicScope.id = 'earn/missions/Mission/Public/index';
-                        t.expressionStatement(
-                            t.assignmentExpression(
-                                '=',
-                                t.memberExpression(
-                                    t.identifier( nomVarScope ),
-                                    t.identifier('id')
-                                ),
-                                t.stringLiteral(cheminScope)
-                            )
-                        ),
-
-                        // + PublicScope.sourceFile = 'earn/missions/Mission/Public/index.sql'
-                        t.expressionStatement(
-                            t.assignmentExpression(
-                                '=',
-                                t.memberExpression(
-                                    t.identifier( nomVarScope ),
-                                    t.identifier('sourceFile')
-                                ),
-                                t.stringLiteral(cheminCompletImport)
-                            )
-                        ),
-                    )
-
-                    /*console.log(`[babel][plugin][queries]`, 
-                        this.fichier, cheminCompletImport, '\n',
-                        recast.print( t.program(remplacement) ).code,
-                        cheminScope
-                    );*/
-
-                    // Remplacement
-                    instruction.replaceWithMultiple(remplacement);
-
-                }
-
-            }
-        }
-    };
-
-    return plugin;
-}

package/compiler/common/plugins/indexage/_utils/Stringify.ts

@@ -1,72 +0,0 @@
-const placeholder: string = '____PLACEHOLDER____';
-const balises = {
-    fonction: '[fonction]',
-    methode: '[methode]'
-}
-
-const regRemplacements = new RegExp('("([^"]+)": )?"' + placeholder + '"', 'g');
-
-// Permet de transformer un objet en chaine json sans niquer les fonctions
-export default ( obj: object, fonctions: string[] = [] ): string => {
-
-    var fns: [string, string][] = [];
-
-    // Remplace les fonctions par un placeholder et tranforme en json
-    var json = JSON.stringify(obj, (key: string, value: any): string => {
-
-        const func: boolean = typeof value === 'function';
-        const ref_fonction: boolean = typeof value === 'string' && value.startsWith( balises.fonction );
-        const ref_methode: boolean = typeof value === 'string' && value.startsWith( balises.methode );
-
-        if (fonctions.includes(key) || func || ref_fonction || ref_methode) {
-
-            if (func)
-                value = value.toString();
-            else if (ref_fonction)
-                value = value.substring( balises.fonction.length );
-            else if (ref_methode)
-                value = value.substring( balises.methode.length );
-
-            fns.push([ value, ref_methode ? 'methode' : 'fonction' ]);
-
-            return placeholder;
-        }
-
-        return value;
-    }, 4);
-
-    // Remplace les placeholders par la fonction brute sans les guillemets
-    json = json.replace(regRemplacements, (match: string, contnom: string, nom: string): string => {
-        const func = fns.shift();
-        if (Array.isArray(func)) {
-
-            const [ fonction, type ] = func;
-
-            // La fonction est dans un tableau
-            if (nom === undefined)
-                return fonction;
-            else
-                return type === 'methode'
-                    // nom() { ... }
-                    ? nom + fonction
-                    // "nom": () => { ... }
-                    : '"'+ nom +'": ' + fonction;
-
-            return fonction ? fonction : '';
-
-        } else
-            return '';
-    });
-
-    // retire les quotes
-    json = json.replace(/\"([a-zA-Z]+)\"\:/gm, '$1:');
-
-    // Correction pour les méthodes de classe
-    // Remplace <nom>: <args> => { par <nom><args> {
-    json = json.replace(
-        /([a-zA-Z]+)\:\s*(\([a-zA-Z\,\s]*\))\s*\=\>\s*\{/gmi,
-        '$1$2 {'
-    );
-
-    return json;
-};

package/compiler/common/plugins/indexage/_utils/annotations.ts

@@ -1,88 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-import fs from 'fs-extra';
-
-/*----------------------------------
-- TYPE
-----------------------------------*/
-type TDonnees = {[cle: string]: string | number};
-
-/*----------------------------------
-- FONCTION
-----------------------------------*/
-export default function lireAnnotations<TRetour = TDonnees>( fichier: string ): TRetour | undefined {
-
-    let annotations: TRetour = {} as TRetour;
-    let lectureAnnotations: boolean = false;
-
-    // Lecture de chaque ligne
-    const lignes = fs.readFileSync(fichier, 'utf-8').split('\n');
-    for (let ligne of lignes) {
-
-        // Debut des annotations
-        if (ligne === "/* ~~~~~~~~~~~~~~~~") {
-
-            lectureAnnotations = true;
-
-        // Fin des anotations
-        } else if (ligne === "~~~~~~~~~~~~~~~~ */") {
-
-            return annotations;
-
-        // Lecture des annotations
-        } else if (lectureAnnotations) {
-
-            // Retire le "* " au debut de la ligne
-            ligne = ligne.substring(2).trim();
-            // Ligne vide
-            if (ligne.length === 0)
-                continue;
-
-            // Niveau indentation
-            //const indentation = ligne.match(/^( )*/)
-            //const indentLevel = indentation === null ? 0 : indentation[0].length;
-            
-            // cle: valeur
-            if (ligne.includes(': ')) {
-
-                // Décomposition clé / valeur
-                let [cle, valeur] = ligne.split(': ') as [string, any];
-                cle = cle.trim().toLowerCase();
-
-                // retire le commentaire
-                const poscommentaire = valeur.indexOf(' //')
-                if (poscommentaire !== -1)
-                    valeur = valeur.substring(0, poscommentaire);
-                valeur = valeur.trim();
-
-                // Met en minuscules
-                if (cle) {
-
-                    // Correction type valeur
-                    if (valeur === 'true')
-                        valeur = true;
-                    else if (valeur === 'false')
-                        valeur = false;
-                    else if (!isNaN(Number(valeur)))
-                        valeur = parseFloat(valeur);
-
-                    // Référencement
-                    if (annotations[cle] === undefined)
-                        annotations[cle] = valeur;
-                    // Valeur déjà existante, regroupement dans un tableau
-                    else if (!Array.isArray(annotations[cle]))
-                        annotations[cle] = [annotations[cle], valeur];
-                    // Déjà en tableau, ajout élement
-                    else
-                        annotations[cle] = [...annotations[cle], valeur];
-
-                }
-
-            }
-        }
-
-    }
-
-    return undefined;
-}

package/compiler/common/plugins/indexage/_utils/iterateur.ts

@@ -1,52 +0,0 @@
-const path = require('path')
-const fs = require('fs')
-
-export default function iterateur(
-    dir: string,
-    func: (fichier: string, ext: string, cheminRelatif: string, dossier: string) => void,
-    extensions: string[] = [],
-    blacklist: string[] = [],
-    func_sinon?: (fichier: string) => void,
-    dir_root?: string
-) {
-
-    if (dir_root === undefined)
-        dir_root = dir;
-
-    // Lecture du contenu du dossier
-    const elements = fs.readdirSync(dir);
-    for (const file of elements) {
-
-        const file_relatif = dir + '/' + file;
-
-        // Pas dans la blacklist
-        if ((!blacklist || !blacklist.includes( file ))) {
-
-            // Récup chemin complet
-            const file_complet = path.resolve(dir, file);
-
-            // Extension sans le point
-            const ext = path.extname( file ).substring(1);
-
-            // Recup infos element
-            const stat = fs.statSync(file_complet);
-
-            // Dossier = recursion
-            if (stat && stat.isDirectory())
-
-                iterateur( file_relatif, func, extensions, blacklist, func_sinon, dir_root );
-
-            else if (extensions.includes( ext )) {
-
-                let chemin = file_relatif.substring(dir_root.length + 1, file_relatif.length - ext.length - 1)
-                if (chemin.endsWith('/index'))
-                    chemin = chemin.substring(0, chemin.length - 6);
-
-                func( file_relatif, ext, chemin, dir );
-
-            }
-
-        } else if (func_sinon)
-            func_sinon( file_relatif );
-    };
-}