Bee4\RobotsTxt\Rules

Complexity

Total Complexity

15

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	13
Bugs	1	Features	3

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	addSitemap()	0	8	2
A	getSitemaps()	0	4	1
A	add()	0	14	3
A	match()	0	4	1
A	handleUa()	0	7	2
A	count()	0	4	1
A	get()	0	21	4

<?php

namespace Bee4\RobotsTxt;

use Bee4\RobotsTxt\Exception\DuplicateRuleException;
use Bee4\RobotsTxt\Exception\InvalidUrlException;

/**
 * Class Rules
 * Represent a collection of Rules
 *
 * @copyright Bee4 2015
 * @author    Stephane HULARD <s.hulard@chstudio.fr>
 */
class Rules implements \Countable
{
    const DEFAULT_UA = '*';

    /**
     * The collection of rules
     * @var array
     */
    protected $collection = [];

    protected $sitemaps = [];

    /**
     * Default rule used if robots.txt is empty
     * @var Rule
     */
    private $defaultRule;

    public function __construct()
    {
        $this->defaultRule = new Rule(self::DEFAULT_UA);
        $this->add($this->defaultRule);
    }

    public function addSitemap($sitemap)
    {
        if (!filter_var($sitemap, FILTER_VALIDATE_URL)) {
            throw (new InvalidUrlException(sprintf('Invalid sitemap URL given: %s', $sitemap)))
                ->setUrl($sitemap);
        }
        $this->sitemaps[] = $sitemap;
    }

    public function getSitemaps()
    {
        return $this->sitemaps;
    }

    /**
     * Add a new rule to the collection
     * @param Rule $rule
     * @return Rules
     */
    public function add(Rule $rule)
    {
        $userAgent = $this->handleUa($rule->getUserAgent());
        if (isset($this->collection[$userAgent]) &&
                $this->collection[$userAgent] !== $this->defaultRule ) {
            throw (new DuplicateRuleException(
                'You can\'t add 2 rules for the same UserAgent'
            ))
                ->setRule($rule);
        }
        $this->collection[$userAgent] = $rule;

        return $this;
    }

    /**
     * Check if the URL match for the given UA or not
     * @param string $userAgent
     * @param string $url
     * @return boolean
     */
    public function match($userAgent, $url)
    {
        return $this->get($userAgent)->match($url);
    }

    /**
     * Retrieve rules for a given UA
     * @param string $userAgent
     * @return null|Rule
     */
    public function get($userAgent)
    {
        $item = null;
        $iterator = new \ArrayIterator($this->collection);
        iterator_apply(
            $iterator,
            function (\ArrayIterator $iterator, $userAgent) use (&$item) {
                if ($iterator->key() != Rules::DEFAULT_UA &&
                        preg_match($iterator->key(), $userAgent) === 1 ) {
                    $item = $iterator->current();
                    return false;
                }
                return true;
            },
            [$iterator, $userAgent]
        );

        return $item!==null?
            $item:
            $this->collection[self::DEFAULT_UA];
    }

    /**
     * Update the UA to make a valid regexp
     * @param string $userAgent
     * @return string
     */
    private function handleUa($userAgent)
    {
        if ($userAgent == self::DEFAULT_UA) {
            return $userAgent;
        }
        return '/^'.preg_quote($userAgent).'.*/i';
    }

    /**
     * Return the number of rules
     * @return integer
     */
    public function count()
    {
        return count($this->collection);
    }
}