Scenario Support: Determine support for Global Filters where it may have sub tags

[sytone]

What is the support for a tag with sub tags used as global filter?

• #context as global and #context/home exists.

If the global filter has a sub tag do we remove the entire tag?
( #context/home -> /context) vs (#context/home -> )

This code seems to handle the global filter differently from the rest of the Tasks plugin.

Here's the testing I did:

1. In the Tasks settings:
   • Turn on a global tag filter #context
   • Turn on 'Remove global filter from description'
2. Restart Obsidian

My first few results look now like this:

Reminder: the above search is:

```tasks
not done
happens before 2022-06-01
tags include #context
sort by tag 0
hide backlink
```

Things to note:

1. The Tasks plugin has removed exactly the tag text #context from the display text. The rest of the tag (e.g. /enfield) is still displayed.
2. The documented behaviour of the new code is to ignore the global tag filter, so none of these tasks with #content/.... should have matched the search.

Some more thoughts on this:

1. The new code handles sub-string matches of tags differently from the existing code
2. But even if it didn't behave differently, I think there should only be one place where tags are compared against the global tag filter, to avoid diverging behaviour in future... And that should be to re-use the existing code for using the global tag filter.
3. I think there's a question as to whether task.tags() should just exclude the global filter, which would make the searching simpler. This would need discussion, as I don't know the current code well enough to know how that could be implemented. But it would certainly make the search and filtering code easier, as the only place that would know about the global tag filter would be the parsing code.

Originally posted by @claremacrae in #636 (comment)

[schemar]

At this stage, I would deem this a discussion, not an issue. What do you think @claremacrae / @sytone ?

[claremacrae]

Yes, I think it's a discussion, to:

• research and record any consistency or difference in behaviour between the two bodies of code
• decide what the correct behaviour should be
• decide where a unified implementation would go in the code