ether-code 0.1.0

package/generators/ruby-generator.js

@@ -0,0 +1,904 @@
+const fs = require('fs')
+
+class RubyGenerator {
+  constructor(i18nPath = null) {
+    this.i18n = null
+    this.indent = 0
+    this.output = ''
+    this.keywordMap = {}
+    this.methodMap = {}
+    
+    if (i18nPath) {
+      this.loadI18n(i18nPath)
+    }
+  }
+
+  loadI18n(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    this.i18n = JSON.parse(content)
+    this.buildMaps()
+  }
+
+  buildMaps() {
+    this.keywordMap = {}
+    
+    if (!this.i18n) return
+
+    const addToMap = (map, section) => {
+      if (!section) return
+      for (const [key, translations] of Object.entries(section)) {
+        if (translations && translations.fr && translations.ruby) {
+          map[translations.fr.toLowerCase()] = translations.ruby
+        }
+      }
+    }
+
+    for (const sectionName of Object.keys(this.i18n)) {
+      addToMap(this.keywordMap, this.i18n[sectionName])
+    }
+  }
+
+  translate(word) {
+    if (!word) return ''
+    const lower = word.toLowerCase()
+    return this.keywordMap[lower] || this.translateGeneric(word)
+  }
+
+  translateGeneric(word) {
+    const translations = {
+      'si': 'if',
+      'sinon': 'else',
+      'sinon si': 'elsif',
+      'sauf si': 'unless',
+      'selon': 'case',
+      'quand': 'when',
+      'pour': 'for',
+      'dans': 'in',
+      'tant que': 'while',
+      'jusqua': 'until',
+      'faire': 'do',
+      'fin': 'end',
+      'définir': 'def',
+      'classe': 'class',
+      'module': 'module',
+      'retourner': 'return',
+      'produire': 'yield',
+      'sortir': 'break',
+      'continuer': 'next',
+      'refaire': 'redo',
+      'reessayer': 'retry',
+      'lever': 'raise',
+      'sauver': 'rescue',
+      'assurer': 'ensure',
+      'commencer': 'begin',
+      'et': 'and',
+      'ou': 'or',
+      'non': 'not',
+      'vrai': 'true',
+      'faux': 'false',
+      'nul': 'nil',
+      'soi': 'self',
+      'super': 'super',
+      'hériter': '<',
+      'inclure': 'include',
+      'etendre': 'extend',
+      'prepend': 'prepend',
+      'public': 'public',
+      'privé': 'private',
+      'protégé': 'protected',
+      'attr lecteur': 'attr_reader',
+      'attr ecrivain': 'attr_writer',
+      'attr accesseur': 'attr_accessor',
+      'initialiser': 'initialize',
+      'nouveau': 'new',
+      'requiert': 'require',
+      'requiert relatif': 'require_relative',
+      'charger': 'load',
+      'afficher': 'puts',
+      'imprimer': 'print',
+      'obtenir': 'gets',
+      'longueur': 'length',
+      'taille': 'size',
+      'vide': 'empty?',
+      'inclut': 'include?',
+      'premier': 'first',
+      'dernier': 'last',
+      'pousser': 'push',
+      'retirer': 'pop',
+      'decaler': 'shift',
+      'insérer début': 'unshift',
+      'ajouter': '<<',
+      'concatener': '+',
+      'aplatir': 'flatten',
+      'compacter': 'compact',
+      'unique': 'uniq',
+      'trier': 'sort',
+      'inverser': 'reverse',
+      'chaque': 'each',
+      'mapper': 'map',
+      'collecter': 'collect',
+      'sélectionner': 'select',
+      'rejeter': 'reject',
+      'trouver': 'find',
+      'detecter': 'detect',
+      'réduire': 'reduce',
+      'injecter': 'inject',
+      'tout': 'all?',
+      'quelconque': 'any?',
+      'aucun': 'none?',
+      'compter': 'count',
+      'grouper par': 'group_by',
+      'trier par': 'sort_by',
+      'min par': 'min_by',
+      'max par': 'max_by',
+      'avec index': 'each_with_index',
+      'avec objet': 'each_with_object',
+      'fois': 'times',
+      'jusqua iter': 'upto',
+      'descendant': 'downto',
+      'etape': 'step',
+      'majuscules': 'upcase',
+      'minuscules': 'downcase',
+      'capitaliser': 'capitalize',
+      'inverser chaîne': 'reverse',
+      'supprimer espaces': 'strip',
+      'supprimer gauche': 'lstrip',
+      'supprimer droite': 'rstrip',
+      'diviser': 'split',
+      'joindre': 'join',
+      'remplacer': 'gsub',
+      'remplacer premier': 'sub',
+      'correspondre': 'match',
+      'commence par': 'start_with?',
+      'finit par': 'end_with?',
+      'contient': 'include?',
+      'vers entier': 'to_i',
+      'vers flottant': 'to_f',
+      'vers chaîne': 'to_s',
+      'vers symbole': 'to_sym',
+      'vers tableau': 'to_a',
+      'vers hash': 'to_h',
+      'clés': 'keys',
+      'valeurs': 'values',
+      'fusionner': 'merge',
+      'chercher': 'fetch',
+      'stocker': 'store',
+      'supprimer clé': 'delete',
+      'a clé': 'has_key?',
+      'a valeur': 'has_value?',
+      'ouvrir': 'open',
+      'lire': 'read',
+      'écrire': 'write',
+      'fermer': 'close',
+      'chaque ligne': 'each_line',
+      'lire lignes': 'readlines',
+      'existe': 'exist?',
+      'fichier': 'file?',
+      'dossier': 'directory?',
+      'supprimer fichier': 'delete',
+      'renommer': 'rename',
+      'maintenant': 'Time.now',
+      'aujourdhui': 'Date.today',
+      'analyser date': 'parse',
+      'formater': 'strftime',
+      'année': 'year',
+      'mois': 'month',
+      'jour': 'day',
+      'heure': 'hour',
+      'minute': 'min',
+      'seconde': 'sec',
+      'aléatoire': 'rand',
+      'absolu': 'abs',
+      'arrondir': 'round',
+      'plancher': 'floor',
+      'plafond': 'ceil',
+      'racine': 'sqrt',
+      'puissance': '**',
+      'lambda': 'lambda',
+      'proc': 'Proc.new',
+      'appeler': 'call',
+      'bloc donne': 'block_given?',
+      'méthode': 'method',
+      'envoyer': 'send',
+      'repondre a': 'respond_to?',
+      'instance de': 'is_a?',
+      'sorte de': 'kind_of?',
+      'classe de': 'class',
+      'methodes': 'methods',
+      'variables instance': 'instance_variables',
+      'variables classe': 'class_variables',
+      'constantes': 'constants',
+      'geler': 'freeze',
+      'gele': 'frozen?',
+      'dupliquer': 'dup',
+      'cloner': 'clone',
+      'inspecter': 'inspect',
+      'symbole': ':',
+      'hash rocket': '=>',
+      'range': '..',
+      'range exclusif': '...',
+      'splat': '*',
+      'double splat': '**',
+      'bloc arg': '&'
+    }
+
+    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()
+  }
+
+  generateNode(node) {
+    if (!node) return ''
+
+    switch (node.type) {
+      case 'RequireStatement':
+        return this.generateRequire(node)
+      case 'ModuleDeclaration':
+        return this.generateModule(node)
+      case 'ClassDeclaration':
+        return this.generateClass(node)
+      case 'MethodDef':
+      case 'MethodDeclaration':
+      case 'FunctionDeclaration':
+        return this.generateMethod(node)
+      case 'IfStatement':
+        return this.generateIf(node)
+      case 'UnlessStatement':
+        return this.generateUnless(node)
+      case 'CaseStatement':
+        return this.generateCase(node)
+      case 'WhileStatement':
+        return this.generateWhile(node)
+      case 'UntilStatement':
+        return this.generateUntil(node)
+      case 'ForStatement':
+        return this.generateFor(node)
+      case 'EachStatement':
+        return this.generateEach(node)
+      case 'TimesStatement':
+        return this.generateTimes(node)
+      case 'BeginRescue':
+      case 'BeginStatement':
+      case 'TryStatement':
+        return this.generateBeginRescue(node)
+      case 'ReturnStatement':
+        return this.generateReturn(node)
+      case 'YieldStatement':
+        return this.generateYield(node)
+      case 'RaiseStatement':
+        return this.generateRaise(node)
+      case 'BreakStatement':
+        this.writeLine('break')
+        return
+      case 'NextStatement':
+        this.writeLine('next')
+        return
+      case 'ExpressionStatement':
+        return this.generateExpressionStatement(node)
+      case 'AssignmentExpression':
+        return this.generateAssignment(node)
+      case 'CallExpression':
+        return this.generateCall(node)
+      case 'BlockExpression':
+        return this.generateBlock(node)
+      case 'LambdaExpression':
+        return this.generateLambda(node)
+      case 'ArrayExpression':
+        return this.generateArray(node)
+      case 'HashExpression':
+        return this.generateHash(node)
+      case 'RangeExpression':
+        return this.generateRange(node)
+      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'
+    this.writeLine(`${method} '${path}'`)
+  }
+
+  generateModule(node) {
+    const name = node.name
+    this.writeLine(`module ${name}`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+    this.writeLine('end')
+    this.writeLine('')
+  }
+
+  generateClass(node) {
+    const name = node.name || node.id?.name
+    let declaration = `class ${name}`
+    
+    if (node.superclass || node.extends) {
+      declaration += ` < ${node.superclass || node.extends}`
+    }
+    
+    this.writeLine(declaration)
+    this.indent++
+    
+    if (node.includes) {
+      for (const inc of node.includes) {
+        this.writeLine(`include ${inc}`)
+      }
+      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 (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 (writers.length > 0) {
+        this.writeLine(`attr_writer ${writers.map(a => ':' + a.name).join(', ')}`)
+      }
+    }
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+    this.writeLine('end')
+  }
+
+  generateMethod(node) {
+    const name = this.translate(node.name || node.id?.name || '')
+    const params = this.generateParams(node.params || node.args || [])
+    const selfMethod = node.static || node.classMethod ? 'self.' : ''
+    
+    this.writeLine(`def ${selfMethod}${name}${params ? '(' + params + ')' : ''}`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    if (body.length === 0) {
+      this.writeLine('nil')
+    } else {
+      for (const stmt of (Array.isArray(body) ? body : [body])) {
+        this.generateNode(stmt)
+      }
+    }
+    
+    this.indent--
+    this.writeLine('end')
+  }
+
+  generateParams(params) {
+    return params.map(p => {
+      let param = ''
+      
+      if (p.splat) param += '*'
+      if (p.doubleSplat) param += '**'
+      if (p.block) param += '&'
+      
+      param += this.translate(p.name || p.arg || p)
+      
+      if (p.default !== undefined) {
+        param += ' = ' + this.generateNode(p.default)
+      }
+      
+      return param
+    }).join(', ')
+  }
+
+  generateIf(node) {
+    const test = this.generateNode(node.test)
+    
+    if (node.modifier) {
+      const body = this.generateNode(node.body)
+      this.writeLine(`${body} if ${test}`)
+      return
+    }
+    
+    this.writeLine(`if ${test}`)
+    this.indent++
+    
+    const consequent = node.consequent?.body || node.consequent || node.body || []
+    for (const stmt of (Array.isArray(consequent) ? consequent : [consequent])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+
+    if (node.alternate || node.elsif) {
+      const alt = node.alternate || node.elsif
+      if (alt.type === 'IfStatement') {
+        const altTest = this.generateNode(alt.test)
+        this.writeLine(`elsif ${altTest}`)
+        this.indent++
+        const altBody = alt.consequent?.body || alt.consequent || alt.body || []
+        for (const stmt of (Array.isArray(altBody) ? altBody : [altBody])) {
+          this.generateNode(stmt)
+        }
+        this.indent--
+        if (alt.alternate) {
+          this.generateNode({ type: 'IfStatement', alternate: alt.alternate })
+        } else {
+          this.writeLine('end')
+        }
+      } else {
+        this.writeLine('else')
+        this.indent++
+        const altBody = Array.isArray(alt) ? alt : (alt.body || [alt])
+        for (const stmt of altBody) {
+          this.generateNode(stmt)
+        }
+        this.indent--
+        this.writeLine('end')
+      }
+    } else {
+      this.writeLine('end')
+    }
+  }
+
+  generateUnless(node) {
+    const test = this.generateNode(node.test)
+    
+    if (node.modifier) {
+      const body = this.generateNode(node.body)
+      this.writeLine(`${body} unless ${test}`)
+      return
+    }
+    
+    this.writeLine(`unless ${test}`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+    
+    if (node.else) {
+      this.writeLine('else')
+      this.indent++
+      for (const stmt of node.else) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+    
+    this.writeLine('end')
+  }
+
+  generateCase(node) {
+    const expr = node.expression ? ' ' + this.generateNode(node.expression) : ''
+    this.writeLine(`case${expr}`)
+    
+    for (const when of node.whens || []) {
+      const conditions = (when.conditions || [when.condition]).map(c => this.generateNode(c))
+      this.writeLine(`when ${conditions.join(', ')}`)
+      this.indent++
+      for (const stmt of when.body || []) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+    
+    if (node.else) {
+      this.writeLine('else')
+      this.indent++
+      for (const stmt of node.else) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+    
+    this.writeLine('end')
+  }
+
+  generateWhile(node) {
+    const test = this.generateNode(node.test)
+    
+    if (node.modifier) {
+      const body = this.generateNode(node.body)
+      this.writeLine(`${body} while ${test}`)
+      return
+    }
+    
+    this.writeLine(`while ${test}`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+    this.writeLine('end')
+  }
+
+  generateUntil(node) {
+    const test = this.generateNode(node.test)
+    
+    this.writeLine(`until ${test}`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+    this.writeLine('end')
+  }
+
+  generateFor(node) {
+    const variable = this.generateNode(node.variable || node.target)
+    const iterable = this.generateNode(node.iterable || node.iter)
+    
+    this.writeLine(`for ${variable} in ${iterable}`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+    this.writeLine('end')
+  }
+
+  generateEach(node) {
+    const collection = this.generateNode(node.collection)
+    const blockParams = (node.params || ['item']).join(', ')
+    
+    this.writeLine(`${collection}.each do |${blockParams}|`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+    this.writeLine('end')
+  }
+
+  generateTimes(node) {
+    const count = this.generateNode(node.count)
+    const variable = node.variable || 'i'
+    
+    this.writeLine(`${count}.times do |${variable}|`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+    this.writeLine('end')
+  }
+
+  generateBeginRescue(node) {
+    this.writeLine('begin')
+    this.indent++
+    
+    const tryBody = node.body?.body || node.body || node.block?.body || []
+    for (const stmt of (Array.isArray(tryBody) ? tryBody : [tryBody])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+
+    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.variable || handler.name) {
+          rescueLine += ' => ' + (handler.variable || handler.name)
+        }
+      }
+      this.writeLine(rescueLine)
+      this.indent++
+      
+      const handlerBody = handler.body?.body || handler.body || []
+      for (const stmt of (Array.isArray(handlerBody) ? handlerBody : [handlerBody])) {
+        this.generateNode(stmt)
+      }
+      
+      this.indent--
+    }
+
+    if (node.else) {
+      this.writeLine('else')
+      this.indent++
+      for (const stmt of node.else) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+
+    if (node.ensure || node.finally) {
+      this.writeLine('ensure')
+      this.indent++
+      const ensureBody = node.ensure || node.finally?.body || node.finally || []
+      for (const stmt of (Array.isArray(ensureBody) ? ensureBody : [ensureBody])) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+
+    this.writeLine('end')
+  }
+
+  generateReturn(node) {
+    if (node.value || node.argument) {
+      const value = this.generateNode(node.value || node.argument)
+      this.writeLine(`return ${value}`)
+    } else {
+      this.writeLine('return')
+    }
+  }
+
+  generateYield(node) {
+    if (node.arguments && node.arguments.length > 0) {
+      const args = node.arguments.map(a => this.generateNode(a)).join(', ')
+      this.writeLine(`yield ${args}`)
+    } else {
+      this.writeLine('yield')
+    }
+  }
+
+  generateRaise(node) {
+    if (node.exception) {
+      const exc = this.generateNode(node.exception)
+      if (node.message) {
+        this.writeLine(`raise ${exc}, ${this.generateNode(node.message)}`)
+      } else {
+        this.writeLine(`raise ${exc}`)
+      }
+    } else {
+      this.writeLine('raise')
+    }
+  }
+
+  generateExpressionStatement(node) {
+    const expr = this.generateNode(node.expression)
+    this.writeLine(expr)
+  }
+
+  generateAssignment(node) {
+    const target = this.generateNode(node.left || node.target)
+    const value = this.generateNode(node.right || node.value)
+    const op = node.operator || '='
+    return `${target} ${op} ${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 args = (node.arguments || node.args || []).map(a => this.generateNode(a))
+    
+    let result = `${receiver}${method}(${args.join(', ')})`
+    
+    if (node.block) {
+      result += ' ' + this.generateBlock(node.block)
+    }
+    
+    return result
+  }
+
+  generateBlock(node) {
+    const params = node.params ? `|${node.params.join(', ')}|` : ''
+    const body = node.body?.body || node.body || []
+    
+    if (body.length === 1 && !body[0].type?.includes('Statement')) {
+      return `{ ${params} ${this.generateNode(body[0])} }`
+    }
+    
+    let result = `do ${params}\n`
+    this.indent++
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      result += this.getIndent() + this.generateNode(stmt) + '\n'
+    }
+    this.indent--
+    result += this.getIndent() + 'end'
+    return result
+  }
+
+  generateLambda(node) {
+    const params = node.params ? `(${this.generateParams(node.params)})` : ''
+    const body = this.generateNode(node.body)
+    return `-> ${params} { ${body} }`
+  }
+
+  generateArray(node) {
+    const elements = (node.elements || []).map(e => this.generateNode(e))
+    return `[${elements.join(', ')}]`
+  }
+
+  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)
+      return `${key} ${value}`
+    })
+    return `{ ${pairs.join(', ')} }`
+  }
+
+  generateRange(node) {
+    const start = this.generateNode(node.start)
+    const end = this.generateNode(node.end)
+    const op = node.exclusive ? '...' : '..'
+    return `${start}${op}${end}`
+  }
+
+  generateSymbol(node) {
+    return ':' + (node.name || node.value)
+  }
+
+  generateStringInterpolation(node) {
+    let result = '"'
+    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) + '}'
+      }
+    }
+    result += '"'
+    return result
+  }
+
+  translateIdentifier(name) {
+    if (!name) return ''
+    
+    if (name.startsWith('@')) return name
+    if (name.startsWith('@@')) return name
+    if (name.startsWith('$')) return name
+    if (name.startsWith(':')) return name
+    
+    return this.translate(name)
+  }
+
+  generateLiteral(node) {
+    if (node.value === null || node.value === undefined) return 'nil'
+    if (node.value === true) return 'true'
+    if (node.value === false) return 'false'
+    if (typeof node.value === 'string') {
+      if (node.symbol) return ':' + node.value
+      return `"${node.value.replace(/"/g, '\\"')}"`
+    }
+    return String(node.value)
+  }
+
+  writeLine(text) {
+    this.output += this.getIndent() + text + '\n'
+  }
+
+  getIndent() {
+    return '  '.repeat(this.indent)
+  }
+}
+
+module.exports = {
+  RubyGenerator
+}