added ability to revert (#21)

CONTRIBUTING.md

@@ -0,0 +1,46 @@
+# Contributing
+
+- Love your input! Contributing to this project should be as easy and transparent as possible, whether it's:
+  - Reporting a bug
+  - Discussing the current state of the code
+  - Submitting a fix
+  - Proposing new features
+  - Becoming a maintainer
+
+## Pull Request Process
+
+- [GitHub flow](https://guides.github.com/introduction/flow/index.html) is used
+- Your pull requests are actively welcomed.
+- The steps:
+  1. Fork the repo and create your branch from master.
+  2. If you've added code that should be tested, add tests.
+  3. If you've changed APIs, update the documentation.
+  4. Ensure the test suite passes.
+  5. Make sure your code lints.
+  6. Issue that pull request!
+- 🙏 DO
+  - Document your changes in the pull request
+  - 💡 Check [developer notes](./docs/developer-notes.md) if you need help
+- ❗ DON'T
+  - Do not update the versions, current version is only [set by the maintainer](./docs/gitops.png) and updated automatically by [bump-everywhere](https://github.com/undergroundwires/bump-everywhere)
+
+## Guidelines
+
+### Extend scripts
+
+- Create a [pull request](./../CONTRIBUTING.md#Pull+Request+Process) for [application.yaml](./../src/application/application.yaml)
+- 🙏 For any new script, try to add `revertCode` that'll revert the changes caused by the script.
+- See [typings](./../src/application/application.yaml.d.ts) for documentation as code.
+
+### Handle the state in presentation layer
+
+- There are two types of components:
+  - **Stateless**, extends `Vue`
+  - **Stateful**, extends [`StatefulVue`](./src/presentation/StatefulVue.ts)
+    - The source of truth for the state lies in [application layer](./src/application/state) and must be updated from the views if they're mutating the state
+    - They mutate or/and reacts to changes in [application state](./src/application/state).
+    - You can react by getting the state and listening to it and update the view accordingly in [`mounted()`](https://vuejs.org/v2/api/#mounted) method.
+
+## License
+
+By contributing, you agree that your contributions will be licensed under its GNU General Public License v3.0.

README.md

@@ -2,7 +2,7 @@
 
 > Web tool to enforce privacy & security best-practices on Windows, because privacy is sexy 🍑🍆
 
-[![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/undergroundwires/privacy.sexy/issues)
+[![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](./CONTRIBUTING.md)
 [![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/undergroundwires/privacy.sexy.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/undergroundwires/privacy.sexy/context:javascript)
 [![Maintainability](https://api.codeclimate.com/v1/badges/3a70b7ef602e2264342c/maintainability)](https://codeclimate.com/github/undergroundwires/privacy.sexy/maintainability)
 [![Tests status](https://github.com/undergroundwires/privacy.sexy/workflows/Test/badge.svg)](https://github.com/undergroundwires/privacy.sexy/actions)
@@ -16,15 +16,17 @@
 
 ## Why
 
-- You don't need to run any compiled software on your system, just run the generated scripts.
+- You don't need to run any compiled software that has access to your system, just run the generated scripts.
 - It's open source, both application & infrastructure is 100% transparent
   - Fully automated C/CD pipeline to AWS for provisioning serverless infrastructure using GitHub actions.
 - Have full visibility into what the tweaks do as you enable them.
+- Ability to revert applied scripts
 - Easily extendable
 
 ## Extend scripts
 
-Fork it & add more scripts in [application.yaml](src/application/application.yaml) and send a pull request 👌
+- Fork it & add more scripts in [application.yaml](src/application/application.yaml) and send a pull request 👌
+- 📖 More: [extend scripts | CONTRIBUTING.md](./CONTRIBUTING.md#extend-scripts)
 
 ## Commands
 

src/App.vue

@@ -13,7 +13,7 @@
 
 <script lang="ts">
 import { Component, Vue, Prop  } from 'vue-property-decorator';
-import { ApplicationState, IApplicationState } from '@/application/State/ApplicationState';
+import { ApplicationState } from '@/application/State/ApplicationState';
 import TheHeader from '@/presentation/TheHeader.vue';
 import TheFooter from '@/presentation/TheFooter.vue';
 import TheCodeArea from '@/presentation/TheCodeArea.vue';

src/application/Parser/ApplicationParser.ts

@@ -1,13 +1,12 @@
-import { Category } from '../../domain/Category';
+import { Category } from '@/domain/Category';
-import { Application } from '../../domain/Application';
+import { Application } from '@/domain/Application';
+import { IApplication } from '@/domain/IApplication';
 import { ApplicationYaml } from 'js-yaml-loader!./../application.yaml';
 import { parseCategory } from './CategoryParser';
 
-export function parseApplication(content: ApplicationYaml): Application {
+export function parseApplication(content: ApplicationYaml): IApplication {
+    validate(content);
     const categories = new Array<Category>();
-    if (!content.actions || content.actions.length <= 0) {
-        throw new Error('Application does not define any action');
-    }
     for (const action of content.actions) {
         const category = parseCategory(action);
         categories.push(category);
@@ -19,3 +18,12 @@ export function parseApplication(content: ApplicationYaml): Application {
         categories);
     return app;
 }
+
+function validate(content: ApplicationYaml): void {
+    if (!content) {
+        throw new Error('application is null or undefined');
+    }
+    if (!content.actions || content.actions.length <= 0) {
+        throw new Error('application does not define any action');
+    }
+}

src/application/Parser/CategoryParser.ts

@@ -1,20 +1,18 @@
 import { YamlCategory, YamlScript } from 'js-yaml-loader!./application.yaml';
 import { Script } from '@/domain/Script';
-import { Category } from '../../domain/Category';
+import { Category } from '@/domain/Category';
 import { parseDocUrls } from './DocumentationParser';
+import { parseScript } from './ScriptParser';
 
 let categoryIdCounter: number = 0;
 
-
 interface ICategoryChildren {
     subCategories: Category[];
     subScripts: Script[];
 }
 
 export function parseCategory(category: YamlCategory): Category {
-    if (!category.children || category.children.length <= 0) {
+    ensureValid(category);
-        throw Error('Category has no children');
-    }
     const children: ICategoryChildren = {
         subCategories: new Array<Category>(),
         subScripts: new Array<Script>(),
@@ -31,6 +29,18 @@ export function parseCategory(category: YamlCategory): Category {
     );
 }
 
+function ensureValid(category: YamlCategory) {
+    if (!category) {
+        throw Error('category is null or undefined');
+    }
+    if (!category.children || category.children.length === 0) {
+        throw Error('category has no children');
+    }
+    if (!category.category || category.category.length === 0) {
+        throw Error('category has no name');
+    }
+}
+
 function parseCategoryChild(
     categoryOrScript: any, children: ICategoryChildren, parent: YamlCategory) {
     if (isCategory(categoryOrScript)) {
@@ -38,11 +48,7 @@ function parseCategoryChild(
         children.subCategories.push(subCategory);
     } else if (isScript(categoryOrScript)) {
         const yamlScript = categoryOrScript as YamlScript;
-        const script = new Script(
+        const script = parseScript(yamlScript);
-            /* name */  yamlScript.name,
-            /* code */ yamlScript.code,
-            /* docs */ parseDocUrls(yamlScript),
-            /* is recommended? */ yamlScript.recommend);
         children.subScripts.push(script);
     } else {
         throw new Error(`Child element is neither a category or a script.
@@ -50,7 +56,6 @@ function parseCategoryChild(
     }
 }
 
-
 function isScript(categoryOrScript: any): boolean {
     return categoryOrScript.code && categoryOrScript.code.length > 0;
 }

src/application/Parser/DocumentationParser.ts

@@ -1,6 +1,9 @@
 import { YamlDocumentable } from 'js-yaml-loader!./application.yaml';
 
 export function parseDocUrls(documentable: YamlDocumentable): ReadonlyArray<string> {
+    if (!documentable) {
+        throw new Error('documentable is null or undefined');
+    }
     const docs = documentable.docs;
     if (!docs) {
         return [];

src/application/Parser/ScriptParser.ts

@@ -0,0 +1,16 @@
+import { Script } from '@/domain/Script';
+import { YamlScript } from 'js-yaml-loader!./application.yaml';
+import { parseDocUrls } from './DocumentationParser';
+
+export function parseScript(yamlScript: YamlScript): Script {
+    if (!yamlScript) {
+        throw new Error('script is null or undefined');
+    }
+    const script = new Script(
+        /* name */              yamlScript.name,
+        /* code */              yamlScript.code,
+        /* revertCode */        yamlScript.revertCode,
+        /* docs */              parseDocUrls(yamlScript),
+        /* isRecommended */     yamlScript.recommend);
+    return script;
+}

src/application/State/ApplicationState.ts

@@ -8,7 +8,7 @@ import { Signal } from '@/infrastructure/Events/Signal';
 import { parseApplication } from '../Parser/ApplicationParser';
 import { IApplicationState } from './IApplicationState';
 import { Script } from '@/domain/Script';
-import { Application } from '@/domain/Application';
+import { IApplication } from '@/domain/IApplication';
 import { IApplicationCode } from './Code/IApplicationCode';
 import applicationFile from 'js-yaml-loader!@/application/application.yaml';
 
@@ -34,7 +34,7 @@ export class ApplicationState implements IApplicationState {
 
     private constructor(
         /** Inner instance of the all scripts */
-        public readonly app: Application,
+        public readonly app: IApplication,
         /** Initially selected scripts */
         public readonly defaultScripts: Script[]) {
         this.selection = new UserSelection(app, defaultScripts);
@@ -42,5 +42,3 @@ export class ApplicationState implements IApplicationState {
         this.filter = new UserFilter(app);
     }
 }
-
-export { IApplicationState, IUserFilter };

src/application/State/Code/ApplicationCode.ts

@@ -1,16 +1,19 @@
+import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+import { IUserSelection } from '@/application/State/Selection/IUserSelection';
 import { UserScriptGenerator } from './UserScriptGenerator';
-import { IUserSelection } from './../Selection/IUserSelection';
 import { Signal } from '@/infrastructure/Events/Signal';
 import { IApplicationCode } from './IApplicationCode';
-import { IScript } from '@/domain/IScript';
+import { IUserScriptGenerator } from './IUserScriptGenerator';
 
 export class ApplicationCode implements IApplicationCode {
     public readonly changed = new Signal<string>();
     public current: string;
 
-    private readonly generator: UserScriptGenerator;
+    private readonly generator: IUserScriptGenerator = new UserScriptGenerator();
 
-    constructor(userSelection: IUserSelection, private readonly version: string) {
+    constructor(
+        userSelection: IUserSelection,
+        private readonly version: string) {
         if (!userSelection) { throw new Error('userSelection is null or undefined'); }
         if (!version) { throw new Error('version is null or undefined'); }
         this.generator = new UserScriptGenerator();
@@ -20,7 +23,7 @@ export class ApplicationCode implements IApplicationCode {
         });
     }
 
-    private setCode(scripts: ReadonlyArray<IScript>) {
+    private setCode(scripts: ReadonlyArray<SelectedScript>) {
         this.current = scripts.length === 0 ? '' : this.generator.buildCode(scripts, this.version);
         this.changed.notify(this.current);
     }

src/application/State/Code/IUserScriptGenerator.ts

@@ -0,0 +1,5 @@
+import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+
+export interface IUserScriptGenerator {
+    buildCode(selectedScripts: ReadonlyArray<SelectedScript>, version: string): string;
+}

src/application/State/Code/UserScriptGenerator.ts

@@ -1,7 +1,8 @@
+import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+import { IUserScriptGenerator } from './IUserScriptGenerator';
 import { CodeBuilder } from './CodeBuilder';
-import { Script } from '@/domain/Script';
 
-const adminRightsScript = {
+export const adminRightsScript = {
     name: 'Ensure admin privileges',
     code: 'fltmc >nul 2>&1 || (\n' +
     '   echo This batch script requires administrator privileges. Right-click on\n' +
@@ -11,17 +12,19 @@ const adminRightsScript = {
     ')',
 };
 
-export class UserScriptGenerator {
+export class UserScriptGenerator implements IUserScriptGenerator {
-    public buildCode(scripts: ReadonlyArray<Script>, version: string): string {
+    public buildCode(selectedScripts: ReadonlyArray<SelectedScript>, version: string): string {
-        if (!scripts) { throw new Error('scripts is undefined'); }
+        if (!selectedScripts) { throw new Error('scripts is undefined'); }
-        if (!scripts.length) { throw new Error('scripts are empty'); }
+        if (!selectedScripts.length) { throw new Error('scripts are empty'); }
         if (!version) { throw new Error('version is undefined'); }
         const builder = new CodeBuilder()
             .appendLine('@echo off')
             .appendCommentLine(`https://privacy.sexy — v${version} — ${new Date().toUTCString()}`)
             .appendFunction(adminRightsScript.name, adminRightsScript.code).appendLine();
-        for (const script of scripts) {
+        for (const selection of selectedScripts) {
-            builder.appendFunction(script.name, script.code).appendLine();
+            const name = selection.revert ? `${selection.script.name} (revert)` : selection.script.name;
+            const code = selection.revert ? selection.script.revertCode : selection.script.code;
+            builder.appendFunction(name, code).appendLine();
         }
         return builder.appendLine()
             .appendLine('pause')

src/application/State/Filter/FilterResult.ts

@@ -1,5 +1,5 @@
 import { IFilterResult } from './IFilterResult';
-import { IScript } from '@/domain/Script';
+import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
 
 export class FilterResult implements IFilterResult {

src/application/State/Filter/UserFilter.ts

@@ -1,6 +1,7 @@
+import { IScript } from '@/domain/IScript';
 import { FilterResult } from './FilterResult';
 import { IFilterResult } from './IFilterResult';
-import { Application } from '../../../domain/Application';
+import { IApplication } from '@/domain/IApplication';
 import { IUserFilter } from './IUserFilter';
 import { Signal } from '@/infrastructure/Events/Signal';
 
@@ -8,7 +9,7 @@ export class UserFilter implements IUserFilter {
     public readonly filtered = new Signal<IFilterResult>();
     public readonly filterRemoved = new Signal<void>();
 
-    constructor(private application: Application) {
+    constructor(private application: IApplication) {
 
     }
 
@@ -18,11 +19,9 @@ export class UserFilter implements IUserFilter {
         }
         const filterLowercase = filter.toLocaleLowerCase();
         const filteredScripts = this.application.getAllScripts().filter(
-            (script) =>
+            (script) => isScriptAMatch(script, filterLowercase));
-            script.name.toLowerCase().includes(filterLowercase) ||
-            script.code.toLowerCase().includes(filterLowercase));
         const filteredCategories = this.application.getAllCategories().filter(
-            (script) => script.name.toLowerCase().includes(filterLowercase));
+            (category) => category.name.toLowerCase().includes(filterLowercase));
 
         const matches = new FilterResult(
             filteredScripts,
@@ -37,3 +36,16 @@ export class UserFilter implements IUserFilter {
         this.filterRemoved.notify();
     }
 }
+
+function isScriptAMatch(script: IScript, filterLowercase: string) {
+    if (script.name.toLowerCase().includes(filterLowercase)) {
+        return true;
+    }
+    if (script.code.toLowerCase().includes(filterLowercase)) {
+        return true;
+    }
+    if (script.revertCode) {
+        return script.revertCode.toLowerCase().includes(filterLowercase);
+    }
+    return false;
+}

src/application/State/Selection/IUserSelection.ts

@@ -1,11 +1,13 @@
+import { SelectedScript } from './SelectedScript';
 import { ISignal } from '@/infrastructure/Events/Signal';
 import { IScript } from '@/domain/IScript';
 
 export interface IUserSelection {
-    readonly changed: ISignal<ReadonlyArray<IScript>>;
+    readonly changed: ISignal<ReadonlyArray<SelectedScript>>;
-    readonly selectedScripts: ReadonlyArray<IScript>;
+    readonly selectedScripts: ReadonlyArray<SelectedScript>;
     readonly totalSelected: number;
-    addSelectedScript(scriptId: string): void;
+    addSelectedScript(scriptId: string, revert: boolean): void;
+    addOrUpdateSelectedScript(scriptId: string, revert: boolean): void;
     removeSelectedScript(scriptId: string): void;
     selectOnly(scripts: ReadonlyArray<IScript>): void;
     isSelected(script: IScript): boolean;

src/application/State/Selection/SelectedScript.ts

@@ -0,0 +1,14 @@
+import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
+import { IScript } from '@/domain/IScript';
+
+export class SelectedScript extends BaseEntity<string> {
+    constructor(
+        public readonly script: IScript,
+        public readonly revert: boolean,
+        ) {
+        super(script.id);
+        if (revert && !script.canRevert()) {
+            throw new Error('cannot revert an irreversible script');
+        }
+    }
+}

src/application/State/Selection/UserSelection.ts

@@ -1,13 +1,14 @@
+import { SelectedScript } from './SelectedScript';
 import { IApplication } from '@/domain/IApplication';
 import { IUserSelection } from './IUserSelection';
 import { InMemoryRepository } from '@/infrastructure/Repository/InMemoryRepository';
-import { IScript } from '@/domain/Script';
+import { IScript } from '@/domain/IScript';
 import { Signal } from '@/infrastructure/Events/Signal';
+import { IRepository } from '@/infrastructure/Repository/IRepository';
 
 export class UserSelection implements IUserSelection {
-    public readonly changed = new Signal<ReadonlyArray<IScript>>();
+    public readonly changed = new Signal<ReadonlyArray<SelectedScript>>();
-
+    private readonly scripts: IRepository<string, SelectedScript> = new InMemoryRepository<string, SelectedScript>();
-    private readonly scripts = new InMemoryRepository<string, IScript>();
 
     constructor(
         private readonly app: IApplication,
@@ -15,33 +16,40 @@ export class UserSelection implements IUserSelection {
         selectedScripts: ReadonlyArray<IScript>) {
         if (selectedScripts && selectedScripts.length > 0) {
             for (const script of selectedScripts) {
-                this.scripts.addItem(script);
+                const selected = new SelectedScript(script, false);
+                this.scripts.addItem(selected);
             }
         }
     }
 
-    /** Add a script to users application */
+    public addSelectedScript(scriptId: string, revert: boolean): void {
-    public addSelectedScript(scriptId: string): void {
         const script = this.app.findScript(scriptId);
         if (!script) {
             throw new Error(`Cannot add (id: ${scriptId}) as it is unknown`);
         }
-        this.scripts.addItem(script);
+        const selectedScript = new SelectedScript(script, revert);
+        this.scripts.addItem(selectedScript);
+        this.changed.notify(this.scripts.getItems());
+    }
+
+    public addOrUpdateSelectedScript(scriptId: string, revert: boolean): void {
+        const script = this.app.findScript(scriptId);
+        const selectedScript = new SelectedScript(script, revert);
+        this.scripts.addOrUpdateItem(selectedScript);
         this.changed.notify(this.scripts.getItems());
     }
 
-    /** Remove a script from users application */
     public removeSelectedScript(scriptId: string): void {
         this.scripts.removeItem(scriptId);
         this.changed.notify(this.scripts.getItems());
     }
 
     public isSelected(script: IScript): boolean {
-        return this.scripts.exists(script);
+        return this.scripts.exists(script.id);
     }
 
     /** Get users scripts based on his/her selections */
-    public get selectedScripts(): ReadonlyArray<IScript> {
+    public get selectedScripts(): ReadonlyArray<SelectedScript> {
         return this.scripts.getItems();
     }
 
@@ -51,8 +59,9 @@ export class UserSelection implements IUserSelection {
 
     public selectAll(): void {
         for (const script of this.app.getAllScripts()) {
-            if (!this.scripts.exists(script)) {
+            if (!this.scripts.exists(script.id)) {
-                this.scripts.addItem(script);
+                const selection = new SelectedScript(script, false);
+                this.scripts.addItem(selection);
             }
         }
         this.changed.notify(this.scripts.getItems());
@@ -78,9 +87,11 @@ export class UserSelection implements IUserSelection {
                 .forEach((scriptId) => this.scripts.removeItem(scriptId));
         }
         // Select from unselected scripts
-        scripts
+        const unselectedScripts = scripts.filter((script) => !this.scripts.exists(script.id));
-            .filter((script) => !this.scripts.exists(script))
+        for (const toSelect of unselectedScripts) {
-            .forEach((script) => this.scripts.addItem(script));
+            const selection = new SelectedScript(toSelect, false);
+            this.scripts.addItem(selection);
+        }
         this.changed.notify(this.scripts.getItems());
     }
 }

src/application/application.yaml

@@ -1,3 +1,4 @@
+# Structure documented in "./application.yaml.d.ts" (as code)
 name: privacy.sexy
 repositoryUrl: https://github.com/undergroundwires/privacy.sexy
 actions:
@@ -304,7 +305,7 @@ actions:
                             SET /A dps_service_running=1
                             net stop DPS
                         )
-                        REM del /F /S /Q /A "%windir%\System32\sru*"
+                        del /F /S /Q /A "%windir%\System32\sru*"
                         IF !dps_service_running! == 1 (
                             net start DPS
                         )
@@ -320,10 +321,13 @@ actions:
                         name: Disable Customer Experience Improvement (CEIP/SQM)
                         recommend: true
                         code: reg add "HKLM\Software\Policies\Microsoft\SQMClient\Windows" /v "CEIPEnable" /t REG_DWORD /d "0" /f
+                        revertCode: reg add "HKLM\Software\Policies\Microsoft\SQMClient\Windows" /v "CEIPEnable" /t REG_DWORD /d "1" /f
+                        docs: https://docs.microsoft.com/en-us/windows/win32/devnotes/ceipenable
                     -
                         name: Disable Application Impact Telemetry (AIT)
                         recommend: true
                         code: reg add "HKLM\Software\Policies\Microsoft\Windows\AppCompat" /v "AITEnable" /t REG_DWORD /d "0" /f
+                        revertCode: reg add "HKLM\Software\Policies\Microsoft\SQMClient\Windows" /v "CEIPEnable" /t REG_DWORD /d "1" /f
                     -
                         name: Disable diagnostics telemetry
                         recommend: true
@@ -343,13 +347,10 @@ actions:
                             schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\Consolidator" /DISABLE
                             schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\KernelCeipTask" /DISABLE
                             schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\UsbCeip" /DISABLE
-                    -
+                        revertCode: |-
-                        name: Disabling Data Logging Services
+                            schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\Consolidator" /ENABLE
-                        recommend: true
+                            schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\KernelCeipTask" /ENABLE
-                        code: |-
+                            schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\UsbCeip" /ENABLE
-                            schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\Consolidator" /DISABLE
-                            schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\KernelCeipTask" /DISABLE
-                            schtasks /change /TN "\Microsoft\Windows\Customer Experience Improvement Program\UsbCeip" /DISABLE
                     -
                         name: Disable telemetry in data collection policy
                         recommend: true
@@ -381,21 +382,21 @@ actions:
                 name: Disable active prompting (pings to MSFT NCSI server)
                 recommend: false
                 code: reg add "HKLM\SYSTEM\CurrentControlSet\Services\NlaSvc\Parameters\Internet" /v "EnableActiveProbing" /t REG_DWORD /d "0" /f
+                revertCode: reg add "HKLM\SYSTEM\CurrentControlSet\Services\NlaSvc\Parameters\Internet" /v "EnableActiveProbing" /t REG_DWORD /d "1" /f
             -
                 name: Opt out from Windows privacy consent
                 recommend: true
-                code: |-
+                code: reg add "HKCU\SOFTWARE\Microsoft\Personalization\Settings" /v "AcceptedPrivacyPolicy" /t REG_DWORD /d 0 /f
-                    reg add "HKCU\SOFTWARE\Microsoft\Personalization\Settings" /v "AcceptedPrivacyPolicy" /t REG_DWORD /d 0 /f
+                revertCode: reg add "HKCU\SOFTWARE\Microsoft\Personalization\Settings" /v "AcceptedPrivacyPolicy" /t REG_DWORD /d 1 /f
             -
                 name: Disable Windows feedback
                 recommend: true
+                docs: https://www.tenforums.com/tutorials/2441-change-feedback-frequency-windows-10-a.html
                 code: |-
                     reg add "HKCU\SOFTWARE\Microsoft\Siuf\Rules" /v "NumberOfSIUFInPeriod" /t REG_DWORD /d 0 /f 
-                    :: removing this value sets feedback frequency to never
                     reg delete "HKCU\SOFTWARE\Microsoft\Siuf\Rules" /v "PeriodInNanoSeconds" /f
                     reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\DataCollection" /v "DoNotShowFeedbackNotifications" /t REG_DWORD /d 1 /f 
                     reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\DataCollection" /v "DoNotShowFeedbackNotifications" /t REG_DWORD /d 1 /f
-                docs: https://www.tenforums.com/tutorials/2441-change-feedback-frequency-windows-10-a.html
             -
                 name: Disable text and handwriting collection
                 recommend: true
@@ -525,27 +526,28 @@ actions:
                     -
                         name: Deny app access to videos
                         recommend: true
-                        code: |-
+                        code: reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\videosLibrary" /v "Value" /d "Deny" /t REG_SZ /f
-                            reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\videosLibrary" /v "Value" /d "Deny" /t REG_SZ /f
+                        revertCode: reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\videosLibrary" /v "Value" /d "Allow" /t REG_SZ /f
                     -
                         name: Deny app access to pictures
                         recommend: true
-                        code: |-
+                        code: reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\picturesLibrary" /v "Value" /d "Deny" /t REG_SZ /f
-                            reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\picturesLibrary" /v "Value" /d "Deny" /t REG_SZ /f
+                        revertCode: reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\picturesLibrary" /v "Value" /d "Allow" /t REG_SZ /f
                     -
                         name: Deny app access to documents
                         recommend: true
-                        code: |-
+                        code: reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\documentsLibrary" /v "Value" /d "Deny" /t REG_SZ /f
-                            reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\documentsLibrary" /v "Value" /d "Deny" /t REG_SZ /f
+                        revertCode: reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\documentsLibrary" /v "Value" /d "Allow" /t REG_SZ /f
                     -
                         name: Deny app access to bluetooth devices
                         recommend: true
-                        code: |-
+                        code: reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\bluetoothSync" /v "Value" /d "Deny" /t REG_SZ /f
-                           reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\bluetoothSync" /v "Value" /d "Deny" /t REG_SZ /f
+                        revertCode: reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\bluetoothSync" /v "Value" /d "Allow" /t REG_SZ /f
                     -
                         name: Deny app access to text/mms 
                         recommend: true
-                        code: reg add "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\DeviceAccess\Global\{992AFA70-6F47-4148-B3E9-3003349C1548}" /t REG_SZ /v "Value" /d DENY /f
+                        code: reg add "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\DeviceAccess\Global\{992AFA70-6F47-4148-B3E9-3003349C1548}" /t REG_SZ /v "Value" /d "Deny" /f
+                        revertCode: reg add "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\DeviceAccess\Global\{992AFA70-6F47-4148-B3E9-3003349C1548}" /t REG_SZ /v "Value" /d "Allow" /f
             -
                 name: Deny location access
                 recommend: true
@@ -645,15 +647,19 @@ actions:
                 name: Disable App Launch Tracking
                 docs: https://www.thewindowsclub.com/enable-or-disable-app-launch-tracking-in-windows-10
                 recommend: true
-                code: reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced" /v "Start_TrackProgs" /d "0" /t REG_DWORD /f
+                code: reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced" /v "Start_TrackProgs" /d 0 /t REG_DWORD /f
+                revertCode: reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced" /v "Start_TrackProgs" /d 1 /t REG_DWORD /f
             -
                 name: Disable Inventory Collector
                 recommend: true
                 code: reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\AppCompat" /v "DisableInventory" /t REG_DWORD /d 1 /f
+                revertCode: reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\AppCompat" /v "DisableInventory" /t REG_DWORD /d 0 /f
             -
                 name: Disable Website Access of Language List
                 recommend: true
+                docs: https://www.tenforums.com/tutorials/82980-turn-off-website-access-language-list-windows-10-a.html
                 code: reg add "HKCU\Control Panel\International\User Profile" /v "HttpAcceptLanguageOptOut" /t REG_DWORD /d 1 /f 
+                revertCode: reg add "HKCU\Control Panel\International\User Profile" /v "HttpAcceptLanguageOptOut" /t REG_DWORD /d 0 /f 
             -
                 name: Disable Auto Downloading Maps
                 recommend: true
@@ -879,6 +885,15 @@ actions:
                     schtasks /change /TN "Microsoft\Office\OfficeTelemetryAgentFallBack2016" /DISABLE
                     schtasks /change /TN "Microsoft\Office\OfficeTelemetryAgentLogOn2016" /DISABLE
                     sc stop "ClickToRunSvc" & sc config "ClickToRunSvc" start=disabled
+                revertCode: |-
+                    reg add "HKCU\SOFTWARE\Policies\Microsoft\Office\15.0\osm" /v "Enablelogging" /t REG_DWORD /d 1 /f 
+                    reg add "HKCU\SOFTWARE\Policies\Microsoft\Office\15.0\osm" /v "EnableUpload" /t REG_DWORD /d 1 /f 
+                    reg add "HKCU\SOFTWARE\Policies\Microsoft\Office\16.0\osm" /v "Enablelogging" /t REG_DWORD /d 1 /f 
+                    reg add "HKCU\SOFTWARE\Policies\Microsoft\Office\16.0\osm" /v "EnableUpload" /t REG_DWORD /d 1 /f
+                    schtasks /change /TN "Microsoft\Office\Office ClickToRun Service Monitor" /ENABLE
+                    schtasks /change /TN "Microsoft\Office\OfficeTelemetryAgentFallBack2016" /ENABLE
+                    schtasks /change /TN "Microsoft\Office\OfficeTelemetryAgentLogOn2016" /ENABLE
+                    sc config "ClickToRunSvc" start=auto
             -
                 category: Configure browsers
                 children: 
@@ -1042,6 +1057,7 @@ actions:
                 name: Disable administrative shares 
                 recommend: true
                 code: reg add "HKLM\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters" /v "AutoShareWks" /t REG_DWORD /d 0 /f
+                revertCode: reg add "HKLM\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters" /v "AutoShareWks" /t REG_DWORD /d 1 /f
             - 
                 name: Force enable data execution prevention (DEP)
                 recommend: false
@@ -1146,6 +1162,11 @@ actions:
                     reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows Defender" /v DisableAntiSpyware /t REG_DWORD /d 1 /f
                     reg add "HKLM\SYSTEM\CurrentControlSet\Services\MpsSvc" /v "Start" /t REG_DWORD /d 4 /f
                     reg add "HKLM\SYSTEM\CurrentControlSet\Services\WinDefend" /v "Start" /t REG_DWORD /d 4 /f
+                revertCode: |-
+                    netsh advfirewall set allprofiles state on
+                    reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows Defender" /v DisableAntiSpyware /t REG_DWORD /d 0 /f
+                    reg add "HKLM\SYSTEM\CurrentControlSet\Services\MpsSvc" /v "Start" /t REG_DWORD /d 2 /f
+                    reg add "HKLM\SYSTEM\CurrentControlSet\Services\WinDefend" /v "Start" /t REG_DWORD /d 2 /f
             -
                 name: Disable Smart Screen 
                 recommend: false
@@ -1155,19 +1176,33 @@ actions:
                     reg add "HKLM\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Explorer" /v "SmartScreenEnabled" /t REG_SZ /d "Off" /f 
                     reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\AppHost" /v "EnableWebContentEvaluation" /t REG_DWORD /d 0 /f 
                     reg add "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\AppHost" /v "EnableWebContentEvaluation" /t REG_DWORD /d 0 /f 
+                revertCode: |-
+                    reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\System" /v "EnableSmartScreen" /t REG_DWORD /d 1 /f
+                    reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer" /v "SmartScreenEnabled" /t REG_SZ /d "Warn" /f 
+                    reg add "HKLM\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Explorer" /v "SmartScreenEnabled" /t REG_SZ /d "Warn" /f 
+                    reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\AppHost" /v "EnableWebContentEvaluation" /t REG_DWORD /d 1 /f 
+                    reg add "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\AppHost" /v "EnableWebContentEvaluation" /t REG_DWORD /d 1 /f
             -
                 name: Disable scheduled On Demand anti malware scanner (MRT)
                 recommend: false
                 code: reg add "HKLM\SOFTWARE\Policies\Microsoft\MRT" /v "DontOfferThroughWUAU" /t REG_DWORD /d 1 /f
+                revertCode: reg add "HKLM\SOFTWARE\Policies\Microsoft\MRT" /v "DontOfferThroughWUAU" /t REG_DWORD /d 0 /f
             -
                 name: Disable automatic updates
                 recommend: false
+                docs: https://docs.microsoft.com/fr-fr/security-updates/windowsupdateservices/18127152
                 code: |-
                     reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" /v "NoAutoUpdate" /t "REG_DWORD" /d "0" /f
                     reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" /v "AUOptions" /t "REG_DWORD" /d "2" /f
                     reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" /v "ScheduledInstallDay" /t "REG_DWORD" /d "0" /f
                     reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" /v "ScheduledInstallTime" /t "REG_DWORD" /d "3" /f
                     sc stop "UsoSvc" & sc config "UsoSvc" start=disabled
+                revertCode: |-
+                    reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" /v "NoAutoUpdate" /t "REG_DWORD" /d "1" /f
+                    reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" /v "AUOptions" /t "REG_DWORD" /d "3" /f
+                    reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" /v "ScheduledInstallDay" /t "REG_DWORD" /d "0" /f
+                    reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" /v "ScheduledInstallTime" /t "REG_DWORD" /d "0" /f
+                    sc config "UsoSvc" start=auto
     -
         category: UI for privacy
         children:         
@@ -1175,6 +1210,8 @@ actions:
                 name: Disable lock screen app notifications
                 recommend: true
                 code: reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\System" /v "DisableLockScreenAppNotifications" /t REG_DWORD /d 1 /f
+                revertCode: reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\System" /v "DisableLockScreenAppNotifications" /t REG_DWORD /d 0 /f
+                docs: https://www.stigviewer.com/stig/windows_server_2012_member_server/2014-01-07/finding/V-36687
             -
                 name: Disable online content in explorer
                 recommend: true
@@ -1336,8 +1373,7 @@ actions:
                 recommend: true
                 docs: https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service
                 code: sc stop "VSS" & sc config "VSS" start=disabled
-
+                revertCode: sc config vss start=auto
-                        
     -
         category: Remove bloatware
         children:
@@ -2074,12 +2110,19 @@ actions:
             -
                 name: Disable Reserved Storage for updates
                 recommend: false
-                docs: https://techcommunity.microsoft.com/t5/storage-at-microsoft/windows-10-and-reserved-storage/ba-p/428327
+                docs: 
+                    - https://techcommunity.microsoft.com/t5/storage-at-microsoft/windows-10-and-reserved-storage/ba-p/428327
+                    - https://www.tenforums.com/tutorials/124858-enable-disable-reserved-storage-windows-10-a.html
                 code: |-
                     dism /online /Set-ReservedStorageState /State:Disabled /NoRestart
                     reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\ReserveManager" /v "MiscPolicyInfo" /t REG_DWORD /d "2" /f
                     reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\ReserveManager" /v "ShippedWithReserves" /t REG_DWORD /d "0" /f
                     reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\ReserveManager" /v "PassedPolicy" /t REG_DWORD /d "0" /f
+                revertCode: |-
+                    DISM /Online /Set-ReservedStorageState /State:Enabled /NoRestart
+                    reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\ReserveManager" /v "MiscPolicyInfo" /t REG_DWORD /d "1" /f
+                    reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\ReserveManager" /v "ShippedWithReserves" /t REG_DWORD /d "1" /f
+                    reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\ReserveManager" /v "PassedPolicy" /t REG_DWORD /d "1" /f
             -
                 name: Run script on start-up [EXPERIMENTAL]
                 recommend: false

src/application/application.yaml.d.ts

@@ -1,5 +1,5 @@
 declare module 'js-yaml-loader!*' {
-    type CategoryOrScript = YamlCategory | YamlScript;
+    export type CategoryOrScript = YamlCategory | YamlScript;
     type DocumentationUrls = ReadonlyArray<string> | string;
 
     export interface YamlDocumentable {
@@ -9,6 +9,7 @@ declare module 'js-yaml-loader!*' {
     export interface YamlScript extends YamlDocumentable {
         name: string;
         code: string;
+        revertCode: string;
         recommend: boolean;
     }
 

src/domain/Application.ts

@@ -13,11 +13,11 @@ export class Application implements IApplication {
         public readonly name: string,
         public readonly repositoryUrl: string,
         public readonly version: string,
-        public readonly categories: ReadonlyArray<ICategory>) {
+        public readonly actions: ReadonlyArray<ICategory>) {
         if (!name) { throw Error('Application has no name'); }
         if (!repositoryUrl) { throw Error('Application has no repository url'); }
         if (!version) { throw Error('Version cannot be empty'); }
-        this.flattened = flatten(categories);
+        this.flattened = flatten(actions);
         if (this.flattened.allCategories.length === 0) {
             throw new Error('Application must consist of at least one category');
         }

src/domain/IApplication.ts

@@ -5,9 +5,9 @@ export interface IApplication {
     readonly name: string;
     readonly repositoryUrl: string;
     readonly version: string;
-    readonly categories: ReadonlyArray<ICategory>;
     readonly totalScripts: number;
     readonly totalCategories: number;
+    readonly actions: ReadonlyArray<ICategory>;
 
     getRecommendedScripts(): ReadonlyArray<IScript>;
     findCategory(categoryId: number): ICategory | undefined;

src/domain/IScript.ts

@@ -1,9 +1,11 @@
-import { IEntity } from './../infrastructure/Entity/IEntity';
+import { IEntity } from '../infrastructure/Entity/IEntity';
 import { IDocumentable } from './IDocumentable';
 
 export interface IScript extends IEntity<string>, IDocumentable {
     readonly name: string;
-    readonly code: string;
     readonly isRecommended: boolean;
     readonly documentationUrls: ReadonlyArray<string>;
+    readonly code: string;
+    readonly revertCode: string;
+    canRevert(): boolean;
 }

src/domain/Script.ts

@@ -2,15 +2,51 @@ import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
 import { IScript } from './IScript';
 
 export class Script extends BaseEntity<string> implements IScript {
-    private static ensureNoEmptyLines(name: string, code: string): void {
+    constructor(
+        public readonly name: string,
+        public readonly code: string,
+        public readonly revertCode: string,
+        public readonly documentationUrls: ReadonlyArray<string>,
+        public readonly isRecommended: boolean) {
+        super(name);
+        validateCode(name, code);
+        if (revertCode) {
+            validateCode(name, revertCode);
+            if (code === revertCode) {
+                throw new Error(`${name}: Code itself and its reverting code cannot be the same`);
+            }
+        }
+    }
+    public canRevert(): boolean {
+        return Boolean(this.revertCode);
+    }
+}
+
+function validateCode(name: string, code: string): void {
+    if (!code || code.length === 0) {
+        throw new Error(`Code of ${name} is empty or null`);
+    }
+    ensureCodeHasUniqueLines(name, code);
+    ensureNoEmptyLines(name, code);
+}
+
+function ensureNoEmptyLines(name: string, code: string): void {
     if (code.split('\n').some((line) => line.trim().length === 0)) {
         throw Error(`Script has empty lines "${name}"`);
     }
 }
 
-    private static ensureCodeHasUniqueLines(name: string, code: string): void {
+function mayBeUniqueLine(codeLine: string): boolean {
+    const trimmed = codeLine.trim();
+    if (trimmed === ')' || trimmed === '(') { // "(" and ")" are used often in batch code
+        return false;
+    }
+    return true;
+}
+
+function ensureCodeHasUniqueLines(name: string, code: string): void {
     const lines = code.split('\n')
-            .filter((line) => this.mayBeUniqueLine(line));
+        .filter((line) => mayBeUniqueLine(line));
     if (lines.length === 0) {
         return;
     }
@@ -19,27 +55,3 @@ export class Script extends BaseEntity<string> implements IScript {
         throw Error(`Duplicates detected in script "${name}":\n ${duplicateLines.join('\n')}`);
     }
 }
-
-    private static mayBeUniqueLine(codeLine: string): boolean {
-        const trimmed = codeLine.trim();
-        if (trimmed === ')' || trimmed === '(') { // "(" and ")" are used often in batch code
-            return false;
-        }
-        return true;
-    }
-
-    constructor(
-        public name: string,
-        public code: string,
-        public documentationUrls: ReadonlyArray<string>,
-        public isRecommended: boolean) {
-        super(name);
-        if (code == null || code.length === 0) {
-            throw new Error('Code is empty or null');
-        }
-        Script.ensureCodeHasUniqueLines(name, code);
-        Script.ensureNoEmptyLines(name, code);
-    }
-}
-
-export { IScript } from './IScript';

src/global.d.ts

@@ -13,6 +13,7 @@ declare module 'liquor-tree' {
     }
     interface ICustomLiquorTreeData {
         documentationUrls: ReadonlyArray<string>;
+        isReversible: boolean;
     }
 
     /**

src/infrastructure/Repository/IRepository.ts

@@ -4,6 +4,7 @@ export interface IRepository<TKey, TEntity extends IEntity<TKey>> {
     readonly length: number;
     getItems(predicate?: (entity: TEntity) => boolean): TEntity[];
     addItem(item: TEntity): void;
+    addOrUpdateItem(item: TEntity): void;
     removeItem(id: TKey): void;
-    exists(item: TEntity): boolean;
+    exists(id: TKey): boolean;
 }

src/infrastructure/Repository/InMemoryRepository.ts

@@ -18,14 +18,24 @@ export class InMemoryRepository<TKey, TEntity extends IEntity<TKey>> implements
 
     public addItem(item: TEntity): void {
         if (!item) {
-            throw new Error('Item is null');
+            throw new Error('item is null or undefined');
         }
-        if (this.exists(item)) {
+        if (this.exists(item.id)) {
             throw new Error(`Cannot add (id: ${item.id}) as it is already exists`);
         }
         this.items.push(item);
     }
 
+    public addOrUpdateItem(item: TEntity): void {
+        if (!item) {
+            throw new Error('item is null or undefined');
+        }
+        if (this.exists(item.id)) {
+            this.removeItem(item.id);
+        }
+        this.items.push(item);
+    }
+
     public removeItem(id: TKey): void {
         const index = this.items.findIndex((item) => item.id === id);
         if (index === -1) {
@@ -34,8 +44,8 @@ export class InMemoryRepository<TKey, TEntity extends IEntity<TKey>> implements
         this.items.splice(index, 1);
     }
 
-    public exists(entity: TEntity): boolean {
+    public exists(id: TKey): boolean {
-        const index = this.items.findIndex((item) => item.id === entity.id);
+        const index = this.items.findIndex((item) => item.id === id);
         return index !== -1;
     }
 }

src/presentation/IconButton.vue

@@ -9,7 +9,7 @@
 
 <script lang="ts">
 import { Component, Prop, Vue, Emit } from 'vue-property-decorator';
-import { StatefulVue, IApplicationState } from './StatefulVue';
+import { StatefulVue } from './StatefulVue';
 import { SaveFileDialog } from './../infrastructure/SaveFileDialog';
 import { Clipboard } from './../infrastructure/Clipboard';
 

src/presentation/Scripts/Cards/CardList.vue

@@ -18,7 +18,7 @@
 <script lang="ts">
 import { Component, Prop, Vue } from 'vue-property-decorator';
 import CardListItem from './CardListItem.vue';
-import { StatefulVue, IApplicationState } from '@/presentation/StatefulVue';
+import { StatefulVue } from '@/presentation/StatefulVue';
 import { ICategory } from '@/domain/ICategory';
 
 @Component({
@@ -32,7 +32,7 @@ export default class CardList extends StatefulVue {
 
   public async mounted() {
     const state = await this.getCurrentStateAsync();
-    this.setCategories(state.app.categories);
+    this.setCategories(state.app.actions);
     this.onOutsideOfActiveCardClicked(() => {
       this.activeCategoryId = null;
     });
@@ -52,7 +52,7 @@ export default class CardList extends StatefulVue {
         return;
       }
       const element = document.querySelector(`[data-category="${this.activeCategoryId}"]`);
-      if (!element.contains(event.target)) {
+      if (element && !element.contains(event.target)) {
         callback();
       }
     };

src/presentation/Scripts/ScriptsTree/ScriptNodeParser.ts

@@ -4,7 +4,7 @@ import { INode } from './SelectableTree/INode';
 
 export function parseAllCategories(app: IApplication): INode[] | undefined {
   const nodes = new Array<INode>();
-  for (const category of app.categories) {
+  for (const category of app.actions) {
     const children = parseCategoryRecursively(category);
     nodes.push(convertCategoryToNode(category, children));
   }
@@ -23,6 +23,7 @@ export function parseSingleCategory(categoryId: number, app: IApplication): INod
 export function getScriptNodeId(script: IScript): string {
   return script.id;
 }
+
 export function getCategoryNodeId(category: ICategory): string {
   return `Category${category.id}`;
 }
@@ -53,6 +54,7 @@ function convertCategoryToNode(
     text: category.name,
     children,
     documentationUrls: category.documentationUrls,
+    isReversible: false,
   };
 }
 
@@ -62,5 +64,6 @@ function convertScriptToNode(script: IScript): INode {
     text: script.name,
     children: undefined,
     documentationUrls: script.documentationUrls,
+    isReversible: script.canRevert(),
   };
 }

src/presentation/Scripts/ScriptsTree/ScriptsTree.vue

@@ -6,7 +6,9 @@
                 :selectedNodeIds="selectedNodeIds"
                 :filterPredicate="filterPredicate"
                 :filterText="filterText"
-                v-on:nodeSelected="checkNodeAsync($event)">
+                v-on:nodeSelected="toggleNodeSelectionAsync($event)"
+                v-on:nodeRevertToggled="handleNodeRevertToggleAsync($event)"
+                >
             </SelectableTree>
         </span>
         <span v-else>Nooo 😢</span>
@@ -25,6 +27,7 @@
   import { parseAllCategories, parseSingleCategory, getScriptNodeId, getCategoryNodeId } from './ScriptNodeParser';
   import SelectableTree, { FilterPredicate } from './SelectableTree/SelectableTree.vue';
   import { INode } from './SelectableTree/INode';
+  import { SelectedScript } from '@/application/State/Selection/SelectedScript';
 
   @Component({
     components: {
@@ -50,13 +53,13 @@
       await this.initializeNodesAsync(this.categoryId);
     }
 
-    public async checkNodeAsync(node: INode) {
+    public async toggleNodeSelectionAsync(node: INode) {
         if (node.children != null && node.children.length > 0) {
             return; // only interested in script nodes
         }
         const state = await this.getCurrentStateAsync();
         if (!this.selectedNodeIds.some((id) => id === node.id)) {
-            state.selection.addSelectedScript(node.id);
+            state.selection.addSelectedScript(node.id, false);
         } else {
             state.selection.removeSelectedScript(node.id);
         }
@@ -71,7 +74,7 @@
         this.nodes = parseAllCategories(state.app);
       }
       this.selectedNodeIds = state.selection.selectedScripts
-        .map((script) => getScriptNodeId(script));
+        .map((selected) => getScriptNodeId(selected.script));
     }
 
     public filterPredicate(node: INode): boolean {
@@ -81,7 +84,7 @@
           (category: ICategory) => node.id === getCategoryNodeId(category));
     }
 
-    private handleSelectionChanged(selectedScripts: ReadonlyArray<IScript>): void {
+    private handleSelectionChanged(selectedScripts: ReadonlyArray<SelectedScript>): void {
       this.selectedNodeIds = selectedScripts
           .map((node) => node.id);
     }

src/presentation/Scripts/ScriptsTree/SelectableTree/DocumentationUrls.vue

@@ -0,0 +1,46 @@
+<template>
+    <div class="documentationUrls">
+        <a v-for="url of this.documentationUrls"
+            v-bind:key="url"
+            :href="url"
+            :alt="url"
+            target="_blank" class="documentationUrl"
+            v-tooltip.top-center="url"
+            v-on:click.stop>
+            <font-awesome-icon :icon="['fas', 'info-circle']" />
+        </a>
+    </div>
+</template>
+
+
+<script lang="ts">
+    import { Component, Prop, Vue } from 'vue-property-decorator';
+    /** Wrapper for Liquor Tree, reveals only abstracted INode for communication */
+    @Component
+    export default class DocumentationUrls extends Vue {
+        @Prop() public documentationUrls: string[];
+    }
+</script>
+
+
+<style scoped lang="scss">
+@import "@/presentation/styles/colors.scss";
+.documentationUrls {
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    align-items: center;
+}
+.documentationUrl {
+    display: flex;
+    color: $gray;
+    cursor: pointer;
+    vertical-align: middle;
+    &:hover {
+        color: $slate;
+    }
+    &:not(:first-child) {
+      margin-left: 0.1em;
+    }
+}
+</style>

src/presentation/Scripts/ScriptsTree/SelectableTree/INode.ts

@@ -1,6 +1,7 @@
 export interface INode {
     readonly id: string;
     readonly text: string;
+    readonly isReversible: boolean;
     readonly documentationUrls: ReadonlyArray<string>;
     readonly children?: ReadonlyArray<INode>;
 }

src/presentation/Scripts/ScriptsTree/SelectableTree/Node.vue

@@ -1,17 +1,14 @@
 <template>
     <div id="node">
-        <div>{{ this.data.text }}</div>
+        <div class="item text">{{ this.data.text }}</div>
-        <div
+        <RevertToggle
-          v-for="url of this.data.documentationUrls"
+          class="item"
-          v-bind:key="url">
+          v-if="data.isReversible"
-            <a :href="url"
+          :scriptId="data.id" />
-                :alt="url"
+        <DocumentationUrls
-                target="_blank" class="docs"
+          class="item"
-                v-tooltip.top-center="url"
+          v-if="data.documentationUrls && data.documentationUrls.length > 0"
-                v-on:click.stop>
+          :documentationUrls="this.data.documentationUrls" />
-                <font-awesome-icon :icon="['fas', 'info-circle']" />
-                </a>
-        </div>
     </div>
 </template>
 
@@ -19,8 +16,15 @@
 <script lang="ts">
     import { Component, Prop, Vue } from 'vue-property-decorator';
     import { INode } from './INode';
+    import RevertToggle from './RevertToggle.vue';
+    import DocumentationUrls from './DocumentationUrls.vue';
     /** Wrapper for Liquor Tree, reveals only abstracted INode for communication */
-    @Component
+    @Component({
+        components: {
+          RevertToggle,
+          DocumentationUrls,
+        },
+    })
     export default class Node extends Vue {
         @Prop() public data: INode;
     }
@@ -33,14 +37,12 @@
     display:flex;
     flex-direction: row;
     flex-wrap: wrap;
-  .docs {
+    .text {
-    color: $gray;
+      display: flex;
-    cursor: pointer;
+      align-items: center;
+    }
+    .item:not(:first-child) {
       margin-left: 5px;
-    &:hover {
-        color: $slate;
     }
 }
-}
-
 </style>

src/presentation/Scripts/ScriptsTree/SelectableTree/NodeTranslator.ts

@@ -12,6 +12,7 @@ export function convertExistingToNode(liquorTreeNode: ILiquorTreeExistingNode):
         children: (!liquorTreeNode.children || liquorTreeNode.children.length === 0)
          ? [] : liquorTreeNode.children.map((childNode) => convertExistingToNode(childNode)),
         documentationUrls: liquorTreeNode.data.documentationUrls,
+        isReversible : liquorTreeNode.data.isReversible,
     };
 }
 
@@ -27,6 +28,7 @@ export function toNewLiquorTreeNode(node: INode): ILiquorTreeNewNode {
          node.children.map((childNode) => toNewLiquorTreeNode(childNode)),
         data: {
             documentationUrls: node.documentationUrls,
+            isReversible: node.isReversible,
         },
     };
 }

src/presentation/Scripts/ScriptsTree/SelectableTree/RevertToggle.vue

@@ -0,0 +1,141 @@
+<template>
+        <div class="checkbox-switch" >
+            <input type="checkbox" class="input-checkbox" 
+                v-model="isReverted"
+                @change="onRevertToggledAsync()" >
+            <div class="checkbox-animate">
+                <span class="checkbox-off">revert</span>
+                <span class="checkbox-on">revert</span>
+            </div>
+        </div>
+</template>
+
+
+<script lang="ts">
+    import { Component, Prop, Vue } from 'vue-property-decorator';
+    import { StatefulVue } from '@/presentation/StatefulVue';
+    import { INode } from './INode';
+    import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+
+    @Component
+    export default class RevertToggle extends StatefulVue {
+        @Prop() public scriptId: string;
+        public isReverted = false;
+        public async mounted() {
+            const state = await this.getCurrentStateAsync();
+            state.selection.changed.on(this.handleSelectionChanged);
+        }
+        public async onRevertToggledAsync() {
+            const state = await this.getCurrentStateAsync();
+            state.selection.addOrUpdateSelectedScript(this.scriptId, this.isReverted);
+        }
+        private handleSelectionChanged(selectedScripts: ReadonlyArray<SelectedScript>): void {
+            const selectedScript = selectedScripts.find((script) => script.id === this.scriptId);
+            if (!selectedScript) {
+                this.isReverted = false;
+            } else {
+                this.isReverted = selectedScript.revert;
+            }
+        }
+    }
+</script>
+
+
+<style scoped lang="scss">
+@import "@/presentation/styles/colors.scss";
+$width: 85px;
+$height: 30px;
+// https://www.designlabthemes.com/css-toggle-switch/
+.checkbox-switch {
+    cursor: pointer;
+    display: inline-block;
+    overflow: hidden;
+    position: relative;
+    width: $width;
+    height: $height;
+    -webkit-border-radius: $height;
+    border-radius: $height;
+    line-height: $height;
+    font-size: $height / 2;
+    display: inline-block;
+
+    input.input-checkbox {
+        position: absolute;
+        left: 0;
+        top: 0;
+        width: $width;
+        height: $height;
+        padding: 0;
+        margin: 0;
+        opacity: 0;
+        z-index: 2;
+        cursor: pointer;
+    }
+
+    .checkbox-animate {
+        position: relative;
+        width: $width;
+        height: $height;
+        background-color: $gray;
+        -webkit-transition: background-color 0.25s ease-out 0s;
+        transition: background-color 0.25s ease-out 0s;
+
+        // Circle
+        &:before {
+            $circle-size: $height * 0.66;
+
+            content: "";
+            display: block;
+            position: absolute;
+            width: $circle-size;
+            height: $circle-size;
+            border-radius: $circle-size * 2;
+            -webkit-border-radius: $circle-size * 2;
+            background-color: $slate;
+            top: $height * 0.16;
+            left: $width * 0.05;
+            -webkit-transition: left 0.3s ease-out 0s;
+            transition: left 0.3s ease-out 0s;
+            z-index: 10;
+        }
+    }
+
+    input.input-checkbox:checked {
+        + .checkbox-animate {
+            background-color: $accent;
+        }
+        + .checkbox-animate:before {
+            left: ($width - $width/3.5);
+            background-color: $light-gray;
+        }
+        + .checkbox-animate .checkbox-off {
+            display: none;
+            opacity: 0;
+        }
+        + .checkbox-animate .checkbox-on {
+            display: block;
+            opacity: 1;
+        }
+    }
+
+    .checkbox-off, .checkbox-on {
+        float: left;
+        color: $white;
+        font-weight: 700;
+            -webkit-transition: all 0.3s ease-out 0s;
+        transition: all 0.3s ease-out 0s;
+    }
+
+    .checkbox-off {
+        margin-left: $width / 3;
+        opacity: 1;
+    }
+
+    .checkbox-on {
+        display: none;
+        float: right;
+        margin-right: $width / 3;
+        opacity: 0;
+    }
+}
+</style>

src/presentation/Scripts/ScriptsTree/SelectableTree/SelectableTree.vue

@@ -144,6 +144,7 @@
                 text: oldNode.data.text,
                 data: {
                     documentationUrls: oldNode.data.documentationUrls,
+                    isReversible: oldNode.data.isReversible,
                 },
                 children: oldNode.children == null ? [] :
                         updateCheckedState(oldNode.children, selectedNodeIds),
@@ -154,9 +155,3 @@
         return result;
     }
 </script>
-
-
-<style scoped lang="scss">
-@import "@/presentation/styles/colors.scss";
-
-</style>

src/presentation/Scripts/Selector/TheSelector.vue

@@ -32,7 +32,8 @@ import { Component, Prop, Vue } from 'vue-property-decorator';
 import { StatefulVue } from '@/presentation/StatefulVue';
 import SelectableOption from './SelectableOption.vue';
 import { IApplicationState } from '@/application/State/IApplicationState';
-import { IScript } from '@/domain/Script';
+import { IScript } from '@/domain/IScript';
+import { SelectedScript } from '../../../application/State/Selection/SelectedScript';
 
 @Component({
   components: {
@@ -79,12 +80,14 @@ export default class TheSelector extends StatefulVue {
     private updateSelections(state: IApplicationState) {
         this.isNoneSelected = state.selection.totalSelected === 0;
         this.isAllSelected = state.selection.totalSelected === state.app.totalScripts;
-        this.isRecommendedSelected = this.areSame(state.app.getRecommendedScripts(), state.selection.selectedScripts);
+        this.isRecommendedSelected = this.areAllRecommended(state.app.getRecommendedScripts(),
+            state.selection.selectedScripts);
     }
 
-    private areSame(scripts: ReadonlyArray<IScript>, other: ReadonlyArray<IScript>): boolean {
+    private areAllRecommended(scripts: ReadonlyArray<IScript>, other: ReadonlyArray<SelectedScript>): boolean {
+        other = other.filter((selected) => !(selected).revert);
         return (scripts.length === other.length) &&
-            scripts.every((script) => other.some((s) => s.id === script.id));
+            scripts.every((script) => other.some((selected) => selected.id === script.id));
     }
 }
 </script>

src/presentation/StatefulVue.ts

@@ -1,6 +1,6 @@
-import { ApplicationState, IApplicationState } from '../application/State/ApplicationState';
+import { ApplicationState } from '@/application/State/ApplicationState';
+import { IApplicationState } from '@/application/State/IApplicationState';
 import { Vue } from 'vue-property-decorator';
-export { IApplicationState };
 
 export abstract class StatefulVue extends Vue {
     public isLoading = true;

src/presentation/TheCodeArea.vue

@@ -4,7 +4,7 @@
 
 <script lang="ts">
 import { Component, Prop, Watch, Vue } from 'vue-property-decorator';
-import { StatefulVue, IApplicationState } from './StatefulVue';
+import { StatefulVue } from './StatefulVue';
 import ace from 'ace-builds';
 import 'ace-builds/webpack-resolver';
 import { CodeBuilder } from '../application/State/Code/CodeBuilder';

src/presentation/TheCodeButtons.vue

@@ -15,7 +15,7 @@
 
 <script lang="ts">
 import { Component, Prop, Vue } from 'vue-property-decorator';
-import { StatefulVue, IApplicationState } from './StatefulVue';
+import { StatefulVue } from './StatefulVue';
 import { SaveFileDialog } from './../infrastructure/SaveFileDialog';
 import { Clipboard } from './../infrastructure/Clipboard';
 import IconButton from './IconButton.vue';

tests/unit/application/Parser/ApplicationParser.spec.ts

@@ -1,12 +1,115 @@
-import applicationFile from 'js-yaml-loader!@/application/application.yaml';
+import { IEntity } from '@/infrastructure/Entity/IEntity';
+import applicationFile, { YamlCategory, YamlScript, ApplicationYaml } from 'js-yaml-loader!@/application/application.yaml';
 import { parseApplication } from '@/application/Parser/ApplicationParser';
 import 'mocha';
 import { expect } from 'chai';
+import { parseCategory } from '@/application/Parser/CategoryParser';
+
+declare var process;
 
 describe('ApplicationParser', () => {
     describe('parseApplication', () => {
         it('can parse current application file', () => {
             expect(() => parseApplication(applicationFile)).to.not.throw();
         });
+        it('throws when undefined', () => {
+            expect(() => parseApplication(undefined)).to.throw('application is null or undefined');
+        });
+        it('throws when undefined actions', () => {
+            const sut: ApplicationYaml = {
+                name: 'test',
+                repositoryUrl: 'https://privacy.sexy',
+                actions: undefined,
+            };
+            expect(() => parseApplication(sut)).to.throw('application does not define any action');
+        });
+        it('throws when has no actions', () => {
+            const sut: ApplicationYaml = {
+                name: 'test',
+                repositoryUrl: 'https://privacy.sexy',
+                actions: [],
+            };
+            expect(() => parseApplication(sut)).to.throw('application does not define any action');
+        });
+        it('returns expected name', () => {
+            // arrange
+            const expected = 'test-app-name';
+            const sut: ApplicationYaml = {
+                name: expected,
+                repositoryUrl: 'https://privacy.sexy',
+                actions: [ getTestCategory() ],
+            };
+            // act
+            const actual = parseApplication(sut).name;
+            // assert
+            expect(actual).to.be.equal(actual);
+        });
+        it('returns expected repository url', () => {
+            // arrange
+            const expected = 'https://privacy.sexy';
+            const sut: ApplicationYaml = {
+                name: 'name',
+                repositoryUrl: expected,
+                actions: [ getTestCategory() ],
+            };
+            // act
+            const actual = parseApplication(sut).repositoryUrl;
+            // assert
+            expect(actual).to.be.equal(actual);
+        });
+        it('returns expected repository version', () => {
+            // arrange
+            const expected = '1.0.0';
+            process = {
+                env: {
+                    VUE_APP_VERSION: expected,
+                },
+            };
+            const sut: ApplicationYaml = {
+                name: 'name',
+                repositoryUrl: 'https://privacy.sexy',
+                actions: [ getTestCategory() ],
+            };
+            // act
+            const actual = parseApplication(sut).version;
+            // assert
+            expect(actual).to.be.equal(actual);
+        });
+        it('parses actions', () => {
+            // arrange
+            const actions = [ getTestCategory('test1'), getTestCategory('test2') ];
+            const expected = [ parseCategory(actions[0]), parseCategory(actions[1]) ];
+            const sut: ApplicationYaml = {
+                name: 'name',
+                repositoryUrl: 'https://privacy.sexy',
+                actions,
+            };
+            // act
+            const actual = parseApplication(sut).actions;
+            // assert
+            expect(excludingId(actual)).to.be.deep.equal(excludingId(expected));
+            function excludingId<TId>(array: ReadonlyArray<IEntity<TId>>) {
+                return array.map((obj) => {
+                    const { ['id']: omitted, ...rest } = obj;
+                    return rest;
+                });
+            }
         });
     });
+});
+
+function getTestCategory(scriptName = 'testScript'): YamlCategory {
+    return {
+        category: 'category name',
+        children: [ getTestScript(scriptName) ],
+    };
+}
+
+function getTestScript(scriptName: string): YamlScript {
+    return {
+        name: scriptName,
+        code: 'script code',
+        revertCode: 'revert code',
+        recommend: true,
+    };
+}

tests/unit/application/Parser/CategoryParser.spec.ts

@@ -0,0 +1,109 @@
+import 'mocha';
+import { expect } from 'chai';
+import { parseCategory } from '@/application/Parser/CategoryParser';
+import { YamlCategory, CategoryOrScript, YamlScript } from 'js-yaml-loader!./application.yaml';
+import { parseScript } from '@/application/Parser/ScriptParser';
+import { parseDocUrls } from '@/application/Parser/DocumentationParser';
+
+describe('CategoryParser', () => {
+    describe('parseCategory', () => {
+
+        it('throws when undefined', () => {
+            expect(() => parseCategory(undefined)).to.throw('category is null or undefined');
+        });
+
+        it('throws when children is empty', () => {
+            const category: YamlCategory = {
+                category: 'test',
+                children: [],
+            };
+            expect(() => parseCategory(category)).to.throw('category has no children');
+        });
+
+        it('throws when children is undefined', () => {
+            const category: YamlCategory = {
+                category: 'test',
+                children: undefined,
+            };
+            expect(() => parseCategory(category)).to.throw('category has no children');
+        });
+
+        it('throws when name is empty', () => {
+            const category: YamlCategory = {
+                category: '',
+                children: getTestChildren(),
+            };
+            expect(() => parseCategory(category)).to.throw('category has no name');
+        });
+
+        it('throws when name is undefined', () => {
+            const category: YamlCategory = {
+                category: undefined,
+                children: getTestChildren(),
+            };
+            expect(() => parseCategory(category)).to.throw('category has no name');
+        });
+
+        it('returns expected docs', () => {
+            // arrange
+            const url = 'https://privacy.sexy';
+            const expected = parseDocUrls({ docs: url });
+            const category: YamlCategory = {
+                category: 'category name',
+                children: getTestChildren(),
+                docs: url,
+            };
+            // act
+            const actual = parseCategory(category).documentationUrls;
+            // assert
+            expect(actual).to.deep.equal(expected);
+        });
+
+        it('returns expected scripts', () => {
+            // arrange
+            const script = getTestScript();
+            const expected = [ parseScript(script) ];
+            const category: YamlCategory = {
+                category: 'category name',
+                children: [ script ],
+            };
+            // act
+            const actual = parseCategory(category).scripts;
+            // assert
+            expect(actual).to.deep.equal(expected);
+        });
+
+        it('returns expected subcategories', () => {
+            // arrange
+            const expected: YamlCategory[]  = [ {
+                category: 'test category',
+                children: [ getTestScript() ],
+            }];
+            const category: YamlCategory = {
+                category: 'category name',
+                children: expected,
+            };
+            // act
+            const actual = parseCategory(category).subCategories;
+            // assert
+            expect(actual).to.have.lengthOf(1);
+            expect(actual[0].name).to.equal(expected[0].category);
+            expect(actual[0].scripts.length).to.equal(expected[0].children.length);
+        });
+    });
+});
+
+function getTestChildren(): ReadonlyArray<CategoryOrScript> {
+    return [
+        getTestScript(),
+    ];
+}
+
+function getTestScript(): YamlScript {
+    return {
+        name: 'script name',
+        code: 'script code',
+        revertCode: 'revert code',
+        recommend: true,
+    };
+}

tests/unit/application/Parser/DocumentationParser.spec.ts

@@ -0,0 +1,39 @@
+import 'mocha';
+import { expect } from 'chai';
+import { YamlDocumentable } from 'js-yaml-loader!./application.yaml';
+import { parseDocUrls } from '@/application/Parser/DocumentationParser';
+
+describe('DocumentationParser', () => {
+    describe('parseDocUrls', () => {
+        it('throws when undefined', () => {
+            expect(() => parseDocUrls(undefined)).to.throw('documentable is null or undefined');
+        });
+        it('returns empty when empty', () => {
+            // arrange
+            const empty: YamlDocumentable = { };
+            // act
+            const actual = parseDocUrls(empty);
+            // assert
+            expect(actual).to.have.lengthOf(0);
+        });
+        it('returns single item when string', () => {
+            // arrange
+            const url = 'https://privacy.sexy';
+            const expected = [ url ];
+            const sut: YamlDocumentable = { docs: url };
+            // act
+            const actual = parseDocUrls(sut);
+            // assert
+            expect(actual).to.deep.equal(expected);
+        });
+        it('returns all when array', () => {
+            // arrange
+            const expected = [ 'https://privacy.sexy', 'https://github.com/undergroundwires/privacy.sexy' ];
+            const sut: YamlDocumentable = { docs: expected };
+            // act
+            const actual = parseDocUrls(sut);
+            // assert
+            expect(actual).to.deep.equal(expected);
+        });
+    });
+});

tests/unit/application/Parser/ScriptParser.spec.ts

@@ -0,0 +1,28 @@
+import { YamlScript } from 'js-yaml-loader!./application.yaml';
+import 'mocha';
+import { expect } from 'chai';
+import { parseScript } from '@/application/Parser/ScriptParser';
+import { parseDocUrls } from '@/application/Parser/DocumentationParser';
+
+describe('ScriptParser', () => {
+    describe('parseScript', () => {
+        it('parseScript parses as expected', () => {
+            // arrange
+            const expected: YamlScript = {
+                name: 'expected name',
+                code: 'expected code',
+                revertCode: 'expected revert code',
+                docs: ['hello.com'],
+                recommend: true,
+            };
+            // act
+            const actual = parseScript(expected);
+            // assert
+            expect(actual.name).to.equal(expected.name);
+            expect(actual.code).to.equal(expected.code);
+            expect(actual.revertCode).to.equal(expected.revertCode);
+            expect(actual.documentationUrls).to.deep.equal(parseDocUrls(expected));
+            expect(actual.isRecommended).to.equal(expected.recommend);
+        });
+    });
+});

tests/unit/application/State/Code/ApplicationCode.spec.ts

@@ -0,0 +1,65 @@
+import { CategoryStub } from './../../../stubs/CategoryStub';
+import { ScriptStub } from './../../../stubs/ScriptStub';
+import { ApplicationStub } from './../../../stubs/ApplicationStub';
+import { UserSelection } from '@/application/State/Selection/UserSelection';
+import { ApplicationCode } from '@/application/State/Code/ApplicationCode';
+import 'mocha';
+import { expect } from 'chai';
+import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+
+describe('ApplicationCode', () => {
+    describe('ctor', () => {
+        it('empty when selection is empty', () => {
+            // arrange
+            const selection = new UserSelection(new ApplicationStub(), []);
+            const sut = new ApplicationCode(selection, 'version');
+            // act
+            const actual = sut.current;
+            // assert
+            expect(actual).to.have.lengthOf(0);
+        });
+        it('has code when selection is not empty', () => {
+            // arrange
+            const scripts = [new ScriptStub('first'), new ScriptStub('second')];
+            const app = new ApplicationStub().withAction(new CategoryStub(1).withScripts(...scripts));
+            const selection = new UserSelection(app, scripts);
+            const version = 'version-string';
+            const sut = new ApplicationCode(selection, version);
+            // act
+            const actual = sut.current;
+            // assert
+            expect(actual).to.have.length.greaterThan(0).and.include(version);
+        });
+    });
+    describe('user selection changes', () => {
+        it('empty when selection is empty', () => {
+            // arrange
+            let signaled: string;
+            const scripts = [new ScriptStub('first'), new ScriptStub('second')];
+            const app = new ApplicationStub().withAction(new CategoryStub(1).withScripts(...scripts));
+            const selection = new UserSelection(app, scripts);
+            const sut = new ApplicationCode(selection, 'version');
+            sut.changed.on((code) => signaled = code);
+            // act
+            selection.changed.notify([]);
+            // assert
+            expect(signaled).to.have.lengthOf(0);
+            expect(signaled).to.equal(sut.current);
+        });
+        it('has code when selection is not empty', () => {
+            // arrange
+            let signaled: string;
+            const scripts = [new ScriptStub('first'), new ScriptStub('second')];
+            const app = new ApplicationStub().withAction(new CategoryStub(1).withScripts(...scripts));
+            const selection = new UserSelection(app, scripts);
+            const version = 'version-string';
+            const sut = new ApplicationCode(selection, version);
+            sut.changed.on((code) => signaled = code);
+            // act
+            selection.changed.notify(scripts.map((s) => new SelectedScript(s, false)));
+            // assert
+            expect(signaled).to.have.length.greaterThan(0).and.include(version);
+            expect(signaled).to.equal(sut.current);
+        });
+    });
+});

tests/unit/application/State/Code/UserScriptGenerator.spec.ts

@@ -0,0 +1,54 @@
+import { ScriptStub } from './../../../stubs/ScriptStub';
+import { UserScriptGenerator, adminRightsScript } from '@/application/State/Code/UserScriptGenerator';
+import 'mocha';
+import { expect } from 'chai';
+import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+
+describe('UserScriptGenerator', () => {
+    it('adds version', () => {
+        const sut = new UserScriptGenerator();
+        // arrange
+        const version = '1.5.0';
+        const selectedScripts = [ new SelectedScript(new ScriptStub('id'), false)];
+        // act
+        const actual = sut.buildCode(selectedScripts, version);
+        // assert
+        expect(actual).to.include(version);
+    });
+    it('adds admin rights function', () => {
+        const sut = new UserScriptGenerator();
+        // arrange
+        const selectedScripts = [ new SelectedScript(new ScriptStub('id'), false)];
+        // act
+        const actual = sut.buildCode(selectedScripts, 'non-important-version');
+        // assert
+        expect(actual).to.include(adminRightsScript.code);
+        expect(actual).to.include(adminRightsScript.name);
+    });
+    it('appends revert script', () => {
+        const sut = new UserScriptGenerator();
+        // arrange
+        const scriptName = 'test non-revert script';
+        const scriptCode = 'REM nop';
+        const script = new ScriptStub('id').withName(scriptName).withRevertCode(scriptCode);
+        const selectedScripts = [ new SelectedScript(script, true)];
+        // act
+        const actual = sut.buildCode(selectedScripts, 'non-important-version');
+        // assert
+        expect(actual).to.include(`${scriptName} (revert)`);
+        expect(actual).to.include(scriptCode);
+    });
+    it('appends non-revert script', () => {
+        const sut = new UserScriptGenerator();
+        // arrange
+        const scriptName = 'test non-revert script';
+        const scriptCode = 'REM nop';
+        const script = new ScriptStub('id').withName(scriptName).withCode(scriptCode);
+        const selectedScripts = [ new SelectedScript(script, false)];
+        // act
+        const actual = sut.buildCode(selectedScripts, 'non-important-version');
+        // assert
+        expect(actual).to.include(scriptName);
+        expect(actual).to.include(scriptCode);
+    });
+});

tests/unit/application/State/Filter/FilterResult.spec.ts

@@ -0,0 +1,46 @@
+import { CategoryStub } from './../../../stubs/CategoryStub';
+import { ScriptStub } from './../../../stubs/ScriptStub';
+import { FilterResult } from '@/application/State/Filter/FilterResult';
+import 'mocha';
+import { expect } from 'chai';
+
+describe('FilterResult', () => {
+    describe('hasAnyMatches', () => {
+        it('false when no matches', () => {
+            const sut = new FilterResult(
+                /* scriptMatches */ [],
+                /* categoryMatches */ [],
+                'query',
+            );
+            const actual = sut.hasAnyMatches();
+            expect(actual).to.equal(false);
+        });
+        it('true when script matches', () => {
+            const sut = new FilterResult(
+                /* scriptMatches */ [ new ScriptStub('id') ],
+                /* categoryMatches */ [],
+                'query',
+            );
+            const actual = sut.hasAnyMatches();
+            expect(actual).to.equal(true);
+        });
+        it('true when category matches', () => {
+            const sut = new FilterResult(
+                /* scriptMatches */ [ ],
+                /* categoryMatches */ [ new CategoryStub(5) ],
+                'query',
+            );
+            const actual = sut.hasAnyMatches();
+            expect(actual).to.equal(true);
+        });
+        it('true when script + category matches', () => {
+            const sut = new FilterResult(
+                /* scriptMatches */ [ new ScriptStub('id') ],
+                /* categoryMatches */ [ new CategoryStub(5) ],
+                'query',
+            );
+            const actual = sut.hasAnyMatches();
+            expect(actual).to.equal(true);
+        });
+    });
+});

tests/unit/application/State/Filter/UserFilter.spec.ts

@@ -0,0 +1,135 @@
+import { CategoryStub } from './../../../stubs/CategoryStub';
+import { ScriptStub } from './../../../stubs/ScriptStub';
+import { IFilterResult } from '@/application/State/Filter/IFilterResult';
+import { ApplicationStub } from './../../../stubs/ApplicationStub';
+import { UserFilter } from '@/application/State/Filter/UserFilter';
+import 'mocha';
+import { expect } from 'chai';
+
+describe('UserFilter', () => {
+    it('signals when removing filter', () => {
+        // arrange
+        let isCalled = false;
+        const sut = new UserFilter(new ApplicationStub());
+        sut.filterRemoved.on(() => isCalled = true);
+        // act
+        sut.removeFilter();
+        // assert
+        expect(isCalled).to.be.equal(true);
+    });
+    it('signals when no matches', () => {
+        // arrange
+        let actual: IFilterResult;
+        const nonMatchingFilter = 'non matching filter';
+        const sut = new UserFilter(new ApplicationStub());
+        sut.filtered.on((filterResult) => actual = filterResult);
+        // act
+        sut.setFilter(nonMatchingFilter);
+        // assert
+        expect(actual.hasAnyMatches()).be.equal(false);
+        expect(actual.categoryMatches).to.have.lengthOf(0);
+        expect(actual.scriptMatches).to.have.lengthOf(0);
+        expect(actual.query).to.equal(nonMatchingFilter);
+    });
+    describe('signals when script matches', () => {
+        it('code matches', () => {
+            // arrange
+            const code = 'HELLO world';
+            const filter = 'Hello WoRLD';
+            let actual: IFilterResult;
+            const script = new ScriptStub('id').withCode(code);
+            const category = new CategoryStub(33).withScript(script);
+            const sut = new UserFilter(new ApplicationStub()
+                .withAction(category));
+            sut.filtered.on((filterResult) => actual = filterResult);
+            // act
+            sut.setFilter(filter);
+            // assert
+            expect(actual.hasAnyMatches()).be.equal(true);
+            expect(actual.categoryMatches).to.have.lengthOf(0);
+            expect(actual.scriptMatches).to.have.lengthOf(1);
+            expect(actual.scriptMatches[0]).to.deep.equal(script);
+            expect(actual.query).to.equal(filter);
+        });
+        it('revertCode matches', () => {
+            // arrange
+            const revertCode = 'HELLO world';
+            const filter = 'Hello WoRLD';
+            let actual: IFilterResult;
+            const script = new ScriptStub('id').withRevertCode(revertCode);
+            const category = new CategoryStub(33).withScript(script);
+            const sut = new UserFilter(new ApplicationStub()
+                .withAction(category));
+            sut.filtered.on((filterResult) => actual = filterResult);
+            // act
+            sut.setFilter(filter);
+            // assert
+            expect(actual.hasAnyMatches()).be.equal(true);
+            expect(actual.categoryMatches).to.have.lengthOf(0);
+            expect(actual.scriptMatches).to.have.lengthOf(1);
+            expect(actual.scriptMatches[0]).to.deep.equal(script);
+            expect(actual.query).to.equal(filter);
+        });
+        it('name matches', () => {
+            // arrange
+            const name = 'HELLO world';
+            const filter = 'Hello WoRLD';
+            let actual: IFilterResult;
+            const script = new ScriptStub('id').withName(name);
+            const category = new CategoryStub(33).withScript(script);
+            const sut = new UserFilter(new ApplicationStub()
+                .withAction(category));
+            sut.filtered.on((filterResult) => actual = filterResult);
+            // act
+            sut.setFilter(filter);
+            // assert
+            expect(actual.hasAnyMatches()).be.equal(true);
+            expect(actual.categoryMatches).to.have.lengthOf(0);
+            expect(actual.scriptMatches).to.have.lengthOf(1);
+            expect(actual.scriptMatches[0]).to.deep.equal(script);
+            expect(actual.query).to.equal(filter);
+        });
+    });
+    it('signals when category matches', () => {
+        // arrange
+        const categoryName = 'HELLO world';
+        const filter = 'Hello WoRLD';
+        let actual: IFilterResult;
+        const category = new CategoryStub(55).withName(categoryName);
+        const sut = new UserFilter(new ApplicationStub()
+            .withAction(category));
+        sut.filtered.on((filterResult) => actual = filterResult);
+        // act
+        sut.setFilter(filter);
+        // assert
+        expect(actual.hasAnyMatches()).be.equal(true);
+        expect(actual.categoryMatches).to.have.lengthOf(1);
+        expect(actual.categoryMatches[0]).to.deep.equal(category);
+        expect(actual.scriptMatches).to.have.lengthOf(0);
+        expect(actual.query).to.equal(filter);
+    });
+    it('signals when category and script matches', () => {
+        // arrange
+        const matchingText = 'HELLO world';
+        const filter = 'Hello WoRLD';
+        let actual: IFilterResult;
+        const script = new ScriptStub('script')
+            .withName(matchingText);
+        const category = new CategoryStub(55)
+            .withName(matchingText)
+            .withScript(script);
+        const app = new ApplicationStub()
+            .withAction(category);
+        const sut = new UserFilter(app);
+        sut.filtered.on((filterResult) => actual = filterResult);
+        // act
+        sut.setFilter(filter);
+        // assert
+        expect(actual.hasAnyMatches()).be.equal(true);
+        expect(actual.categoryMatches).to.have.lengthOf(1);
+        expect(actual.categoryMatches[0]).to.deep.equal(category);
+        expect(actual.scriptMatches).to.have.lengthOf(1);
+        expect(actual.scriptMatches[0]).to.deep.equal(script);
+        expect(actual.query).to.equal(filter);
+    });
+});

tests/unit/application/State/Selection/SelectedScript.spec.ts

@@ -0,0 +1,28 @@
+import { ScriptStub } from './../../../stubs/ScriptStub';
+import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+import 'mocha';
+import { expect } from 'chai';
+
+describe('SelectedScript', () => {
+    it('id is same as script id', () => {
+        // arrange
+        const expectedId = 'scriptId';
+        const script = new ScriptStub(expectedId);
+        const sut = new SelectedScript(script, false);
+        // act
+        const actualId = sut.id;
+        // assert
+        expect(actualId).to.equal(expectedId);
+    });
+    it('throws when revert is true for irreversible script', () => {
+        // arrange
+        const expectedId = 'scriptId';
+        const script = new ScriptStub(expectedId)
+            .withRevertCode(undefined);
+        // act
+        function construct() { new SelectedScript(script, true); } // tslint:disable-line:no-unused-expression
+        // assert
+        expect(construct).to.throw('cannot revert an irreversible script');
+    });
+
+});

tests/unit/application/State/Selection/UserSelection.spec.ts

@@ -0,0 +1,96 @@
+import { ScriptStub } from './../../../stubs/ScriptStub';
+import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+import { CategoryStub } from '../../../stubs/CategoryStub';
+import { ApplicationStub } from '../../../stubs/ApplicationStub';
+import { UserSelection } from '@/application/State/Selection/UserSelection';
+import 'mocha';
+import { expect } from 'chai';
+import { IScript } from '@/domain/IScript';
+
+describe('UserSelection', () => {
+    it('deselectAll removes all items', () => {
+        // arrange
+        const events: Array<readonly SelectedScript[]>  = [];
+        const app = new ApplicationStub()
+            .withAction(new CategoryStub(1)
+                .withScriptIds('s1', 's2', 's3', 's4'));
+        const selectedScripts = [new ScriptStub('s1'), new ScriptStub('s2'), new ScriptStub('s3')];
+        const sut = new UserSelection(app, selectedScripts);
+        sut.changed.on((newScripts) => events.push(newScripts));
+        // act
+        sut.deselectAll();
+        // assert
+        expect(sut.selectedScripts).to.have.length(0);
+        expect(events).to.have.lengthOf(1);
+        expect(events[0]).to.have.length(0);
+    });
+    it('selectOnly selects expected', () => {
+        // arrange
+        const events: Array<readonly SelectedScript[]>  = [];
+        const app = new ApplicationStub()
+            .withAction(new CategoryStub(1)
+                .withScriptIds('s1', 's2', 's3', 's4'));
+        const selectedScripts = [new ScriptStub('s1'), new ScriptStub('s2'), new ScriptStub('s3')];
+        const sut = new UserSelection(app, selectedScripts);
+        sut.changed.on((newScripts) => events.push(newScripts));
+        const scripts = [new ScriptStub('s2'), new ScriptStub('s3'), new ScriptStub('s4')];
+        const expected = scripts.map((script) => new SelectedScript(script, false));
+        // act
+        sut.selectOnly(scripts);
+        // assert
+        expect(sut.selectedScripts).to.deep.equal(expected);
+        expect(events).to.have.lengthOf(1);
+        expect(events[0]).to.deep.equal(expected);
+    });
+    it('selectAll selects as expected', () => {
+        // arrange
+        const events: Array<readonly SelectedScript[]>  = [];
+        const scripts: IScript[] = [new ScriptStub('s1'), new ScriptStub('s2'), new ScriptStub('s3'), new ScriptStub('s4')];
+        const app = new ApplicationStub()
+            .withAction(new CategoryStub(1)
+                .withScripts(...scripts));
+        const sut = new UserSelection(app, []);
+        sut.changed.on((newScripts) => events.push(newScripts));
+        const expected = scripts.map((script) => new SelectedScript(script, false));
+        // act
+        sut.selectAll();
+        // assert
+        expect(sut.selectedScripts).to.deep.equal(expected);
+        expect(events).to.have.lengthOf(1);
+        expect(events[0]).to.deep.equal(expected);
+    });
+    describe('addOrUpdateSelectedScript', () => {
+        it('adds when item does not exist', () => {
+            // arrange
+            const events: Array<readonly SelectedScript[]>  = [];
+            const app = new ApplicationStub()
+                .withAction(new CategoryStub(1)
+                    .withScripts(new ScriptStub('s1'), new ScriptStub('s2')));
+            const sut = new UserSelection(app, []);
+            sut.changed.on((scripts) => events.push(scripts));
+            const expected = [ new SelectedScript(new ScriptStub('s1'), false) ];
+            // act
+            sut.addOrUpdateSelectedScript('s1', false);
+            // assert
+            expect(sut.selectedScripts).to.deep.equal(expected);
+            expect(events).to.have.lengthOf(1);
+            expect(events[0]).to.deep.equal(expected);
+        });
+        it('updates when item exists', () => {
+            // arrange
+            const events: Array<readonly SelectedScript[]>  = [];
+            const app = new ApplicationStub()
+                .withAction(new CategoryStub(1)
+                    .withScripts(new ScriptStub('s1'), new ScriptStub('s2')));
+            const sut = new UserSelection(app, []);
+            sut.changed.on((scripts) => events.push(scripts));
+            const expected = [ new SelectedScript(new ScriptStub('s1'), true) ];
+            // act
+            sut.addOrUpdateSelectedScript('s1', true);
+            // assert
+            expect(sut.selectedScripts).to.deep.equal(expected);
+            expect(events).to.have.lengthOf(1);
+            expect(events[0]).to.deep.equal(expected);
+        });
+    });
+});

tests/unit/application/UserSelection.spec.ts

@@ -1,41 +0,0 @@
-import { CategoryStub } from './../stubs/CategoryStub';
-import { ApplicationStub } from './../stubs/ApplicationStub';
-import { ScriptStub } from './../stubs/ScriptStub';
-import { UserSelection } from '@/application/State/Selection/UserSelection';
-import 'mocha';
-import { expect } from 'chai';
-
-
-describe('UserSelection', () => {
-    it('deselectAll removes all items', async () => {
-        // arrange
-        const app = new ApplicationStub()
-            .withCategory(new CategoryStub(1)
-                .withScriptIds('s1', 's2', 's3', 's4'));
-        const selectedScripts = [new ScriptStub('s1'), new ScriptStub('s2'), new ScriptStub('s3')];
-        const sut = new UserSelection(app, selectedScripts);
-
-        // act
-        sut.deselectAll();
-        const actual = sut.selectedScripts;
-
-        // assert
-        expect(actual, JSON.stringify(sut.selectedScripts)).to.have.length(0);
-    });
-    it('selectOnly selects expected', async () => {
-        // arrange
-        const app = new ApplicationStub()
-            .withCategory(new CategoryStub(1)
-            .withScriptIds('s1', 's2', 's3', 's4'));
-        const selectedScripts = [new ScriptStub('s1'), new ScriptStub('s2'), new ScriptStub('s3')];
-        const sut = new UserSelection(app, selectedScripts);
-        const expected = [new ScriptStub('s2'), new ScriptStub('s3'), new ScriptStub('s4')];
-
-        // act
-        sut.selectOnly(expected);
-        const actual = sut.selectedScripts;
-
-        // assert
-        expect(actual).to.deep.equal(expected);
-    });
-});

tests/unit/domain/Script.spec.ts

@@ -3,15 +3,44 @@ import { expect } from 'chai';
 import { Script } from '@/domain/Script';
 
 describe('Script', () => {
-
+    describe('ctor', () => {
+        describe('code', () => {
             it('cannot construct with duplicate lines', () => {
-        // arrange
                 const code = 'duplicate\nduplicate\ntest\nduplicate';
-
+                expect(() => createWithCode(code)).to.throw();
-        // act
+            });
-        function construct() { return new Script('ScriptName', code, [], true); }
+            it('cannot construct with empty lines', () => {
-
+                const code = 'duplicate\n\n\ntest\nduplicate';
-        // assert
+                expect(() => createWithCode(code)).to.throw();
-        expect(construct).to.throw();
             });
         });
+        describe('revertCode', () => {
+            it('cannot construct with duplicate lines', () => {
+                const code = 'duplicate\nduplicate\ntest\nduplicate';
+                expect(() => createWithCode('REM', code)).to.throw();
+            });
+            it('cannot construct with empty lines', () => {
+                const code = 'duplicate\n\n\ntest\nduplicate';
+                expect(() => createWithCode('REM', code)).to.throw();
+            });
+            it('cannot construct with when same as code', () => {
+                const code = 'REM';
+                expect(() => createWithCode(code, code)).to.throw();
+            });
+        });
+        describe('canRevert', () => {
+            it('returns false without revert code', () => {
+                const sut = createWithCode('code');
+                expect(sut.canRevert()).to.equal(false);
+            });
+            it('returns true with revert code', () => {
+                const sut = createWithCode('code', 'non empty revert code');
+                expect(sut.canRevert()).to.equal(true);
+            });
+        });
+    });
+});
+
+function createWithCode(code: string, revertCode?: string): Script {
+    return new Script('name', code, revertCode, [], false);
+}

tests/unit/infrastructure/InMemoryRepository.spec.ts

@@ -8,15 +8,15 @@ describe('InMemoryRepository', () => {
             [new NumericEntityStub(1), new NumericEntityStub(2), new NumericEntityStub(3)]);
 
         describe('item exists', () => {
-            const actual = sut.exists(new NumericEntityStub(1));
+            const actual = sut.exists(1);
             it('returns true', () => expect(actual).to.be.true);
         });
         describe('item does not exist', () => {
-            const actual = sut.exists(new NumericEntityStub(99));
+            const actual = sut.exists(99);
             it('returns false', () => expect(actual).to.be.false);
         });
     });
-    it('can get', () => {
+    it('getItems gets initial items', () => {
         // arrange
         const expected = [
             new NumericEntityStub(1), new NumericEntityStub(2), new NumericEntityStub(3), new NumericEntityStub(4)];
@@ -28,7 +28,7 @@ describe('InMemoryRepository', () => {
         // assert
         expect(actual).to.deep.equal(expected);
     });
-    it('can add', () => {
+    it('addItem adds', () => {
         // arrange
         const sut = new InMemoryRepository<number, NumericEntityStub>();
         const expected = {
@@ -47,7 +47,7 @@ describe('InMemoryRepository', () => {
         expect(actual.length).to.equal(expected.length);
         expect(actual.item).to.deep.equal(expected.item);
     });
-    it('can remove', () => {
+    it('removeItem removes', () => {
         // arrange
         const initialItems = [
             new NumericEntityStub(1), new NumericEntityStub(2), new NumericEntityStub(3), new NumericEntityStub(4)];
@@ -69,4 +69,30 @@ describe('InMemoryRepository', () => {
         expect(actual.length).to.equal(expected.length);
         expect(actual.items).to.deep.equal(expected.items);
     });
+    describe('addOrUpdateItem', () => {
+        it('adds when item does not exist', () => {
+            // arrange
+            const initialItems = [ new NumericEntityStub(1), new NumericEntityStub(2) ];
+            const newItem = new NumericEntityStub(3);
+            const expected = [ ...initialItems, newItem ];
+            const sut = new InMemoryRepository<number, NumericEntityStub>(initialItems);
+            // act
+            sut.addOrUpdateItem(newItem);
+            // assert
+            const actual = sut.getItems();
+            expect(actual).to.deep.equal(expected);
+        });
+        it('updates when item exists', () => {
+            // arrange
+            const initialItems = [ new NumericEntityStub(1).withCustomProperty('bca') ];
+            const updatedItem = new NumericEntityStub(1).withCustomProperty('abc');
+            const expected = [ updatedItem ];
+            const sut = new InMemoryRepository<number, NumericEntityStub>(initialItems);
+            // act
+            sut.addOrUpdateItem(updatedItem);
+            // assert
+            const actual = sut.getItems();
+            expect(actual).to.deep.equal(expected);
+        });
+    });
 });

tests/unit/infrastructure/Signal.spec.ts

@@ -37,14 +37,18 @@ describe('Signal Tests', () => {
             receivers = [
                 new ReceiverMock(), new ReceiverMock(),
                 new ReceiverMock(), new ReceiverMock()];
-            for (const receiver of receivers) {
+            function subscribeReceiver(receiver: ReceiverMock) {
                 signal.on((arg) => receiver.onReceive(arg));
-            }});
+            }
+            for (const receiver of receivers) {
+                subscribeReceiver(receiver);
+            }
+        });
 
 
         it('notify() should execute all callbacks', () => {
             signal.notify(5);
-            receivers.every((receiver) => {
+            receivers.forEach((receiver) => {
                 expect(receiver.onRecieveCalls).to.have.length(1);
             });
         });
@@ -52,7 +56,7 @@ describe('Signal Tests', () => {
         it('notify() should execute all callbacks with payload', () => {
             const expected = 5;
             signal.notify(expected);
-            receivers.every((receiver) => {
+            receivers.forEach((receiver) => {
                 expect(receiver.onRecieveCalls).to.deep.equal([expected]);
             });
         });

tests/unit/stubs/ApplicationStub.ts

@@ -1,15 +1,15 @@
 import { IApplication, ICategory, IScript } from '@/domain/IApplication';
 
 export class ApplicationStub implements IApplication {
-    public readonly totalScripts = 0;
+    public totalScripts = 0;
-    public readonly totalCategories = 0;
+    public totalCategories = 0;
     public readonly name = 'StubApplication';
     public readonly repositoryUrl = 'https://privacy.sexy';
     public readonly version = '0.1.0';
-    public readonly categories = new Array<ICategory>();
+    public readonly actions = new Array<ICategory>();
 
-    public withCategory(category: ICategory): IApplication {
+    public withAction(category: ICategory): IApplication {
-        this.categories.push(category);
+        this.actions.push(category);
         return this;
     }
     public findCategory(categoryId: number): ICategory {
@@ -19,12 +19,51 @@ export class ApplicationStub implements IApplication {
         throw new Error('Method not implemented.');
     }
     public findScript(scriptId: string): IScript {
-        throw new Error('Method not implemented.');
+        return this.getAllScripts().find((script) => scriptId === script.id);
     }
     public getAllScripts(): ReadonlyArray<IScript> {
-        throw new Error('Method not implemented.');
+        const scripts = [];
+        for (const category of this.actions) {
+            const categoryScripts = getScriptsRecursively(category);
+            scripts.push(...categoryScripts);
+        }
+        return scripts;
     }
     public getAllCategories(): ReadonlyArray<ICategory> {
-        throw new Error('Method not implemented.');
+        const categories = [];
+        categories.push(...this.actions);
+        for (const category of this.actions) {
+            const subCategories = getSubCategoriesRecursively(category);
+            categories.push(...subCategories);
+        }
+        return categories;
     }
 }
+
+function getSubCategoriesRecursively(category: ICategory): ReadonlyArray<ICategory> {
+    const subCategories = [];
+    if (category.subCategories) {
+        for (const subCategory of category.subCategories) {
+            subCategories.push(subCategory);
+            subCategories.push(...getSubCategoriesRecursively(subCategory));
+        }
+    }
+    return subCategories;
+}
+
+
+function getScriptsRecursively(category: ICategory): ReadonlyArray<IScript> {
+    const categoryScripts = [];
+    if (category.scripts) {
+        for (const script of category.scripts) {
+            categoryScripts.push(script);
+        }
+    }
+    if (category.subCategories) {
+        for (const subCategory of category.subCategories) {
+            const subCategoryScripts = getScriptsRecursively(subCategory);
+            categoryScripts.push(...subCategoryScripts);
+        }
+    }
+    return categoryScripts;
+}

tests/unit/stubs/CategoryStub.ts

@@ -1,9 +1,9 @@
-import { ScriptStub } from './ScriptStub';
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
 import { ICategory, IScript } from '@/domain/ICategory';
+import { ScriptStub } from './ScriptStub';
 
 export class CategoryStub extends BaseEntity<number> implements ICategory  {
-    public readonly name = `category-with-id-${this.id}`;
+    public name = `category-with-id-${this.id}`;
     public readonly subCategories = new Array<ICategory>();
     public readonly scripts = new Array<IScript>();
     public readonly documentationUrls = new Array<string>();
@@ -13,14 +13,22 @@ export class CategoryStub extends BaseEntity<number> implements ICategory  {
     }
     public withScriptIds(...scriptIds: string[]): CategoryStub {
         for (const scriptId of scriptIds) {
-            this.scripts.push(new ScriptStub(scriptId));
+            this.withScript(new ScriptStub(scriptId));
         }
         return this;
     }
     public withScripts(...scripts: IScript[]): CategoryStub {
         for (const script of scripts) {
-            this.scripts.push(script);
+            this.withScript(script);
         }
         return this;
     }
+    public withScript(script: IScript): CategoryStub {
+        this.scripts.push(script);
+        return this;
+    }
+    public withName(categoryName: string) {
+        this.name = categoryName;
+        return this;
+    }
 }

tests/unit/stubs/NumericEntityStub.ts

@@ -1,7 +1,12 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
 
 export class NumericEntityStub extends BaseEntity<number> {
+    public customProperty = 'customProperty';
     constructor(id: number) {
         super(id);
     }
+    public withCustomProperty(value: string): NumericEntityStub {
+        this.customProperty = value;
+        return this;
+    }
 }

tests/unit/stubs/ScriptStub.ts

@@ -1,18 +1,34 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
-import { IScript } from './../../../src/domain/IScript';
+import { IScript } from '@/domain/IScript';
 
 export class ScriptStub extends BaseEntity<string> implements IScript {
-    public readonly name = `name${this.id}`;
+    public name = `name${this.id}`;
-    public readonly code = `name${this.id}`;
+    public code = `REM code${this.id}`;
+    public revertCode = `REM revertCode${this.id}`;
     public readonly documentationUrls = new Array<string>();
     public isRecommended = false;
 
     constructor(public readonly id: string) {
         super(id);
     }
+    public canRevert(): boolean {
+        return Boolean(this.revertCode);
+    }
 
     public withIsRecommended(value: boolean): ScriptStub {
         this.isRecommended = value;
         return this;
     }
+    public withCode(value: string): ScriptStub {
+        this.code = value;
+        return this;
+    }
+    public withName(name: string): ScriptStub {
+        this.name = name;
+        return this;
+    }
+    public withRevertCode(revertCode: string): ScriptStub {
+        this.revertCode = revertCode;
+        return this;
+    }
 }