CssToInlineStyles::convert() - Code Metrics - RainLoop/rainloop-webmail - Measure and Improve Code Quality continuously with Scrutinizer

CssToInlineStyles::convert() F
last analyzed 2019-04-17 21:09 UTC

↳ Parent: CssToInlineStyles

Complexity

Conditions	38
Paths	76

Size

Total Lines

265

Duplication

Lines	54
Ratio	20.38 %

Importance

Changes

Metric	Value
cc	38
nc	76
nop	1
dl	54
loc	265
rs	3.3333
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

namespace TijsVerkoyen\CssToInlineStyles;

/**
 * CSS to Inline Styles class
 *
 * @author		Tijs Verkoyen <[email protected]>
 * @version		1.1.0
 * @copyright	Copyright (c), Tijs Verkoyen. All rights reserved.
 * @license		BSD License
 */
class CssToInlineStyles
{
    /**
     * The CSS to use
     *
     * @var	string
     */
    private $css;

    /**
     * The processed CSS rules
     *
     * @var	array
     */
    private $cssRules;

    /**
     * Should the generated HTML be cleaned
     *
     * @var	bool
     */
    private $cleanup = false;

    /**
     * The encoding to use.
     *
     * @var	string
     */
    private $encoding = 'UTF-8';

    /**
     * The HTML to process
     *
     * @var	string
     */
    private $html;

    /**
     * Use inline-styles block as CSS
     *
     * @var	bool
     */
    private $useInlineStylesBlock = false;

    /*
     * Strip original style tags
     *
     * @var bool
     */
    private $stripOriginalStyleTags = false;

    /**
     * Creates an instance, you could set the HTML and CSS here, or load it
     * later.
     *
     * @return void

     * @param  string[optional] $html The HTML to process.
     * @param  string[optional] $css  The CSS to use.
     */
    public function __construct($html = null, $css = null)
    {
        if($html !== null) $this->setHTML($html);
        if($css !== null) $this->setCSS($css);
    }

    /**
     * Convert a CSS-selector into an xPath-query
     *
     * @return string
     * @param  string $selector The CSS-selector.
     */
    private function buildXPathQuery($selector)
    {
        // redefine
        $selector = (string) $selector;

        // the CSS selector
        $cssSelector = array(
            // E F, Matches any F element that is a descendant of an E element
            '/(\w)\s+(\w)/',
            // E > F, Matches any F element that is a child of an element E
            '/(\w)\s*>\s*(\w)/',
            // E:first-child, Matches element E when E is the first child of its parent
            '/(\w):first-child/',
            // E + F, Matches any F element immediately preceded by an element
            '/(\w)\s*\+\s*(\w)/',
            // E[foo], Matches any E element with the "foo" attribute set (whatever the value)
            '/(\w)\[([\w\-]+)]/',
            // E[foo="warning"], Matches any E element whose "foo" attribute value is exactly equal to "warning"
            '/(\w)\[([\w\-]+)\=\"(.*)\"]/',
            // div.warning, HTML only. The same as DIV[class~="warning"]
            '/(\w+|\*)+\.([\w\-]+)+/',
            // .warning, HTML only. The same as *[class~="warning"]
            '/\.([\w\-]+)/',
            // E#myid, Matches any E element with id-attribute equal to "myid"
            '/(\w+)+\#([\w\-]+)/',
            // #myid, Matches any element with id-attribute equal to "myid"
            '/\#([\w\-]+)/'
        );

        // the xPath-equivalent
        $xPathQuery = array(
            // E F, Matches any F element that is a descendant of an E element
            '\1//\2',
            // E > F, Matches any F element that is a child of an element E
            '\1/\2',
            // E:first-child, Matches element E when E is the first child of its parent
            '*[1]/self::\1',
            // E + F, Matches any F element immediately preceded by an element
            '\1/following-sibling::*[1]/self::\2',
            // E[foo], Matches any E element with the "foo" attribute set (whatever the value)
            '\1 [ @\2 ]',
            // E[foo="warning"], Matches any E element whose "foo" attribute value is exactly equal to "warning"
            '\1[ contains( concat( " ", @\2, " " ), concat( " ", "\3", " " ) ) ]',
            // div.warning, HTML only. The same as DIV[class~="warning"]
            '\1[ contains( concat( " ", @class, " " ), concat( " ", "\2", " " ) ) ]',
            // .warning, HTML only. The same as *[class~="warning"]
            '*[ contains( concat( " ", @class, " " ), concat( " ", "\1", " " ) ) ]',
            // E#myid, Matches any E element with id-attribute equal to "myid"
            '\1[ @id = "\2" ]',
            // #myid, Matches any element with id-attribute equal to "myid"
            '*[ @id = "\1" ]'
        );

        // return
        $xPath = (string) '//' . preg_replace($cssSelector, $xPathQuery, $selector);

        return str_replace('] *', ']//*', $xPath);
    }

    /**
     * Calculate the specifity for the CSS-selector
     *
     * @return int
     * @param  string $selector The selector to calculate the specifity for.
     */
    private function calculateCSSSpecifity($selector)
    {
        // cleanup selector
        $selector = str_replace(array('>', '+'), array(' > ', ' + '), $selector);

        // init var
        $specifity = 0;

        // split the selector into chunks based on spaces
        $chunks = explode(' ', $selector);

        // loop chunks
        foreach ($chunks as $chunk) {
            // an ID is important, so give it a high specifity
            if(strstr($chunk, '#') !== false) $specifity += 100;

            // classes are more important than a tag, but less important then an ID
            elseif(strstr($chunk, '.')) $specifity += 10;

            // anything else isn't that important
            else $specifity += 1;
        }

        // return
        return $specifity;
    }


    /**
     * Cleanup the generated HTML
     *
     * @return string
     * @param  string $html The HTML to cleanup.
     */
    private function cleanupHTML($html)
    {
        // remove classes
        $html = preg_replace('/(\s)+class="(.*)"(\s)+/U', ' ', $html);

        // remove IDs
        $html = preg_replace('/(\s)+id="(.*)"(\s)+/U', ' ', $html);

        // return
        return $html;
    }


    /**
     * Converts the loaded HTML into an HTML-string with inline styles based on the loaded CSS
     *
     * @return string
     * @param  bool[optional] $outputXHTML Should we output valid XHTML?
     */
    public function convert($outputXHTML = false)
    {
        // redefine
        $outputXHTML = (bool) $outputXHTML;

        // validate
        if($this->html == null) throw new Exception('No HTML provided.');

        // should we use inline style-block
        if ($this->useInlineStylesBlock) {
            // init var
            $matches = array();

            // match the style blocks
            preg_match_all('|<style(.*)>(.*)</style>|isU', $this->html, $matches);

            // any style-blocks found?
            if (!empty($matches[2])) {
                // add
                foreach($matches[2] as $match) $this->css .= trim($match) ."\n";
            }
        }

        // process css
        $this->processCSS();

        // create new DOMDocument
        $document = new \DOMDocument('1.0', $this->getEncoding());

        // set error level
        libxml_use_internal_errors(true);

        // load HTML
//        $document->loadHTML($this->html);
        $document->loadHTML('<'.'?xml version="1.0" encoding="'.$this->getEncoding().'"?'.'><head><meta http-equiv="Content-Type" content="text/html; charset='.$this->getEncoding().'"></head>'.$this->html);

        // create new XPath
        $xPath = new \DOMXPath($document);

        // any rules?
        if (!empty($this->cssRules)) {
            // loop rules
            foreach ($this->cssRules as $rule) {
                // init var
                $query = $this->buildXPathQuery($rule['selector']);

                // validate query
                if($query === false) continue;

                // search elements
                $elements = $xPath->query($query);

                // validate elements
                if($elements === false) continue;

                // loop found elements
                foreach ($elements as $element) {
                    // no styles stored?
                    if ($element->attributes->getNamedItem(
                        'data-css-to-inline-styles-original-styles'
                    ) == null) {
                        // init var
                        $originalStyle = '';
                        if ($element->attributes->getNamedItem('style') !== null) {
                            $originalStyle = $element->attributes->getNamedItem('style')->value;
                        }

                        // store original styles
                        $element->setAttribute(
                            'data-css-to-inline-styles-original-styles',
                            $originalStyle
                        );

                        // clear the styles
                        $element->setAttribute('style', '');
                    }

                    // init var
                    $properties = array();

                    // get current styles
                    $stylesAttribute = $element->attributes->getNamedItem('style');

                    // any styles defined before?
                    if ($stylesAttribute !== null) {

                        // get value for the styles attribute
                        $definedStyles = (string) $stylesAttribute->value;

                        // split into properties
                        $definedProperties = (array) explode(';', $definedStyles);

                        // loop properties
                        foreach ($definedProperties as $property) {
                            // validate property
                            if($property == '') continue;

                            // split into chunks
                            $chunks = (array) explode(':', trim($property), 2);

                            // validate
                            if(!isset($chunks[1])) continue;

                            // loop chunks
                            $properties[$chunks[0]] = trim($chunks[1]);
                        }
                    }

                    // add new properties into the list
                    foreach ($rule['properties'] as $key => $value) {
                        $properties[$key] = $value;
                    }

                    // build string
                    $propertyChunks = array();

                    // build chunks
                    foreach ($properties as $key => $values) {

                        foreach ((array) $values as $value) {
                            $propertyChunks[] = $key . ': ' . $value . ';';
                        }
                    }

                    // build properties string
                    $propertiesString = implode(' ', $propertyChunks);

                    // set attribute
                    if ($propertiesString != '') {
                        $element->setAttribute('style', $propertiesString);
                    }
                }
            }

            // reapply original styles
            $query = $this->buildXPathQuery(
                '*[@data-css-to-inline-styles-original-styles]'
            );

            // validate query
            if($query === false) return;

            // search elements
            $elements = $xPath->query($query);

            // loop found elements
            foreach ($elements as $element) {
                // get the original styles
                $originalStyle = $element->attributes->getNamedItem(
                    'data-css-to-inline-styles-original-styles'
                )->value;

                if ($originalStyle != '') {
                    $originalProperties = array();
                    $originalStyles = (array) explode(';', $originalStyle);

                    foreach ($originalStyles as $property) {
                        // validate property
                        if($property == '') continue;

                        // split into chunks
                        $chunks = (array) explode(':', trim($property), 2);

                        // validate
                        if(!isset($chunks[1])) continue;

                        // loop chunks
                        $originalProperties[$chunks[0]] = trim($chunks[1]);
                    }

                    // get current styles
                    $stylesAttribute = $element->attributes->getNamedItem('style');
                    $properties = array();

                    // any styles defined before?
                    if ($stylesAttribute !== null) {

                        // get value for the styles attribute
                        $definedStyles = (string) $stylesAttribute->value;

                        // split into properties
                        $definedProperties = (array) explode(';', $definedStyles);

                        // loop properties
                        foreach ($definedProperties as $property) {
                            // validate property
                            if($property == '') continue;

                            // split into chunks
                            $chunks = (array) explode(':', trim($property), 2);

                            // validate
                            if(!isset($chunks[1])) continue;

                            // loop chunks
                            $properties[$chunks[0]] = trim($chunks[1]);
                        }
                    }

                    // add new properties into the list
                    foreach ($originalProperties as $key => $value) {
                        $properties[$key] = $value;
                    }

                    // build string
                    $propertyChunks = array();

                    // build chunks
                    foreach ($properties as $key => $values) {

                        foreach ((array) $values as $value) {
                            $propertyChunks[] = $key . ': ' . $value . ';';
                        }
                    }

                    // build properties string
                    $propertiesString = implode(' ', $propertyChunks);

                    // set attribute
                    if($propertiesString != '') $element->setAttribute(
                        'style', $propertiesString
                    );
                }

                // remove placeholder
                $element->removeAttribute(
                    'data-css-to-inline-styles-original-styles'
                );
            }
        }

        // should we output XHTML?
        if ($outputXHTML) {
            // set formating
            $document->formatOutput = true;

            // get the HTML as XML
            $html = $document->saveXML(null, LIBXML_NOEMPTYTAG);

            // get start of the XML-declaration
            $startPosition = strpos($html, '<?xml');

            // valid start position?
            if ($startPosition !== false) {
                // get end of the xml-declaration
                $endPosition = strpos($html, '?>', $startPosition);

                // remove the XML-header
                $html = ltrim(substr($html, $endPosition + 1));
            }
        }

        // just regular HTML 4.01 as it should be used in newsletters
        else {
            // get the HTML
            $html = $document->saveHTML();
        }

        // cleanup the HTML if we need to
        if($this->cleanup) $html = $this->cleanupHTML($html);

        // strip original style tags if we need to
        if ($this->stripOriginalStyleTags) {
            $html = $this->stripOriginalStyleTags($html);
        }

        // return
        return $html;
    }


    /**
     * Get the encoding to use
     *
     * @return string
     */
    private function getEncoding()
    {
        return $this->encoding;
    }


    /**
     * Process the loaded CSS
     *
     * @return void
     */
    private function processCSS()
    {
        // init vars
        $css = (string) $this->css;

        // remove newlines
        $css = str_replace(array("\r", "\n"), '', $css);

        // replace double quotes by single quotes
        $css = str_replace('"', '\'', $css);

        // remove comments
        $css = preg_replace('|/\*.*?\*/|', '', $css);

        // remove spaces
        $css = preg_replace('/\s\s+/', ' ', $css);

        // rules are splitted by }
        $rules = (array) explode('}', $css);

        // init var
        $i = 1;

        // loop rules
        foreach ($rules as $rule) {
            // split into chunks
            $chunks = explode('{', $rule);

            // invalid rule?
            if(!isset($chunks[1])) continue;

            // set the selectors
            $selectors = trim($chunks[0]);

            // get cssProperties
            $cssProperties = trim($chunks[1]);

            // split multiple selectors
            $selectors = (array) explode(',', $selectors);

            // loop selectors
            foreach ($selectors as $selector) {
                // cleanup
                $selector = trim($selector);

                // build an array for each selector
                $ruleSet = array();

                // store selector
                $ruleSet['selector'] = $selector;

                // process the properties
                $ruleSet['properties'] = $this->processCSSProperties(
                    $cssProperties
                );

                // calculate specifity
                $ruleSet['specifity'] = $this->calculateCSSSpecifity(
                    $selector
                ) + $i;

                // add into global rules
                $this->cssRules[] = $ruleSet;
            }

            // increment
            $i++;
        }

        // sort based on specifity
        if (!empty($this->cssRules)) {
            usort($this->cssRules, array(__CLASS__, 'sortOnSpecifity'));
        }
    }

    /**
     * Process the CSS-properties
     *
     * @return array
     * @param  string $propertyString The CSS-properties.
     */
    private function processCSSProperties($propertyString)
    {
        // split into chunks
        $properties = (array) explode(';', $propertyString);

        // init var
        $pairs = array();

        // loop properties
        foreach ($properties as $property) {
            // split into chunks
            $chunks = (array) explode(':', $property, 2);

            // validate
            if(!isset($chunks[1])) continue;

            // cleanup
            $chunks[0] = trim($chunks[0]);
            $chunks[1] = trim($chunks[1]);

            // add to pairs array
            if(!isset($pairs[$chunks[0]]) ||
               !in_array($chunks[1], $pairs[$chunks[0]])) {
                $pairs[$chunks[0]][] = $chunks[1];
            }
        }

        // sort the pairs
        ksort($pairs);

        // return
        return $pairs;
    }

    /**
     * Should the IDs and classes be removed?
     *
     * @return void
     * @param  bool[optional] $on Should we enable cleanup?
     */
    public function setCleanup($on = true)
    {
        $this->cleanup = (bool) $on;
    }

    /**
     * Set CSS to use
     *
     * @return void
     * @param  string $css The CSS to use.
     */
    public function setCSS($css)
    {
        $this->css = (string) $css;
    }

    /**
     * Set the encoding to use with the DOMDocument
     *
     * @return void
     * @param  string $encoding The encoding to use.
     */
    public function setEncoding($encoding)
    {
        $this->encoding = (string) $encoding;
    }

    /**
     * Set HTML to process
     *
     * @return void
     * @param  string $html The HTML to process.
     */
    public function setHTML($html)
    {
        $this->html = (string) $html;
    }

    /**
     * Set use of inline styles block
     * If this is enabled the class will use the style-block in the HTML.
     *
     * @return void
     * @param  bool[optional] $on Should we process inline styles?
     */
    public function setUseInlineStylesBlock($on = true)
    {
        $this->useInlineStylesBlock = (bool) $on;
    }

    /**
     * Set strip original style tags
     * If this is enabled the class will remove all style tags in the HTML.
     *
     * @return void
     * @param  bool[optional] $onShould we process inline styles?
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function setStripOriginalStyleTags($on = true)
    {
        $this->stripOriginalStyleTags = (bool) $on;
    }

    /**
     * Strip style tags into the generated HTML
     *
     * @return string
     * @param  string $html The HTML to strip style tags.
     */
    private function stripOriginalStyleTags($html)
    {
        return preg_replace('|<style(.*)>(.*)</style>|isU', '', $html);
    }

    /**
     * Sort an array on the specifity element
     *
     * @return int
     * @param  array $e1 The first element.
     * @param  array $e2 The second element.
     */
    private static function sortOnSpecifity($e1, $e2)
    {
        // validate
        if(!isset($e1['specifity']) || !isset($e2['specifity'])) return 0;

        // lower
        if($e1['specifity'] < $e2['specifity']) return -1;

        // higher
        if($e1['specifity'] > $e2['specifity']) return 1;

        // fallback
        return 0;
    }
}


1		<?php
2
3		namespace TijsVerkoyen\CssToInlineStyles;
4
5		/**
6		* CSS to Inline Styles class
7		*
8		* @author Tijs Verkoyen <[email protected]>
9		* @version 1.1.0
10		* @copyright Copyright (c), Tijs Verkoyen. All rights reserved.
11		* @license BSD License
12		*/
13		class CssToInlineStyles
14		{
15		/**
16		* The CSS to use
17		*
18		* @var string
19		*/
20		private $css;
21
22		/**
23		* The processed CSS rules
24		*
25		* @var array
26		*/
27		private $cssRules;
28
29		/**
30		* Should the generated HTML be cleaned
31		*
32		* @var bool
33		*/
34		private $cleanup = false;
35
36		/**
37		* The encoding to use.
38		*
39		* @var string
40		*/
41		private $encoding = 'UTF-8';
42
43		/**
44		* The HTML to process
45		*
46		* @var string
47		*/
48		private $html;
49
50		/**
51		* Use inline-styles block as CSS
52		*
53		* @var bool
54		*/
55		private $useInlineStylesBlock = false;
56
57		/*
58		* Strip original style tags
59		*
60		* @var bool
61		*/
62		private $stripOriginalStyleTags = false;
63
64		/**
65		* Creates an instance, you could set the HTML and CSS here, or load it
66		* later.
67		*
68		* @return void
		0 ignored issues – show Comprehensibility Best Practice introduced 2017-10-06 18:56 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
69		* @param string[optional] $html The HTML to process.
70		* @param string[optional] $css The CSS to use.
71		*/
72		public function __construct($html = null, $css = null)
73		{
74		if($html !== null) $this->setHTML($html);
75		if($css !== null) $this->setCSS($css);
76		}
77
78		/**
79		* Convert a CSS-selector into an xPath-query
80		*
81		* @return string
82		* @param string $selector The CSS-selector.
83		*/
84		private function buildXPathQuery($selector)
85		{
86		// redefine
87		$selector = (string) $selector;
88
89		// the CSS selector
90		$cssSelector = array(
91		// E F, Matches any F element that is a descendant of an E element
92		'/(\w)\s+(\w)/',
93		// E > F, Matches any F element that is a child of an element E
94		'/(\w)\s>\s(\w)/',
95		// E:first-child, Matches element E when E is the first child of its parent
96		'/(\w):first-child/',
97		// E + F, Matches any F element immediately preceded by an element
98		'/(\w)\s\+\s(\w)/',
99		// E[foo], Matches any E element with the "foo" attribute set (whatever the value)
100		'/(\w)\[([\w\-]+)]/',
101		// E[foo="warning"], Matches any E element whose "foo" attribute value is exactly equal to "warning"
102		'/(\w)\[([\w\-]+)\=\"(.*)\"]/',
103		// div.warning, HTML only. The same as DIV[class~="warning"]
104		'/(\w+\|\*)+\.([\w\-]+)+/',
105		// .warning, HTML only. The same as *[class~="warning"]
106		'/\.([\w\-]+)/',
107		// E#myid, Matches any E element with id-attribute equal to "myid"
108		'/(\w+)+\#([\w\-]+)/',
109		// #myid, Matches any element with id-attribute equal to "myid"
110		'/\#([\w\-]+)/'
111		);
112
113		// the xPath-equivalent
114		$xPathQuery = array(
115		// E F, Matches any F element that is a descendant of an E element
116		'\1//\2',
117		// E > F, Matches any F element that is a child of an element E
118		'\1/\2',
119		// E:first-child, Matches element E when E is the first child of its parent
120		'*[1]/self::\1',
121		// E + F, Matches any F element immediately preceded by an element
122		'\1/following-sibling::*[1]/self::\2',
123		// E[foo], Matches any E element with the "foo" attribute set (whatever the value)
124		'\1 [ @\2 ]',
125		// E[foo="warning"], Matches any E element whose "foo" attribute value is exactly equal to "warning"
126		'\1[ contains( concat( " ", @\2, " " ), concat( " ", "\3", " " ) ) ]',
127		// div.warning, HTML only. The same as DIV[class~="warning"]
128		'\1[ contains( concat( " ", @class, " " ), concat( " ", "\2", " " ) ) ]',
129		// .warning, HTML only. The same as *[class~="warning"]
130		'*[ contains( concat( " ", @class, " " ), concat( " ", "\1", " " ) ) ]',
131		// E#myid, Matches any E element with id-attribute equal to "myid"
132		'\1[ @id = "\2" ]',
133		// #myid, Matches any element with id-attribute equal to "myid"
134		'*[ @id = "\1" ]'
135		);
136
137		// return
138		$xPath = (string) '//' . preg_replace($cssSelector, $xPathQuery, $selector);
139
140		return str_replace('] ', ']//', $xPath);
141		}
142
143		/**
144		* Calculate the specifity for the CSS-selector
145		*
146		* @return int
147		* @param string $selector The selector to calculate the specifity for.
148		*/
149		private function calculateCSSSpecifity($selector)
150		{
151		// cleanup selector
152		$selector = str_replace(array('>', '+'), array(' > ', ' + '), $selector);
153
154		// init var
155		$specifity = 0;
156
157		// split the selector into chunks based on spaces
158		$chunks = explode(' ', $selector);
159
160		// loop chunks
161		foreach ($chunks as $chunk) {
162		// an ID is important, so give it a high specifity
163		if(strstr($chunk, '#') !== false) $specifity += 100;
164
165		// classes are more important than a tag, but less important then an ID
166		elseif(strstr($chunk, '.')) $specifity += 10;
167
168		// anything else isn't that important
169		else $specifity += 1;
170		}
171
172		// return
173		return $specifity;
174		}
175
176
177		/**
178		* Cleanup the generated HTML
179		*
180		* @return string
181		* @param string $html The HTML to cleanup.
182		*/
183		private function cleanupHTML($html)
184		{
185		// remove classes
186		$html = preg_replace('/(\s)+class="(.*)"(\s)+/U', ' ', $html);
187
188		// remove IDs
189		$html = preg_replace('/(\s)+id="(.*)"(\s)+/U', ' ', $html);
190
191		// return
192		return $html;
193		}
194
195
196		/**
197		* Converts the loaded HTML into an HTML-string with inline styles based on the loaded CSS
198		*
199		* @return string
200		* @param bool[optional] $outputXHTML Should we output valid XHTML?
201		*/
202		public function convert($outputXHTML = false)
203		{
204		// redefine
205		$outputXHTML = (bool) $outputXHTML;
206
207		// validate
208		if($this->html == null) throw new Exception('No HTML provided.');
209
210		// should we use inline style-block
211		if ($this->useInlineStylesBlock) {
212		// init var
213		$matches = array();
214
215		// match the style blocks
216		preg_match_all('\|<style(.)>(.)</style>\|isU', $this->html, $matches);
217
218		// any style-blocks found?
219		if (!empty($matches[2])) {
220		// add
221		foreach($matches[2] as $match) $this->css .= trim($match) ."\n";
222		}
223		}
224
225		// process css
226		$this->processCSS();
227
228		// create new DOMDocument
229		$document = new \DOMDocument('1.0', $this->getEncoding());
230
231		// set error level
232		libxml_use_internal_errors(true);
233
234		// load HTML
235		// $document->loadHTML($this->html);
236		$document->loadHTML('<'.'?xml version="1.0" encoding="'.$this->getEncoding().'"?'.'><head><meta http-equiv="Content-Type" content="text/html; charset='.$this->getEncoding().'"></head>'.$this->html);
237
238		// create new XPath
239		$xPath = new \DOMXPath($document);
240
241		// any rules?
242		if (!empty($this->cssRules)) {
243		// loop rules
244		foreach ($this->cssRules as $rule) {
245		// init var
246		$query = $this->buildXPathQuery($rule['selector']);
247
248		// validate query
249		if($query === false) continue;
250
251		// search elements
252		$elements = $xPath->query($query);
253
254		// validate elements
255		if($elements === false) continue;
256
257		// loop found elements
258		foreach ($elements as $element) {
259		// no styles stored?
260		if ($element->attributes->getNamedItem(
261		'data-css-to-inline-styles-original-styles'
262		) == null) {
263		// init var
264		$originalStyle = '';
265		if ($element->attributes->getNamedItem('style') !== null) {
266		$originalStyle = $element->attributes->getNamedItem('style')->value;
267		}
268
269		// store original styles
270		$element->setAttribute(
271		'data-css-to-inline-styles-original-styles',
272		$originalStyle
273		);
274
275		// clear the styles
276		$element->setAttribute('style', '');
277		}
278
279		// init var
280		$properties = array();
281
282		// get current styles
283		$stylesAttribute = $element->attributes->getNamedItem('style');
284
285		// any styles defined before?
286	View Code Duplication	if ($stylesAttribute !== null) {
		0 ignored issues – show Duplication introduced 2017-10-06 18:56 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
287		// get value for the styles attribute
288		$definedStyles = (string) $stylesAttribute->value;
289
290		// split into properties
291		$definedProperties = (array) explode(';', $definedStyles);
292
293		// loop properties
294		foreach ($definedProperties as $property) {
295		// validate property
296		if($property == '') continue;
297
298		// split into chunks
299		$chunks = (array) explode(':', trim($property), 2);
300
301		// validate
302		if(!isset($chunks[1])) continue;
303
304		// loop chunks
305		$properties[$chunks[0]] = trim($chunks[1]);
306		}
307		}
308
309		// add new properties into the list
310		foreach ($rule['properties'] as $key => $value) {
311		$properties[$key] = $value;
312		}
313
314		// build string
315		$propertyChunks = array();
316
317		// build chunks
318	View Code Duplication	foreach ($properties as $key => $values) {
		0 ignored issues – show Duplication introduced 2017-10-06 18:56 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
319		foreach ((array) $values as $value) {
320		$propertyChunks[] = $key . ': ' . $value . ';';
321		}
322		}
323
324		// build properties string
325		$propertiesString = implode(' ', $propertyChunks);
326
327		// set attribute
328		if ($propertiesString != '') {
329		$element->setAttribute('style', $propertiesString);
330		}
331		}
332		}
333
334		// reapply original styles
335		$query = $this->buildXPathQuery(
336		'*[@data-css-to-inline-styles-original-styles]'
337		);
338
339		// validate query
340		if($query === false) return;
341
342		// search elements
343		$elements = $xPath->query($query);
344
345		// loop found elements
346		foreach ($elements as $element) {
347		// get the original styles
348		$originalStyle = $element->attributes->getNamedItem(
349		'data-css-to-inline-styles-original-styles'
350		)->value;
351
352		if ($originalStyle != '') {
353		$originalProperties = array();
354		$originalStyles = (array) explode(';', $originalStyle);
355
356		foreach ($originalStyles as $property) {
357		// validate property
358		if($property == '') continue;
359
360		// split into chunks
361		$chunks = (array) explode(':', trim($property), 2);
362
363		// validate
364		if(!isset($chunks[1])) continue;
365
366		// loop chunks
367		$originalProperties[$chunks[0]] = trim($chunks[1]);
368		}
369
370		// get current styles
371		$stylesAttribute = $element->attributes->getNamedItem('style');
372		$properties = array();
373
374		// any styles defined before?
375	View Code Duplication	if ($stylesAttribute !== null) {
		0 ignored issues – show Duplication introduced 2017-10-06 18:56 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
376		// get value for the styles attribute
377		$definedStyles = (string) $stylesAttribute->value;
378
379		// split into properties
380		$definedProperties = (array) explode(';', $definedStyles);
381
382		// loop properties
383		foreach ($definedProperties as $property) {
384		// validate property
385		if($property == '') continue;
386
387		// split into chunks
388		$chunks = (array) explode(':', trim($property), 2);
389
390		// validate
391		if(!isset($chunks[1])) continue;
392
393		// loop chunks
394		$properties[$chunks[0]] = trim($chunks[1]);
395		}
396		}
397
398		// add new properties into the list
399		foreach ($originalProperties as $key => $value) {
400		$properties[$key] = $value;
401		}
402
403		// build string
404		$propertyChunks = array();
405
406		// build chunks
407	View Code Duplication	foreach ($properties as $key => $values) {
		0 ignored issues – show Duplication introduced 2017-10-06 18:56 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
408		foreach ((array) $values as $value) {
409		$propertyChunks[] = $key . ': ' . $value . ';';
410		}
411		}
412
413		// build properties string
414		$propertiesString = implode(' ', $propertyChunks);
415
416		// set attribute
417		if($propertiesString != '') $element->setAttribute(
418		'style', $propertiesString
419		);
420		}
421
422		// remove placeholder
423		$element->removeAttribute(
424		'data-css-to-inline-styles-original-styles'
425		);
426		}
427		}
428
429		// should we output XHTML?
430		if ($outputXHTML) {
431		// set formating
432		$document->formatOutput = true;
433
434		// get the HTML as XML
435		$html = $document->saveXML(null, LIBXML_NOEMPTYTAG);
436
437		// get start of the XML-declaration
438		$startPosition = strpos($html, '<?xml');
439
440		// valid start position?
441		if ($startPosition !== false) {
442		// get end of the xml-declaration
443		$endPosition = strpos($html, '?>', $startPosition);
444
445		// remove the XML-header
446		$html = ltrim(substr($html, $endPosition + 1));
447		}
448		}
449
450		// just regular HTML 4.01 as it should be used in newsletters
451		else {
452		// get the HTML
453		$html = $document->saveHTML();
454		}
455
456		// cleanup the HTML if we need to
457		if($this->cleanup) $html = $this->cleanupHTML($html);
458
459		// strip original style tags if we need to
460		if ($this->stripOriginalStyleTags) {
461		$html = $this->stripOriginalStyleTags($html);
462		}
463
464		// return
465		return $html;
466		}
467
468
469		/**
470		* Get the encoding to use
471		*
472		* @return string
473		*/
474		private function getEncoding()
475		{
476		return $this->encoding;
477		}
478
479
480		/**
481		* Process the loaded CSS
482		*
483		* @return void
484		*/
485		private function processCSS()
486		{
487		// init vars
488		$css = (string) $this->css;
489
490		// remove newlines
491		$css = str_replace(array("\r", "\n"), '', $css);
492
493		// replace double quotes by single quotes
494		$css = str_replace('"', '\'', $css);
495
496		// remove comments
497		$css = preg_replace('\|/\.?\*/\|', '', $css);
498
499		// remove spaces
500		$css = preg_replace('/\s\s+/', ' ', $css);
501
502		// rules are splitted by }
503		$rules = (array) explode('}', $css);
504
505		// init var
506		$i = 1;
507
508		// loop rules
509		foreach ($rules as $rule) {
510		// split into chunks
511		$chunks = explode('{', $rule);
512
513		// invalid rule?
514		if(!isset($chunks[1])) continue;
515
516		// set the selectors
517		$selectors = trim($chunks[0]);
518
519		// get cssProperties
520		$cssProperties = trim($chunks[1]);
521
522		// split multiple selectors
523		$selectors = (array) explode(',', $selectors);
524
525		// loop selectors
526		foreach ($selectors as $selector) {
527		// cleanup
528		$selector = trim($selector);
529
530		// build an array for each selector
531		$ruleSet = array();
532
533		// store selector
534		$ruleSet['selector'] = $selector;
535
536		// process the properties
537		$ruleSet['properties'] = $this->processCSSProperties(
538		$cssProperties
539		);
540
541		// calculate specifity
542		$ruleSet['specifity'] = $this->calculateCSSSpecifity(
543		$selector
544		) + $i;
545
546		// add into global rules
547		$this->cssRules[] = $ruleSet;
548		}
549
550		// increment
551		$i++;
552		}
553
554		// sort based on specifity
555		if (!empty($this->cssRules)) {
556		usort($this->cssRules, array(__CLASS__, 'sortOnSpecifity'));
557		}
558		}
559
560		/**
561		* Process the CSS-properties
562		*
563		* @return array
564		* @param string $propertyString The CSS-properties.
565		*/
566		private function processCSSProperties($propertyString)
567		{
568		// split into chunks
569		$properties = (array) explode(';', $propertyString);
570
571		// init var
572		$pairs = array();
573
574		// loop properties
575		foreach ($properties as $property) {
576		// split into chunks
577		$chunks = (array) explode(':', $property, 2);
578
579		// validate
580		if(!isset($chunks[1])) continue;
581
582		// cleanup
583		$chunks[0] = trim($chunks[0]);
584		$chunks[1] = trim($chunks[1]);
585
586		// add to pairs array
587		if(!isset($pairs[$chunks[0]]) \|\|
588		!in_array($chunks[1], $pairs[$chunks[0]])) {
589		$pairs[$chunks[0]][] = $chunks[1];
590		}
591		}
592
593		// sort the pairs
594		ksort($pairs);
595
596		// return
597		return $pairs;
598		}
599
600		/**
601		* Should the IDs and classes be removed?
602		*
603		* @return void
604		* @param bool[optional] $on Should we enable cleanup?
605		*/
606		public function setCleanup($on = true)
607		{
608		$this->cleanup = (bool) $on;
609		}
610
611		/**
612		* Set CSS to use
613		*
614		* @return void
615		* @param string $css The CSS to use.
616		*/
617		public function setCSS($css)
618		{
619		$this->css = (string) $css;
620		}
621
622		/**
623		* Set the encoding to use with the DOMDocument
624		*
625		* @return void
626		* @param string $encoding The encoding to use.
627		*/
628		public function setEncoding($encoding)
629		{
630		$this->encoding = (string) $encoding;
631		}
632
633		/**
634		* Set HTML to process
635		*
636		* @return void
637		* @param string $html The HTML to process.
638		*/
639		public function setHTML($html)
640		{
641		$this->html = (string) $html;
642		}
643
644		/**
645		* Set use of inline styles block
646		* If this is enabled the class will use the style-block in the HTML.
647		*
648		* @return void
649		* @param bool[optional] $on Should we process inline styles?
650		*/
651		public function setUseInlineStylesBlock($on = true)
652		{
653		$this->useInlineStylesBlock = (bool) $on;
654		}
655
656		/**
657		* Set strip original style tags
658		* If this is enabled the class will remove all style tags in the HTML.
659		*
660		* @return void
661		* @param bool[optional] $onShould we process inline styles?
		0 ignored issues – show Bug introduced 2017-10-06 18:56 UTC by Report Bug Copy Issue Report There is no parameter named `$onShould`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
662		*/
663		public function setStripOriginalStyleTags($on = true)
664		{
665		$this->stripOriginalStyleTags = (bool) $on;
666		}
667
668		/**
669		* Strip style tags into the generated HTML
670		*
671		* @return string
672		* @param string $html The HTML to strip style tags.
673		*/
674		private function stripOriginalStyleTags($html)
675		{
676		return preg_replace('\|<style(.)>(.)</style>\|isU', '', $html);
677		}
678
679		/**
680		* Sort an array on the specifity element
681		*
682		* @return int
683		* @param array $e1 The first element.
684		* @param array $e2 The second element.
685		*/
686		private static function sortOnSpecifity($e1, $e2)
687		{
688		// validate
689		if(!isset($e1['specifity']) \|\| !isset($e2['specifity'])) return 0;
690
691		// lower
692		if($e1['specifity'] < $e2['specifity']) return -1;
693
694		// higher
695		if($e1['specifity'] > $e2['specifity']) return 1;
696
697		// fallback
698		return 0;
699		}
700		}
701

RainLoop / rainloop-webmail

CssToInlineStyles::convert() F last analyzed 2019-04-17 21:09 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

CssToInlineStyles::convert() F
last analyzed 2019-04-17 21:09 UTC