removed empty __init__methods (only super called)

manfred-kaiser · manfred-kaiser · commit a0b55fba318c · 2020-09-29T16:02:40.000+02:00
diff --git a/sifter/commands/discard.py b/sifter/commands/discard.py
@@ -24,15 +24,6 @@ class CommandDiscard(Command):
 
     RULE_IDENTIFIER = 'DISCARD'
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None,
-        block: Optional[CommandList] = None
-    ) -> None:
-        super().__init__(arguments, tests, block)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
         state.actions.cancel_implicit_keep()
         return None
diff --git a/sifter/commands/fileinto.py b/sifter/commands/fileinto.py
@@ -33,8 +33,7 @@ def __init__(
         block: Optional[CommandList] = None
     ) -> None:
         super().__init__(arguments, tests, block)
-        _, positional_args = self.validate()
-        self.file_dest = positional_args[0]
+        self.file_dest = self.positional_args[0]
 
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
         state.check_required_extension('fileinto', 'FILEINTO')
diff --git a/sifter/commands/if_cmd.py b/sifter/commands/if_cmd.py
@@ -25,15 +25,6 @@ class CommandIfBase(Command):
     TESTS_MIN = 1
     HAS_BLOCKS = False
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None,
-        block: Optional[CommandList] = None
-    ) -> None:
-        super().__init__(arguments, tests, block)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
         if self.tests[0].evaluate(message, state):
             result = self.block.evaluate(message, state)
@@ -77,7 +68,6 @@ def __init__(
         block: Optional[CommandList] = None
     ) -> None:
         super().__init__(arguments, tests, block)
-        self.validate()
 
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
         if state.last_if:
diff --git a/sifter/commands/keep.py b/sifter/commands/keep.py
@@ -25,15 +25,6 @@ class CommandKeep(Command):
     RULE_IDENTIFIER = 'KEEP'
     HAS_BLOCKS = False
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None,
-        block: Optional[CommandList] = None
-    ) -> None:
-        super().__init__(arguments, tests, block)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
         state.actions.append('keep')
         state.actions.cancel_implicit_keep()
diff --git a/sifter/commands/redirect.py b/sifter/commands/redirect.py
@@ -35,9 +35,8 @@ def __init__(
         block: Optional[CommandList] = None
     ) -> None:
         super().__init__(arguments, tests, block)
-        _, positional_args = self.validate()
 
-        self.email_address = positional_args[0][0]  # type: ignore
+        self.email_address = self.positional_args[0][0]  # type: ignore
         # TODO: section 2.4.2.3 constrains the email address to a limited
         # subset of valid address formats. need to check if python's
         # email.utils also uses this subset or if we need to do our own
diff --git a/sifter/commands/require.py b/sifter/commands/require.py
@@ -35,8 +35,7 @@ def __init__(
         block: Optional[CommandList] = None
     ) -> None:
         super().__init__(arguments, tests, block)
-        _, positional_args = self.validate()
-        self.ext_names = positional_args[0]
+        self.ext_names = self.positional_args[0]
 
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
         for ext_name in self.ext_names:
diff --git a/sifter/commands/stop.py b/sifter/commands/stop.py
@@ -24,15 +24,6 @@ class CommandStop(Command):
 
     RULE_IDENTIFIER = 'STOP'
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None,
-        block: Optional[CommandList] = None
-    ) -> None:
-        super().__init__(arguments, tests, block)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
         state.actions.append('stop')
         return None
diff --git a/sifter/grammar/command.py b/sifter/grammar/command.py
@@ -35,11 +35,11 @@ def __init__(
         tests: Optional[List['Test']] = None,
         block: Optional[CommandList] = None
     ) -> None:
-        super().__init__(arguments, tests)
         if block is None:
             self.block = CommandList()
         else:
             self.block = block
+        super().__init__(arguments, tests)
 
     def __str__(self) -> Text:
         s = [super().__str__(), ]
diff --git a/sifter/grammar/rule.py b/sifter/grammar/rule.py
@@ -48,7 +48,8 @@ def register(cls) -> None:
     def __init__(
         self,
         arguments: Optional[List[Union['Tag', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None
+        tests: Optional[List['Test']] = None,
+        validate: bool = True
     ) -> None:
         if arguments is None:
             self.arguments = []
@@ -58,6 +59,8 @@ def __init__(
             self.tests = []
         else:
             self.tests = tests
+        if validate:
+            self.tagged_args, self.positional_args = self.validate()
 
     def __str__(self) -> Text:
         s = ["%s" % self.RULE_IDENTIFIER, ]
diff --git a/sifter/tests/address.py b/sifter/tests/address.py
@@ -42,16 +42,15 @@ def __init__(
         tests: Optional[List['Test']] = None
     ) -> None:
         super().__init__(arguments, tests)
-        tagged_args, positional_args = self.validate()
 
-        self.headers, self.keylist = positional_args
+        self.headers, self.keylist = self.positional_args
         self.match_type = self.comparator = self.address_part = None
-        if 'comparator' in tagged_args:
-            self.comparator = tagged_args['comparator'][1][0]  # type: ignore
-        if 'match_type' in tagged_args:
-            self.match_type = tagged_args['match_type'][0]
-        if 'address_part' in tagged_args:
-            self.address_part = tagged_args['address_part'][0]
+        if 'comparator' in self.tagged_args:
+            self.comparator = self.tagged_args['comparator'][1][0]  # type: ignore
+        if 'match_type' in self.tagged_args:
+            self.match_type = self.tagged_args['match_type'][0]
+        if 'address_part' in self.tagged_args:
+            self.address_part = self.tagged_args['address_part'][0]
 
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         if not isinstance(self.keylist, list):
diff --git a/sifter/tests/allof.py b/sifter/tests/allof.py
@@ -22,14 +22,6 @@ class TestAllOf(Test):
     RULE_IDENTIFIER: Text = 'ALLOF'
     HAS_TESTS = False
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None
-    ) -> None:
-        super().__init__(arguments, tests)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         # short-circuit evaluation if a test is false. the base standard does
         # not specify if all tests must be evaluated or in what order, but the
diff --git a/sifter/tests/anyof.py b/sifter/tests/anyof.py
@@ -22,14 +22,6 @@ class TestAnyOf(Test):
     RULE_IDENTIFIER = 'ANYOF'
     HAS_TESTS = False
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None
-    ) -> None:
-        super().__init__(arguments, tests)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         # short-circuit evaluation if a test is true. the base standard does
         # not specify if all tests must be evaluated or in what order, but the
diff --git a/sifter/tests/exists.py b/sifter/tests/exists.py
@@ -30,8 +30,7 @@ def __init__(
         tests: Optional[List['Test']] = None
     ) -> None:
         super().__init__(arguments, tests)
-        tagged_args, positional_args = self.validate()
-        self.headers = positional_args[0]
+        self.headers = self.positional_args[0]
 
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         if not isinstance(self.headers, list):
diff --git a/sifter/tests/false.py b/sifter/tests/false.py
@@ -21,14 +21,6 @@ class TestFalse(Test):
 
     RULE_IDENTIFIER = 'FALSE'
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None
-    ) -> None:
-        super().__init__(arguments, tests)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         return False
 
diff --git a/sifter/tests/header.py b/sifter/tests/header.py
@@ -39,16 +39,15 @@ def __init__(
         tests: Optional[List['Test']] = None
     ) -> None:
         super().__init__(arguments, tests)
-        tagged_args, positional_args = self.validate()
 
-        self.headers = positional_args[0]
-        self.keylist = positional_args[1]
+        self.headers = self.positional_args[0]
+        self.keylist = self.positional_args[1]
         self.match_type: Optional['TagGrammar'] = None
         self.comparator: Optional[Union[Text, 'TagGrammar']] = None
-        if 'comparator' in tagged_args:
-            self.comparator = tagged_args['comparator'][1][0]  # type: ignore
-        if 'match_type' in tagged_args:
-            self.match_type = tagged_args['match_type'][0]  # type: ignore
+        if 'comparator' in self.tagged_args:
+            self.comparator = self.tagged_args['comparator'][1][0]  # type: ignore
+        if 'match_type' in self.tagged_args:
+            self.match_type = self.tagged_args['match_type'][0]  # type: ignore
 
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         if not isinstance(self.headers, list):
diff --git a/sifter/tests/not_test.py b/sifter/tests/not_test.py
@@ -22,14 +22,6 @@ class TestNot(Test):
     RULE_IDENTIFIER = 'NOT'
     TESTS_MIN = 1
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None
-    ) -> None:
-        super().__init__(arguments, tests)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         return not self.tests[0].evaluate(message, state)
 
diff --git a/sifter/tests/size.py b/sifter/tests/size.py
@@ -44,9 +44,8 @@ def __init__(
         tests: Optional[List['Test']] = None
     ) -> None:
         super().__init__(arguments, tests)
-        tagged_args, positional_args = self.validate()
-        self.comparison_fn = self.COMPARISON_FNS[tagged_args['size'][0]]  # type: ignore
-        self.comparison_size = tagged_args['size'][1]
+        self.comparison_fn = self.COMPARISON_FNS[self.tagged_args['size'][0]]  # type: ignore
+        self.comparison_size = self.tagged_args['size'][1]
 
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         # FIXME: size is defined as number of octets, whereas this gives us
diff --git a/sifter/tests/true.py b/sifter/tests/true.py
@@ -20,14 +20,6 @@ class TestTrue(Test):
 
     RULE_IDENTIFIER = 'TRUE'
 
-    def __init__(
-        self,
-        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
-        tests: Optional[List['Test']] = None
-    ) -> None:
-        super().__init__(arguments, tests)
-        self.validate()
-
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         return True
 
diff --git a/tests/test_validators.py b/tests/test_validators.py
@@ -10,28 +10,26 @@
 from sifter.validators.tag import Tag as TagValidator
 
 
-class MockRule(Rule):
-
-    RULE_TYPE = 'mock'
-    RULE_IDENTIFIER = 'MOCKRULE'
-
-    def __init__(self, arguments=None, tests=None):
-        super().__init__(arguments, tests)
-
-
 def test_too_many_args() -> None:
-    mock_rule = MockRule([GrammarTag('IS'), 13, ])
+    class MockRuleNoArgs(Rule):
+        RULE_TYPE = 'mock'
+        RULE_IDENTIFIER = 'MOCKRULE'
+
     with pytest.raises(RuleSyntaxError):
-        mock_rule.validate_arguments()
+        _ = MockRuleNoArgs([GrammarTag('IS'), 13, ])
 
 
 def test_not_enough_args() -> None:
-    mock_rule = MockRule([13, ])
-    with pytest.raises(RuleSyntaxError):
-        mock_rule.validate_arguments([
+    class MockRuleTwoArgs(Rule):
+        RULE_TYPE = 'mock'
+        RULE_IDENTIFIER = 'MOCKRULE'
+        TAGGED_ARGS = [
             Number(),
             StringList(),
-        ])
+        ]
+
+    with pytest.raises(RuleSyntaxError):
+        _ = MockRuleTwoArgs([13, ])
 
 
 def test_allowed_tag() -> None:
