register extensions in an extension registry

Author: manfred-kaiser

sifter/commands/require.py

@@ -21,7 +21,7 @@ class CommandRequire(Command):
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
         ext_name_list = self.positional_args[0]
         for ext_name in ext_name_list:  # type: ignore
-            if not sifter.handler.get('extension', ext_name):
+            if not sifter.handler.ExtensionRegistry.get('extension', ext_name):
                 raise RuntimeError(
                     "Required extension '%s' not supported"
                     % ext_name

sifter/comparator.py

@@ -4,22 +4,16 @@
     Text,
     Optional,
     Tuple,
-    Type,
     Union
 )
 
 import sifter.handler
 
 if TYPE_CHECKING:
-    from sifter.grammar.comparator import Comparator
     from sifter.grammar.tag import Tag
     from sifter.grammar.state import EvaluationState
 
 
-def register(comparator_name: Optional[Text], comparator_cls: Type['Comparator']) -> None:
-    sifter.handler.register('comparator', comparator_name, comparator_cls)
-
-
 def get_match_fn(
     comparator: Optional[Union[Text, 'Tag']],
     match_type: Optional[Union[Text, 'Tag']]
@@ -37,7 +31,7 @@ def get_match_fn(
         match_type = 'IS'
 
     # TODO: support wildcard matching in comparator names (RFC 4790)
-    cmp_handler = sifter.handler.get('comparator', comparator)
+    cmp_handler = sifter.handler.ExtensionRegistry.get('comparator', comparator)
     if not cmp_handler:
         raise RuntimeError("Comparator not supported: %s" % comparator)
 

sifter/extension.py

@@ -4,4 +4,4 @@
 
 
 def register(extension_name: Text) -> None:
-    sifter.handler.register('extension', extension_name, True)
+    sifter.handler.ExtensionRegistry.register('extension', extension_name, True)

sifter/extensions/builtin.py

@@ -6,7 +6,6 @@
 )
 
 import re
-import sifter.comparator
 from sifter.grammar.state import EvaluationState
 
 
@@ -16,22 +15,13 @@ class Comparator(object):
     COMPARATOR_ID: Optional[Text] = None
 
     @classmethod
-    def get_mapkey(cls):
+    def handler_type(cls):
         return 'comparator'
 
     @classmethod
-    def get_identifier(cls):
+    def handler_id(cls):
         return cls.COMPARATOR_ID
 
-    @classmethod
-    def register(cls) -> None:
-        try:
-            sifter.comparator.register(cls.COMPARATOR_ID, cls)
-        except AttributeError:
-            # this method should only be called on sub-classes that define an
-            # identifier
-            raise NotImplementedError
-
     @classmethod
     def sort_key(cls, s: Text) -> Text:
         return s

sifter/extensions/regex.py

@@ -19,6 +19,7 @@
 from sifter.grammar.string import String
 import sifter.handler
 from sifter.grammar.lexer import SieveLexer
+from sifter.handler import ExtensionRegistry
 
 if TYPE_CHECKING:
     from py.yacc import LRParser, YaccProduction  # type: ignore
@@ -31,6 +32,7 @@ class SieveParser():
     def __init__(self) -> None:
         self.lexer = SieveLexer()
         self.parser = self.make_parser(self)
+        self.extensions = ExtensionRegistry()
 
     @staticmethod
     def make_parser(mod: Any) -> 'LRParser':
@@ -77,7 +79,7 @@ def p_command(self, p: 'YaccProduction') -> None:
         block = None
         if p[3] != ';':
             block = p[3]
-        handler = sifter.handler.get('command', p[1])
+        handler = sifter.handler.ExtensionRegistry.get('command', p[1])
         if handler is None:
             print("No handler registered for command '%s' on line %d" % (p[1], p.lineno(1)))
             raise SyntaxError
@@ -134,7 +136,7 @@ def p_test(self, p: 'YaccProduction') -> None:
         """test : IDENTIFIER arguments"""
         # print("TEST:", p[1], p[2])
         tests = p[2].get('tests')
-        handler = sifter.handler.get('test', p[1])
+        handler = sifter.handler.ExtensionRegistry.get('test', p[1])
         if handler is None:
             print("No handler registered for test '%s' on line %d" % (p[1], p.lineno(1)))
             raise SyntaxError

sifter/grammar/comparator.py

@@ -37,22 +37,13 @@ class Rule(object):
     TESTS_MAX: Optional[int] = None
 
     @classmethod
-    def get_mapkey(cls):
+    def handler_type(cls):
         return cls.RULE_TYPE
 
     @classmethod
-    def get_identifier(cls):
+    def handler_id(cls):
         return cls.RULE_IDENTIFIER
 
-    @classmethod
-    def register(cls) -> None:
-        try:
-            sifter.handler.register(cls.RULE_TYPE, cls.RULE_IDENTIFIER, cls)
-        except AttributeError:
-            # this method shouldn't be called on the Rule class directly,
-            # only on subclasses that implement specific rules
-            raise NotImplementedError
-
     def __init__(
         self,
         arguments: Optional[List[Union['Tag', SupportsInt, List[Union[Text, 'String']]]]] = None,

sifter/grammar/grammar.py

@@ -13,32 +13,44 @@
     from sifter.grammar.comparator import Comparator
 
 
-_HANDLERS_MAP: Dict[Text, Dict[Text, Union[bool, Type['Comparator'], Type['Rule']]]] = {}
+class ExtensionRegistry():
 
+    _HANDLERS_MAP: Dict[Text, Dict[Text, Union[bool, Type['Comparator'], Type['Rule']]]] = {}
+    DEFAULT_EXTENSION = [
+        'regex',
+        'comparator-i;ascii-casemap',
+        'comparator-i;octet',
+        'fileinto',
+    ]
 
-def register(
-    handler_type: Optional[Text],
-    handler_id: Optional[Text],
-    value: Union[bool, Type['Comparator'], Type['Rule']]
-) -> None:
-    from sifter.grammar.rule import Rule
-    from sifter.grammar.comparator import Comparator
-    if not handler_type or not handler_id:
-        raise ValueError("handler_type and handler_id must not be None!")
-    if not isinstance(value, Rule) and not (isinstance(value, type) and issubclass(value, (Rule, Comparator))):
-        print(type(value))
-        _HANDLERS_MAP.setdefault(handler_type, {})[handler_id] = value
-    else:
-        for entry_point in pkg_resources.iter_entry_points('sifter_extensions'):
-            if entry_point.name not in _HANDLERS_MAP:
-                ext_cls = entry_point.load()
-                _HANDLERS_MAP.setdefault(ext_cls.get_mapkey(), {})[ext_cls.get_identifier()] = ext_cls
-                _HANDLERS_MAP[entry_point.name] = entry_point.load()
-
+    def __init__(self) -> None:
+        for extension_name in self.DEFAULT_EXTENSION:
+            self.register_extension(extension_name)
 
-def unregister(handler_type: Text, handler_id: Text) -> Optional[Union[bool, Type['Comparator'], Type['Rule']]]:
-    return _HANDLERS_MAP.get(handler_type, {}).pop(handler_id, None)
-
-
-def get(handler_type: Text, handler_id: Text) -> Optional[Union[bool, Type['Comparator'], Type['Rule']]]:
-    return _HANDLERS_MAP.get(handler_type, {}).get(handler_id, None)
+        for entry_point in pkg_resources.iter_entry_points('sifter_extensions'):
+            self.register_handler(entry_point.load())
+
+    @classmethod
+    def register_extension(cls, extension_name):
+        cls.register('extension', extension_name, True)
+
+    @classmethod
+    def register_handler(cls, ext_cls):
+        cls.register(ext_cls.handler_type(), ext_cls.handler_id(), ext_cls)
+
+    @classmethod
+    def register(
+        cls,
+        handler_type: Optional[Text],
+        handler_id: Optional[Text],
+        value: Union[bool, Type['Comparator'], Type['Rule']]
+    ) -> None:
+        cls._HANDLERS_MAP.setdefault(handler_type, {})[handler_id] = value
+
+    @classmethod
+    def unregister(cls, handler_type: Text, handler_id: Text) -> Optional[Union[bool, Type['Comparator'], Type['Rule']]]:
+        return cls._HANDLERS_MAP.get(handler_type, {}).pop(handler_id, None)
+
+    @classmethod
+    def get(cls, handler_type: Text, handler_id: Text) -> Optional[Union[bool, Type['Comparator'], Type['Rule']]]:
+        return cls._HANDLERS_MAP.get(handler_type, {}).get(handler_id, None)

sifter/grammar/rule.py

@@ -3,8 +3,7 @@
     TextIO
 )
 
-import sifter.extensions.builtin  # needed by the lexer
-import sifter.extensions.regex  # needed by the lexer
+
 from sifter.grammar.grammar import SieveParser
 from sifter.grammar.command_list import CommandList