refactor: Tags search now implemented with SubstringMatcher (#1056)

* refactor: Add SubstringMatcher.matchesAnyOf()

* refactor: Make IStringMatcher an abstract class

In preparation for moving a method down from SubstringMatcher

* refactor: Move matchesAnyOf() down to IStringMatcher

* refactor: Rework 'tags include' & co to use SubstringMatcher

* refactor: Rework 'do not include' & co to use SubstringMatcher

* refactor: Rework TagsField to use TextField.maybeNegate()

* refactor: Simplify TagsField, using idea from TextField

Author: claremacrae

src/Query/Filter/TagsField.ts

@@ -1,4 +1,5 @@
 import type { Task } from '../../Task';
+import { SubstringMatcher } from '../Matchers/SubstringMatcher';
 import { Field } from './Field';
 import { FilterOrErrorMessage } from './Filter';
 import { TextField } from './TextField';
@@ -22,19 +23,13 @@ export class TagsField extends Field {
             // Search is done sans the hash. If it is provided then strip it off.
             const search = tagMatch[3].replace(/^#/, '');
 
-            if (filterMethod === 'include' || filterMethod === 'includes') {
+            if (filterMethod.includes('include')) {
+                const matcher = new SubstringMatcher(search);
                 result.filter = (task: Task) =>
-                    task.tags.find((tag) =>
-                        TextField.stringIncludesCaseInsensitive(tag, search),
-                    ) !== undefined;
-            } else if (
-                tagMatch[2] === 'do not include' ||
-                tagMatch[2] === 'does not include'
-            ) {
-                result.filter = (task: Task) =>
-                    task.tags.find((tag) =>
-                        TextField.stringIncludesCaseInsensitive(tag, search),
-                    ) == undefined;
+                    TextField.maybeNegate(
+                        matcher.matchesAnyOf(task.tags),
+                        filterMethod,
+                    );
             } else {
                 result.error = 'do not understand query filter (tag/tags)';
             }

src/Query/Filter/TextField.ts

@@ -68,7 +68,7 @@ export abstract class TextField extends Field {
      */
     protected abstract value(task: Task): string;
 
-    private static maybeNegate(match: boolean, filterMethod: String) {
+    public static maybeNegate(match: boolean, filterMethod: String) {
         return filterMethod.match(/not/) ? !match : match;
     }
 }

src/Query/Matchers/IStringMatcher.ts

@@ -4,10 +4,18 @@
  * This is used to hide away the details of various text searches, such as the
  * simple inclusion of a sub-string, or the more complex regular expression searches.
  */
-export interface IStringMatcher {
+export abstract class IStringMatcher {
     /**
      * Return whether the given string matches this condition.
      * @param stringToSearch
      */
-    matches(stringToSearch: string): boolean;
+    public abstract matches(stringToSearch: string): boolean;
+
+    /**
+     * Return whether any of the given strings matches this condition.
+     * @param stringsToSearch
+     */
+    public matchesAnyOf(stringsToSearch: string[]) {
+        return stringsToSearch.some((s) => this.matches(s));
+    }
 }

src/Query/Matchers/RegexMatcher.ts

@@ -1,9 +1,9 @@
-import type { IStringMatcher } from './IStringMatcher';
+import { IStringMatcher } from './IStringMatcher';
 
 /**
  * Regular-expression-based implementation of IStringMatcher.
  */
-export class RegexMatcher implements IStringMatcher {
+export class RegexMatcher extends IStringMatcher {
     private readonly regex: RegExp;
 
     /**
@@ -12,6 +12,7 @@ export class RegexMatcher implements IStringMatcher {
      * @param regex {RegExp} - A valid regular expression
      */
     public constructor(regex: RegExp) {
+        super();
         this.regex = regex;
     }
 

src/Query/Matchers/SubstringMatcher.ts

@@ -1,11 +1,11 @@
-import type { IStringMatcher } from './IStringMatcher';
+import { IStringMatcher } from './IStringMatcher';
 
 /**
  * Substring-based implementation of IStringMatcher.
  *
  * This does a case-insensitive search for the given string.
  */
-export class SubstringMatcher implements IStringMatcher {
+export class SubstringMatcher extends IStringMatcher {
     private readonly stringToFind: string;
 
     /**
@@ -15,6 +15,7 @@ export class SubstringMatcher implements IStringMatcher {
      *                                Searches will be case-insensitive.
      */
     public constructor(stringToFind: string) {
+        super();
         this.stringToFind = stringToFind;
     }
 

tests/Query/Matchers/SubstringMatcher.test.ts

@@ -7,4 +7,14 @@ describe('SubstringMatcher', () => {
         expect(matcher.matches('prefix find me suffix')).toStrictEqual(true);
         expect(matcher.matches('FIND ME')).toStrictEqual(true);
     });
+
+    it('should match any values in array of text', () => {
+        const matcher = new SubstringMatcher('find me');
+        expect(
+            matcher.matchesAnyOf(['wibble', 'stuff', 'FIND ME']),
+        ).toStrictEqual(true);
+        expect(
+            matcher.matchesAnyOf(['wibble', 'stuff', 'LOSE ME']),
+        ).not.toStrictEqual(true);
+    });
 });