SysUtility::truncateHtml()   F
last analyzed

Complexity

Conditions 19
Paths 194

Size

Total Lines 89
Code Lines 47

Duplication

Lines 0
Ratio 0 %

Importance

Changes 2
Bugs 0 Features 0
Metric Value
cc 19
eloc 47
nc 194
nop 5
dl 0
loc 89
rs 3.7333
c 2
b 0
f 0

How to fix   Long Method    Complexity   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

1
<?php declare(strict_types=1);
2
3
namespace XoopsModules\Newbb\Common;
4
5
/*
6
 Utility Class Definition
7
8
 You may not change or alter any portion of this comment or credits of
9
 supporting developers from this source code or any supporting source code
10
 which is considered copyrighted (c) material of the original comment or credit
11
 authors.
12
13
 This program is distributed in the hope that it will be useful, but
14
 WITHOUT ANY WARRANTY; without even the implied warranty of
15
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16
 */
17
18
/**
19
 * @license      GNU GPL 2.0 or later (https://www.gnu.org/licenses/gpl-2.0.html)
20
 * @copyright    https://xoops.org 2000-2020 &copy; XOOPS Project
21
 * @author       ZySpec <[email protected]>
22
 * @author       Mamba <[email protected]>
23
 */
24
25
use XoopsModules\Newbb\Helper;
26
27
/**
28
 * Class SysUtility
29
 */
30
class SysUtility
31
{
32
    use VersionChecks;
0 ignored issues
show
introduced by
The trait XoopsModules\Newbb\Common\VersionChecks requires some properties which are not provided by XoopsModules\Newbb\Common\SysUtility: $tag_name, $prerelease
Loading history...
33
34
    //checkVerXoops, checkVerPhp Traits
35
36
    use ServerStats;
37
38
    // getServerStats Trait
39
40
    use FilesManagement;
41
42
    // Files Management Trait
43
44
    /**
45
     * truncateHtml can truncate a string up to a number of characters while preserving whole words and HTML tags
46
     * www.gsdesign.ro/blog/cut-html-string-without-breaking-the-tags
47
     * www.cakephp.org
48
     *
49
     * @param string $text         String to truncate.
50
     * @param int    $length       Length of returned string, including ellipsis.
51
     * @param string $ending       Ending to be appended to the trimmed string.
52
     * @param bool   $exact        If false, $text will not be cut mid-word
53
     * @param bool   $considerHtml If true, HTML tags would be handled correctly
54
     *
55
     * @return string Trimmed string.
56
     */
57
    public static function truncateHtml(string $text, int $length = 100, string $ending = '...', bool $exact = false, bool $considerHtml = true): string
58
    {
59
        if ($considerHtml) {
60
            // if the plain text is shorter than the maximum length, return the whole text
61
            if (mb_strlen(\preg_replace('/<.*?' . '>/', '', $text)) <= $length) {
62
                return $text;
63
            }
64
            // splits all html-tags to scanable lines
65
            \preg_match_all('/(<.+?' . '>)?([^<>]*)/s', $text, $lines, \PREG_SET_ORDER);
66
            $total_length = mb_strlen($ending);
67
            $open_tags    = [];
68
            $truncate     = '';
69
            foreach ($lines as $line_matchings) {
70
                // if there is any html-tag in this line, handle it and add it (uncounted) to the output
71
                if (!empty($line_matchings[1])) {
72
                    // if it's an "empty element" with or without xhtml-conform closing slash
73
                    if (\preg_match('/^<(\s*.+?\/\s*|\s*(img|br|input|hr|area|base|basefont|col|frame|isindex|link|meta|param)(\s.+?)?)>$/is', $line_matchings[1])) {
74
                        // do nothing
75
                        // if tag is a closing tag
76
                    } elseif (\preg_match('/^<\s*\/(\S+?)\s*>$/s', $line_matchings[1], $tag_matchings)) {
77
                        // delete tag from $open_tags list
78
                        $pos = \array_search($tag_matchings[1], $open_tags, true);
79
                        if (false !== $pos) {
80
                            unset($open_tags[$pos]);
81
                        }
82
                        // if tag is an opening tag
83
                    } elseif (\preg_match('/^<\s*([^\s>!]+).*?' . '>$/s', $line_matchings[1], $tag_matchings)) {
84
                        // add tag to the beginning of $open_tags list
85
                        \array_unshift($open_tags, \mb_strtolower($tag_matchings[1]));
86
                    }
87
                    // add html-tag to $truncate'd text
88
                    $truncate .= $line_matchings[1];
89
                }
90
                // calculate the length of the plain text part of the line; handle entities as one character
91
                $content_length = mb_strlen(\preg_replace('/&[0-9a-z]{2,8};|&#\d{1,7};|[0-9a-f]{1,6};/i', ' ', $line_matchings[2]));
92
                if ($total_length + $content_length > $length) {
93
                    // the number of characters which are left
94
                    $left            = $length - $total_length;
95
                    $entities_length = 0;
96
                    // search for html entities
97
                    if (\preg_match_all('/&[0-9a-z]{2,8};|&#\d{1,7};|[0-9a-f]{1,6};/i', $line_matchings[2], $entities, \PREG_OFFSET_CAPTURE)) {
98
                        // calculate the real length of all entities in the legal range
99
                        foreach ($entities[0] as $entity) {
100
                            if ($left >= $entity[1] + 1 - $entities_length) {
101
                                $left--;
102
                                $entities_length += mb_strlen($entity[0]);
103
                            } else {
104
                                // no more characters left
105
                                break;
106
                            }
107
                        }
108
                    }
109
                    $truncate .= mb_substr($line_matchings[2], 0, $left + $entities_length);
110
                    // maximum lenght is reached, so get off the loop
111
                    break;
112
                }
113
                $truncate     .= $line_matchings[2];
114
                $total_length += $content_length;
115
116
                // if the maximum length is reached, get off the loop
117
                if ($total_length >= $length) {
118
                    break;
119
                }
120
            }
121
        } else {
122
            if (mb_strlen($text) <= $length) {
123
                return $text;
124
            }
125
            $truncate = mb_substr($text, 0, $length - mb_strlen($ending));
126
        }
127
        // if the words shouldn't be cut in the middle...
128
        if (!$exact) {
129
            // ...search the last occurance of a space...
130
            $spacepos = mb_strrpos($truncate, ' ');
131
            if (isset($spacepos)) {
132
                // ...and cut the text in this position
133
                $truncate = mb_substr($truncate, 0, $spacepos);
134
            }
135
        }
136
        // add the defined ending to the text
137
        $truncate .= $ending;
138
        if ($considerHtml) {
139
            // close all unclosed html-tags
140
            foreach ($open_tags as $tag) {
0 ignored issues
show
Comprehensibility Best Practice introduced by
The variable $open_tags does not seem to be defined for all execution paths leading up to this point.
Loading history...
141
                $truncate .= '</' . $tag . '>';
142
            }
143
        }
144
145
        return $truncate;
146
    }
147
148
    /**
149
     * @param \Xmf\Module\Helper|null $helper
150
     * @param array|null              $options
151
     * @return \XoopsFormDhtmlTextArea|\XoopsFormEditor
152
     */
153
    public static function getEditor(\Xmf\Module\Helper $helper = null, array $options = null)
154
    {
155
        /** @var Helper $helper */
156
        if (null === $options) {
157
            $options           = [];
158
            $options['name']   = 'Editor';
159
            $options['value']  = 'Editor';
160
            $options['rows']   = 10;
161
            $options['cols']   = '100%';
162
            $options['width']  = '100%';
163
            $options['height'] = '400px';
164
        }
165
166
        if (null === $helper) {
167
            $helper = Helper::getInstance();
168
        }
169
170
        $isAdmin = $helper->isUserAdmin();
171
172
        if (\class_exists('XoopsFormEditor')) {
173
            if ($isAdmin) {
174
                $descEditor = new \XoopsFormEditor(\ucfirst((string) $options['name']), $helper->getConfig('editorAdmin'), $options, $nohtml = false, $onfailure = 'textarea');
175
            } else {
176
                $descEditor = new \XoopsFormEditor(\ucfirst((string) $options['name']), $helper->getConfig('editorUser'), $options, $nohtml = false, $onfailure = 'textarea');
177
            }
178
        } else {
179
            $descEditor = new \XoopsFormDhtmlTextArea(\ucfirst((string) $options['name']), $options['name'], $options['value'], '100%', '100%');
0 ignored issues
show
Bug introduced by
'100%' of type string is incompatible with the type integer expected by parameter $rows of XoopsFormDhtmlTextArea::__construct(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

179
            $descEditor = new \XoopsFormDhtmlTextArea(\ucfirst((string) $options['name']), $options['name'], $options['value'], /** @scrutinizer ignore-type */ '100%', '100%');
Loading history...
Bug introduced by
'100%' of type string is incompatible with the type integer expected by parameter $cols of XoopsFormDhtmlTextArea::__construct(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

179
            $descEditor = new \XoopsFormDhtmlTextArea(\ucfirst((string) $options['name']), $options['name'], $options['value'], '100%', /** @scrutinizer ignore-type */ '100%');
Loading history...
180
        }
181
182
        //        $form->addElement($descEditor);
183
184
        return $descEditor;
185
    }
186
187
    /**
188
     * @param string $fieldname
189
     * @param string $table
190
     *
191
     * @return bool
192
     */
193
    public static function fieldExists(string $fieldname, string $table): bool
194
    {
195
        global $xoopsDB;
196
        $sql = "SHOW COLUMNS FROM   $table LIKE '$fieldname'";
197
        $result = $xoopsDB->queryF($sql);
198
        if (!$xoopsDB->isResultSet($result)) {
199
            \trigger_error("Query Failed! SQL: $sql- Error: " . $xoopsDB->error(), E_USER_ERROR);
200
        }
201
        return ($xoopsDB->getRowsNum($result) > 0);
202
    }
203
204
    /**
205
     * Check if dB table exists
206
     *
207
     * @param string $tablename dB tablename with prefix
208
     * @return bool true if table exists
209
     */
210
    public static function tableExists(string $tablename): bool
211
    {
212
        $ret    = false;
213
        $trace = \debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1);
214
        \trigger_error(__FUNCTION__ . " is deprecated, called from {$trace[0]['file']} line {$trace[0]['line']}");
215
        $GLOBALS['xoopsLogger']->addDeprecated(
216
            \basename(\dirname(__DIR__, 2)) . ' Module: ' . __FUNCTION__ . ' function is deprecated, please use Xmf\Database\Tables method(s) instead.' . " Called from {$trace[0]['file']}line {$trace[0]['line']}"
217
        );
218
        $result = $GLOBALS['xoopsDB']->queryF("SHOW TABLES LIKE '$tablename'");
219
220
        if ($GLOBALS['xoopsDB']->isResultSet($result)) {
221
            $ret = $GLOBALS['xoopsDB']->getRowsNum($result) > 0;
222
        }
223
224
        return $ret;
225
    }
226
227
    /**
228
     * @param mixed[]|string $tableName
229
     * @param string       $id_field
230
     * @param int          $id
231
     *
232
     * @return bool
233
     */
234
    public static function cloneRecord($tableName, string $id_field, int $id): bool
235
    {
236
        $new_id = false;
0 ignored issues
show
Unused Code introduced by
The assignment to $new_id is dead and can be removed.
Loading history...
237
        $table  = $GLOBALS['xoopsDB']->prefix($tableName);
238
        // copy content of the record you wish to clone
239
        $sql = "SELECT * FROM $table WHERE $id_field='$id' ";
240
        $result = $GLOBALS['xoopsDB']->query($sql);
241
        if (!$GLOBALS['xoopsDB']->isResultSet($result)) {
242
            \trigger_error("Could not select record! SQL: $sql- Error: " . $GLOBALS['xoopsDB']->error(), E_USER_ERROR);
243
        }
244
        $tempTable = $GLOBALS['xoopsDB']->fetchArray($GLOBALS['xoopsDB']->query($sql), \MYSQLI_ASSOC);
245
        // set the auto-incremented id's value to blank.
246
        unset($tempTable[$id_field]);
247
        // insert cloned copy of the original  record
248
        $sql = "INSERT INTO $table (" . \implode(', ', \array_keys($tempTable)) . ") VALUES ('" . \implode("', '", \array_values($tempTable)) . "')";
249
        $result = $GLOBALS['xoopsDB']->queryF($sql);
250
        if ($result) {
251
            // Return the new id
252
            $new_id = $GLOBALS['xoopsDB']->getInsertId();
253
        } else {
254
            exit($GLOBALS['xoopsDB']->error());
0 ignored issues
show
Best Practice introduced by
Using exit here is not recommended.

In general, usage of exit should be done with care and only when running in a scripting context like a CLI script.

Loading history...
Bug Best Practice introduced by
In this branch, the function will implicitly return null which is incompatible with the type-hinted return boolean. Consider adding a return statement or allowing null as return value.

For hinted functions/methods where all return statements with the correct type are only reachable via conditions, ?null? gets implicitly returned which may be incompatible with the hinted type. Let?s take a look at an example:

interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
Loading history...
255
        }
256
        return $new_id;
257
    }
258
259
    /**
260
     * Add a field to a mysql table
261
     *
262
     * @param string $field
263
     * @param string $table
264
     * @author        Hervé Thouzard (https://www.herve-thouzard.com)
265
     * @copyright (c) Hervé Thouzard
266
     * @return bool|\mysqli_result
267
     */
268
    public static function addField(string $field, string $table)
269
    {
270
        global $xoopsDB;
271
        $sql = 'ALTER TABLE ' . $table . " ADD $field";
272
        $result = $xoopsDB->queryF($sql);
273
274
        return $result;
275
    }
276
277
    /**
278
     * Function responsible for checking if a directory exists, we can also write in and create an index.html file
279
     *
280
     * @param string $folder Le chemin complet du répertoire à vérifier
281
     */
282
    public static function prepareFolder(string $folder): void
283
    {
284
        try {
285
            if (!@\mkdir($folder) && !\is_dir($folder)) {
286
                throw new \RuntimeException(\sprintf('Unable to create the %s directory', $folder));
287
            }
288
            file_put_contents($folder . '/index.html', '<script>history.go(-1);</script>');
289
        } catch (\Throwable $e) {
290
            echo 'Caught exception: ', $e->getMessage(), "\n", '<br>';
291
        }
292
    }
293
}
294