#450 Potential fixes

 * Need to add tests

Author: chinyeungli

src/attributecode/gen.py

@@ -303,27 +303,28 @@ def generate(location, base_dir, android=None, reference_dir=None, fetch_license
                            u'does not exist' % locals())
                     not_exist_errors.append(msg)
 
+            licenses_dict = {}
             if gen_license:
                 # Write generated LICENSE file
                 license_key_name_context_url_list = about.dump_lic(dump_loc, license_dict)
                 if license_key_name_context_url_list:
-                    # use value not "presence"
-                    if not about.license_file.present:
-                        about.license_file.value = OrderedDict()
-                        for lic_key, lic_name, lic_context, lic_url in license_key_name_context_url_list:
-                            gen_license_name = lic_key + u'.LICENSE'
-                            about.license_file.value[gen_license_name] = lic_context
+                    for lic_key, lic_name, lic_context, lic_url in license_key_name_context_url_list:
+                        licenses_dict[lic_key] = [lic_name, lic_context, lic_url]
+                        gen_license_name = lic_key + u'.LICENSE'
+                        if not lic_name in about.license_name.value:
+                            about.license_name.value.append(lic_name)
+                        about.license_file.value[gen_license_name] = license_dict[lic_key][1]
+                        if not lic_url in about.license_url.value:
+                            about.license_url.value.append(lic_url)
+
+                        if about.license_name.value:
+                            about.license_name.present = True
+                        if about.license_file.value:
                             about.license_file.present = True
-                            if not about.license_name.present:
-                                about.license_name.value.append(lic_name)
-                            if not about.license_url.present:
-                                about.license_url.value.append(lic_url)
                         if about.license_url.value:
                             about.license_url.present = True
-                        if about.license_name.value:
-                            about.license_name.present = True
 
-            about.dump(dump_loc)
+            about.dump(dump_loc, licenses_dict)
 
             if android:
                 """

src/attributecode/model.py

@@ -1050,7 +1050,7 @@ def from_dict(cls, about_data, base_dir=''):
         about.load_dict(about_data, base_dir=base_dir)
         return about
 
-    def dumps(self):
+    def dumps(self, licenses_dict=None):
         """
         Return self as a formatted ABOUT string.
         """
@@ -1064,7 +1064,6 @@ def dumps(self):
         for field in self.all_fields():
             if not field.value and not field.name in bool_fields:
                 continue
-
             if field.name == 'license_key' and field.value:
                 license_key = field.value
             elif field.name == 'license_name' and field.value:
@@ -1095,10 +1094,6 @@ def dumps(self):
                     license_file = field.value.keys()
             elif field.name == 'license_url' and field.value:
                 license_url = field.value
-
-            # No multiple 'about_resource' reference supported.
-            # Take the first element (should only be one) in the list for the
-            # value of 'about_resource'
             elif field.name in file_fields and field.value:
                 data[field.name] = field.original_value
             elif field.name in bool_fields and not field.value == None:
@@ -1108,7 +1103,36 @@ def dumps(self):
                     data[field.name] = field.value
 
         # Group the same license information in a list
-        license_group = list(zip_longest(license_key, license_name, license_file, license_url))
+        # This `licenses_dict` is a dictionary with license key as the key and the 
+        # value is the list of [license_name, license_context, license_url]
+        lic_key_dup = license_key[:]
+        for lic_key in license_key:
+            lic_dict = OrderedDict()
+
+            if licenses_dict and lic_key in licenses_dict:
+                lic_dict['key'] = lic_key
+                lic_name = licenses_dict[lic_key][0]
+                lic_url = licenses_dict[lic_key][2]
+                lic_file = lic_key + '.LICENSE'
+
+                lic_dict['name'] = lic_name
+                lic_dict['file'] = lic_file
+                lic_dict['url'] = lic_url
+    
+                # Remove the license information if it has been handled
+                #license_key.remove(lic_key)
+                #print(license_key)
+                lic_key_dup.remove(lic_key)
+                if lic_name in license_name:
+                    license_name.remove(lic_name)
+                if lic_url in license_url:
+                    license_url.remove(lic_url)
+                if lic_file in license_file:
+                    license_file.remove(lic_file)
+                data.setdefault('licenses', []).append(lic_dict)
+
+        # Handle license information that have not been handled.
+        license_group = list(zip_longest(lic_key_dup, license_name, license_file, license_url))
         for lic_group in license_group:
             lic_dict = OrderedDict()
             if lic_group[0]:
@@ -1123,7 +1147,7 @@ def dumps(self):
 
         return saneyaml.dump(data)
 
-    def dump(self, location):
+    def dump(self, location, lic_dict=None):
         """
         Write formatted ABOUT representation of self to location.
         """
@@ -1146,7 +1170,7 @@ def dump(self, location):
 
         with io.open(about_file_path, mode='w', encoding='utf-8') as dumped:
             dumped.write(genereated_tk_version)
-            dumped.write(self.dumps())
+            dumped.write(self.dumps(lic_dict))
 
     def dump_android_notice(self, path, context):
         """
@@ -1208,14 +1232,15 @@ def dump_lic(self, location, license_dict):
         if not posixpath.exists(parent):
             os.makedirs(add_unc(parent))
 
-        if self.license_expression.present and not self.license_file.present:
+        if self.license_expression.present:
             special_char_in_expression, lic_list = parse_license_expression(self.license_expression.value)
-            self.license_key.value = lic_list
             self.license_key.present = True
             if not special_char_in_expression:
                 for lic_key in lic_list:
                     try:
                         if license_dict[lic_key]:
+                            if not lic_key in self.license_key.value:
+                                self.license_key.value.append(lic_key)
                             license_path = posixpath.join(parent, lic_key)
                             license_path += u'.LICENSE'
                             license_path = add_unc(license_path)

tests/test_model.py

@@ -700,8 +700,8 @@ def test_load_dict_issue_433(self):
             'license_expression': 'license1 AND license2',
             'notice_file': 'package1.zip.NOTICE',
             'licenses': [
-                {'key': 'license1', 'name': 'License1', 'file': 'license1.LICENSE'},
-                {'key': 'license2', 'name': 'License2', 'file': 'license2.LICENSE'},
+                {'key': 'license1', 'name': 'License1', 'file': 'license1.LICENSE', 'url': 'some_url'},
+                {'key': 'license2', 'name': 'License2', 'file': 'license2.LICENSE','url': 'some_url'},
             ],
         }
         about = model.About()
@@ -717,11 +717,14 @@ def test_load_dict_issue_433(self):
   - key: license1
     name: License1
     file: license1.LICENSE
+    url: some_url
   - key: license2
     name: License2
     file: license2.LICENSE
+    url: some_url
 '''
-        assert about.dumps() == expected
+        lic_dict = {u'license1': [u'License1', u'', u'some_url'], u'license2' : [u'License2', u'', u'some_url']}
+        assert about.dumps(lic_dict) == expected
 
 class SerializationTest(unittest.TestCase):
     def test_About_dumps(self):