Merge pull request #11490 from annando/issue-11487

[friendica.git] / src / Util / Strings.php

diff --git a/src/Util/Strings.php b/src/Util/Strings.php
index c520b54b9ba508f1aaaa42331585c6d92ee5dc25..8666d30c18310d68574d37d72940c307b37ae52d 100644 (file)
--- a/src/Util/Strings.php
+++ b/src/Util/Strings.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * @copyright Copyright (C) 2020, Friendica
+ * @copyright Copyright (C) 2010-2022, the Friendica project
  *
  * @license GNU AGPL version 3 or any later version
  *
@@ -59,21 +59,6 @@ class Strings
                return !empty($hexCode) ? @preg_match("/^[a-f0-9]{2,}$/i", $hexCode) && !(strlen($hexCode) & 1) : false;
        }
 
-       /**
-        * This is our primary input filter.
-        *
-        * Use this on any text input where angle chars are not valid or permitted
-        * They will be replaced with safer brackets. This may be filtered further
-        * if these are not allowed either.
-        *
-        * @param string $string Input string
-        * @return string Filtered string
-        */
-       public static function escapeTags($string)
-       {
-               return str_replace(["<", ">"], ['[', ']'], $string);
-       }
-
        /**
         * Use this on "body" or "content" input where angle chars shouldn't be removed,
         * and allow them to be safely displayed.
@@ -283,7 +268,7 @@ class Strings
        public static function base64UrlDecode($s)
        {
                if (is_array($s)) {
-                       Logger::log('base64url_decode: illegal input: ' . print_r(debug_backtrace(), true));
+                       Logger::notice('base64url_decode: illegal input: ', ['backtrace' => debug_backtrace()]);
                        return $s;
                }
 
@@ -369,13 +354,43 @@ class Strings
         * @param array  $chars
         * @return bool
         */
-       public static function startsWith($string, array $chars)
+       public static function startsWithChars($string, array $chars)
        {
                $return = in_array(substr(trim($string), 0, 1), $chars);
 
                return $return;
        }
 
+       /**
+        * Check if the first string starts with the second
+        *
+        * @see http://maettig.com/code/php/php-performance-benchmarks.php#startswith
+        * @param string $string
+        * @param string $start
+        * @return bool
+        */
+       public static function startsWith(string $string, string $start)
+       {
+               $return = substr_compare($string, $start, 0, strlen($start)) === 0;
+
+               return $return;
+       }
+
+       /**
+        * Checks if the first string ends with the second
+        *
+        * @see http://maettig.com/code/php/php-performance-benchmarks.php#endswith
+        * @param string $string
+        * @param string $end
+        * @return bool
+        */
+       public static function endsWith(string $string, string $end)
+       {
+               $return = substr_compare($string, $end, -strlen($end)) === 0;
+
+               return $return;
+       }
+
        /**
         * Returns the regular expression string to match URLs in a given text
         *
@@ -420,4 +435,89 @@ class Strings
 
                return $pathItem;
        }
+
+       /**
+        * Multi-byte safe implementation of substr_replace where $start and $length are character offset and count rather
+        * than byte offset and counts.
+        *
+        * Depends on mbstring, use default encoding.
+        *
+        * @param string   $string
+        * @param string   $replacement
+        * @param int      $start
+        * @param int|null $length
+        * @return string
+        * @see substr_replace()
+        */
+       public static function substringReplace(string $string, string $replacement, int $start, int $length = null)
+       {
+               $string_length = mb_strlen($string);
+
+               $length = $length ?? $string_length;
+
+               if ($start < 0) {
+                       $start = max(0, $string_length + $start);
+               } else if ($start > $string_length) {
+                       $start = $string_length;
+               }
+
+               if ($length < 0) {
+                       $length = max(0, $string_length - $start + $length);
+               } else if ($length > $string_length) {
+                       $length = $string_length;
+               }
+
+               if (($start + $length) > $string_length) {
+                       $length = $string_length - $start;
+               }
+
+               return mb_substr($string, 0, $start) . $replacement . mb_substr($string, $start + $length, $string_length - $start - $length);
+       }
+
+       /**
+        * Perform a custom function on a text after having escaped blocks matched by the provided regular expressions.
+        * Only full matches are used, capturing group are ignored.
+        *
+        * To change the provided text, the callback function needs to return it and this function will return the modified
+        * version as well after having restored the escaped blocks.
+        *
+        * @param string   $text
+        * @param string   $regex
+        * @param callable $callback
+        * @return string
+        */
+       public static function performWithEscapedBlocks(string $text, string $regex, callable $callback): string
+       {
+               // Enables nested use
+               $executionId = random_int(PHP_INT_MAX / 10, PHP_INT_MAX);
+
+               $blocks = [];
+
+               $text = preg_replace_callback($regex,
+                       function ($matches) use ($executionId, &$blocks) {
+                               $return = '«block-' . $executionId . '-' . count($blocks) . '»';
+
+                               $blocks[] = $matches[0];
+
+                               return $return;
+                       },
+                       $text
+               );
+
+               $text = $callback($text) ?? '';
+
+               // Restore code blocks
+               $text = preg_replace_callback('/«block-' . $executionId . '-([0-9]+)»/iU',
+                       function ($matches) use ($blocks) {
+                               $return = $matches[0];
+                               if (isset($blocks[intval($matches[1])])) {
+                                       $return = $blocks[$matches[1]];
+                               }
+                               return $return;
+                       },
+                       $text
+               );
+
+               return $text;
+       }
 }