fabric.php

См. документацию.

<?php
namespace Bitrix\Iblock\Template\Functions;
class Fabric
{
    protected static array $defaultFunctionMap = [
        'upper' => FunctionUpper::class,
        'lower' => FunctionLower::class,
        'translit' => FunctionTranslit::class,
        'concat' => FunctionConcat::class,
        'limit' => FunctionLimit::class,
        'contrast' => FunctionContrast::class,
        'min' => FunctionMin::class,
        'max' => FunctionMax::class,
        'distinct' => FunctionDistinct::class,
        'ucfirst' => FunctionUcfirst::class,
        'ucwords' => FunctionUcwords::class,
        'striptags' => FunctionStripTags::class,
    ];
 
    protected static array $functionMap = [];
    public static function createInstance($functionName, $data = null) //todo rename createInstance
    {
        if (!is_string($functionName))
        {
            return new FunctionBase($data);
        }
        if (isset(self::$defaultFunctionMap[$functionName]))
        {
            $functionClass = self::$defaultFunctionMap[$functionName];
            return new $functionClass($data);
        }
        elseif (isset(self::$functionMap[$functionName]))
        {
            $functionClass = self::$functionMap[$functionName];
            return new $functionClass($data);
        }
        else
        {
            $event = new \Bitrix\Main\Event("iblock", "OnTemplateGetFunctionClass", array($functionName));
            $event->send();
            if ($event->getResults())
            {
                foreach($event->getResults() as $evenResult)
                {
                    if($evenResult->getType() == \Bitrix\Main\EventResult::SUCCESS)
                    {
                        $functionClass = $evenResult->getParameters();
                        if (is_string($functionClass) && class_exists($functionClass))
                        {
                            self::$functionMap[$functionName] = $functionClass;
                        }
                        break;
                    }
                }
            }
            if (isset(self::$functionMap[$functionName]))
            {
                $functionClass = self::$functionMap[$functionName];
                return new $functionClass($data);
            }
        }
 
        return new FunctionBase($data);
    }
}

class FunctionBase
{
    protected $data = null;

    function __construct($data = null)
    {
        $this->data = $data;
    }

    public function onPrepareParameters(\Bitrix\Iblock\Template\Entity\Base $entity, array $parameters)
    {
        $arguments = array();
        foreach ($parameters as $parameter)
        {
            $arguments[] = $parameter->process($entity);
        }
        return $arguments;
    }

    public function calculate(array $parameters)
    {
        return "";
    }

    protected function parametersToString(array $parameters)
    {
        $result = array();
        foreach ($parameters as $param)
        {
            if (is_array($param))
                $result[] = implode(" ", $param);
            elseif ($param != "")
                $result[] = $param;
        }
        return implode(" ", $result);
    }

    protected function parametersToArray(array $parameters)
    {
        $result = array();
        foreach ($parameters as $param)
        {
            if (is_array($param))
            {
                foreach ($param as $p)
                    $result[] = $p;
            }
            elseif ($param != "")
            {
                $result[] = $param;
            }
        }
        return $result;
    }
}

class FunctionUpper extends FunctionBase
{
    public function calculate(array $parameters)
    {
        return mb_strtoupper($this->parametersToString($parameters));
    }
}

class FunctionLower extends FunctionBase
{
    public function calculate(array $parameters)
    {
        return mb_strtolower($this->parametersToString($parameters));
    }
}

class FunctionTranslit extends FunctionBase
{
    public function calculate(array $parameters)
    {
        $changeCase = false;
        $replaceChar = "";
 
        if (
            isset($this->data)
            && isset($this->data["replace_space"])
            && $this->data["replace_space"] != ""
        )
        {
            $changeCase = isset($this->data[""])? $this->data["change_case"]: false;
            $replaceChar = $this->data["replace_space"];
        }
 
        if (
            isset($this->data)
            && isset($this->data["change_case"])
            && $this->data["change_case"] != ""
        )
        {
            $changeCase = $this->data["change_case"];
        }
 
 
        return \CUtil::translit($this->parametersToString($parameters), LANGUAGE_ID, array(
            //"max_len" => 50,
            "change_case" => $changeCase, // 'L' - toLower, 'U' - toUpper, false - do not change
            "replace_space" => $replaceChar,
            "replace_other" => $replaceChar,
            "delete_repeat_replace" => true,
        ));
    }
}

class FunctionConcat extends FunctionBase
{
    public function calculate(array $parameters)
    {
        $result = $this->parametersToArray($parameters);
        $delimiter = array_pop($result);
 
        return implode($delimiter, $result);
    }
}

class FunctionLimit extends FunctionBase
{
    public function calculate(array $parameters)
    {
        $result = $this->parametersToArray($parameters);
        $limit = array_pop($result);
        $delimiter = array_pop($result);
        $text = implode(" ", $result);
 
        $result = preg_split("/([".preg_quote($delimiter, "/")."]+)/", $text);
        return array_slice($result, 0, $limit);
    }
}

class FunctionContrast extends FunctionBase
{
    public function calculate(array $parameters)
    {
        $result = $this->parametersToArray($parameters);
        $limit = array_pop($result);
        $delimiter = array_pop($result);
        $text = strip_tags(implode(" ", $result));
 
        $words = array();
        $result = preg_split("/([".preg_quote($delimiter, "/")."]+)/", $text);
        if ($result)
        {
            foreach ($result as $word)
            {
                if (mb_strlen($word) > 1)
                    $words[$word]++;
            }
            $len = log(max(20, array_sum($words)));
            foreach ($words as $word => $count)
            {
                $words[$word] = log($count + 1) / $len;
            }
            arsort($words);
        }
        return array_keys(array_slice($words, 0, $limit));
    }
}

class FunctionMin extends FunctionBase
{
    public function calculate(array $parameters)
    {
        $result = $this->parametersToArray($parameters);
        $asFloat = [];
        foreach ($result as $rawValue)
        {
            if (!isset($asFloat[$rawValue]))
            {
                $value = preg_replace("/&\#[0-9]+;/", '', $rawValue);
                $floatFalue = (float)preg_replace("/[^0-9.]+/", "", $value);
                $asFloat[$rawValue] = $floatFalue;
            }
        }
 
        if (empty($asFloat))
        {
            return '';
        }
        elseif (count($asFloat) == 1)
        {
            return end($result);
        }
        else
        {
            $min = min($asFloat);
 
            return array_search($min, $asFloat);
        }
    }
}

class FunctionMax extends FunctionBase
{
    public function calculate(array $parameters)
    {
        $result = $this->parametersToArray($parameters);
        $asFloat = [];
        foreach ($result as $rawValue)
        {
            if (!isset($asFloat[$rawValue]))
            {
                $value = preg_replace("/&\#[0-9]+;/", '', $rawValue);
                $floatFalue = (float)preg_replace("/[^0-9.]+/", '', $value);
                $asFloat[$rawValue] = $floatFalue;
            }
        }
        if (empty($asFloat))
        {
            return '';
        }
        elseif (count($asFloat) == 1)
        {
            return end($result);
        }
        else
        {
            $max = max($asFloat);
 
            return array_search($max, $asFloat);
        }
    }
}

class FunctionDistinct extends FunctionBase
{
    public function calculate(array $parameters)
    {
        $result = array();
        foreach ($this->parametersToArray($parameters) as $value)
            $result[$value] = $value;
        return array_values($result);
    }
}