Bee4\RobotsTxt\Rule

Complexity

Total Complexity

9

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

96.67%

Importance

Changes	7
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	disallow()	0	4	1
A	allow()	0	4	1
A	addExpression()	0	6	1
A	compile()	0	16	2
A	match()	0	16	3
A	lastFilledIndex()	0	4	1

<?php

namespace Bee4\RobotsTxt;

/**
 * Class Rule
 * Represent a Ruleset inside a Robots.txt file
 *
 * @copyright Bee4 2015
 * @author    Stephane HULARD <s.hulard@chstudio.fr>
 */
class Rule
{
    const COMPILED = 'compiled';
    const DIRTY    = 'dirty';

    /**
     * Rule status (compiled or dirty)
     * @var string
     */
    private $state;

    /**
     * Expression collection with allow / disallow segments
     * @var array
     */
    private $exp = [
        'allow'    => [],
        'disallow' => []
    ];

    /**
     * Compiled regex pattern with allow / disallow segments
     * @var array
     */
    private $patterns = [
        'allow'    => '',
        'disallow' => ''
    ];

    /**
     * Add a pattern to match in the current rule by allowing
     * @param string $pattern
     * @return Rule
     */
    public function allow($pattern)
    {
        return $this->addExpression(new Expression($pattern), 'allow');
    }

    /**
     * Add a pattern to match in the current rule by disallowing
     * @param string $pattern
     * @return Rule
     */
    public function disallow($pattern)
    {
        return $this->addExpression(new Expression($pattern), 'disallow');
    }

    /**
     * Add an expression in the current rule
     * @param string $pattern Expression raw pattern

There is no parameter named $pattern. Was it maybe removed?

     * @param string $mode    Expression mode (allow / disallow)
     * @return Expression
     */
    private function addExpression(Expression $exp, $mode)
    {
        $this->state = self::DIRTY;
        $this->exp[$mode][] = $exp;
        return $this;
    }

    /**
     * Compile expressions to a global pattern
     * @return boolean
     */
    public function compile()
    {
        if( self::COMPILED === $this->state ) {
            return true;
        }

        $process = function(array &$patterns) {
            usort($patterns, function(Expression $a, Expression $b) {
                return strlen($a->getRaw()) < strlen($b->getRaw());
            });

            return '/^(('.implode(')|(', $patterns).'))$/';
        };
        $this->patterns['allow'] = $process($this->exp['allow']);
        $this->patterns['disallow'] = $process($this->exp['disallow']);
    }

    /**
     * Check if the URL is allowed or not
     * @param string $url
     * @return boolean
     */
    public function match($url)
    {
        $this->compile();

        if( 1 === preg_match($this->patterns['disallow'], $url, $disallowed) ) {
            if( 1 === preg_match($this->patterns['allow'], $url, $allowed) ) {
                $a = $this->lastFilledIndex($allowed);
                $d = $this->lastFilledIndex($disallowed);
                return strlen($this->exp['allow'][$a-2]->getRaw()) >= strlen($this->exp['disallow'][$d-2]->getRaw());
            }

            return false;
        }

        return true;
    }

    /**
     * Retrieve the last filled index in a given array
     * @param  array  $data
     * @return integer
     */
    private function lastFilledIndex(array $data)
    {
        return key( array_slice( array_filter($data), -1, 1, true ) );
    }
}