ether-code 0.4.7 → 0.4.9

package/cli/ether.js

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

package/ether-parser.js

@@ -118,9 +118,9 @@ class EtherParser {
       'absolu': 'abs',
       'maximum': 'max',
       'minimum': 'min',
-      'date': 'Date',
+      
       'maintenant': 'now',
-      'carte': 'Map',
+      
       'ensemble': 'Set',
       'symbole': 'Symbol',
       'objet': 'Object',
@@ -297,9 +297,36 @@ class EtherParser {
     const token = this.current()
     if (!token || token.value === null || token.value === undefined) return null
     const tokenVal = String(token.value).toLowerCase()
-    if (tokenVal === value.toLowerCase()) {
+    const valueLower = value.toLowerCase()
+    
+    if (tokenVal === valueLower) {
       return this.advance()
     }
+    
+    if (valueLower.includes(' ')) {
+      const parts = valueLower.split(' ')
+      if (tokenVal === parts[0]) {
+        const savedPos = this.pos
+        const tokens = [this.advance()]
+        let matched = true
+        
+        for (let i = 1; i < parts.length && matched; i++) {
+          const nextToken = this.current()
+          if (nextToken && String(nextToken.value).toLowerCase() === parts[i]) {
+            tokens.push(this.advance())
+          } else {
+            matched = false
+          }
+        }
+        
+        if (matched) {
+          return tokens[tokens.length - 1]
+        } else {
+          this.pos = savedPos
+        }
+      }
+    }
+    
     return null
   }
 
@@ -314,6 +341,27 @@ class EtherParser {
   detectTargetLanguage(source) {
     const lower = source.toLowerCase()
     
+    const targetMatch = source.match(/\/\/\s*cible\s*:\s*(\w+)/i)
+    if (targetMatch) {
+      const target = targetMatch[1].toLowerCase()
+      const langMap = {
+        'js': 'js', 'javascript': 'js',
+        'css': 'css', 'style': 'css',
+        'html': 'html', 'page': 'html',
+        'ts': 'ts', 'typescript': 'ts',
+        'react': 'react', 'jsx': 'react',
+        'php': 'php',
+        'python': 'python', 'py': 'python',
+        'ruby': 'ruby', 'rb': 'ruby',
+        'sql': 'sql',
+        'node': 'node', 'nodejs': 'node',
+        'graphql': 'graphql', 'gql': 'graphql'
+      }
+      if (langMap[target]) {
+        return langMap[target]
+      }
+    }
+    
     if (/^\s*(document|page|<!doctype|<html|tete|corps|entete|navigation|section|article)/m.test(lower)) {
       return 'html'
     }
@@ -1250,7 +1298,7 @@ class EtherParser {
       'cesure': 'wbr',
       'noscript': 'noscript',
       'sans script': 'noscript',
-      'carte': 'map',
+      
       'zone': 'area'
     }
     
@@ -1506,6 +1554,47 @@ class EtherParser {
     }
   }
 
+  parseFunctionExpression(lang) {
+    this.advance()
+    
+    let name = null
+    const nameToken = this.current()
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER && !this.check(TokenType.LPAREN)) {
+      const nextToken = this.peek(1)
+      if (nextToken && nextToken.type === TokenType.LPAREN) {
+        name = nameToken.value
+        this.advance()
+      }
+    }
+    
+    const params = []
+    if (this.match(TokenType.LPAREN)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
+        const param = this.parseParameter(lang)
+        if (param) {
+          params.push(param)
+        }
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    let returnType = null
+    if (this.match(TokenType.COLON) || this.match(TokenType.ARROW)) {
+      returnType = this.parseType(lang)
+    }
+    
+    this.skipNewlines()
+    const body = this.parseBlock(lang)
+    
+    return {
+      type: 'FunctionExpression',
+      name: name,
+      params: params,
+      returnType: returnType,
+      body: body
+    }
+  }
+
   parseParameter(lang) {
     const nameToken = this.current()
     if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
@@ -1590,7 +1679,7 @@ class EtherParser {
       'jamais': 'never',
       'inconnu': 'unknown',
       'symbole': 'symbol',
-      'date': 'Date',
+      
       'promesse': 'Promise',
       'fonction': 'Function'
     }
@@ -1640,8 +1729,10 @@ class EtherParser {
     }
   }
 
-  parseConditional(lang) {
-    const keyword = this.advance()
+  parseConditional(lang, isElseIf = false) {
+    if (!isElseIf) {
+      this.advance()
+    }
     const condition = this.parseExpression(lang)
     
     this.skipNewlines()
@@ -1652,7 +1743,7 @@ class EtherParser {
     
     if (this.matchValue('sinon')) {
       if (this.matchValue('si')) {
-        alternate = this.parseConditional(lang)
+        alternate = this.parseConditional(lang, true)
       } else {
         this.skipNewlines()
         alternate = this.parseBlock(lang)
@@ -1844,17 +1935,42 @@ class EtherParser {
   parseBlock(lang) {
     const body = []
     
-    if (this.match(TokenType.INDENT)) {
+    const hasBrace = this.match(TokenType.LBRACE)
+    this.skipNewlines()
+    
+    if (hasBrace) {
+      this.match(TokenType.INDENT)
+    }
+    
+    if (hasBrace || this.match(TokenType.INDENT)) {
       while (!this.isAtEnd()) {
+        this.skipNewlines()
+        
         const current = this.current()
         
         if (current && current.type === TokenType.DEDENT) {
           this.advance()
+          if (hasBrace) {
+            this.skipNewlines()
+            this.match(TokenType.RBRACE)
+          }
           break
         }
         
+        if (hasBrace && current && current.type === TokenType.RBRACE) {
+          this.advance()
+          break
+        }
+        
+        if (current && (current.type === TokenType.INDENT || current.type === TokenType.NEWLINE)) {
+          this.advance()
+          continue
+        }
+        
         const statement = this.parseStatement(lang)
-        if (statement) {
+        if (statement && statement.expression?.value !== null) {
+          body.push(statement)
+        } else if (statement && statement.type !== 'ExpressionStatement') {
           body.push(statement)
         }
         
@@ -1924,17 +2040,16 @@ class EtherParser {
     let left = this.parseComparison(lang)
     
     while (true) {
-      const compoundOp = this.tryMatchCompoundOperator()
-      if (compoundOp === '===' || compoundOp === '!==') {
+      if (this.matchValue('strictement egal') || this.matchValue('strictement égal')) {
         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')) {
+        left = { type: 'BinaryExpression', operator: '===', left, right }
+      } else if (this.matchValue('strictement different') || this.matchValue('strictement différent')) {
+        const right = this.parseComparison(lang)
+        left = { type: 'BinaryExpression', operator: '!==', left, right }
+      } else if (this.match(TokenType.DOUBLE_EQUALS) || this.matchValue('egal') || this.matchValue('egale') || this.matchValue('égal')) {
         const right = this.parseComparison(lang)
         left = { type: 'BinaryExpression', operator: '===', left, right }
-      } else if (this.match(TokenType.NOT_EQUALS) || this.matchValue('different')) {
+      } else if (this.match(TokenType.NOT_EQUALS) || this.matchValue('different') || this.matchValue('différent')) {
         const right = this.parseComparison(lang)
         left = { type: 'BinaryExpression', operator: '!==', left, right }
       } else {
@@ -1949,25 +2064,18 @@ class EtherParser {
     let left = this.parseAdditive(lang)
     
     while (true) {
-      const compoundOp = this.tryMatchCompoundOperator()
-      if (compoundOp === '>=' || compoundOp === '<=') {
+      if (this.matchValue('superieur ou egal') || this.matchValue('supérieur ou égal') || this.match(TokenType.GTE)) {
         const right = this.parseAdditive(lang)
-        left = { type: 'BinaryExpression', operator: compoundOp, left, right }
-        continue
-      }
-      
-      if (this.match(TokenType.LT) || this.matchValue('inferieur')) {
+        left = { type: 'BinaryExpression', operator: '>=', left, right }
+      } else if (this.matchValue('inferieur ou egal') || this.matchValue('inférieur ou égal') || this.match(TokenType.LTE)) {
+        const right = this.parseAdditive(lang)
+        left = { type: 'BinaryExpression', operator: '<=', left, right }
+      } else if (this.match(TokenType.LT) || this.matchValue('inferieur') || this.matchValue('inférieur')) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '<', left, right }
-      } else if (this.match(TokenType.GT) || this.matchValue('superieur')) {
+      } else if (this.match(TokenType.GT) || this.matchValue('superieur') || this.matchValue('supérieur')) {
         const right = this.parseAdditive(lang)
         left = { type: 'BinaryExpression', operator: '>', left, right }
-      } else if (this.match(TokenType.LTE)) {
-        const right = this.parseAdditive(lang)
-        left = { type: 'BinaryExpression', operator: '<=', left, right }
-      } else if (this.match(TokenType.GTE)) {
-        const right = this.parseAdditive(lang)
-        left = { type: 'BinaryExpression', operator: '>=', left, right }
       } else {
         break
       }
@@ -2026,6 +2134,14 @@ class EtherParser {
       return { type: 'UnaryExpression', operator: '-', operand }
     }
     
+    if (this.matchValue('nouveau') || this.matchValue('new')) {
+      const callee = this.parseCall(lang)
+      if (callee.type === 'CallExpression') {
+        return { type: 'NewExpression', callee: callee.callee, arguments: callee.arguments }
+      }
+      return { type: 'NewExpression', callee, arguments: [] }
+    }
+    
     return this.parseCall(lang)
   }
 
@@ -2078,6 +2194,10 @@ class EtherParser {
     if (token.type === TokenType.IDENTIFIER) {
       const value = token.value.toLowerCase()
       
+      if (value === 'fonction' || value === 'function') {
+        return this.parseFunctionExpression(lang)
+      }
+      
       if (value === 'vrai' || value === 'true') {
         this.advance()
         return { type: 'Literal', value: true }
@@ -2141,26 +2261,32 @@ class EtherParser {
       this.match(TokenType.COMMA)
     }
     
-    return { type: 'ArrayLiteral', elements }
+    return { type: 'ArrayExpression', elements }
   }
 
   parseObjectLiteral(lang) {
     this.expect(TokenType.LBRACE)
     const properties = []
     
-    while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
+    this.skipWhitespace()
+    
+    while (!this.isAtEnd() && !this.check(TokenType.RBRACE)) {
+      this.skipWhitespace()
+      
       const keyToken = this.current()
-      if (!keyToken) break
+      if (!keyToken || keyToken.type === TokenType.RBRACE) break
       
       let key
       if (keyToken.type === TokenType.STRING) {
-        key = keyToken.value.replace(/^["']|["']$/g, '')
+        const keyValue = keyToken.value.replace(/^["']|["']$/g, '')
+        key = { type: 'Literal', value: keyValue }
+        this.advance()
       } else if (keyToken.type === TokenType.IDENTIFIER) {
-        key = keyToken.value
+        key = { type: 'Identifier', name: keyToken.value }
+        this.advance()
       } else {
         break
       }
-      this.advance()
       
       this.match(TokenType.COLON) || this.match(TokenType.EQUALS)
       
@@ -2168,9 +2294,21 @@ class EtherParser {
       properties.push({ key, value })
       
       this.match(TokenType.COMMA)
+      this.skipWhitespace()
     }
     
-    return { type: 'ObjectLiteral', properties }
+    this.match(TokenType.RBRACE)
+    
+    return { type: 'ObjectExpression', properties }
+  }
+  
+  skipWhitespace() {
+    while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
+  }
+  
+  check(type) {
+    const token = this.current()
+    return token && token.type === type
   }
 
   parseSQLProgram() {

package/generators/js-generator.js

@@ -5,6 +5,9 @@ class JSGenerator {
     this.i18n = null
     this.indent = 0
     this.output = ''
+    this.keywordMap = {}
+    this.methodMap = {}
+    this.builtinMap = {}
     
     if (i18nPath) {
       this.loadI18n(i18nPath)
@@ -18,10 +21,6 @@ class JSGenerator {
   }
 
   buildMaps() {
-    this.keywordMap = {}
-    this.methodMap = {}
-    this.builtinMap = {}
-    
     if (!this.i18n) return
 
     const addToMap = (map, section) => {
@@ -326,6 +325,8 @@ class JSGenerator {
         break
       case 'ArrowFunctionExpression':
         return this.generateArrowFunction(node)
+      case 'FunctionExpression':
+        return this.generateFunctionExpression(node)
       case 'CallExpression':
         return this.generateCallExpression(node)
       case 'MemberExpression':
@@ -407,6 +408,28 @@ class JSGenerator {
     this.writeLine('')
   }
 
+  generateFunctionExpression(node) {
+    const async = node.async ? 'async ' : ''
+    const generator = node.generator ? '*' : ''
+    const name = node.name ? this.translate(node.name) : ''
+    const params = (node.params || []).map(p => this.generateParameter(p)).join(', ')
+    
+    const bodyStatements = node.body?.body || []
+    const bodyCode = bodyStatements.map(stmt => {
+      const savedOutput = this.output
+      const savedIndent = this.indent
+      this.output = ''
+      this.indent = 1
+      this.generateNode(stmt)
+      const stmtCode = this.output.trim()
+      this.output = savedOutput
+      this.indent = savedIndent
+      return stmtCode
+    }).join('\n    ')
+    
+    return `${async}function${generator}${name ? ' ' + name : ''}(${params}) {\n    ${bodyCode}\n  }`
+  }
+
   generateParameter(node) {
     if (!node) return ''
     if (typeof node === 'string') return node
@@ -466,17 +489,22 @@ class JSGenerator {
     this.writeLine('')
   }
 
-  generateIfStatement(node) {
-    const test = this.generateNode(node.test)
-    this.writeLine(`if (${test}) {`)
+  generateIfStatement(node, isElseIf = false) {
+    const test = this.generateNode(node.test || node.condition)
+    
+    if (isElseIf) {
+      this.writeLine(`} else if (${test}) {`)
+    } else {
+      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() + ' else '
-        this.generateIfStatement(node.alternate)
+        this.generateIfStatement(node.alternate, true)
       } else {
         this.writeLine('} else {')
         this.indent++

package/i18n/i18n-js.json

@@ -158,14 +158,6 @@
       "zh": "正则表达式",
       "ja": "正規表現"
     },
-    "carte": {
-      "fr": "carte",
-      "en": "map",
-      "es": "mapa",
-      "ru": "карта",
-      "zh": "映射",
-      "ja": "マップ"
-    },
     "ensemble": {
       "fr": "ensemble",
       "en": "set",
@@ -2787,4 +2779,4 @@
       "ja": "レングス"
     }
   }
-}
+}

package/package.json

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