Strings::htmlEntityDecode() - Code Metrics - Inspection of "Fix replacer on encoded html" - matecat/whole-text-finder - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#6)

by Mauro

created 2025-02-14 11:02 UTC

Strings::htmlEntityDecode() A

↳ Parent: Strings

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	3
rs	10

<?php

namespace Matecat\Finder\Helper;

class Strings
{
    /**
     * @param string $string
     *
     * @return string
     */
    public static function cutNbsps($string)
    {
        return str_replace(['&nbsp;', ' '], ' ', $string);
    }

    /**
     * @param string $string
     *
     * @return string
     */
    public static function htmlEntityDecode($string)
    {
        return html_entity_decode($string, ENT_QUOTES|ENT_XHTML, 'UTF-8');
    }

    /**
     * @param string $string
     *
     * @return array|bool|string[]|null
     */
    public static function split($string)
    {
        return mb_str_split($string);
    }

    /**
     * @param int $length
     *
     * @return string
     */
    public static function token($length = 8)
    {
        $key = '';
        $keys = array_merge(range(0, 9), range('a', 'z'));

        for ($i = 0; $i < $length; $i++) {
            $key .= $keys[array_rand($keys)];
        }

        return $key;
    }

    /**
     * @param string $string
     *
     * @return bool
     */
    public static function isMultibyte($string)
    {
        return ((strlen($string) - mb_strlen($string)) > 0);
    }

    /**
     * @param $needle
     * @param $haystack
     *
     * @return bool
     */
    public static function contains($needle, $haystack)
    {
        if(empty($haystack)){
            return false;
        }

        return strpos($haystack, $needle) !== false;
    }

    public static function firstChar($string)
    {
        return $string[0];
    }

    public static function lastChar($string)
    {
        return $string[strlen($string) - 1];
    }

    /**
     * @param string $string
     * @return string
     */
    public static function protectHTMLTags($string)
    {
        preg_match_all('/&lt;(.*?)&gt;|<(.*?)>/sm', $string, $matches);

        if(!empty($matches[0])){
            foreach ($matches[0] as $index => $element){

                $tag = explode(" ", $element);
                $tag = str_replace(["<", ">", "&lt;", "&gt;", "/"], "", $tag[0]);

                if(!self::contains("/", $element)){

                    $tagMatch = false;

                    for($i = ($index+1); $i < count($matches[0]); $i++){
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                        $nextElement = $matches[0][$i] ?? null;

                        if($nextElement === null){
                            continue;
                        }

                        $nextTag = explode(" ", $nextElement);
                        $nextTag = str_replace(["<", ">", "&lt;", "&gt;", "/"], "", $nextTag[0]);

                        if($nextTag === $tag){
                            $tagMatch = true;
                        }
                    }

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

                } else {
                    // self closing tag
                    $closingTag = explode(" ", $element);
                    $closingTag = str_replace(["<", ">", "&lt;", "&gt;"], "", $closingTag[0]);

                    if(empty($closingTag)){
                        continue;
                    }

                    if(!(self::firstChar($closingTag) === "/" or self::lastChar($closingTag) === "/")){
                        continue;
                    }
                }

                $charMap = self::charMap();
                $protectedTag = str_replace(["<", ">", "&lt;", "&gt;"], [$charMap["<"], $charMap[">"], $charMap["&lt;"], $charMap["&gt;"]], $element);
                $string = str_replace($element, $protectedTag, $string);
            }
        }

        return $string;
    }

    /**
     * @param string $string
     * @return string
     */
    public static function unprotectHTMLTags($string)
    {
        $charMap = self::charMap();
        $string = str_replace([$charMap["<"], $charMap[">"], $charMap["&lt;"], $charMap["&gt;"]], ["<", ">", "&lt;", "&gt;"], $string);

        return $string;
    }

    /**
     * @return array
     */
    private static function charMap()
    {
        return [
            "<"    => "ʃʃʃʃ",
            ">"    => "¶¶¶¶",
            "&lt;" => "ɑɑɑɑ",
            "&gt;" => "ʒʒʒʒ",
        ];
    }
}

1			<?php
2
3			namespace Matecat\Finder\Helper;
4
5			class Strings
6			{
7			/**
8			* @param string $string
9			*
10			* @return string
11			*/
12			public static function cutNbsps($string)
13			{
14			return str_replace([' ', ' '], ' ', $string);
15			}
16
17			/**
18			* @param string $string
19			*
20			* @return string
21			*/
22			public static function htmlEntityDecode($string)
23			{
24			return html_entity_decode($string, ENT_QUOTES\|ENT_XHTML, 'UTF-8');
25			}
26
27			/**
28			* @param string $string
29			*
30			* @return array\|bool\|string[]\|null
31			*/
32			public static function split($string)
33			{
34			return mb_str_split($string);
35			}
36
37			/**
38			* @param int $length
39			*
40			* @return string
41			*/
42			public static function token($length = 8)
43			{
44			$key = '';
45			$keys = array_merge(range(0, 9), range('a', 'z'));
46
47			for ($i = 0; $i < $length; $i++) {
48			$key .= $keys[array_rand($keys)];
49			}
50
51			return $key;
52			}
53
54			/**
55			* @param string $string
56			*
57			* @return bool
58			*/
59			public static function isMultibyte($string)
60			{
61			return ((strlen($string) - mb_strlen($string)) > 0);
62			}
63
64			/**
65			* @param $needle
66			* @param $haystack
67			*
68			* @return bool
69			*/
70			public static function contains($needle, $haystack)
71			{
72			if(empty($haystack)){
73			return false;
74			}
75
76			return strpos($haystack, $needle) !== false;
77			}
78
79			public static function firstChar($string)
80			{
81			return $string[0];
82			}
83
84			public static function lastChar($string)
85			{
86			return $string[strlen($string) - 1];
87			}
88
89			/**
90			* @param string $string
91			* @return string
92			*/
93			public static function protectHTMLTags($string)
94			{
95			preg_match_all('/<(.?)>\|<(.?)>/sm', $string, $matches);
96
97			if(!empty($matches[0])){
98			foreach ($matches[0] as $index => $element){
99
100			$tag = explode(" ", $element);
101			$tag = str_replace(["<", ">", "<", ">", "/"], "", $tag[0]);
102
103			if(!self::contains("/", $element)){
104
105			$tagMatch = false;
106
107			for($i = ($index+1); $i < count($matches[0]); $i++){
			0 ignored issues – show Performance Best Practice introduced 2025-02-14 11:06 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
108			$nextElement = $matches[0][$i] ?? null;
109
110			if($nextElement === null){
111			continue;
112			}
113
114			$nextTag = explode(" ", $nextElement);
115			$nextTag = str_replace(["<", ">", "<", ">", "/"], "", $nextTag[0]);
116
117			if($nextTag === $tag){
118			$tagMatch = true;
119			}
120			}
121
122			if($tagMatch === false){
123			continue;
124			}
125
126			} else {
127			// self closing tag
128			$closingTag = explode(" ", $element);
129			$closingTag = str_replace(["<", ">", "<", ">"], "", $closingTag[0]);
130
131			if(empty($closingTag)){
132			continue;
133			}
134
135			if(!(self::firstChar($closingTag) === "/" or self::lastChar($closingTag) === "/")){
136			continue;
137			}
138			}
139
140			$charMap = self::charMap();
141			$protectedTag = str_replace(["<", ">", "<", ">"], [$charMap["<"], $charMap[">"], $charMap["<"], $charMap[">"]], $element);
142			$string = str_replace($element, $protectedTag, $string);
143			}
144			}
145
146			return $string;
147			}
148
149			/**
150			* @param string $string
151			* @return string
152			*/
153			public static function unprotectHTMLTags($string)
154			{
155			$charMap = self::charMap();
156			$string = str_replace([$charMap["<"], $charMap[">"], $charMap["<"], $charMap[">"]], ["<", ">", "<", ">"], $string);
157
158			return $string;
159			}
160
161			/**
162			* @return array
163			*/
164			private static function charMap()
165			{
166			return [
167			"<" => "ʃʃʃʃ",
168			">" => "¶¶¶¶",
169			"<" => "ɑɑɑɑ",
170			">" => "ʒʒʒʒ",
171			];
172			}
173			}

matecat / whole-text-finder

Pull Request — master (#6)

Strings::htmlEntityDecode() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like