9.5/_marker_based_template_service_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\Service;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */

use ‪TYPO3\CMS\Core\Cache\CacheManager;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Core\Utility\MathUtility;


class ‪MarkerBasedTemplateService

{

    public function ‪getSubpart($content, $marker)

    {

        $start = strpos($content, $marker);

        if ($start === false) {

            return '';

        }

        $start += strlen($marker);

        $stop = strpos($content, $marker, $start);

        // Q: What shall get returned if no stop marker is given

        // Everything till the end or nothing?

        if ($stop === false) {

            return '';

        }

        $content = substr($content, $start, $stop - $start);

        $matches = [];

        if (preg_match('/^([^\\<]*\\-\\-\\>)(.*)(\\<\\!\\-\\-[^\\>]*)$/s', $content, $matches) === 1) {

            return $matches[2];

        }

        // Resetting $matches

        $matches = [];

        if (preg_match('/(.*)(\\<\\!\\-\\-[^\\>]*)$/s', $content, $matches) === 1) {

            return $matches[1];

        }

        // Resetting $matches

        $matches = [];

        if (preg_match('/^([^\\<]*\\-\\-\\>)(.*)$/s', $content, $matches) === 1) {

            return $matches[2];

        }


        return $content;

    }


    public function ‪substituteSubpart($content, $marker, $subpartContent, $recursive = true, $keepMarker = false)

    {

        $start = strpos($content, $marker);

        if ($start === false) {

            return $content;

        }

        $startAM = $start + strlen($marker);

        $stop = strpos($content, $marker, $startAM);

        if ($stop === false) {

            return $content;

        }

        $stopAM = $stop + strlen($marker);

        $before = substr($content, 0, $start);

        $after = substr($content, $stopAM);

        $between = substr($content, $startAM, $stop - $startAM);

        if ($recursive) {

            $after = $this->‪substituteSubpart($after, $marker, $subpartContent, $recursive, $keepMarker);

        }

        if ($keepMarker) {

            $matches = [];

            if (preg_match('/^([^\\<]*\\-\\-\\>)(.*)(\\<\\!\\-\\-[^\\>]*)$/s', $between, $matches) === 1) {

                $before .= $marker . $matches[1];

                $between = $matches[2];

                $after = $matches[3] . $marker . $after;

            } elseif (preg_match('/^(.*)(\\<\\!\\-\\-[^\\>]*)$/s', $between, $matches) === 1) {

                $before .= $marker;

                $between = $matches[1];

                $after = $matches[2] . $marker . $after;

            } elseif (preg_match('/^([^\\<]*\\-\\-\\>)(.*)$/s', $between, $matches) === 1) {

                $before .= $marker . $matches[1];

                $between = $matches[2];

                $after = $marker . $after;

            } else {

                $before .= $marker;

                $after = $marker . $after;

            }

        } else {

            $matches = [];

            if (preg_match('/^(.*)\\<\\!\\-\\-[^\\>]*$/s', $before, $matches) === 1) {

                $before = $matches[1];

            }

            if (is_array($subpartContent)) {

                $matches = [];

                if (preg_match('/^([^\\<]*\\-\\-\\>)(.*)(\\<\\!\\-\\-[^\\>]*)$/s', $between, $matches) === 1) {

                    $between = $matches[2];

                } elseif (preg_match('/^(.*)(\\<\\!\\-\\-[^\\>]*)$/s', $between, $matches) === 1) {

                    $between = $matches[1];

                } elseif (preg_match('/^([^\\<]*\\-\\-\\>)(.*)$/s', $between, $matches) === 1) {

                    $between = $matches[2];

                }

            }

            $matches = [];

            // resetting $matches

            if (preg_match('/^[^\\<]*\\-\\-\\>(.*)$/s', $after, $matches) === 1) {

                $after = $matches[1];

            }

        }

        if (is_array($subpartContent)) {

            $between = $subpartContent[0] . $between . $subpartContent[1];

        } else {

            $between = $subpartContent;

        }


        return $before . $between . $after;

    }


    public function ‪substituteSubpartArray($content, array $subpartsContent)

    {

        foreach ($subpartsContent as $subpartMarker => $subpartContent) {

            $content = $this->‪substituteSubpart($content, $subpartMarker, $subpartContent);

        }


        return $content;

    }


    public function ‪substituteMarker($content, $marker, $markContent)

    {

        return str_replace($marker, $markContent, $content);

    }


    public function ‪substituteMarkerArray($content, $markContentArray, $wrap = '', $uppercase = false, $deleteUnused = false)

    {

        if (is_array($markContentArray)) {

            $wrapArr = GeneralUtility::trimExplode('|', $wrap);

            $search = [];

            $replace = [];

            foreach ($markContentArray as $marker => $markContent) {

                if ($uppercase) {

                    // use strtr instead of strtoupper to avoid locale problems with Turkish

                    $marker = strtr($marker, 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');

                }

                if (isset($wrapArr[0], $wrapArr[1])) {

                    $marker = $wrapArr[0] . $marker . $wrapArr[1];

                }

                $search[] = $marker;

                $replace[] = $markContent;

            }

            $content = str_replace($search, $replace, $content);

            unset($search, $replace);

            if ($deleteUnused) {

                if (empty($wrap)) {

                    $wrapArr = ['###', '###'];

                }

                $content = preg_replace('/' . preg_quote($wrapArr[0], '/') . '([A-Z0-9_|\\-]*)' . preg_quote($wrapArr[1], '/') . '/is', '', $content);

            }

        }


        return $content;

    }


    public function ‪substituteMarkerAndSubpartArrayRecursive($content, array $markersAndSubparts, $wrap = '', $uppercase = false, $deleteUnused = false)

    {

        $wraps = GeneralUtility::trimExplode('|', $wrap);

        $singleItems = [];

        $compoundItems = [];

        // Split markers and subparts into separate arrays

        foreach ($markersAndSubparts as $markerName => $markerContent) {

            if (is_array($markerContent)) {

                $compoundItems[] = $markerName;

            } else {

                $singleItems[$markerName] = $markerContent;

            }

        }

        $subTemplates = [];

        $subpartSubstitutes = [];

        // Build a cache for the sub template

        foreach ($compoundItems as $subpartMarker) {

            if ($uppercase) {

                // Use strtr instead of strtoupper to avoid locale problems with Turkish

                $subpartMarker = strtr($subpartMarker, 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');

            }

            if (isset($wraps[0], $wraps[1])) {

                $subpartMarker = $wraps[0] . $subpartMarker . $wraps[1];

            }

            $subTemplates[$subpartMarker] = $this->‪getSubpart($content, $subpartMarker);

        }

        // Replace the subpart contents recursively

        foreach ($compoundItems as $subpartMarker) {

            $completeMarker = $subpartMarker;

            if ($uppercase) {

                // use strtr instead of strtoupper to avoid locale problems with Turkish

                $completeMarker = strtr($completeMarker, 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');

            }

            if (isset($wraps[0], $wraps[1])) {

                $completeMarker = $wraps[0] . $completeMarker . $wraps[1];

            }

            if (!empty($markersAndSubparts[$subpartMarker])) {

                $subpartSubstitutes[$completeMarker] = '';

                foreach ($markersAndSubparts[$subpartMarker] as $partialMarkersAndSubparts) {

                    $subpartSubstitutes[$completeMarker] .= $this->‪substituteMarkerAndSubpartArrayRecursive(

                        $subTemplates[$completeMarker],

                        $partialMarkersAndSubparts,

                        $wrap,

                        $uppercase,

                        $deleteUnused

                    );

                }

            } else {

                $subpartSubstitutes[$completeMarker] = '';

            }

        }

        // Substitute the single markers and subparts

        $result = $this->‪substituteSubpartArray($content, $subpartSubstitutes);

        $result = $this->‪substituteMarkerArray($result, $singleItems, $wrap, $uppercase, $deleteUnused);


        return $result;

    }


    public function ‪substituteMarkerArrayCached($content, array $markContentArray = null, array $subpartContentArray = null, array $wrappedSubpartContentArray = null)

    {

        $runtimeCache = $this->‪getRuntimeCache();

        // If not arrays then set them

        if ($markContentArray === null) {

            // Plain markers

            $markContentArray = [];

        }

        if ($subpartContentArray === null) {

            // Subparts being directly substituted

            $subpartContentArray = [];

        }

        if ($wrappedSubpartContentArray === null) {

            // Subparts being wrapped

            $wrappedSubpartContentArray = [];

        }

        // Finding keys and check hash:

        $sPkeys = array_keys($subpartContentArray);

        $wPkeys = array_keys($wrappedSubpartContentArray);

        $keysToReplace = array_merge(array_keys($markContentArray), $sPkeys, $wPkeys);

        if (empty($keysToReplace)) {

            return $content;

        }

        asort($keysToReplace);

        $storeKey = md5('substituteMarkerArrayCached_storeKey:' . serialize([$content, $keysToReplace]));

        $fromCache = $runtimeCache->get($storeKey);

        if ($fromCache) {

            $storeArr = $fromCache;

        } else {

            $cache = $this->‪getCache();

            $storeArrDat = $cache->get($storeKey);

            if (is_array($storeArrDat)) {

                $storeArr = $storeArrDat;

                // Setting the data in the first level cache

                $runtimeCache->set($storeKey, $storeArr);

            } else {

                // Finding subparts and substituting them with the subpart as a marker

                foreach ($sPkeys as $sPK) {

                    $content = $this->‪substituteSubpart($content, $sPK, $sPK);

                }

                // Finding subparts and wrapping them with markers

                foreach ($wPkeys as $wPK) {

                    $content = $this->‪substituteSubpart($content, $wPK, [

                        $wPK,

                        $wPK

                    ]);

                }


                $storeArr = [];

                // search all markers in the content

                $result = preg_match_all('/###([^#](?:[^#]*+|#{1,2}[^#])+)###/', $content, $markersInContent);

                if ($result !== false && !empty($markersInContent[1])) {

                    $keysToReplaceFlipped = array_flip($keysToReplace);

                    $regexKeys = [];

                    $wrappedKeys = [];

                    // Traverse keys and quote them for reg ex.

                    foreach ($markersInContent[1] as $key) {

                        if (isset($keysToReplaceFlipped['###' . $key . '###'])) {

                            $regexKeys[] = preg_quote($key, '/');

                            $wrappedKeys[] = '###' . $key . '###';

                        }

                    }

                    $regex = '/###(?:' . implode('|', $regexKeys) . ')###/';

                    $storeArr['c'] = preg_split($regex, $content); // contains all content parts around markers

                    $storeArr['k'] = $wrappedKeys; // contains all markers incl. ###

                    // Setting the data inside the second-level cache

                    $runtimeCache->set($storeKey, $storeArr);

                    // Storing the cached data permanently

                    $cache->set($storeKey, $storeArr, ['substMarkArrayCached'], 0);

                }

            }

        }

        if (!empty($storeArr['k']) && is_array($storeArr['k'])) {

            // Substitution/Merging:

            // Merging content types together, resetting

            $valueArr = array_merge($markContentArray, $subpartContentArray, $wrappedSubpartContentArray);

            $wSCA_reg = [];

            $content = '';

            // Traversing the keyList array and merging the static and dynamic content

            foreach ($storeArr['k'] as $n => $keyN) {

                // add content before marker

                $content .= $storeArr['c'][$n];

                if (!is_array($valueArr[$keyN])) {

                    // fetch marker replacement from $markContentArray or $subpartContentArray

                    $content .= $valueArr[$keyN];

                } else {

                    if (!isset($wSCA_reg[$keyN])) {

                        $wSCA_reg[$keyN] = 0;

                    }

                    // fetch marker replacement from $wrappedSubpartContentArray

                    $content .= $valueArr[$keyN][$wSCA_reg[$keyN] % 2];

                    $wSCA_reg[$keyN]++;

                }

            }

            // add remaining content

            $content .= $storeArr['c'][count($storeArr['k'])];

        }

        return $content;

    }


    public function ‪substituteMarkerInObject(&$tree, array $markContentArray)

    {

        if (is_array($tree)) {

            foreach ($tree as $key => $value) {

                $this->‪substituteMarkerInObject($tree[$key], $markContentArray);

            }

        } else {

            $tree = $this->‪substituteMarkerArray($tree, $markContentArray);

        }

        return $tree;

    }


    public function ‪fillInMarkerArray(array $markContentArray, array $row, $fieldList = '', $nl2br = true, $prefix = 'FIELD_', $htmlSpecialCharsValue = false, $respectXhtml = false)

    {

        if ($fieldList) {

            $fArr = GeneralUtility::trimExplode(',', $fieldList, true);

            foreach ($fArr as $field) {

                $markContentArray['###' . $prefix . $field . '###'] = $nl2br ? nl2br($row[$field], $respectXhtml) : $row[$field];

            }

        } else {

            if (is_array($row)) {

                foreach ($row as $field => $value) {

                    if (!‪MathUtility::canBeInterpretedAsInteger($field)) {

                        if ($htmlSpecialCharsValue) {

                            $value = htmlspecialchars($value);

                        }

                        $markContentArray['###' . $prefix . $field . '###'] = $nl2br ? nl2br($value, $respectXhtml) : $value;

                    }

                }

            }

        }

        return $markContentArray;

    }


    protected function ‪getCache()

    {

        return GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_hash');

    }


    protected function ‪getRuntimeCache()

    {

        return GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_runtime');

    }

}