papagaio 0.2.3 → 0.2.7

package/src/papagaio.js

@@ -1,319 +1,308 @@
-export class Papagaio {
-  maxRecursion = 512;
-  #counter = { value: 0, unique: 0 };
-  open = "{";
-  close = "}";
-  sigil = "$";
-  keywords = { pattern: "pattern", context: "context" };
-  content = "";
-
-  constructor() {
-    this.#counter.value = 0;
-    this.#counter.unique = 0;
-  }
+// https://github.com/jardimdanificado/papagaio
 
-  process(input) {
-    this.content = input;
-    let src = input, last = null, iter = 0;
-    const pending = () => {
-      const rCtx = new RegExp(`\\b${this.keywords.context}\\s*\\${this.open}`, "g");
-      const rPat = new RegExp(`\\b${this.keywords.pattern}\\s*\\${this.open}`, "g");
-      return rCtx.test(src) || rPat.test(src);
-    };
-    while (src !== last && iter < this.maxRecursion) {
-      iter++;
-      last = src;
-      src = this.#procContext(src);
-      const [patterns, s2] = this.#collectPatterns(src);
-      src = s2;
-      src = this.#applyPatterns(src, patterns);
-      if (!pending()) break;
+function processContext(papagaio, src) {
+  const ctxRe = new RegExp(`\\b${papagaio.symbols.context}\\s*\\${papagaio.symbols.open}`, "g");
+  let m, matches = [];
+  while ((m = ctxRe.exec(src)) !== null)
+    matches.push({ idx: m.index, pos: m.index + m[0].length - 1 });
+  for (let j = matches.length - 1; j >= 0; j--) {
+    const x = matches[j], [content, posAfter] = extractBlock(papagaio, src, x.pos);
+    if (!content.trim()) {
+      src = src.slice(0, x.idx) + src.slice(posAfter);
+      continue;
     }
-    return this.content = src, src;
+    const proc = papagaio.process(content);
+    let left = src.substring(0, x.idx), right = src.substring(posAfter);
+    let prefix = left.endsWith("\n") ? "\n" : "";
+    if (prefix) left = left.slice(0, -1);
+    src = left + prefix + proc + right;
   }
+  return src;
+}
 
-  #procContext(src) {
-    const ctxRe = new RegExp(`\\b${this.keywords.context}\\s*\\${this.open}`, "g");
-    let m, matches = [];
-    while ((m = ctxRe.exec(src)) !== null)
-      matches.push({ idx: m.index, pos: m.index + m[0].length - 1 });
-    for (let j = matches.length - 1; j >= 0; j--) {
-      const x = matches[j], [content, posAfter] = this.#extractBlock(src, x.pos);
-      if (!content.trim()) {
-        src = src.slice(0, x.idx) + src.slice(posAfter);
-        continue;
+function extractBlock(papagaio, src, openPos, openDelim = papagaio.symbols.open, closeDelim = papagaio.symbols.close) {
+  let i = openPos;
+  if (openDelim.length > 1 || closeDelim.length > 1) {
+    if (src.substring(i, i + openDelim.length) === openDelim) {
+      i += openDelim.length;
+      const innerStart = i;
+      let d = 0;
+      while (i < src.length) {
+        if (src.substring(i, i + openDelim.length) === openDelim) {
+          d++;
+          i += openDelim.length;
+        } else if (src.substring(i, i + closeDelim.length) === closeDelim) {
+          if (d === 0) return [src.substring(innerStart, i), i + closeDelim.length];
+          d--;
+          i += closeDelim.length;
+        } else i++;
       }
-      const proc = this.process(content);
-      let left = src.substring(0, x.idx), right = src.substring(posAfter);
-      let prefix = left.endsWith("\n") ? "\n" : "";
-      if (prefix) left = left.slice(0, -1);
-      src = left + prefix + proc + right;
+      return [src.substring(innerStart), src.length];
     }
-    return src;
   }
-
-  #extractBlock(src, openPos, openDelim = this.open, closeDelim = this.close) {
-    let i = openPos, depth = 0, innerStart = null, inStr = false, strChar = '';
-    
-    // Se openDelim tem múltiplos caracteres, processa diferente
-    if (openDelim.length > 1) {
-      // Pula o delimitador de abertura
-      if (src.substring(i, i + openDelim.length) === openDelim) {
-        i += openDelim.length;
-        innerStart = i;
-        // Procura pelo delimitador de fechamento com balanceamento
-        let d = 0;
-        while (i < src.length) {
-          if (src.substring(i, i + openDelim.length) === openDelim) {
-            d++;
-            i += openDelim.length;
-          } else if (src.substring(i, i + closeDelim.length) === closeDelim) {
-            if (d === 0) {
-              return [src.substring(innerStart, i), i + closeDelim.length];
-            }
-            d--;
-            i += closeDelim.length;
-          } else {
-            i++;
-          }
-        }
-        return [src.substring(innerStart), src.length];
-      }
-    }
-    
-    // Para delimitadores single-char, balanceia
-    while (i < src.length) {
-      const ch = src[i];
-      if (inStr) {
-        if (ch === '\\') i += 2;
-        else if (ch === strChar) { inStr = false; strChar = ''; i++; }
-        else i++;
-        continue;
-      }
-      if (ch === "'" || ch === "`") {
-        inStr = true;
-        strChar = ch;
-        i++;
-        continue;
-      }
-      if (ch === openDelim) {
-        depth++;
-        if (innerStart === null) innerStart = i + 1;
-      } else if (ch === closeDelim) {
-        depth--;
-        if (depth === 0) return [innerStart !== null ? src.substring(innerStart, i) : '', i + 1];
+  if (src[i] === openDelim) {
+    i++;
+    const innerStart = i;
+    if (openDelim === closeDelim) {
+      while (i < src.length && src[i] !== closeDelim) i++;
+      return [src.substring(innerStart, i), i + 1];
+    } else {
+      let depth = 1;
+      while (i < src.length && depth > 0) {
+        if (src[i] === openDelim) depth++;
+        else if (src[i] === closeDelim) depth--;
+        if (depth > 0) i++;
       }
-      i++;
+      return [src.substring(innerStart, i), i + 1];
     }
-    return [innerStart !== null ? src.substring(innerStart) : '', src.length];
   }
+  return ['', i];
+}
 
-  #patternToRegex(pattern) {
-    let regex = '', i = 0;
-    const S = this.sigil, S2 = S + S;
-    while (i < pattern.length) {
-      if (pattern.startsWith(S2, i)) {
-        regex += '\\s*';
-        i += S2.length;
-        continue;
-      }
-      if (pattern.startsWith(S + 'block', i)) {
-        let j = i + S.length + 'block'.length;
+function parsePattern(papagaio, pattern) {
+  const tokens = [];
+  let i = 0;
+  const S = papagaio.symbols.sigil, S2 = S + S;
+  while (i < pattern.length) {
+    if (pattern.startsWith(S2, i)) {
+      tokens.push({ type: 'whitespace-optional' });
+      i += S2.length;
+      continue;
+    }
+    if (pattern.startsWith(S + 'block', i)) {
+      let j = i + S.length + 'block'.length;
+      while (j < pattern.length && /\s/.test(pattern[j])) j++;
+      let varName = '';
+      while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
+      if (varName) {
         while (j < pattern.length && /\s/.test(pattern[j])) j++;
-        
-        let varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) {
-          varName += pattern[j++];
-        }
-        
-        if (varName) {
+        let openDelim = papagaio.symbols.open;
+        if (j < pattern.length && pattern[j] === papagaio.symbols.open) {
+          const [c, e] = extractBlock(papagaio, pattern, j);
+          openDelim = unescapeDelimiter(c.trim()) || papagaio.symbols.open;
+          j = e;
           while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          
-          // Extrair delimitador de abertura - com balanceamento
-          let openDelim = this.open;
-          if (j < pattern.length && pattern[j] === this.open) {
-            const [c, e] = this.#extractBlock(pattern, j);
-            openDelim = c.trim() || this.open;
-            j = e;
-            while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          }
-          
-          // Extrair delimitador de fechamento - com balanceamento
-          let closeDelim = this.close;
-          if (j < pattern.length && pattern[j] === this.open) {
-            const [c, e] = this.#extractBlock(pattern, j, this.open, this.close);
-            closeDelim = c.trim() || this.close;
-            j = e;
-          }
-          
-          const eoMask = this.#escapeRegex(openDelim);
-          const ecMask = this.#escapeRegex(closeDelim);
-          // Use greedy match to allow nested delimiters to be captured (will match up to the last closing delimiter)
-          regex += `${eoMask}([\\s\\S]*)${ecMask}`;
-          i = j;
-          continue;
         }
-      }
-      if (pattern[i] === S) {
-        let j = i + S.length, varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
-        if (varName) {
-          regex += '(\\S+)';
-          i = j;
-        } else {
-          regex += this.#escapeRegex(S);
-          i += S.length;
+        let closeDelim = papagaio.symbols.close;
+        if (j < pattern.length && pattern[j] === papagaio.symbols.open) {
+          const [c, e] = extractBlock(papagaio, pattern, j);
+          closeDelim = unescapeDelimiter(c.trim()) || papagaio.symbols.close;
+          j = e;
         }
+        tokens.push({ type: 'block', varName, openDelim, closeDelim });
+        i = j;
         continue;
       }
-      if (/\s/.test(pattern[i])) {
-        regex += '\\s+';
-        while (i < pattern.length && /\s/.test(pattern[i])) i++;
+    }
+    if (pattern[i] === S) {
+      let j = i + S.length, varName = '';
+      while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
+      if (varName) {
+        tokens.push({ type: 'var', varName });
+        i = j;
         continue;
       }
-      const ch = pattern[i];
-      regex += /[.*+?^${}()|[\]\\]/.test(ch) ? '\\' + ch : ch;
-      i++;
+      tokens.push({ type: 'literal', value: S });
+      i += S.length;
+      continue;
+    }
+    if (/\s/.test(pattern[i])) {
+      let ws = '';
+      while (i < pattern.length && /\s/.test(pattern[i])) ws += pattern[i++];
+      tokens.push({ type: 'whitespace', value: ws });
+      continue;
     }
-    return new RegExp(regex, 'g');
+    let literal = '';
+    while (i < pattern.length && !pattern.startsWith(S, i) && !/\s/.test(pattern[i])) literal += pattern[i++];
+    if (literal) tokens.push({ type: 'literal', value: literal });
   }
+  return tokens;
+}
 
-  #extractVarNames(pattern) {
-    const vars = [], seen = new Set(), S = this.sigil, S2 = S + S;
-    let i = 0;
-    while (i < pattern.length) {
-      if (pattern.startsWith(S + 'block', i)) {
-        let j = i + S.length + 'block'.length;
-        while (j < pattern.length && /\s/.test(pattern[j])) j++;
-        
-        // Extrair nome como identificador simples
-        let varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) {
-          varName += pattern[j++];
-        }
-        
-        if (varName && !seen.has(varName)) {
-          vars.push(S + varName);
-          seen.add(varName);
-        }
-        
-        if (varName) {
-          while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          
-          // Pular delimitador de abertura
-          if (j < pattern.length && pattern[j] === this.open) {
-            const [, ne] = this.#extractBlock(pattern, j);
-            j = ne;
-            while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          }
-          
-          // Pular delimitador de fechamento
-          if (j < pattern.length && pattern[j] === this.open) {
-            const [, ne] = this.#extractBlock(pattern, j);
-            j = ne;
-          }
-        }
-        
-        i = j;
-        continue;
-      }
-      if (pattern.startsWith(S2, i)) {
-        i += S2.length;
-        continue;
-      }
-      if (pattern.startsWith(S, i)) {
-        let j = i + S.length, varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
-        if (varName && !seen.has(varName)) {
-          vars.push(S + varName);
-          seen.add(varName);
+function matchPattern(papagaio, src, tokens, startPos = 0) {
+  let pos = startPos;
+  const captures = {};
+  for (let ti = 0; ti < tokens.length; ti++) {
+    const token = tokens[ti];
+    if (token.type === 'whitespace-optional') {
+      while (pos < src.length && /\s/.test(src[pos])) pos++;
+      continue;
+    }
+    if (token.type === 'whitespace') {
+      if (pos >= src.length || !/\s/.test(src[pos])) return null;
+      while (pos < src.length && /\s/.test(src[pos])) pos++;
+      continue;
+    }
+    if (token.type === 'literal') {
+      if (!src.startsWith(token.value, pos)) return null;
+      pos += token.value.length;
+      continue;
+    }
+    if (token.type === 'var') {
+      const nextToken = ti + 1 < tokens.length ? tokens[ti + 1] : null;
+      let varValue = '';
+      if (nextToken) {
+        if (nextToken.type === 'whitespace' || nextToken.type === 'whitespace-optional') {
+          while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
+        } else if (nextToken.type === 'literal') {
+          const stopChar = nextToken.value[0];
+          while (pos < src.length && src[pos] !== stopChar && !/\s/.test(src[pos])) varValue += src[pos++];
+        } else if (nextToken.type === 'block') {
+          while (pos < src.length && !src.startsWith(nextToken.openDelim, pos) && !/\s/.test(src[pos])) varValue += src[pos++];
+        } else {
+          while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
         }
-        i = j;
-        continue;
+      } else {
+        while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
       }
-      i++;
+      if (!varValue) return null;
+      captures[papagaio.symbols.sigil + token.varName] = varValue;
+      continue;
+    }
+    if (token.type === 'block') {
+      const { varName, openDelim, closeDelim } = token;
+      if (!src.startsWith(openDelim, pos)) return null;
+      const [blockContent, endPos] = extractBlock(papagaio, src, pos, openDelim, closeDelim);
+      captures[papagaio.symbols.sigil + varName] = blockContent;
+      pos = endPos;
+      continue;
     }
-    return vars;
   }
+  return { captures, endPos: pos };
+}
 
-  #collectPatterns(src) {
-    const patterns = [], patRe = new RegExp(`\\b${this.keywords.pattern}\\s*\\${this.open}`, "g");
-    let result = src, i = 0;
-    while (i < result.length) {
-      patRe.lastIndex = i;
-      const m = patRe.exec(result);
-      if (!m) break;
-      const start = m.index, openPos = m.index + m[0].length - 1;
-      const [matchPat, posAfterMatch] = this.#extractBlock(result, openPos);
-      let k = posAfterMatch;
-      while (k < result.length && /\s/.test(result[k])) k++;
-      if (k < result.length && result[k] === this.open) {
-        const [replacePat, posAfterReplace] = this.#extractBlock(result, k);
-        patterns.push({ match: matchPat.trim(), replace: replacePat.trim() });
-        result = result.slice(0, start) + result.slice(posAfterReplace);
-        i = start;
-        continue;
-      }
-      i = start + 1;
+function collectPatterns(papagaio, src) {
+  const patterns = [];
+  const patRe = new RegExp(`\\b${papagaio.symbols.pattern}\\s*\\${papagaio.symbols.open}`, "g");
+  let result = src;
+  while (true) {
+    patRe.lastIndex = 0;
+    const m = patRe.exec(result);
+    if (!m) break;
+    const start = m.index;
+    const openPos = m.index + m[0].length - 1;
+    const [matchPat, posAfterMatch] = extractBlock(papagaio, result, openPos);
+    let k = posAfterMatch;
+    while (k < result.length && /\s/.test(result[k])) k++;
+    if (k < result.length && result[k] === papagaio.symbols.open) {
+      const [replacePat, posAfterReplace] = extractBlock(papagaio, result, k);
+      patterns.push({ match: matchPat.trim(), replace: replacePat.trim() });
+      result = result.slice(0, start) + result.slice(posAfterReplace);
+      continue;
     }
-    return [patterns, result];
+    result = result.slice(0, start) + result.slice(posAfterMatch);
   }
+  return [patterns, result];
+}
 
-  #applyPatterns(src, patterns) {
-    let clearFlag = false, lastResult = "", S = this.sigil;
-    for (const pat of patterns) {
-      // Aplicar uma única vez
-      const regex = this.#patternToRegex(pat.match);
-      const varNames = this.#extractVarNames(pat.match);
-      src = src.replace(regex, (...args) => {
-        const fullMatch = args[0];
-        const captures = args.slice(1, -2);
-        const matchStart = args[args.length - 2];
-        const matchEnd = matchStart + fullMatch.length;
+function applyPatterns(papagaio, src, patterns) {
+  let clearFlag = false, lastResult = "", S = papagaio.symbols.sigil;
+  for (const pat of patterns) {
+    const tokens = parsePattern(papagaio, pat.match);
+    let newSrc = '';
+    let pos = 0, matched = false;
+    while (pos < src.length) {
+      const matchResult = matchPattern(papagaio, src, tokens, pos);
+      if (matchResult) {
+        matched = true;
+        const { captures, endPos } = matchResult;
         let result = pat.replace;
-        const varMap = {};
-        for (let i = 0; i < varNames.length; i++)
-          varMap[varNames[i]] = captures[i] || '';
-        for (const [k, v] of Object.entries(varMap)) {
-          const keyEsc = this.#escapeRegex(k);
+        for (const [k, v] of Object.entries(captures)) {
+          const keyEsc = escapeRegex(k);
           result = result.replace(new RegExp(keyEsc + '(?![A-Za-z0-9_])', 'g'), v);
         }
-        result = result.replace(new RegExp(`${this.#escapeRegex(S)}unique\\b`, 'g'), 
-          () => this.#genUnique());
+        
+        const uniqueId = papagaio.unique_id++;
+        result = result.replace(new RegExp(`${escapeRegex(S)}unique\\b`, 'g'), () => String(uniqueId));
         result = result.replace(/\$eval\{([^}]*)\}/g, (_, code) => {
           try {
             const wrapped = `"use strict"; return (function() { ${code} })();`;
-            return String(Function("papagaio", "ctx", wrapped)(this, {}));
+            return String(Function("papagaio", "ctx", wrapped)(papagaio, {}));
           } catch {
             return "";
           }
         });
         const S2 = S + S;
-        result = result.replace(new RegExp(this.#escapeRegex(S2), 'g'), '');
-        if (new RegExp(`${this.#escapeRegex(S)}clear\\b`, 'g').test(result)) {
-          result = result.replace(new RegExp(`${this.#escapeRegex(S)}clear\\b`, 'g'), '');
+        result = result.replace(new RegExp(escapeRegex(S2), 'g'), '');
+        
+        if (new RegExp(`${escapeRegex(S)}clear\\b`, 'g').test(result)) {
+          result = result.replace(new RegExp(`${escapeRegex(S)}clear\\b\\s?`, 'g'), '');
           clearFlag = true;
         }
+        
+        const matchStart = pos, matchEnd = endPos;
         result = result
-          .replace(new RegExp(`${this.#escapeRegex(S)}prefix\\b`, 'g'), src.slice(0, matchStart))
-          .replace(new RegExp(`${this.#escapeRegex(S)}suffix\\b`, 'g'), src.slice(matchEnd))
-          .replace(new RegExp(`${this.#escapeRegex(S)}match\\b`, 'g'), fullMatch);
+          .replace(new RegExp(`${escapeRegex(S)}prefix\\b`, 'g'), src.slice(0, matchStart))
+          .replace(new RegExp(`${escapeRegex(S)}suffix\\b`, 'g'), src.slice(matchEnd))
+          .replace(new RegExp(`${escapeRegex(S)}match\\b`, 'g'), src.slice(matchStart, matchEnd));
+        newSrc += result;
         lastResult = result;
-        return result;
-      });
-      if (clearFlag) {
-        src = lastResult;
-        clearFlag = false;
+        pos = endPos;
+      } else {
+        newSrc += src[pos];
+        pos++;
       }
     }
-    return src;
+    if (matched) {
+      src = clearFlag ? lastResult : newSrc;
+      clearFlag = false;
+    }
   }
+  return src;
+}
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&');
+}
 
-  #genUnique() {
-    return "u" + (this.#counter.unique++).toString(36);
+function unescapeDelimiter(str) {
+  let result = '';
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === '\\' && i + 1 < str.length) {
+      const next = str[i + 1];
+      if (next === '"' || next === "'" || next === '\\') {
+        result += next;
+        i++;
+      } else {
+        result += str[i];
+      }
+    } else {
+      result += str[i];
+    }
+  }
+  return result;
+}
+
+export class Papagaio {
+  constructor() {
+    this.recursion_limit = 512;
+    this.unique_id = 0;
+    this.symbols = {
+      pattern: "pattern",
+      context: "context",
+      open: "{",
+      close: "}",
+      sigil: "$"
+    };
+    this.content = "";
   }
 
-  #escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\\"']/g, '\\$&');
+  process(input) {
+    this.content = input;
+    let src = input, last = null, iter = 0;
+    const pending = () => {
+      const rCtx = new RegExp(`\\b${this.symbols.context}\\s*\\${this.symbols.open}`, "g");
+      const rPat = new RegExp(`\\b${this.symbols.pattern}\\s*\\${this.symbols.open}`, "g");
+      return rCtx.test(src) || rPat.test(src);
+    };
+    while (src !== last && iter < this.recursion_limit) {
+      iter++;
+      last = src;
+      src = processContext(this, src);
+      const [patterns, s2] = collectPatterns(this, src);
+      src = applyPatterns(this, s2, patterns);
+      if (!pending()) break;
+    }
+    return this.content = src, src;
   }
 }

package/tests/test.js

@@ -20,8 +20,6 @@ const testsPath = path.join(__dirname, 'tests.json');
 const testsData = JSON.parse(fs.readFileSync(testsPath, 'utf-8'));
 const tests = testsData.tests;
 
-const p = new Papagaio();
-
 console.log(`${colors.cyan}[TEST] PAPAGAIO - TEST RUNNER${colors.reset}\n`);
 console.log('='.repeat(80));
 
@@ -30,22 +28,25 @@ let failed = 0;
 const failedTests = [];
 
 for (const test of tests) {
+  // Criar nova instância de Papagaio para cada teste
+  const p = new Papagaio();
+  
   try {
     const result = p.process(test.code).trim();
-    const success = result.includes(test.shouldContain);
+    const success = result.includes(test.expected);
     
     if (success) {
       console.log(`${colors.green}[PASS]${colors.reset} [${test.id}] ${test.name}`);
       passed++;
     } else {
       console.log(`${colors.red}[FAIL]${colors.reset} [${test.id}] ${test.name}`);
-      console.log(`       ${colors.yellow}Expected:${colors.reset} "${test.shouldContain}"`);
+      console.log(`       ${colors.yellow}Expected:${colors.reset} "${test.expected}"`);
       console.log(`       ${colors.yellow}Got:${colors.reset}      "${result.substring(0, 80)}${result.length > 80 ? '...' : ''}"`);
       failed++;
       failedTests.push({
         id: test.id,
         name: test.name,
-        expected: test.shouldContain,
+        expected: test.expected,
         got: result.substring(0, 150)
       });
     }
@@ -93,6 +94,7 @@ const report = {
 
 const reportPath = path.join(__dirname, 'test-report.json');
 fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+
 console.log(`\n${colors.cyan}[INFO]${colors.reset} Report saved at: ${reportPath}`);
 
 process.exit(failed > 0 ? 1 : 0);