Fixed #101 - Add 'about_resource_path' in the ABOUT file

Fixed #129 - Use the 'license_text_file' as the license input for attribution.

Author: chinyeungli

about_code_tool/about.py

@@ -951,16 +951,6 @@ def notice_text(self):
 
         return ""  # Returns empty string if the notice file does not exist
 
-    def get_dje_license_name(self):
-        """
-        Return the dje_license value if the dje_license field exists
-        """
-        try:
-            return self.parsed['dje_license_name']
-        except Exception as e:
-            pass
-        return ""
-
     def get_license_text_file_name(self):
         """
         Return the license_text_file name if the license_text_file field exists
@@ -991,6 +981,16 @@ def get_about_name(self):
             pass
         return ""
 
+    def get_about_resource_path(self):
+        """
+        Return the about object's name
+        """
+        try:
+            return self.parsed['about_resource_path']
+        except Exception as e:
+            pass
+        return ""
+
 class AboutCollector(object):
     """
     A collection of AboutFile instances.
@@ -1140,6 +1140,7 @@ def generate_attribution(self, template_path=None, limit_to=None):
         license_key = []
         license_text_list = []
         license_dict = {}
+        common_license_dict = {}
         not_exist_components = list(limit_to)
 
         for about_object in self:
@@ -1155,16 +1156,24 @@ def generate_attribution(self, template_path=None, limit_to=None):
             if not limit_to or about_relative_path in limit_to:
                 validated_fields.append(about_object.validated_fields)
                 notice_text.append(about_object.notice_text())
-                dje_license_name = about_object.get_dje_license_name()
                 license_text_file = about_object.get_license_text_file_name()
-                license_text = about_object.get_license_text()
+                about_resource_path = about_object.get_about_resource_path()
+                if not about_resource_path:
+                    msg = 'About File: %s - The required field, about_resource_path, not found'\
+                        ' License generation is skipped.'\
+                        % about_object.location
+                    self.genattrib_errors.append(Error(GENATTRIB,\
+                                   'about_resource',\
+                                   about_object.location, msg))
                 if license_text_file:
-                    # Check if the license key, license_text_file, already
-                    # exist in the license dictionary
-                    if license_text_file in license_dict:
+                    # Use the about_file_path as the key
+                    # Check if the key already existed in the dictionary
+                    # This shouldn't be reached as the 'about_resource_path'
+                    # should be unique.
+                    if about_resource_path in license_dict:
                         # Raise error if key name are the same but the content
                         # are different
-                        license_text_check = license_dict[license_text_file]
+                        license_text_check = license_dict[about_resource_path]
                         if not unicode(license_text_check) == unicode(about_object.license_text()):
                             msg = 'License Name: %s - Same license name with different content.'\
                                 ' License generation is skipped.'\
@@ -1173,18 +1182,12 @@ def generate_attribution(self, template_path=None, limit_to=None):
                                    'license_text',\
                                    license_text_file, msg))
                     else:
-                        if license_text_file.endswith('.LICENSE'):
-                            license_dict[license_text_file] = unicode(about_object.license_text(), errors='replace')
-                        else:
-                            # If the 'license_text_file' doesn't end with '.LICENSE',
-                            # such as COPYING, COPYRIGHT, we will use the name
-                            # of the About file combine with the 'license_text_file'
-                            # as the key of the license dictionary.
-                            license_name = about_object.get_about_name() + '_' + license_text_file
-                            license_dict[license_name] = unicode(about_object.license_text(), errors='replace')
-                elif license_text:
+                        license_dict[about_resource_path] = unicode(about_object.license_text(), errors='replace')
+                        if license_text_file in COMMON_LICENSES:
+                            common_license_dict[license_text_file] = unicode(about_object.license_text(), errors='replace')
+                elif about_object.get_license_text():
                     # We don't need to do anything here as the license_text
-                    # will be capture directly in the about object.
+                    # will be captured directly in the about object.
                     pass
                 else:
                     msg = 'No license_text is found. License generation is skipped.'
@@ -1200,16 +1203,14 @@ def generate_attribution(self, template_path=None, limit_to=None):
                 self.genattrib_errors.append(Error(GENATTRIB, 'about_file',\
                                                    component, msg))
 
-        # We want the license generation in alphabetical order
-        for key in sorted(license_dict.keys()):
+        # We want to display common_licenses in alphabetical order
+        for key in sorted(common_license_dict.keys()):
             license_key.append(key)
-            license_text_list.append(license_dict[key])
+            license_text_list.append(common_license_dict[key])
 
         return template.render(about_objects=validated_fields,
                                license_keys=license_key,
                                license_texts = license_text_list,
-                               #license_keys=license_text_file_name,
-                               #license_texts = license_text_file_content,
                                notice_texts=notice_text,
                                license_dicts=license_dict,
                                common_licenses=COMMON_LICENSES)

about_code_tool/genabout.py

@@ -467,6 +467,9 @@ def pre_generation(self, gen_location, input_list, action_num, all_in_one):
                 # This is to get the filename instead of the file path
                 file_location = file_location.rpartition('/')[2]
             about_file_location = join(gen_location, file_location)
+            if not file_location.startswith('/'):
+                line['about_resource_path'] = '/'
+            line['about_resource_path'] += file_location
             dir = dirname(about_file_location)
             if not _exists(dir):
                 makedirs(dir)

about_code_tool/templates/default.html

@@ -56,7 +56,7 @@ <h1>OPEN SOURCE SOFTWARE INFORMATION</h1>
                 <h3 class="component-name">{{ about_object.name }}
                     {% if about_object.version %}{{ about_object.version }}{% endif %}
                 </h3>
-                {% if about_object.license_text_file in license_dicts.keys() %}
+                {% if about_object.about_resource_path in license_dicts.keys() %}
                     {% if about_object.dje_license_name %}
                         <p>This component is licensed under {{about_object.dje_license_name }}.
                     {% endif %}
@@ -70,18 +70,20 @@ <h3 class="component-name">{{ about_object.name }}
                     <pre class="component-notice">{{ notice_texts[loop.index0] }}</pre>
                 {% endif %}
                 {% if about_object.license_text_file %}
+                    <!-- 'license_text_file' is not a common license if it 
+                        doesn't end with '.LICENSE'
+                    -->
                     {% if not about_object.license_text_file.endswith('.LICENSE') %}
-                        <pre>{{ license_dicts[about_object.name + '_' + about_object.license_text_file]|e }}</pre>
-                    {% endif %}
-                    {% if about_object.license_text_file in license_dicts.keys() %}
+                        <pre>{{ license_dicts[about_object.about_resource_path]|e }}</pre>
+                    {% elif about_object.about_resource_path in license_dicts.keys() %}
                         {% if about_object.license_text_file in common_licenses %}
                             <p>Full text of
                                 <a class="{{ about_object.license_text_file }}" href="#component-license-{{ about_object.license_text_file }}">
                                  {{ about_object.license_text_file }}
                                  </a>
                                     is available at the end of this document.</p>
                         {% else %}
-                            <pre>{{ license_dicts[about_object.license_text_file]|e }}</pre>
+                            <pre>{{ license_dicts[about_object.about_resource_path]|e }}</pre>
                         {% endif %}
                     {% endif %}
                 {% elif about_object.license_text %}

about_code_tool/tests/test_about.py

@@ -578,36 +578,18 @@ def test_notice_text_returns_empty_string_when_ref_file_doesnt_exist(self):
         notice_text = about_file.notice_text()
         self.assertEqual(notice_text, expected)
 
-    def test_get_dje_license_name(self):
-        expected = 'Apache License 2.0'
-        about_file = about.AboutFile(join(TESTDATA_PATH, 'parser_tests/about_resource_field_present.ABOUT'))
-        output = about_file.get_dje_license_name()
-        self.assertTrue(output == expected)
-
     def test_get_license_text_file_name(self):
         expected = 'httpd.LICENSE'
         about_file = about.AboutFile(join(TESTDATA_PATH, 'parser_tests/about_resource_field_present.ABOUT'))
         output = about_file.get_license_text_file_name()
         self.assertTrue(output == expected)
 
-    def test_get_dje_license_name_no_value(self):
-        expected = ''
-        about_file = about.AboutFile(join(TESTDATA_PATH, 'parser_tests/about_file_empty_value_for_dje_license_license_text_file.ABOUT'))
-        output = about_file.get_dje_license_name()
-        self.assertTrue(output == expected)
-
     def test_get_license_text_file_name_no_value(self):
         expected = ''
         about_file = about.AboutFile(join(TESTDATA_PATH, 'parser_tests/about_file_empty_value_for_dje_license_license_text_file.ABOUT'))
         output = about_file.get_license_text_file_name()
         self.assertTrue(output == expected)
 
-    def test_get_dje_license_name_no_key(self):
-        expected = None
-        about_file = about.AboutFile(join(TESTDATA_PATH, 'parser_tests/about_file_no_dje_license_no_license_text_file_keys.ABOUT'))
-        output = about_file.get_dje_license_name()
-        self.assertTrue(output == expected)
-
     def test_get_license_text_file_name_no_key(self):
         expected = None
         about_file = about.AboutFile(join(TESTDATA_PATH, 'parser_tests/about_file_no_dje_license_no_license_text_file_keys.ABOUT'))

about_code_tool/tests/test_genabout.py

@@ -299,6 +299,7 @@ def test_pre_generation_about_is_dir_exists_action_0(self):
                         'about_resource': '.', 'name': 'ABOUT tool'}]
         expected_output_list = [[join(TESTDATA_PATH, 'test_files_for_genabout/TESTCASE', 'TESTCASE.ABOUT'),
                                  {'about_file': '/TESTCASE/', 'version': '0.8.1',
+                                  'about_resource_path' : '/TESTCASE/TESTCASE.ABOUT',
                                   'about_resource': '.', 'name': 'ABOUT tool'}]]
         output_list = gen.pre_generation(gen_location, input_list, action_num, False)
         self.assertTrue(expected_output_list == output_list)
@@ -336,9 +337,9 @@ def test_pre_generation_about_exists_action_2(self):
         input_list = [{'about_file': '/about.py.ABOUT', 'version': '0.8.2',
                         'about_resource': '.', 'name': '', 'test': 'test sample'}]
         expected_output_list = [[join(TESTDATA_PATH, 'test_files_for_genabout', 'about.py.ABOUT'),
-                                  {'test': 'test sample', 'about_file': 'about.py.ABOUT',
-                                    'version': '0.8.1', 'about_resource': '.',
-                                     'name': 'ABOUT tool'}]]
+                                 {'about_file': 'about.py.ABOUT', 'name': 'ABOUT tool',
+                                      'about_resource_path': '/about.py.ABOUT',
+                                      'version': '0.8.1', 'test': 'test sample', 'about_resource': '.'}]]
         output_list = gen.pre_generation(GEN_LOCATION, input_list, action_num, False)
         self.assertTrue(expected_output_list == output_list)
         self.assertFalse(gen.warnings, "No warnings should be returned.")
@@ -351,7 +352,8 @@ def test_pre_generation_about_exists_action_3(self):
                         'about_resource': '.', 'name': '', 'test': 'test sample'}]
         expected_output_list = [[join(TESTDATA_PATH, 'test_files_for_genabout', 'about.py.ABOUT'),
                                   {'about_file': '/about.py.ABOUT', 'version': '0.8.2',
-                                    'about_resource': '.', 'name': '', 'test': 'test sample'}]]
+                                   'about_resource_path': '/about.py.ABOUT',
+                                   'about_resource': '.', 'name': '', 'test': 'test sample'}]]
         output_list = gen.pre_generation(GEN_LOCATION, input_list, action_num, False)
         self.assertTrue(expected_output_list == output_list)
         self.assertFalse(gen.warnings, "No warnings should be returned.")