We have a similar challenge on our side. Here is the generalized idea:

We know the way something should look.
But it is very hard to describe the way it should not look (and there are possibly an infinite number of possibilities).

Simple/silly example:

We only want to accept the string ABC if it is immediately followed by either DEF or 123.
The regex to find ABC is simple, but then it is much more challenging to say "trigger if there is anything else than DEF or 123 afterwards" (maybe not for regex gurus, but those are rare, and the resulting regexes are hard for everyone else to understand & maintain).

What I would propose:

We keep the current concept of pattern matching to find rows in a file.
But then we add a new concept/parameter of mustMatch, which would be a positive regex of how the match should look, rather than trying to do it all via a negative/exclusion regex of what something bad looks like.
pattern would continue to match on rows, and extract the corresponding substring(s).
mustMatch would then have to find an exact match (in each substring), or the rule would be triggered (for each substring).
If mustMatch matches, the rule is not triggered.

So the solution to the above would become:

pattern: 'ABC.*' # or maybe 'ABC.{3}'
mustMatch: 'ABC((DEF)|(123))'

And @petemounce, the solution for you could probably look something like this (although I'm probably missing a lot of details):

pattern: '[^\d]\d+\.\d+\.\d+[^\d]'
mustMatch: '[^v]\d+\.\d+\.\d+' # or maybe '"\d+\.\d+\.\d+"'

So much simpler. 💙

@petemounce, @codingjoe: What do you think?

Add a negate flag #15

Description