refactor: Merge formatters into matchers

[tienvx]

Apply SOLID

L - Liskov Substitution Principle

Currently most of formatter's code are like this:

class BooleanFormatter implements FormatterInterface
{
    public function format(MatcherInterface $matcher): string
    {
        if (!$matcher instanceof Boolean) {
            throw MatcherNotSupported();
        }

        return 'formatted value';
    }
}

Now it's just a method inside matcher:

class BooleanMatcher
{
    public function formatExpression(): string
    {
         return 'formatted value';
    }
}

I - Interface Segregation Principle

Create bunch of small interfaces. Matchers can decide to implement interface that it need:

class Boolean implements JsonFormattableInterface, ExpressionFormattableInterface
{
    public function formatJson(): array {}
    public function formatExpression(): string {}
}

class StatusCode implements JsonFormattableInterface
{
    public function formatJson(): array {}
}

no need to implement a big interface then throw exception on unused method like before:

class ArrayContains
{
    public function createExpressionFormatter(): ExpressionFormatterInterface
    {
        throw new MatcherNotSupportedException("ArrayContains matcher doesn't support expression formatter");
    }
}

O - Open-Closed Principle

Instead of using array and string, wrap them in new classes Attributes and Expression

Simplify generator flow

Old flow

New flow

Breaking changes

I tried not to introduce any breaking changes. All matchers can be used normally using the helper class Matcher

[coveralls]

Pull Request Test Coverage Report for Build 11248263126

Details

• 516 of 516 (100.0%) changed or added relevant lines in 53 files are covered.
• No unchanged relevant lines lost coverage.
• Overall coverage increased (+0.5%) to 96.371%

---

Totals
Change from base Build 11173981158:	0.5%
Covered Lines:	2443
Relevant Lines:	2535

---

💛 - Coveralls