Rename invalid_keys to invalid_symbols #56

    * We keep track of invalid license symbols from syntax errors

Signed-off-by: Jono Yang <[email protected]>

Author: JonoYang

src/license_expression/__init__.py

@@ -141,30 +141,31 @@ class ExpressionInfo:
     - errors: list
       - If there were errors validating a license expression,
         the error messages will be appended here.
-    - invalid_keys: list
+    - invalid_symbols: list
       - If the license expression that has been passed into `validate()` has
         license keys that are invalid (either that they are unknown or not used
-        in the right context), then those keys will be appended here.
+        in the right context), or the syntax is incorrect because an invalid
+        symbol was used, then those symbols will be appended here.
     """
     def __init__(
         self,
         original_expression,
         normalized_expression=None,
         errors=None,
-        invalid_keys=None,
+        invalid_symbols=None,
     ):
         self.original_expression = original_expression
         self.normalized_expression = normalized_expression
         self.errors = errors or []
-        self.invalid_keys = invalid_keys or []
+        self.invalid_symbols = invalid_symbols or []
 
     def __repr__(self):
         return (
             'ExpressionInfo(\n'
                 f'    original_expression={self.original_expression!r},\n'
                 f'    normalized_expression={self.normalized_expression!r},\n'
                 f'    errors={self.errors!r},\n'
-                f'    invalid_keys={self.invalid_keys!r}\n'
+                f'    invalid_symbols={self.invalid_symbols!r}\n'
             ')'
         )
 
@@ -684,8 +685,8 @@ def validate(self, expression, strict=True, **kwargs):
         If an error was encountered when validating `expression`,
         `ExpressionInfo.errors` will be populated with strings containing the
         error message that has occured. If an error has occured due to unknown
-        license keys, the offending keys will be present in
-        `ExpressionInfo.invalid_keys`
+        license keys or an invalid license symbol, the offending keys or symbols
+        will be present in `ExpressionInfo.invalid_symbols`
 
         If `strict` is True, validation error messages will be included if in a "WITH"
         expression such as "XXX with ZZZ" if the XXX symbol has `is_exception`
@@ -701,11 +702,7 @@ def validate(self, expression, strict=True, **kwargs):
             parsed_expression = self.parse(expression, strict=strict)
         except ExpressionError as e:
             expression_info.errors.append(str(e))
-            error_code = e.error_code
-            # If we have these error codes, then we have a problematic license
-            # key that we need to append to `invalid_keys`
-            if error_code and error_code in (PARSE_INVALID_EXCEPTION, PARSE_INVALID_SYMBOL_AS_EXCEPTION):
-                expression_info.invalid_keys.append(e.token_string)
+            expression_info.invalid_symbols.append(e.token_string)
             return expression_info
 
         # Check `expression` keys (validate)
@@ -714,13 +711,13 @@ def validate(self, expression, strict=True, **kwargs):
         except ExpressionError as e:
             expression_info.errors.append(str(e))
             unknown_keys = self.unknown_license_keys(expression)
-            expression_info.invalid_keys.extend(unknown_keys)
+            expression_info.invalid_symbols.extend(unknown_keys)
             return expression_info
 
         # If we have not hit an exception, set `normalized_expression` in
         # `expression_info` only if we did not encounter any errors
         # along the way
-        if not expression_info.errors and not expression_info.invalid_keys:
+        if not expression_info.errors and not expression_info.invalid_symbols:
             expression_info.normalized_expression = str(parsed_expression)
         return expression_info
 

tests/test_license_expression.py

@@ -2242,56 +2242,56 @@ def test_validate_simple(self):
         assert result.original_expression == 'GPL-2.0-or-later AND MIT'
         assert result.normalized_expression == 'GPL-2.0-or-later AND MIT'
         assert result.errors == []
-        assert result.invalid_keys == []
+        assert result.invalid_symbols == []
 
     def test_validation_invalid_license_key(self):
         result = self.licensing.validate('cool-license')
         assert result.original_expression == 'cool-license'
         assert not result.normalized_expression
         assert result.errors == ['Unknown license key(s): cool-license']
-        assert result.invalid_keys == ['cool-license']
+        assert result.invalid_symbols == ['cool-license']
 
     def test_validate_exception(self):
         result = self.licensing.validate('GPL-2.0-or-later WITH WxWindows-exception-3.1')
         assert result.original_expression == 'GPL-2.0-or-later WITH WxWindows-exception-3.1'
         assert result.normalized_expression == 'GPL-2.0-or-later WITH WxWindows-exception-3.1'
         assert result.errors == []
-        assert result.invalid_keys == []
+        assert result.invalid_symbols == []
 
     def test_validation_exception_with_choice(self):
         result = self.licensing.validate('GPL-2.0-or-later WITH WxWindows-exception-3.1 OR MIT')
         assert result.original_expression == 'GPL-2.0-or-later WITH WxWindows-exception-3.1 OR MIT'
         assert result.normalized_expression == 'GPL-2.0-or-later WITH WxWindows-exception-3.1 OR MIT'
         assert result.errors == []
-        assert result.invalid_keys == []
+        assert result.invalid_symbols == []
 
     def test_validation_exception_as_regular_key(self):
         result = self.licensing.validate('GPL-2.0-or-later AND WxWindows-exception-3.1')
         assert result.original_expression == 'GPL-2.0-or-later AND WxWindows-exception-3.1'
         assert not result.normalized_expression
         assert result.errors == ['A license exception symbol can only be used as an exception in a "WITH exception" statement. for token: "WxWindows-exception-3.1" at position: 21']
-        assert result.invalid_keys == ['WxWindows-exception-3.1']
+        assert result.invalid_symbols == ['WxWindows-exception-3.1']
 
     def test_validation_bad_syntax(self):
         result = self.licensing.validate('Apache-2.0 + MIT')
         assert result.original_expression == 'Apache-2.0 + MIT'
         assert not result.normalized_expression
         assert result.errors == ['Invalid symbols sequence such as (A B) for token: "+" at position: 11']
-        assert result.invalid_keys == []
+        assert result.invalid_symbols == ['+']
 
     def test_validation_invalid_license_exception(self):
         result = self.licensing.validate('Apache-2.0 WITH MIT')
         assert result.original_expression == 'Apache-2.0 WITH MIT'
         assert not result.normalized_expression
         assert result.errors == ["A plain license symbol cannot be used as an exception in a \"WITH symbol\" statement. for token: \"MIT\" at position: 16"]
-        assert result.invalid_keys == ['MIT']
+        assert result.invalid_symbols == ['MIT']
 
     def test_validation_invalid_license_exception_strict_false(self):
         result = self.licensing.validate('Apache-2.0 WITH MIT', strict=False)
         assert result.original_expression == 'Apache-2.0 WITH MIT'
         assert result.normalized_expression == 'Apache-2.0 WITH MIT'
         assert result.errors == []
-        assert result.invalid_keys == []
+        assert result.invalid_symbols == []
 
 
 class UtilTest(TestCase):