rename Application to CategoryCollection #40

src/application/Context/ApplicationContext.ts

@@ -1,20 +1,20 @@
 import { IApplicationContext } from './IApplicationContext';
-import { IApplication } from '@/domain/IApplication';
-import { IApplicationState } from './State/IApplicationState';
-import { ApplicationState } from './State/ApplicationState';
+import { ICategoryCollectionState } from './State/ICategoryCollectionState';
+import { CategoryCollectionState } from './State/CategoryCollectionState';
 import applicationFile from 'js-yaml-loader!@/application/application.yaml';
-import { parseApplication } from '../Parser/ApplicationParser';
+import { parseCategoryCollection } from '../Parser/CategoryCollectionParser';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
 
 
 export function createContext(): IApplicationContext {
-    const application = parseApplication(applicationFile);
+    const application = parseCategoryCollection(applicationFile);
     const context = new ApplicationContext(application);
     return context;
 }
 
 export class ApplicationContext implements IApplicationContext {
-    public readonly state: IApplicationState;
-    public constructor(public readonly app: IApplication) {
-        this.state = new ApplicationState(app);
+    public readonly state: ICategoryCollectionState;
+    public constructor(public readonly collection: ICategoryCollection) {
+        this.state = new CategoryCollectionState(collection);
     }
 }

src/application/Context/ApplicationContextProvider.ts

@@ -1,9 +1,9 @@
 import { ApplicationContext } from './ApplicationContext';
 import { IApplicationContext } from '@/application/Context/IApplicationContext';
 import applicationFile from 'js-yaml-loader!@/application/application.yaml';
-import { parseApplication } from '@/application/Parser/ApplicationParser';
+import { parseCategoryCollection } from '@/application/Parser/CategoryCollectionParser';
 
 export function buildContext(): IApplicationContext {
-    const application = parseApplication(applicationFile);
+    const application = parseCategoryCollection(applicationFile);
     return new ApplicationContext(application);
 }

src/application/Context/IApplicationContext.ts

@@ -1,7 +1,7 @@
-import { IApplication } from '@/domain/IApplication';
-import { IApplicationState } from './State/IApplicationState';
+import { ICategoryCollectionState } from './State/ICategoryCollectionState';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
 
 export interface IApplicationContext {
-    readonly app: IApplication;
-    readonly state: IApplicationState;
+    readonly collection: ICategoryCollection;
+    readonly state: ICategoryCollectionState;
 }

src/application/Context/State/CategoryCollectionState.ts

@@ -3,18 +3,18 @@ import { IUserFilter } from './Filter/IUserFilter';
 import { ApplicationCode } from './Code/ApplicationCode';
 import { UserSelection } from './Selection/UserSelection';
 import { IUserSelection } from './Selection/IUserSelection';
-import { IApplicationState } from './IApplicationState';
-import { IApplication } from '@/domain/IApplication';
+import { ICategoryCollectionState } from './ICategoryCollectionState';
 import { IApplicationCode } from './Code/IApplicationCode';
+import { ICategoryCollection } from '../../../domain/ICategoryCollection';
 
-export class ApplicationState implements IApplicationState {
+export class CategoryCollectionState implements ICategoryCollectionState {
     public readonly code: IApplicationCode;
     public readonly selection: IUserSelection;
     public readonly filter: IUserFilter;
 
-    public constructor(readonly app: IApplication) {
-        this.selection = new UserSelection(app, []);
-        this.code = new ApplicationCode(this.selection, app.scripting);
-        this.filter = new UserFilter(app);
+    public constructor(readonly collection: ICategoryCollection) {
+        this.selection = new UserSelection(collection, []);
+        this.code = new ApplicationCode(this.selection, collection.scripting);
+        this.filter = new UserFilter(collection);
     }
 }

src/application/Context/State/Filter/UserFilter.ts

@@ -1,16 +1,16 @@
 import { IScript } from '@/domain/IScript';
 import { FilterResult } from './FilterResult';
 import { IFilterResult } from './IFilterResult';
-import { IApplication } from '@/domain/IApplication';
 import { IUserFilter } from './IUserFilter';
 import { Signal } from '@/infrastructure/Events/Signal';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
 
 export class UserFilter implements IUserFilter {
     public readonly filtered = new Signal<IFilterResult>();
     public readonly filterRemoved = new Signal<void>();
     public currentFilter: IFilterResult | undefined;
 
-    constructor(private application: IApplication) {
+    constructor(private collection: ICategoryCollection) {
 
     }
 
@@ -19,9 +19,9 @@ export class UserFilter implements IUserFilter {
             throw new Error('Filter must be defined and not empty. Use removeFilter() to remove the filter');
         }
         const filterLowercase = filter.toLocaleLowerCase();
-        const filteredScripts = this.application.getAllScripts().filter(
+        const filteredScripts = this.collection.getAllScripts().filter(
             (script) => isScriptAMatch(script, filterLowercase));
-        const filteredCategories = this.application.getAllCategories().filter(
+        const filteredCategories = this.collection.getAllCategories().filter(
             (category) => category.name.toLowerCase().includes(filterLowercase));
         const matches = new FilterResult(
             filteredScripts,

src/application/Context/State/ICategoryCollectionState.ts

@@ -3,7 +3,7 @@ import { IUserSelection } from './Selection/IUserSelection';
 import { IApplicationCode } from './Code/IApplicationCode';
 export { IUserSelection, IApplicationCode, IUserFilter };
 
-export interface IApplicationState {
+export interface ICategoryCollectionState {
     readonly code: IApplicationCode;
     readonly filter: IUserFilter;
     readonly selection: IUserSelection;

src/application/Context/State/Selection/UserSelection.ts

@@ -1,17 +1,18 @@
 import { SelectedScript } from './SelectedScript';
-import { IApplication, ICategory } from '@/domain/IApplication';
 import { IUserSelection } from './IUserSelection';
 import { InMemoryRepository } from '@/infrastructure/Repository/InMemoryRepository';
 import { IScript } from '@/domain/IScript';
 import { Signal } from '@/infrastructure/Events/Signal';
 import { IRepository } from '@/infrastructure/Repository/IRepository';
+import { ICategory } from '@/domain/ICategory';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
 
 export class UserSelection implements IUserSelection {
     public readonly changed = new Signal<ReadonlyArray<SelectedScript>>();
     private readonly scripts: IRepository<string, SelectedScript>;
 
     constructor(
-        private readonly app: IApplication,
+        private readonly collection: ICategoryCollection,
         selectedScripts: ReadonlyArray<SelectedScript>) {
         this.scripts =  new InMemoryRepository<string, SelectedScript>();
         if (selectedScripts && selectedScripts.length > 0) {
@@ -40,7 +41,7 @@ export class UserSelection implements IUserSelection {
     }
 
     public removeAllInCategory(categoryId: number): void {
-        const category = this.app.findCategory(categoryId);
+        const category = this.collection.findCategory(categoryId);
         const scriptsToRemove = category.getAllScriptsRecursively()
             .filter((script) => this.scripts.exists(script.id));
         if (!scriptsToRemove.length) {
@@ -53,7 +54,7 @@ export class UserSelection implements IUserSelection {
     }
 
     public addOrUpdateAllInCategory(categoryId: number, revert: boolean = false): void {
-        const category = this.app.findCategory(categoryId);
+        const category = this.collection.findCategory(categoryId);
         const scriptsToAddOrUpdate = category.getAllScriptsRecursively()
             .filter((script) =>
                 !this.scripts.exists(script.id)
@@ -70,7 +71,7 @@ export class UserSelection implements IUserSelection {
     }
 
     public addSelectedScript(scriptId: string, revert: boolean): void {
-        const script = this.app.findScript(scriptId);
+        const script = this.collection.findScript(scriptId);
         if (!script) {
             throw new Error(`Cannot add (id: ${scriptId}) as it is unknown`);
         }
@@ -80,7 +81,7 @@ export class UserSelection implements IUserSelection {
     }
 
     public addOrUpdateSelectedScript(scriptId: string, revert: boolean): void {
-        const script = this.app.findScript(scriptId);
+        const script = this.collection.findScript(scriptId);
         const selectedScript = new SelectedScript(script, revert);
         this.scripts.addOrUpdateItem(selectedScript);
         this.changed.notify(this.scripts.getItems());
@@ -105,7 +106,7 @@ export class UserSelection implements IUserSelection {
     }
 
     public selectAll(): void {
-        for (const script of this.app.getAllScripts()) {
+        for (const script of this.collection.getAllScripts()) {
             if (!this.scripts.exists(script.id)) {
                 const selection = new SelectedScript(script, false);
                 this.scripts.addItem(selection);

src/application/Parser/CategoryCollectionParser.ts

@@ -1,6 +1,4 @@
 import { Category } from '@/domain/Category';
-import { Application } from '@/domain/Application';
-import { IApplication } from '@/domain/IApplication';
 import { YamlApplication } from 'js-yaml-loader!@/application.yaml';
 import { parseCategory } from './CategoryParser';
 import { parseProjectInformation } from './ProjectInformationParser';
@@ -8,11 +6,13 @@ 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';
 
-export function parseApplication(
+export function parseCategoryCollection(
     content: YamlApplication,
     env: NodeJS.ProcessEnv = process.env,
-    osParser = createEnumParser(OperatingSystem)): IApplication {
+    osParser = createEnumParser(OperatingSystem)): ICategoryCollection {
     validate(content);
     const compiler = new ScriptCompiler(content.functions);
     const categories = new Array<Category>();
@@ -23,19 +23,19 @@ export function parseApplication(
     const os = osParser.parseEnum(content.os, 'os');
     const info = parseProjectInformation(env);
     const scripting = parseScriptingDefinition(content.scripting, info);
-    const app = new Application(
+    const collection = new CategoryCollection(
         os,
         info,
         categories,
         scripting);
-    return app;
+    return collection;
 }
 
 function validate(content: YamlApplication): void {
     if (!content) {
-        throw new Error('application is null or undefined');
+        throw new Error('content is null or undefined');
     }
     if (!content.actions || content.actions.length <= 0) {
-        throw new Error('application does not define any action');
+        throw new Error('content does not define any action');
     }
 }