Add code to handle special character(s) in license_expression #275

 * The following characters cannot be in the license expression:
 ['!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '+', '=', '{', '}',
'|', '[', ']', '\\', ':', ';', '<', '>', '?', ',', '/']

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

Author: chinyeungli

src/attributecode/model.py

@@ -1010,19 +1010,21 @@ def dump_lic(self, location, license_dict):
             os.makedirs(add_unc(parent))
 
         if self.license.present and not self.license_file.present:
-            for lic_key in parse_license_expression(self.license.value):
-                try:
-                    if license_dict[lic_key]:
-                        license_path = posixpath.join(parent, lic_key)
-                        license_path += u'.LICENSE'
-                        license_path = add_unc(license_path)
-                        license_name, license_context, license_url = license_dict[lic_key]
-                        license_info = (lic_key, license_name, license_context, license_url)
-                        license_key_name_context_url.append(license_info)
-                        with codecs.open(license_path, mode='wb', encoding='utf-8') as lic:
-                            lic.write(license_context)
-                except:
-                    pass
+            special_char_in_expression, lic_list = parse_license_expression(self.license.value)
+            if not special_char_in_expression:
+                for lic_key in lic_list:
+                    try:
+                        if license_dict[lic_key]:
+                            license_path = posixpath.join(parent, lic_key)
+                            license_path += u'.LICENSE'
+                            license_path = add_unc(license_path)
+                            license_name, license_context, license_url = license_dict[lic_key]
+                            license_info = (lic_key, license_name, license_context, license_url)
+                            license_key_name_context_url.append(license_info)
+                            with codecs.open(license_path, mode='wb', encoding='utf-8') as lic:
+                                lic.write(license_context)
+                    except:
+                        pass
         return license_key_name_context_url
 
 # valid field name
@@ -1248,11 +1250,13 @@ def by_license(abouts):
     no_license = grouped['']
     for about in abouts:
         if about.license.value:
-            for lic in parse_license_expression(about.license.value):
-                if lic in grouped:
-                    grouped[lic].append(about)
-                else:
-                    grouped[lic] = [about]
+            special_char_in_expression, lic_list = parse_license_expression(about.license.value)
+            if not special_char_in_expression:
+                for lic in lic_list:
+                    if lic in grouped:
+                        grouped[lic].append(about)
+                    else:
+                        grouped[lic] = [about]
         else:
             no_license.append(about)
     return OrderedDict(sorted(grouped.items()))
@@ -1300,11 +1304,13 @@ def by_license_content(abouts):
     no_license = grouped['']
     for about in abouts:
         if about.license.value:
-            for lic in parse_license_expression(about.license.value):
-                if lic in grouped:
-                    grouped[lic].append(about)
-                else:
-                    grouped[lic] = [about]
+            special_char_in_expression, lic_list = parse_license_expression(about.license.value)
+            if not special_char_in_expression:
+                for lic in lic_list:
+                    if lic in grouped:
+                        grouped[lic].append(about)
+                    else:
+                        grouped[lic] = [about]
         else:
             no_license.append(about)
     return OrderedDict(sorted(grouped.items()))
@@ -1342,27 +1348,46 @@ def pre_process_and_fetch_license_dict(abouts, api_url, api_key):
         if auth_error in errors:
             break
         if about.license.present:
-            for lic_key in parse_license_expression(about.license.value):
-                if not lic_key in captured_license:
-                    detail_list = []
-                    license_name, license_key, license_text, errs = api.get_license_details_from_api(api_url, api_key, lic_key)
-                    for e in errs:
-                        if e not in errors:
-                            errors.append(e)
-                    if license_key:
-                        captured_license.append(lic_key)
-                        dje_lic_url = dje_lic_urn + license_key
-                        detail_list.append(license_name)
-                        detail_list.append(license_text)
-                        detail_list.append(dje_lic_url)
-                        key_text_dict[license_key] = detail_list
+            special_char_in_expression, lic_list = parse_license_expression(about.license.value)
+            if special_char_in_expression:
+                msg = (u"The following character(s) cannot be in the licesne_expression: " +
+                       str(special_char_in_expression))
+                errors.append(Error(ERROR, msg))
+            else:
+                for lic_key in lic_list:
+                    if not lic_key in captured_license:
+                        detail_list = []
+                        license_name, license_key, license_text, errs = api.get_license_details_from_api(api_url, api_key, lic_key)
+                        for e in errs:
+                            if e not in errors:
+                                errors.append(e)
+                        if license_key:
+                            captured_license.append(lic_key)
+                            dje_lic_url = dje_lic_urn + license_key
+                            detail_list.append(license_name)
+                            detail_list.append(license_text)
+                            detail_list.append(dje_lic_url)
+                            key_text_dict[license_key] = detail_list
     return key_text_dict, errors
 
 def parse_license_expression(lic_expression):
     licensing = Licensing()
-    # Parse the license expression and save it into a list
-    lic_list = licensing.license_keys(lic_expression)
-    return lic_list
+    lic_list = []
+    special_char = special_char_in_license_expresion(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
+
+def special_char_in_license_expresion(lic_expression):
+    not_support_char = ['!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
+                    '+', '=', '{', '}', '|', '[', ']', '\\',
+                    ':', ';', '<', '>', '?', ',', '/']
+    special_character = []
+    for char in not_support_char:
+        if char in lic_expression:
+            special_character.append(char)
+    return special_character
 
 def valid_api_url(api_url):
     try:

tests/test_model.py

@@ -1147,9 +1147,18 @@ def test_collect_inventory_with_license_expression(self):
         assert expected_lic == returned_lic
 
     def test_parse_license_expression(self):
-        returned_lic = model.parse_license_expression(u'mit or apache-2.0')
+        spec_char, returned_lic = model.parse_license_expression(u'mit or apache-2.0')
         expected_lic = [u'mit', u'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(u'mit, apache-2.0')
+        expected_lic = []
+        expected_spec_char = [',']
+        assert expected_lic == returned_lic
+        assert expected_spec_char == spec_char
 
     def test_collect_inventory_works_with_relative_paths(self):
         # FIXME: This test need to be run under src/attributecode/