MarkerBasedTemplateService.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Core\Service;
 
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('hash');
    }
 
    protected function ‪getRuntimeCache()
    {
        return GeneralUtility::makeInstance(CacheManager::class)->getCache('runtime');
    }
}