refactor to allow switching ICategoryCollection context #40

src/application/Context/ApplicationContext.ts

@@ -1,20 +1,72 @@
-import { IApplicationContext } from './IApplicationContext';
+import { IApplicationContext, IApplicationContextChangedEvent } from './IApplicationContext';
 import { ICategoryCollectionState } from './State/ICategoryCollectionState';
 import { CategoryCollectionState } from './State/CategoryCollectionState';
-import applicationFile from 'js-yaml-loader!@/application/application.yaml';
-import { parseCategoryCollection } from '../Parser/CategoryCollectionParser';
+import { IApplication } from '@/domain/IApplication';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { Signal } from '@/infrastructure/Events/Signal';
 
-
-export function createContext(): IApplicationContext {
-    const application = parseCategoryCollection(applicationFile);
-    const context = new ApplicationContext(application);
-    return context;
-}
+type StateMachine = Map<OperatingSystem, ICategoryCollectionState>;
 
 export class ApplicationContext implements IApplicationContext {
-    public readonly state: ICategoryCollectionState;
-    public constructor(public readonly collection: ICategoryCollection) {
-        this.state = new CategoryCollectionState(collection);
+    public readonly contextChanged = new Signal<IApplicationContextChangedEvent>();
+    public collection: ICategoryCollection;
+    public currentOs: OperatingSystem;
+
+    public get state(): ICategoryCollectionState {
+        return this.states[this.collection.os];
+    }
+
+    private readonly states: StateMachine;
+    public constructor(
+        public readonly app: IApplication,
+        initialContext: OperatingSystem) {
+        validateApp(app);
+        validateOs(initialContext);
+        this.states = initializeStates(app);
+        this.changeContext(initialContext);
+    }
+
+    public changeContext(os: OperatingSystem): void {
+        if (this.currentOs === os) {
+            return;
+        }
+        this.collection = this.app.getCollection(os);
+        if (!this.collection) {
+            throw new Error(`os "${OperatingSystem[os]}" is not defined in application`);
+        }
+        const event: IApplicationContextChangedEvent = {
+            newState: this.state,
+            newCollection: this.collection,
+            newOs: os,
+        };
+        this.contextChanged.notify(event);
+        this.currentOs = os;
     }
 }
+
+function validateApp(app: IApplication) {
+    if (!app) {
+        throw new Error('undefined app');
+    }
+}
+
+function validateOs(os: OperatingSystem) {
+    if (os === undefined) {
+        throw new Error('undefined os');
+    }
+    if (os === OperatingSystem.Unknown) {
+        throw new Error('unknown os');
+    }
+    if (!(os in OperatingSystem)) {
+        throw new Error(`os "${os}" is out of range`);
+    }
+}
+
+function initializeStates(app: IApplication): StateMachine {
+    const machine = new Map<OperatingSystem, ICategoryCollectionState>();
+    for (const collection of app.collections) {
+        machine[collection.os] = new CategoryCollectionState(collection);
+    }
+    return machine;
+}

src/application/Context/ApplicationContextProvider.ts

@@ -1,9 +1,32 @@
 import { ApplicationContext } from './ApplicationContext';
 import { IApplicationContext } from '@/application/Context/IApplicationContext';
-import applicationFile from 'js-yaml-loader!@/application/application.yaml';
-import { parseCategoryCollection } from '@/application/Parser/CategoryCollectionParser';
+import { OperatingSystem } from '@/domain/OperatingSystem';
+import { Environment } from '../Environment/Environment';
+import { IApplication } from '@/domain/IApplication';
+import { IEnvironment } from '../Environment/IEnvironment';
+import { parseApplication } from '../Parser/ApplicationParser';
 
-export function buildContext(): IApplicationContext {
-    const application = parseCategoryCollection(applicationFile);
-    return new ApplicationContext(application);
+export type ApplicationParserType = () => IApplication;
+const ApplicationParser: ApplicationParserType = parseApplication;
+
+export function buildContext(
+    parser = ApplicationParser,
+    environment = Environment.CurrentEnvironment): IApplicationContext {
+    const app = parser();
+    const os = getInitialOs(app, environment);
+    return new ApplicationContext(app, os);
+}
+
+function getInitialOs(app: IApplication, environment: IEnvironment): OperatingSystem {
+    const currentOs = environment.os;
+    const supportedOsList = app.getSupportedOsList();
+    if (supportedOsList.includes(currentOs)) {
+        return currentOs;
+    }
+    supportedOsList.sort((os1, os2) => {
+        const os1SupportLevel = app.collections[os1].totalScripts;
+        const os2SupportLevel = app.collections[os2].totalScripts;
+        return os1SupportLevel - os2SupportLevel;
+    });
+    return supportedOsList[0];
 }

src/application/Context/IApplicationContext.ts

@@ -1,7 +1,20 @@
 import { ICategoryCollectionState } from './State/ICategoryCollectionState';
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { OperatingSystem } from '@/domain/OperatingSystem';
+import { ISignal } from '@/infrastructure/Events/ISignal';
+import { IApplication } from '@/domain/IApplication';
 
 export interface IApplicationContext {
+    readonly currentOs: OperatingSystem;
+    readonly app: IApplication;
     readonly collection: ICategoryCollection;
     readonly state: ICategoryCollectionState;
+    readonly contextChanged: ISignal<IApplicationContextChangedEvent>;
+    changeContext(os: OperatingSystem): void;
+}
+
+export interface IApplicationContextChangedEvent {
+    readonly newState: ICategoryCollectionState;
+    readonly newCollection: ICategoryCollection;
+    readonly newOs: OperatingSystem;
 }

src/application/Environment/IEnvironment.ts

@@ -1,6 +1,6 @@
 import { OperatingSystem } from '@/domain/OperatingSystem';
 
 export interface IEnvironment {
-    isDesktop: boolean;
-    os: OperatingSystem;
+    readonly isDesktop: boolean;
+    readonly os: OperatingSystem;
 }

src/application/Parser/ApplicationParser.ts

@@ -0,0 +1,27 @@
+import { IApplication } from '@/domain/IApplication';
+import { IProjectInformation } from '@/domain/IProjectInformation';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { parseCategoryCollection } from './CategoryCollectionParser';
+import applicationFile, { YamlApplication } from 'js-yaml-loader!@/application/application.yaml';
+import { parseProjectInformation } from '@/application/Parser/ProjectInformationParser';
+import { Application } from '@/domain/Application';
+
+export function parseApplication(
+    parser = CategoryCollectionParser,
+    processEnv: NodeJS.ProcessEnv = process.env,
+    collectionData = CollectionData): IApplication {
+    const information = parseProjectInformation(processEnv);
+    const collection = parser(collectionData, information);
+    const app = new Application(information, [ collection ]);
+    return app;
+}
+
+export type CategoryCollectionParserType
+    = (file: YamlApplication, info: IProjectInformation) => ICategoryCollection;
+
+const CategoryCollectionParser: CategoryCollectionParserType
+    = (file, info) => parseCategoryCollection(file, info);
+
+const CollectionData: YamlApplication
+    = applicationFile;
+

src/application/Parser/CategoryCollectionParser.ts

@@ -1,17 +1,17 @@
 import { Category } from '@/domain/Category';
 import { YamlApplication } from 'js-yaml-loader!@/application.yaml';
 import { parseCategory } from './CategoryParser';
-import { parseProjectInformation } from './ProjectInformationParser';
 import { ScriptCompiler } from './Compiler/ScriptCompiler';
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import { parseScriptingDefinition } from './ScriptingDefinitionParser';
 import { createEnumParser } from '../Common/Enum';
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { CategoryCollection } from '@/domain/CategoryCollection';
+import { IProjectInformation } from '@/domain/IProjectInformation';
 
 export function parseCategoryCollection(
     content: YamlApplication,
-    env: NodeJS.ProcessEnv = process.env,
+    info: IProjectInformation,
     osParser = createEnumParser(OperatingSystem)): ICategoryCollection {
     validate(content);
     const compiler = new ScriptCompiler(content.functions);
@@ -21,11 +21,9 @@ export function parseCategoryCollection(
         categories.push(category);
     }
     const os = osParser.parseEnum(content.os, 'os');
-    const info = parseProjectInformation(env);
     const scripting = parseScriptingDefinition(content.scripting, info);
     const collection = new CategoryCollection(
         os,
-        info,
         categories,
         scripting);
     return collection;