Luminaire\Premailer\Parser\RelevantSelectorParser

Complexity

Total Complexity

32

Size/Duplication

Total Lines	271
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	2
Bugs	1	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	extract()	0	13	2
A	populateSelectors()	0	21	4
A	storeDeclaration()	0	4	1
A	prepareSelectorArray()	0	14	3
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->populateSelectors($selectors, $rule);
        }

        return $selectors;
    }

    /**
     * Store the selectors from the rule to the tank
     *
     * @param  array   &$tank
     * @param  array   $selectors

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

     * @return void
     */
    protected function populateSelectors(array &$tank, $rule)
    {
        foreach ($rule->getSelectors() as $selector)
        {
            if ( ! $this->isPseudoClassAllowed($selector))
            {
                continue;
            }

            $position = $this->prepareSelectorArray(

Are you sure the assignment to $position is correct as $this->prepareSelectorArray($tank, $selector->getSpecificity(), $selector->getValue()) (which targets Luminaire\Premailer\Parser\RelevantSelectorParser::prepareSelectorArray()) seems to always return null.

                $tank,
                $selector->getSpecificity(),
                $selector->getValue()
            );

            foreach ($rule->getDeclarations() as $declaration)
            {
                $this->storeDeclaration($position, $declaration);

It seems like $position defined by $this->prepareSelectorArray($tank, $selector->getSpecificity(), $selector->getValue()) on line 117 can also be of type null; however, Luminaire\Premailer\Parser\RelevantSelectorParser::storeDeclaration() does only seem to accept array, maybe add an additional type check?

            }
        }
    }

    protected function storeDeclaration(array &$tank, $declaration)
    {
        $tank[] = $declaration;
    }

    /**
     * Before building the dictionary of declaration we will need to make sure
     * there are an empty array.
     *
     * @param  array   &$selectors
     * @param  string  $specifity
     * @param  string  $name
     * @return void
     */
    protected function prepareSelectorArray(array &$selectors, $specifity, $name)
    {
        if ( ! isset($selectors[$specifity]))
        {
            $selectors[$specifity] = [];
        }

        if ( ! isset($selectors[$specifity][$name]))
        {
            $selectors[$specifity][$name] = [];
        }

        return $selectors[$specifity][$name];
    }

    /**
     * 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($rule, $style_rules);
            }
        }

        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;
    }

}