@halleyassist/rule-templater 0.0.4 → 0.0.6

package/README.md

@@ -27,10 +27,15 @@ const parsed = RuleTemplate.parse(template);
 const variables = parsed.extractVariables();
 console.log(variables);
 // [
-//   { name: 'EVENT_TYPE', filters: [] },
-//   { name: 'THRESHOLD', filters: [] }
+//   { name: 'EVENT_TYPE', filters: [], positions: [{ start: 8, end: 21 }] },
+//   { name: 'THRESHOLD', filters: [], positions: [{ start: 36, end: 48 }] }
 // ]
 
+// Extract function calls from the template
+const functions = parsed.extractFunctions();
+console.log(functions);
+// ['EventIs', 'Value']
+
 // Validate that variables are provided correctly
 const validation = parsed.validate({
     EVENT_TYPE: { value: 'sensor-update', type: 'string' },
@@ -57,8 +62,8 @@ const parsed = RuleTemplate.parse(template);
 // Extract variables
 const variables = parsed.extractVariables();
 // [
-//   { name: 'ACTION', filters: [] },
-//   { name: 'TIME', filters: [] }
+//   { name: 'ACTION', filters: [], positions: [{ start: 48, end: 57 }] },
+//   { name: 'TIME', filters: [], positions: [{ start: 142, end: 149 }] }
 // ]
 
 // Prepare with values
@@ -79,7 +84,7 @@ const template = 'EventIs(${EVENT_TYPE|upper})';
 
 const parsed = RuleTemplate.parse(template);
 const variables = parsed.extractVariables();
-// [{ name: 'EVENT_TYPE', filters: ['upper'] }]
+// [{ name: 'EVENT_TYPE', filters: ['upper'], positions: [{ start: 8, end: 27 }] }]
 
 // Prepare with filters applied
 const prepared = parsed.prepare({
@@ -154,6 +159,28 @@ Extracts all variables from the template using the AST.
 **Returns:** Array of objects with:
 - `name` (string): The variable name
 - `filters` (array): Array of filter names applied to the variable
+- `positions` (array): Array of position objects, each with:
+  - `start` (number): Zero-based start index of the variable in the template string
+  - `end` (number): Zero-based end index of the variable in the template string
+
+Note: If a variable appears multiple times in the template, all occurrences will be recorded in the `positions` array.
+
+### `ruleTemplate.extractFunctions()`
+
+Extracts all function calls from the template using the AST.
+
+**Returns:** Array of unique function names (sorted alphabetically) used in the template.
+
+**Example:**
+```javascript
+const template = 'EventIs("test") && Value() > 10 && TimeLastTrueCheck("last_check") < 60';
+const parsed = RuleTemplate.parse(template);
+const functions = parsed.extractFunctions();
+console.log(functions);
+// ['EventIs', 'TimeLastTrueCheck', 'Value']
+```
+
+This is useful for comparing against a hub's list of available functions to ensure all functions used in the template are supported.
 
 ### `ruleTemplate.validate(variables)`
 

package/dist/rule-templater.browser.js

@@ -2113,11 +2113,11 @@ class RuleTemplate {
 
     /**
      * Extract variables from the template using the AST
-     * @returns {Array} Array of {name, filters: []} objects
+     * @returns {Array} Array of {name, filters: [], positions: [{start, end}]} objects
      */
     extractVariables(){
         const variables = [];
-        const seen = new Set();
+        const variableMap = new Map();
         
         const traverse = (node) => {
             if (!node) return;
@@ -2126,9 +2126,24 @@ class RuleTemplate {
             if (node.type === 'template_value') {
                 // Extract the variable information
                 const varInfo = this._extractVariableFromNode(node);
-                if (varInfo && !seen.has(varInfo.name)) {
-                    seen.add(varInfo.name);
-                    variables.push(varInfo);
+                if (varInfo) {
+                    // Add position to existing variable or create new entry
+                    if (variableMap.has(varInfo.name)) {
+                        const existing = variableMap.get(varInfo.name);
+                        existing.positions.push({
+                            start: varInfo.start,
+                            end: varInfo.end
+                        });
+                    } else {
+                        variableMap.set(varInfo.name, {
+                            name: varInfo.name,
+                            filters: varInfo.filters,
+                            positions: [{
+                                start: varInfo.start,
+                                end: varInfo.end
+                            }]
+                        });
+                    }
                 }
             }
             
@@ -2141,9 +2156,48 @@ class RuleTemplate {
         };
         
         traverse(this.ast);
+        
+        // Convert map to array
+        for (const variable of variableMap.values()) {
+            variables.push(variable);
+        }
+        
         return variables;
     }
 
+    /**
+     * Extract function calls from the template using the AST
+     * @returns {Array} Array of unique function names used in the template
+     */
+    extractFunctions(){
+        const functions = new Set();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a function call node
+            if (node.type === 'fcall') {
+                // Find the function name in children
+                const fnameNode = node.children?.find(c => c.type === 'fname');
+                if (fnameNode && fnameNode.text) {
+                    functions.add(fnameNode.text.trim());
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        
+        // Convert set to sorted array for consistent output
+        return Array.from(functions).sort();
+    }
+
     /**
      * Extract variable name and filters from a template_value AST node
      * @private
@@ -2172,7 +2226,11 @@ class RuleTemplate {
             }
         }
         
-        return { name, filters };
+        // Extract position information from the node
+        const start = node.start;
+        const end = node.end;
+        
+        return { name, filters, start, end };
     }
 
     /**

package/index.d.ts

@@ -1,6 +1,12 @@
+export interface VariablePosition {
+    start: number;
+    end: number;
+}
+
 export interface VariableInfo {
     name: string;
     filters: string[];
+    positions: VariablePosition[];
 }
 
 export interface VariableValue {
@@ -62,6 +68,12 @@ export default class RuleTemplate {
      */
     extractVariables(): VariableInfo[];
 
+    /**
+     * Extract function calls from the template using the AST
+     * @returns Array of unique function names used in the template
+     */
+    extractFunctions(): string[];
+
     /**
      * Validate variable types against the AST
      * @param variables Object mapping variable names to {value, type} objects
@@ -89,3 +101,24 @@ export default class RuleTemplate {
 export const ParserRules: any[];
 export const VariableTypes: string[];
 export const TemplateFilters: TemplateFiltersType;
+
+export interface IParsingErrorPosition {
+    offset: number;
+    line: number;
+    column: number;
+}
+
+export interface IFailureTreeNode {
+    name: string;
+    expected?: string | RegExp;
+    children?: IFailureTreeNode[];
+}
+
+export class ParsingError extends Error {
+    readonly position: IParsingErrorPosition;
+    readonly expected: string[];
+    readonly found: string;
+    readonly failureTree?: IFailureTreeNode[];
+    constructor(message: string, position: IParsingErrorPosition, expected: string[], found: string, failureTree?: IFailureTreeNode[]);
+    toString(): string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halleyassist/rule-templater",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "The grammar for HalleyAssist rules",
   "main": "src/RuleTemplater.production.js",
   "browser": "./dist/rule-templater.browser.js",

package/src/RuleTemplater.js

@@ -75,11 +75,11 @@ class RuleTemplate {
 
     /**
      * Extract variables from the template using the AST
-     * @returns {Array} Array of {name, filters: []} objects
+     * @returns {Array} Array of {name, filters: [], positions: [{start, end}]} objects
      */
     extractVariables(){
         const variables = [];
-        const seen = new Set();
+        const variableMap = new Map();
         
         const traverse = (node) => {
             if (!node) return;
@@ -88,9 +88,24 @@ class RuleTemplate {
             if (node.type === 'template_value') {
                 // Extract the variable information
                 const varInfo = this._extractVariableFromNode(node);
-                if (varInfo && !seen.has(varInfo.name)) {
-                    seen.add(varInfo.name);
-                    variables.push(varInfo);
+                if (varInfo) {
+                    // Add position to existing variable or create new entry
+                    if (variableMap.has(varInfo.name)) {
+                        const existing = variableMap.get(varInfo.name);
+                        existing.positions.push({
+                            start: varInfo.start,
+                            end: varInfo.end
+                        });
+                    } else {
+                        variableMap.set(varInfo.name, {
+                            name: varInfo.name,
+                            filters: varInfo.filters,
+                            positions: [{
+                                start: varInfo.start,
+                                end: varInfo.end
+                            }]
+                        });
+                    }
                 }
             }
             
@@ -103,9 +118,48 @@ class RuleTemplate {
         };
         
         traverse(this.ast);
+        
+        // Convert map to array
+        for (const variable of variableMap.values()) {
+            variables.push(variable);
+        }
+        
         return variables;
     }
 
+    /**
+     * Extract function calls from the template using the AST
+     * @returns {Array} Array of unique function names used in the template
+     */
+    extractFunctions(){
+        const functions = new Set();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a function call node
+            if (node.type === 'fcall') {
+                // Find the function name in children
+                const fnameNode = node.children?.find(c => c.type === 'fname');
+                if (fnameNode && fnameNode.text) {
+                    functions.add(fnameNode.text.trim());
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        
+        // Convert set to sorted array for consistent output
+        return Array.from(functions).sort();
+    }
+
     /**
      * Extract variable name and filters from a template_value AST node
      * @private
@@ -134,7 +188,11 @@ class RuleTemplate {
             }
         }
         
-        return { name, filters };
+        // Extract position information from the node
+        const start = node.start;
+        const end = node.end;
+        
+        return { name, filters, start, end };
     }
 
     /**

package/src/RuleTemplater.production.js

@@ -75,11 +75,11 @@ class RuleTemplate {
 
     /**
      * Extract variables from the template using the AST
-     * @returns {Array} Array of {name, filters: []} objects
+     * @returns {Array} Array of {name, filters: [], positions: [{start, end}]} objects
      */
     extractVariables(){
         const variables = [];
-        const seen = new Set();
+        const variableMap = new Map();
         
         const traverse = (node) => {
             if (!node) return;
@@ -88,9 +88,24 @@ class RuleTemplate {
             if (node.type === 'template_value') {
                 // Extract the variable information
                 const varInfo = this._extractVariableFromNode(node);
-                if (varInfo && !seen.has(varInfo.name)) {
-                    seen.add(varInfo.name);
-                    variables.push(varInfo);
+                if (varInfo) {
+                    // Add position to existing variable or create new entry
+                    if (variableMap.has(varInfo.name)) {
+                        const existing = variableMap.get(varInfo.name);
+                        existing.positions.push({
+                            start: varInfo.start,
+                            end: varInfo.end
+                        });
+                    } else {
+                        variableMap.set(varInfo.name, {
+                            name: varInfo.name,
+                            filters: varInfo.filters,
+                            positions: [{
+                                start: varInfo.start,
+                                end: varInfo.end
+                            }]
+                        });
+                    }
                 }
             }
             
@@ -103,9 +118,48 @@ class RuleTemplate {
         };
         
         traverse(this.ast);
+        
+        // Convert map to array
+        for (const variable of variableMap.values()) {
+            variables.push(variable);
+        }
+        
         return variables;
     }
 
+    /**
+     * Extract function calls from the template using the AST
+     * @returns {Array} Array of unique function names used in the template
+     */
+    extractFunctions(){
+        const functions = new Set();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a function call node
+            if (node.type === 'fcall') {
+                // Find the function name in children
+                const fnameNode = node.children?.find(c => c.type === 'fname');
+                if (fnameNode && fnameNode.text) {
+                    functions.add(fnameNode.text.trim());
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        
+        // Convert set to sorted array for consistent output
+        return Array.from(functions).sort();
+    }
+
     /**
      * Extract variable name and filters from a template_value AST node
      * @private
@@ -134,7 +188,11 @@ class RuleTemplate {
             }
         }
         
-        return { name, filters };
+        // Extract position information from the node
+        const start = node.start;
+        const end = node.end;
+        
+        return { name, filters, start, end };
     }
 
     /**