papagaio 0.6.2 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papagaio",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "easy yet powerful preprocessor",
   "main": "src/papagaio.js",
   "type": "module",

package/src/papagaio.js

@@ -1,6 +1,6 @@
 // papagaio - https://github.com/jardimdanificado/papagaio
 function parsePattern(p, pat) {
-    const t = [], S = p.symbols.sigil, O = p.symbols.open;
+    const t = [], S = p.symbols.sigil, O = p.symbols.open, C = p.symbols.close;
     let i = 0;
     while (i < pat.length) {
         if (pat.startsWith(S + p.symbols.regex, i)) {
@@ -17,36 +17,30 @@ function parsePattern(p, pat) {
                 }
             }
         }
-        if (pat.startsWith(S + p.symbols.block, i)) {
-            let j = i + S.length + p.symbols.block.length;
-            while (j < pat.length && /\s/.test(pat[j])) j++;
-            let v = '';
-            while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
-            if (v) {
-                while (j < pat.length && /\s/.test(pat[j])) j++;
-                let od = O, cd = p.symbols.close;
-                if (pat[j] === O) {
-                    const [c, e] = extractBlock(p, pat, j);
-                    od = unescapeDelim(c.trim()) || O;
-                    j = e; while (j < pat.length && /\s/.test(pat[j])) j++;
-                }
-                if (pat[j] === O) {
-                    const [c, e] = extractBlock(p, pat, j);
-                    cd = unescapeDelim(c.trim()) || cd;
-                    j = e;
+        if (pat[i] === S) {
+            let j = i + S.length;
+            const isDouble = pat[j] === S;
+            if (isDouble) j++;
+            if (pat[j] === O) {
+                const [od, e1] = extractBlock(p, pat, j);
+                if (pat[e1] === O) {
+                    const [cd, e2] = extractBlock(p, pat, e1);
+                    let v = '', k = e2;
+                    while (k < pat.length && /[A-Za-z0-9_]/.test(pat[k])) v += pat[k++];
+                    if (v) {
+                        t.push({ type: isDouble ? 'blockseq' : 'block', varName: v, open: unescapeDelim(od.trim()) || O, close: unescapeDelim(cd.trim()) || C });
+                        i = k; continue;
+                    }
                 }
-                t.push({ type: 'block', varName: v, open: od, close: cd }); 
-                i = j; continue;
             }
-        }
-        if (pat[i] === S) {
-            let j = i + S.length, v = '';
+            j = i + S.length;
+            let v = '';
             while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
-            if (v) { 
+            if (v) {
                 const optional = pat[j] === '?';
                 if (optional) j++;
-                t.push({ type: 'var', varName: v, optional }); 
-                i = j; continue; 
+                t.push({ type: 'var', varName: v, optional });
+                i = j; continue;
             }
             t.push({ type: 'lit', value: S }); i += S.length; continue;
         }
@@ -80,11 +74,9 @@ function matchPattern(p, src, tok, pos = 0) {
             while (pos < src.length && /\s/.test(src[pos])) pos++;
             const nx = findNext(tok, ti);
             let v = '';
-            if (nx && nx.type === 'block') {
-                while (pos < src.length && !src.startsWith(nx.open, pos) && src[pos] !== '\n') v += src[pos++];
-                v = v.trimEnd();
-            } else if (nx && nx.type === 'lit') {
-                while (pos < src.length && !src.startsWith(nx.value, pos) && src[pos] !== '\n') v += src[pos++];
+            if (nx && (nx.type === 'block' || nx.type === 'lit')) {
+                const stop = nx.type === 'block' ? nx.open : nx.value;
+                while (pos < src.length && !src.startsWith(stop, pos) && src[pos] !== '\n') v += src[pos++];
                 v = v.trimEnd();
             } else {
                 while (pos < src.length && !/\s/.test(src[pos])) v += src[pos++];
@@ -93,6 +85,18 @@ function matchPattern(p, src, tok, pos = 0) {
             cap[p.symbols.sigil + t.varName] = v;
             continue;
         }
+        if (t.type === 'blockseq') {
+            let blocks = [];
+            while (pos < src.length && src.startsWith(t.open, pos)) {
+                const [c, e] = extractBlock(p, src, pos, t.open, t.close);
+                blocks.push(c);
+                pos = e;
+                while (pos < src.length && /\s/.test(src[pos])) pos++;
+            }
+            if (!blocks.length) return null;
+            cap[p.symbols.sigil + t.varName] = blocks.join(' ');
+            continue;
+        }
         if (t.type === 'block') {
             if (!src.startsWith(t.open, pos)) return null;
             const [c, e] = extractBlock(p, src, pos, t.open, t.close);
@@ -151,18 +155,15 @@ function extractEvals(p, txt) {
     const ev = [], S = p.symbols.sigil, O = p.symbols.open;
     let i = 0, out = txt, off = 0;
     while (i < txt.length) {
-        if (txt.substring(i, i + S.length) === S) {
-            const rest = txt.substring(i + S.length);
-            if (rest.startsWith(p.symbols.eval)) {
-                let j = i + S.length + p.symbols.eval.length;
-                while (j < txt.length && /\s/.test(txt[j])) j++;
-                if (j < txt.length && txt.substring(j, j + O.length) === O) {
-                    const sp = i, bp = j, [c, ep] = extractBlock(p, txt, bp);
-                    ev.push({ code: c, sp: sp - off, ep: ep - off });
-                    const ph = `__E${ev.length - 1}__`;
-                    out = out.substring(0, sp - off) + ph + out.substring(ep - off);
-                    off += (ep - sp) - ph.length; i = ep; continue;
-                }
+        if (txt.substring(i, i + S.length) === S && txt.substring(i + S.length).startsWith(p.symbols.eval)) {
+            let j = i + S.length + p.symbols.eval.length;
+            while (j < txt.length && /\s/.test(txt[j])) j++;
+            if (j < txt.length && txt.substring(j, j + O.length) === O) {
+                const sp = i, bp = j, [c, ep] = extractBlock(p, txt, bp);
+                ev.push({ code: c, sp: sp - off, ep: ep - off });
+                const ph = `__E${ev.length - 1}__`;
+                out = out.substring(0, sp - off) + ph + out.substring(ep - off);
+                off += (ep - sp) - ph.length; i = ep; continue;
             }
         }
         i++;
@@ -174,10 +175,8 @@ function applyEvals(p, txt, ev) {
     let r = txt;
     for (let i = ev.length - 1; i >= 0; i--) {
         const ph = `__E${i}__`;
-        let res;
-        try { res = String(Function("papagaio", "ctx", `"use strict";return(function(){${ev[i].code}})();`)(p, {})); }
-        catch (e) { res = "error: " + e.message; }
-        r = r.replace(ph, res);
+        try { r = r.replace(ph, String(Function("papagaio", "ctx", `"use strict";return(function(){${ev[i].code}})();`)(p, {}))); }
+        catch (e) { r = r.replace(ph, "error: " + e.message); }
     }
     return r;
 }
@@ -219,8 +218,8 @@ function unescapeDelim(s) {
 }
 
 export class Papagaio {
-    constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern', evalKw = 'eval', blockKw = 'block', regexKw = 'regex') {
-        this.symbols = { pattern, open, close, sigil, eval: evalKw, block: blockKw, regex: regexKw };
+    constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern', evalKw = 'eval', blockKw = 'recursive', regexKw = 'regex', blockseqKw = 'sequential') {
+        this.symbols = { pattern, open, close, sigil, eval: evalKw, block: blockKw, regex: regexKw, blockseq: blockseqKw };
         this.content = "";
         this.match = "";
     }

package/tests/tests.json

@@ -15,19 +15,19 @@
     {
       "id": 3,
       "name": "Block with custom delimiters",
-      "code": "$pattern {$block content {(}{)}} {[$content]}\ndata (hello world)",
+      "code": "$pattern {${(}{)}content} {[$content]}\ndata (hello world)",
       "expected": "data [hello world]"
     },
     {
       "id": 4,
       "name": "Block with multi-char delimiters",
-      "code": "$pattern {$block code {<<}{>>}} {CODE[$code]}\n<<console.log()>>",
+      "code": "$pattern {${<<}{>>}code} {CODE[$code]}\n<<console.log()>>",
       "expected": "CODE[console.log()]"
     },
     {
       "id": 5,
       "name": "Block with nested delimiters",
-      "code": "$pattern {$block txt {<}{>}} {[$txt]}\nouter <middle <inner> content>",
+      "code": "$pattern {${<}{>}txt} {[$txt]}\nouter <middle <inner> content>",
       "expected": "outer [middle <inner> content]"
     },
     {
@@ -63,7 +63,7 @@
     {
       "id": 11,
       "name": "Multiple blocks in one pattern",
-      "code": "$pattern {$block a {(}{)} and $block b {[}{]}} {$a|$b}\n(first) and [second]",
+      "code": "$pattern {${(}{)}a  and ${[}{]}b} {$a|$b}\n(first) and [second]",
       "expected": "first|second"
     },
     {
@@ -87,7 +87,7 @@
     {
       "id": 15,
       "name": "Block with angle brackets",
-      "code": "$pattern {$block inner {<}{>}} {WRAPPED[$inner]}\n<content>",
+      "code": "$pattern {${<}{>}inner} {WRAPPED[$inner]}\n<content>",
       "expected": "WRAPPED[content]"
     },
     {
@@ -105,7 +105,7 @@
     {
       "id": 18,
       "name": "Block capturing with square brackets",
-      "code": "$pattern {$block arr {[}{]}} {ARRAY[$arr]}\n[1, 2, 3]",
+      "code": "$pattern {${[}{]}arr} {ARRAY[$arr]}\n[1, 2, 3]",
       "expected": "ARRAY[1, 2, 3]"
     },
     {
@@ -129,31 +129,31 @@
     {
       "id": 22,
       "name": "Block delimiter balancing - parentheses",
-      "code": "$pattern {$block code {(}{)}} {RESULT[$code]}\n(a (b (c) d) e)",
+      "code": "$pattern {${(}{)}code} {RESULT[$code]}\n(a (b (c) d) e)",
       "expected": "RESULT[a (b (c) d) e]"
     },
     {
       "id": 23,
       "name": "Block delimiter balancing - angle brackets",
-      "code": "$pattern {$block inner {<}{>}} {X[$inner]}\n<outer <middle <deep>> more>",
+      "code": "$pattern {${<}{>}inner} {X[$inner]}\n<outer <middle <deep>> more>",
       "expected": "X[outer <middle <deep>> more]"
     },
     {
       "id": 24,
       "name": "Block delimiter balancing - square brackets",
-      "code": "$pattern {$block data {[}{]}} {DATA[$data]}\n[outer [inner [deep]] more]",
+      "code": "$pattern {${[}{]}data} {DATA[$data]}\n[outer [inner [deep]] more]",
       "expected": "DATA[outer [inner [deep]] more]"
     },
     {
       "id": 25,
       "name": "Block delimiter balancing - curly braces",
-      "code": "$pattern {$block obj {}{}} {OBJ[$obj]}\n{key: {nested: {value}}}",
+      "code": "$pattern {${}{}obj} {OBJ[$obj]}\n{key: {nested: {value}}}",
       "expected": "OBJ[key: {nested: {value}}]"
     },
     {
       "id": 26,
       "name": "Multiple nested delimiters in same pattern",
-      "code": "$pattern {$block a {(}{)} $block b {[}{]}} {[$a|$b]}\n(test1) [test2]",
+      "code": "$pattern {${(}{)}a ${[}{]}b} {[$a|$b]}\n(test1) [test2]",
       "expected": "[test1|test2]"
     },
     {
@@ -165,25 +165,25 @@
     {
       "id": 28,
       "name": "Block with quotes as delimiters",
-      "code": "$pattern {$block str {\"}{\"}} {STRING[$str]}\n\"hello world\"",
+      "code": "$pattern {${\"}{\"}str} {STRING[$str]}\n\"hello world\"",
       "expected": "STRING[hello world]"
     },
     {
       "id": 29,
       "name": "Block with pipe delimiters",
-      "code": "$pattern {$block val {|}{|}} {PIPE[$val]}\n|content here|",
+      "code": "$pattern {${|}{|}val} {PIPE[$val]}\n|content here|",
       "expected": "PIPE[content here]"
     },
     {
       "id": 30,
       "name": "Deeply nested block delimiters",
-      "code": "$pattern {$block deep {<}{>}} {[$deep]}\n<a <b <c <d> c> b> a>",
+      "code": "$pattern {${<}{>}deep} {[$deep]}\n<a <b <c <d> c> b> a>",
       "expected": "[a <b <c <d> c> b> a]"
     },
     {
       "id": 31,
       "name": "Two sequential patterns",
-      "code": "$pattern {$block content {(}{)}} {BLOCK [$content]}\n$pattern {BLOCK $x} {RESULT: $x}\n(inner data)",
+      "code": "$pattern {${(}{)}content} {BLOCK [$content]}\n$pattern {BLOCK $x} {RESULT: $x}\n(inner data)",
       "expected": "RESULT: [inner data]"
     },
     {
@@ -195,13 +195,13 @@
     {
       "id": 33,
       "name": "Block delimiter edge case - empty content",
-      "code": "$pattern {$block empty {(}{)}} {EMPTY[$empty]}\n()",
+      "code": "$pattern {${(}{)}empty} {EMPTY[$empty]}\n()",
       "expected": "EMPTY[]"
     },
     {
       "id": 34,
       "name": "Multi-char delimiters with nesting",
-      "code": "$pattern {$block code {<<}{>>}} {CODE[$code]}\n<<outer <<inner>> more>>",
+      "code": "$pattern {${<<}{>>}code} {CODE[$code]}\n<<outer <<inner>> more>>",
       "expected": "CODE[outer <<inner>> more]"
     },
     {