refactor to allow switching ICategoryCollection context #40

src/domain/Application.ts

@@ -0,0 +1,47 @@
+import { IApplication } from './IApplication';
+import { ICategoryCollection } from './ICategoryCollection';
+import { IProjectInformation } from './IProjectInformation';
+import { OperatingSystem } from './OperatingSystem';
+
+export class Application implements IApplication {
+    constructor(public info: IProjectInformation, public collections: readonly ICategoryCollection[]) {
+        validateInformation(info);
+        validateCollections(collections);
+    }
+
+    public getSupportedOsList(): OperatingSystem[] {
+        return this.collections.map((collection) => collection.os);
+    }
+
+    public getCollection(operatingSystem: OperatingSystem): ICategoryCollection | undefined {
+        return this.collections.find((collection) => collection.os === operatingSystem);
+    }
+}
+
+function validateInformation(info: IProjectInformation) {
+    if (!info) {
+        throw new Error('undefined project information');
+    }
+}
+
+function validateCollections(collections: readonly ICategoryCollection[]) {
+    if (!collections) {
+        throw new Error('undefined collections');
+    }
+    if (collections.length === 0) {
+        throw new Error('no collection in the list');
+    }
+    if (collections.filter((c) => !c).length > 0) {
+        throw new Error('undefined collection in the list');
+    }
+    const osList = collections.map((c) => c.os);
+    const duplicates = getDuplicates(osList);
+    if (duplicates.length > 0) {
+        throw new Error('multiple collections with same os: ' +
+            duplicates.map((os) => OperatingSystem[os].toLowerCase()).join('", "'));
+    }
+}
+
+function getDuplicates(list: readonly OperatingSystem[]): OperatingSystem[] {
+    return list.filter((os, index) => list.indexOf(os) !== index);
+}

src/domain/CategoryCollection.ts

@@ -2,7 +2,6 @@ import { getEnumNames, getEnumValues } from '@/application/Common/Enum';
 import { IEntity } from '../infrastructure/Entity/IEntity';
 import { ICategory } from './ICategory';
 import { IScript } from './IScript';
-import { IProjectInformation } from './IProjectInformation';
 import { RecommendationLevel } from './RecommendationLevel';
 import { OperatingSystem } from './OperatingSystem';
 import { IScriptingDefinition } from './IScriptingDefinition';
@@ -16,12 +15,8 @@ export class CategoryCollection implements ICategoryCollection {
 
     constructor(
         public readonly os: OperatingSystem,
-        public readonly info: IProjectInformation,
         public readonly actions: ReadonlyArray<ICategory>,
         public readonly scripting: IScriptingDefinition) {
-        if (!info) {
-            throw new Error('undefined info');
-        }
         if (!scripting) {
             throw new Error('undefined scripting definition');
         }

src/domain/IApplication.ts

@@ -0,0 +1,11 @@
+import { ICategoryCollection } from './ICategoryCollection';
+import { IProjectInformation } from './IProjectInformation';
+import { OperatingSystem } from './OperatingSystem';
+
+export interface IApplication {
+    readonly info: IProjectInformation;
+    readonly collections: readonly ICategoryCollection[];
+
+    getSupportedOsList(): OperatingSystem[];
+    getCollection(operatingSystem: OperatingSystem): ICategoryCollection | undefined;
+}

src/domain/ICategoryCollection.ts

@@ -3,10 +3,8 @@ import { OperatingSystem } from '@/domain/OperatingSystem';
 import { RecommendationLevel } from '@/domain/RecommendationLevel';
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
-import { IProjectInformation } from '@/domain/IProjectInformation';
 
 export interface ICategoryCollection {
-    readonly info: IProjectInformation;
     readonly scripting: IScriptingDefinition;
     readonly os: OperatingSystem;
     readonly totalScripts: number;