Add to write yaml

src/fosslight_util/constant.py

@@ -4,3 +4,12 @@
 # SPDX-License-Identifier: Apache-2.0
 
 LOGGER_NAME = "FOSSLight"
+
+FL_SOURCE = 'FL_Source'
+FL_DEPENDENCY = 'FL_Dependency'
+FL_BINARY = 'FL_Binary'
+supported_sheet_and_scanner = {'SRC': FL_SOURCE,
+                               'BIN': FL_BINARY,
+                               f'SRC_{FL_SOURCE}': FL_SOURCE,
+                               f'SRC_{FL_DEPENDENCY}': FL_DEPENDENCY,
+                               f'BIN_{FL_BINARY}': FL_BINARY}

src/fosslight_util/oss_item.py

@@ -10,109 +10,138 @@
 
 
 class OssItem:
-    name = "-"
-    version = ""
-    licenses = []
-    source = ""
-    files = []
-    copyright = ""
-    comment = ""
-    exclude = ""
-    homepage = ""
-    relative_path = ""
-
     def __init__(self, value):
-        self.name = "-"
-        self.version = ""
-        self.licenses = []
-        self.source = ""
-        self.files = []
-        self.copyright = ""
+        self._name = "-"
+        self._version = ""
+        self._license = []
+        self._copyright = ""
         self.comment = ""
-        self.exclude = ""
+        self._exclude = False
         self.homepage = ""
         self.relative_path = value
+        self._source_name_or_path = []
+        self.download_location = ""
 
     def __del__(self):
         pass
 
-    def set_homepage(self, value):
-        self.homepage = value
-
-    def set_comment(self, value):
-        self.comment = value
+    @property
+    def copyright(self):
+        return self._copyright
 
-    def set_copyright(self, value):
+    @copyright.setter
+    def copyright(self, value):
         if value != "":
             if isinstance(value, list):
                 value = "\n".join(value)
             value = value.strip()
-        self.copyright = value
+        self._copyright = value
+
+    @property
+    def exclude(self):
+        return self._exclude
 
-    def set_exclude(self, value):
+    @exclude.setter
+    def exclude(self, value):
         if value:
-            self.exclude = "Exclude"
+            self._exclude = True
         else:
-            self.exclude = ""
+            self._exclude = False
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if value != "":
+            self._name = value
 
-    def set_name(self, value):
-        self.name = value
+    @property
+    def version(self):
+        return self._version
 
-    def set_version(self, value):
-        self.version = str(value)
+    @version.setter
+    def version(self, value):
+        if value:
+            self._version = str(value)
+        else:
+            self._version = ""
 
-    def set_licenses(self, value):
+    @property
+    def license(self):
+        return self._license
+
+    @license.setter
+    def license(self, value):
         if not isinstance(value, list):
             value = value.split(",")
-        self.licenses.extend(value)
-        self.licenses = [item.strip() for item in self.licenses]
-        self.licenses = list(set(self.licenses))
+        self._license.extend(value)
+        self._license = [item.strip() for item in self._license]
+        self._license = list(set(self._license))
 
-    def set_files(self, value):
-        if isinstance(value, list):
-            self.files.extend(value)
-        else:
-            self.files.append(value)
-        self.files = list(set(self.files))
+    @property
+    def source_name_or_path(self):
+        return self._source_name_or_path
 
-    def set_source(self, value):
-        self.source = value
+    @source_name_or_path.setter
+    def source_name_or_path(self, value):
+        if not isinstance(value, list):
+            value = value.split(",")
+        self._source_name_or_path.extend(value)
+        self._source_name_or_path = [item.strip() for item in self._source_name_or_path]
+        self._source_name_or_path = list(set(self._source_name_or_path))
+
+    def set_sheet_item(self, item):
+        if len(item) < 9:
+            _logger.warning(f"sheet list is too short ({len(item)}): {item}")
+            return
+        self.source_name_or_path = item[0]
+        self.name = item[1]
+        self.version = item[2]
+        self.license = item[3]
+        self.download_location = item[4]
+        self.homepage = item[5]
+        self.copyright = item[6]
+        self.exclude = item[7]
+        self.comment = item[8]
 
     def get_print_array(self):
         items = []
-        if len(self.files) == 0:
-            self.files.append("")
-        if len(self.licenses) == 0:
-            self.licenses.append("")
-        for file in self.files:
-            lic = ",".join(self.licenses)
+        if len(self.source_name_or_path) == 0:
+            self.source_name_or_path.append("")
+        if len(self.license) == 0:
+            self.license.append("")
+
+        exclude = "Exclude" if self.exclude else ""
+
+        for source_name_or_path in self.source_name_or_path.split(","):
+            lic = ",".join(self.license)
             if self.relative_path != "" and not str(self.relative_path).endswith("/"):
                 self.relative_path += "/"
-            items.append([self.relative_path + file, self.name, self.version, lic, self.source, self.homepage,
-                          self.copyright, "", self.exclude, self.comment])
+            items.append([self.relative_path + source_name_or_path, self.name, self.version, lic,
+                          self.download_location, self.homepage, self.copyright, exclude, self.comment])
         return items
 
     def get_print_json(self):
         json_item = {}
         json_item["name"] = self.name
 
-        if self.version != "":
-            json_item["version"] = self.version
-        if self.source != "":
-            json_item["source"] = self.source
+        json_item["version"] = self.version
+        if len(self.source_name_or_path) > 0:
+            json_item["source name or path"] = self.source_name_or_path
+        if len(self.license) > 0:
+            json_item["license"] = self.license
+        if self.download_location != "":
+            json_item["download location"] = self.download_location
+        if self.homepage != "":
+            json_item["homepage"] = self.homepage
         if self.copyright != "":
-            json_item["copyright"] = self.copyright
-        if self.exclude != "":
+            json_item["copyright text"] = self.copyright
+        if self.exclude:
             json_item["exclude"] = self.exclude
         if self.comment != "":
             json_item["comment"] = self.comment
-        if self.homepage != "":
-            json_item["homepage"] = self.homepage
-
-        if len(self.files) > 0:
-            json_item["file"] = self.files
-        if len(self.licenses) > 0:
-            json_item["license"] = self.licenses
 
         return json_item
 

src/fosslight_util/output_format.py

@@ -5,8 +5,9 @@
 import os
 from fosslight_util.write_excel import write_result_to_excel, write_excel_and_csv, write_result_to_csv
 from fosslight_util.write_opossum import write_opossum
+from fosslight_util.write_yaml import write_yaml
 
-SUPPORT_FORMAT = {'excel': '.xlsx', 'csv': '.csv', 'opossum': '.json'}
+SUPPORT_FORMAT = {'excel': '.xlsx', 'csv': '.csv', 'opossum': '.json', 'yaml': '.yaml'}
 
 
 def check_output_format(output='', format='', customized_format={}):
@@ -71,6 +72,8 @@ def write_output_file(output_file_without_ext, file_extension, sheet_list, exten
         success, msg, result_file = write_result_to_csv(result_file, sheet_list)
     elif file_extension == '.json':
         success, msg = write_opossum(result_file, sheet_list)
+    elif file_extension == '.yaml':
+        success, msg, result_file = write_yaml(result_file, sheet_list, False)
     else:
         success = False
         msg = f'Not supported file extension({file_extension})'

src/fosslight_util/write_opossum.py

@@ -16,21 +16,17 @@
 import fosslight_util.constant as constant
 from fosslight_util.write_excel import remove_empty_sheet
 
-FL_SOURCE = 'FL_Source'
-FL_DEPENDENCY = 'FL_Dependency'
-FL_BINARY = 'FL_Binary'
-supported_sheet_and_scanner = {'SRC': FL_SOURCE, 'BIN': FL_BINARY}
-supported_sheet_name = ['SRC_' + FL_SOURCE, 'SRC_' + FL_DEPENDENCY, 'BIN_' + FL_BINARY]
 
-PACKAE = {
+PACKAGE = {
     'requirements.txt': 'pypi',
     'package.json': 'npm',
     'pom.xml': 'maven',
     'build.gradle': 'gradle',
     'pubspec.yaml': 'pub',
     'Podfile.lock': 'cocoapods',
     'Package.resolved': 'swift',
-    'Cartfile.resolved': 'carthage'
+    'Cartfile.resolved': 'carthage',
+    'go.mod': 'Go'
 }
 
 _attributionConfidence = 80
@@ -55,7 +51,7 @@ def __init__(self,
             self.excludeFromNotice = False
 
         self.source_name = source_name
-        if source_name == FL_DEPENDENCY:
+        if source_name == constant.FL_DEPENDENCY:
             self.preSelected = True
         else:
             self.preSelected = False
@@ -117,12 +113,12 @@ def get_externalAttribution_dict(self):
         dict[licenseName] = self.licenseName
         dict[preSelected] = self.preSelected
 
-        if self.source_name == FL_SOURCE or FL_BINARY:
+        if self.source_name == constant.FL_SOURCE or constant.FL_BINARY:
             dict[copyright] = self.copyright
             dict[packageName] = self.packageName
             dict[packageVersion] = self.packageVersion
             dict[url] = self.url
-        elif self.source_name == FL_DEPENDENCY:
+        elif self.source_name == constant.FL_DEPENDENCY:
             dict[copyright] = self.copyright
             dict[packageName] = self.packageName
             dict[packageVersion] = self.packageVersion
@@ -196,10 +192,8 @@ def write_opossum(filename, sheet_list):
         attributionBreakpoints_list = []
         try:
             for sheet_name, sheet_contents in sheet_list.items():
-                if sheet_name in supported_sheet_and_scanner:
-                    scanner = supported_sheet_and_scanner.get(sheet_name)
-                elif sheet_name in supported_sheet_name:
-                    scanner = '_'.join(sheet_name.split('_')[1:])
+                if sheet_name in constant.supported_sheet_and_scanner.keys():
+                    scanner = constant.supported_sheet_and_scanner.get(sheet_name)
                 else:
                     logger.warning("Not supported scanner(sheet_name):" + sheet_name)
                     continue
@@ -263,15 +257,15 @@ def make_resources_and_attributions(sheet_items, scanner, resources, fc_list):
             items = items[0:9]
             path, oss_name, oss_version, license, url, homepage, copyright, exclude, comment = items
 
-            if scanner == FL_SOURCE:
+            if scanner == constant.FL_SOURCE:
                 if (os.path.join(os.sep, path) + os.sep) not in fc_list:
                     resources = make_resources(path, resources)
                 attribution = Attribution(scanner, license, exclude, copyright, oss_name, oss_version, url)
-            elif scanner == FL_BINARY:
+            elif scanner == constant.FL_BINARY:
                 resources = make_resources(path, resources)
                 attribution = Attribution(scanner, license, exclude, copyright, oss_name, oss_version, url)
-            elif scanner == FL_DEPENDENCY:
-                packageType = PACKAE[path]
+            elif scanner == constant.FL_DEPENDENCY:
+                packageType = PACKAGE[path]
                 if (os.path.join(os.sep, path) + os.sep) not in fc_list:
                     fc_list.append(os.path.join(os.sep, path) + os.sep)
                     ab_list.append(os.path.join(os.sep, path, packageType) + os.sep)