CssToInlineStyles::calculatePropertiesToBeApplied() - Code Metrics - Inspection of "Merge branch '2.0'" - tijsverkoyen/CssToInlineStyles - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (bb535b)

by Tijs

created 2016-02-23 13:32 UTC

calculatePropertiesToBeApplied() C

↳ Parent: CssToInlineStyles

Complexity

Conditions	13
Paths	14

Size

Total Lines	59
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
c	3
b	1
f	0
dl	0
loc	59
rs	6.4268
cc	13
eloc	34
nc	14
nop	2

How to fix Long Method Complexity

<?php

namespace TijsVerkoyen\CssToInlineStyles;

use Symfony\Component\CssSelector\CssSelector;
use Symfony\Component\CssSelector\CssSelectorConverter;
use Symfony\Component\CssSelector\Exception\ExceptionInterface;
use TijsVerkoyen\CssToInlineStyles\Css\Processor;
use TijsVerkoyen\CssToInlineStyles\Css\Property\Processor as PropertyProcessor;
use TijsVerkoyen\CssToInlineStyles\Css\Rule\Rule;

class CssToInlineStyles
{
    /**
     * Will inline the $css into the given $html
     *
     * Remark: if the html contains <style>-tags those will be used, the rules
     * in $css will be appended.
     *
     * @param string $html
     * @param string $css
     * @return string
     */
    public function convert($html, $css = null)
    {
        $document = $this->createDomDocumentFromHtml($html);
        $processor = new Processor();

        // get all styles from the style-tags
        $rules = $processor->getRules(
            $processor->getCssFromStyleTags($html)
        );

        if ($css !== null) {
            $rules = $processor->getRules($css, $rules);
        }

        $document = $this->inline($document, $rules);

        return $this->getHtmlFromDocument($document);
    }

    /**
     * Inle the given properties on an given DOMElement
     *
     * @param \DOMElement             $element
     * @param Css\Property\Property[] $properties
     * @return \DOMElement
     */
    public function inlineCssOnElement(\DOMElement $element, array $properties)
    {
        if (empty($properties)) {
            return $element;
        }

        $cssProperties = array();
        $inlineProperties = $this->getInlineStyles($element);

        if (!empty($inlineProperties)) {
            foreach ($inlineProperties as $property) {
                $cssProperties[$property->getName()] = $property;
            }
        }

        foreach ($properties as $property) {
            if (!isset($cssProperties[$property->getName()])) {
                $cssProperties[$property->getName()] = $property;
            }
        }

        $rules = array();
        foreach ($cssProperties as $property) {
            $rules[] = $property->toString();
        }
        $element->setAttribute('style', implode(' ', $rules));

        return $element;
    }

    /**
     * Get the current inline styles for a given DOMElement
     *
     * @param \DOMElement $element
     * @return Css\Property\Property[]
     */
    public function getInlineStyles(\DOMElement $element)
    {
        $processor = new PropertyProcessor();

        return $processor->convertArrayToObjects(
            $processor->splitIntoSeparateProperties(
                $element->getAttribute('style')
            )
        );
    }

    /**
     * @param string $html
     * @return \DOMDocument
     */
    protected function createDomDocumentFromHtml($html)
    {
        $document = new \DOMDocument('1.0', 'UTF-8');
        $internalErrors = libxml_use_internal_errors(true);
        $document->loadHTML($html);
        libxml_use_internal_errors($internalErrors);
        $document->formatOutput = true;

        return $document;
    }

    /**
     * @param \DOMDocument $document
     * @return string
     */
    protected function getHtmlFromDocument(\DOMDocument $document)
    {
        $xml = $document->saveXML(null, LIBXML_NOEMPTYTAG);

        $html = preg_replace(
            '|<\?xml (.*)\?>|',
            '',
            $xml
        );

        return ltrim($html);
    }

    /**
     * @param \DOMDocument    $document
     * @param Css\Rule\Rule[] $rules
     * @return \DOMDocument
     */
    protected function inline(\DOMDocument $document, array $rules)
    {
        if (empty($rules)) {
            return $document;
        }

        $xPath = new \DOMXPath($document);
        foreach ($rules as $rule) {
            try {
                if (class_exists('Symfony\Component\CssSelector\CssSelectorConverter')) {
                    $converter = new CssSelectorConverter();
                    $expression = $converter->toXPath($rule->getSelector());
                } else {
                    $expression = CssSelector::toXPath($rule->getSelector());
                }
            } catch (ExceptionInterface $e) {
                continue;
            }

            $elements = $xPath->query($expression);

            if ($elements === false) {
                continue;
            }

            foreach ($elements as $element) {
                $this->calculatePropertiesToBeApplied($element, $rule->getProperties());
            }
        }

        $elements = $xPath->query('//*[@data-css-to-inline-styles]');

        foreach ($elements as $element) {
            $propertiesToBeApplied = $element->attributes->getNamedItem('data-css-to-inline-styles');
            $element->removeAttribute('data-css-to-inline-styles');

            if ($propertiesToBeApplied !== null) {
                $properties = unserialize(base64_decode($propertiesToBeApplied->value));
                $this->inlineCssOnElement($element, $properties);
            }
        }

        return $document;
    }

    /**
     * Store the calculated values in a temporary data-attribute
     *
     * @param \DOMElement             $element
     * @param Css\Property\Property[] $properties
     * @return \DOMElement
     */
    private function calculatePropertiesToBeApplied(
        \DOMElement $element,
        array $properties
    ) {
        if (empty($properties)) {
            return $element;
        }

        $cssProperties = array();
        $currentStyles = $element->attributes->getNamedItem('data-css-to-inline-styles');

        if ($currentStyles !== null) {
            $currentProperties = unserialize(
                base64_decode(
                    $currentStyles->value
                )
            );

            foreach ($currentProperties as $property) {
                $cssProperties[$property->getName()] = $property;
            }
        }

        foreach ($properties as $property) {
            if (isset($cssProperties[$property->getName()])) {
                $existingProperty = $cssProperties[$property->getName()];

                if (
                    ($existingProperty->isImportant() && $property->isImportant()) &&
                    ($existingProperty->getOriginalSpecificity()->compareTo($property->getOriginalSpecificity()) <= 0)
                ) {
                    // if both the properties are important we should use the specificity
                    $cssProperties[$property->getName()] = $property;
                } elseif (!$existingProperty->isImportant() && $property->isImportant()) {
                    // if the existing property is not important but the new one is, it should be overruled
                    $cssProperties[$property->getName()] = $property;
                } elseif (
                    !$existingProperty->isImportant() &&
                    ($existingProperty->getOriginalSpecificity()->compareTo($property->getOriginalSpecificity()) <= 0)
                ) {
                    // if the existing property is not important we should check the specificity
                    $cssProperties[$property->getName()] = $property;
                }
            } else {
                $cssProperties[$property->getName()] = $property;
            }
        }

        $element->setAttribute(
            'data-css-to-inline-styles',
            base64_encode(
                serialize(
                    array_values($cssProperties)
                )
            )
        );

        return $element;
    }
}


1			<?php
2
3			namespace TijsVerkoyen\CssToInlineStyles;
4
5			use Symfony\Component\CssSelector\CssSelector;
6			use Symfony\Component\CssSelector\CssSelectorConverter;
7			use Symfony\Component\CssSelector\Exception\ExceptionInterface;
8			use TijsVerkoyen\CssToInlineStyles\Css\Processor;
9			use TijsVerkoyen\CssToInlineStyles\Css\Property\Processor as PropertyProcessor;
10			use TijsVerkoyen\CssToInlineStyles\Css\Rule\Rule;
11
12			class CssToInlineStyles
13			{
14			/**
15			* Will inline the $css into the given $html
16			*
17			* Remark: if the html contains <style>-tags those will be used, the rules
18			* in $css will be appended.
19			*
20			* @param string $html
21			* @param string $css
22			* @return string
23			*/
24			public function convert($html, $css = null)
25			{
26			$document = $this->createDomDocumentFromHtml($html);
27			$processor = new Processor();
28
29			// get all styles from the style-tags
30			$rules = $processor->getRules(
31			$processor->getCssFromStyleTags($html)
32			);
33
34			if ($css !== null) {
35			$rules = $processor->getRules($css, $rules);
36			}
37
38			$document = $this->inline($document, $rules);
39
40			return $this->getHtmlFromDocument($document);
41			}
42
43			/**
44			* Inle the given properties on an given DOMElement
45			*
46			* @param \DOMElement $element
47			* @param Css\Property\Property[] $properties
48			* @return \DOMElement
49			*/
50			public function inlineCssOnElement(\DOMElement $element, array $properties)
51			{
52			if (empty($properties)) {
53			return $element;
54			}
55
56			$cssProperties = array();
57			$inlineProperties = $this->getInlineStyles($element);
58
59			if (!empty($inlineProperties)) {
60			foreach ($inlineProperties as $property) {
61			$cssProperties[$property->getName()] = $property;
62			}
63			}
64
65			foreach ($properties as $property) {
66			if (!isset($cssProperties[$property->getName()])) {
67			$cssProperties[$property->getName()] = $property;
68			}
69			}
70
71			$rules = array();
72			foreach ($cssProperties as $property) {
73			$rules[] = $property->toString();
74			}
75			$element->setAttribute('style', implode(' ', $rules));
76
77			return $element;
78			}
79
80			/**
81			* Get the current inline styles for a given DOMElement
82			*
83			* @param \DOMElement $element
84			* @return Css\Property\Property[]
85			*/
86			public function getInlineStyles(\DOMElement $element)
87			{
88			$processor = new PropertyProcessor();
89
90			return $processor->convertArrayToObjects(
91			$processor->splitIntoSeparateProperties(
92			$element->getAttribute('style')
93			)
94			);
95			}
96
97			/**
98			* @param string $html
99			* @return \DOMDocument
100			*/
101			protected function createDomDocumentFromHtml($html)
102			{
103			$document = new \DOMDocument('1.0', 'UTF-8');
104			$internalErrors = libxml_use_internal_errors(true);
105			$document->loadHTML($html);
106			libxml_use_internal_errors($internalErrors);
107			$document->formatOutput = true;
108
109			return $document;
110			}
111
112			/**
113			* @param \DOMDocument $document
114			* @return string
115			*/
116			protected function getHtmlFromDocument(\DOMDocument $document)
117			{
118			$xml = $document->saveXML(null, LIBXML_NOEMPTYTAG);
119
120			$html = preg_replace(
121			'\|<\?xml (.*)\?>\|',
122			'',
123			$xml
124			);
125
126			return ltrim($html);
127			}
128
129			/**
130			* @param \DOMDocument $document
131			* @param Css\Rule\Rule[] $rules
132			* @return \DOMDocument
133			*/
134			protected function inline(\DOMDocument $document, array $rules)
135			{
136			if (empty($rules)) {
137			return $document;
138			}
139
140			$xPath = new \DOMXPath($document);
141			foreach ($rules as $rule) {
142			try {
143			if (class_exists('Symfony\Component\CssSelector\CssSelectorConverter')) {
144			$converter = new CssSelectorConverter();
145			$expression = $converter->toXPath($rule->getSelector());
146			} else {
147			$expression = CssSelector::toXPath($rule->getSelector());
148			}
149			} catch (ExceptionInterface $e) {
150			continue;
151			}
152
153			$elements = $xPath->query($expression);
154
155			if ($elements === false) {
156			continue;
157			}
158
159			foreach ($elements as $element) {
160			$this->calculatePropertiesToBeApplied($element, $rule->getProperties());
161			}
162			}
163
164			$elements = $xPath->query('//*[@data-css-to-inline-styles]');
165
166			foreach ($elements as $element) {
167			$propertiesToBeApplied = $element->attributes->getNamedItem('data-css-to-inline-styles');
168			$element->removeAttribute('data-css-to-inline-styles');
169
170			if ($propertiesToBeApplied !== null) {
171			$properties = unserialize(base64_decode($propertiesToBeApplied->value));
172			$this->inlineCssOnElement($element, $properties);
173			}
174			}
175
176			return $document;
177			}
178
179			/**
180			* Store the calculated values in a temporary data-attribute
181			*
182			* @param \DOMElement $element
183			* @param Css\Property\Property[] $properties
184			* @return \DOMElement
185			*/
186			private function calculatePropertiesToBeApplied(
187			\DOMElement $element,
188			array $properties
189			) {
190			if (empty($properties)) {
191			return $element;
192			}
193
194			$cssProperties = array();
195			$currentStyles = $element->attributes->getNamedItem('data-css-to-inline-styles');
196
197			if ($currentStyles !== null) {
198			$currentProperties = unserialize(
199			base64_decode(
200			$currentStyles->value
201			)
202			);
203
204			foreach ($currentProperties as $property) {
205			$cssProperties[$property->getName()] = $property;
206			}
207			}
208
209			foreach ($properties as $property) {
210			if (isset($cssProperties[$property->getName()])) {
211			$existingProperty = $cssProperties[$property->getName()];
212
213			if (
214			($existingProperty->isImportant() && $property->isImportant()) &&
215			($existingProperty->getOriginalSpecificity()->compareTo($property->getOriginalSpecificity()) <= 0)
216			) {
217			// if both the properties are important we should use the specificity
218			$cssProperties[$property->getName()] = $property;
219			} elseif (!$existingProperty->isImportant() && $property->isImportant()) {
220			// if the existing property is not important but the new one is, it should be overruled
221			$cssProperties[$property->getName()] = $property;
222			} elseif (
223			!$existingProperty->isImportant() &&
224			($existingProperty->getOriginalSpecificity()->compareTo($property->getOriginalSpecificity()) <= 0)
225			) {
226			// if the existing property is not important we should check the specificity
227			$cssProperties[$property->getName()] = $property;
228			}
229			} else {
230			$cssProperties[$property->getName()] = $property;
231			}
232			}
233
234			$element->setAttribute(
235			'data-css-to-inline-styles',
236			base64_encode(
237			serialize(
238			array_values($cssProperties)
239			)
240			)
241			);
242
243			return $element;
244			}
245			}
246

tijsverkoyen / CssToInlineStyles

Branch — master (bb535b)

calculatePropertiesToBeApplied() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like