ether-code 0.1.7 → 0.1.9

package/cli/compiler.js

@@ -2,6 +2,7 @@ const fs = require('fs')
 const path = require('path')
 
 const { EtherLexer } = require('../lexer/ether-lexer')
+const { EtherParser } = require('../ether-parser')
 
 const { CSSGenerator } = require('../generators/css-generator')
 const { HTMLGenerator } = require('../generators/html-generator')
@@ -67,9 +68,10 @@ class EtherCompiler {
     
     this.lexer = new EtherLexer()
     this.generators = {}
-    this.parsers = {}
+    this.parser = null
     
     this.initGenerators()
+    this.initParser()
   }
 
   initGenerators() {
@@ -86,6 +88,11 @@ class EtherCompiler {
     }
   }
 
+  initParser() {
+    const i18nDir = path.join(__dirname, '..', 'i18n')
+    this.parser = new EtherParser(i18nDir)
+  }
+
   normalizeTarget(target) {
     const mappings = {
       javascript: 'js',
@@ -127,58 +134,7 @@ class EtherCompiler {
 
   parse(content, target) {
     const normalizedTarget = this.normalizeTarget(target)
-    
-    if (normalizedTarget === 'html') {
-      return this.parseHTML(content)
-    }
-    
-    const lexer = new EtherLexer(content)
-    const tokens = lexer.tokenize()
-    
-    try {
-      const ParserClass = this.loadParser(normalizedTarget)
-      if (ParserClass) {
-        const parser = new ParserClass(tokens, this.config)
-        return parser.parse()
-      }
-    } catch (err) {
-    }
-    
-    return this.buildGenericAST(tokens, target)
-  }
-
-  parseHTML(content) {
-    const { HTMLParser } = require('../parsers/html-parser')
-    const i18nPath = path.join(__dirname, '..', 'i18n', 'i18n-html.json')
-    const parser = new HTMLParser(i18nPath)
-    return parser.parse(content)
-  }
-
-  loadParser(target) {
-    try {
-      const parserPath = path.join(__dirname, '..', 'parsers', `${target}-parser.js`)
-      if (fs.existsSync(parserPath)) {
-        const module = require(parserPath)
-        const className = `${target.charAt(0).toUpperCase()}${target.slice(1)}Parser`
-        return module[className] || module.default || Object.values(module)[0]
-      }
-    } catch (err) {
-    }
-    return null
-  }
-
-  buildGenericAST(tokens, target) {
-    return {
-      type: 'Program',
-      target,
-      body: tokens.map(token => ({
-        type: 'Token',
-        tokenType: token.type,
-        value: token.value,
-        line: token.line,
-        column: token.column
-      }))
-    }
+    return this.parser.parse(content, normalizedTarget)
   }
 
   generate(ast, target) {

package/ether-compiler.js

@@ -0,0 +1,190 @@
+const fs = require('fs')
+const path = require('path')
+const { EtherLexer, TokenType } = require('./ether-lexer')
+const { EtherParser } = require('./ether-parser')
+const { CSSGenerator } = require('./generators/css-generator')
+const { HTMLGenerator } = require('./generators/html-generator')
+const { JSGenerator } = require('./generators/js-generator')
+const { TSGenerator } = require('./generators/ts-generator')
+const { PHPGenerator } = require('./generators/php-generator')
+const { PythonGenerator } = require('./generators/python-generator')
+const { RubyGenerator } = require('./generators/ruby-generator')
+const { SQLGenerator } = require('./generators/sql-generator')
+const { NodeGenerator } = require('./generators/node-generator')
+const { ReactGenerator } = require('./generators/react-generator')
+const { GraphQLGenerator } = require('./generators/graphql-generator')
+
+class EtherCompiler {
+  constructor(options = {}) {
+    this.i18nDir = options.i18nDir || path.join(__dirname, 'i18n')
+    this.parser = new EtherParser({ i18nDir: this.i18nDir })
+    this.generators = {}
+    this.initGenerators()
+  }
+
+  initGenerators() {
+    const generatorConfigs = [
+      { name: 'css', Generator: CSSGenerator, i18n: 'i18n-css.json' },
+      { name: 'html', Generator: HTMLGenerator, i18n: 'i18n-html.json' },
+      { name: 'js', Generator: JSGenerator, i18n: 'i18n-js.json' },
+      { name: 'ts', Generator: TSGenerator, i18n: 'i18n-ts.json' },
+      { name: 'php', Generator: PHPGenerator, i18n: 'i18n-php.json' },
+      { name: 'python', Generator: PythonGenerator, i18n: 'i18n-python.json' },
+      { name: 'ruby', Generator: RubyGenerator, i18n: 'i18n-ruby.json' },
+      { name: 'sql', Generator: SQLGenerator, i18n: 'i18n-sql.json' },
+      { name: 'node', Generator: NodeGenerator, i18n: 'i18n-node.json' },
+      { name: 'react', Generator: ReactGenerator, i18n: 'i18n-react.json' },
+      { name: 'graphql', Generator: GraphQLGenerator, i18n: 'i18n-graphql.json' }
+    ]
+
+    for (const config of generatorConfigs) {
+      try {
+        const i18nPath = path.join(this.i18nDir, config.i18n)
+        if (fs.existsSync(i18nPath)) {
+          this.generators[config.name] = new config.Generator(i18nPath)
+        } else {
+          this.generators[config.name] = new config.Generator()
+        }
+      } catch (e) {
+        this.generators[config.name] = null
+      }
+    }
+
+    this.generators.javascript = this.generators.js
+    this.generators.typescript = this.generators.ts
+    this.generators.py = this.generators.python
+    this.generators.rb = this.generators.ruby
+    this.generators.nodejs = this.generators.node
+    this.generators.jsx = this.generators.react
+    this.generators.gql = this.generators.graphql
+  }
+
+  compile(source, targetLang = 'auto') {
+    const ast = this.parser.parse(source, targetLang)
+    const lang = this.detectLanguage(ast, targetLang, source)
+    const generator = this.generators[lang]
+
+    if (!generator) {
+      throw new Error(`Générateur non disponible pour: ${lang}`)
+    }
+
+    return generator.generate(ast)
+  }
+
+  detectLanguage(ast, targetLang, source) {
+    if (targetLang && targetLang !== 'auto') {
+      return targetLang.toLowerCase()
+    }
+
+    if (ast.type === 'StyleSheet') return 'css'
+    if (ast.type === 'Document') return 'html'
+    if (ast.type === 'SQLProgram') return 'sql'
+    if (ast.type === 'GraphQLProgram') return 'graphql'
+    if (ast.lang) return ast.lang
+
+    return this.parser.detectTargetLanguage(source)
+  }
+
+  compileFile(inputPath, outputPath = null, targetLang = 'auto') {
+    const source = fs.readFileSync(inputPath, 'utf-8')
+    const result = this.compile(source, targetLang)
+
+    if (outputPath) {
+      const dir = path.dirname(outputPath)
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true })
+      }
+      fs.writeFileSync(outputPath, result)
+    }
+
+    return result
+  }
+
+  getExtension(lang) {
+    const extensions = {
+      css: '.css',
+      html: '.html',
+      js: '.js',
+      javascript: '.js',
+      ts: '.ts',
+      typescript: '.ts',
+      php: '.php',
+      python: '.py',
+      py: '.py',
+      ruby: '.rb',
+      rb: '.rb',
+      sql: '.sql',
+      node: '.js',
+      nodejs: '.js',
+      react: '.jsx',
+      jsx: '.jsx',
+      graphql: '.graphql',
+      gql: '.graphql'
+    }
+    return extensions[lang] || '.txt'
+  }
+
+  parse(source, targetLang = 'auto') {
+    return this.parser.parse(source, targetLang)
+  }
+
+  generate(ast, lang) {
+    const generator = this.generators[lang]
+    if (!generator) {
+      throw new Error(`Générateur non disponible pour: ${lang}`)
+    }
+    return generator.generate(ast)
+  }
+
+  tokenize(source) {
+    const lexer = new EtherLexer(source)
+    return lexer.tokenize()
+  }
+
+  inferTargetFromFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase()
+    const extMap = {
+      '.eth': 'auto',
+      '.ether': 'auto',
+      '.ecss': 'css',
+      '.ehtml': 'html',
+      '.ejs': 'js',
+      '.ets': 'ts',
+      '.ephp': 'php',
+      '.epy': 'python',
+      '.erb': 'ruby',
+      '.esql': 'sql',
+      '.egql': 'graphql',
+      '.ejsx': 'react'
+    }
+    return extMap[ext] || 'auto'
+  }
+}
+
+function compile(source, targetLang = 'auto', options = {}) {
+  const compiler = new EtherCompiler(options)
+  return compiler.compile(source, targetLang)
+}
+
+function compileFile(inputPath, outputPath = null, targetLang = 'auto', options = {}) {
+  const compiler = new EtherCompiler(options)
+  return compiler.compileFile(inputPath, outputPath, targetLang)
+}
+
+function parse(source, targetLang = 'auto', options = {}) {
+  const compiler = new EtherCompiler(options)
+  return compiler.parse(source, targetLang)
+}
+
+function tokenize(source, options = {}) {
+  const lexer = new EtherLexer(source, options)
+  return lexer.tokenize()
+}
+
+module.exports = {
+  EtherCompiler,
+  compile,
+  compileFile,
+  parse,
+  tokenize
+}