ether-code 0.5.1 → 0.5.4

package/cli/compiler.js

@@ -68,6 +68,7 @@ class EtherCompiler {
     
     this.generators = {}
     this.parser = null
+    this.resolvedIncludes = new Set()
     
     this.initGenerators()
     this.initParser()
@@ -110,10 +111,14 @@ class EtherCompiler {
   compileFile(filePath) {
     const content = fs.readFileSync(filePath, 'utf-8')
     const fileName = path.basename(filePath, '.eth')
+    const basePath = path.dirname(path.resolve(filePath))
     
     const target = this.detectTarget(content, filePath)
     const ast = this.parse(content, target)
-    const code = this.generate(ast, target)
+    
+    const resolvedAst = this.resolveIncludes(ast, basePath, target)
+    
+    const code = this.generate(resolvedAst, target)
     
     const extension = this.getExtension(target)
     const outputPath = fileName + extension
@@ -128,6 +133,86 @@ class EtherCompiler {
     }
   }
 
+  resolveIncludes(ast, basePath, targetLang) {
+    const self = this
+    
+    const visit = (node) => {
+      if (!node || typeof node !== 'object') return node
+      
+      if (node.type === 'Include' && node.path) {
+        let includePath = node.path
+        
+        if (!includePath.endsWith('.eth') && !includePath.endsWith('.ether')) {
+          includePath = includePath.replace(/\.(html|php|js|css)$/i, '.eth')
+          if (!includePath.endsWith('.eth')) {
+            includePath += '.eth'
+          }
+        }
+        
+        const fullPath = path.resolve(basePath, includePath)
+        
+        if (self.resolvedIncludes.has(fullPath)) {
+          console.warn(`Inclusion circulaire détectée: ${fullPath}`)
+          return null
+        }
+        
+        if (!fs.existsSync(fullPath)) {
+          console.warn(`Fichier inclus non trouvé: ${fullPath}`)
+          return {
+            type: 'Comment',
+            content: `Fichier non trouvé: ${node.path}`
+          }
+        }
+        
+        self.resolvedIncludes.add(fullPath)
+        
+        const includeSource = fs.readFileSync(fullPath, 'utf-8')
+        const includeDir = path.dirname(fullPath)
+        
+        const normalizedTarget = self.normalizeTarget(targetLang)
+        const includeAst = self.parser.parse(includeSource, normalizedTarget)
+        
+        const resolvedIncludeAst = self.resolveIncludes(includeAst, includeDir, targetLang)
+        
+        self.resolvedIncludes.delete(fullPath)
+        
+        if (resolvedIncludeAst.children && Array.isArray(resolvedIncludeAst.children)) {
+          return resolvedIncludeAst.children
+        }
+        
+        if (resolvedIncludeAst.body && Array.isArray(resolvedIncludeAst.body)) {
+          return resolvedIncludeAst.body
+        }
+        
+        return resolvedIncludeAst
+      }
+      
+      if (node.children && Array.isArray(node.children)) {
+        node.children = node.children.flatMap(child => {
+          const result = visit(child)
+          if (Array.isArray(result)) {
+            return result
+          }
+          return result ? [result] : []
+        })
+      }
+      
+      if (node.body && Array.isArray(node.body)) {
+        node.body = node.body.flatMap(child => {
+          const result = visit(child)
+          if (Array.isArray(result)) {
+            return result
+          }
+          return result ? [result] : []
+        })
+      }
+      
+      return node
+    }
+    
+    return visit(ast)
+  }
+
   parse(content, target) {
     const normalizedTarget = this.normalizeTarget(target)
     return this.parser.parse(content, normalizedTarget)

package/cli/ether.js

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

package/ether-compiler.js

@@ -17,8 +17,10 @@ const { GraphQLGenerator } = require('./generators/graphql-generator')
 class EtherCompiler {
   constructor(options = {}) {
     this.i18nDir = options.i18nDir || path.join(__dirname, 'i18n')
+    this.basePath = options.basePath || process.cwd()
     this.parser = new EtherParser({ i18nDir: this.i18nDir })
     this.generators = {}
+    this.resolvedIncludes = new Set()
     this.initGenerators()
   }
 
@@ -59,16 +61,94 @@ class EtherCompiler {
     this.generators.gql = this.generators.graphql
   }
 
-  compile(source, targetLang = 'auto') {
+  compile(source, targetLang = 'auto', basePath = null) {
     const ast = this.parser.parse(source, targetLang)
     const lang = this.detectLanguage(ast, targetLang, source)
+    
+    const resolvedAst = this.resolveIncludes(ast, basePath || this.basePath, lang)
+    
     const generator = this.generators[lang]
 
     if (!generator) {
       throw new Error(`Générateur non disponible pour: ${lang}`)
     }
 
-    return generator.generate(ast)
+    return generator.generate(resolvedAst)
+  }
+
+  resolveIncludes(ast, basePath, targetLang) {
+    const self = this
+    
+    const visit = (node) => {
+      if (!node || typeof node !== 'object') return node
+      
+      if (node.type === 'Include' && node.path) {
+        let includePath = node.path
+        
+        if (!includePath.endsWith('.eth') && !includePath.endsWith('.ether')) {
+          includePath = includePath.replace(/\.(html|php|js|css)$/i, '.eth')
+          if (!includePath.endsWith('.eth')) {
+            includePath += '.eth'
+          }
+        }
+        
+        const fullPath = path.resolve(basePath, includePath)
+        
+        if (self.resolvedIncludes.has(fullPath)) {
+          console.warn(`Inclusion circulaire détectée: ${fullPath}`)
+          return null
+        }
+        
+        if (!fs.existsSync(fullPath)) {
+          console.warn(`Fichier inclus non trouvé: ${fullPath}`)
+          return {
+            type: 'Comment',
+            content: `Fichier non trouvé: ${node.path}`
+          }
+        }
+        
+        self.resolvedIncludes.add(fullPath)
+        
+        const includeSource = fs.readFileSync(fullPath, 'utf-8')
+        const includeDir = path.dirname(fullPath)
+        
+        const includeAst = self.parser.parse(includeSource, targetLang)
+        
+        const resolvedIncludeAst = self.resolveIncludes(includeAst, includeDir, targetLang)
+        
+        self.resolvedIncludes.delete(fullPath)
+        
+        if (resolvedIncludeAst.children && Array.isArray(resolvedIncludeAst.children)) {
+          return resolvedIncludeAst.children
+        }
+        
+        return resolvedIncludeAst
+      }
+      
+      if (node.children && Array.isArray(node.children)) {
+        node.children = node.children.flatMap(child => {
+          const result = visit(child)
+          if (Array.isArray(result)) {
+            return result
+          }
+          return result ? [result] : []
+        })
+      }
+      
+      if (node.body && Array.isArray(node.body)) {
+        node.body = node.body.flatMap(child => {
+          const result = visit(child)
+          if (Array.isArray(result)) {
+            return result
+          }
+          return result ? [result] : []
+        })
+      }
+      
+      return node
+    }
+    
+    return visit(ast)
   }
 
   detectLanguage(ast, targetLang, source) {
@@ -87,7 +167,8 @@ class EtherCompiler {
 
   compileFile(inputPath, outputPath = null, targetLang = 'auto') {
     const source = fs.readFileSync(inputPath, 'utf-8')
-    const result = this.compile(source, targetLang)
+    const basePath = path.dirname(path.resolve(inputPath))
+    const result = this.compile(source, targetLang, basePath)
 
     if (outputPath) {
       const dir = path.dirname(outputPath)
@@ -187,4 +268,4 @@ module.exports = {
   compileFile,
   parse,
   tokenize
-}
+}

package/ether-parser.js

@@ -1179,6 +1179,43 @@ class EtherParser {
     let tagName = tagToken.value.toLowerCase()
     this.advance()
     
+    const includeKeywords = ['inclure', 'requiert', 'include', 'require', 'importer']
+    if (includeKeywords.includes(tagName)) {
+      let includePath = null
+      
+      if (this.current() && this.current().type === TokenType.COLON) {
+        this.advance()
+      }
+      
+      const pathToken = this.current()
+      if (pathToken && pathToken.type === TokenType.STRING) {
+        includePath = pathToken.value.replace(/^["']|["']$/g, '')
+        this.advance()
+      } else if (pathToken && pathToken.type === TokenType.IDENTIFIER) {
+        let pathParts = [pathToken.value]
+        this.advance()
+        while (this.current() && (this.current().type === TokenType.SLASH || this.current().type === TokenType.DOT || this.current().type === TokenType.IDENTIFIER)) {
+          if (this.current().type === TokenType.SLASH) {
+            pathParts.push('/')
+          } else if (this.current().type === TokenType.DOT) {
+            pathParts.push('.')
+          } else {
+            pathParts.push(this.current().value)
+          }
+          this.advance()
+        }
+        includePath = pathParts.join('')
+      }
+      
+      this.skipNewlines()
+      
+      return {
+        type: 'Include',
+        path: includePath,
+        resolved: false
+      }
+    }
+    
     const nextToken = this.current()
     if ((tagName === 'titre' || tagName === 'heading') && nextToken && (nextToken.type === TokenType.NUMBER || nextToken.type === TokenType.INTEGER)) {
       const num = parseInt(nextToken.value)
@@ -2245,8 +2282,31 @@ class EtherParser {
   }
 
   parseImport(lang) {
+    const importToken = this.current()
+    const importKeyword = importToken ? importToken.value.toLowerCase() : ''
     this.advance()
     
+    const includeKeywords = ['inclure', 'requiert', 'include', 'require']
+    
+    if (this.current() && this.current().type === TokenType.COLON) {
+      this.advance()
+    }
+    
+    const nextToken = this.current()
+    if (includeKeywords.includes(importKeyword) && nextToken && nextToken.type === TokenType.STRING) {
+      const includePath = nextToken.value.replace(/^["']|["']$/g, '')
+      this.advance()
+      
+      if (includePath.endsWith('.eth') || includePath.endsWith('.ether') || 
+          !includePath.includes('.') || includePath.match(/\.(html|php|js|css)$/i)) {
+        return {
+          type: 'Include',
+          path: includePath,
+          resolved: false
+        }
+      }
+    }
+    
     const imports = []
     let source = null
     let defaultImport = null
@@ -2277,6 +2337,20 @@ class EtherParser {
     } else if (token && token.type === TokenType.IDENTIFIER) {
       defaultImport = token.value
       this.advance()
+    } else if (token && token.type === TokenType.STRING) {
+      source = token.value.replace(/^["']|["']$/g, '')
+      this.advance()
+      
+      if (includeKeywords.includes(importKeyword)) {
+        if (source.endsWith('.eth') || source.endsWith('.ether') || 
+            !source.includes('.') || source.match(/\.(html|php|js|css)$/i)) {
+          return {
+            type: 'Include',
+            path: source,
+            resolved: false
+          }
+        }
+      }
     }
     
     if (this.matchValue('depuis') || this.matchValue('de') || this.matchValue('from')) {

package/generators/html-generator.js

@@ -414,6 +414,9 @@ class HTMLGenerator {
       case 'doctype':
         this.generateDoctype(node)
         break
+      case 'Include':
+        this.generateInclude(node)
+        break
       default:
         if (node.tag || node.tagName) {
           this.generateElement(node)
@@ -591,6 +594,16 @@ class HTMLGenerator {
     this.output += '<!DOCTYPE html>\n'
   }
 
+  generateInclude(node) {
+    if (node.resolved && node.children) {
+      for (const child of node.children) {
+        this.generateNode(child)
+      }
+    } else {
+      this.writeLine(`<!-- Include non résolu: ${node.path || 'inconnu'} -->`)
+    }
+  }
+
   writeLine(text) {
     const indentation = '  '.repeat(this.indent)
     this.output += indentation + text + '\n'