Extend search by including documentation content

This commit broadens the search functionality within privacy.sexy by
including documentation text in the search scope. Users can now find
scripts and categories not only by their names but also by content in
their documentation. This improvement aims to make the discovery of
relevant scripts and information more intuitive and comprehensive.

Key changes:

- Documentation text is now searchable, enhancing the ability to
  discover scripts and categories based on content details.

Other supporting changes:

- Remove interface prefixes (`I`) from related interfaces to adhere to
  naming conventions, enhancing code readability.
- Refactor filtering to separate actual filtering logic from filter
  state management, improving the structure for easier maintenance.
- Improve test coverage to ensure relability of existing and new search
  capabilities.
- Test coverage expanded to ensure the reliability of the new search
  capabilities.

src/application/Context/State/CategoryCollectionState.ts

@@ -1,7 +1,7 @@
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { UserFilter } from './Filter/UserFilter';
-import { IUserFilter } from './Filter/IUserFilter';
+import { AdaptiveFilterContext } from './Filter/AdaptiveFilterContext';
+import { FilterContext } from './Filter/FilterContext';
 import { ApplicationCode } from './Code/ApplicationCode';
 import { UserSelection } from './Selection/UserSelection';
 import { ICategoryCollectionState } from './ICategoryCollectionState';
@@ -15,7 +15,7 @@ export class CategoryCollectionState implements ICategoryCollectionState {
 
   public readonly selection: UserSelection;
 
-  public readonly filter: IUserFilter;
+  public readonly filter: FilterContext;
 
   public constructor(
     public readonly collection: ICategoryCollection,
@@ -45,7 +45,7 @@ const DefaultSelectionFactory: SelectionFactory = (
 ) => new UserSelectionFacade(...params);
 
 export type FilterFactory = (
-  ...params: ConstructorParameters<typeof UserFilter>
-) => IUserFilter;
+  ...params: ConstructorParameters<typeof AdaptiveFilterContext>
+) => FilterContext;
 
-const DefaultFilterFactory: FilterFactory = (...params) => new UserFilter(...params);
+const DefaultFilterFactory: FilterFactory = (...params) => new AdaptiveFilterContext(...params);

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

@@ -0,0 +1,35 @@
+import { EventSource } from '@/infrastructure/Events/EventSource';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { FilterResult } from './Result/FilterResult';
+import { FilterContext } from './FilterContext';
+import { FilterChangeDetails } from './Event/FilterChangeDetails';
+import { FilterChange } from './Event/FilterChange';
+import { FilterStrategy } from './Strategy/FilterStrategy';
+import { LinearFilterStrategy } from './Strategy/LinearFilterStrategy';
+
+export class AdaptiveFilterContext implements FilterContext {
+  public readonly filterChanged = new EventSource<FilterChangeDetails>();
+
+  public currentFilter: FilterResult | undefined;
+
+  constructor(
+    private readonly collection: ICategoryCollection,
+    private readonly filterStrategy: FilterStrategy = new LinearFilterStrategy(),
+  ) {
+
+  }
+
+  public applyFilter(filter: string): void {
+    if (!filter) {
+      throw new Error('Filter must be defined and not empty. Use clearFilter() to remove the filter');
+    }
+    const result = this.filterStrategy.applyFilter(filter, this.collection);
+    this.currentFilter = result;
+    this.filterChanged.notify(FilterChange.forApply(this.currentFilter));
+  }
+
+  public clearFilter(): void {
+    this.currentFilter = undefined;
+    this.filterChanged.notify(FilterChange.forClear());
+  }
+}

src/application/Context/State/Filter/Event/FilterChange.ts

@@ -1,24 +1,24 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { FilterActionType } from './FilterActionType';
 import {
-  IFilterChangeDetails, IFilterChangeDetailsVisitor,
+  FilterChangeDetails, FilterChangeDetailsVisitor,
   ApplyFilterAction, ClearFilterAction,
-} from './IFilterChangeDetails';
+} from './FilterChangeDetails';
 
-export class FilterChange implements IFilterChangeDetails {
+export class FilterChange implements FilterChangeDetails {
   public static forApply(
-    filter: IFilterResult,
-  ): IFilterChangeDetails {
+    filter: FilterResult,
+  ): FilterChangeDetails {
     return new FilterChange({ type: FilterActionType.Apply, filter });
   }
 
-  public static forClear(): IFilterChangeDetails {
+  public static forClear(): FilterChangeDetails {
     return new FilterChange({ type: FilterActionType.Clear });
   }
 
   private constructor(public readonly action: ApplyFilterAction | ClearFilterAction) { }
 
-  public visit(visitor: IFilterChangeDetailsVisitor): void {
+  public visit(visitor: FilterChangeDetailsVisitor): void {
     switch (this.action.type) {
       case FilterActionType.Apply:
         if (visitor.onApply) {

src/application/Context/State/Filter/Event/FilterChangeDetails.ts

@@ -0,0 +1,23 @@
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import type { FilterActionType } from './FilterActionType';
+
+export interface FilterChangeDetails {
+  readonly action: FilterAction;
+  visit(visitor: FilterChangeDetailsVisitor): void;
+}
+
+export interface FilterChangeDetailsVisitor {
+  readonly onClear?: () => void;
+  readonly onApply?: (filter: FilterResult) => void;
+}
+
+export type ApplyFilterAction = {
+  readonly type: FilterActionType.Apply,
+  readonly filter: FilterResult;
+};
+
+export type ClearFilterAction = {
+  readonly type: FilterActionType.Clear,
+};
+
+export type FilterAction = ApplyFilterAction | ClearFilterAction;

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

@@ -0,0 +1,13 @@
+import { IEventSource } from '@/infrastructure/Events/IEventSource';
+import { FilterResult } from './Result/FilterResult';
+import { FilterChangeDetails } from './Event/FilterChangeDetails';
+
+export interface ReadonlyFilterContext {
+  readonly currentFilter: FilterResult | undefined;
+  readonly filterChanged: IEventSource<FilterChangeDetails>;
+}
+
+export interface FilterContext extends ReadonlyFilterContext {
+  applyFilter(filter: string): void;
+  clearFilter(): void;
+}

src/application/Context/State/Filter/FilterResult.ts → src/application/Context/State/Filter/Result/AppliedFilterResult.ts

@@ -1,8 +1,8 @@
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
-import { IFilterResult } from './IFilterResult';
+import { FilterResult } from './FilterResult';
 
-export class FilterResult implements IFilterResult {
+export class AppliedFilterResult implements FilterResult {
   constructor(
     public readonly scriptMatches: ReadonlyArray<IScript>,
     public readonly categoryMatches: ReadonlyArray<ICategory>,

src/application/Context/State/Filter/IFilterResult.ts → src/application/Context/State/Filter/Result/FilterResult.ts

@@ -1,6 +1,6 @@
 import { IScript, ICategory } from '@/domain/ICategory';
 
-export interface IFilterResult {
+export interface FilterResult {
   readonly categoryMatches: ReadonlyArray<ICategory>;
   readonly scriptMatches: ReadonlyArray<IScript>;
   readonly query: string;

src/application/Context/State/Filter/Strategy/FilterStrategy.ts

@@ -0,0 +1,9 @@
+import type { ICategoryCollection } from '@/domain/ICategoryCollection';
+import type { FilterResult } from '../Result/FilterResult';
+
+export interface FilterStrategy {
+  applyFilter(
+    filter: string,
+    collection: ICategoryCollection,
+  ): FilterResult;
+}

src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts

@@ -0,0 +1,80 @@
+import type { ICategory, IScript } from '@/domain/ICategory';
+import type { IScriptCode } from '@/domain/IScriptCode';
+import type { IDocumentable } from '@/domain/IDocumentable';
+import type { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { AppliedFilterResult } from '../Result/AppliedFilterResult';
+import type { FilterStrategy } from './FilterStrategy';
+import type { FilterResult } from '../Result/FilterResult';
+
+export class LinearFilterStrategy implements FilterStrategy {
+  applyFilter(filter: string, collection: ICategoryCollection): FilterResult {
+    const filterLowercase = filter.toLocaleLowerCase();
+    const filteredScripts = collection.getAllScripts().filter(
+      (script) => matchesScript(script, filterLowercase),
+    );
+    const filteredCategories = collection.getAllCategories().filter(
+      (category) => matchesCategory(category, filterLowercase),
+    );
+    return new AppliedFilterResult(
+      filteredScripts,
+      filteredCategories,
+      filter,
+    );
+  }
+}
+
+function matchesCategory(
+  category: ICategory,
+  filterLowercase: string,
+): boolean {
+  return matchesAny(
+    () => matchName(category.name, filterLowercase),
+    () => matchDocumentation(category, filterLowercase),
+  );
+}
+
+function matchesScript(
+  script: IScript,
+  filterLowercase: string,
+): boolean {
+  return matchesAny(
+    () => matchName(script.name, filterLowercase),
+    () => matchCode(script.code, filterLowercase),
+    () => matchDocumentation(script, filterLowercase),
+  );
+}
+
+function matchesAny(
+  ...predicates: ReadonlyArray<() => boolean>
+): boolean {
+  return predicates.some((predicate) => predicate());
+}
+
+function matchName(
+  name: string,
+  filterLowercase: string,
+): boolean {
+  return name.toLowerCase().includes(filterLowercase);
+}
+
+function matchCode(
+  code: IScriptCode,
+  filterLowercase: string,
+): boolean {
+  if (code.execute.toLowerCase().includes(filterLowercase)) {
+    return true;
+  }
+  if (code.revert?.toLowerCase().includes(filterLowercase)) {
+    return true;
+  }
+  return false;
+}
+
+function matchDocumentation(
+  documentable: IDocumentable,
+  filterLowercase: string,
+): boolean {
+  return documentable.docs.some(
+    (doc) => doc.toLocaleLowerCase().includes(filterLowercase),
+  );
+}

src/application/Context/State/ICategoryCollectionState.ts

@@ -1,18 +1,18 @@
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { IReadOnlyUserFilter, IUserFilter } from './Filter/IUserFilter';
+import { ReadonlyFilterContext, FilterContext } from './Filter/FilterContext';
 import { ReadonlyUserSelection, UserSelection } from './Selection/UserSelection';
 import { IApplicationCode } from './Code/IApplicationCode';
 
 export interface IReadOnlyCategoryCollectionState {
   readonly code: IApplicationCode;
   readonly os: OperatingSystem;
-  readonly filter: IReadOnlyUserFilter;
+  readonly filter: ReadonlyFilterContext;
   readonly selection: ReadonlyUserSelection;
   readonly collection: ICategoryCollection;
 }
 
 export interface ICategoryCollectionState extends IReadOnlyCategoryCollectionState {
-  readonly filter: IUserFilter;
+  readonly filter: FilterContext;
   readonly selection: UserSelection;
 }

src/presentation/components/Scripts/Menu/TheScriptsMenu.vue

@@ -16,7 +16,7 @@
 <script lang="ts">
 import { defineComponent, ref } from 'vue';
 import { injectKey } from '@/presentation/injectionSymbols';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
 import { IEventSubscription } from '@/infrastructure/Events/IEventSource';
 import TheOsChanger from './TheOsChanger.vue';
 import TheViewChanger from './View/TheViewChanger.vue';
@@ -49,7 +49,7 @@ export default defineComponent({
     }, { immediate: true });
 
     function subscribeToFilterChanges(
-      filter: IReadOnlyUserFilter,
+      filter: ReadonlyFilterContext,
     ): IEventSubscription {
       return filter.filterChanged.on((event) => {
         event.visit({