Catch invalid license_expression in parse_license_expression

Signed-off-by: Chin Yeung Li <[email protected]>

Author: chinyeungli

CHANGELOG.rst

@@ -6,6 +6,7 @@ Changelog
 
     * Add character support (at most 2 characters) for `attribute` field
     * Strip empty newline characters when loading an inventory
+    * Catch invalid license_expression
 
 
 2023-09-25

src/attributecode/attrib.py

@@ -225,7 +225,8 @@ def generate_sctk_input(abouts, min_license_score, license_dict):
             updated_lic_name = []
             updated_lic_score = []
             for index, lic in enumerate(updated_dict):
-                _sp_char, lic_keys = parse_license_expression(lic)
+                _sp_char, lic_keys, _invalid_lic_exp = parse_license_expression(
+                    lic)
                 score, name = updated_dict[lic]
                 if score >= min_license_score:
                     for lic_key in lic_keys:
@@ -306,12 +307,17 @@ def generate_and_save(abouts, is_about_input, license_dict, output_location, sca
     for about in abouts:
         if not about.license_expression.value:
             continue
-        special_char_in_expression, lic_list = parse_license_expression(
+        special_char_in_expression, lic_list, invalid_lic_exp = parse_license_expression(
             about.license_expression.value)
-        if special_char_in_expression:
-            msg = (u"The following character(s) cannot be in the license_expression: " +
-                   str(special_char_in_expression))
+        if special_char_in_expression or invalid_lic_exp:
+            if special_char_in_expression:
+                msg = (u"The following character(s) cannot be in the license_expression: " +
+                       str(special_char_in_expression))
+            else:
+                msg = (u"This license_expression is invalid: " +
+                       str(invalid_lic_exp))
             errors.append(Error(ERROR, msg))
+
     rendering_error, rendered = generate_from_file(
         abouts,
         is_about_input,

src/attributecode/model.py

@@ -1194,7 +1194,7 @@ def load_dict(self, fields_dict, base_dir, scancode=False, from_attrib=False, ru
                     lic_key_exp_list = []
                     lic_score_list = []
                     for lic in lic_list:
-                        _char, lic_keys = parse_license_expression(
+                        _char, lic_keys, _invalid_lic_exp = parse_license_expression(
                             lic['lic_exp'])
                         lic_key_list.append(lic_keys)
                         # for lic_key in lic_keys:
@@ -1327,7 +1327,7 @@ def dumps(self, licenses_dict=None):
         # and get the parsed license key
         if 'license_expression' in data:
             if not license_key and data['license_expression']:
-                _spec_char, lic_list = parse_license_expression(
+                _spec_char, lic_list, _invalid_lic_exp = parse_license_expression(
                     data['license_expression'])
                 license_key = lic_list
 
@@ -1501,11 +1501,11 @@ def dump_lic(self, location, license_dict):
             os.makedirs(add_unc(parent))
 
         if self.license_expression.present:
-            special_char_in_expression, lic_list = parse_license_expression(
+            special_char_in_expression, lic_list, invalid_lic_exp = parse_license_expression(
                 self.license_expression.value)
             self.license_key.value = lic_list
             self.license_key.present = True
-            if not special_char_in_expression:
+            if not special_char_in_expression and not invalid_lic_exp:
                 for lic_key in lic_list:
                     license_name = ''
                     license_filename = ''
@@ -1905,11 +1905,15 @@ def pre_process_and_fetch_license_dict(abouts, from_check=False, api_url=None, a
 
         if not about.license_expression.value and about.spdx_license_expression.value:
             lic_exp_value = ""
-            special_char_in_expression, lic_list = parse_license_expression(
+            special_char_in_expression, lic_list, invalid_lic_exp = parse_license_expression(
                 about.spdx_license_expression.value)
-            if special_char_in_expression:
-                msg = (about.about_file_path + u": The following character(s) cannot be in the spdx_license_expression: " +
-                       str(special_char_in_expression))
+            if special_char_in_expression or invalid_lic_exp:
+                if special_char_in_expression:
+                    msg = (about.about_file_path + u": The following character(s) cannot be in the spdx_license_expression: " +
+                           str(special_char_in_expression))
+                else:
+                    msg = (about.about_file_path + u": This spdx_license_expression is invalid: " +
+                           str(invalid_lic_exp))
                 errors.append(Error(ERROR, msg))
             else:
                 spdx_lic_exp_segment = about.spdx_license_expression.value.split()
@@ -1925,11 +1929,15 @@ def pre_process_and_fetch_license_dict(abouts, from_check=False, api_url=None, a
                     about.license_expression.present = True
 
         if about.license_expression.value:
-            special_char_in_expression, lic_list = parse_license_expression(
+            special_char_in_expression, lic_list, invalid_lic_exp = parse_license_expression(
                 about.license_expression.value)
-            if special_char_in_expression:
-                msg = (about.about_file_path + u": The following character(s) cannot be in the license_expression: " +
-                       str(special_char_in_expression))
+            if special_char_in_expression or invalid_lic_exp:
+                if special_char_in_expression:
+                    msg = (about.about_file_path + u": The following character(s) cannot be in the license_expression: " +
+                           str(special_char_in_expression))
+                else:
+                    msg = (about.about_file_path + u": This license_expression is invalid: " +
+                           str(invalid_lic_exp))
                 errors.append(Error(ERROR, msg))
             else:
                 for lic_key in lic_list:
@@ -2027,11 +2035,15 @@ def convert_spdx_expression_to_lic_expression(spdx_key, spdx_lic_dict):
 def parse_license_expression(lic_expression):
     licensing = Licensing()
     lic_list = []
+    invalid_lic_exp = ''
     special_char = detect_special_char(lic_expression)
     if not special_char:
         # Parse the license expression and save it into a list
-        lic_list = licensing.license_keys(lic_expression)
-    return special_char, lic_list
+        try:
+            lic_list = licensing.license_keys(lic_expression)
+        except:
+            invalid_lic_exp = lic_expression
+    return special_char, lic_list, invalid_lic_exp
 
 
 def detect_special_char(expression):

tests/test_model.py

@@ -1217,15 +1217,15 @@ def test_collect_inventory_does_not_raise_error_and_maintains_order_on_custom_fi
         assert expected == [a.dumps() for a in abouts]
 
     def test_parse_license_expression(self):
-        spec_char, returned_lic = model.parse_license_expression(
+        spec_char, returned_lic, _invalid_lic_exp = model.parse_license_expression(
             'mit or apache-2.0')
         expected_lic = ['mit', 'apache-2.0']
         expected_spec_char = []
         assert expected_lic == returned_lic
         assert expected_spec_char == spec_char
 
     def test_parse_license_expression_with_special_chara(self):
-        spec_char, returned_lic = model.parse_license_expression(
+        spec_char, returned_lic, _invalid_lic_exp = model.parse_license_expression(
             'mit, apache-2.0')
         expected_lic = []
         expected_spec_char = [',']