drools-builder 0.1.3 → 1.0.1

package/dist/index.cjs

@@ -614,8 +614,72 @@ ${indent}}`;
       return `${cons.expression};`;
     case "RawConsequence":
       return `${cons.code};`;
+    case "ReturnConsequence":
+      return cons.expression ? `return ${cons.expression};` : "return;";
+    case "WhileConsequence": {
+      const body = cons.body.map((c) => `${indent}  ${generateConsequence(c, indent + "  ")}`).join("\n");
+      return `while (${cons.condition}) {
+${body}
+${indent}}`;
+    }
+    case "ForEachConsequence": {
+      const body = cons.body.map((c) => `${indent}  ${generateConsequence(c, indent + "  ")}`).join("\n");
+      return `for (${cons.typeName} ${cons.varName} : ${cons.collection}) {
+${body}
+${indent}}`;
+    }
+    case "ForConsequence": {
+      const body = cons.body.map((c) => `${indent}  ${generateConsequence(c, indent + "  ")}`).join("\n");
+      return `for (${cons.init}; ${cons.condition}; ${cons.update}) {
+${body}
+${indent}}`;
+    }
+    case "VarDeclConsequence":
+      return `${cons.typeName} ${cons.name} = ${cons.value};`;
+    case "MethodCallConsequence":
+      return `${cons.object}.${cons.method}(${cons.args});`;
+    case "SwitchConsequence": {
+      const caseLines = cons.cases.map((c) => {
+        const body = c.body.map((b) => `${indent}  ${generateConsequence(b, indent + "  ")}`).join("\n");
+        return `${indent}  case ${c.value}:
+${body}
+${indent}    break;`;
+      });
+      if (cons.default && cons.default.length > 0) {
+        const defBody = cons.default.map((b) => `${indent}  ${generateConsequence(b, indent + "  ")}`).join("\n");
+        caseLines.push(`${indent}  default:
+${defBody}`);
+      }
+      return `switch (${cons.expression}) {
+${caseLines.join("\n")}
+${indent}}`;
+    }
+    case "IfConsequence": {
+      const thenLines = cons.then.map((c) => `${indent}  ${generateConsequence(c, indent + "  ")}`).join("\n");
+      if (cons.else && cons.else.length > 0) {
+        const elseLines = cons.else.map((c) => `${indent}  ${generateConsequence(c, indent + "  ")}`).join("\n");
+        return `if (${cons.condition}) {
+${thenLines}
+${indent}} else {
+${elseLines}
+${indent}}`;
+      }
+      return `if (${cons.condition}) {
+${thenLines}
+${indent}}`;
+    }
   }
 }
+function generateDeclaration(decl) {
+  const attrs = decl.attributes.map((a) => `    ${a.name} : ${a.type}`).join("\n");
+  return `declare ${decl.className}${attrs ? "\n" + attrs + "\n" : "\n"}end`;
+}
+function generateFunction(fn, indent = "    ") {
+  const body = fn.body.map((c) => `${indent}${generateConsequence(c, indent)}`).join("\n");
+  return `function ${fn.returnType} ${fn.name}(${fn.params}) {
+${body}
+}`;
+}
 function generateRule(rule) {
   const lines = [`rule "${rule.name}"`];
   if (rule.salience !== void 0) lines.push(`  salience ${rule.salience}`);
@@ -637,6 +701,10 @@ var MetaToDRLTransformer = {
       sections.push(file.imports.map((i) => `import ${i};`).join("\n"));
     if (file.globals.length > 0)
       sections.push(file.globals.map((g) => `global ${g.type} ${g.name};`).join("\n"));
+    if (file.declarations && file.declarations.length > 0)
+      sections.push(file.declarations.map((d) => generateDeclaration(d)).join("\n\n"));
+    if (file.functions && file.functions.length > 0)
+      sections.push(file.functions.map((fn) => generateFunction(fn)).join("\n\n"));
     sections.push(file.rules.map(generateRule).join("\n\n"));
     return sections.join("\n\n");
   },
@@ -754,24 +822,54 @@ function parseGlobals(drl) {
 }
 function extractRuleBlocks(drl) {
   const blocks = [];
-  const re = /\brule\s+"[^"]*"[\s\S]*?\bend\b/g;
+  const re = /\brule\s+(?:"[^"]*"|'[^']*')[\s\S]*?\bend\b/g;
   let m;
   while ((m = re.exec(drl)) !== null) blocks.push(m[0]);
   return blocks;
 }
+function parseFunctions(drl) {
+  const results = [];
+  const re = /\bfunction\s+([\w<>?,\s\[\]]+?)\s+(\w+)\s*\(([^)]*)\)\s*\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
+  let m;
+  while ((m = re.exec(drl)) !== null) {
+    results.push({
+      returnType: m[1].trim(),
+      name: m[2].trim(),
+      params: m[3].trim(),
+      body: parseConsequences(m[4].trim())
+    });
+  }
+  return results;
+}
+function parseDeclarations(drl) {
+  const results = [];
+  const re = /\bdeclare\s+(\w+)\s*([\s\S]*?)\bend\b/g;
+  let m;
+  while ((m = re.exec(drl)) !== null) {
+    const className = m[1].trim();
+    const attributes = [];
+    const attrRe = /^\s*(\w+)\s*:\s*(\S+)/gm;
+    let a;
+    while ((a = attrRe.exec(m[2])) !== null) {
+      attributes.push({ name: a[1].trim(), type: a[2].trim() });
+    }
+    results.push({ className, attributes });
+  }
+  return results;
+}
 function parseRuleName(block) {
-  const m = block.match(/\brule\s+"([^"]+)"/);
-  return m ? m[1] : "unknown";
+  const m = block.match(/\brule\s+(?:"([^"]+)"|'([^']+)')/);
+  return m ? m[1] ?? m[2] : "unknown";
 }
 function parseRuleAttributes(block) {
   const attrs = {};
-  const m = block.match(/\brule\s+"[^"]+"\s*([\s\S]*?)\bwhen\b/);
+  const m = block.match(/\brule\s+(?:"[^"]+"|'[^']+')\s*([\s\S]*?)\bwhen\b/);
   if (!m) return attrs;
   const attr = m[1];
   const salience = attr.match(/\bsalience\s+(-?\d+)/);
   if (salience) attrs.salience = parseInt(salience[1], 10);
-  if (/\bno-loop\s+true\b/.test(attr)) attrs.noLoop = true;
-  if (/\block-on-active\s+true\b/.test(attr)) attrs.lockOnActive = true;
+  if (!/\bno-loop\s+false\b/.test(attr) && /\bno-loop\b/.test(attr)) attrs.noLoop = true;
+  if (!/\block-on-active\s+false\b/.test(attr) && /\block-on-active\b/.test(attr)) attrs.lockOnActive = true;
   const ag = attr.match(/\bagenda-group\s+"([^"]+)"/);
   if (ag) attrs.agendaGroup = ag[1];
   const rfg = attr.match(/\bruleflow-group\s+"([^"]+)"/);
@@ -937,6 +1035,31 @@ function parseFrom(text, fromIdx) {
     expression: text.slice(fromIdx + " from ".length).trim()
   };
 }
+function parseSwitchBody(body) {
+  const cases = [];
+  let defaultBody;
+  const markers = [];
+  const caseRe = /\bcase\s+([^:]+):/g;
+  const defRe = /\bdefault\s*:/g;
+  let m;
+  while ((m = caseRe.exec(body)) !== null)
+    markers.push({ index: m.index, headerLen: m[0].length, type: "case", value: m[1].trim() });
+  while ((m = defRe.exec(body)) !== null)
+    markers.push({ index: m.index, headerLen: m[0].length, type: "default" });
+  markers.sort((a, b) => a.index - b.index);
+  for (let i = 0; i < markers.length; i++) {
+    const marker = markers[i];
+    const contentStart = marker.index + marker.headerLen;
+    const contentEnd = i + 1 < markers.length ? markers[i + 1].index : body.length;
+    const raw = body.slice(contentStart, contentEnd).trim();
+    const content = raw.replace(/\s*\bbreak\s*;\s*$/, "").trim();
+    if (marker.type === "case")
+      cases.push({ kind: "CaseConsequence", value: marker.value, body: parseConsequences(content) });
+    else
+      defaultBody = parseConsequences(content);
+  }
+  return { cases, ...defaultBody !== void 0 && { default: defaultBody } };
+}
 function parseConsequences(then) {
   const consequences = [];
   let remaining = then.trim();
@@ -951,6 +1074,65 @@ function parseConsequences(then) {
 function parseNextConsequence(text) {
   const t = text.trim();
   if (!t) return null;
+  if (/^while\s*\(/.test(t)) {
+    const condition = extractBalanced(t, "(", ")");
+    const afterCond = t.slice(t.indexOf("(") + condition.length + 2).trim();
+    const body = extractBalanced(afterCond, "{", "}");
+    const endIdx = afterCond.indexOf("{") + body.length + 2;
+    return {
+      consequence: { kind: "WhileConsequence", condition: condition.trim(), body: parseConsequences(body) },
+      rest: afterCond.slice(endIdx)
+    };
+  }
+  if (/^for\s*\(/.test(t)) {
+    const header = extractBalanced(t, "(", ")");
+    const afterHeader = t.slice(t.indexOf("(") + header.length + 2).trim();
+    const body = extractBalanced(afterHeader, "{", "}");
+    const endIdx = afterHeader.indexOf("{") + body.length + 2;
+    const colonIdx = indexAtDepth0(header, ":");
+    if (colonIdx !== -1 && indexAtDepth0(header, ";") === -1) {
+      const parts = header.slice(0, colonIdx).trim().split(/\s+/);
+      const varName = parts.pop();
+      const typeName = parts.join(" ");
+      return {
+        consequence: { kind: "ForEachConsequence", typeName, varName, collection: header.slice(colonIdx + 1).trim(), body: parseConsequences(body) },
+        rest: afterHeader.slice(endIdx)
+      };
+    } else {
+      const parts = splitAtDepth0(header, ";");
+      return {
+        consequence: { kind: "ForConsequence", init: (parts[0] ?? "").trim(), condition: (parts[1] ?? "").trim(), update: (parts[2] ?? "").trim(), body: parseConsequences(body) },
+        rest: afterHeader.slice(endIdx)
+      };
+    }
+  }
+  if (/^switch\s*\(/.test(t)) {
+    const expression = extractBalanced(t, "(", ")");
+    const afterExpr = t.slice(t.indexOf("(") + expression.length + 2).trim();
+    const switchBody = extractBalanced(afterExpr, "{", "}");
+    const endIdx = afterExpr.indexOf("{") + switchBody.length + 2;
+    return {
+      consequence: { kind: "SwitchConsequence", expression: expression.trim(), ...parseSwitchBody(switchBody) },
+      rest: afterExpr.slice(endIdx)
+    };
+  }
+  if (/^if\s*\(/.test(t)) {
+    const condition = extractBalanced(t, "(", ")");
+    const afterCond = t.slice(t.indexOf("(") + condition.length + 2).trim();
+    const thenBlock = extractBalanced(afterCond, "{", "}");
+    const thenConsequences = parseConsequences(thenBlock);
+    let afterThen = afterCond.slice(afterCond.indexOf("{") + thenBlock.length + 2).trim();
+    let elseConsequences;
+    if (/^else\s*\{/.test(afterThen)) {
+      const elseBlock = extractBalanced(afterThen, "{", "}");
+      elseConsequences = parseConsequences(elseBlock);
+      afterThen = afterThen.slice(afterThen.indexOf("{") + elseBlock.length + 2).trim();
+    }
+    return {
+      consequence: { kind: "IfConsequence", condition: condition.trim(), then: thenConsequences, ...elseConsequences && { else: elseConsequences } },
+      rest: afterThen
+    };
+  }
   if (/^modify\s*\(/.test(t)) {
     const m = t.match(/^modify\s*\(\s*(\$\w+)\s*\)/);
     if (m) {
@@ -973,6 +1155,14 @@ function parseNextConsequence(text) {
     const rest = t.slice(t.indexOf("(") + inner.length + 2).replace(/^\s*;/, "");
     return { consequence: { kind: "RetractConsequence", binding: inner.trim() }, rest };
   }
+  if (/^return\b/.test(t)) {
+    const semiIdx2 = indexAtDepth0(t, ";");
+    const expression = t.slice("return".length, semiIdx2 !== -1 ? semiIdx2 : void 0).trim();
+    return {
+      consequence: { kind: "ReturnConsequence", expression },
+      rest: semiIdx2 !== -1 ? t.slice(semiIdx2 + 1) : ""
+    };
+  }
   const semiIdx = indexAtDepth0(t, ";");
   if (semiIdx !== -1)
     return { consequence: { kind: "RawConsequence", code: t.slice(0, semiIdx).trim() }, rest: t.slice(semiIdx + 1) };
@@ -991,8 +1181,10 @@ var DRLToMetaTransformer = {
     const clean = stripComments(drl);
     return {
       name: "parsed",
-      imports: parseImports(clean),
+      imports: [...new Set(parseImports(clean))],
       globals: parseGlobals(clean),
+      declarations: parseDeclarations(clean),
+      functions: parseFunctions(clean),
       rules: extractRuleBlocks(clean).map((block) => DRLToMetaTransformer.parseRule(block))
     };
   },