Changed custom pattern handling to not silently ignore errors and other minor improvements

[sandreas]

Hey there,

here is the PR you mentioned in #52.

Some notes:

• I added a constructor for adding custom patterns by IEnumerable<(string, string)>, because I thought Stream is not neccessary in all the use cases
• I noticed, that the default constructor loads custom patterns from a manifest file and added a comment, wether this is a good idea
• While the PatternViolations list I added might be a quick fix for the silently ignores errors problem, I'm not sure, that this is a good design decision in the long term. I would think over an API redesign calling Grok statically with a fluent interface removing all logic from the constructor... Maybe there is also room for using async/await. Example see below (just an idea, maybe we should discuss that as soon as you have more time):

public class Grok
{
    // I prefer IEnumberable over Dictionary because of thread safety
    private IEnumerable<(string, string)> _patterns;

    private Grok(string definition)
    {
        // ...
    }

    public static Grok Define(string definition)
    {
        EnsureDefintionIsValid(definition);
        return new Grok(definition);
    }

    public Grok WithPatterns(IEnumerable<(string, string)> patterns)
    {
        var patternsArray = patterns.ToArray();
        EnsurePatternsAreValid(patternsArray);
        _patterns = patternsArray;
        return this;
    }

    private void EnsurePatternsAreValid(IEnumerable<(string, string)> patterns)
    {
        // ...
    }

    private static void EnsureDefintionIsValid(string definition)
    {
        // ...
    }

    public bool TryMatch(string subject, out IEnumerable<GrokItem> matches)
    {
        matches = new List<GrokItem>();
        // ...
        return true;
    }
}

try {
  var matcher = Grok.Define("%{ZIPCODE:zipcode}:%{EMAILADDRESS:email}").WithPatterns(new[] {
      ("ZIPCODE", "[1-9]{1}[0-9]{2}\\s{0,1}[0-9]{3}"), 
      ("FLOAT", "[+-]?([0-9]*[.,])?[0-9]+"),
  });
  
  if(matcher.TryMatch("122 001:[email protected]", out var matches)) {
    Console.WriteLine("Matches found: " + matches.Count);
  } else {
    Console.WriteLine("No matches found");
  };
} catch(GrokDefinitionException e) {
  Console.WriteLine("Invalid definition: " + e.Message);
} catch(GrokPatternException pe) {
  Console.WriteLine("Invalid custom pattern: " + e.Message);
}

[Marusyk]

Many thanks for your contribution and interest in the project.

• The new constructor will be a nice feature
• The constructor loads default patterns (not custom, from custom file), it is an important requirement and must be done automatically during the Grok initialization (in order not to force the user/consumer to do it - dangerous - there is no guarantee that the user will do this)
• PatternViolations concept will not fix the issue with ignoring errors, but adds more complexity and, again, requires additional operations from users
• With what actions can you use async/await here?
• A fluent interface is a good idea and can be designed however I'd avoid any static

[Marusyk]

👍 LGTM
Great job! Thank you

[ealvesss]

Any help for first issue?

[Marusyk]

Hi @EltonAlvess,
what do you mean? This is not an issue, it's a pull request that has already been merged