Laravel version update

Laravel version update

vendor/tijsverkoyen/css-to-inline-styles/src/Css/Processor.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace TijsVerkoyen\CssToInlineStyles\Css;
+
+use TijsVerkoyen\CssToInlineStyles\Css\Rule\Processor as RuleProcessor;
+use TijsVerkoyen\CssToInlineStyles\Css\Rule\Rule;
+
+class Processor
+{
+    /**
+     * Get the rules from a given CSS-string
+     *
+     * @param string $css
+     * @param array  $existingRules
+     * @return Rule[]
+     */
+    public function getRules($css, $existingRules = array())
+    {
+        $css = $this->doCleanup($css);
+        $rulesProcessor = new RuleProcessor();
+        $rules = $rulesProcessor->splitIntoSeparateRules($css);
+
+        return $rulesProcessor->convertArrayToObjects($rules, $existingRules);
+    }
+
+    /**
+     * Get the CSS from the style-tags in the given HTML-string
+     *
+     * @param string $html
+     * @return string
+     */
+    public function getCssFromStyleTags($html)
+    {
+        $css = '';
+        $matches = array();
+        $htmlNoComments = preg_replace('|<!--.*?-->|s', '', $html);
+        preg_match_all('|<style(?:\s.*)?>(.*)</style>|isU', $htmlNoComments, $matches);
+
+        if (!empty($matches[1])) {
+            foreach ($matches[1] as $match) {
+                $css .= trim($match) . "\n";
+            }
+        }
+
+        return $css;
+    }
+
+    /**
+     * @param string $css
+     * @return string
+     */
+    private function doCleanup($css)
+    {
+        // remove charset
+        $css = preg_replace('/@charset "[^"]++";/', '', $css);
+        // remove media queries
+        $css = preg_replace('/@media [^{]*+{([^{}]++|{[^{}]*+})*+}/', '', $css);
+
+        $css = str_replace(array("\r", "\n"), '', $css);
+        $css = str_replace(array("\t"), ' ', $css);
+        $css = str_replace('"', '\'', $css);
+        $css = preg_replace('|/\*.*?\*/|', '', $css);
+        $css = preg_replace('/\s\s++/', ' ', $css);
+        $css = trim($css);
+
+        return $css;
+    }
+}

vendor/tijsverkoyen/css-to-inline-styles/src/Css/Property/Processor.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace TijsVerkoyen\CssToInlineStyles\Css\Property;
+
+use Symfony\Component\CssSelector\Node\Specificity;
+
+class Processor
+{
+    /**
+     * Split a string into seperate properties
+     *
+     * @param string $propertiesString
+     * @return array
+     */
+    public function splitIntoSeparateProperties($propertiesString)
+    {
+        $propertiesString = $this->cleanup($propertiesString);
+
+        $properties = (array) explode(';', $propertiesString);
+        $keysToRemove = array();
+        $numberOfProperties = count($properties);
+
+        for ($i = 0; $i < $numberOfProperties; $i++) {
+            $properties[$i] = trim($properties[$i]);
+
+            // if the new property begins with base64 it is part of the current property
+            if (isset($properties[$i + 1]) && strpos(trim($properties[$i + 1]), 'base64,') === 0) {
+                $properties[$i] .= ';' . trim($properties[$i + 1]);
+                $keysToRemove[] = $i + 1;
+            }
+        }
+
+        if (!empty($keysToRemove)) {
+            foreach ($keysToRemove as $key) {
+                unset($properties[$key]);
+            }
+        }
+
+        return array_values($properties);
+    }
+
+    /**
+     * @param $string
+     * @return mixed|string
+     */
+    private function cleanup($string)
+    {
+        $string = str_replace(array("\r", "\n"), '', $string);
+        $string = str_replace(array("\t"), ' ', $string);
+        $string = str_replace('"', '\'', $string);
+        $string = preg_replace('|/\*.*?\*/|', '', $string);
+        $string = preg_replace('/\s\s+/', ' ', $string);
+
+        $string = trim($string);
+        $string = rtrim($string, ';');
+
+        return $string;
+    }
+
+    /**
+     * Convert a property-string into an object
+     *
+     * @param string $property
+     * @return Property|null
+     */
+    public function convertToObject($property, Specificity $specificity = null)
+    {
+        if (strpos($property, ':') === false) {
+            return null;
+        }
+
+        list($name, $value) = explode(':', $property, 2);
+
+        $name = trim($name);
+        $value = trim($value);
+
+        if ($value === '') {
+            return null;
+        }
+
+        return new Property($name, $value, $specificity);
+    }
+
+    /**
+     * Convert an array of property-strings into objects
+     *
+     * @param array $properties
+     * @return Property[]
+     */
+    public function convertArrayToObjects(array $properties, Specificity $specificity = null)
+    {
+        $objects = array();
+
+        foreach ($properties as $property) {
+            $object = $this->convertToObject($property, $specificity);
+            if ($object === null) {
+                continue;
+            }
+
+            $objects[] = $object;
+        }
+
+        return $objects;
+    }
+
+    /**
+     * Build the property-string for multiple properties
+     *
+     * @param array $properties
+     * @return string
+     */
+    public function buildPropertiesString(array $properties)
+    {
+        $chunks = array();
+
+        foreach ($properties as $property) {
+            $chunks[] = $property->toString();
+        }
+
+        return implode(' ', $chunks);
+    }
+}

vendor/tijsverkoyen/css-to-inline-styles/src/Css/Property/Property.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace TijsVerkoyen\CssToInlineStyles\Css\Property;
+
+use Symfony\Component\CssSelector\Node\Specificity;
+
+final class Property
+{
+    /**
+     * @var string
+     */
+    private $name;
+
+    /**
+     * @var string
+     */
+    private $value;
+
+    /**
+     * @var Specificity
+     */
+    private $originalSpecificity;
+
+    /**
+     * Property constructor.
+     * @param                  $name
+     * @param                  $value
+     * @param Specificity|null $specificity
+     */
+    public function __construct($name, $value, Specificity $specificity = null)
+    {
+        $this->name = $name;
+        $this->value = $value;
+        $this->originalSpecificity = $specificity;
+    }
+
+    /**
+     * Get name
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Get value
+     *
+     * @return string
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Get originalSpecificity
+     *
+     * @return Specificity
+     */
+    public function getOriginalSpecificity()
+    {
+        return $this->originalSpecificity;
+    }
+
+    /**
+     * Is this property important?
+     *
+     * @return bool
+     */
+    public function isImportant()
+    {
+        return (stripos($this->value, '!important') !== false);
+    }
+
+    /**
+     * Get the textual representation of the property
+     *
+     * @return string
+     */
+    public function toString()
+    {
+        return sprintf(
+            '%1$s: %2$s;',
+            $this->name,
+            $this->value
+        );
+    }
+}

vendor/tijsverkoyen/css-to-inline-styles/src/Css/Rule/Processor.php

@@ -0,0 +1,155 @@
+<?php
+
+namespace TijsVerkoyen\CssToInlineStyles\Css\Rule;
+
+use Symfony\Component\CssSelector\Node\Specificity;
+use \TijsVerkoyen\CssToInlineStyles\Css\Property\Processor as PropertyProcessor;
+
+class Processor
+{
+    /**
+     * Split a string into seperate rules
+     *
+     * @param string $rulesString
+     * @return array
+     */
+    public function splitIntoSeparateRules($rulesString)
+    {
+        $rulesString = $this->cleanup($rulesString);
+
+        return (array) explode('}', $rulesString);
+    }
+
+    /**
+     * @param string $string
+     * @return string
+     */
+    private function cleanup($string)
+    {
+        $string = str_replace(array("\r", "\n"), '', $string);
+        $string = str_replace(array("\t"), ' ', $string);
+        $string = str_replace('"', '\'', $string);
+        $string = preg_replace('|/\*.*?\*/|', '', $string);
+        $string = preg_replace('/\s\s+/', ' ', $string);
+
+        $string = trim($string);
+        $string = rtrim($string, '}');
+
+        return $string;
+    }
+
+    /**
+     * Convert a rule-string into an object
+     *
+     * @param string $rule
+     * @param int    $originalOrder
+     * @return array
+     */
+    public function convertToObjects($rule, $originalOrder)
+    {
+        $rule = $this->cleanup($rule);
+
+        $chunks = explode('{', $rule);
+        if (!isset($chunks[1])) {
+            return array();
+        }
+        $propertiesProcessor = new PropertyProcessor();
+        $rules = array();
+        $selectors = (array) explode(',', trim($chunks[0]));
+        $properties = $propertiesProcessor->splitIntoSeparateProperties($chunks[1]);
+
+        foreach ($selectors as $selector) {
+            $selector = trim($selector);
+            $specificity = $this->calculateSpecificityBasedOnASelector($selector);
+
+            $rules[] = new Rule(
+                $selector,
+                $propertiesProcessor->convertArrayToObjects($properties, $specificity),
+                $specificity,
+                $originalOrder
+            );
+        }
+
+        return $rules;
+    }
+
+    /**
+     * Calculate the specificity based on a CSS Selector string,
+     * Based on the patterns from premailer/css_parser by Alex Dunae
+     *
+     * @see https://github.com/premailer/css_parser/blob/master/lib/css_parser/regexps.rb
+     * @param string $selector
+     * @return Specificity
+     */
+    public function calculateSpecificityBasedOnASelector($selector)
+    {
+        $idSelectorsPattern = "  \#";
+        $classAttributesPseudoClassesSelectorsPattern = "  (\.[\w]+)                     # classes
+                        |
+                        \[(\w+)                       # attributes
+                        |
+                        (\:(                          # pseudo classes
+                          link|visited|active
+                          |hover|focus
+                          |lang
+                          |target
+                          |enabled|disabled|checked|indeterminate
+                          |root
+                          |nth-child|nth-last-child|nth-of-type|nth-last-of-type
+                          |first-child|last-child|first-of-type|last-of-type
+                          |only-child|only-of-type
+                          |empty|contains
+                        ))";
+
+        $typePseudoElementsSelectorPattern = "  ((^|[\s\+\>\~]+)[\w]+       # elements
+                        |
+                        \:{1,2}(                    # pseudo-elements
+                          after|before
+                          |first-letter|first-line
+                          |selection
+                        )
+                      )";
+
+        return new Specificity(
+            preg_match_all("/{$idSelectorsPattern}/ix", $selector, $matches),
+            preg_match_all("/{$classAttributesPseudoClassesSelectorsPattern}/ix", $selector, $matches),
+            preg_match_all("/{$typePseudoElementsSelectorPattern}/ix", $selector, $matches)
+        );
+    }
+
+    /**
+     * @param array $rules
+     * @return Rule[]
+     */
+    public function convertArrayToObjects(array $rules, array $objects = array())
+    {
+        $order = 1;
+        foreach ($rules as $rule) {
+            $objects = array_merge($objects, $this->convertToObjects($rule, $order));
+            $order++;
+        }
+
+        return $objects;
+    }
+
+    /**
+     * Sort an array on the specificity element in an ascending way
+     * Lower specificity will be sorted to the beginning of the array
+     *
+     * @return int
+     * @param  Rule $e1 The first element.
+     * @param  Rule $e2 The second element.
+     */
+    public static function sortOnSpecificity(Rule $e1, Rule $e2)
+    {
+        $e1Specificity = $e1->getSpecificity();
+        $value = $e1Specificity->compareTo($e2->getSpecificity());
+
+        // if the specificity is the same, use the order in which the element appeared
+        if ($value === 0) {
+            $value = $e1->getOrder() - $e2->getOrder();
+        }
+
+        return $value;
+    }
+}

vendor/tijsverkoyen/css-to-inline-styles/src/Css/Rule/Rule.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace TijsVerkoyen\CssToInlineStyles\Css\Rule;
+
+use Symfony\Component\CssSelector\Node\Specificity;
+
+final class Rule
+{
+    /**
+     * @var string
+     */
+    private $selector;
+
+    /**
+     * @var array
+     */
+    private $properties;
+
+    /**
+     * @var Specificity
+     */
+    private $specificity;
+
+    /**
+     * @var integer
+     */
+    private $order;
+
+    /**
+     * Rule constructor.
+     *
+     * @param string      $selector
+     * @param Property[]  $properties
+     * @param Specificity $specificity
+     * @param int         $order
+     */
+    public function __construct($selector, array $properties, Specificity $specificity, $order)
+    {
+        $this->selector = $selector;
+        $this->properties = $properties;
+        $this->specificity = $specificity;
+        $this->order = $order;
+    }
+
+    /**
+     * Get selector
+     *
+     * @return string
+     */
+    public function getSelector()
+    {
+        return $this->selector;
+    }
+
+    /**
+     * Get properties
+     *
+     * @return array
+     */
+    public function getProperties()
+    {
+        return $this->properties;
+    }
+
+    /**
+     * Get specificity
+     *
+     * @return Specificity
+     */
+    public function getSpecificity()
+    {
+        return $this->specificity;
+    }
+
+    /**
+     * Get order
+     *
+     * @return int
+     */
+    public function getOrder()
+    {
+        return $this->order;
+    }
+}