scanoss 0.7.8 → 0.7.9

package/tests/sdk/FileCount/samples/22036/files/b.ts

@@ -0,0 +1,184 @@
+// import {
+//   DataProvider,
+//   IDataLayers,
+//   LicenseComponent,
+//   LicenseDataLayer
+// } from '../DataLayerTypes';
+// import {
+//   ScannerComponent,
+//   ScannerResults
+// } from '../../scanner/ScannerTypes';
+// import { IDependencyResponse } from '../../Dependencies/DependencyTypes';
+//
+// export class LicenseDataProvider implements DataProvider {
+//
+//   private scanResults: ScannerResults
+//
+//   private componentList: ScannerComponent[];
+//
+//   private dependencies: IDependencyResponse;
+//
+//   private licenseStorage: Record<string, LicenseDataLayer>;
+//
+//   private licenseLayer: Array<LicenseDataLayer>;
+//
+//   constructor(scanResults: ScannerResults, dependencies?: IDependencyResponse ) {
+//     this.scanResults = scanResults;
+//     this.dependencies = dependencies;
+//
+//     //Maps a license name to its own data
+//     this.licenseStorage = {};
+//     this.licenseLayer = [];
+//   }
+//
+//   public getLayerName(): string {
+//     return this.constructor.name;
+//   }
+//
+//   public getData(): IDataLayers {
+//
+//     this.componentList = Object.values(this.scanResults).flat();
+//     this.componentList = this.componentList.filter(component => component.id!=='none')
+//
+//     if (this.componentList.length >0)
+//       this.updateLicenseStorageFromComponentList();
+//
+//     if (this.dependencies && this.dependencies.filesList.length > 0)
+//       this.updateLicenseStorageFromDependencies();
+//
+//
+//     this.licenseLayer = Object.values(this.licenseStorage);
+//     if (this.licenseLayer.length > 0)
+//       this.updateIncompatibilities();
+//
+//     this.licenseLayer.sort((itemA, itemB) => {
+//       if (itemA.value > itemB.value) return -1
+//       else if (itemA.value < itemB.value) return 1
+//       return 0;
+//     });
+//
+//     return {licenses: this.licenseLayer} as IDataLayers
+//   }
+//
+//   //Gets all license from the result of scan and stores in this.licenseStorage map
+//   private updateLicenseStorageFromComponentList() {
+//     this.componentList.forEach(component => {
+//       component.licenses.forEach((license) => {
+//
+//         const newLicenseComponent: LicenseComponent = <LicenseComponent>{};
+//         newLicenseComponent.purl = component.purl[0];
+//         newLicenseComponent.vendor = component.vendor;
+//         newLicenseComponent.versions = [component.version];
+//         newLicenseComponent.name = component.component
+//         newLicenseComponent.url = component.url;
+//
+//         const licenseExist = !!this.licenseStorage[license.name];
+//         if(!licenseExist){
+//           const newLicense: LicenseDataLayer = <LicenseDataLayer>{};
+//           newLicense.value = 1;
+//           newLicense.label = license.name;
+//           newLicense.copyleft = license.copyleft === 'yes' ? true : false;
+//           newLicense.hasIncompatibles = [];
+//           newLicense.incompatibleWith = license.incompatible_with!== undefined ? license.incompatible_with.split(',').map(il=> il.trim()) : [];
+//           newLicense.components = [newLicenseComponent];
+//           this.licenseStorage[license.name] = newLicense;
+//         } else {
+//           this.licenseStorage[license.name] = this.insertComponentIntoLicense(this.licenseStorage[license.name], newLicenseComponent);
+//         }
+//       });
+//     });
+//   }
+//
+//   //Gets all licenses from results of dependency analysis
+//   private updateLicenseStorageFromDependencies() {
+//     this.dependencies.filesList.forEach(file => {
+//       file.dependenciesList.forEach(dependency => {
+//         dependency.licensesList.forEach(license => {
+//
+//
+//           const newLicenseComponent = <LicenseComponent>{};
+//           newLicenseComponent.purl = dependency.purl;
+//           newLicenseComponent.versions = [dependency.version];
+//           newLicenseComponent.name = dependency.component;
+//           newLicenseComponent.vendor = null;
+//           newLicenseComponent.url = null;
+//
+//           if(license.spdxId !== '') {
+//             license.spdxId.split(/;|\//g).forEach(license_name => {
+//
+//               const licenseExist = !!this.licenseStorage[license_name];
+//               if (!licenseExist) {
+//                 const newLicense: LicenseDataLayer = <LicenseDataLayer>{};
+//                 newLicense.value = 1;
+//                 newLicense.label = license_name;
+//                 newLicense.copyleft = false;
+//                 newLicense.hasIncompatibles = [];
+//                 newLicense.incompatibleWith = [];
+//                 newLicense.components = [newLicenseComponent];
+//                 this.licenseStorage[license_name] = newLicense;
+//               } else {
+//                 this.licenseStorage[license_name] = this.insertComponentIntoLicense(this.licenseStorage[license_name], newLicenseComponent);
+//               }
+//             });
+//           } else { // Unknown license
+//             const licenseExist = !!this.licenseStorage['unknown'];
+//             if (!licenseExist) {
+//               const newLicense: LicenseDataLayer = <LicenseDataLayer>{};
+//               newLicense.value = 1;
+//               newLicense.label = 'unknown';
+//               newLicense.copyleft = false;
+//               newLicense.hasIncompatibles = [];
+//               newLicense.incompatibleWith = [];
+//               newLicense.components = [newLicenseComponent];
+//               this.licenseStorage['unknown'] = newLicense;
+//             } else{
+//               this.licenseStorage['unknown'] = this.insertComponentIntoLicense(this.licenseStorage['unknown'], newLicenseComponent);
+//             }
+//           }
+//         });
+//       });
+//     });
+//   }
+//
+//   private updateIncompatibilities() {
+//     for (let l = 0; l < this.licenseLayer.length; l += 1) {
+//       const license = this.licenseLayer[l];
+//       if (license.incompatibleWith !== undefined)
+//         for (let i = 0; i < license.incompatibleWith.length; i += 1) {
+//           if (this.licenseLayer.some((lic) => lic.label === license.incompatibleWith[i]))
+//             license.hasIncompatibles.push(license.incompatibleWith[i]);
+//         }
+//     }
+//   }
+//
+//
+//   private insertComponentIntoLicense(license: LicenseDataLayer, newComponent: LicenseComponent): LicenseDataLayer {
+//     const componentIndex = license.components.findIndex((c)=> c.purl === newComponent.purl);
+//     if (componentIndex >= 0) {  //if newComponent exist in license
+//       const versionExist = !!license.components[componentIndex].versions.find((version)=>version === newComponent.versions[0]);
+//       if (!versionExist) {
+//         license.components[componentIndex].versions.push(newComponent.versions[0]);
+//         license.value++;
+//       }
+//     } else {
+//       license.components.push(newComponent);
+//       license.value++;
+//     }
+//     return license;
+//   }
+//
+//   private unknownLicensesToEnd(){
+//     // let unknownLicenses = null;
+//     // if(this.licenseMapper['unknown']){
+//     //   unknownLicenses =  this.licenseMapper['unknown'];
+//     //   delete this.licenseMapper['unknown'];
+//     // }
+//     //
+//     // this.licenses =  Object.values((this.licenseMapper));
+//     // if(unknownLicenses){
+//     //   this.licenses.push(unknownLicenses);
+//     // }
+//   }
+//
+//
+// }

package/tests/sdk/FileCount/samples/22036/files/c.ts

@@ -0,0 +1,47 @@
+// import { DataProvider, IDataLayers, SummaryDataLayer } from '../DataLayerTypes';
+// import {
+//   ScannerComponent,
+//   ScannerComponentId,
+//   ScannerResults
+// } from '../../scanner/ScannerTypes';
+//
+// export class SummaryDataProvider implements DataProvider {
+//
+//   private scannerResults: ScannerResults;
+//
+//   private summary: SummaryDataLayer;
+//
+//   private projectName: string;
+//
+//   private projectCreateAt: Date;
+//
+//   constructor(projectName: string, projectCreatedAt: Date, scannerResults: ScannerResults) {
+//     this.scannerResults = scannerResults;
+//     this.projectName = projectName;
+//     this.projectCreateAt = projectCreatedAt
+//     this.summary = <SummaryDataLayer>{};
+//   }
+//
+//   public getLayerName(): string {
+//     return this.constructor.name;
+//   }
+//
+//   public getData(): IDataLayers {
+//     this.summary.projectName = this.projectName;
+//     this.summary.timestamp = this.projectCreateAt;
+//     this.summary.totalFiles = 0;
+//     this.summary.noMatchFiles = 0;
+//     this.summary.matchedFiles = 0;
+//
+//     for (const [file, components] of Object.entries(this.scannerResults)) {
+//       components.forEach(component => {
+//         if (component.id==ScannerComponentId.NONE) this.summary.noMatchFiles++;
+//         else this.summary.matchedFiles++;
+//         this.summary.totalFiles++;
+//       });
+//     }
+//
+//     return <IDataLayers>{summary: this.summary};
+//   }
+//
+// }

package/tests/sdk/FileCount/samples/22036/files/d.ts

@@ -0,0 +1,48 @@
+// import {
+//   DataProvider,
+//   IDataLayers,
+//   DependencyDataLayer,
+//   License, Dependency
+// } from '../DataLayerTypes';
+// import { IDependencyResponse } from '../../Dependencies/DependencyTypes';
+//
+// export class DependencyDataProvider implements DataProvider {
+//
+//   private dependencies: IDependencyResponse;
+//
+//   constructor(dependencies: IDependencyResponse) {
+//     this.dependencies = dependencies;
+//   }
+//
+//   public getLayerName(): string {
+//     return this.constructor.name;
+//   }
+//
+//   public getData(): IDataLayers {
+//     const dependencyLayer = <IDataLayers>{dependencies: null};
+//     if(!this.dependencies) return dependencyLayer;
+//     const parsedDepLayer = this.parseDependencyData(this.dependencies);
+//     dependencyLayer.dependencies = parsedDepLayer;
+//     if (!dependencyLayer.dependencies.length) dependencyLayer.dependencies=null;
+//
+//     return dependencyLayer;
+//   }
+//
+//   public parseDependencyData(dependencies: IDependencyResponse): DependencyDataLayer[]{
+//     const dependencyLayer: Array<DependencyDataLayer> = [];
+//
+//     dependencies.filesList.forEach(file => {
+//       const newDependencies: Array<Dependency> = [];
+//       file.dependenciesList.forEach(dependency => {
+//         const newLicenses: Array<License> = [];
+//         dependency.licensesList.forEach((license) => {
+//           newLicenses.push({name: license.name, spdxid: license.spdxId});
+//         });
+//         newDependencies.push({purl: dependency.purl, licenses: newLicenses, version: dependency.version, component: dependency.component});
+//       });
+//       dependencyLayer.push({file: file.file, dependencies: newDependencies});
+//     });
+//
+//     return dependencyLayer;
+//   }
+// }

package/tests/sdk/FileCount/samples/22036/y.ts

@@ -0,0 +1,27 @@
+// import { DataProvider, IDataLayers } from './DataLayerTypes';
+//
+// export class DataProviderManager {
+//   private dataLayersProviders: Array<DataProvider>;
+//
+//   constructor() {
+//     this.dataLayersProviders = [];
+//   }
+//
+//   public addDataProvider(l: DataProvider) {
+//     this.dataLayersProviders.push(l)
+//   }
+//
+//   public generateData(): IDataLayers {
+//
+//     let dataLayer: IDataLayers = {
+//       component: null,
+//       dependencies: null,
+//       vulnerabilities: null,
+//       summary: null,
+//       licenses: null
+//     };
+//
+//     for (const layer of this.dataLayersProviders) Object.assign(dataLayer, layer.getData());
+//     return dataLayer;
+//   }
+// }

package/tests/sdk/FileCount/samples/22036/z.ts

@@ -0,0 +1,129 @@
+// /*************  Component interface definition  *************/
+// export interface ComponentDataLayer {
+//   key: string; // purl[0]
+//   purls: string[];
+//   name: string;
+//   vendor: string;
+//   url: string;
+//   health: Health;
+//   versions: Version[];
+// }
+//
+// export interface Version {
+//   version: string;
+//   licenses:  string[]
+//   copyrights: Copyright[]
+//   cryptography: Cryptography[];
+//   quality: Quality;
+// }
+//
+// export interface Copyright {
+//   name: string;
+//   source: string;
+// };
+//
+// export interface Cryptography {
+//   algorithm: string;
+//   strength: string;
+// };
+//
+// export interface Quality {
+//   scoreAvg: number;
+//   count: number;
+//   sum: number; //TODO remove
+// };
+//
+// export interface Health {
+//   creation_date: string;
+//   issues: number;
+//   last_push: string;
+//   last_update: string;
+//   watchers: number;
+//   country: string;
+//   stars: number;
+//   forks: number;
+// }
+// /*************  Component interface definition  *************/
+//
+//
+// /*************  Dependency interface definition  *************/
+// export interface DependencyDataLayer {
+//   file: string;
+//   dependencies: Dependency[];
+// }
+//
+// export interface License {
+//   name: string;
+//   spdxid: string;
+// }
+//
+// export interface Dependency {
+//   purl: string;
+//   component: string;
+//   version: string;
+//   licenses: License[]
+// }
+// /*************  Dependency interface definition  *************/
+//
+// /*************  Vulnerability interface definition  *************/
+// export interface Vulnerability {
+//   id: string;
+//   cve: string;
+//   url: string;
+//   summary: string;
+//   severity: string;
+//   published: string;
+//   modified: string;
+//   source: string;
+// }
+//
+// export interface VulnerabilityDataLayer {
+//   purl: string;
+//   vulnerability: Vulnerability[];
+// }
+// /*************  Vulnerability interface definition  *************/
+//
+//
+// /*************  License interface definition  *************/
+// export interface LicenseDataLayer {
+//   label: string;
+//   value: number;  //Number of licenses found
+//   components: Array<LicenseComponent>;
+//   incompatibleWith: Array<string>;
+//   hasIncompatibles: Array<string>;
+//   copyleft:boolean;
+// }
+//
+//
+// export interface LicenseComponent {
+//   purl: string;
+//   name: string;
+//   versions: Array<string>;
+//   url:string;
+//   vendor:string;
+// }
+// /*************  License interface definition  *************/
+//
+// export interface SummaryDataLayer {
+//   projectName: string;
+//   timestamp: Date;
+//   matchedFiles: number;
+//   noMatchFiles: number;
+//   totalFiles: number;
+// }
+//
+// // Each layer is created to group by differents criteria.
+// export interface IDataLayers {
+//   licenses: LicenseDataLayer[];
+//   component: ComponentDataLayer[];
+//   dependencies: DependencyDataLayer[];
+//   vulnerabilities: VulnerabilityDataLayer[];
+//   summary: SummaryDataLayer;
+// }
+//
+//
+// export interface DataProvider {
+//   getData(): IDataLayers;
+//   getLayerName(): string;
+// }
+//