Luminaire\Premailer\Parser\RelevantSelectorParser

Complexity

Total Complexity

29

Size/Duplication

Total Lines	238
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	extract()	0	13	2
B	extractSelector()	0	24	5
A	setStylesheetReader()	0	17	3
A	getStylesheetReader()	0	4	1
A	setCharset()	0	6	1
A	getCharset()	0	4	1
A	isPseudoClassAllowed()	0	12	3
A	getRelevantStyleRules()	0	19	4
A	getRelevantMediaRule()	0	17	4
A	isAllowedMediaRule()	0	7	3

<?php namespace Luminaire\Premailer\Parser;

/**
 * Created by Sublime Text 3
 *
 * @user     Kevin Tanjung
 * @website  http://kevintanjung.github.io
 * @email    kevin@custombagus.com
 * @date     04/08/2016
 * @time     09:09
 */

use Crossjoin\Css\Reader\CssString as StylesheetReader;
use Crossjoin\Css\Format\Rule\AtMedia\MediaQuery;
use Crossjoin\Css\Format\Rule\AtMedia\MediaRule;
use Crossjoin\Css\Format\Rule\Style\StyleRuleSet;
use Crossjoin\Css\Format\Rule\Style\StyleSelector;
use Illuminate\Support\Arr;
use InvalidArgumentException;

/**
 * Retrieve relevant CSS selector from a given CSS rules
 *
 * @package  \Luminaire\Poseidon\Parser
 */
class RelevantSelectorParser
{

    /**
     * The pseudo classes that can be set in a style attribute and that are
     * supported by the Symfony CssSelector (doesn't support CSS4 yet).
     *
     * @var array
     */
    protected $allowed_pseudo_classes = [
        StyleSelector::PSEUDO_CLASS_FIRST_CHILD,
        StyleSelector::PSEUDO_CLASS_ROOT,
        StyleSelector::PSEUDO_CLASS_NTH_CHILD,
        StyleSelector::PSEUDO_CLASS_NTH_LAST_CHILD,
        StyleSelector::PSEUDO_CLASS_NTH_OF_TYPE,
        StyleSelector::PSEUDO_CLASS_NTH_LAST_OF_TYPE,
        StyleSelector::PSEUDO_CLASS_LAST_CHILD,
        StyleSelector::PSEUDO_CLASS_FIRST_OF_TYPE,
        StyleSelector::PSEUDO_CLASS_LAST_OF_TYPE,
        StyleSelector::PSEUDO_CLASS_ONLY_CHILD,
        StyleSelector::PSEUDO_CLASS_ONLY_OF_TYPE,
        StyleSelector::PSEUDO_CLASS_EMPTY,
        StyleSelector::PSEUDO_CLASS_NOT,
    ];

    /**
     * The stylesheet reader instance
     *
     * @var \Crossjoin\Css\Reader\CssString
     */
    protected $stylesheet;

    /**
     * The charset of the stylesheet
     *
     * @var string
     */
    protected $charset;

    /**
     * Create a new instance of "Relevant Selector Parser"
     *
     * @param  \Crossjoin\Css\Reader\CssString|string|null  $stylesheet
     * @param  string                                       $charset
     */
    public function __construct($stylesheet = null, $charset = 'UTF-8')
    {
        $this->charset = $charset;

        if ( ! is_null($stylesheet))
        {
            $this->setStylesheetReader($stylesheet);
        }
    }

    /**
     * Get the relevant selectors
     *
     * @param  \Crossjoin\Css\Reader\CssString  $reader

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

     * @return array
     */
    public function extract()
    {
        $selectors = [];
        $rules     = $this->reader->getStyleSheet()->getRules();

The property reader does not exist. Did you maybe forget to declare it?

        $relevant  = $this->getRelevantStyleRules($rules);

        foreach ($relevant as $rule)
        {
            $this->extractSelector($selectors, $rule);
        }

        return $selectors;
    }

    protected function extractSelector(array &$selectors, $rule)
    {
        foreach ($rule->getSelectors() as $selector)
        {
            if ( ! $this->isPseudoClassAllowed($selector))
            {
                continue;
            }

            $key = $selector->getSpecificity() . '.' . $selector->getValue();

            if (is_null(Arr::get($selectors, $key)))
            {
                Arr::set($selectors, $key, []);
            }

            foreach ($rule->getDeclarations() as $declaration)
            {
                $count = count(Arr::get($selectors, $key)) - 1;

                Arr::set($selectors, "{$key}.{$count}", $declaration);
            }
        }
    }

    /**
     * Set the stylesheet reader instance
     *
     * @param  \Crossjoin\Css\Reader\CssString|string  $stylesheet
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function setStylesheetReader($stylesheet)
    {
        if (is_string($stylesheet))
        {
            $stylesheet = new StylesheetReader($stylesheet);
        }

        if ( ! $stylesheet instanceof StylesheetReader)
        {
            throw new InvalidArgumentException('The argument 0 of the [setStylesheetReader] method expects to be a string of CSS or a [Crossjoin\Css\Reader\CssString]');
        }

        $this->reader = $stylesheet;
        $this->reader->setEnvironmentEncoding($this->getCharset());

        return $this;
    }

    /**
     * Get the stylesheet reader instance
     *
     * @return \Crossjoin\Css\Reader\CssString|null
     */
    public function getStylesheetReader()
    {
        return $this->reader;
    }

    /**
     * Set the charset of the stylesheet
     *
     * @param  string  $charset
     * @return $this
     */
    public function setCharset($charset)
    {
        $this->charset = $charset;

        return $this;
    }

    /**
     * Get the charset of the stylesheet
     *
     * @return string
     */
    public function getCharset()
    {
        return $this->charset;
    }

    /**
     * Check if a Selector has a valid Pseudo Class
     *
     * @param  \Crossjoin\Css\Format\Rule\Style\StyleSelector  $selector
     * @return bool
     */
    public function isPseudoClassAllowed(StyleSelector $selector)
    {
        foreach ($selector->getPseudoClasses() as $pseudo_class)
        {
            if ( ! in_array($pseudo_class, $this->allowed_pseudo_classes))
            {
                return false;
            }
        }

        return true;
    }

    /**
     * Gets all generally relevant style rules
     *
     * @param  RuleAbstract[]  $rules
     * @return StyleRuleSet[]
     */
    protected function getRelevantStyleRules(array $rules)
    {
        $style_rules = [];

        foreach ($rules as $rule)
        {
            if ($rule instanceof StyleRuleSet)
            {
                $style_rules[] = $rule;
            }

            if ($rule instanceof MediaRule)
            {
                $this->getRelevantMediaRule($style_rules, $rule);

$style_rules is of type array, but the function expects a object<Crossjoin\Css\Format\Rule\AtMedia\MediaRule>.

            }
        }

        return $style_rules;
    }

    /**
     * Gets the relevant style rules from a media rule
     *
     * @param  \Crossjoin\Css\Format\Rule\AtMedia\MediaRule  $rule
     * @param  array                                         &$collection
     * @return void
     */
    protected function getRelevantMediaRule(MediaRule $rule, &$collection)
    {
        foreach ($rule->getQueries() as $media_query)
        {
            if ( ! $this->isAllowedMediaRule($media_query))
            {
                continue;
            }

            foreach ($this->getRelevantStyleRules($rule->getRules()) as $style_rule)

$rule->getRules() is of type array<integer,object<Crossjoin\Css\Format\Rule\RuleAbstract>>, but the function expects a array<integer,object<Luminaire\Premailer\Parser\RuleAbstract>>.

            {
                $collection[] = $style_rule;
            }

            break;
        }
    }

    protected function isAllowedMediaRule($media_query)
    {
        $type      = $media_query->getType();
        $condition = count($media_query->getConditions());

        return ($type === MediaQuery::TYPE_ALL || $type === MediaQuery::TYPE_SCREEN) && $condition === 0;
    }

}