overhaul TRLParser

telegram_engine.py

@@ -34,20 +34,120 @@ def ns_api_request(params, user_agent_override=USER_AGENT):
 
 
 class TRLParser:
-    """Parses and evaluates a TRL string."""
+    """
+    A robust, recursive-descent parser for Template Recipient Language,
+    modeled after the official JavaScript implementation.
+    """
 
-    # This method is now responsible for handling the new regex primitive
-    def _fetch_nations_from_primitive(self, category, args_str, current_nations):
-        # API-based primitives (do not need current_nations)
-        if category == "nations":
+    def _consume_whitespace(self, text):
+        return text.lstrip()
+
+    def _parse_primitive(self, text):
+        text = self._consume_whitespace(text)
+
+        # Match category
+        category_match = re.match(r'^[a-zA-Z_]+', text)
+        if not category_match:
+            raise ValueError("Expected a primitive category (e.g., 'nations', 'regions')")
+        category = category_match.group(0)
+        text = text[len(category):]
+        text = self._consume_whitespace(text)
+
+        # Match arguments within brackets
+        if not text.startswith('['):
+            raise ValueError("Expected '[' after primitive category")
+
+        # Find the first closing bracket. This matches the official implementation's logic.
+        try:
+            end_bracket_index = text.index(']')
+        except ValueError:
+            raise ValueError("Unmatched '[' in primitive arguments")
+
+        args_str = text[1:end_bracket_index]
+        text = text[end_bracket_index + 1:]
+
+        # For regex, we don't split by comma. For others, we do.
+        if category == "name_regex":
+            args = [args_str]
+        else:
             args = [arg.strip() for arg in args_str.split(',')]
+
+        primitive = {"type": "primitive", "category": category, "args": args}
+        return primitive, text
+
+    def _parse_command(self, text):
+        text = self._consume_whitespace(text)
+
+        # Match action
+        action_char = text[0]
+        if action_char in "+-/":
+            action = {"+": "add", "-": "remove", "/": "limit"}[action_char]
+            text = text[1:]
+        else:
+            action = "add"  # Default action
+
+        text = self._consume_whitespace(text)
+
+        # Match body (either a group or a primitive)
+        if text.startswith('('):
+            body, text = self._parse_group(text)
+        else:
+            body, text = self._parse_primitive(text)
+
+        text = self._consume_whitespace(text)
+        if not text.startswith(';'):
+            raise ValueError("Expected ';' to terminate a command")
+        text = text[1:]
+
+        command = {"type": "command", "action": action, "body": body}
+        return command, text
+
+    def _parse_group(self, text):
+        text = self._consume_whitespace(text)
+        if not text.startswith('('):
+            raise ValueError("Expected '(' to start a group")
+        text = text[1:]  # Consume '('
+
+        commands = []
+        while True:
+            text = self._consume_whitespace(text)
+            if not text:
+                raise ValueError("Unmatched '(' in group definition")
+            if text.startswith(')'):
+                break
+            command, text = self._parse_command(text)
+            commands.append(command)
+
+        text = text[1:]  # Consume ')'
+        group = {"type": "group", "commands": commands}
+        return group, text
+
+    def parse(self, trl_string):
+        """Parses a raw TRL string into a structured command tree."""
+        # Pre-processing
+        cleaned_string = re.sub(r'#.*$', '', trl_string, flags=re.MULTILINE)
+        # Wrap the entire string in an implicit group for the parser
+        group_to_parse = f"({cleaned_string})"
+
+        parsed_group, remaining_text = self._parse_group(group_to_parse)
+
+        if self._consume_whitespace(remaining_text):
+            raise ValueError(f"Unexpected trailing characters in TRL string: {remaining_text}")
+
+        return parsed_group
+
+    # --- EVALUATION LOGIC ---
+    def _evaluate_primitive(self, primitive, current_nations):
+        category = primitive["category"]
+        args = primitive["args"]
+        args_str = ",".join(args)  # Re-join for the old API fetcher
+
+        if category == "nations":
             return {arg.lower().replace(' ', '_') for arg in args}
         if category == "regions":
-            args = [arg.strip() for arg in args_str.split(',')]
-            xml = ns_api_request({"q": "nations", "region": ",".join(args)})
+            xml = ns_api_request({"q": "nations", "region": args_str})
             return set(re.findall(r'<NATION id="([^"]+)">', xml))
         if category == "wa":
-            args = [arg.strip() for arg in args_str.split(',')]
             if "members" in args:
                 xml = ns_api_request({"q": "wamembers"})
                 return set(xml.split(','))
@@ -55,61 +155,43 @@ class TRLParser:
                 xml = ns_api_request({"q": "wadelegates"})
                 return set(xml.split(','))
         if category in ("new", "refounded"):
-            limit = int(args_str) if args_str and args_str.isdigit() else 50
+            limit = int(args[0]) if args and args[0].isdigit() else 50
             happenings_filter = "founding" if category == "new" else "refounding"
             xml = ns_api_request({"q": "happenings", "filter": happenings_filter, "limit": limit})
             return set(re.findall(r'@@([^@]+)@@', xml))
-
-        # --- NEW PRIMITIVE LOGIC ---
-        # This primitive filters the list of nations already gathered.
         if category == "name_regex":
             try:
-                # The regex pattern is the only argument
-                pattern = re.compile(args_str.strip())
-                # Return a new set of nations from the current list that match the pattern
+                pattern = re.compile(args[0].strip())
                 return {nation for nation in current_nations if pattern.search(nation)}
             except re.error as e:
-                # Raise an error that can be caught by the main engine
-                raise ValueError(f"Invalid Regular Expression '{args_str}': {e}")
-        # --- END OF NEW LOGIC ---
-
+                raise ValueError(f"Invalid Regular Expression '{args[0]}': {e}")
         return set()
 
-    # This method is updated to pass the current nations set to the primitive fetcher
+    def _evaluate_group(self, group, initial_nations=None):
+        nations = initial_nations if initial_nations is not None else set()
+        for command in group["commands"]:
+            action = command["action"]
+            body = command["body"]
+
+            if body["type"] == "group":
+                target_nations = self._evaluate_group(body)
+            else:  # Primitive
+                target_nations = self._evaluate_primitive(body, current_nations=nations)
+
+            if action == 'add':
+                nations.update(target_nations)
+            elif action == 'remove':
+                nations.difference_update(target_nations)
+            elif action == 'limit':
+                nations.intersection_update(target_nations)
+        return nations
+
     def evaluate(self, trl_string):
-        """Evaluates the TRL string and returns a set of nation names."""
-        # First, strip all comments to clean up the TRL string.
-        # A comment is a '#' character followed by anything until the end of the line.
-        trl_string = re.sub(r'#.*$', '', trl_string, flags=re.MULTILINE)
-
-        trl_string = re.sub(r'^\s*(?=[a-zA-Z(])', '+', trl_string, flags=re.MULTILINE)
-        trl_string = trl_string.replace('\n', ' ').strip()
-        token_regex = re.compile(r'([+\-/])\s*(\([^)]+\)|[a-zA-Z_]+\s*\[(.*)\])\s*;')
-
-        def _process_group(group_str):
-            nations = set()
-            tokens = token_regex.findall(group_str)
-            for action, body in tokens:
-                target_nations = set()
-                if body.startswith('('):
-                    target_nations = _process_group(body[1:-1])
-                else:
-                    match = re.match(r'([a-zA-Z_]+)\s*\[([^\]]+)\]', body)
-                    if match:
-                        category, args_str = match.groups()
-                        # Pass the current 'nations' set to the primitive handler
-                        target_nations = self._fetch_nations_from_primitive(
-                            category.lower(), args_str, current_nations=nations
-                        )
-                if action == '+':
-                    nations.update(target_nations)
-                elif action == '-':
-                    nations.difference_update(target_nations)
-                elif action == '/':
-                    nations.intersection_update(target_nations)
-            return nations
-
-        return _process_group(trl_string)
+        """Parses and then evaluates a TRL string."""
+        if not trl_string.strip():
+            return set()
+        parsed_structure = self.parse(trl_string)
+        return self._evaluate_group(parsed_structure)
 
 
 def telegram_engine(