Replace the word "tool" with "rule"

Author: suhaibmujahid

.github/workflows/wiki.yaml

@@ -19,5 +19,5 @@ jobs:
         with:
           python-version: 3.9
 
-      - name: Check tools on the wiki page
+      - name: Check rules on the wiki page
         run: python scripts/check_rules_on_wiki.py -ci

.gitignore

@@ -3,7 +3,7 @@
 *~
 .DS_Store
 configs/*
-!configs/tools.json
+!configs/rules.json
 !configs/rm.json
 !configs/team_managers.json
 models/

bugbot/bzcleaner.py

@@ -22,10 +22,10 @@
 
 
 class TooManyChangesError(Exception):
-    """Exception raised when the tool is trying to apply too many changes"""
+    """Exception raised when the rule is trying to apply too many changes"""
 
     def __init__(self, bugs, changes, max_changes):
-        message = f"The tool has been aborted because it was attempting to apply changes on {len(changes)} bugs. Max is {max_changes}."
+        message = f"The rule has been aborted because it was attempting to apply changes on {len(changes)} bugs. Max is {max_changes}."
         super().__init__(message)
         self.bugs = bugs
         self.changes = changes
@@ -43,15 +43,15 @@ class BzCleaner(object):
         no_bugmail: If `True`, a token for an account that does not trigger
             bugmail will be used when performing `PUT` actions on Bugzilla.
         normal_changes_max: The maximum number of changes that could be made in
-            a normal situation. If exceeded, the tool will fail.
+            a normal situation. If exceeded, the rule will fail.
     """
 
     no_bugmail: bool = False
     normal_changes_max: int = 50
 
     def __init__(self):
         super(BzCleaner, self).__init__()
-        self._set_tool_name()
+        self._set_rule_name()
         self.apply_autofix = True
         self.has_autofix = False
         self.autofix_changes = {}
@@ -62,16 +62,16 @@ def __init__(self):
         self.cache = Cache(self.name(), self.max_days_in_cache())
         self.test_mode = utils.get_config("common", "test", False)
         self.versions = None
-        logger.info("Run tool {}".format(self.get_tool_path()))
+        logger.info("Run rule {}".format(self.get_rule_path()))
 
-    def _set_tool_name(self):
+    def _set_rule_name(self):
         module = sys.modules[self.__class__.__module__]
         base = os.path.dirname(__file__)
-        scripts = os.path.join(base, "scripts")
-        self.__tool_path__ = os.path.relpath(module.__file__, scripts)
+        rules = os.path.join(base, "rules")
+        self.__rule_path__ = os.path.relpath(module.__file__, rules)
         name = os.path.basename(module.__file__)
         name = os.path.splitext(name)[0]
-        self.__tool_name__ = name
+        self.__rule_name__ = name
 
     def init_versions(self):
         self.versions = utils.get_checked_versions()
@@ -86,12 +86,12 @@ def description(self):
         return ""
 
     def name(self):
-        """Get the tool name"""
-        return self.__tool_name__
+        """Get the rule name"""
+        return self.__rule_name__
 
-    def get_tool_path(self):
-        """Get the tool path"""
-        return self.__tool_path__
+    def get_rule_path(self):
+        """Get the rule path"""
+        return self.__rule_path__
 
     def needinfo_template_name(self):
         """Get the txt template filename"""
@@ -117,7 +117,7 @@ def ignore_date(self):
         return False
 
     def must_run(self, date):
-        """Check if the tool must run for this date"""
+        """Check if the rule must run for this date"""
         days = self.get_config("must_run", None)
         if not days:
             return True
@@ -129,7 +129,7 @@ def must_run(self, date):
         return False
 
     def has_enough_data(self):
-        """Check if the tool has enough data to run"""
+        """Check if the rule has enough data to run"""
         if self.versions is None:
             # init_versions() has never been called
             return True
@@ -166,7 +166,7 @@ def exclude_no_action_bugs(self):
         needinfo got ignored due to exceeding the limit). This is applied only
         when using the `add_prioritized_action()` method.
 
-        Returning `False` could be useful if we want to list all actions the tool
+        Returning `False` could be useful if we want to list all actions the rule
         would do if it had no limits.
         """
         return True
@@ -491,7 +491,7 @@ def get_list_bugs(self, bugs):
 
     def get_documentation(self):
         return "For more information, please visit [BugBot documentation](https://wiki.mozilla.org/Release_Management/autonag#{}).".format(
-            self.get_tool_path().replace("/", ".2F")
+            self.get_rule_path().replace("/", ".2F")
         )
 
     def has_bot_set_ni(self, bug):
@@ -613,7 +613,7 @@ def autofix(self, bugs):
 
     @staticmethod
     def apply_changes_on_bugzilla(
-        tool_name: str,
+        rule_name: str,
         new_changes: Dict[str, dict],
         no_bugmail: bool = False,
         is_dryrun: bool = True,
@@ -622,7 +622,7 @@ def apply_changes_on_bugzilla(
         """Apply changes on Bugzilla
 
         Args:
-            tool_name: the name of the tool that is performing the changes.
+            rule_name: the name of the rule that is performing the changes.
             new_changes: the changes that will be performed. The dictionary key
                 should be the bug ID.
             no_bugmail: If True, an account that doesn't trigger bugmail will be
@@ -651,12 +651,12 @@ def apply_changes_on_bugzilla(
                     time.sleep(1)
                 else:
                     added = True
-                    db.BugChange.add(tool_name, bugid, extra=db_extra.get(bugid, ""))
+                    db.BugChange.add(rule_name, bugid, extra=db_extra.get(bugid, ""))
                     break
             if not added:
                 logger.error(
                     "%s: Cannot put data for bug %s (change => %s): %s",
-                    tool_name,
+                    rule_name,
                     bugid,
                     ch,
                     failures,
@@ -720,7 +720,7 @@ def _send_alert_about_too_many_changes(self, err: TooManyChangesError):
             changes=err.changes.items(),
             changes_size=len(err.changes),
             normal_changes_max=self.normal_changes_max,
-            tool_name=self.name(),
+            rule_name=self.name(),
             https_proxy=os.environ.get("https_proxy"),
             enumerate=enumerate,
             table_attrs=self.get_config("table_attrs"),
@@ -755,7 +755,7 @@ def send_email(self, date="today"):
                 return
 
         if not self.has_enough_data():
-            logger.info("The tool {} hasn't enough data to run".format(self.name()))
+            logger.info("The rule {} hasn't enough data to run".format(self.name()))
             return
 
         login_info = utils.get_login_info()
@@ -775,7 +775,7 @@ def send_email(self, date="today"):
                     dryrun=self.dryrun,
                 )
             except Exception:
-                logger.exception("Tool {}".format(self.name()))
+                logger.exception("Rule {}".format(self.name()))
                 status = "Failure"
 
             db.Email.add(self.name(), receivers, "global", status)
@@ -810,7 +810,7 @@ def get_args_parser(self):
             dest="is_limited",
             action="store_false",
             default=True,
-            help=f"If the flag is not passed, the tool will be limited to touch a maximum of {self.normal_changes_max} bugs",
+            help=f"If the flag is not passed, the rule will be limited to touch a maximum of {self.normal_changes_max} bugs",
         )
 
         if not self.ignore_date():
@@ -828,7 +828,7 @@ def get_args_parser(self):
         return parser
 
     def run(self):
-        """Run the tool"""
+        """Run the rule"""
         args = self.get_args_parser().parse_args()
         self.parse_custom_arguments(args)
         date = "" if self.ignore_date() else args.date
@@ -838,9 +838,9 @@ def run(self):
         try:
             self.send_email(date=date)
             self.terminate()
-            logger.info("Tool {} has finished.".format(self.get_tool_path()))
+            logger.info("Rule {} has finished.".format(self.get_rule_path()))
         except TooManyChangesError as err:
             self._send_alert_about_too_many_changes(err)
-            logger.exception("Tool %s", self.name())
+            logger.exception("Rule %s", self.name())
         except Exception:
-            logger.exception("Tool {}".format(self.name()))
+            logger.exception("Rule {}".format(self.name()))

bugbot/multi_autofixers.py

@@ -10,25 +10,25 @@
 from bugbot.bzcleaner import BzCleaner
 from bugbot.nag_me import Nag
 
-ToolsChanges = Dict[Type[BzCleaner], Any]
+RulesChanges = Dict[Type[BzCleaner], Any]
 
 
-class UnexpectedToolsError(Exception):
-    """Unexpected tools appear in merge function"""
+class UnexpectedRulesError(Exception):
+    """Unexpected rules appear in merge function"""
 
-    def __init__(self, tools: Iterable[Type[BzCleaner]]) -> None:
+    def __init__(self, rules: Iterable[Type[BzCleaner]]) -> None:
         """Constructor
 
         Args:
-            tools: the tools that change the same field.
+            rules: the rules that change the same field.
         """
         super().__init__()
-        self.tools = tools
+        self.rules = rules
 
     def __str__(self):
         return (
             "Error: merge function does not support merge fields "
-            f"from '{utils.english_list([tool.__name__ for tool in self.tools])}'"
+            f"from '{utils.english_list([rule.__name__ for rule in self.rules])}'"
         )
 
 
@@ -49,37 +49,37 @@ def __str__(self):
 
 
 class MultiAutoFixers:
-    "Merge changes from multiple tools and apply them to Bugzilla at once"
+    "Merge changes from multiple rules and apply them to Bugzilla at once"
 
     def __init__(
-        self, *tools: BzCleaner, **merge_functions: Callable[[ToolsChanges], dict]
+        self, *rules: BzCleaner, **merge_functions: Callable[[RulesChanges], dict]
     ):
         """Constructor
 
         Args:
-            *tools: tools to merge their changes.
+            *rules: rules to merge their changes.
             **merge_functions: functions to merge field values when multiple
-                tools are changing the same field. The key should be the field
+                rules are changing the same field. The key should be the field
                 name.
         """
         super().__init__()
-        for tool in tools:
-            if isinstance(tool, Nag):
+        for rule in rules:
+            if isinstance(rule, Nag):
                 logger.warning(
                     "%s implements Nag, however, nag emails will not be merged",
-                    type(tool),
+                    type(rule),
                 )
-        self.tools = tools
+        self.rules = rules
         self.merge_functions = merge_functions
         self.is_dryrun: bool = True
 
     def description(self):
-        """Return a description of the tool"""
-        return "Grouped changes for the following tools: " + self.name()
+        """Return a description of the rule"""
+        return "Grouped changes for the following rules: " + self.name()
 
     def name(self):
-        """Return the name of the tool"""
-        return utils.english_list([tool.name() for tool in self.tools])
+        """Return the name of the rule"""
+        return utils.english_list([rule.name() for rule in self.rules])
 
     def get_args_parser(self):
         """Get the arguments from the command line"""
@@ -97,34 +97,34 @@ def get_args_parser(self):
         return parser
 
     def run(self):
-        """Run the tool"""
+        """Run the rule"""
         args = self.get_args_parser().parse_args()
         self.is_dryrun = args.dryrun
 
-        for tool in self.tools:
-            tool.apply_autofix = False
-            tool.run()
+        for rule in self.rules:
+            rule.apply_autofix = False
+            rule.run()
 
-        new_changes = self._merge_changes_from_tools()
-        no_bugmail = all(tool.no_bugmail for tool in self.tools)
+        new_changes = self._merge_changes_from_rules()
+        no_bugmail = all(rule.no_bugmail for rule in self.rules)
 
         BzCleaner.apply_changes_on_bugzilla(
             self.name(), new_changes, no_bugmail, self.is_dryrun, db_extra={}
         )
 
-    def _merge_changes_from_tools(self) -> Dict[str, dict]:
+    def _merge_changes_from_rules(self) -> Dict[str, dict]:
         all_changes: Dict[str, dict] = defaultdict(dict)
-        for tool in self.tools:
-            for bugid, changes in tool.autofix_changes.items():
-                all_changes[bugid][tool.__class__] = changes
+        for rule in self.rules:
+            for bugid, changes in rule.autofix_changes.items():
+                all_changes[bugid][rule.__class__] = changes
 
-        for bugid, tools in all_changes.items():
+        for bugid, rules in all_changes.items():
             merged_changes = {}
 
             common_fields = (
                 field
                 for field, count in Counter(
-                    field for changes in tools.values() for field in changes.keys()
+                    field for changes in rules.values() for field in changes.keys()
                 ).items()
                 if count > 1
             )
@@ -133,13 +133,13 @@ def _merge_changes_from_tools(self) -> Dict[str, dict]:
                 if field not in self.merge_functions:
                     raise MissingMergeFunctionError(field)
 
-                tools_with_common_field = {
-                    tool: changes for tool, changes in tools.items() if field in changes
+                rules_with_common_field = {
+                    rule: changes for rule, changes in rules.items() if field in changes
                 }
                 merged_changes[field] = self.merge_functions[field](
-                    tools_with_common_field
+                    rules_with_common_field
                 )
 
-            all_changes[bugid] = dict(ChainMap(merged_changes, *tools.values()))
+            all_changes[bugid] = dict(ChainMap(merged_changes, *rules.values()))
 
         return all_changes

bugbot/nag_me.py

@@ -185,7 +185,7 @@ def send_mails(self, title, dryrun=False):
                     dryrun=dryrun,
                 )
             except Exception:
-                logger.exception("Tool {}".format(self.name()))
+                logger.exception("Rule {}".format(self.name()))
                 status = "Failure"
 
             db.Email.add(self.name(), receivers, "individual", status)

bugbot/round_robin_fallback.py

@@ -49,4 +49,4 @@ def check_people(date, dryrun=False):
     try:
         check_people(args.date, dryrun=args.dryrun)
     except Exception:
-        logger.exception("Tool round_robin_fallback")
+        logger.exception("Rule round_robin_fallback")

bugbot/rules/fuzz_blockers.py

@@ -43,7 +43,7 @@ def get_mail_to_auto_ni(self, bug):
 
     @staticmethod
     def _is_commented(bug: dict) -> bool:
-        """Get whether the bug has a previous comment by this tool"""
+        """Get whether the bug has a previous comment by this rule"""
         for comment in reversed(bug["comments"]):
             if comment["creator"] == History.BOT and comment["raw_text"].startswith(
                 "This bug prevents fuzzing from making progress"