ether-code 0.1.0

package/generators/php-generator.js

@@ -0,0 +1,706 @@
+const fs = require('fs')
+
+class PHPGenerator {
+  constructor(i18nPath = null) {
+    this.i18n = null
+    this.indent = 0
+    this.output = ''
+    this.keywordMap = {}
+    this.functionMap = {}
+    
+    if (i18nPath) {
+      this.loadI18n(i18nPath)
+    }
+  }
+
+  loadI18n(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    this.i18n = JSON.parse(content)
+    this.buildMaps()
+  }
+
+  buildMaps() {
+    this.keywordMap = {}
+    this.functionMap = {}
+    
+    if (!this.i18n) return
+
+    const addToMap = (map, section) => {
+      if (!section) return
+      for (const [key, translations] of Object.entries(section)) {
+        if (translations && translations.fr && translations.php) {
+          map[translations.fr.toLowerCase()] = translations.php
+        }
+      }
+    }
+
+    addToMap(this.keywordMap, this.i18n.variables)
+    addToMap(this.keywordMap, this.i18n.types)
+    addToMap(this.keywordMap, this.i18n.operateursArithmetiques)
+    addToMap(this.keywordMap, this.i18n.operateursComparaison)
+    addToMap(this.keywordMap, this.i18n.operateursLogiques)
+    addToMap(this.keywordMap, this.i18n.conditions)
+    addToMap(this.keywordMap, this.i18n.boucles)
+    addToMap(this.keywordMap, this.i18n.fonctions)
+    addToMap(this.keywordMap, this.i18n.classes)
+    addToMap(this.keywordMap, this.i18n.visibilite)
+    addToMap(this.keywordMap, this.i18n.erreursExceptions)
+
+    addToMap(this.functionMap, this.i18n.chainesManipulation)
+    addToMap(this.functionMap, this.i18n.chainesRecherche)
+    addToMap(this.functionMap, this.i18n.chainesCasse)
+    addToMap(this.functionMap, this.i18n.tableauxBase)
+    addToMap(this.functionMap, this.i18n.tableauxTri)
+    addToMap(this.functionMap, this.i18n.tableauxFonctionnels)
+    addToMap(this.functionMap, this.i18n.mathsBase)
+    addToMap(this.functionMap, this.i18n.datesBase)
+    addToMap(this.functionMap, this.i18n.fichiersOuverture)
+    addToMap(this.functionMap, this.i18n.fichiersOperations)
+    addToMap(this.functionMap, this.i18n.regexFonctions)
+    addToMap(this.functionMap, this.i18n.jsonFonctions)
+  }
+
+  translate(word) {
+    const lower = word.toLowerCase()
+    return this.keywordMap[lower] || this.functionMap[lower] || this.translateGeneric(word)
+  }
+
+  translateGeneric(word) {
+    const translations = {
+      'variable': '',
+      'constante': 'const',
+      'fonction': 'function',
+      'retourner': 'return',
+      'si': 'if',
+      'sinon': 'else',
+      'sinon si': 'elseif',
+      'pour': 'for',
+      'pour chaque': 'foreach',
+      'tant que': 'while',
+      'faire': 'do',
+      'selon': 'switch',
+      'cas': 'case',
+      'défaut': 'default',
+      'sortir': 'break',
+      'continuer': 'continue',
+      'essayer': 'try',
+      'attraper': 'catch',
+      'finalement': 'finally',
+      'lancer': 'throw',
+      'nouveau': 'new',
+      'classe': 'class',
+      'interface': 'interface',
+      'trait': 'trait',
+      'étend': 'extends',
+      'implémente': 'implements',
+      'utiliser': 'use',
+      'public': 'public',
+      'privé': 'private',
+      'protégé': 'protected',
+      'statique': 'static',
+      'final': 'final',
+      'abstrait': 'abstract',
+      'constructeur': '__construct',
+      'destructeur': '__destruct',
+      'obtenir': '__get',
+      'définir': '__set',
+      'appeler': '__call',
+      'vers chaîne': '__toString',
+      'espace de noms': 'namespace',
+      'comme': 'as',
+      'vrai': 'true',
+      'faux': 'false',
+      'nul': 'null',
+      'ceci': '$this',
+      'parent': 'parent',
+      'soi': 'self',
+      'et': '&&',
+      'ou': '||',
+      'non': '!',
+      'egal': '===',
+      'different': '!==',
+      'concatener': '.',
+      'tableau': 'array',
+      'chaîne': 'string',
+      'entier': 'int',
+      'flottant': 'float',
+      'booléen': 'bool',
+      'objet': 'object',
+      'vide': 'void',
+      'mixte': 'mixed',
+      'afficher': 'echo',
+      'imprimer': 'print',
+      'longueur': 'strlen',
+      'compter': 'count',
+      'exploser': 'explode',
+      'imploser': 'implode',
+      'remplacer': 'str_replace',
+      'position': 'strpos',
+      'sous chaîne': 'substr',
+      'majuscules': 'strtoupper',
+      'minuscules': 'strtolower',
+      'supprimer espaces': 'trim',
+      'ajouter': 'array_push',
+      'retirer': 'array_pop',
+      'fusionner': 'array_merge',
+      'filtrer': 'array_filter',
+      'mapper': 'array_map',
+      'réduire': 'array_reduce',
+      'trier': 'sort',
+      'inverser': 'array_reverse',
+      'clés': 'array_keys',
+      'valeurs': 'array_values',
+      'existe': 'isset',
+      'vide test': 'empty',
+      'est tableau': 'is_array',
+      'est chaîne': 'is_string',
+      'est entier': 'is_int',
+      'est flottant': 'is_float',
+      'est numerique': 'is_numeric',
+      'est nul': 'is_null',
+      'type de': 'gettype',
+      'convertir chaîne': 'strval',
+      'convertir entier': 'intval',
+      'convertir flottant': 'floatval',
+      'date': 'date',
+      'temps': 'time',
+      'maintenant': 'now',
+      'fichier existe': 'file_exists',
+      'lire fichier': 'file_get_contents',
+      'écrire fichier': 'file_put_contents',
+      'ouvrir': 'fopen',
+      'fermer': 'fclose',
+      'lire': 'fread',
+      'écrire': 'fwrite',
+      'json encoder': 'json_encode',
+      'json décoder': 'json_decode',
+      'json decoder': 'json_decode',
+      'regex correspondance': 'preg_match',
+      'regex toutes': 'preg_match_all',
+      'regex remplacer': 'preg_replace',
+      'en tete': 'header',
+      'rediriger': 'header',
+      'session démarrer': 'session_start',
+      'session': '$_SESSION',
+      'post': '$_POST',
+      'get': '$_GET',
+      'requête': '$_REQUEST',
+      'serveur': '$_SERVER',
+      'fichiers': '$_FILES',
+      'cookie': '$_COOKIE',
+      'mourir': 'die',
+      'sortie': 'exit',
+      'inclure': 'include',
+      'inclure une fois': 'include_once',
+      'requiert': 'require',
+      'requiert une fois': 'require_once'
+    }
+
+    const lower = word.toLowerCase()
+    return translations[lower] || word
+  }
+
+  generate(ast) {
+    this.output = ''
+    this.indent = 0
+
+    if (Array.isArray(ast)) {
+      for (const node of ast) {
+        const result = this.generateNode(node)
+        if (result !== undefined && result !== '' && this.output === '') {
+          return result
+        }
+      }
+    } else if (ast && ast.type) {
+      const result = this.generateNode(ast)
+      if (result !== undefined && result !== '' && this.output === '') {
+        return result
+      }
+    } else if (ast && ast.body) {
+      for (const node of ast.body) {
+        const result = this.generateNode(node)
+        if (result !== undefined && result !== '' && this.output === '') {
+          return result
+        }
+      }
+    }
+
+    return this.output.trim() || '<?php'
+  }
+
+  generateNode(node) {
+    if (!node) return ''
+
+    switch (node.type) {
+      case 'VariableDeclaration':
+        return this.generateVariableDeclaration(node)
+      case 'FunctionDeclaration':
+        return this.generateFunctionDeclaration(node)
+      case 'ClassDeclaration':
+        return this.generateClassDeclaration(node)
+      case 'IfStatement':
+        return this.generateIfStatement(node)
+      case 'ForStatement':
+        return this.generateForStatement(node)
+      case 'ForEachStatement':
+        return this.generateForEachStatement(node)
+      case 'WhileStatement':
+        return this.generateWhileStatement(node)
+      case 'DoWhileStatement':
+        return this.generateDoWhileStatement(node)
+      case 'SwitchStatement':
+        return this.generateSwitchStatement(node)
+      case 'TryStatement':
+        return this.generateTryStatement(node)
+      case 'ReturnStatement':
+        return this.generateReturnStatement(node)
+      case 'ThrowStatement':
+        return this.generateThrowStatement(node)
+      case 'BreakStatement':
+        this.writeLine('break;')
+        return
+      case 'ContinueStatement':
+        this.writeLine('continue;')
+        return
+      case 'ExpressionStatement':
+        return this.generateExpressionStatement(node)
+      case 'EchoStatement':
+        return this.generateEchoStatement(node)
+      case 'NamespaceDeclaration':
+        return this.generateNamespace(node)
+      case 'UseStatement':
+        return this.generateUseStatement(node)
+      case 'CallExpression':
+        return this.generateCallExpression(node)
+      case 'MemberExpression':
+        return this.generateMemberExpression(node)
+      case 'BinaryExpression':
+        return this.generateBinaryExpression(node)
+      case 'AssignmentExpression':
+        return this.generateAssignmentExpression(node)
+      case 'UpdateExpression':
+        return this.generateUpdateExpression(node)
+      case 'ArrayExpression':
+        return this.generateArrayExpression(node)
+      case 'ObjectExpression':
+        return this.generateObjectExpression(node)
+      case 'Identifier':
+        return this.generateIdentifier(node)
+      case 'Literal':
+        return this.generateLiteral(node)
+      case 'NewExpression':
+        return this.generateNewExpression(node)
+      default:
+        if (node.name && !node.type) {
+          return this.generateIdentifier(node)
+        }
+        return ''
+    }
+  }
+
+  generateUpdateExpression(node) {
+    const arg = this.generateNode(node.argument)
+    const op = node.operator
+    if (node.prefix) {
+      return `${op}${arg}`
+    }
+    return `${arg}${op}`
+  }
+
+  generateVariableDeclaration(node) {
+    const declarations = node.declarations || []
+    
+    for (const decl of declarations) {
+      const name = this.generateIdentifier(decl.id || { name: decl.name })
+      if (decl.init) {
+        const init = this.generateNode(decl.init)
+        this.writeLine(`${name} = ${init};`)
+      } else {
+        this.writeLine(`${name};`)
+      }
+    }
+  }
+
+  generateFunctionDeclaration(node) {
+    const name = this.translate(node.name || node.id?.name || '')
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    const returnType = node.returnType ? ': ' + this.translate(node.returnType) : ''
+
+    this.writeLine(`function ${name}(${params})${returnType} {`)
+    this.indent++
+    
+    if (node.body) {
+      if (Array.isArray(node.body)) {
+        for (const stmt of node.body) {
+          this.generateNode(stmt)
+        }
+      } else {
+        this.generateNode(node.body)
+      }
+    }
+    
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateParam(param) {
+    let result = ''
+    
+    if (param.type && param.type !== 'Identifier') {
+      result += this.translate(param.type) + ' '
+    }
+    
+    result += this.generateIdentifier(param)
+    
+    if (param.default) {
+      result += ' = ' + this.generateNode(param.default)
+    }
+    
+    return result
+  }
+
+  generateClassDeclaration(node) {
+    const name = node.name || node.id?.name || ''
+    let declaration = 'class ' + name
+
+    if (node.extends) {
+      declaration += ' extends ' + node.extends
+    }
+
+    if (node.implements && node.implements.length > 0) {
+      declaration += ' implements ' + node.implements.join(', ')
+    }
+
+    this.writeLine(declaration + ' {')
+    this.indent++
+
+    const members = node.body?.body || node.members || node.body || []
+    for (const member of members) {
+      this.generateClassMember(member)
+    }
+
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateClassMember(node) {
+    const visibility = node.visibility || 'public'
+    const isStatic = node.static ? 'static ' : ''
+    
+    if (node.type === 'Property' || node.kind === 'property') {
+      const name = this.generateIdentifier(node.key || { name: node.name })
+      const typeHint = node.typeHint ? this.translate(node.typeHint) + ' ' : ''
+      const value = node.value ? ' = ' + this.generateNode(node.value) : ''
+      this.writeLine(`${visibility} ${isStatic}${typeHint}${name}${value};`)
+      this.writeLine('')
+    } else if (node.type === 'Method' || node.kind === 'method' || node.type === 'FunctionDeclaration') {
+      const name = this.translate(node.key?.name || node.name || '')
+      const params = (node.params || node.value?.params || []).map(p => this.generateParam(p)).join(', ')
+      const returnType = node.returnType ? ': ' + this.translate(node.returnType) : ''
+      
+      this.writeLine(`${visibility} ${isStatic}function ${name}(${params})${returnType} {`)
+      this.indent++
+      
+      const body = node.body || node.value?.body
+      if (body) {
+        if (Array.isArray(body)) {
+          for (const stmt of body) {
+            this.generateNode(stmt)
+          }
+        } else if (body.body) {
+          for (const stmt of body.body) {
+            this.generateNode(stmt)
+          }
+        } else {
+          this.generateNode(body)
+        }
+      }
+      
+      this.indent--
+      this.writeLine('}')
+      this.writeLine('')
+    }
+  }
+
+  generateIfStatement(node) {
+    const test = this.generateNode(node.test)
+    this.writeLine(`if (${test}) {`)
+    this.indent++
+    this.generateNode(node.consequent)
+    this.indent--
+
+    if (node.alternate) {
+      if (node.alternate.type === 'IfStatement') {
+        this.output = this.output.trimEnd() + '\n' + this.getIndent() + '} elseif '
+        const altTest = this.generateNode(node.alternate.test)
+        this.output += `(${altTest}) {\n`
+        this.indent++
+        this.generateNode(node.alternate.consequent)
+        this.indent--
+        if (node.alternate.alternate) {
+          if (node.alternate.alternate.type === 'IfStatement') {
+            this.generateIfStatement({ test: node.alternate.alternate.test, consequent: node.alternate.alternate.consequent, alternate: node.alternate.alternate.alternate })
+          } else {
+            this.writeLine('} else {')
+            this.indent++
+            this.generateNode(node.alternate.alternate)
+            this.indent--
+            this.writeLine('}')
+          }
+        } else {
+          this.writeLine('}')
+        }
+      } else {
+        this.writeLine('} else {')
+        this.indent++
+        this.generateNode(node.alternate)
+        this.indent--
+        this.writeLine('}')
+      }
+    } else {
+      this.writeLine('}')
+    }
+  }
+
+  generateForStatement(node) {
+    const init = node.init ? this.generateNode(node.init).replace(/;$/, '') : ''
+    const test = node.test ? this.generateNode(node.test) : ''
+    const update = node.update ? this.generateNode(node.update) : ''
+
+    this.writeLine(`for (${init}; ${test}; ${update}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateForEachStatement(node) {
+    const array = this.generateNode(node.array || node.right)
+    const value = this.generateIdentifier(node.value || node.left)
+    const key = node.key ? this.generateIdentifier(node.key) + ' => ' : ''
+
+    this.writeLine(`foreach (${array} as ${key}${value}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateWhileStatement(node) {
+    const test = this.generateNode(node.test)
+    this.writeLine(`while (${test}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateDoWhileStatement(node) {
+    this.writeLine('do {')
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    const test = this.generateNode(node.test)
+    this.writeLine(`} while (${test});`)
+  }
+
+  generateSwitchStatement(node) {
+    const discriminant = this.generateNode(node.discriminant)
+    this.writeLine(`switch (${discriminant}) {`)
+    this.indent++
+
+    for (const caseNode of node.cases || []) {
+      if (caseNode.test) {
+        const test = this.generateNode(caseNode.test)
+        this.writeLine(`case ${test}:`)
+      } else {
+        this.writeLine('default:')
+      }
+      this.indent++
+      for (const stmt of caseNode.consequent || []) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateTryStatement(node) {
+    this.writeLine('try {')
+    this.indent++
+    this.generateNode(node.block)
+    this.indent--
+
+    if (node.handler) {
+      const exceptionType = node.handler.type || 'Exception'
+      const param = node.handler.param ? this.generateIdentifier(node.handler.param) : '$e'
+      this.writeLine(`} catch (${exceptionType} ${param}) {`)
+      this.indent++
+      this.generateNode(node.handler.body)
+      this.indent--
+    }
+
+    if (node.finalizer) {
+      this.writeLine('} finally {')
+      this.indent++
+      this.generateNode(node.finalizer)
+      this.indent--
+    }
+
+    this.writeLine('}')
+  }
+
+  generateReturnStatement(node) {
+    if (node.argument) {
+      const arg = this.generateNode(node.argument)
+      this.writeLine(`return ${arg};`)
+    } else {
+      this.writeLine('return;')
+    }
+  }
+
+  generateThrowStatement(node) {
+    const arg = this.generateNode(node.argument)
+    this.writeLine(`throw ${arg};`)
+  }
+
+  generateExpressionStatement(node) {
+    const expr = this.generateNode(node.expression)
+    this.writeLine(`${expr};`)
+  }
+
+  generateEchoStatement(node) {
+    const args = (node.arguments || [node.argument]).map(a => this.generateNode(a)).join(', ')
+    this.writeLine(`echo ${args};`)
+  }
+
+  generateNamespace(node) {
+    this.writeLine(`namespace ${node.name};`)
+    this.writeLine('')
+  }
+
+  generateUseStatement(node) {
+    const name = node.name || node.source
+    const alias = node.alias ? ' as ' + node.alias : ''
+    this.writeLine(`use ${name}${alias};`)
+  }
+
+  generateCallExpression(node) {
+    const callee = typeof node.callee === 'string' 
+      ? this.translate(node.callee)
+      : this.generateNode(node.callee)
+    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
+    return `${callee}(${args})`
+  }
+
+  generateMemberExpression(node) {
+    const object = this.generateNode(node.object)
+    const property = typeof node.property === 'string' 
+      ? node.property 
+      : this.generateNode(node.property)
+    
+    if (node.static) {
+      return `${object}::${property}`
+    }
+    if (node.computed) {
+      return `${object}[${property}]`
+    }
+    return `${object}->${property}`
+  }
+
+  generateBinaryExpression(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    let op = node.operator
+
+    const opMap = {
+      'et': '&&',
+      'ou': '||',
+      'concatener': '.'
+    }
+    op = opMap[op] || op
+
+    return `${left} ${op} ${right}`
+  }
+
+  generateAssignmentExpression(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    const op = node.operator || '='
+    return `${left} ${op} ${right}`
+  }
+
+  generateArrayExpression(node) {
+    const elements = (node.elements || []).map(e => {
+      if (e.key) {
+        const key = this.generateNode(e.key)
+        const value = this.generateNode(e.value || e)
+        return `${key} => ${value}`
+      }
+      return this.generateNode(e)
+    })
+    
+    if (elements.length === 0) return '[]'
+    if (elements.length <= 3) {
+      return `[${elements.join(', ')}]`
+    }
+    return `[\n${this.getIndent()}  ${elements.join(',\n' + this.getIndent() + '  ')}\n${this.getIndent()}]`
+  }
+
+  generateObjectExpression(node) {
+    return this.generateArrayExpression(node)
+  }
+
+  generateIdentifier(node) {
+    const name = node.name || node
+    if (typeof name !== 'string') return '$var'
+    
+    const translated = this.translate(name)
+    
+    if (translated.startsWith('$')) return translated
+    if (['true', 'false', 'null', 'self', 'parent', 'static'].includes(translated)) {
+      return translated
+    }
+    if (/^[A-Z]/.test(translated)) return translated
+    
+    return '$' + translated
+  }
+
+  generateLiteral(node) {
+    if (node.raw) return node.raw
+    if (typeof node.value === 'string') {
+      return `"${node.value.replace(/"/g, '\\"')}"`
+    }
+    if (node.value === null) return 'null'
+    if (node.value === true) return 'true'
+    if (node.value === false) return 'false'
+    return String(node.value)
+  }
+
+  generateNewExpression(node) {
+    const callee = typeof node.callee === 'string'
+      ? node.callee
+      : this.generateNode(node.callee)
+    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
+    return `new ${callee}(${args})`
+  }
+
+  writeLine(text) {
+    if (this.output === '') {
+      this.output = '<?php '
+    }
+    this.output += this.getIndent() + text + '\n'
+  }
+
+  getIndent() {
+    return '  '.repeat(this.indent)
+  }
+}
+
+module.exports = {
+  PHPGenerator
+}