gnu-social/src/Util/Formatting.php

540 lines
19 KiB
PHP

<?php
// {{{ License
// This file is part of GNU social - https://www.gnu.org/software/social
//
// GNU social is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU social is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with GNU social. If not, see <http://www.gnu.org/licenses/>.
// }}}
/**
* String formatting utilities
*
* @package GNUsocial
* @category Util
*
* @author Hugo Sales <hugo@hsal.es>
* @copyright 2020-2021 Free Software Foundation, Inc http://www.fsf.org
* @license https://www.gnu.org/licenses/agpl.html GNU AGPL v3 or later
*/
namespace App\Util;
use App\Core\Event;
use App\Core\Log;
use App\Entity\Actor;
use App\Entity\Group;
use App\Entity\Note;
use App\Util\Exception\NicknameException;
use App\Util\Exception\ServerException;
use Functional as F;
use InvalidArgumentException;
abstract class Formatting
{
private static ?\Twig\Environment $twig;
public static function setTwig(\Twig\Environment $twig)
{
self::$twig = $twig;
}
public static function twigRenderString(string $template, array $context): string
{
return self::$twig->createTemplate($template, null)->render($context);
}
public static function twigRenderFile(string $template_path, array $context): string
{
return self::$twig->render($template_path, $context);
}
/**
* Normalize path by converting \ to /
*
* @param string $path
*
* @return string
*/
public static function normalizePath(string $path): string
{
return preg_replace(',(/|\\\\)+,', '/', $path);
}
/**
* Get plugin name from it's path, or null if not a plugin
*
* @param string $path
*
* @return null|string
*/
public static function moduleFromPath(string $path): ?string
{
foreach (['/plugins/', '/components/'] as $mod_p) {
$module = strpos($path, $mod_p);
if ($module === false) {
continue;
}
$cut = $module + strlen($mod_p);
$cut2 = strpos($path, '/', $cut);
if ($cut2) {
$final = substr($path, $cut, $cut2 - $cut);
} else {
// We might be running directly from the plugins dir?
// If so, there's no place to store locale info.
$m = 'The GNU social install dir seems to contain a piece named \'plugin\' or \'component\'';
Log::critical($m);
throw new ServerException($m);
}
return $final;
}
return null;
}
/**
* Check whether $haystack starts with $needle
*
* @param array|string $haystack if array, check that all strings start with $needle
* @param string $needle
*
* @return bool
*/
public static function startsWith($haystack, string $needle): bool
{
if (is_string($haystack)) {
$length = strlen($needle);
return substr($haystack, 0, $length) === $needle;
}
return F\every($haystack,
function ($haystack) use ($needle) {
return self::startsWith($haystack, $needle);
});
}
/**
* Check whether $haystack ends with $needle
*
* @param array|string $haystack if array, check that all strings end with $needle
* @param string $needle
*
* @return bool
*/
public static function endsWith($haystack, string $needle)
{
if (is_string($haystack)) {
$length = strlen($needle);
if ($length == 0) {
return true;
}
return substr($haystack, -$length) === $needle;
}
return F\every($haystack,
function ($haystack) use ($needle) {
return self::endsWith($haystack, $needle);
});
}
/**
* If $haystack starts with $needle, remove it from the beginning
*/
public static function removePrefix(string $haystack, string $needle)
{
return self::startsWith($haystack, $needle) ? substr($haystack, strlen($needle)) : $haystack;
}
/**
* If $haystack ends with $needle, remove it from the end
*/
public static function removeSuffix(string $haystack, string $needle)
{
return self::endsWith($haystack, $needle) && !empty($needle) ? substr($haystack, 0, -strlen($needle)) : $haystack;
}
public static function camelCaseToSnakeCase(string $str): string
{
return strtolower(preg_replace('/([a-z])([A-Z])/', '$1_$2', $str));
}
public static function snakeCaseToCamelCase(string $str): string
{
return implode('', F\map(preg_split('/[\b_]/', $str), F\ary('ucfirst', 1)));
}
/**
* Indent $in, a string or array, $level levels
*
* @param array|string $in
* @param int $level How many levels of indentation
* @param int $count How many spaces per indentation
*
* @return string
*/
public static function indent($in, int $level = 1, int $count = 2): string
{
if (is_string($in)) {
return self::indent(explode("\n", $in), $level, $count);
} elseif (is_array($in)) {
$indent = str_repeat(' ', $count * $level);
return implode("\n", F\map(F\select($in,
F\ary(function ($s) {
return $s != '';
}, 1)),
function ($val) use ($indent) {
return F\concat($indent . $val);
}));
}
throw new InvalidArgumentException('Formatting::indent\'s first parameter must be either an array or a string. Input was: ' . $in);
}
const SPLIT_BY_SPACE = ' ';
const JOIN_BY_SPACE = ' ';
const SPLIT_BY_COMMA = ', ';
const JOIN_BY_COMMA = ', ';
const SPLIT_BY_BOTH = '/[, ]/';
/**
* Convert scalars, objects implementing __toString or arrays to strings
*
* @param mixed $value
*/
public static function toString($value, string $join_type = self::JOIN_BY_COMMA): string
{
if (!in_array($join_type, [static::JOIN_BY_SPACE, static::JOIN_BY_COMMA])) {
throw new \Exception('Formatting::toString received invalid join option');
} else {
if (!is_array($value)) {
return (string) $value;
} else {
return implode($join_type, $value);
}
}
}
/**
* Convert a user supplied string to array and return whether the conversion was successfull
*
* @param mixed $output
*/
public static function toArray(string $input, &$output, string $split_type = self::SPLIT_BY_COMMA): bool
{
if (!in_array($split_type, [static::SPLIT_BY_SPACE, static::SPLIT_BY_COMMA, static::SPLIT_BY_BOTH])) {
throw new \Exception('Formatting::toArray received invalid split option');
}
if ($input == '') {
$output = [];
return true;
}
$matches = [];
if (preg_match('/^ *\[?([^,]+(, ?[^,]+)*)\]? *$/', $input, $matches)) {
switch ($split_type) {
case self::SPLIT_BY_BOTH:
$arr = preg_split($split_type, $matches[1], 0, PREG_SPLIT_NO_EMPTY);
break;
case self::SPLIT_BY_COMMA:
$arr = preg_split('/, ?/', $matches[1]);
break;
default:
$arr = explode($split_type[0], $matches[1]);
}
$output = str_replace([' \'', '\'', ' "', '"'], '', $arr);
$output = F\map($output, F\ary('trim', 1));
return true;
}
return false;
}
/**
* Render a plain text note content into HTML, extracting links and tags
*/
public static function renderPlainText(string $text): string
{
$text = self::quoteAndRemoveControlCodes($text);
// Split \n\n into paragraphs, process each paragrah and merge
$text = implode("\n", F\map(explode("\n\n", $text), function (string $paragraph) {
$paragraph = nl2br($paragraph, use_xhtml: false);
Event::handle('RenderContent', [&$paragraph]);
return HTML::html(['p' => [$paragraph]], options: ['raw' => true, 'indent' => false]);
}));
return $text;
}
/**
* Quote HTML special chars and strip Unicode text
* formatting/direction codes. This is can be pretty dangerous for
* visualisation of text or be used for mischief
*/
public static function quoteAndRemoveControlCodes(string $text): string
{
// Quote special chars
$text = htmlspecialchars($text, flags: ENT_QUOTES | ENT_SUBSTITUTE, double_encode: false);
// Normalize newlines to strictly \n and remove ASCII control codes
return preg_replace(['/[\x{0}-\x{8}\x{b}-\x{c}\x{e}-\x{19}\x{200b}-\x{200f}\x{202a}-\x{202e}]/u', '/\R/u'], ['', "\n"], $text);
}
/**
* Convert $str to it's closest ASCII representation
*/
public static function slugify(string $str, int $length = 64): string
{
// php-intl is highly recommended...
if (!function_exists('transliterator_transliterate')) {
$str = preg_replace('/[^\pL\pN]/u', '', $str);
$str = mb_convert_case($str, MB_CASE_LOWER, 'UTF-8');
$str = substr($str, 0, $length);
return $str;
}
$str = transliterator_transliterate('Any-Latin;' . // any charset to latin compatible
'NFD;' . // decompose
'[:Nonspacing Mark:] Remove;' . // remove nonspacing marks (accents etc.)
'NFC;' . // composite again
'[:Punctuation:] Remove;' . // remove punctuation (.,¿? etc.)
'Lower();' . // turn into lowercase
'Latin-ASCII;', // get ASCII equivalents (ð to d for example)
$str);
return substr(preg_replace('/[^\pL\pN]/u', '', $str), 0, $length);
}
/**
* Find @-mentions in the given text, using the given notice object as context.
* References will be resolved with common_relative_profile() against the user
* who posted the notice.
*
* Note the return data format is internal, to be used for building links and
* such. Should not be used directly; rather, call common_linkify_mentions().
*
* @param string $text
* @param Actor $actor the Actor that is sending the current text
* @param Note $parent the Note this text is in reply to, if any
*
* @return array
*
*/
public static function findMentions(string $text, Actor $actor, Note $parent = null)
{
$mentions = [];
if (Event::handle('StartFindMentions', [$actor, $text, &$mentions])) {
// Get the context of the original notice, if any
$origMentions = [];
// Does it have a parent notice for context?
if ($parent instanceof Note) {
foreach ($parent->getAttentionProfiles() as $repliedTo) {
if (!$repliedTo->isPerson()) {
continue;
}
$origMentions[$repliedTo->getId()] = $repliedTo;
}
}
$matches = self::findMentionsRaw($text, '@');
foreach ($matches as $match) {
try {
$nickname = Nickname::normalize($match[0], check_already_used: false);
} catch (NicknameException $e) {
// Bogus match? Drop it.
continue;
}
// primarily mention the profiles mentioned in the parent
$mention_found_in_origMentions = false;
foreach ($origMentions as $origMentionsId => $origMention) {
if ($origMention->getNickname() == $nickname) {
$mention_found_in_origMentions = $origMention;
// don't mention same twice! the parent might have mentioned
// two users with same nickname on different instances
unset($origMentions[$origMentionsId]);
break;
}
}
// Try to get a profile for this nickname.
// Start with parents mentions, then go to parents sender context
if ($mention_found_in_origMentions) {
$mentioned = $mention_found_in_origMentions;
} elseif ($parent instanceof Note && $parent->getActorNickname() === $nickname) {
$mentioned = $parent->getActor();
} else {
// sets to null if no match
$mentioned = $actor->findRelativeActor($nickname);
}
if ($mentioned instanceof Actor) {
$url = $mentioned->getUri(); // prefer the URI as URL, if it is one.
if (!Common::isValidHttpUrl($url)) {
$url = $mentioned->getUrl();
}
$mention = [
'mentioned' => [$mentioned],
'type' => 'mention',
'text' => $match[0],
'position' => $match[1],
'length' => mb_strlen($match[0]),
'title' => $mentioned->getFullname(),
'url' => $url,
];
$mentions[] = $mention;
}
}
// TODO Tag subscriptions
// @#tag => mention of all subscriptions tagged 'tag'
// $tag_matches = [];
// preg_match_all(
// '/' . Nickname::BEFORE_MENTIONS . '@#([\pL\pN_\-\.]{1,64})/',
// $text,
// $tag_matches,
// PREG_OFFSET_CAPTURE
// );
// foreach ($tag_matches[1] as $tag_match) {
// $tag = self::canonicalTag($tag_match[0]);
// $plist = Profile_list::getByTaggerAndTag($actor->getID(), $tag);
// if (!$plist instanceof Profile_list || $plist->private) {
// continue;
// }
// $tagged = $actor->getTaggedSubscribers($tag);
// $url = common_local_url(
// 'showprofiletag',
// ['nickname' => $actor->getNickname(), 'tag' => $tag]
// );
// $mentions[] = ['mentioned' => $tagged,
// 'type' => 'list',
// 'text' => $tag_match[0],
// 'position' => $tag_match[1],
// 'length' => mb_strlen($tag_match[0]),
// 'url' => $url, ];
// }
$group_matches = self::findMentionsRaw($text, '!');
foreach ($group_matches as $group_match) {
$nickname = Nickname::normalize($group_match[0], check_already_used: false);
$group = Group::getFromNickname($nickname, $actor);
if (!$group instanceof Group) {
continue;
}
$profile = $group->getActor();
$mentions[] = [
'mentioned' => [$profile],
'type' => 'group',
'text' => $group_match[0],
'position' => $group_match[1],
'length' => mb_strlen($group_match[0]),
'url' => $group->getUri(),
'title' => $group->getFullname(),
];
}
Event::handle('EndFindMentions', [$actor, $text, &$mentions]);
}
return $mentions;
}
/**
* Does the actual regex pulls to find @-mentions in text.
* Should generally not be called directly; for use in common_find_mentions.
*
* @param string $text
* @param string $preMention Character(s) that signals a mention ('@', '!'...)
*
* @return array of PCRE match arrays
*/
private static function findMentionsRaw(string $text, string $preMention = '@'): array
{
$tmatches = [];
preg_match_all(
'/^T (' . Nickname::DISPLAY_FMT . ') /',
$text,
$tmatches,
PREG_OFFSET_CAPTURE
);
$atmatches = [];
// the regexp's "(?!\@)" makes sure it doesn't matches the single "@remote" in "@remote@server.com"
preg_match_all(
'/' . Nickname::BEFORE_MENTIONS . preg_quote($preMention, '/') . '(' . Nickname::DISPLAY_FMT . ')\b(?!\@)/',
$text,
$atmatches,
PREG_OFFSET_CAPTURE
);
$matches = array_merge($tmatches[1], $atmatches[1]);
return $matches;
}
/**
* Finds @-mentions within the partially-rendered text section and
* turns them into live links.
*
* Should generally not be called except from common_render_content().
*
* @param string $text partially-rendered HTML
* @param Actor $author the Actor that is composing the current notice
* @param Note $parent the Note this is sent in reply to, if any
*
* @return string partially-rendered HTML
*/
public static function linkifyMentions($text, Actor $author, ?Note $parent = null)
{
$mentions = self::findMentions($text, $author, $parent);
// We need to go through in reverse order by position,
// so our positions stay valid despite our fudging with the
// string!
$points = [];
foreach ($mentions as $mention) {
$points[$mention['position']] = $mention;
}
krsort($points);
foreach ($points as $position => $mention) {
$linkText = self::linkifyMentionArray($mention);
$text = substr_replace($text, $linkText, $position, $mention['length']);
}
return $text;
}
public static function linkifyMentionArray(array $mention)
{
$output = null;
if (Event::handle('StartLinkifyMention', [$mention, &$output])) {
$attrs = [
'href' => $mention['url'],
'class' => 'h-card u-url p-nickname ' . $mention['type'],
];
if (!empty($mention['title'])) {
$attrs['title'] = $mention['title'];
}
$output = HTML::html(['a' => ['attrs' => $attrs, $mention['text']]]);
Event::handle('EndLinkifyMention', [$mention, &$output]);
}
return $output;
}
}