MadWeb\Robots\Robots

Complexity

Total Complexity

19

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Test Coverage

Coverage

89.13%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	addSpacer()	0	3	1
A	addComment()	0	3	1
A	addSitemap()	0	3	1
A	generate()	0	3	1
A	addLine()	0	3	1
A	addRuleLine()	0	4	2
A	reset()	0	3	1
A	addDisallow()	0	3	1
A	addUserAgent()	0	3	1
A	addAllow()	0	3	1
A	addLines()	0	4	2
A	addHost()	0	3	1
A	metaTag()	0	3	2
A	shouldIndex()	0	7	2
A	setShouldIndexCallback()	0	3	1

<?php

namespace MadWeb\Robots;

class Robots
{
    /**
     * The lines of for the robots.txt.
     *
     * @var array
     */
    protected $lines = [];

    /** @var callable|bool */
    protected static $shouldIndex = true;

    /**
     * Generate the robots.txt data.
     *
     * @return string
     */
    public function generate()
    {
        return implode(PHP_EOL, $this->lines);
    }

    /**
     * Add a Sitemap to the robots.txt.
     *
     * @param string $sitemap
     */
    public function addSitemap($sitemap)
    {
        $this->addLine("Sitemap: $sitemap");
    }

    /**
     * Add a User-agent to the robots.txt.
     *
     * @param string $userAgent
     */
    public function addUserAgent($userAgent)
    {
        $this->addLine("User-agent: $userAgent");
    }

    /**
     * Add a Host to the robots.txt.
     *
     * @param string $host
     */
    public function addHost($host)
    {
        $this->addLine("Host: $host");
    }

    /**
     * Add a disallow rule to the robots.txt.
     *
     * @param string|array $directories
     */
    public function addDisallow($directories)
    {
        $this->addRuleLine($directories, 'Disallow');
    }

    /**
     * Add a allow rule to the robots.txt.
     *
     * @param string|array $directories
     */
    public function addAllow($directories)
    {
        $this->addRuleLine($directories, 'Allow');
    }

    /**
     * Add a rule to the robots.txt.
     *
     * @param string|array $directories
     * @param string       $rule
     */
    public function addRuleLine($directories, string $rule)
    {
        foreach ((array) $directories as $directory) {
            $this->addLine("$rule: $directory");
        }
    }

    /**
     * Add a comment to the robots.txt.
     *
     * @param string $comment
     */
    public function addComment($comment)
    {
        $this->addLine("# $comment");
    }

    /**
     * Add a spacer to the robots.txt.
     */
    public function addSpacer()
    {
        $this->addLine('');
    }

    /**
     * Add a line to the robots.txt.
     *
     * @param string $line
     */
    public function addLine(string $line)
    {
        $this->lines[] = $line;
    }

    /**
     * Add multiple lines to the robots.txt.
     *
     * @param string|array $lines
     */
    protected function addLines($lines)
    {
        foreach ((array) $lines as $line) {
            $this->addLine($line);
        }
    }

    /**
     * Reset the lines.
     *
     * @return void
     */
    public function reset()
    {
        $this->lines = [];
    }

    /**
     * Set callback with should index condition.
     */
    public function setShouldIndexCallback(callable $callback)
    {
        self::$shouldIndex = $callback;
    }

    /**
     * Check is application should be indexed.
     */
    public function shouldIndex(): bool
    {
        if (is_callable(self::$shouldIndex)) {
            return (bool) call_user_func(self::$shouldIndex);

It seems like self::shouldIndex can also be of type boolean; however, parameter $function of call_user_func() does only seem to accept callable, maybe add an additional type check?

        }

        return self::$shouldIndex;
    }

    /**
     * Render robots meta tag.
     */
    public function metaTag(): string
    {
        return '<meta name="robots" content="'.($this->shouldIndex() ? 'index, follow' : 'noindex, nofollow').'">';
    }
}