ether-code 0.4.4 → 0.4.6

package/cli/compiler.js

@@ -145,17 +145,22 @@ class EtherCompiler {
   }
 
   detectTarget(content, filePath) {
-    const directiveMatch = content.match(/^\/\/\s*(?:cible|target|@target)\s*:\s*(\w+)/im)
+    const atMatch = content.match(/^@(?:cible|target)\s*:\s*(\w+)/im)
+    if (atMatch) {
+      return atMatch[1].toLowerCase()
+    }
+    
+    const directiveMatch = content.match(/^\/\/\s*(?:cible|target|@cible|@target)\s*:\s*(\w+)/im)
     if (directiveMatch) {
       return directiveMatch[1].toLowerCase()
     }
     
-    const commentMatch = content.match(/^\/\*\s*(?:cible|target)\s*:\s*(\w+)\s*\*\//im)
+    const commentMatch = content.match(/^\/\*\s*(?:cible|target|@cible|@target)\s*:\s*(\w+)\s*\*\//im)
     if (commentMatch) {
       return commentMatch[1].toLowerCase()
     }
     
-    const hashMatch = content.match(/^#\s*(?:cible|target)\s*:\s*(\w+)/im)
+    const hashMatch = content.match(/^#\s*(?:cible|target|@cible|@target)\s*:\s*(\w+)/im)
     if (hashMatch) {
       return hashMatch[1].toLowerCase()
     }
@@ -249,4 +254,4 @@ class EtherCompiler {
   }
 }
 
-module.exports = { EtherCompiler, GENERATORS, TARGET_EXTENSIONS }
+module.exports = { EtherCompiler, GENERATORS, TARGET_EXTENSIONS }

package/cli/ether.js

@@ -6,7 +6,7 @@ const http = require('http')
 const { EtherCompiler } = require('./compiler')
 const { Watcher } = require('./watcher')
 
-const VERSION = '0.4.4'
+const VERSION = '0.4.6'
 
 const COLORS = {
   reset: '\x1b[0m',

package/ether-parser.js

@@ -11,6 +11,206 @@ class EtherParser {
     this.targetLang = options.targetLang || 'auto'
     
     this.loadAllI18n(options.i18nDir || './i18n')
+    this.initCompoundTerms()
+  }
+
+  initCompoundTerms() {
+    this.compoundOperators = {
+      'strictement egal': '===',
+      'strictement égal': '===',
+      'strictement different': '!==',
+      'strictement différent': '!==',
+      'superieur ou egal': '>=',
+      'supérieur ou égal': '>=',
+      'inferieur ou egal': '<=',
+      'inférieur ou égal': '<=',
+      'coalescence nulle': '??',
+      'chainage optionnel': '?.',
+      'chaînage optionnel': '?.'
+    }
+    
+    this.compoundKeywords = {
+      'sinon si': 'else if',
+      'tant que': 'while',
+      'pour chaque': 'forEach',
+      'fonction asynchrone': 'async function',
+      'fonction async': 'async function',
+      'fonction generatrice': 'function*',
+      'fonction génératrice': 'function*',
+      'variable globale': 'var'
+    }
+
+    this.jsTranslations = {
+      'variable': 'let',
+      'constante': 'const',
+      'fonction': 'function',
+      'retourner': 'return',
+      'si': 'if',
+      'sinon': 'else',
+      'pour': 'for',
+      'de': 'of',
+      'dans': 'in',
+      'selon': 'switch',
+      'cas': 'case',
+      'defaut': 'default',
+      'sortir': 'break',
+      'continuer': 'continue',
+      'essayer': 'try',
+      'attraper': 'catch',
+      'finalement': 'finally',
+      'lancer': 'throw',
+      'nouveau': 'new',
+      'supprimer': 'delete',
+      'vrai': 'true',
+      'faux': 'false',
+      'nul': 'null',
+      'indefini': 'undefined',
+      'ceci': 'this',
+      'classe': 'class',
+      'etendre': 'extends',
+      'super': 'super',
+      'constructeur': 'constructor',
+      'statique': 'static',
+      'obtenir': 'get',
+      'definir': 'set',
+      'asynchrone': 'async',
+      'attendre': 'await',
+      'importer': 'import',
+      'exporter': 'export',
+      'depuis': 'from',
+      'comme': 'as',
+      'addition': '+',
+      'soustraction': '-',
+      'multiplication': '*',
+      'division': '/',
+      'modulo': '%',
+      'puissance': '**',
+      'increment': '++',
+      'decrement': '--',
+      'egal': '==',
+      'different': '!=',
+      'superieur': '>',
+      'inferieur': '<',
+      'et': '&&',
+      'ou': '||',
+      'non': '!',
+      'document': 'document',
+      'fenetre': 'window',
+      'console': 'console',
+      'journal': 'console.log',
+      'erreur': 'console.error',
+      'avertir': 'console.warn',
+      'info': 'console.info',
+      'promesse': 'Promise',
+      'resoudre': 'resolve',
+      'rejeter': 'reject',
+      'alors': 'then',
+      'tout': 'all',
+      'course': 'race',
+      'json': 'JSON',
+      'serialiser': 'stringify',
+      'analyser': 'parse',
+      'math': 'Math',
+      'aleatoire': 'random',
+      'arrondir': 'round',
+      'plancher': 'floor',
+      'plafond': 'ceil',
+      'absolu': 'abs',
+      'maximum': 'max',
+      'minimum': 'min',
+      'date': 'Date',
+      'maintenant': 'now',
+      'carte': 'Map',
+      'ensemble': 'Set',
+      'symbole': 'Symbol',
+      'objet': 'Object',
+      'selecteur': 'querySelector',
+      'sur': 'addEventListener',
+      'longueur': 'length',
+      'taille': 'size',
+      'recuperer': 'fetch',
+      'transformer': 'map',
+      'filtrer': 'filter',
+      'reduire': 'reduce',
+      'trouver': 'find',
+      'certains': 'some',
+      'tous': 'every',
+      'inclut': 'includes',
+      'joindre': 'join',
+      'inverser': 'reverse',
+      'trier': 'sort',
+      'decouper': 'slice',
+      'concatener': 'concat',
+      'ajouter': 'push',
+      'retirer': 'pop',
+      'diviser': 'split',
+      'remplacer': 'replace',
+      'rogner': 'trim',
+      'repeter': 'repeat'
+    }
+  }
+
+  normalizeAccents(str) {
+    return str.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+  }
+
+  tryMatchCompoundOperator() {
+    const current = this.current()
+    if (!current || current.type !== TokenType.IDENTIFIER) return null
+    
+    const val1 = this.normalizeAccents(String(current.value))
+    const next = this.peek(1)
+    const next2 = this.peek(2)
+    
+    if (next && next.type === TokenType.IDENTIFIER) {
+      const val2 = this.normalizeAccents(String(next.value))
+      
+      if (next2 && next2.type === TokenType.IDENTIFIER) {
+        const val3 = this.normalizeAccents(String(next2.value))
+        const compound3 = `${val1} ${val2} ${val3}`
+        if (this.compoundOperators[compound3]) {
+          this.advance()
+          this.advance()
+          this.advance()
+          return this.compoundOperators[compound3]
+        }
+      }
+      
+      const compound2 = `${val1} ${val2}`
+      if (this.compoundOperators[compound2]) {
+        this.advance()
+        this.advance()
+        return this.compoundOperators[compound2]
+      }
+    }
+    
+    return null
+  }
+
+  tryMatchCompoundKeyword() {
+    const current = this.current()
+    if (!current || current.type !== TokenType.IDENTIFIER) return null
+    
+    const val1 = this.normalizeAccents(String(current.value))
+    const next = this.peek(1)
+    
+    if (next && next.type === TokenType.IDENTIFIER) {
+      const val2 = this.normalizeAccents(String(next.value))
+      const compound2 = `${val1} ${val2}`
+      if (this.compoundKeywords[compound2]) {
+        this.advance()
+        this.advance()
+        return this.compoundKeywords[compound2]
+      }
+    }
+    
+    return null
+  }
+
+  translateJSIdentifier(word) {
+    if (!word) return word
+    const lower = this.normalizeAccents(String(word))
+    return this.jsTranslations[lower] || word
   }
 
   loadAllI18n(dir) {
@@ -1153,7 +1353,14 @@ class EtherParser {
       return this.parseExport(lang)
     }
     
-    return this.parseExpression(lang)
+    const expr = this.parseExpression(lang)
+    if (expr) {
+      return {
+        type: 'ExpressionStatement',
+        expression: expr
+      }
+    }
+    return null
   }
 
   isVariableDeclaration(value) {
@@ -1717,6 +1924,13 @@ class EtherParser {
     let left = this.parseComparison(lang)
     
     while (true) {
+      const compoundOp = this.tryMatchCompoundOperator()
+      if (compoundOp === '===' || compoundOp === '!==') {
+        const right = this.parseComparison(lang)
+        left = { type: 'BinaryExpression', operator: compoundOp, left, right }
+        continue
+      }
+      
       if (this.match(TokenType.DOUBLE_EQUALS) || this.matchValue('egal') || this.matchValue('egale')) {
         const right = this.parseComparison(lang)
         left = { type: 'BinaryExpression', operator: '===', left, right }
@@ -1735,16 +1949,23 @@ class EtherParser {
     let left = this.parseAdditive(lang)
     
     while (true) {
+      const compoundOp = this.tryMatchCompoundOperator()
+      if (compoundOp === '>=' || compoundOp === '<=') {
+        const right = this.parseAdditive(lang)
+        left = { type: 'BinaryExpression', operator: compoundOp, left, right }
+        continue
+      }
+      
       if (this.match(TokenType.LT) || this.matchValue('inferieur')) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '<', left, right }
       } else if (this.match(TokenType.GT) || this.matchValue('superieur')) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '>', left, right }
-      } else if (this.match(TokenType.LTE) || this.matchValue('inferieur ou egal')) {
+      } else if (this.match(TokenType.LTE)) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '<=', left, right }
-      } else if (this.match(TokenType.GTE) || this.matchValue('superieur ou egal')) {
+      } else if (this.match(TokenType.GTE)) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '>=', left, right }
       } else {
@@ -1759,10 +1980,10 @@ class EtherParser {
     let left = this.parseMultiplicative(lang)
     
     while (true) {
-      if (this.match(TokenType.PLUS) || this.matchValue('plus')) {
+      if (this.match(TokenType.PLUS) || this.matchValue('plus') || this.matchValue('addition')) {
         const right = this.parseMultiplicative(lang)
         left = { type: 'BinaryExpression', operator: '+', left, right }
-      } else if (this.match(TokenType.MINUS) || this.matchValue('moins')) {
+      } else if (this.match(TokenType.MINUS) || this.matchValue('moins') || this.matchValue('soustraction')) {
         const right = this.parseMultiplicative(lang)
         left = { type: 'BinaryExpression', operator: '-', left, right }
       } else {
@@ -1777,10 +1998,10 @@ class EtherParser {
     let left = this.parseUnary(lang)
     
     while (true) {
-      if (this.match(TokenType.STAR) || this.matchValue('fois') || this.matchValue('multiplie')) {
+      if (this.match(TokenType.STAR) || this.matchValue('fois') || this.matchValue('multiplie') || this.matchValue('multiplication')) {
         const right = this.parseUnary(lang)
         left = { type: 'BinaryExpression', operator: '*', left, right }
-      } else if (this.match(TokenType.SLASH) || this.matchValue('divise')) {
+      } else if (this.match(TokenType.SLASH) || this.matchValue('divise') || this.matchValue('division')) {
         const right = this.parseUnary(lang)
         left = { type: 'BinaryExpression', operator: '/', left, right }
       } else if (this.match(TokenType.PERCENT) || this.matchValue('modulo')) {
@@ -1877,8 +2098,19 @@ class EtherParser {
         return { type: 'Literal', value: undefined }
       }
       
+      const translated = this.translateJSIdentifier(token.value)
       this.advance()
-      return { type: 'Identifier', name: token.value }
+      
+      if (translated && translated.includes('.')) {
+        const parts = translated.split('.')
+        let expr = { type: 'Identifier', name: parts[0] }
+        for (let i = 1; i < parts.length; i++) {
+          expr = { type: 'MemberExpression', object: expr, property: parts[i] }
+        }
+        return expr
+      }
+      
+      return { type: 'Identifier', name: translated || token.value }
     }
     
     if (token.type === TokenType.LBRACKET) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ether-code",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Ether - Le langage intentionnel",
   "main": "cli/compiler.js",
   "bin": {