Ray\Aop\Matcher

Complexity

Total Complexity

10

Size/Duplication

Total Lines	70
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	1	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	any()	0	4	1
A	logicalOr()	0	4	1
A	annotatedWith()	0	8	2
A	subclassesOf()	0	8	2
A	startsWith()	0	8	2
A	logicalAnd()	0	4	1
A	logicalNot()	0	4	1

<?php
/**
 * This file is part of the Ray.Aop package
 *
 * @license http://opensource.org/licenses/bsd-license.php BSD
 */
namespace Ray\Aop;

use Ray\Aop\Exception\InvalidAnnotationException;
use Ray\Aop\Exception\InvalidArgumentException;

class Matcher implements MatcherInterface
{
    /**
     * {@inheritdoc}
     */
    public function any()
    {
        return new BuiltinMatcher(__FUNCTION__, []);
    }

    /**
     * {@inheritdoc}
     */
    public function annotatedWith($annotationName)
    {
        if (! class_exists($annotationName)) {
            throw new InvalidAnnotationException($annotationName);
        }

        return new AnnotatedMatcher(__FUNCTION__, [$annotationName]);
    }

    /**
     * {@inheritdoc}
     */
    public function subclassesOf($superClass)
    {
        if (! class_exists($superClass)) {
            throw new InvalidArgumentException($superClass);
        }

        return new BuiltinMatcher(__FUNCTION__, [$superClass]);
    }

    /**
     * {@inheritdoc}
     */
    public function startsWith($prefix)
    {
        if (! is_string($prefix)) {
            throw new InvalidArgumentException($prefix);
        }

        return new BuiltinMatcher(__FUNCTION__, [$prefix]);
    }

    /**
     * {@inheritdoc}
     */
    public function logicalOr(AbstractMatcher $matcherA, AbstractMatcher $matcherB)
    {
        return new BuiltinMatcher(__FUNCTION__, [$matcherA, $matcherB]);
    }

    /**
     * {@inheritdoc}
     */
    public function logicalAnd(AbstractMatcher $matcherA, AbstractMatcher $matcherB)
    {
        return new BuiltinMatcher(__FUNCTION__, [$matcherA, $matcherB]);
    }

    /**
     * {@inheritdoc}
     */
    public function logicalNot(AbstractMatcher $matcher)
    {
        return new BuiltinMatcher(__FUNCTION__, [$matcher]);
    }
}