@halleyassist/rule-parser 0.1.1 → 0.1.4

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@halleyassist/rule-parser",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "The grammar for HalleyAssist rules",
-  "main": "index.js",
+  "main": "src/RuleParser.production.js",
   "scripts": {
     "test": "mocha"
   },
@@ -20,11 +20,15 @@
     "ebnf": "^1.9.1"
   },
   "devDependencies": {
-    "chai": "^4.4.1",
+    "chai": "^4",
     "mocha": "^10.4.0"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
-  }
+  },
+  "files": [
+    "src/*",
+    "index.js"
+  ]
 }

package/src/RuleParser.ebnf.js

@@ -0,0 +1,78 @@
+const {Grammars} = require('ebnf');
+
+const grammar = `
+statement_main       ::= statement EOF
+logical_operator     ::= AND | OR
+statement            ::= expression (logical_operator expression)*
+expression           ::= not_expression | standard_expression | parenthesis_expression
+parenthesis_expression::= BEGIN_PARENTHESIS WS* statement WS* END_PARENTHESIS
+not_expression       ::= NOT (result | parenthesis_expression)
+standard_expression  ::= result ((WS* eq_approx) | (WS* basic_rhs) | ((WS+ IS)? WS+ between))?
+basic_rhs            ::= operator WS*  result
+eq_approx            ::= eq_operator WS* "~" WS* result
+
+PLUS                 ::= "+"
+MINUS                ::= "-"
+MULTIPLY             ::= "*"
+DIVIDE               ::= "/"
+MODULUS              ::= "%"
+DEFAULT_VAL          ::= "??"
+arithmetic_operator  ::= PLUS | MINUS | MULTIPLY | DIVIDE | MODULUS | DEFAULT_VAL
+arithmetic_result    ::= simple_result WS* arithmetic_operator WS* ( arithmetic_result | simple_result )
+
+simple_result        ::= fcall | value
+result               ::= arithmetic_result | simple_result
+value                ::= false | true | array | number_time | number | number_tod | time_period | string
+BEGIN_ARRAY          ::= WS* #x5B WS*  /* [ left square bracket */
+BEGIN_OBJECT         ::= WS* #x7B WS*  /* { left curly bracket */
+END_ARRAY            ::= WS* #x5D WS*  /* ] right square bracket */
+END_OBJECT           ::= WS* #x7D WS*  /* } right curly bracket */
+NAME_SEPARATOR       ::= WS* #x3A WS*  /* : colon */
+VALUE_SEPARATOR      ::= WS* #x2C WS*  /* , comma */
+WS                   ::= [#x20#x09#x0A#x0D]+   /* Space | Tab | \n | \r */
+
+operator             ::= GTE | LTE | GT | LT | EQ | NEQ
+eq_operator          ::= EQ | NEQ
+
+BEGIN_ARGUMENT       ::= "("
+END_ARGUMENT         ::= ")"
+
+BEGIN_PARENTHESIS    ::= "("
+END_PARENTHESIS      ::= ")"
+
+argument             ::= statement WS* ("," WS*)?
+arguments            ::= argument*
+fname                ::= [a-zA-z0-9]+
+fcall                ::= fname WS* BEGIN_ARGUMENT arguments? END_ARGUMENT
+
+between_number       ::= number ((WS+ ("and" | "AND") WS+) | (WS* "-" WS*)) number
+between_tod          ::= number_tod ((WS+ ("and" | "AND") WS+)) number_tod
+between              ::= ("between" | "BETWEEN") WS+ (between_number | between_tod)
+
+AND                  ::= (WS* "&&" WS*) | (WS+ ("AND"|"and") WS+)
+OR                   ::= (WS* "||" WS*) | (WS+ ("OR"|"or") WS+)
+GT                   ::= ">"
+LT                   ::= "<"
+GTE                  ::= ">="
+LTE                  ::= "<="
+IS                   ::= "is" | "IS"
+EQ                   ::= "==" | "="
+NEQ                  ::= "!="
+NOT                  ::= ("!" WS*) | ("not" WS+)
+false                ::= "false" | "FALSE"
+null                 ::= "null" | "NULL"
+true                 ::= "true" | "TRUE"
+array                ::= BEGIN_ARRAY (value (VALUE_SEPARATOR value)*)? END_ARRAY
+
+unit                 ::= "seconds" | "second" | "minutes" | "minute" | "min" | "mins" | "min" | "hours" | "hour" | "days" | "day" | "weeks" | "week"
+number               ::= "-"? ([0-9]+) ("." [0-9]+)? (("e" | "E") ( "-" | "+" )? ("0" | [1-9] [0-9]*))?
+number_time          ::= number WS+ unit
+number_tod           ::= ([0-9]+) ":" ([0-9]+)
+
+time_period_const    ::= "today"
+time_period          ::= time_period_const | between
+
+string               ::= '"' (([#x20-#x21] | [#x23-#x5B] | [#x5D-#xFFFF]) | #x5C (#x22 | #x5C | #x2F | #x62 | #x66 | #x6E | #x72 | #x74 | #x75 HEXDIG HEXDIG HEXDIG HEXDIG))* '"'
+HEXDIG               ::= [a-fA-F0-9]
+`
+module.exports = Grammars.W3C.getRules(grammar);

package/src/RuleParser.ebnf.json

@@ -0,0 +1 @@
+[{"name":"statement_main","bnf":[["statement","EOF"]]},{"name":"logical_operator","bnf":[["AND"],["OR"]]},{"name":"%statement0","bnf":[["logical_operator","expression"]],"fragment":true},{"name":"statement","bnf":[["expression","%statement0*"]]},{"name":"expression","bnf":[["not_expression"],["standard_expression"],["parenthesis_expression"]]},{"name":"parenthesis_expression","bnf":[["BEGIN_PARENTHESIS","WS*","statement","WS*","END_PARENTHESIS"]]},{"name":"%not_expression1","bnf":[["result"],["parenthesis_expression"]],"fragment":true},{"name":"not_expression","bnf":[["NOT","%not_expression1"]]},{"name":"%%standard_expression23","bnf":[["WS*","eq_approx"]],"fragment":true},{"name":"%%standard_expression24","bnf":[["WS*","basic_rhs"]],"fragment":true},{"name":"%%%standard_expression256","bnf":[["WS+","IS"]],"fragment":true},{"name":"%%standard_expression25","bnf":[["%%%standard_expression256?","WS+","between"]],"fragment":true},{"name":"%standard_expression2","bnf":[["%%standard_expression23"],["%%standard_expression24"],["%%standard_expression25"]],"fragment":true},{"name":"standard_expression","bnf":[["result","%standard_expression2?"]]},{"name":"basic_rhs","bnf":[["operator","WS*","result"]]},{"name":"eq_approx","bnf":[["eq_operator","WS*","\"~\"","WS*","result"]]},{"name":"PLUS","bnf":[["\"+\""]]},{"name":"MINUS","bnf":[["\"-\""]]},{"name":"MULTIPLY","bnf":[["\"*\""]]},{"name":"DIVIDE","bnf":[["\"/\""]]},{"name":"MODULUS","bnf":[["\"%\""]]},{"name":"DEFAULT_VAL","bnf":[["\"??\""]]},{"name":"arithmetic_operator","bnf":[["PLUS"],["MINUS"],["MULTIPLY"],["DIVIDE"],["MODULUS"],["DEFAULT_VAL"]]},{"name":"%arithmetic_result7","bnf":[["arithmetic_result"],["simple_result"]],"fragment":true},{"name":"arithmetic_result","bnf":[["simple_result","WS*","arithmetic_operator","WS*","%arithmetic_result7"]]},{"name":"simple_result","bnf":[["fcall"],["value"]]},{"name":"result","bnf":[["arithmetic_result"],["simple_result"]]},{"name":"value","bnf":[["false"],["true"],["array"],["number_time"],["number"],["number_tod"],["time_period"],["string"]]},{"name":"BEGIN_ARRAY","bnf":[["WS*",{},"WS*"]]},{"name":"BEGIN_OBJECT","bnf":[["WS*",{},"WS*"]]},{"name":"END_ARRAY","bnf":[["WS*",{},"WS*"]]},{"name":"END_OBJECT","bnf":[["WS*",{},"WS*"]]},{"name":"NAME_SEPARATOR","bnf":[["WS*",{},"WS*"]]},{"name":"VALUE_SEPARATOR","bnf":[["WS*",{},"WS*"]]},{"name":"%WS8","bnf":[[{}]]},{"name":"WS","bnf":[["%WS8+"]]},{"name":"operator","bnf":[["GTE"],["LTE"],["GT"],["LT"],["EQ"],["NEQ"]]},{"name":"eq_operator","bnf":[["EQ"],["NEQ"]]},{"name":"BEGIN_ARGUMENT","bnf":[["\"(\""]]},{"name":"END_ARGUMENT","bnf":[["\")\""]]},{"name":"BEGIN_PARENTHESIS","bnf":[["\"(\""]]},{"name":"END_PARENTHESIS","bnf":[["\")\""]]},{"name":"%argument9","bnf":[["\",\"","WS*"]],"fragment":true},{"name":"argument","bnf":[["statement","WS*","%argument9?"]]},{"name":"arguments","bnf":[["argument*"]]},{"name":"%fname10","bnf":[[{}]]},{"name":"fname","bnf":[["%fname10+"]]},{"name":"fcall","bnf":[["fname","WS*","BEGIN_ARGUMENT","arguments?","END_ARGUMENT"]]},{"name":"%%%between_number111213","bnf":[["\"and\""],["\"AND\""]],"fragment":true},{"name":"%%between_number1112","bnf":[["WS+","%%%between_number111213","WS+"]],"fragment":true},{"name":"%%between_number1114","bnf":[["WS*","\"-\"","WS*"]],"fragment":true},{"name":"%between_number11","bnf":[["%%between_number1112"],["%%between_number1114"]],"fragment":true},{"name":"between_number","bnf":[["number","%between_number11","number"]]},{"name":"%%%between_tod151617","bnf":[["\"and\""],["\"AND\""]],"fragment":true},{"name":"%%between_tod1516","bnf":[["WS+","%%%between_tod151617","WS+"]],"fragment":true},{"name":"%between_tod15","bnf":[["%%between_tod1516"]],"fragment":true},{"name":"between_tod","bnf":[["number_tod","%between_tod15","number_tod"]]},{"name":"%between18","bnf":[["\"between\""],["\"BETWEEN\""]],"fragment":true},{"name":"%between19","bnf":[["between_number"],["between_tod"]],"fragment":true},{"name":"between","bnf":[["%between18","WS+","%between19"]]},{"name":"%AND20","bnf":[["WS*","\"&&\"","WS*"]],"fragment":true},{"name":"%%AND2122","bnf":[["\"AND\""],["\"and\""]],"fragment":true},{"name":"%AND21","bnf":[["WS+","%%AND2122","WS+"]],"fragment":true},{"name":"AND","bnf":[["%AND20"],["%AND21"]]},{"name":"%OR23","bnf":[["WS*","\"||\"","WS*"]],"fragment":true},{"name":"%%OR2425","bnf":[["\"OR\""],["\"or\""]],"fragment":true},{"name":"%OR24","bnf":[["WS+","%%OR2425","WS+"]],"fragment":true},{"name":"OR","bnf":[["%OR23"],["%OR24"]]},{"name":"GT","bnf":[["\">\""]]},{"name":"LT","bnf":[["\"<\""]]},{"name":"GTE","bnf":[["\">=\""]]},{"name":"LTE","bnf":[["\"<=\""]]},{"name":"IS","bnf":[["\"is\""],["\"IS\""]]},{"name":"EQ","bnf":[["\"==\""],["\"=\""]]},{"name":"NEQ","bnf":[["\"!=\""]]},{"name":"%NOT26","bnf":[["\"!\"","WS*"]],"fragment":true},{"name":"%NOT27","bnf":[["\"not\"","WS+"]],"fragment":true},{"name":"NOT","bnf":[["%NOT26"],["%NOT27"]]},{"name":"false","bnf":[["\"false\""],["\"FALSE\""]]},{"name":"null","bnf":[["\"null\""],["\"NULL\""]]},{"name":"true","bnf":[["\"true\""],["\"TRUE\""]]},{"name":"%%array2829","bnf":[["VALUE_SEPARATOR","value"]],"fragment":true},{"name":"%array28","bnf":[["value","%%array2829*"]],"fragment":true},{"name":"array","bnf":[["BEGIN_ARRAY","%array28?","END_ARRAY"]]},{"name":"unit","bnf":[["\"seconds\""],["\"second\""],["\"minutes\""],["\"minute\""],["\"min\""],["\"mins\""],["\"min\""],["\"hours\""],["\"hour\""],["\"days\""],["\"day\""],["\"weeks\""],["\"week\""]]},{"name":"%%number3031","bnf":[[{}]]},{"name":"%number30","bnf":[["%%number3031+"]],"fragment":true},{"name":"%%number3233","bnf":[[{}]]},{"name":"%number32","bnf":[["\".\"","%%number3233+"]],"fragment":true},{"name":"%%number3435","bnf":[["\"e\""],["\"E\""]],"fragment":true},{"name":"%%number3436","bnf":[["\"-\""],["\"+\""]],"fragment":true},{"name":"%%%number343738","bnf":[[{}]]},{"name":"%%number3437","bnf":[["\"0\""],[{},"%%%number343738*"]],"fragment":true},{"name":"%number34","bnf":[["%%number3435","%%number3436?","%%number3437"]],"fragment":true},{"name":"number","bnf":[["\"-\"?","%number30","%number32?","%number34?"]]},{"name":"number_time","bnf":[["number","WS+","unit"]]},{"name":"%%number_tod3940","bnf":[[{}]]},{"name":"%number_tod39","bnf":[["%%number_tod3940+"]],"fragment":true},{"name":"%%number_tod4142","bnf":[[{}]]},{"name":"%number_tod41","bnf":[["%%number_tod4142+"]],"fragment":true},{"name":"number_tod","bnf":[["%number_tod39","\":\"","%number_tod41"]]},{"name":"time_period_const","bnf":[["\"today\""]]},{"name":"time_period","bnf":[["time_period_const"],["between"]]},{"name":"%%string4344","bnf":[[{}],[{}],[{}]],"fragment":true},{"name":"%%string4345","bnf":[[{}],[{}],[{}],[{}],[{}],[{}],[{}],[{}],[{},"HEXDIG","HEXDIG","HEXDIG","HEXDIG"]],"fragment":true},{"name":"%string43","bnf":[["%%string4344"],[{},"%%string4345"]],"fragment":true},{"name":"string","bnf":[["'\"'","%string43*","'\"'"]]},{"name":"HEXDIG","bnf":[[{}]]}]

package/src/RuleParser.js

@@ -1,85 +1,8 @@
-const { Grammars, Parser } = require('ebnf'),
+const { Parser } = require('ebnf'),
       assert = require('assert')
 
-
-const grammar = `
-statement_main       ::= statement EOF
-logical_operator     ::= AND | OR
-statement            ::= expression (logical_operator expression)*
-expression           ::= not_expression | standard_expression | parenthesis_expression
-parenthesis_expression::= BEGIN_PARENTHESIS WS* statement WS* END_PARENTHESIS
-not_expression       ::= NOT (result | parenthesis_expression)
-standard_expression  ::= result ((WS* eq_approx) | (WS* basic_rhs) | ((WS+ IS)? WS+ between))?
-basic_rhs            ::= operator WS*  result
-eq_approx            ::= eq_operator WS* "~" WS* result
-
-PLUS                 ::= "+"
-MINUS                ::= "-"
-MULTIPLY             ::= "*"
-DIVIDE               ::= "/"
-MODULUS              ::= "%"
-DEFAULT_VAL          ::= "??"
-arithmetic_operator  ::= PLUS | MINUS | MULTIPLY | DIVIDE | MODULUS | DEFAULT_VAL
-arithmetic_result    ::= simple_result WS* arithmetic_operator WS* ( arithmetic_result | simple_result )
-
-simple_result        ::= fcall | value
-result               ::= arithmetic_result | simple_result
-value                ::= false | true | array | number_time | number | number_tod | time_period | string
-BEGIN_ARRAY          ::= WS* #x5B WS*  /* [ left square bracket */
-BEGIN_OBJECT         ::= WS* #x7B WS*  /* { left curly bracket */
-END_ARRAY            ::= WS* #x5D WS*  /* ] right square bracket */
-END_OBJECT           ::= WS* #x7D WS*  /* } right curly bracket */
-NAME_SEPARATOR       ::= WS* #x3A WS*  /* : colon */
-VALUE_SEPARATOR      ::= WS* #x2C WS*  /* , comma */
-WS                   ::= [#x20#x09#x0A#x0D]+   /* Space | Tab | \n | \r */
-
-operator             ::= GTE | LTE | GT | LT | EQ | NEQ
-eq_operator          ::= EQ | NEQ
-
-BEGIN_ARGUMENT       ::= "("
-END_ARGUMENT         ::= ")"
-
-BEGIN_PARENTHESIS    ::= "("
-END_PARENTHESIS      ::= ")"
-
-argument             ::= statement WS* ("," WS*)?
-arguments            ::= argument*
-fname                ::= [a-zA-z0-9]+
-fcall                ::= fname WS* BEGIN_ARGUMENT arguments? END_ARGUMENT
-
-between_number       ::= number ((WS+ ("and" | "AND") WS+) | (WS* "-" WS*)) number
-between_tod          ::= number_tod ((WS+ ("and" | "AND") WS+)) number_tod
-between              ::= ("between" | "BETWEEN") WS+ (between_number | between_tod)
-
-AND                  ::= (WS* "&&" WS*) | (WS+ ("AND"|"and") WS+)
-OR                   ::= (WS* "||" WS*) | (WS+ ("OR"|"or") WS+)
-GT                   ::= ">"
-LT                   ::= "<"
-GTE                  ::= ">="
-LTE                  ::= "<="
-IS                   ::= "is" | "IS"
-EQ                   ::= "==" | "="
-NEQ                  ::= "!="
-NOT                  ::= ("!" WS*) | ("not" WS+)
-false                ::= "false" | "FALSE"
-null                 ::= "null" | "NULL"
-true                 ::= "true" | "TRUE"
-array                ::= BEGIN_ARRAY (value (VALUE_SEPARATOR value)*)? END_ARRAY
-
-unit                 ::= "seconds" | "second" | "minutes" | "minute" | "min" | "mins" | "min" | "hours" | "hour" | "days" | "day" | "weeks" | "week"
-number               ::= "-"? ([0-9]+) ("." [0-9]+)? (("e" | "E") ( "-" | "+" )? ("0" | [1-9] [0-9]*))?
-number_time          ::= number WS+ unit
-number_tod           ::= ([0-9]+) ":" ([0-9]+)
-
-time_period_const    ::= "today"
-time_period          ::= time_period_const | between
-
-string               ::= '"' (([#x20-#x21] | [#x23-#x5B] | [#x5D-#xFFFF]) | #x5C (#x22 | #x5C | #x2F | #x62 | #x66 | #x6E | #x72 | #x74 | #x75 HEXDIG HEXDIG HEXDIG HEXDIG))* '"'
-HEXDIG               ::= [a-fA-F0-9]
-`
-let RULES = Grammars.W3C.getRules(grammar);
-let parser = new Parser(RULES, {debug: false});
-const target = 'statement_main'
+let ParserRules = require('./RuleParser.ebnf.js')
+let ParserCache;
 
 const ArithmeticOperators = {
     "+": 'MathAdd',
@@ -114,10 +37,12 @@ const Epsilon = 0.01
 class RuleParser {
     static toAst(txt){
         let ret
-        //if(process.env.NODE_ENV === 'test') {
-        //    parser.debug = true
-        //}
-        ret = parser.getAST(txt, target);
+
+        if(!ParserCache){
+            ParserCache = new Parser(ParserRules, {debug: false})
+        }
+
+        ret = ParserCache.getAST(txt, 'statement_main');
         
         if(ret){
             return ret.children[0]

package/src/RuleParser.production.js

@@ -0,0 +1,284 @@
+const { Parser } = require('ebnf'),
+      assert = require('assert')
+
+let ParserRules = require('./RuleParser.ebnf.json')
+let ParserCache;
+
+const ArithmeticOperators = {
+    "+": 'MathAdd',
+    "-": 'MathSub',
+    "/": 'MathDiv',
+    "*": 'MathMul',
+    "%": 'MathMod',
+    "??": "Default"
+}
+
+const OperatorFn = {
+    ">": "Gt",
+    "<": "Lt",
+    ">=": "Gte",
+    "<=": "Lte",
+    "==": "Eq",
+    "=": "Eq",
+    "!=": "Neq"
+}
+
+const LogicalOperators = {
+    "&&": 'And',
+    "AND": 'And',
+    "and": 'And',
+    "||": 'Or',
+    "OR": 'Or',
+    "or": 'Or',
+}
+
+const Epsilon = 0.01
+
+class RuleParser {
+    static toAst(txt){
+        let ret
+
+        if(!ParserCache){
+            ParserCache = new Parser(ParserRules, {debug: false})
+        }
+
+        ret = ParserCache.getAST(txt, 'statement_main');
+        
+        if(ret){
+            return ret.children[0]
+        }
+    }
+    static _parseArgument(argument){
+        assert(argument.type === 'argument')
+        const child = argument.children[0]
+        return RuleParser._buildExpressionGroup(child)
+    }
+    static _parseFcall(fcall){
+        const fname = fcall.children[0]
+        const ret = [fname.text]
+        if(fcall.children.length != 1){
+            const args = fcall.children[1]
+            for(const a of args.children){
+                ret.push(RuleParser._parseArgument(a))
+            }
+        }
+        return ret
+    }
+    static _parseTimePeriod(tp){
+        switch(tp.type){
+            case 'time_period_const':
+                return ["TimePeriodConst", tp.text]
+            case 'between':
+                return ["TimePeriodBetween", RuleParser.__parseValue(tp.children[0]?.children[0]), RuleParser.__parseValue(tp.children[0]?.children[1])]
+        }
+    }
+    static __parseValue(child){
+        const type = child.type
+        switch(type){
+            case 'string': {
+                const str = child.text
+                return str.slice(1, -1)
+            }
+            case 'number':
+                return parseFloat(child.text)
+            case 'number_tod': {
+                const tokens = child.text.split(':')
+                if (tokens.length !== 2) {
+                    throw new Error(`Invalid time of day, ${child.text} should be ##:##`)
+                }
+                const hours = parseInt(tokens[0])
+                const minutes = parseInt(tokens[1])
+                const tod = hours * 100 + minutes
+                const ret = { hours, minutes, tod }
+                if (!isNaN(tod) && ret.hours >= 0 && ret.hours <= 24 && ret.minutes >= 0 && ret.minutes < 60) {
+                    return ret
+                }
+                throw new Error(`Invalid time of day, ${child.text} -> [${tokens.join(', ')}] -> ${hours}h${minutes}m -> ${tod}`)
+            }
+            case 'number_time': {
+                const nt = child
+                const mult = parseFloat(nt.children[0].text)
+                switch(nt.children[1].text){
+                    case 'seconds':
+                    case 'second':
+                        return mult
+                    case 'minutes':
+                    case 'minute':
+                    case 'mins':
+                    case 'min':
+                        return mult * 60
+                    case 'hours':
+                    case 'hour':
+                        return mult * 60 * 60
+                    case 'days':
+                    case 'day':
+                        return mult * 60 * 60 * 24
+                    case 'weeks':
+                    case 'week':
+                        return mult * 60 * 60 * 24 * 7
+                }
+                throw new Error(`Invalid exponent ${nt.children[1].text}`)
+            }
+            case 'true':
+                return true
+            case 'false':
+                return false
+            case 'array': {
+                const ret = []
+                for(const c of child.children){
+                    ret.push(RuleParser.__parseValue(c.children[0]))
+                }
+                return ret;
+            }
+            default:
+                throw new Error(`Unknown value type ${type}`)
+        }
+    }
+    static _parseValue(value){
+        const child = value.children[0]
+        
+        const type = child.type
+        switch(type){
+            case 'time_period': {
+                const tp = child.children[0]
+                return RuleParser._parseTimePeriod(tp)
+            }
+            default:
+                return ['Value', RuleParser.__parseValue(child)]
+        }
+    }
+    static _parseSimpleResult(result){
+        assert(result.children.length == 1)
+        const child = result.children[0]
+        const type = child.type
+        switch(type){
+            case 'fcall':
+                return RuleParser._parseFcall(child)
+            case 'value':
+                return RuleParser._parseValue(child)
+        }
+        return null
+    }
+    static _parseArithmeticResult(result){
+        assert(result.children.length == 3)
+        const partA = this._parseSimpleResult(result.children[0])
+        const operatorFn = ArithmeticOperators[result.children[1].text]
+        const partB = this.__parseResult(result, 2)
+
+        return [operatorFn, partA, partB]
+    }
+
+    static __parseResult(result, idx){
+        const child = result.children[idx]
+        const type = child.type
+        switch(type){
+            case 'simple_result':
+                return RuleParser._parseSimpleResult(child)
+            case 'arithmetic_result':
+                return RuleParser._parseArithmeticResult(child)
+        }
+        
+        throw new Error(`Unknown result node ${type}`)
+    }
+    static _parseResult(result){
+        assert(result.children.length == 1)
+
+        return RuleParser.__parseResult(result, 0)
+    }
+    static _parseStdExpression(expr){
+        assert(expr.type === 'standard_expression')
+        switch(expr.children.length){
+            case 1:
+                return RuleParser._parseResult(expr.children[0])
+            case 2: {
+                const rhs = expr.children[1]
+                switch(rhs.type){
+                    case 'between_tod':
+                    case 'between_number':
+                    case 'between':
+                        return ['Between', RuleParser._parseResult(expr.children[0]), ['Value', RuleParser.__parseValue(rhs.children[0].children[0])], ['Value', RuleParser.__parseValue(rhs.children[0].children[1])]]
+                    case 'basic_rhs':
+                        return [OperatorFn[rhs.children[0].text], RuleParser._parseResult(expr.children[0]), RuleParser._parseResult(rhs.children[1])]
+                    case 'eq_approx': {
+                        const rhsValue = RuleParser._parseResult(rhs.children[1])
+                        assert(rhsValue[0] === 'Value')
+                        const ret = ['Between', RuleParser._parseResult(expr.children[0]), ['Value', rhsValue[1] - Epsilon], ['Value', rhsValue[1] + Epsilon]]
+                        if(rhs.children[0].text === '!='){
+                            return ['Not', ret]
+                        }
+                        return ret
+                    }
+
+                    default:
+                        throw new Error(`unable to parse std expression, unknown rhs type ${rhs.type}`)
+                }
+            }
+                
+            default:
+                throw new Error(`unable to parse std expression, unknown number of children ${expr.children.length}`)
+        }
+    }
+    static buildLogical(members, fn){
+        return [fn, ...members]
+    }
+    static _buildExpressionGroup(ast){
+        let ret = []
+        let currentLogical = null
+        for(const expr of ast.children){
+            if(expr.type == 'logical_operator') {
+                const logicalOperator = expr.text.trim()
+                const operatorFn = LogicalOperators[logicalOperator]
+                assert(operatorFn, `Unknown logical operator ${logicalOperator}`)
+                if(currentLogical === null || currentLogical !== operatorFn){
+                    if(ret.length > 1){
+                        ret = [RuleParser.buildLogical(ret, currentLogical)]
+                    }
+                    currentLogical = operatorFn
+                }
+            }else{
+                ret.push(RuleParser._exprToIL(expr))
+            }
+        }
+        if(ret.length == 0){
+            throw new Error('invalid rule')
+        }
+        if(ret.length == 1){
+            return ret[0]
+        }
+        return RuleParser.buildLogical(ret, currentLogical)
+    }
+    static _parseParenthesisExpression(expr){
+        return RuleParser._buildExpressionGroup(expr.children[0])
+    }
+    static _exprToIL(expr){
+        assert(expr.type === 'expression')
+        assert(expr.children.length === 1)
+        const eInner = expr.children[0]
+        switch(eInner.type){
+            case 'standard_expression':
+                return RuleParser._parseStdExpression(eInner)
+            case 'not_expression': {
+                const child = eInner.children[0]
+                let result
+                switch(child.type){
+                    case 'parenthesis_expression':
+                        result = RuleParser._parseParenthesisExpression(child)
+                        break;
+                    default:
+                        result = RuleParser._parseResult(child)
+                }
+                return ['Not', result]
+            }
+            case 'parenthesis_expression':
+            return RuleParser._parseParenthesisExpression(eInner)
+            default:
+                throw new Error(`unknown type of expression ${eInner.type}`)
+        }
+    }
+    static toIL(txt){
+        const ast = RuleParser.toAst(txt)
+        if(!ast) throw new Error(`failed to parse ${txt}`)
+        return RuleParser._buildExpressionGroup(ast)
+    }
+}
+module.exports = RuleParser

package/.eslintrc.yml

@@ -1,8 +0,0 @@
-env:
-  node: true
-  es2021: true
-extends: 'eslint:recommended'
-parserOptions:
-  ecmaVersion: 12
-  sourceType: module
-rules: {}

package/.github/workflows/build.yml

@@ -1,69 +0,0 @@
-name: Build
-on:
-  push:
-
-jobs:
-  check_eslint:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install modules
-      run: |
-        sudo npm install -g eslint@8
-    - run: eslint index.js --ext .js,.jsx,.ts,.tsx
-  test:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@master
-    - name: Set up Node.js
-      uses: actions/setup-node@master
-      with:
-        node-version: 17
-    - run: |
-        npm install
-    - run: |
-        npm run-script test
-  npm:
-    name: npm-publish
-    if: "github.event_name == 'push'"
-    runs-on: ubuntu-latest
-    needs: [check_eslint,test]
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@master
-    - name: Set up Node.js
-      uses: actions/setup-node@master
-      with:
-        node-version: 16
-        registry-url: 'https://registry.npmjs.org'
-    - name: Install modules
-      run: |
-        npm install
-    - name: Test
-      run: npm test
-    - run: |
-        VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,' | sed -e 's/^v//')
-        jq '.version="'"$VERSION"'"' package.json > /tmp/a
-        mv /tmp/a package.json
-      if: "startsWith(github.ref, 'refs/tags/v')"
-    - run: |
-        # npm login --scope=@halleyassist --registry=https://registry.npmjs.org/
-        npm whoami
-      env: 
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}
-    - run: |
-        npm publish
-      env: 
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}
-      if: "startsWith(github.ref, 'refs/tags/v')"
-    - uses: actions/setup-node@v2
-      with:
-          node-version: 16
-          registry-url: https://npm.pkg.github.com/
-      if: "startsWith(github.ref, 'refs/tags/v')"
-    - run: |
-        npm publish
-      env:
-        NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-      if: "startsWith(github.ref, 'refs/tags/v')"

package/test/rule_parse_test.js

@@ -1,214 +0,0 @@
-const
-	RuleParser = require("../src/RuleParser"),
-	{ expect } = require('chai')
-
-describe("RuleParser", function () {
-	it("parse basic", function () {
-		expect(RuleParser.toIL("1 > 2")).to.be.eql(["Gt", ["Value", 1], ["Value", 2]])
-		expect(RuleParser.toIL("AFunction(1,2) > 3")).to.be.eql(["Gt", ["AFunction", ["Value", 1], ["Value", 2]], ["Value", 3]])
-		expect(RuleParser.toIL("AFunction(1,2)")).to.be.eql(["AFunction", ["Value", 1], ["Value", 2]])
-		expect(RuleParser.toIL("AFunction(\"string\",2) == \"string\"")).to.be.eql(["Eq", ["AFunction", ["Value", "string"], ["Value", 2]], ["Value", "string"]])
-	})
-	it("parse logic expression", function () {
-		expect(RuleParser.toIL("AFunction()")).to.be.eql(["AFunction"])
-		expect(RuleParser.toIL("!AFunction()")).to.be.eql(["Not", ["AFunction"]])
-		expect(RuleParser.toIL("! AFunction()")).to.be.eql(["Not", ["AFunction"]])
-		expect(RuleParser.toIL("not AFunction()")).to.be.eql(["Not", ["AFunction"]])
-	})
-	it("parse function no args", function () {
-		expect(RuleParser.toIL("AFunction() > 3")).to.be.eql(["Gt", ["AFunction"], ["Value", 3]])
-	})
-	it("parse number starting with 0", function () {
-		expect(RuleParser.toIL("AFunction() > 03")).to.be.eql(["Gt", ["AFunction"], ["Value", 3]])
-	})
-	it("should throw if additional junk", function () {
-		expect(function () {
-			RuleParser.toIL("AFunction() > 3 abc")
-		}).to.throw()
-	})
-	it("parse array", function () {
-		expect(RuleParser.toIL("AFunction([1,2])")).to.be.eql(["AFunction", ["Value", [1, 2]]])
-	})
-	it("should be able to parse all basic comparison operators", function () {
-		const operators = [
-			'==', '=', "!=", ">=", ">", "<=", '<'
-		]
-		for (const op of operators) {
-			const expression1 = `RoomDuration("Room 1") ${op} 5`
-			RuleParser.toIL(expression1)
-			const expression2 = `RoomDuration("Room 1")${op}5`
-			RuleParser.toIL(expression2)
-		}
-	})
-	it("should be able to parse the between operator", function () {
-		const expression1 = `RoomDuration("Room 1") between 1 and 5`
-		expect(RuleParser.toIL(expression1)).to.be.eql(['Between', ["RoomDuration", ["Value", "Room 1"]], ["Value", 1], ["Value", 5]])
-	})
-	it("should be able to parse the equals approximately operator", function () {
-		const expression1 = `RoomDuration("Room 1") == ~1`
-		expect(RuleParser.toIL(expression1)).to.be.eql([
-			'Between',
-			['RoomDuration', ['Value', 'Room 1']],
-			['Value', 0.99],
-			['Value', 1.01]
-		])
-	})
-	it("should be able to parse the approximately not equals operator", function () {
-		const expression1 = `RoomDuration("Room 1") !=~1`
-		expect(RuleParser.toIL(expression1)).to.be.eql([
-			'Not', ['Between',
-				['RoomDuration', ['Value', 'Room 1']],
-				['Value', 0.99],
-				['Value', 1.01]
-			]])
-	})
-	it("should be able to parse all time units", function () {
-		const unit = [
-			'second', 'minute', 'hour', 'day', 'week'
-		]
-		for (const u of unit) {
-			const expression1 = `RoomDuration(1 ${u})`
-			RuleParser.toIL(expression1)
-			const expression2 = `RoomDuration(1 ${u}s)`
-			RuleParser.toIL(expression2)
-		}
-	})
-	it("should be able to parse all time tp constants", function () {
-		const unit = [
-			'today'/*, "yesterday"*/
-		]
-		for (const u of unit) {
-			const expression1 = `RoomDuration(${u})`
-			const il = RuleParser.toIL(expression1)
-			expect(il).to.be.eql(['RoomDuration', ['TimePeriodConst', u]])
-		}
-	})
-	it("should be able to parse tp between", function () {
-		const expression1 = `RoomDuration(BETWEEN 01:00 and 24:00)`
-		const il = RuleParser.toIL(expression1)
-		const oneAm = {hours: 1, minutes: 0, tod: 100}
-		const midnight = {hours: 24, minutes: 0, tod: 2400}
-		expect(il).to.be.eql(['RoomDuration', ['TimePeriodBetween', oneAm, midnight]])
-	})
-	it("should be able to parse parenthesis", function () {
-		const expression1 = `(A()==2 and B()==1) and (C(2) && D(1))`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql([
-			'And',
-			['And', ['Eq', ["A"], ["Value", 2]], ['Eq', ["B"], ["Value", 1]]],
-			['And', ['C', ["Value", 2]], ['D', ["Value", 1]]]
-		])
-	})
-	it("should be able to parse not expressions (1)", function () {
-		const expression1 = `!D(1)`
-		let il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql(['Not', ['D', ['Value', 1]]])
-		const expression2 = `! D(1)&& !D(2)`
-		il = RuleParser.toIL(expression2)
-		expect(il).to.be.eql(['And', ['Not', ['D', ['Value', 1]]], ['Not', ['D', ['Value', 2]]]])
-		const expression3 = `(! D(1) && !D(3)) && !D(2)`
-		il = RuleParser.toIL(expression3)
-		expect(il).to.be.eql([
-			'And',
-			['And', ['Not', ['D', ['Value', 1]]], ['Not', ['D', ['Value', 3]]]],
-			['Not', ['D', ['Value', 2]]]
-		])
-	})
-	it("should be able to parse not expressions (2)", function () {
-		const expression1 = `(A()==2 and B()==1) and (C(2) && !D(1))`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql([
-			'And',
-			['And', ['Eq', ["A"], ["Value", 2]], ['Eq', ["B"], ["Value", 1]]],
-			['And', ['C', ["Value", 2]], ['Not', ['D', ["Value", 1]]]]
-		])
-	})
-	it("should be able to parse not expressions (3)", function () {
-		const expression1 = `(A()==2 and B()==1) and ! (C(2) && D(1))`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql([
-			'And',
-			['And', ['Eq', ["A"], ["Value", 2]], ['Eq', ["B"], ["Value", 1]]],
-			['Not', ['And', ['C', ["Value", 2]], ['D', ["Value", 1]]]]
-		])
-	})
-	it("should be able to parse or expressions (1)", function () {
-		const expression1 = `(A()==2 and B()==1) or (C(2) && D(1))`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql([
-			'Or',
-			['And', ['Eq', ["A"], ["Value", 2]], ['Eq', ["B"], ["Value", 1]]],
-			['And', ['C', ["Value", 2]], ['D', ["Value", 1]]]
-		])
-	})
-	it("should be able to parse or expressions (2)", function () {
-		const expression1 = `(A()==2 or B()==1) and (C(2) || D(1))`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql([
-			'And',
-			['Or', ['Eq', ["A"], ["Value", 2]], ['Eq', ["B"], ["Value", 1]]],
-			['Or', ['C', ["Value", 2]], ['D', ["Value", 1]]]
-		])
-	})
-	it("should be able to parse or expressions (3)", function () {
-		const expression1 = `A() or !(C(2) && D(1))`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql([
-			'Or',
-			["A"],
-			['Not', ['And', ['C', ["Value", 2]], ['D', ["Value", 1]]]]
-		])
-	})
-	it("should be able to parse or expressions (4)", function () {
-		const expression1 = `A() and !(C(2) || D(1))`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql([
-			'And',
-			["A"],
-			['Not', ['Or', ['C', ["Value", 2]], ['D', ["Value", 1]]]]
-		])
-	})
-
-	it("should be able to parse real or expressions (1)", function () {
-		const expression1 = "HasCapableSensor(\"weight\") && !((TimeOfDay() BETWEEN 0800 AND 1200 && Event(\"kind\") == \"measurement\" && EventHasData(\"weight\") && TimeLastTrueSet(\"slot1\")) || TimeLastTrueCheck(\"slot1\") < 5 minutes)"
-		const il = RuleParser.toIL(expression1) 
-		expect(il).to.be.eql(
-			["And", 
-			["HasCapableSensor", ["Value", "weight"]], 
-			["Not", ["Or", 
-				["And", ["Between", ["TimeOfDay"], ["Value", 800], ["Value", 1200]], ["Eq", ["Event", ["Value", "kind"]], ["Value", "measurement"]], ["EventHasData", ["Value", "weight"]], ["TimeLastTrueSet", ["Value", "slot1"]]], 
-				["Lt", ["TimeLastTrueCheck", ["Value", "slot1"]], ["Value", 300]]
-			]]])
-	})
-	it("should be able to parse arithmetic (1)", function () {
-		const expression1 = `A() + D(1) == 2`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql(["Eq",["MathAdd",["A"],["D",["Value",1]]],["Value",2]])
-	})
-	it("should be able to parse arithmetic (2)", function () {
-		const expression1 = `A() + D(1) * 4 == 2 * A()`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql(["Eq",["MathAdd",["A"],["MathMul",["D",["Value",1]],["Value",4]]],["MathMul",["Value",2],["A"]]])
-	})
-	it("should be able to parse arithmetic (3)", function () {
-		const expression1 = `A() + D(1)`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql(["MathAdd",["A"],["D",["Value",1]]])
-	})
-
-	it("should be able to parse && in arguments", function () {
-		const expression1 = `A(B() && C())`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql(["A",["And",["B"],["C"]]])
-	})
-	it("should be able to parse default value operator", function () {
-		const expression1 = `A() ?? 1`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql(["Default",["A"],["Value",1]])
-	})
-	it("should be able to parse default value operator in an expression", function () {
-		const expression1 = `A() ?? 1 < 20`
-		const il = RuleParser.toIL(expression1)
-		expect(il).to.be.eql(["Lt",["Default",["A"],["Value",1]],["Value",20]])
-	})
-});