From fe174793b992144c2480d3300ad919b6ccab2564 Mon Sep 17 00:00:00 2001
From: undergroundwires <undergroundwires@users.noreply.github.com>
Date: Sun, 22 Aug 2021 15:26:05 +0100
Subject: [PATCH] Add revert all toggle

- Also aligns items on top menu vertically
- Renames SelectionStatus to RecommentationLevel in the top menu to make
  it more clear.
- In App.vue it renames row class to `app__row` to avoid misusage as styles are not scoped in it.
- In ScriptsArea, remove unintended row class refering to global style,
 make styling menu class more verbose and lower bottom margin.
- Change category toggle so its status become reverted when all of its
  reversible scripts are reverted, before it did not care about
  reversible scripts but required all scripts to be reverted. If a
  category has no reversible scripts, revert toggle returns false.
---
 .github/ISSUE_TEMPLATE/3-feature-request.md   |  11 ++
 .../Context/State/Selection/IUserSelection.ts |   1 +
 .../Context/State/Selection/UserSelection.ts  |  32 +++--
 src/domain/UserScriptPosition.ts              |   8 ++
 src/presentation/components/App.vue           |  10 +-
 .../components/Scripts/Menu/MenuOption.vue    |   6 +-
 .../RecommendationStatusHandler.ts}           |  29 ++---
 .../RecommendationStatusType.ts               |   7 ++
 .../TheRecommendationSelector.vue}            |  39 +++---
 .../Menu/Revert/RevertStatusHandler.ts        |  29 +++++
 .../Scripts/Menu/Revert/RevertStatusType.ts   |   6 +
 .../Scripts/Menu/Revert/TheRevertSelector.vue |  72 +++++++++++
 .../Scripts/Menu/TheScriptsMenu.vue           |  26 ++--
 .../components/Scripts/TheScriptArea.vue      |   6 +-
 .../Node/Reverter/CategoryReverter.ts         |   8 +-
 .../State/Selection/SelectedScript.spec.ts    |   1 -
 .../State/Selection/UserSelection.spec.ts     | 103 ++++++++++++++++
 .../RecommendationStatusHandler.spec.ts}      |  59 ++++-----
 .../RecommendationStatusTestScenario.ts}      |   2 +-
 .../Menu/Revert/RevertStatusHandler.spec.ts   | 106 +++++++++++++++++
 .../Node/Reverter/CategoryReverter.spec.ts    | 112 +++++++++++++++---
 tests/unit/stubs/ScriptStub.ts                |  13 +-
 tests/unit/stubs/UserSelectionStub.ts         |   3 +
 23 files changed, 566 insertions(+), 123 deletions(-)
 create mode 100644 src/domain/UserScriptPosition.ts
 rename src/presentation/components/Scripts/Menu/{Selector/SelectionTypeHandler.ts => Recommendation/RecommendationStatusHandler.ts} (77%)
 create mode 100644 src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusType.ts
 rename src/presentation/components/Scripts/Menu/{Selector/TheSelector.vue => Recommendation/TheRecommendationSelector.vue} (60%)
 create mode 100644 src/presentation/components/Scripts/Menu/Revert/RevertStatusHandler.ts
 create mode 100644 src/presentation/components/Scripts/Menu/Revert/RevertStatusType.ts
 create mode 100644 src/presentation/components/Scripts/Menu/Revert/TheRevertSelector.vue
 rename tests/unit/presentation/components/Scripts/Menu/{Selector/SelectionTypeHandler.spec.ts => Recommendation/RecommendationStatusHandler.spec.ts} (66%)
 rename tests/unit/presentation/components/Scripts/Menu/{Selector/SelectionStateTestScenario.ts => Recommendation/RecommendationStatusTestScenario.ts} (97%)
 create mode 100644 tests/unit/presentation/components/Scripts/Menu/Revert/RevertStatusHandler.spec.ts

diff --git a/.github/ISSUE_TEMPLATE/3-feature-request.md b/.github/ISSUE_TEMPLATE/3-feature-request.md
index 99a34742b..d9c1aebe5 100644
--- a/.github/ISSUE_TEMPLATE/3-feature-request.md
+++ b/.github/ISSUE_TEMPLATE/3-feature-request.md
@@ -5,6 +5,7 @@ labels: enhancement
 ---
 
 <!--
+<<<<<<< HEAD
 Thank you for suggesting an idea to improve privacy better 🤗.
 Please fill in as much of the template below as you're able.
 -->
@@ -15,6 +16,16 @@ Please fill in as much of the template below as you're able.
 What are we trying to solve?
 Please add a clear and concise description of the problem you are seeking to solve with this feature request.
 E.g. I'm always frustrated when [...]
+=======
+Thank you for suggesting an idea to make privacy better. 🤗
+Please fill in as much of the template below as you're able.
+-->
+
+### Problem Description
+
+<!--
+Please add a clear and concise description of the problem you are seeking to solve with this feature request. Ex. I'm always frustrated when [...]
+>>>>>>> 6f2a8f8... Add issue template for suggesting new scripts
 -->
 
 ### Proposed solution
diff --git a/src/application/Context/State/Selection/IUserSelection.ts b/src/application/Context/State/Selection/IUserSelection.ts
index 0cc991b88..134c71dca 100644
--- a/src/application/Context/State/Selection/IUserSelection.ts
+++ b/src/application/Context/State/Selection/IUserSelection.ts
@@ -12,6 +12,7 @@ export interface IUserSelection {
     addOrUpdateAllInCategory(categoryId: number, revert: boolean): void;
     addSelectedScript(scriptId: string, revert: boolean): void;
     addOrUpdateSelectedScript(scriptId: string, revert: boolean): void;
+    addOrUpdateAll(scripts: readonly ISelectedScript[]): void;
     removeSelectedScript(scriptId: string): void;
     selectOnly(scripts: ReadonlyArray<IScript>): void;
     isSelected(scriptId: string): boolean;
diff --git a/src/application/Context/State/Selection/UserSelection.ts b/src/application/Context/State/Selection/UserSelection.ts
index 3aab3d0e7..adca71b59 100644
--- a/src/application/Context/State/Selection/UserSelection.ts
+++ b/src/application/Context/State/Selection/UserSelection.ts
@@ -57,18 +57,8 @@ export class UserSelection implements IUserSelection {
     public addOrUpdateAllInCategory(categoryId: number, revert: boolean = false): void {
         const category = this.collection.findCategory(categoryId);
         const scriptsToAddOrUpdate = category.getAllScriptsRecursively()
-            .filter((script) =>
-                !this.scripts.exists(script.id)
-                    || this.scripts.getById(script.id).revert !== revert,
-            );
-        if (!scriptsToAddOrUpdate.length) {
-            return;
-        }
-        for (const script of scriptsToAddOrUpdate) {
-            const selectedScript = new SelectedScript(script, revert);
-            this.scripts.addOrUpdateItem(selectedScript);
-        }
-        this.changed.notify(this.scripts.getItems());
+            .map((script) => new SelectedScript(script, revert));
+        this.addOrUpdateAll(scriptsToAddOrUpdate);
     }
 
     public addSelectedScript(scriptId: string, revert: boolean): void {
@@ -139,4 +129,22 @@ export class UserSelection implements IUserSelection {
         }
         this.changed.notify(this.scripts.getItems());
     }
+
+    public addOrUpdateAll(scripts: readonly SelectedScript[]): void {
+        if (!scripts.length) {
+            return;
+        }
+        const scriptsToAddOrUpdate = scripts
+            .filter((script) =>
+                !this.scripts.exists(script.id)
+                    || this.scripts.getById(script.id).revert !== script.revert,
+            );
+        if (!scriptsToAddOrUpdate.length) {
+            return;
+        }
+        for (const script of scriptsToAddOrUpdate) {
+            this.scripts.addOrUpdateItem(script);
+        }
+        this.changed.notify(this.scripts.getItems());
+    }
 }
diff --git a/src/domain/UserScriptPosition.ts b/src/domain/UserScriptPosition.ts
new file mode 100644
index 000000000..8538a1a8e
--- /dev/null
+++ b/src/domain/UserScriptPosition.ts
@@ -0,0 +1,8 @@
+/* Represents preferred position in generated user script */
+export class ScriptPosition {
+    constructor(
+        public readonly positionInFile: number,
+        public readonly positionInCategory: number) {
+
+    }
+}
diff --git a/src/presentation/components/App.vue b/src/presentation/components/App.vue
index a0cd601a1..531b69187 100644
--- a/src/presentation/components/App.vue
+++ b/src/presentation/components/App.vue
@@ -1,10 +1,10 @@
 <template>
   <div id="app">
       <div class="wrapper">
-        <TheHeader class="row" />
-        <TheSearchBar class="row" />
-        <TheScriptArea class="row" />
-        <TheCodeButtons class="row code-buttons" />
+        <TheHeader class="app__row" />
+        <TheSearchBar class="app__row" />
+        <TheScriptArea class="app__row" />
+        <TheCodeButtons class="app__row code-buttons" />
         <TheFooter />
       </div>
    </div>
@@ -58,7 +58,7 @@ body {
     padding: 2%;
     display:flex;
     flex-direction: column;
-    .row {
+    .app__row {
       margin-bottom: 10px;
     }
     .code-buttons {
diff --git a/src/presentation/components/Scripts/Menu/MenuOption.vue b/src/presentation/components/Scripts/Menu/MenuOption.vue
index 353b3c57f..a8b981504 100644
--- a/src/presentation/components/Scripts/Menu/MenuOption.vue
+++ b/src/presentation/components/Scripts/Menu/MenuOption.vue
@@ -9,16 +9,12 @@
 
 <script lang="ts">
 import { Component, Prop, Emit, Vue } from 'vue-property-decorator';
-import { NonCollapsing } from '@/presentation/components/Scripts/Cards/NonCollapsingDirective';
+import { NonCollapsing } from '@/presentation/components/Scripts/View/Cards/NonCollapsingDirective';
 
 @Component({
     directives: { NonCollapsing },
 })
-<<<<<<< HEAD:src/presentation/components/Scripts/Menu/MenuOptionListItem.vue
 export default class MenuOptionListItem extends Vue {
-=======
-export default class MenuOption extends Vue {
->>>>>>> 25de66d... Fix excessive highlighting on hover:src/presentation/components/Scripts/Menu/MenuOption.vue
   @Prop() public enabled: boolean;
   @Prop() public label: string;
   @Emit('click') public onClicked() { return; }
diff --git a/src/presentation/components/Scripts/Menu/Selector/SelectionTypeHandler.ts b/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.ts
similarity index 77%
rename from src/presentation/components/Scripts/Menu/Selector/SelectionTypeHandler.ts
rename to src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.ts
index 7ea9c9216..752aaf4c8 100644
--- a/src/presentation/components/Scripts/Menu/Selector/SelectionTypeHandler.ts
+++ b/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.ts
@@ -3,33 +3,26 @@ import { ISelectedScript } from '@/application/Context/State/Selection/ISelected
 import { RecommendationLevel } from '@/domain/RecommendationLevel';
 import { scrambledEqual } from '@/application/Common/Array';
 import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
+import { RecommendationStatusType } from './RecommendationStatusType';
 
-export enum SelectionType {
-    Standard,
-    Strict,
-    All,
-    None,
-    Custom,
-}
-
-export class SelectionTypeHandler {
+export class RecommendationStatusHandler {
     constructor(private readonly state: ICategoryCollectionState) {
         if (!state) { throw new Error('undefined state'); }
     }
-    public selectType(type: SelectionType) {
-        if (type === SelectionType.Custom) {
+    public setRecommendationStatusType(type: RecommendationStatusType) {
+        if (type === RecommendationStatusType.Custom) {
             throw new Error('cannot select custom type');
         }
         const selector = selectors.get(type);
         selector.select(this.state);
     }
-    public getCurrentSelectionType(): SelectionType {
+    public getCurrentRecommendationStatusType(): RecommendationStatusType {
         for (const [type, selector] of Array.from(selectors.entries())) {
             if (selector.isSelected(this.state)) {
                 return type;
             }
         }
-        return SelectionType.Custom;
+        return RecommendationStatusType.Custom;
     }
 }
 
@@ -38,16 +31,16 @@ interface ISingleTypeHandler {
     select: (state: ICategoryCollectionState) => void;
 }
 
-const selectors = new Map<SelectionType, ISingleTypeHandler>([
-    [SelectionType.None, {
+const selectors = new Map<RecommendationStatusType, ISingleTypeHandler>([
+    [RecommendationStatusType.None, {
         select: (state) =>
             state.selection.deselectAll(),
         isSelected: (state) =>
             state.selection.selectedScripts.length === 0,
     }],
-    [SelectionType.Standard, getRecommendationLevelSelector(RecommendationLevel.Standard)],
-    [SelectionType.Strict, getRecommendationLevelSelector(RecommendationLevel.Strict)],
-    [SelectionType.All, {
+    [RecommendationStatusType.Standard, getRecommendationLevelSelector(RecommendationLevel.Standard)],
+    [RecommendationStatusType.Strict, getRecommendationLevelSelector(RecommendationLevel.Strict)],
+    [RecommendationStatusType.All, {
         select: (state) =>
             state.selection.selectAll(),
         isSelected: (state) =>
diff --git a/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusType.ts b/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusType.ts
new file mode 100644
index 000000000..e9a5bb7dd
--- /dev/null
+++ b/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusType.ts
@@ -0,0 +1,7 @@
+export enum RecommendationStatusType {
+    Standard,
+    Strict,
+    All,
+    None,
+    Custom,
+}
diff --git a/src/presentation/components/Scripts/Menu/Selector/TheSelector.vue b/src/presentation/components/Scripts/Menu/Recommendation/TheRecommendationSelector.vue
similarity index 60%
rename from src/presentation/components/Scripts/Menu/Selector/TheSelector.vue
rename to src/presentation/components/Scripts/Menu/Recommendation/TheRecommendationSelector.vue
index 2053c2201..cf2e261e7 100644
--- a/src/presentation/components/Scripts/Menu/Selector/TheSelector.vue
+++ b/src/presentation/components/Scripts/Menu/Recommendation/TheRecommendationSelector.vue
@@ -2,31 +2,31 @@
     <MenuOptionList label="Select">
         <MenuOptionListItem
             label="None"
-            :enabled="this.currentSelection !== SelectionType.None"
-            @click="selectType(SelectionType.None)"
+            :enabled="this.currentSelection !== RecommendationStatusType.None"
+            @click="setRecommendationStatusType(RecommendationStatusType.None)"
             v-tooltip=" 'Deselect all selected scripts.<br/>' +
                         '💡 Good start to dive deeper into tweaks and select only what you want.'"
             />
         <MenuOptionListItem
             label="Standard"
-            :enabled="this.currentSelection !== SelectionType.Standard"
-            @click="selectType(SelectionType.Standard)"
+            :enabled="this.currentSelection !== RecommendationStatusType.Standard"
+            @click="setRecommendationStatusType(RecommendationStatusType.Standard)"
             v-tooltip=" '🛡️ Balanced for privacy and functionality.<br/>' +
                         'OS and applications will function normally.<br/>' +
                         '💡 Recommended for everyone'"
             />
         <MenuOptionListItem
             label="Strict"
-            :enabled="this.currentSelection !== SelectionType.Strict"
-            @click="selectType(SelectionType.Strict)"
+            :enabled="this.currentSelection !== RecommendationStatusType.Strict"
+            @click="setRecommendationStatusType(RecommendationStatusType.Strict)"
             v-tooltip=" '🚫 Stronger privacy, disables risky functions that may leak your data.<br/>' +
                         '⚠️ Double check to remove scripts where you would trade functionality for privacy<br/>' +
                         '💡 Recommended for daily users that prefers more privacy over non-essential functions'"
             />
         <MenuOptionListItem
             label="All"
-            :enabled="this.currentSelection !== SelectionType.All"
-            @click="selectType(SelectionType.All)"
+            :enabled="this.currentSelection !== RecommendationStatusType.All"
+            @click="setRecommendationStatusType(RecommendationStatusType.All)"
             v-tooltip=" '🔒 Strongest privacy, disabling any functionality that may leak your data.<br/>' +
                         '🛑 Not designed for daily users, it will break important functionalities.<br/>' +
                         '💡 Only recommended for extreme use-cases like crime labs where no leak is acceptable'"
@@ -35,12 +35,13 @@
 </template>
 
 <script lang="ts">
+import MenuOptionList from '../MenuOptionList.vue';
+import MenuOptionListItem from '../MenuOptionListItem.vue';
 import { Component } from 'vue-property-decorator';
 import { StatefulVue } from '@/presentation/components/Shared/StatefulVue';
 import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
-import { SelectionType, SelectionTypeHandler } from './SelectionTypeHandler';
-import MenuOptionList from './../MenuOptionList.vue';
-import MenuOptionListItem from '../MenuOptionListItem.vue';
+import { RecommendationStatusHandler } from './RecommendationStatusHandler';
+import { RecommendationStatusType } from './RecommendationStatusType';
 
 @Component({
   components: {
@@ -48,27 +49,27 @@ import MenuOptionListItem from '../MenuOptionListItem.vue';
     MenuOptionListItem,
   },
 })
-export default class TheSelector extends StatefulVue {
-    public SelectionType = SelectionType;
-    public currentSelection = SelectionType.None;
-    private selectionTypeHandler: SelectionTypeHandler;
+export default class TheRecommendationSelector extends StatefulVue {
+    public RecommendationStatusType = RecommendationStatusType;
+    public currentSelection = RecommendationStatusType.None;
+    private selectionStatusTypeHandler: RecommendationStatusHandler;
 
-    public async selectType(type: SelectionType) {
+    public setRecommendationStatusType(type: RecommendationStatusType) {
         if (this.currentSelection === type) {
             return;
         }
-        this.selectionTypeHandler.selectType(type);
+        this.selectionStatusTypeHandler.setRecommendationStatusType(type);
     }
 
     protected handleCollectionState(newState: ICategoryCollectionState): void {
         this.events.unsubscribeAll();
-        this.selectionTypeHandler = new SelectionTypeHandler(newState);
+        this.selectionStatusTypeHandler = new RecommendationStatusHandler(newState);
         this.updateSelections();
         this.events.register(newState.selection.changed.on(() => this.updateSelections()));
     }
 
     private updateSelections() {
-       this.currentSelection = this.selectionTypeHandler.getCurrentSelectionType();
+       this.currentSelection = this.selectionStatusTypeHandler.getCurrentRecommendationStatusType();
     }
 }
 
diff --git a/src/presentation/components/Scripts/Menu/Revert/RevertStatusHandler.ts b/src/presentation/components/Scripts/Menu/Revert/RevertStatusHandler.ts
new file mode 100644
index 000000000..909b9e222
--- /dev/null
+++ b/src/presentation/components/Scripts/Menu/Revert/RevertStatusHandler.ts
@@ -0,0 +1,29 @@
+import { SelectedScript } from '@/application/Context/State/Selection/SelectedScript';
+import { RevertStatusType } from './RevertStatusType';
+import { IUserSelection } from '@/application/Context/State/Selection/IUserSelection';
+
+export class RevertStatusHandler {
+    public getCurrentStatusType(scripts: readonly SelectedScript[]): RevertStatusType {
+        const allRevertStatuses = getReversibleScripts(scripts)
+            .map((script) => script.revert);
+        if (!allRevertStatuses.length) {
+            return RevertStatusType.NothingIsReversible;
+        }
+        if (allRevertStatuses.every((c) => c === true)) {
+            return RevertStatusType.AllReverted;
+        }
+        if (allRevertStatuses.every((c) => c === false)) {
+            return RevertStatusType.NoneReverted;
+        }
+        return RevertStatusType.SomeReverted;
+    }
+    public setType(revert: boolean, selection: IUserSelection) {
+        const scriptsToChange = getReversibleScripts(selection.selectedScripts)
+            .map((script) => new SelectedScript(script.script, revert));
+        selection.addOrUpdateAll(scriptsToChange);
+    }
+}
+
+function getReversibleScripts(scripts: readonly SelectedScript[]) {
+    return scripts.filter((script) => script.script.canRevert());
+}
diff --git a/src/presentation/components/Scripts/Menu/Revert/RevertStatusType.ts b/src/presentation/components/Scripts/Menu/Revert/RevertStatusType.ts
new file mode 100644
index 000000000..62eabddff
--- /dev/null
+++ b/src/presentation/components/Scripts/Menu/Revert/RevertStatusType.ts
@@ -0,0 +1,6 @@
+export enum RevertStatusType {
+    NothingIsReversible,
+    NoneReverted,
+    SomeReverted,
+    AllReverted,
+}
diff --git a/src/presentation/components/Scripts/Menu/Revert/TheRevertSelector.vue b/src/presentation/components/Scripts/Menu/Revert/TheRevertSelector.vue
new file mode 100644
index 000000000..136fe54fe
--- /dev/null
+++ b/src/presentation/components/Scripts/Menu/Revert/TheRevertSelector.vue
@@ -0,0 +1,72 @@
+<template>
+    <MenuOptionList
+        label="Revert"
+        v-if="this.currentStatus !== RevertStatusType.a">
+        <MenuOptionListItem
+            label="All"
+            :enabled="canSetStatus(RevertStatusType.AllReverted)"
+            @click="setRevertTypeAsync(true)"
+            v-tooltip=" '⏩ Sets all scripts on apply mode to protect privacy.<br/>' +
+                        '⚠️ Increases privacy but non-recommended scripts can break things.<br/>' "
+            />
+        <MenuOptionListItem
+            label="None"
+            :enabled="canSetStatus(RevertStatusType.NoneReverted)"
+            @click="setRevertTypeAsync(false)"
+            v-tooltip=" '↩️ Sets all scripts on revert mode.<br/>' +
+                        '⚠️ Restores settings but reduces privacy.<br/>' "
+            />
+    </MenuOptionList>
+</template>
+
+<script lang="ts">
+import MenuOptionList from '../MenuOptionList.vue';
+import MenuOptionListItem from '../MenuOptionListItem.vue';
+import { Component } from 'vue-property-decorator';
+import { StatefulVue } from '@/presentation/components/Shared/StatefulVue';
+import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
+import { RevertStatusHandler } from './RevertStatusHandler';
+import { RevertStatusType } from './RevertStatusType';
+
+@Component({
+  components: {
+    MenuOptionList,
+    MenuOptionListItem,
+  },
+})
+export default class TheRevertSelector extends StatefulVue {
+    public RevertStatusType = RevertStatusType;
+    public currentStatus = RevertStatusType.NothingIsReversible;
+    private revertStatusHandler = new RevertStatusHandler();
+
+    public async setRevertTypeAsync(revert: boolean) {
+        const context = await this.getCurrentContextAsync();
+        this.revertStatusHandler.setType(revert, context.state.selection);
+    }
+
+    public canSetStatus(status: RevertStatusType): boolean {
+        if (this.currentStatus === RevertStatusType.NothingIsReversible) {
+            return false;
+        }
+        if (this.currentStatus === RevertStatusType.SomeReverted) {
+            return true;
+        }
+        return this.currentStatus !== status;
+    }
+
+    protected handleCollectionState(newState: ICategoryCollectionState): void {
+        this.events.unsubscribeAll();
+        this.updateStatuses(newState);
+        this.events.register(newState.selection.changed.on(() => this.updateStatuses(newState)));
+    }
+
+    private updateStatuses(state: ICategoryCollectionState) {
+       this.currentStatus = this.revertStatusHandler.getCurrentStatusType(state.selection.selectedScripts);
+    }
+}
+
+</script>
+
+<style scoped lang="scss">
+
+</style>
diff --git a/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue b/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
index b66026ec4..a4b066203 100644
--- a/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
+++ b/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
@@ -1,28 +1,33 @@
 <template>
     <div id="container">
-        <TheSelector class="item" />
-        <TheOsChanger class="item"  />
-        <TheViewChanger
-            class="item"
-            v-on:viewChanged="$emit('viewChanged', $event)"
-            v-if="!this.isSearching" />
+      <div class="item rows">
+        <TheRecommendationSelector class="item" />
+        <TheRevertSelector class="item"  />
+      </div>
+      <TheOsChanger class="item"  />
+      <TheViewChanger
+          class="item"
+          v-on:viewChanged="$emit('viewChanged', $event)"
+          v-if="!this.isSearching" />
     </div>
 </template>
 
 <script lang="ts">
 import { Component } from 'vue-property-decorator';
 import TheOsChanger from './TheOsChanger.vue';
-import TheSelector from './Selector/TheSelector.vue';
 import TheViewChanger from './View/TheViewChanger.vue';
+import TheRecommendationSelector from './Recommendation/TheRecommendationSelector.vue';
+import TheRevertSelector from './Revert/TheRevertSelector.vue';
 import { StatefulVue } from '@/presentation/components/Shared/StatefulVue';
 import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
 import { IEventSubscription } from '@/infrastructure/Events/IEventSource';
 
 @Component({
   components: {
-    TheSelector,
+    TheRecommendationSelector,
     TheOsChanger,
     TheViewChanger,
+    TheRevertSelector,
   },
 })
 export default class TheScriptsMenu extends StatefulVue {
@@ -73,5 +78,10 @@ export default class TheScriptsMenu extends StatefulVue {
             justify-content: flex-end;
         }
     }
+    .rows {
+      display: flex;
+      flex-direction: column;
+      align-items: flex-start;
+    }
 }
 </style>
diff --git a/src/presentation/components/Scripts/TheScriptArea.vue b/src/presentation/components/Scripts/TheScriptArea.vue
index 889cb5a92..96a3365cb 100644
--- a/src/presentation/components/Scripts/TheScriptArea.vue
+++ b/src/presentation/components/Scripts/TheScriptArea.vue
@@ -1,7 +1,7 @@
 <template>
 <div class="scripts">
     <TheScriptsMenu v-on:viewChanged="currentView = $event" />
-    <HorizontalResizeSlider class="row">
+    <HorizontalResizeSlider>
         <template v-slot:left>
             <TheScriptsView :currentView="currentView" />
         </template>
@@ -35,8 +35,8 @@ export default class TheScriptArea extends Vue {
 
 <style scoped lang="scss">
 .scripts {
-    > * + * {
-        margin-top: 15px;
+    .menu {
+        margin-bottom: 6px;
     }
 }
 ::v-deep .left {
diff --git a/src/presentation/components/Scripts/View/ScriptsTree/SelectableTree/Node/Reverter/CategoryReverter.ts b/src/presentation/components/Scripts/View/ScriptsTree/SelectableTree/Node/Reverter/CategoryReverter.ts
index 07565cf1f..3abd21be4 100644
--- a/src/presentation/components/Scripts/View/ScriptsTree/SelectableTree/Node/Reverter/CategoryReverter.ts
+++ b/src/presentation/components/Scripts/View/ScriptsTree/SelectableTree/Node/Reverter/CategoryReverter.ts
@@ -13,6 +13,10 @@ export class CategoryReverter implements IReverter {
         this.scriptReverters = getAllSubScriptReverters(this.categoryId, collection);
     }
     public getState(selectedScripts: ReadonlyArray<ISelectedScript>): boolean {
+        if (!this.scriptReverters.length) {
+            // Scripts under category are not reversible
+            return false;
+        }
         return this.scriptReverters.every((script) => script.getState(selectedScripts));
     }
     public selectWithRevertState(newState: boolean, selection: IUserSelection): void {
@@ -25,6 +29,8 @@ function getAllSubScriptReverters(categoryId: number, collection: ICategoryColle
     if (!category) {
         throw new Error(`Category with id "${categoryId}" does not exist`);
     }
-    const scripts = category.getAllScriptsRecursively();
+    const scripts = category
+        .getAllScriptsRecursively()
+        .filter((script) => script.canRevert());
     return scripts.map((script) => new ScriptReverter(script.id));
 }
diff --git a/tests/unit/application/Context/State/Selection/SelectedScript.spec.ts b/tests/unit/application/Context/State/Selection/SelectedScript.spec.ts
index 8044cbce1..704243de7 100644
--- a/tests/unit/application/Context/State/Selection/SelectedScript.spec.ts
+++ b/tests/unit/application/Context/State/Selection/SelectedScript.spec.ts
@@ -24,5 +24,4 @@ describe('SelectedScript', () => {
         // assert
         expect(construct).to.throw('cannot revert an irreversible script');
     });
-
 });
diff --git a/tests/unit/application/Context/State/Selection/UserSelection.spec.ts b/tests/unit/application/Context/State/Selection/UserSelection.spec.ts
index 9c8c2b4a6..42ea1d5ad 100644
--- a/tests/unit/application/Context/State/Selection/UserSelection.spec.ts
+++ b/tests/unit/application/Context/State/Selection/UserSelection.spec.ts
@@ -185,6 +185,109 @@ describe('UserSelection', () => {
                 .expectFinalScripts([]);
         });
     });
+    describe('addOrUpdateAll', () => {
+        describe('when all already exists', () => {
+            describe('does nothing if nothing is changed', () => {
+                // arrange
+                const existingScripts = [
+                    new SelectedScriptStub('s1', false),
+                    new SelectedScriptStub('s2', false),
+                ];
+                new UserSelectionTestRunner()
+                    .withSelectedScripts(existingScripts)
+                // act
+                    .run((sut) => {
+                        sut.addOrUpdateAll(existingScripts);
+                    })
+                // assert
+                    .expectTotalFiredEvents(0)
+                    .expectFinalScripts(existingScripts);
+            });
+            describe('updates revert status if some are changed', () => {
+                // arrange
+                const existingScripts = [
+                    new SelectedScriptStub('s1', false),
+                    new SelectedScriptStub('s2', false),
+                ];
+                const changedScripts = [
+                    new SelectedScriptStub('s1', true),  // Changed
+                    new SelectedScriptStub('s2', false),
+                ];
+                new UserSelectionTestRunner()
+                    .withSelectedScripts(existingScripts)
+                // act
+                    .run((sut) => {
+                        sut.addOrUpdateAll(changedScripts);
+                    })
+                // assert
+                    .expectTotalFiredEvents(1)
+                    .expectFinalScripts(changedScripts)
+                    .expectFinalScriptsInEvent(0, changedScripts);
+            });
+            describe('updates revert status if all are changed', () => {
+                // arrange
+                const existingScripts = [
+                    new SelectedScriptStub('s1', false),
+                    new SelectedScriptStub('s2', false),
+                ];
+                const changedScripts = [
+                    new SelectedScriptStub('s1', true),
+                    new SelectedScriptStub('s2', true),
+                ];
+                new UserSelectionTestRunner()
+                    .withSelectedScripts(existingScripts)
+                // act
+                    .run((sut) => {
+                        sut.addOrUpdateAll(changedScripts);
+                    })
+                // assert
+                    .expectTotalFiredEvents(1)
+                    .expectFinalScripts(changedScripts)
+                    .expectFinalScriptsInEvent(0, changedScripts);
+            });
+        });
+        describe('when nothing exists; adds all', () => {
+            // arrange
+            const newScripts = [
+                new SelectedScriptStub('s1', false),
+                new SelectedScriptStub('s2', true),
+            ];
+            new UserSelectionTestRunner()
+                .withSelectedScripts([])
+                .withCategory(1, newScripts.map((s) => s.script))
+            // act
+                .run((sut) => {
+                    sut.addOrUpdateAll(newScripts);
+                })
+            // assert
+                .expectTotalFiredEvents(1)
+                .expectFinalScripts(newScripts)
+                .expectFinalScriptsInEvent(0, newScripts);
+        });
+        describe('when some exists; changes revert status of all', () => {
+            // arrange
+            const existingScripts = [
+                new SelectedScriptStub('s1', false),
+                new SelectedScriptStub('s2', true),
+            ];
+            const newScripts = [
+                new SelectedScriptStub('s1', true),
+                new SelectedScriptStub('s2', false),
+                new SelectedScriptStub('s3', true),
+            ];
+            new UserSelectionTestRunner()
+                .withSelectedScripts(existingScripts)
+                .withCategory(1, [ ...existingScripts, ...newScripts].map((s) => s.script))
+            // act
+                .run((sut) => {
+                    sut.addOrUpdateAll(newScripts);
+                })
+            // assert
+                .expectTotalFiredEvents(1)
+                .expectFinalScripts(newScripts)
+                .expectFinalScriptsInEvent(0, newScripts);
+        });
+    });
     describe('addOrUpdateAllInCategory', () => {
         describe('when all already exists', () => {
             describe('does nothing if nothing is changed', () => {
diff --git a/tests/unit/presentation/components/Scripts/Menu/Selector/SelectionTypeHandler.spec.ts b/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.spec.ts
similarity index 66%
rename from tests/unit/presentation/components/Scripts/Menu/Selector/SelectionTypeHandler.spec.ts
rename to tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.spec.ts
index c453a80f8..236b57ec2 100644
--- a/tests/unit/presentation/components/Scripts/Menu/Selector/SelectionTypeHandler.spec.ts
+++ b/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.spec.ts
@@ -1,37 +1,38 @@
 import 'mocha';
 import { expect } from 'chai';
-import { SelectionType, SelectionTypeHandler } from '@/presentation/components/Scripts/Menu/Selector/SelectionTypeHandler';
+import { RecommendationStatusHandler } from '@/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler';
 import { scrambledEqual } from '@/application/Common/Array';
 import { RecommendationLevel } from '@/domain/RecommendationLevel';
-import { SelectionStateTestScenario } from './SelectionStateTestScenario';
+import { RecommendationStatusTestScenario } from './RecommendationStatusTestScenario';
+import { RecommendationStatusType } from '@/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusType';
 
-describe('SelectionTypeHandler', () => {
+describe('RecommendationStatusHandler', () => {
     describe('ctor', () => {
         it('throws when state is undefined', () => {
             // arrange
             const expectedError = 'undefined state';
             const state = undefined;
             // act
-            const sut = () => new SelectionTypeHandler(state);
+            const sut = () => new RecommendationStatusHandler(state);
             // assert
             expect(sut).to.throw(expectedError);
         });
     });
-    describe('selectType', () => {
+    describe('setRecommendationStatusType', () => {
         it('throws when type is custom', () => {
             // arrange
             const expectedError = 'cannot select custom type';
-            const scenario = new SelectionStateTestScenario();
+            const scenario = new RecommendationStatusTestScenario();
             const state = scenario.generateState([]);
-            const sut = new SelectionTypeHandler(state);
+            const sut = new RecommendationStatusHandler(state);
             // act
-            const act = () => sut.selectType(SelectionType.Custom);
+            const act = () => sut.setRecommendationStatusType(RecommendationStatusType.Custom);
             // assert
             expect(act).to.throw(expectedError);
         });
         describe('select types as expected', () => {
             // arrange
-            const scenario = new SelectionStateTestScenario();
+            const scenario = new RecommendationStatusTestScenario();
             const initialScriptsCases = [{
                 name: 'when nothing is selected',
                 initialScripts: [],
@@ -45,24 +46,24 @@ describe('SelectionTypeHandler', () => {
             for (const initialScriptsCase of initialScriptsCases) {
                 describe(initialScriptsCase.name, () => {
                     const state = scenario.generateState(initialScriptsCase.initialScripts);
-                    const sut = new SelectionTypeHandler(state);
+                    const sut = new RecommendationStatusHandler(state);
                     const typeExpectations = [{
-                        input: SelectionType.None,
+                        input: RecommendationStatusType.None,
                         output: [],
                     }, {
-                        input: SelectionType.Standard,
+                        input: RecommendationStatusType.Standard,
                         output: scenario.allStandard,
                     }, {
-                        input: SelectionType.Strict,
+                        input: RecommendationStatusType.Strict,
                         output: [...scenario.allStandard, ...scenario.allStrict],
                     }, {
-                        input: SelectionType.All,
+                        input: RecommendationStatusType.All,
                         output: scenario.all,
                     }];
                     for (const expectation of typeExpectations) {
                         // act
-                        it(`${SelectionType[expectation.input]} returns as expected`, () => {
-                            sut.selectType(expectation.input);
+                        it(`${RecommendationStatusType[expectation.input]} returns as expected`, () => {
+                            sut.setRecommendationStatusType(expectation.input);
                             // assert
                             const actual = state.selection.selectedScripts;
                             const expected = expectation.output;
@@ -73,51 +74,51 @@ describe('SelectionTypeHandler', () => {
             }
         });
     });
-    describe('getCurrentSelectionType', () => {
+    describe('getCurrentRecommendationStatusType', () => {
         // arrange
-        const scenario = new SelectionStateTestScenario();
+        const scenario = new RecommendationStatusTestScenario();
         const testCases = [{
             name: 'when nothing is selected',
             selection: [],
-            expected: SelectionType.None,
+            expected: RecommendationStatusType.None,
         }, {
             name: 'when some standard scripts are selected',
             selection: scenario.someStandard,
-            expected: SelectionType.Custom,
+            expected: RecommendationStatusType.Custom,
         }, {
             name: 'when all standard scripts are selected',
             selection: scenario.allStandard,
-            expected: SelectionType.Standard,
+            expected: RecommendationStatusType.Standard,
         }, {
             name: 'when all standard and some strict scripts are selected',
             selection: [...scenario.allStandard, ...scenario.someStrict],
-            expected: SelectionType.Custom,
+            expected: RecommendationStatusType.Custom,
         }, {
             name: 'when all standard and strict scripts are selected',
             selection: [...scenario.allStandard, ...scenario.allStrict],
-            expected: SelectionType.Strict,
+            expected: RecommendationStatusType.Strict,
         }, {
             name: 'when strict scripts are selected but not standard',
             selection: scenario.allStrict,
-            expected: SelectionType.Custom,
+            expected: RecommendationStatusType.Custom,
         }, {
             name: 'when all standard and strict, and some unrecommended are selected',
             selection: [...scenario.allStandard, ...scenario.allStrict, ...scenario.someUnrecommended],
-            expected: SelectionType.Custom,
+            expected: RecommendationStatusType.Custom,
         }, {
             name: 'when all scripts are selected',
             selection: scenario.all,
-            expected: SelectionType.All,
+            expected: RecommendationStatusType.All,
         } ];
         for (const testCase of testCases) {
             it(testCase.name, () => {
                 const state = scenario.generateState(testCase.selection);
-                const sut = new SelectionTypeHandler(state);
+                const sut = new RecommendationStatusHandler(state);
                 // act
-                const actual = sut.getCurrentSelectionType();
+                const actual = sut.getCurrentRecommendationStatusType();
                 // assert
                 expect(actual).to.deep.equal(testCase.expected,
-                    `Actual: "${SelectionType[actual]}", expected: "${SelectionType[testCase.expected]}"` +
+                    `Actual: "${RecommendationStatusType[actual]}", expected: "${RecommendationStatusType[testCase.expected]}"` +
                     `\nSelection: ${printSelection()}`);
                 function printSelection() {
                     return `total: ${testCase.selection.length}\n` +
diff --git a/tests/unit/presentation/components/Scripts/Menu/Selector/SelectionStateTestScenario.ts b/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusTestScenario.ts
similarity index 97%
rename from tests/unit/presentation/components/Scripts/Menu/Selector/SelectionStateTestScenario.ts
rename to tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusTestScenario.ts
index 0471d28ef..08055367b 100644
--- a/tests/unit/presentation/components/Scripts/Menu/Selector/SelectionStateTestScenario.ts
+++ b/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusTestScenario.ts
@@ -3,7 +3,7 @@ import { RecommendationLevel } from '@/domain/RecommendationLevel';
 import { CategoryCollectionStateStub } from '@tests/unit/stubs/CategoryCollectionStateStub';
 import { ScriptStub } from '@tests/unit/stubs/ScriptStub';
 
-export class SelectionStateTestScenario {
+export class RecommendationStatusTestScenario {
     public readonly all: readonly SelectedScript[];
     public readonly allStandard: readonly SelectedScript[];
     public readonly someStandard: readonly SelectedScript[];
diff --git a/tests/unit/presentation/components/Scripts/Menu/Revert/RevertStatusHandler.spec.ts b/tests/unit/presentation/components/Scripts/Menu/Revert/RevertStatusHandler.spec.ts
new file mode 100644
index 000000000..2ffe41cf9
--- /dev/null
+++ b/tests/unit/presentation/components/Scripts/Menu/Revert/RevertStatusHandler.spec.ts
@@ -0,0 +1,106 @@
+import 'mocha';
+import { expect } from 'chai';
+import { RevertStatusType } from '@/presentation/components/Scripts/Menu/Revert/RevertStatusType';
+import { RevertStatusHandler } from '@/presentation/components/Scripts/Menu/Revert/RevertStatusHandler';
+import { ScriptStub } from '@tests/unit/stubs/ScriptStub';
+import { SelectedScript } from '@/application/Context/State/Selection/SelectedScript';
+import { UserSelection } from '@/application/Context/State/Selection/UserSelection';
+import { ISelectedScript } from '../../../../../../../src/application/Context/State/Selection/ISelectedScript';
+
+describe('RevertStatusHandler', () => {
+    describe('getCurrentStatusType', () => {
+        const testCases = [
+            {
+                state: 'when nothing is selected',
+                scripts: [],
+                expected: RevertStatusType.NothingIsReversible,
+            },
+            {
+                state: 'when selected are not reversible',
+                scripts: [
+                    createSelectedScript(false),
+                    createSelectedScript(false),
+                ],
+                expected: RevertStatusType.NothingIsReversible,
+            },
+            {
+                state: 'when selected are reversible and reverted',
+                scripts: [
+                    createSelectedScript(true, true),
+                    createSelectedScript(true, true),
+                ],
+                expected: RevertStatusType.AllReverted,
+            },
+            {
+                state: 'when selected are reversible and reverted',
+                scripts: [
+                    createSelectedScript(false, false),
+                    createSelectedScript(true, true),
+                ],
+                expected: RevertStatusType.AllReverted,
+            },
+            {
+                state: 'when selected are reversible and reverted',
+                scripts: [
+                    createSelectedScript(true, true),
+                    createSelectedScript(true, false),
+                ],
+                expected: RevertStatusType.SomeReverted,
+            },
+            {
+                state: 'when selected are reversible and reverted',
+                scripts: [
+                    createSelectedScript(false, false),
+                    createSelectedScript(true, true),
+                    createSelectedScript(true, false),
+                ],
+                expected: RevertStatusType.SomeReverted,
+            },
+        ];
+        for (const testCase of testCases) {
+            it(`${testCase.state}; returns ${RevertStatusType[testCase.expected]}`, () => {
+                // arrange
+                const sut = new RevertStatusHandler();
+                // act
+                const actual = sut.getCurrentStatusType(testCase.scripts);
+                // assert
+                expect(actual).to.equal(testCase.expected);
+            });
+        }
+    });
+    describe('setType', () => {
+        describe('when some scripts are selected', () => {
+            const testCases = [ true, false ];
+            for (const expectedRevert of testCases) {
+                it(`updates reversible state to ${expectedRevert}`, () => {
+                    // arrange
+                    const selected =  [
+                        createSelectedScript(false, false),
+                        createSelectedScript(true, true),
+                        createSelectedScript(true, false),
+                    ];
+                    const expected = [
+                        selected[0],
+                        new SelectedScript(selected[1].script,  expectedRevert),
+                        new SelectedScript(selected[2].script,  expectedRevert),
+                    ];
+                    const selection = new UserSelection(undefined, selected);
+                    const sut = new RevertStatusHandler();
+                    // act
+                    sut.setType(expectedRevert, selection);
+                    // assert
+                    const sort = (scripts: readonly ISelectedScript[]) =>
+                        [...scripts].sort((a, b) => a.id.localeCompare(b.id));
+                    expect(sort(selection.selectedScripts)).to.deep.equal(sort(expected));
+                });
+            }
+        });
+    });
+});
+
+function createSelectedScript(reversibility: boolean, isReverted: boolean = false): SelectedScript {
+    const id = (Math.random() + 1).toString(36).substring(7);
+    const script = new ScriptStub(id)
+        .withReversibility(reversibility);
+    return new SelectedScript(script, isReverted);
+}
diff --git a/tests/unit/presentation/components/Scripts/View/Tree/SelectableTree/Node/Reverter/CategoryReverter.spec.ts b/tests/unit/presentation/components/Scripts/View/Tree/SelectableTree/Node/Reverter/CategoryReverter.spec.ts
index 0cfb27206..a895e63e0 100644
--- a/tests/unit/presentation/components/Scripts/View/Tree/SelectableTree/Node/Reverter/CategoryReverter.spec.ts
+++ b/tests/unit/presentation/components/Scripts/View/Tree/SelectableTree/Node/Reverter/CategoryReverter.spec.ts
@@ -7,36 +7,116 @@ import { UserSelection } from '@/application/Context/State/Selection/UserSelecti
 import { CategoryStub } from '@tests/unit/stubs/CategoryStub';
 import { CategoryCollectionStub } from '@tests/unit/stubs/CategoryCollectionStub';
 import { ScriptStub } from '@tests/unit/stubs/ScriptStub';
+import { SelectedScriptStub } from '@tests/unit/stubs/SelectedScriptStub';
 
 describe('CategoryReverter', () => {
     describe('getState', () => {
         // arrange
-        const scripts = [
-            new ScriptStub('revertable').withRevertCode('REM revert me'),
-            new ScriptStub('revertable2').withRevertCode('REM revert me 2'),
-        ];
-        const category = new CategoryStub(1).withScripts(...scripts);
-        const nodeId = getCategoryNodeId(category);
-        const collection = new CategoryCollectionStub().withAction(category);
-        const sut = new CategoryReverter(nodeId, collection);
         const testCases = [
             {
-                name: 'false when subscripts are not reverted',
-                state: scripts.map((script) => new SelectedScript(script, false)),
+                name: 'true when all subscripts are reverted',
+                existingScripts: [
+                    new ScriptStub('1').withReversibility(true),
+                    new ScriptStub('2').withReversibility(true),
+                ],
+                state: [
+                    new SelectedScriptStub('1', true),
+                    new SelectedScriptStub('2', true),
+                ],
+                expected: true,
+            },
+            {
+                name: 'true when all reversible subscripts are reverted',
+                existingScripts: [
+                    new ScriptStub('1').withReversibility(false),
+                    new ScriptStub('2').withReversibility(true),
+                    new ScriptStub('3').withReversibility(true),
+                ],
+                state: [
+                    new SelectedScriptStub('2', true),
+                    new SelectedScriptStub('3', true),
+                ],
+                expected: true,
+            },
+            {
+                name: 'false when none of subscripts are reverted',
+                existingScripts: [
+                    new ScriptStub('1').withReversibility(true),
+                    new ScriptStub('2').withReversibility(true),
+                ],
+                state: [
+                    new SelectedScriptStub('1', false),
+                    new SelectedScriptStub('2', false),
+                ],
                 expected: false,
             },
             {
                 name: 'false when some subscripts are reverted',
-                state: [new SelectedScript(scripts[0], false), new SelectedScript(scripts[0], true)],
+                existingScripts: [
+                    new ScriptStub('1').withReversibility(true),
+                    new ScriptStub('2').withReversibility(true),
+                ],
+                state: [
+                    new SelectedScriptStub('1', false),
+                    new SelectedScriptStub('2', true),
+                ],
                 expected: false,
             },
             {
                 name: 'false when subscripts are not reverted',
-                state: scripts.map((script) => new SelectedScript(script, true)),
-                expected: true,
+                existingScripts: [
+                    new ScriptStub('1').withReversibility(true),
+                    new ScriptStub('2').withReversibility(true),
+                ],
+                state: [
+                    new SelectedScriptStub('1', false),
+                    new SelectedScriptStub('2', false),
+                ],
+                expected: false,
+            },
+            {
+                name: 'false when all reversible subscripts are not reverted',
+                existingScripts: [
+                    new ScriptStub('1').withReversibility(false),
+                    new ScriptStub('2').withReversibility(true),
+                    new ScriptStub('3').withReversibility(true),
+                ],
+                state: [
+                    new SelectedScriptStub('2', false),
+                    new SelectedScriptStub('3', false),
+                ],
+                expected: false,
+            },
+            {
+                name: 'false some subscripts are reverted',
+                existingScripts: [
+                    new ScriptStub('1').withReversibility(false),
+                    new ScriptStub('2').withReversibility(true),
+                    new ScriptStub('3').withReversibility(true),
+                ],
+                state: [
+                    new SelectedScriptStub('2', true),
+                    new SelectedScriptStub('3', false),
+                ],
+                expected: false,
+            },
+            {
+                name: 'false when there are no reversible scripts',
+                existingScripts: [
+                    new ScriptStub('1').withReversibility(false),
+                    new ScriptStub('2').withReversibility(false),
+                    new ScriptStub('3').withReversibility(false),
+                ],
+                state: [ ],
+                expected: false,
             },
         ];
         for (const testCase of testCases) {
+            // arrange
+            const category = new CategoryStub(1).withScripts(...testCase.existingScripts);
+            const nodeId = getCategoryNodeId(category);
+            const collection = new CategoryCollectionStub().withAction(category);
+            const sut = new CategoryReverter(nodeId, collection);
             it(testCase.name, () => {
                 // act
                 const actual = sut.getState(testCase.state);
@@ -48,8 +128,8 @@ describe('CategoryReverter', () => {
     describe('selectWithRevertState', () => {
         // arrange
         const scripts = [
-            new ScriptStub('revertable').withRevertCode('REM revert me'),
-            new ScriptStub('revertable2').withRevertCode('REM revert me 2'),
+            new ScriptStub('1').withReversibility(true),
+            new ScriptStub('2').withReversibility(true),
         ];
         const category = new CategoryStub(1).withScripts(...scripts);
         const collection = new CategoryCollectionStub().withAction(category);
@@ -80,7 +160,7 @@ describe('CategoryReverter', () => {
                 revert: true, expectRevert: true,
             },
             {
-                name: 'keeps revert state deselected when already selected wtih non revert state',
+                name: 'keeps revert state deselected when already selected with non revert state',
                 selection: scripts.map((script) => new SelectedScript(script, false)),
                 revert: false, expectRevert: false,
             },
diff --git a/tests/unit/stubs/ScriptStub.ts b/tests/unit/stubs/ScriptStub.ts
index bd77b7463..11a45710b 100644
--- a/tests/unit/stubs/ScriptStub.ts
+++ b/tests/unit/stubs/ScriptStub.ts
@@ -12,34 +12,37 @@ export class ScriptStub extends BaseEntity<string> implements IScript {
     public readonly documentationUrls = new Array<string>();
     public level = RecommendationLevel.Standard;
 
+    private isReversible = true;
+
     constructor(public readonly id: string) {
         super(id);
     }
 
     public canRevert(): boolean {
-        return Boolean(this.code.revert);
+        return this.isReversible;
     }
 
     public withLevel(value: RecommendationLevel): ScriptStub {
         this.level = value;
         return this;
     }
-
+    public withReversibility(isReversible: boolean): ScriptStub {
+        this.isReversible = isReversible;
+        return this;
+    }
     public withCode(value: string): ScriptStub {
         this.code.execute = value;
         return this;
     }
-
     public withName(name: string): ScriptStub {
         this.name = name;
         return this;
     }
-
     public withRevertCode(revertCode: string): ScriptStub {
         this.code.revert = revertCode;
+        this.isReversible = Boolean(revertCode);
         return this;
     }
-
     public toSelectedScript(isReverted = false): SelectedScript {
         return new SelectedScript(this, isReverted);
     }
diff --git a/tests/unit/stubs/UserSelectionStub.ts b/tests/unit/stubs/UserSelectionStub.ts
index 46154d4d1..720728078 100644
--- a/tests/unit/stubs/UserSelectionStub.ts
+++ b/tests/unit/stubs/UserSelectionStub.ts
@@ -13,6 +13,9 @@ export class UserSelectionStub implements IUserSelection {
     public withSelectedScripts(selectedScripts: readonly SelectedScript[]) {
         this.selectedScripts = selectedScripts;
     }
+    public addOrUpdateAll(): void {
+        throw new Error('Method not implemented.');
+    }
     public areAllSelected(): boolean {
         throw new Error('Method not implemented.');
     }