Diff::cleanHTML() - Code Metrics - Inspection of "Merge pull request #6786 from mikenz/patch-10" - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a65ae8...dcf23a )

by Daniel

created 2017-05-11 10:58 UTC

Diff::cleanHTML() B

↳ Parent: Diff

Complexity

Conditions	5
Paths	6

Size

Total Lines	24
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	13
nc	6
nop	2
dl	0
loc	24
rs	8.5125
c	0
b	0
f	0

<?php


namespace SilverStripe\View\Parsers;

use InvalidArgumentException;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Injector\Injector;

require_once 'difflib/difflib.php';

/**
 * Class representing a 'diff' between two sequences of strings.
 */
class Diff extends \Diff
{
    public static $html_cleaner_class = null;

    /**
     *  Attempt to clean invalid HTML, which messes up diffs.
     *  This cleans code if possible, using an instance of HTMLCleaner
     *
     *  NB: By default, only extremely simple tidying is performed,
     *  by passing through DomDocument::loadHTML and saveXML
     *
     * @param string $content HTML content
     * @param HTMLCleaner $cleaner Optional instance of a HTMLCleaner class to
     *    use, overriding self::$html_cleaner_class
     * @return mixed|string
     */
    public static function cleanHTML($content, $cleaner = null)
    {
        if (!$cleaner) {
            if (self::$html_cleaner_class && class_exists(self::$html_cleaner_class)) {
                $cleaner = Injector::inst()->create(self::$html_cleaner_class);
            } else {
                //load cleaner if the dependent class is available
                $cleaner = HTMLCleaner::inst();
            }
        }

        if ($cleaner) {
            $content = $cleaner->cleanHTML($content);
        } else {
            // At most basic level of cleaning, use DOMDocument to save valid XML.
            $doc = Injector::inst()->create('HTMLValue', $content);
            $content = $doc->getContent();
        }

        // Remove empty <ins /> and <del /> tags because browsers hate them
        $content = preg_replace('/<(ins|del)[^>]*\/>/', '', $content);

        return $content;
    }

    /**
     * @param string $from
     * @param string $to
     * @param bool $escape
     * @return string
     */
    public static function compareHTML($from, $to, $escape = false)
    {
        // First split up the content into words and tags
        $set1 = self::getHTMLChunks($from);
        $set2 = self::getHTMLChunks($to);

        // Diff that
        $diff = new Diff($set1, $set2);

        $tagStack[1] = $tagStack[2] = 0;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        $rechunked[1] = $rechunked[2] = array();
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}

        // Go through everything, converting edited tags (and their content) into single chunks.  Otherwise
        // the generated HTML gets crusty
        foreach ($diff->edits as $edit) {
            $lookForTag = false;
            $stuffFor = [];
            switch ($edit->type) {
                case 'copy':
                    $lookForTag = false;
                    $stuffFor[1] = $edit->orig;
                    $stuffFor[2] = $edit->orig;
                    break;

                case 'change':
                    $lookForTag = true;
                    $stuffFor[1] = $edit->orig;
                    $stuffFor[2] = $edit->final;
                    break;

                case 'add':
                    $lookForTag = true;
                    $stuffFor[1] = null;
                    $stuffFor[2] = $edit->final;
                    break;

                case 'delete':
                    $lookForTag = true;
                    $stuffFor[1] = $edit->orig;
                    $stuffFor[2] = null;
                    break;
            }

            foreach ($stuffFor as $listName => $chunks) {
                if ($chunks) {
                    foreach ($chunks as $item) {
                        // $tagStack > 0 indicates that we should be tag-building
                        if ($tagStack[$listName]) {
                            $rechunked[$listName][sizeof($rechunked[$listName])-1] .= ' ' . $item;
                        } else {
                            $rechunked[$listName][] = $item;
                        }

                        if ($lookForTag
                            && !$tagStack[$listName]
                            && isset($item[0])
                            && $item[0] == "<"
                            && substr($item, 0, 2) != "</"
                        ) {
                            $tagStack[$listName] = 1;
                        } elseif ($tagStack[$listName]) {
                            if (substr($item, 0, 2) == "</") {
                                $tagStack[$listName]--;
                            } elseif (isset($item[0]) && $item[0] == "<") {
                                $tagStack[$listName]++;
                            }
                        }
                    }
                }
            }
        }

        // Diff the re-chunked data, turning it into maked up HTML
        $diff = new Diff($rechunked[1], $rechunked[2]);
        $content = '';
        foreach ($diff->edits as $edit) {
            $orig = ($escape) ? Convert::raw2xml($edit->orig) : $edit->orig;
            $final = ($escape) ? Convert::raw2xml($edit->final) : $edit->final;

            switch ($edit->type) {
                case 'copy':
                    $content .= " " . implode(" ", $orig) . " ";
                    break;

                case 'change':
                    $content .= " <ins>" . implode(" ", $final) . "</ins> ";
                    $content .= " <del>" . implode(" ", $orig) . "</del> ";
                    break;

                case 'add':
                    $content .= " <ins>" . implode(" ", $final) . "</ins> ";
                    break;

                case 'delete':
                    $content .= " <del>" . implode(" ", $orig) . "</del> ";
                    break;
            }
        }

        return self::cleanHTML($content);
    }

    /**
     * @param string|bool|array $content If passed as an array, values will be concatenated with a comma.
     * @return array
     */
    public static function getHTMLChunks($content)
    {
        if ($content && !is_string($content) && !is_array($content) && !is_numeric($content) && !is_bool($content)) {
            throw new InvalidArgumentException('$content parameter needs to be a string or array');
        }
        if (is_bool($content)) {
            // Convert boolean to strings
            $content = $content ? "true" : "false";
        }
        if (is_array($content)) {
            // Convert array to CSV
            $content = implode(',', $content);
        }

        $content = str_replace(array("&nbsp;", "<", ">"), array(" "," <", "> "), $content);
        $candidateChunks = preg_split("/[\t\r\n ]+/", $content);
        $chunks = [];
        while ($chunk = each($candidateChunks)) {
            $item = $chunk['value'];
            if (isset($item[0]) && $item[0] == "<") {
                $newChunk = $item;
                while ($item[strlen($item)-1] != ">") {
                    $chunk = each($candidateChunks);
                    $item = $chunk['value'];
                    $newChunk .= ' ' . $item;
                }
                $chunks[] = $newChunk;
            } else {
                $chunks[] = $item;
            }
        }
        return $chunks;
    }
}


1			<?php
			0 ignored issues – show Coding Style Compatibility introduced 2017-04-19 22:22 UTC by Report Bug Copy Issue Report For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 14 and the first side effect is on line 9. The PSR-1: Basic Coding Standard recommends that a file should either introduce new symbols, that is classes, functions, constants or similar, or have side effects. Side effects are anything that executes logic, like for example printing output, changing ini settings or writing to a file. The idea behind this recommendation is that merely auto-loading a class should not change the state of an application. It also promotes a cleaner style of programming and makes your code less prone to errors, because the logic is not spread out all over the place. To learn more about the PSR-1, please see the PHP-FIG site on the PSR-1. Loading history...
2
3			namespace SilverStripe\View\Parsers;
4
5			use InvalidArgumentException;
6			use SilverStripe\Core\Convert;
7			use SilverStripe\Core\Injector\Injector;
8
9			require_once 'difflib/difflib.php';
10
11			/**
12			* Class representing a 'diff' between two sequences of strings.
13			*/
14			class Diff extends \Diff
15			{
16			public static $html_cleaner_class = null;
17
18			/**
19			* Attempt to clean invalid HTML, which messes up diffs.
20			* This cleans code if possible, using an instance of HTMLCleaner
21			*
22			* NB: By default, only extremely simple tidying is performed,
23			* by passing through DomDocument::loadHTML and saveXML
24			*
25			* @param string $content HTML content
26			* @param HTMLCleaner $cleaner Optional instance of a HTMLCleaner class to
27			* use, overriding self::$html_cleaner_class
28			* @return mixed\|string
29			*/
30			public static function cleanHTML($content, $cleaner = null)
31			{
32			if (!$cleaner) {
33			if (self::$html_cleaner_class && class_exists(self::$html_cleaner_class)) {
34			$cleaner = Injector::inst()->create(self::$html_cleaner_class);
35			} else {
36			//load cleaner if the dependent class is available
37			$cleaner = HTMLCleaner::inst();
38			}
39			}
40
41			if ($cleaner) {
42			$content = $cleaner->cleanHTML($content);
43			} else {
44			// At most basic level of cleaning, use DOMDocument to save valid XML.
45			$doc = Injector::inst()->create('HTMLValue', $content);
46			$content = $doc->getContent();
47			}
48
49			// Remove empty <ins /> and <del /> tags because browsers hate them
50			$content = preg_replace('/<(ins\|del)[^>]*\/>/', '', $content);
51
52			return $content;
53			}
54
55			/**
56			* @param string $from
57			* @param string $to
58			* @param bool $escape
59			* @return string
60			*/
61			public static function compareHTML($from, $to, $escape = false)
62			{
63			// First split up the content into words and tags
64			$set1 = self::getHTMLChunks($from);
65			$set2 = self::getHTMLChunks($to);
66
67			// Diff that
68			$diff = new Diff($set1, $set2);
69
70			$tagStack[1] = $tagStack[2] = 0;
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-11-01 00:55 UTC by Report Bug Copy Issue Report `$tagStack` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$tagStack = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
71			$rechunked[1] = $rechunked[2] = array();
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-11-01 00:55 UTC by Report Bug Copy Issue Report `$rechunked` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$rechunked = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
72
73			// Go through everything, converting edited tags (and their content) into single chunks. Otherwise
74			// the generated HTML gets crusty
75			foreach ($diff->edits as $edit) {
76			$lookForTag = false;
77			$stuffFor = [];
78			switch ($edit->type) {
79			case 'copy':
80			$lookForTag = false;
81			$stuffFor[1] = $edit->orig;
82			$stuffFor[2] = $edit->orig;
83			break;
84
85			case 'change':
86			$lookForTag = true;
87			$stuffFor[1] = $edit->orig;
88			$stuffFor[2] = $edit->final;
89			break;
90
91			case 'add':
92			$lookForTag = true;
93			$stuffFor[1] = null;
94			$stuffFor[2] = $edit->final;
95			break;
96
97			case 'delete':
98			$lookForTag = true;
99			$stuffFor[1] = $edit->orig;
100			$stuffFor[2] = null;
101			break;
102			}
103
104			foreach ($stuffFor as $listName => $chunks) {
105			if ($chunks) {
106			foreach ($chunks as $item) {
107			// $tagStack > 0 indicates that we should be tag-building
108			if ($tagStack[$listName]) {
109			$rechunked[$listName][sizeof($rechunked[$listName])-1] .= ' ' . $item;
110			} else {
111			$rechunked[$listName][] = $item;
112			}
113
114			if ($lookForTag
115			&& !$tagStack[$listName]
116			&& isset($item[0])
117			&& $item[0] == "<"
118			&& substr($item, 0, 2) != "</"
119			) {
120			$tagStack[$listName] = 1;
121			} elseif ($tagStack[$listName]) {
122			if (substr($item, 0, 2) == "</") {
123			$tagStack[$listName]--;
124			} elseif (isset($item[0]) && $item[0] == "<") {
125			$tagStack[$listName]++;
126			}
127			}
128			}
129			}
130			}
131			}
132
133			// Diff the re-chunked data, turning it into maked up HTML
134			$diff = new Diff($rechunked[1], $rechunked[2]);
135			$content = '';
136			foreach ($diff->edits as $edit) {
137			$orig = ($escape) ? Convert::raw2xml($edit->orig) : $edit->orig;
138			$final = ($escape) ? Convert::raw2xml($edit->final) : $edit->final;
139
140			switch ($edit->type) {
141			case 'copy':
142			$content .= " " . implode(" ", $orig) . " ";
143			break;
144
145			case 'change':
146			$content .= " <ins>" . implode(" ", $final) . "</ins> ";
147			$content .= " <del>" . implode(" ", $orig) . "</del> ";
148			break;
149
150			case 'add':
151			$content .= " <ins>" . implode(" ", $final) . "</ins> ";
152			break;
153
154			case 'delete':
155			$content .= " <del>" . implode(" ", $orig) . "</del> ";
156			break;
157			}
158			}
159
160			return self::cleanHTML($content);
161			}
162
163			/**
164			* @param string\|bool\|array $content If passed as an array, values will be concatenated with a comma.
165			* @return array
166			*/
167			public static function getHTMLChunks($content)
168			{
169			if ($content && !is_string($content) && !is_array($content) && !is_numeric($content) && !is_bool($content)) {
170			throw new InvalidArgumentException('$content parameter needs to be a string or array');
171			}
172			if (is_bool($content)) {
173			// Convert boolean to strings
174			$content = $content ? "true" : "false";
175			}
176			if (is_array($content)) {
177			// Convert array to CSV
178			$content = implode(',', $content);
179			}
180
181			$content = str_replace(array(" ", "<", ">"), array(" "," <", "> "), $content);
182			$candidateChunks = preg_split("/[\t\r\n ]+/", $content);
183			$chunks = [];
184			while ($chunk = each($candidateChunks)) {
185			$item = $chunk['value'];
186			if (isset($item[0]) && $item[0] == "<") {
187			$newChunk = $item;
188			while ($item[strlen($item)-1] != ">") {
189			$chunk = each($candidateChunks);
190			$item = $chunk['value'];
191			$newChunk .= ' ' . $item;
192			}
193			$chunks[] = $newChunk;
194			} else {
195			$chunks[] = $item;
196			}
197			}
198			return $chunks;
199			}
200			}
201

silverstripe / silverstripe-framework

Push — master ( a65ae8...dcf23a )

Diff::cleanHTML() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like