@halleyassist/rule-parser 1.0.11 → 1.0.12

package/README.md

@@ -1,3 +1,7 @@
 # rule-parser
 
 The grammar for HalleyAssist rules
+
+## Documentation
+
+- [Built-in Functions](BUILTIN_FUNCTIONS.md) - Complete documentation of all built-in functions, operators, and data structures used in the rule parser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halleyassist/rule-parser",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "The grammar for HalleyAssist rules",
   "main": "src/RuleParser.production.js",
   "scripts": {

package/src/RuleParser.js

@@ -91,25 +91,22 @@ class RuleParser {
         return ret
     }
     static _parseDowRange(dowRange) {
-        const dow = [];
         // dow_range can have 1 or 2 children (single day or range)
         if (dowRange.children.length === 1) {
-            // Single day: ON MONDAY
-            dow.push(normalizeDow(dowRange.children[0].text));
+            // Single day: ON MONDAY - return just the day string
+            return { start: normalizeDow(dowRange.children[0].text), end: normalizeDow(dowRange.children[0].text) };
         } else if (dowRange.children.length === 2) {
-            // Range: ON MONDAY TO WEDNESDAY
-            dow.push(normalizeDow(dowRange.children[0].text));
-            dow.push(normalizeDow(dowRange.children[1].text));
+            // Range: ON MONDAY TO FRIDAY - return both start and end days
+            return { start: normalizeDow(dowRange.children[0].text), end: normalizeDow(dowRange.children[1].text) };
         } else {
             throw new Error(`Invalid dow_range with ${dowRange.children.length} children`);
         }
-        return dow;
     }
     static _addDowToTods(startTod, endTod, dowRange) {
         if (dowRange && dowRange.type === 'dow_range') {
             const dow = RuleParser._parseDowRange(dowRange)
-            startTod.dow = dow
-            endTod.dow = dow
+            startTod.dow = dow.start
+            endTod.dow = dow.end
         }
     }
     static _parseTimePeriod(tp){
@@ -143,11 +140,13 @@ class RuleParser {
                 // time_period_ago_between has children[0] = number_time, children[1] = between_tod_only
                 const betweenTodOnly = tp.children[1]
                 const betweenTod = betweenTodOnly.children[0]
-                const startTod = RuleParser.__parseValue(betweenTod.children[0])
-                const endTod = RuleParser.__parseValue(betweenTod.children[1])
+                let startTod = RuleParser.__parseValue(betweenTod.children[0])
+                let endTod = RuleParser.__parseValue(betweenTod.children[1])
                 
                 // Check if there's a dow_range at betweenTod.children[2]
                 if (betweenTod.children.length > 2) {
+                    if(typeof startTod === 'number') startTod = {seconds: startTod, dow: null}
+                    if(typeof endTod === 'number') endTod = {seconds: endTod, dow: null}
                     RuleParser._addDowToTods(startTod, endTod, betweenTod.children[2])
                 }
                 
@@ -156,11 +155,13 @@ class RuleParser {
             case 'between_tod_only': {
                 // between_tod_only has children[0] = between_tod node
                 const betweenTod = tp.children[0]
-                const startTod = RuleParser.__parseValue(betweenTod.children[0])
-                const endTod = RuleParser.__parseValue(betweenTod.children[1])
+                let startTod = RuleParser.__parseValue(betweenTod.children[0])
+                let endTod = RuleParser.__parseValue(betweenTod.children[1])
                 
                 // Check if there's a dow_range at betweenTod.children[2]
                 if (betweenTod.children.length > 2) {
+                    if(typeof startTod === 'number') startTod = {seconds: startTod, dow: null}
+                    if(typeof endTod === 'number') endTod = {seconds: endTod, dow: null}
                     RuleParser._addDowToTods(startTod, endTod, betweenTod.children[2])
                 }
                 
@@ -176,8 +177,13 @@ class RuleParser {
                 // If DOW filters are provided, append them as additional parameters
                 if (betweenNumberTime.children.length > 2 && betweenNumberTime.children[2].type === 'dow_range') {
                     const dow = RuleParser._parseDowRange(betweenNumberTime.children[2])
-                    // Append DOW as additional arguments: ["TimePeriodBetween", start, end, "MONDAY"] or ["TimePeriodBetween", start, end, "MONDAY", "FRIDAY"]
-                    return ["TimePeriodBetween", startValue, endValue, ...dow]
+                    if (dow.start === dow.end) {
+                        // Single day: ["TimePeriodBetween", start, end, "MONDAY"]
+                        return ["TimePeriodBetween", startValue, endValue, dow.start]
+                    } else {
+                        // Range: ["TimePeriodBetween", start, end, "MONDAY", "FRIDAY"]
+                        return ["TimePeriodBetween", startValue, endValue, dow.start, dow.end]
+                    }
                 }
                 
                 return ["TimePeriodBetween", startValue, endValue]
@@ -285,12 +291,43 @@ class RuleParser {
         }
         throw new Error(`Unknown arithmetic operand type ${type}`)
     }
+    static _isConstantValue(expr){
+        // Check if an expression is a constant value
+        return Array.isArray(expr) && expr.length === 2 && expr[0] === 'Value' && typeof expr[1] === 'number'
+    }
+    
+    static _evaluateConstantArithmetic(operator, leftValue, rightValue){
+        // Evaluate constant arithmetic operations at parse time
+        switch(operator){
+            case 'MathAdd':
+                return leftValue + rightValue
+            case 'MathSub':
+                return leftValue - rightValue
+            case 'MathMul':
+                return leftValue * rightValue
+            case 'MathDiv':
+                return leftValue / rightValue
+            case 'MathMod':
+                return leftValue % rightValue
+            default:
+                return null
+        }
+    }
+    
     static _parseArithmeticResult(result){
         assert(result.children.length == 3)
         const partA = RuleParser._parseArithmeticOperand(result.children[0])
         const operatorFn = ArithmeticOperators[result.children[1].text]
         const partB = RuleParser.__parseArithmeticResult(result, 2)
 
+        // Compile out constant expressions
+        if (RuleParser._isConstantValue(partA) && RuleParser._isConstantValue(partB)) {
+            const result = RuleParser._evaluateConstantArithmetic(operatorFn, partA[1], partB[1])
+            if (result !== null) {
+                return ['Value', result]
+            }
+        }
+
         return [operatorFn, partA, partB]
     }
 

package/src/RuleParser.production.js

@@ -91,25 +91,22 @@ class RuleParser {
         return ret
     }
     static _parseDowRange(dowRange) {
-        const dow = [];
         // dow_range can have 1 or 2 children (single day or range)
         if (dowRange.children.length === 1) {
-            // Single day: ON MONDAY
-            dow.push(normalizeDow(dowRange.children[0].text));
+            // Single day: ON MONDAY - return just the day string
+            return { start: normalizeDow(dowRange.children[0].text), end: normalizeDow(dowRange.children[0].text) };
         } else if (dowRange.children.length === 2) {
-            // Range: ON MONDAY TO WEDNESDAY
-            dow.push(normalizeDow(dowRange.children[0].text));
-            dow.push(normalizeDow(dowRange.children[1].text));
+            // Range: ON MONDAY TO FRIDAY - return both start and end days
+            return { start: normalizeDow(dowRange.children[0].text), end: normalizeDow(dowRange.children[1].text) };
         } else {
             throw new Error(`Invalid dow_range with ${dowRange.children.length} children`);
         }
-        return dow;
     }
     static _addDowToTods(startTod, endTod, dowRange) {
         if (dowRange && dowRange.type === 'dow_range') {
             const dow = RuleParser._parseDowRange(dowRange)
-            startTod.dow = dow
-            endTod.dow = dow
+            startTod.dow = dow.start
+            endTod.dow = dow.end
         }
     }
     static _parseTimePeriod(tp){
@@ -143,11 +140,13 @@ class RuleParser {
                 // time_period_ago_between has children[0] = number_time, children[1] = between_tod_only
                 const betweenTodOnly = tp.children[1]
                 const betweenTod = betweenTodOnly.children[0]
-                const startTod = RuleParser.__parseValue(betweenTod.children[0])
-                const endTod = RuleParser.__parseValue(betweenTod.children[1])
+                let startTod = RuleParser.__parseValue(betweenTod.children[0])
+                let endTod = RuleParser.__parseValue(betweenTod.children[1])
                 
                 // Check if there's a dow_range at betweenTod.children[2]
                 if (betweenTod.children.length > 2) {
+                    if(typeof startTod === 'number') startTod = {seconds: startTod, dow: null}
+                    if(typeof endTod === 'number') endTod = {seconds: endTod, dow: null}
                     RuleParser._addDowToTods(startTod, endTod, betweenTod.children[2])
                 }
                 
@@ -156,11 +155,13 @@ class RuleParser {
             case 'between_tod_only': {
                 // between_tod_only has children[0] = between_tod node
                 const betweenTod = tp.children[0]
-                const startTod = RuleParser.__parseValue(betweenTod.children[0])
-                const endTod = RuleParser.__parseValue(betweenTod.children[1])
+                let startTod = RuleParser.__parseValue(betweenTod.children[0])
+                let endTod = RuleParser.__parseValue(betweenTod.children[1])
                 
                 // Check if there's a dow_range at betweenTod.children[2]
                 if (betweenTod.children.length > 2) {
+                    if(typeof startTod === 'number') startTod = {seconds: startTod, dow: null}
+                    if(typeof endTod === 'number') endTod = {seconds: endTod, dow: null}
                     RuleParser._addDowToTods(startTod, endTod, betweenTod.children[2])
                 }
                 
@@ -176,8 +177,13 @@ class RuleParser {
                 // If DOW filters are provided, append them as additional parameters
                 if (betweenNumberTime.children.length > 2 && betweenNumberTime.children[2].type === 'dow_range') {
                     const dow = RuleParser._parseDowRange(betweenNumberTime.children[2])
-                    // Append DOW as additional arguments: ["TimePeriodBetween", start, end, "MONDAY"] or ["TimePeriodBetween", start, end, "MONDAY", "FRIDAY"]
-                    return ["TimePeriodBetween", startValue, endValue, ...dow]
+                    if (dow.start === dow.end) {
+                        // Single day: ["TimePeriodBetween", start, end, "MONDAY"]
+                        return ["TimePeriodBetween", startValue, endValue, dow.start]
+                    } else {
+                        // Range: ["TimePeriodBetween", start, end, "MONDAY", "FRIDAY"]
+                        return ["TimePeriodBetween", startValue, endValue, dow.start, dow.end]
+                    }
                 }
                 
                 return ["TimePeriodBetween", startValue, endValue]
@@ -285,12 +291,43 @@ class RuleParser {
         }
         throw new Error(`Unknown arithmetic operand type ${type}`)
     }
+    static _isConstantValue(expr){
+        // Check if an expression is a constant value
+        return Array.isArray(expr) && expr.length === 2 && expr[0] === 'Value' && typeof expr[1] === 'number'
+    }
+    
+    static _evaluateConstantArithmetic(operator, leftValue, rightValue){
+        // Evaluate constant arithmetic operations at parse time
+        switch(operator){
+            case 'MathAdd':
+                return leftValue + rightValue
+            case 'MathSub':
+                return leftValue - rightValue
+            case 'MathMul':
+                return leftValue * rightValue
+            case 'MathDiv':
+                return leftValue / rightValue
+            case 'MathMod':
+                return leftValue % rightValue
+            default:
+                return null
+        }
+    }
+    
     static _parseArithmeticResult(result){
         assert(result.children.length == 3)
         const partA = RuleParser._parseArithmeticOperand(result.children[0])
         const operatorFn = ArithmeticOperators[result.children[1].text]
         const partB = RuleParser.__parseArithmeticResult(result, 2)
 
+        // Compile out constant expressions
+        if (RuleParser._isConstantValue(partA) && RuleParser._isConstantValue(partB)) {
+            const result = RuleParser._evaluateConstantArithmetic(operatorFn, partA[1], partB[1])
+            if (result !== null) {
+                return ['Value', result]
+            }
+        }
+
         return [operatorFn, partA, partB]
     }