ether-code 0.1.5 → 0.1.7

package/generators/ruby-generator.js

@@ -5,8 +5,6 @@ class RubyGenerator {
     this.i18n = null
     this.indent = 0
     this.output = ''
-    this.keywordMap = {}
-    this.methodMap = {}
     
     if (i18nPath) {
       this.loadI18n(i18nPath)
@@ -58,7 +56,7 @@ class RubyGenerator {
       'jusqua': 'until',
       'faire': 'do',
       'fin': 'end',
-      'définir': 'def',
+      'definir': 'def',
       'classe': 'class',
       'module': 'module',
       'retourner': 'return',
@@ -79,13 +77,13 @@ class RubyGenerator {
       'nul': 'nil',
       'soi': 'self',
       'super': 'super',
-      'hériter': '<',
+      'heriter': '<',
       'inclure': 'include',
       'etendre': 'extend',
       'prepend': 'prepend',
       'public': 'public',
-      'privé': 'private',
-      'protégé': 'protected',
+      'prive': 'private',
+      'protege': 'protected',
       'attr lecteur': 'attr_reader',
       'attr ecrivain': 'attr_writer',
       'attr accesseur': 'attr_accessor',
@@ -106,7 +104,7 @@ class RubyGenerator {
       'pousser': 'push',
       'retirer': 'pop',
       'decaler': 'shift',
-      'insérer début': 'unshift',
+      'inserer debut': 'unshift',
       'ajouter': '<<',
       'concatener': '+',
       'aplatir': 'flatten',
@@ -117,11 +115,11 @@ class RubyGenerator {
       'chaque': 'each',
       'mapper': 'map',
       'collecter': 'collect',
-      'sélectionner': 'select',
+      'selectionner': 'select',
       'rejeter': 'reject',
       'trouver': 'find',
       'detecter': 'detect',
-      'réduire': 'reduce',
+      'reduire': 'reduce',
       'injecter': 'inject',
       'tout': 'all?',
       'quelconque': 'any?',
@@ -140,7 +138,7 @@ class RubyGenerator {
       'majuscules': 'upcase',
       'minuscules': 'downcase',
       'capitaliser': 'capitalize',
-      'inverser chaîne': 'reverse',
+      'inverser chaine': 'reverse',
       'supprimer espaces': 'strip',
       'supprimer gauche': 'lstrip',
       'supprimer droite': 'rstrip',
@@ -154,21 +152,21 @@ class RubyGenerator {
       'contient': 'include?',
       'vers entier': 'to_i',
       'vers flottant': 'to_f',
-      'vers chaîne': 'to_s',
+      'vers chaine': 'to_s',
       'vers symbole': 'to_sym',
       'vers tableau': 'to_a',
       'vers hash': 'to_h',
-      'clés': 'keys',
+      'cles': 'keys',
       'valeurs': 'values',
       'fusionner': 'merge',
       'chercher': 'fetch',
       'stocker': 'store',
-      'supprimer clé': 'delete',
-      'a clé': 'has_key?',
+      'supprimer cle': 'delete',
+      'a cle': 'has_key?',
       'a valeur': 'has_value?',
       'ouvrir': 'open',
       'lire': 'read',
-      'écrire': 'write',
+      'ecrire': 'write',
       'fermer': 'close',
       'chaque ligne': 'each_line',
       'lire lignes': 'readlines',
@@ -181,13 +179,13 @@ class RubyGenerator {
       'aujourdhui': 'Date.today',
       'analyser date': 'parse',
       'formater': 'strftime',
-      'année': 'year',
+      'annee': 'year',
       'mois': 'month',
       'jour': 'day',
       'heure': 'hour',
       'minute': 'min',
       'seconde': 'sec',
-      'aléatoire': 'rand',
+      'aleatoire': 'rand',
       'absolu': 'abs',
       'arrondir': 'round',
       'plancher': 'floor',
@@ -198,7 +196,7 @@ class RubyGenerator {
       'proc': 'Proc.new',
       'appeler': 'call',
       'bloc donne': 'block_given?',
-      'méthode': 'method',
+      'methode': 'method',
       'envoyer': 'send',
       'repondre a': 'respond_to?',
       'instance de': 'is_a?',
@@ -232,22 +230,13 @@ class RubyGenerator {
 
     if (Array.isArray(ast)) {
       for (const node of ast) {
-        const result = this.generateNode(node)
-        if (result !== undefined && result !== '' && this.output === '') {
-          return result
-        }
+        this.generateNode(node)
       }
     } else if (ast && ast.type) {
-      const result = this.generateNode(ast)
-      if (result !== undefined && result !== '' && this.output === '') {
-        return result
-      }
+      this.generateNode(ast)
     } else if (ast && ast.body) {
       for (const node of ast.body) {
-        const result = this.generateNode(node)
-        if (result !== undefined && result !== '' && this.output === '') {
-          return result
-        }
+        this.generateNode(node)
       }
     }
 
@@ -258,6 +247,15 @@ class RubyGenerator {
     if (!node) return ''
 
     switch (node.type) {
+      case 'Program':
+        if (node.body) {
+          for (const child of node.body) {
+            this.generateNode(child)
+          }
+        }
+        return
+      case 'VariableDeclaration':
+        return this.generateVariableDeclaration(node)
       case 'RequireStatement':
         return this.generateRequire(node)
       case 'ModuleDeclaration':
@@ -265,7 +263,6 @@ class RubyGenerator {
       case 'ClassDeclaration':
         return this.generateClass(node)
       case 'MethodDef':
-      case 'MethodDeclaration':
       case 'FunctionDeclaration':
         return this.generateMethod(node)
       case 'IfStatement':
@@ -285,7 +282,6 @@ class RubyGenerator {
       case 'TimesStatement':
         return this.generateTimes(node)
       case 'BeginRescue':
-      case 'BeginStatement':
       case 'TryStatement':
         return this.generateBeginRescue(node)
       case 'ReturnStatement':
@@ -319,71 +315,16 @@ class RubyGenerator {
       case 'SymbolExpression':
         return this.generateSymbol(node)
       case 'StringInterpolation':
-      case 'InterpolatedString':
         return this.generateStringInterpolation(node)
-      case 'BinaryExpression':
-        return this.generateBinary(node)
-      case 'UnaryExpression':
-        return this.generateUnary(node)
-      case 'TernaryExpression':
-      case 'ConditionalExpression':
-        return this.generateTernary(node)
-      case 'MethodCallExpression':
-        return this.generateMethodCall(node)
       case 'Identifier':
         return this.translateIdentifier(node.name)
       case 'Literal':
         return this.generateLiteral(node)
       default:
-        if (node.name && !node.type) {
-          return this.translateIdentifier(node.name)
-        }
         return ''
     }
   }
 
-  generateBinary(node) {
-    const left = this.generateNode(node.left)
-    const right = this.generateNode(node.right)
-    const op = node.operator
-    return `${left} ${op} ${right}`
-  }
-
-  generateUnary(node) {
-    const operand = this.generateNode(node.operand || node.argument)
-    const op = node.operator
-    if (op === 'not' || op === '!') {
-      return `${op === 'not' ? 'not ' : '!'}${operand}`
-    }
-    return `${op}${operand}`
-  }
-
-  generateTernary(node) {
-    const test = this.generateNode(node.test)
-    const consequent = this.generateNode(node.consequent)
-    const alternate = this.generateNode(node.alternate)
-    return `${test} ? ${consequent} : ${alternate}`
-  }
-
-  generateMethodCall(node) {
-    const receiver = this.generateNode(node.receiver)
-    const method = this.translate(node.method)
-    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
-    const safe = node.safe ? '&.' : '.'
-    const argsStr = args ? `(${args})` : ''
-    
-    if (node.block) {
-      const blockParams = node.block.params ? '|' + node.block.params.map(p => p.name || p).join(', ') + '|' : ''
-      const blockBody = (node.block.body || []).map(s => this.generateNode(s)).join('; ')
-      if (node.block.body?.length === 1) {
-        return `${receiver}${safe}${method}${argsStr} { ${blockParams} ${blockBody} }`
-      }
-      return `${receiver}${safe}${method}${argsStr} do ${blockParams}\n${blockBody}\nend`
-    }
-    
-    return `${receiver}${safe}${method}${argsStr}`
-  }
-
   generateRequire(node) {
     const path = typeof node.path === 'string' ? node.path : this.generateNode(node.path)
     const method = node.relative ? 'require_relative' : 'require'
@@ -423,21 +364,24 @@ class RubyGenerator {
       this.writeLine('')
     }
     
-    const attrs = node.attrs || node.attributes || []
-    if (attrs.length > 0) {
-      const accessors = attrs.filter(a => a.accessor === 'accessor')
-      const readers = attrs.filter(a => a.accessor === 'reader')
-      const writers = attrs.filter(a => a.accessor === 'writer')
+    if (node.attrs) {
+      const readers = node.attrs.filter(a => a.access === 'read' || a.access === 'accessor')
+      const writers = node.attrs.filter(a => a.access === 'write')
+      const accessors = node.attrs.filter(a => a.access === 'accessor')
       
       if (accessors.length > 0) {
         this.writeLine(`attr_accessor ${accessors.map(a => ':' + a.name).join(', ')}`)
       }
-      if (readers.length > 0) {
-        this.writeLine(`attr_reader ${readers.map(a => ':' + a.name).join(', ')}`)
+      if (readers.length > 0 && !accessors.some(a => readers.includes(a))) {
+        const onlyReaders = readers.filter(r => !accessors.includes(r))
+        if (onlyReaders.length > 0) {
+          this.writeLine(`attr_reader ${onlyReaders.map(a => ':' + a.name).join(', ')}`)
+        }
       }
       if (writers.length > 0) {
         this.writeLine(`attr_writer ${writers.map(a => ':' + a.name).join(', ')}`)
       }
+      this.writeLine('')
     }
     
     const body = node.body?.body || node.body || []
@@ -447,6 +391,7 @@ class RubyGenerator {
     
     this.indent--
     this.writeLine('end')
+    this.writeLine('')
   }
 
   generateMethod(node) {
@@ -459,7 +404,7 @@ class RubyGenerator {
     
     const body = node.body?.body || node.body || []
     if (body.length === 0) {
-      this.writeLine('nil')
+      this.writeLine('# TODO')
     } else {
       for (const stmt of (Array.isArray(body) ? body : [body])) {
         this.generateNode(stmt)
@@ -468,6 +413,7 @@ class RubyGenerator {
     
     this.indent--
     this.writeLine('end')
+    this.writeLine('')
   }
 
   generateParams(params) {
@@ -692,9 +638,8 @@ class RubyGenerator {
 
     for (const handler of node.rescues || node.handlers || (node.handler ? [node.handler] : [])) {
       let rescueLine = 'rescue'
-      const exceptions = handler.exceptions || (handler.exception ? [handler.exception] : []) || (handler.type ? [handler.type] : [])
-      if (exceptions.length > 0) {
-        rescueLine += ' ' + exceptions.join(', ')
+      if (handler.exception || handler.type) {
+        rescueLine += ' ' + (handler.exception || handler.type)
         if (handler.variable || handler.name) {
           rescueLine += ' => ' + (handler.variable || handler.name)
         }
@@ -775,13 +720,22 @@ class RubyGenerator {
     return `${target} ${op} ${value}`
   }
 
+  generateVariableDeclaration(node) {
+    const name = node.name || (node.id && node.id.name) || 'var'
+    const value = node.init ? this.generateNode(node.init) : 'nil'
+    this.writeLine(`${name} = ${value}`)
+  }
+
   generateCall(node) {
     const receiver = node.receiver ? this.generateNode(node.receiver) + '.' : ''
-    const callee = node.callee?.name || node.callee || node.method || ''
-    const method = typeof callee === 'string' ? this.translate(callee) : this.generateNode(callee)
+    const method = this.translate(node.method || node.callee?.name || node.callee || '')
     const args = (node.arguments || node.args || []).map(a => this.generateNode(a))
     
-    let result = `${receiver}${method}(${args.join(', ')})`
+    let result = `${receiver}${method}`
+    
+    if (args.length > 0 || node.parens) {
+      result += `(${args.join(', ')})`
+    }
     
     if (node.block) {
       result += ' ' + this.generateBlock(node.block)
@@ -821,22 +775,10 @@ class RubyGenerator {
 
   generateHash(node) {
     const pairs = (node.pairs || node.properties || []).map(p => {
-      let key, value
-      
-      if (p.key?.type === 'SymbolExpression') {
-        key = (p.key.name || p.key.value) + ':'
-      } else if (typeof p.key === 'string' || p.key?.type === 'Literal') {
-        const keyVal = typeof p.key === 'string' ? p.key : p.key.value
-        if (typeof keyVal === 'string' && !keyVal.includes(' ')) {
-          key = this.generateNode(p.key) + ' =>'
-        } else {
-          key = this.generateNode(p.key) + ' =>'
-        }
-      } else {
-        key = this.generateNode(p.key) + ' =>'
-      }
-      
-      value = this.generateNode(p.value)
+      const key = p.key?.type === 'SymbolExpression' || p.symbol
+        ? this.generateNode(p.key) + ':'
+        : this.generateNode(p.key) + ' =>'
+      const value = this.generateNode(p.value)
       return `${key} ${value}`
     })
     return `{ ${pairs.join(', ')} }`
@@ -858,8 +800,6 @@ class RubyGenerator {
     for (const part of node.parts || []) {
       if (part.type === 'Literal' || typeof part === 'string') {
         result += typeof part === 'string' ? part : part.value
-      } else if (part.expression) {
-        result += '#{' + this.generateNode(part.expression) + '}'
       } else {
         result += '#{' + this.generateNode(part) + '}'
       }

package/generators/sql-generator.js

@@ -5,9 +5,6 @@ class SQLGenerator {
     this.i18n = null
     this.indent = 0
     this.output = ''
-    this.keywordMap = {}
-    this.functionMap = {}
-    this.typeMap = {}
     
     if (i18nPath) {
       this.loadI18n(i18nPath)
@@ -49,7 +46,7 @@ class SQLGenerator {
 
   translateGeneric(word) {
     const translations = {
-      'sélectionner': 'SELECT',
+      'selectionner': 'SELECT',
       'depuis': 'FROM',
       'ou': 'WHERE',
       'et': 'AND',
@@ -74,15 +71,15 @@ class SQLGenerator {
       'union': 'UNION',
       'intersection': 'INTERSECT',
       'difference': 'EXCEPT',
-      'insérer': 'INSERT',
+      'inserer': 'INSERT',
       'dans': 'INTO',
       'valeurs': 'VALUES',
       'mettre a jour': 'UPDATE',
-      'définir': 'SET',
+      'definir': 'SET',
       'supprimer': 'DELETE',
-      'créer': 'CREATE',
+      'creer': 'CREATE',
       'table': 'TABLE',
-      'base de données': 'DATABASE',
+      'base de donnees': 'DATABASE',
       'schema': 'SCHEMA',
       'index': 'INDEX',
       'vue': 'VIEW',
@@ -93,16 +90,16 @@ class SQLGenerator {
       'vers': 'TO',
       'colonne': 'COLUMN',
       'contrainte': 'CONSTRAINT',
-      'clé primaire': 'PRIMARY KEY',
-      'clé etrangere': 'FOREIGN KEY',
-      'références': 'REFERENCES',
+      'cle primaire': 'PRIMARY KEY',
+      'cle etrangere': 'FOREIGN KEY',
+      'references': 'REFERENCES',
       'unique': 'UNIQUE',
       'non nul': 'NOT NULL',
-      'par défaut': 'DEFAULT',
+      'par defaut': 'DEFAULT',
       'verification': 'CHECK',
       'cascade': 'CASCADE',
-      'définir null': 'SET NULL',
-      'définir défaut': 'SET DEFAULT',
+      'definir null': 'SET NULL',
+      'definir defaut': 'SET DEFAULT',
       'restreindre': 'RESTRICT',
       'pas action': 'NO ACTION',
       'avec': 'WITH',
@@ -134,7 +131,7 @@ class SQLGenerator {
       'heure actuelle': 'CURRENT_TIME',
       'horodatage actuel': 'CURRENT_TIMESTAMP',
       'extraire': 'EXTRACT',
-      'année': 'YEAR',
+      'annee': 'YEAR',
       'mois': 'MONTH',
       'jour': 'DAY',
       'heure': 'HOUR',
@@ -145,7 +142,7 @@ class SQLGenerator {
       'majuscules': 'UPPER',
       'minuscules': 'LOWER',
       'supprimer espaces': 'TRIM',
-      'sous chaîne': 'SUBSTRING',
+      'sous chaine': 'SUBSTRING',
       'remplacer': 'REPLACE',
       'position': 'POSITION',
       'arrondir': 'ROUND',
@@ -163,12 +160,12 @@ class SQLGenerator {
       'decimal': 'DECIMAL',
       'numerique': 'NUMERIC',
       'reel': 'REAL',
-      'double précision': 'DOUBLE PRECISION',
+      'double precision': 'DOUBLE PRECISION',
       'texte': 'TEXT',
-      'caractère variable': 'VARCHAR',
-      'caractère': 'CHAR',
-      'booléen': 'BOOLEAN',
-      'type date': 'DATE',
+      'caractere variable': 'VARCHAR',
+      'caractere': 'CHAR',
+      'booleen': 'BOOLEAN',
+      'date': 'DATE',
       'temps': 'TIME',
       'horodatage': 'TIMESTAMP',
       'intervalle': 'INTERVAL',
@@ -185,11 +182,12 @@ class SQLGenerator {
       'transaction': 'TRANSACTION',
       'accorder': 'GRANT',
       'revoquer': 'REVOKE',
+      'a': 'TO',
       'sur table': 'ON',
-      'type role': 'ROLE',
+      'role': 'ROLE',
       'utilisateur': 'USER',
       'public': 'PUBLIC',
-      'sélection': 'SELECT',
+      'selection': 'SELECT',
       'insertion': 'INSERT',
       'mise a jour': 'UPDATE',
       'suppression': 'DELETE',
@@ -201,7 +199,7 @@ class SQLGenerator {
     }
 
     const lower = word.toLowerCase()
-    return translations[lower] || word
+    return translations[lower] || word.toUpperCase()
   }
 
   generate(ast) {
@@ -230,6 +228,11 @@ class SQLGenerator {
     if (!node) return ''
 
     switch (node.type) {
+      case 'SQLProgram':
+        if (node.statements) {
+          return node.statements.map(stmt => this.generateNode(stmt)).filter(s => s).join(';\n\n') + ';'
+        }
+        return ''
       case 'SelectStatement':
         return this.generateSelect(node)
       case 'InsertStatement':
@@ -273,8 +276,8 @@ class SQLGenerator {
     const columns = (node.columns || ['*']).map(c => this.generateColumn(c))
     sql += ' ' + columns.join(', ')
 
-    if (node.from) {
-      sql += '\nFROM ' + this.generateFrom(node.from)
+    if (node.from || node.table) {
+      sql += '\nFROM ' + this.generateFrom(node.from || node.table)
     }
 
     if (node.joins && node.joins.length > 0) {
@@ -299,11 +302,11 @@ class SQLGenerator {
       sql += '\nORDER BY ' + node.orderBy.map(o => this.generateOrderBy(o)).join(', ')
     }
 
-    if (node.limit !== undefined) {
+    if (node.limit != null) {
       sql += '\nLIMIT ' + node.limit
     }
 
-    if (node.offset !== undefined) {
+    if (node.offset != null) {
       sql += ' OFFSET ' + node.offset
     }
 
@@ -447,8 +450,6 @@ class SQLGenerator {
     if (typeof expr === 'number') return String(expr)
     if (typeof expr === 'boolean') return expr ? 'TRUE' : 'FALSE'
     if (typeof expr === 'string') {
-      if (expr.toLowerCase() === 'true') return 'TRUE'
-      if (expr.toLowerCase() === 'false') return 'FALSE'
       if (expr.startsWith("'") || expr.startsWith('"')) return expr
       if (/^\d+$/.test(expr)) return expr
       return this.translate(expr)
@@ -727,11 +728,11 @@ class SQLGenerator {
     
     switch (constraint.type?.toLowerCase()) {
       case 'primary key':
-      case 'clé primaire':
+      case 'cle primaire':
         sql += 'PRIMARY KEY (' + constraint.columns.join(', ') + ')'
         break
       case 'foreign key':
-      case 'clé etrangere':
+      case 'cle etrangere':
         sql += 'FOREIGN KEY (' + constraint.columns.join(', ') + ')'
         sql += ' REFERENCES ' + constraint.references.table
         sql += '(' + constraint.references.columns.join(', ') + ')'
@@ -777,8 +778,8 @@ class SQLGenerator {
         case 'alter':
         case 'modifier':
           let alter = 'ALTER COLUMN ' + action.column
-          if (action.dataType || action.newType) {
-            alter += ' TYPE ' + this.translate(action.dataType || action.newType)
+          if (action.type) {
+            alter += ' TYPE ' + this.translate(action.type)
           }
           if (action.setDefault !== undefined) {
             alter += ' SET DEFAULT ' + this.generateExpression(action.setDefault)
@@ -860,9 +861,6 @@ class SQLGenerator {
   }
 
   generateCreateView(node) {
-    const savedOutput = this.output
-    this.output = ''
-    
     let sql = 'CREATE'
     
     if (node.orReplace) sql += ' OR REPLACE'
@@ -875,11 +873,9 @@ class SQLGenerator {
     }
     
     sql += ' AS\n'
-    this.output = ''
-    this.generateSelect(node.select)
-    sql += this.output.trim()
+    sql += this.generateSelect(node.select)
 
-    this.output = savedOutput + sql
+    this.output += sql
     return sql
   }
 
@@ -932,9 +928,6 @@ class SQLGenerator {
   }
 
   generateWith(node) {
-    const savedOutput = this.output
-    this.output = ''
-    
     let sql = 'WITH '
     
     if (node.recursive) sql += 'RECURSIVE '
@@ -945,40 +938,26 @@ class SQLGenerator {
         cteSql += ' (' + cte.columns.join(', ') + ')'
       }
       cteSql += ' AS (\n'
-      this.output = ''
-      this.generateSelect(cte.query)
-      cteSql += this.output.trim()
+      cteSql += this.generateSelect(cte.query)
       cteSql += '\n)'
       return cteSql
     })
     
     sql += ctes.join(',\n')
     sql += '\n'
-    this.output = ''
-    this.generateSelect(node.select)
-    sql += this.output.trim()
+    sql += this.generateSelect(node.select)
 
-    this.output = savedOutput + sql
+    this.output += sql
     return sql
   }
 
   generateUnion(node) {
-    const savedOutput = this.output
-    this.output = ''
-    
     const queries = node.queries || [node.left, node.right]
     const type = node.all ? 'UNION ALL' : 'UNION'
     
-    const parts = []
-    for (const q of queries) {
-      this.output = ''
-      this.generateSelect(q)
-      parts.push(this.output.trim())
-    }
+    const sql = queries.map(q => this.generateSelect(q)).join('\n' + type + '\n')
     
-    const sql = parts.join('\n' + type + '\n')
-    
-    this.output = savedOutput + sql
+    this.output += sql
     return sql
   }
 }