Upgrade to php 8 3

composer.json

@@ -10,10 +10,10 @@
     ],
     "minimum-stability": "dev",
     "require": {
-        "php": ">=5.3.3"
+        "php": ">=8.3"
     },
     "require-dev": {
-        "phpunit/phpunit": "~4.0"
+        "phpunit/phpunit": "~11.3"
     },
     "autoload": {
         "psr-0": { "ConfigToken\\": "lib/" }

lib/ConfigToken/LoggerInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace ConfigToken;
+
+interface LoggerInterface
+{
+    const DEBUG = 100;
+    const INFO = 200;
+    const NOTICE = 250;
+    const WARNING = 300;
+    const ERROR = 400;
+
+    public function addRecord($level, $message, array $context = array());
+}

lib/ConfigToken/TokenCollection.php

@@ -62,7 +62,7 @@ public function setIgnoreUnknownFilters($ignoreUnknownFilters)
      * @link http://php.net/manual/en/iteratoraggregate.getiterator.php
      * @return \Traversable An instance of an object implementing <b>Iterator</b> or <b>Traversable</b>
      */
-    public function getIterator()
+    public function getIterator(): \Traversable
     {
         return new \ArrayIterator($this->tokens);
     }
@@ -342,6 +342,7 @@ public function findWithUnresolvedFilters()
      * @param TokenResolverInterface $tokenResolver
      * @param boolean|null $ignoreUnknownTokens Null to use token resolver option.
      * @param boolean|null $ignoreUnknownFilters Null to use collection option.
+     * @param LoggerInterface|null $logger
      * @throws UnknownFilterException
      *
      * If using RegisteredTokenResolver:
@@ -355,7 +356,7 @@ public function findWithUnresolvedFilters()
      * @return $this
      */
     public function resolve(TokenResolverInterface $tokenResolver,
-                            $ignoreUnknownTokens = null, $ignoreUnknownFilters = null)
+                            $ignoreUnknownTokens = null, $ignoreUnknownFilters = null, LoggerInterface $logger=null)
     {
         if (is_null($ignoreUnknownTokens)) {
             $ignoreUnknownTokens = $tokenResolver->getIgnoreUnknownTokens();
@@ -377,4 +378,4 @@ public function resolve(TokenResolverInterface $tokenResolver,
         return $this;
     }
 
-}
+}

lib/ConfigToken/TokenInjector.php

@@ -15,10 +15,11 @@ class TokenInjector
      * @param string $string The string where to inject the resolved token values.
      * @param TokenCollection $tokens The tokens.
      * @param boolean $checkHash If true, the hash of the string must match the source hash of the tokens.
+     * @param LoggerInterface|null $logger
      * @throws UnknownTokenSourceException
      * @return string
      */
-    public static function injectString($string, TokenCollection $tokens, $checkHash = False) {
+    public static function injectString($string, TokenCollection $tokens, $checkHash = False, LoggerInterface $logger=null) {
         if ($checkHash) {
             $hash = md5($string);
             if ($tokens->hasSourceHash() && ($tokens->getSourceHash() !== $hash)) {
@@ -52,6 +53,15 @@ public static function injectString($string, TokenCollection $tokens, $checkHash
                     $blocks[] = $tokenValue;
                     $lastOffset = $offset + strlen($tokenString);
                     $offsetDelta += strlen($tokenValue) - strlen($tokenString);
+                    if (isset($logger) && (!isset($injected[$tokenString]))) {
+                        $logger->addRecord(
+                            LoggerInterface::DEBUG,
+                            sprintf(
+                                'Replaced token "%s" with value "%s".',
+                                $token
+                            )
+                        );
+                    }
                     $injected[$tokenString] = $token;
                 }
             }

lib/ConfigToken/TreeCompiler.php

@@ -71,6 +71,8 @@ class TreeCompiler
     protected $xrefTokenResolverRequiredOptionKeys = array();
     /** @var string[] */
     protected $xrefTokenResolverOptionSetterMapping = array();
+    /** @var array $headers */
+    protected $headers = array();
 
     /** @var string */
     protected $removeKey = 'remove';
@@ -85,8 +87,9 @@ class TreeCompiler
     const INCLUDE_TYPE_GROUP = 'group';
     const INCLUDE_TYPE_XREF = 'xref';
 
-    public function __construct(XrefCollection $xrefs = null)
+    public function __construct(XrefCollection $xrefs = null, $headers=array())
     {
+        $this->headers = $headers;
         if (!isset($xrefs)) {
             $xrefs = new XrefCollection();
         }
@@ -341,11 +344,14 @@ protected function validateXrefTokenResolverOptions($xrefKey, $tokenResolverDefi
      * @param string|array $xrefInfo
      * @param XrefTokenResolverCollection $xrefTokenResolvers
      * @param Xref[] $xrefPath
+     * @param Xref $currentXref
+     * @param LoggerInterface|null $logger
      * @return Xref|mixed
      * @throws TreeCompilerFormatException
      * @throws \Exception
      */
-    protected function parseXrefInfo($xrefKey, $xrefInfo, XrefTokenResolverCollection $xrefTokenResolvers = null, $xrefPath)
+    protected function parseXrefInfo($xrefKey, $xrefInfo, XrefTokenResolverCollection $xrefTokenResolvers = null,
+                                     $xrefPath, Xref $currentXref, LoggerInterface $logger=null)
     {
         $xrefData = null;
         if (gettype($xrefInfo) == 'string') {
@@ -390,11 +396,33 @@ protected function parseXrefInfo($xrefKey, $xrefInfo, XrefTokenResolverCollectio
 
         if (isset($xrefData)) {
             if (isset($xrefTokenResolvers)) {
-                $xrefTokenResolvers->applyToArray($xrefData);
+                $xrefTokenResolvers->applyToArray($xrefData, $logger);
             }
         } else {
             if (isset($xrefTokenResolvers)) {
-                $xrefLocation = $xrefTokenResolvers->applyToString($xrefLocation);
+                if (isset($logger)) {
+                    $logger->addRecord(
+                        LoggerInterface::DEBUG,
+                        sprintf(
+                            'Resolving tokens in xref location "%s" included by "%s"',
+                            $xrefLocation,
+                            $currentXref->getLocation()
+                        )
+                    );
+                }
+                $newXrefLocation = $xrefTokenResolvers->applyToString($xrefLocation, $logger);
+                if (isset($logger)) {
+                    $logger->addRecord(
+                        LoggerInterface::DEBUG,
+                        sprintf(
+                            'Xref location "%s" changed to "%s"',
+                            $xrefLocation,
+                            $newXrefLocation,
+                            $currentXref->getLocation()
+                        )
+                    );
+                }
+                $xrefLocation = $newXrefLocation;
             }
             $xrefLocation = Xref::computeAbsoluteLocation($xrefType, $xrefLocation, $xrefPath);
         }
@@ -418,10 +446,14 @@ protected function parseXrefInfo($xrefKey, $xrefInfo, XrefTokenResolverCollectio
      * @param array $tokenResolversInfo
      * @param XrefTokenResolverCollection $tokenResolvers
      * @param Xref[] $xrefPath
+     * @param Xref $currentXref
+     * @param LoggerInterface|null $logger
      * @return XrefTokenResolverCollection
      * @throws \Exception
      */
-    protected function parseXrefTokenResolverDefinitions($xrefKey, $tokenResolversInfo, XrefTokenResolverCollection $tokenResolvers = null, $xrefPath)
+    protected function parseXrefTokenResolverDefinitions($xrefKey, $tokenResolversInfo,
+                                                         XrefTokenResolverCollection $tokenResolvers=null, $xrefPath,
+                                                         Xref $currentXref, LoggerInterface $logger=null)
     {
         $resolverValues = array();
         $tokenResolverDefinitionIndex = 0;
@@ -500,10 +532,12 @@ protected function parseXrefTokenResolverDefinitions($xrefKey, $tokenResolversIn
                     sprintf('%s.%s[%d]', $xrefKey, $this->includeXrefResolversKey, $tokenResolverDefinitionIndex),
                     $xrefInfo,
                     $tokenResolvers,
-                    $xrefPath
+                    $xrefPath,
+                    $currentXref,
+                    $logger
                 );
                 // pass down current token resolvers
-                $values = $this->recursiveCompileXref($xref, $tokenResolvers, null, null, $xrefPath);
+                $values = $this->recursiveCompileXref($xref, $tokenResolvers, null, null, $xrefPath, $logger);
             }
             if (!is_array($values)) {
                 throw new TokenResolverDefinitionException(
@@ -521,6 +555,7 @@ protected function parseXrefTokenResolverDefinitions($xrefKey, $tokenResolversIn
         }
 
         $result = new XrefTokenResolverCollection();
+        $tokenResolverPosition = 0;
         // parse
         foreach ($tokenResolversInfo as $tokenResolverKey => $tokenResolverInfo) {
             if (isset($tokenResolverInfo[$this->xrefTokenResolverOptionsKey])) {
@@ -530,6 +565,10 @@ protected function parseXrefTokenResolverDefinitions($xrefKey, $tokenResolversIn
             }
             $tokenResolver = TokenResolverFactory::get($tokenResolverInfo[$this->xrefTokenResolverTypeKey]);
             $xrefTokenResolver = new XrefTokenResolver($tokenResolver);
+            $xrefTokenResolver
+                ->setSourceXrefLocation($currentXref->getLocation())
+                ->setSourceXrefPosition($tokenResolverPosition++)
+            ;
             $values = $resolverValues[$tokenResolverKey];
             $xrefTokenResolver->setRegisteredTokenValues($values);
             if (isset($options)) {
@@ -580,6 +619,7 @@ protected function parseXrefTokenResolverDefinitions($xrefKey, $tokenResolversIn
      * @param string|null $includeType
      * @param string|array|null $includeTypeValue
      * @param array $xrefPath
+     * @param LoggerInterface|null $logger
      * @return array
      *
      * @throws CircularReferenceException
@@ -590,14 +630,19 @@ protected function parseXrefTokenResolverDefinitions($xrefKey, $tokenResolversIn
      * @throws \Exception
      */
     protected function recursiveCompileXref(Xref $xref, XrefTokenResolverCollection $tokenResolvers = null,
-                                            $includeType = null, $includeTypeValue = null, &$xrefPath)
+                                            $includeType = null, $includeTypeValue = null, &$xrefPath = null, 
+                                            LoggerInterface $logger=null)
     {
         static $XREF_KEY = 0;
         static $XREF_RESOLVERS_KEY = 1;
-
+        
         if (!isset($includeType)) {
             $includeType = static::INCLUDE_TYPE_GROUP;
         }
+
+        if (isset($logger)) {
+            $logger->addRecord(LoggerInterface::DEBUG, sprintf('Compiling %s', $xref->getLocation()));
+        }
 
         switch ($includeType) {
             case static::INCLUDE_TYPE_GROUP:
@@ -627,7 +672,7 @@ protected function recursiveCompileXref(Xref $xref, XrefTokenResolverCollection
         }
         $mustIncludeSpecificGroup = $includeTypeValue != $this->includeMainKey;
 
-        $xref->resolve();
+        $xref->resolve(false, $logger, $this->headers);
 
         $xrefData = $xref->getData();
         if (empty($xrefData)) {
@@ -663,7 +708,7 @@ protected function recursiveCompileXref(Xref $xref, XrefTokenResolverCollection
                             $result = $xrefData;
                         }
                         if (isset($tokenResolvers)) {
-                            $tokenResolvers->applyToArray($result);
+                            $tokenResolvers->applyToArray($result, $logger);
                         }
                         return $result;
                     }
@@ -704,7 +749,7 @@ protected function recursiveCompileXref(Xref $xref, XrefTokenResolverCollection
                             $result = $xrefData;
                         }
                         if (isset($tokenResolvers)) {
-                            $tokenResolvers->applyToArray($result);
+                            $tokenResolvers->applyToArray($result, $logger);
                         }
                         return $result;
                     }
@@ -753,15 +798,18 @@ protected function recursiveCompileXref(Xref $xref, XrefTokenResolverCollection
                 $xrefKey,
                 $xrefInfo,
                 $tokenResolvers,
-                $xrefPath
+                $xrefPath,
+                $xref,
+                $logger
             );
 
             if (is_array($xrefInfo) && isset($xrefInfo[$this->includeXrefResolversKey])) {
                 $xrefTokenResolvers = $this->parseXrefTokenResolverDefinitions(
                     $xrefKey,
                     $xrefInfo[$this->includeXrefResolversKey],
                     $tokenResolvers,
-                    $xrefPath
+                    $xrefPath,
+                    $xref
                 );
             } else {
                 $xrefTokenResolvers = null;
@@ -803,46 +851,67 @@ protected function recursiveCompileXref(Xref $xref, XrefTokenResolverCollection
                 $downTokenResolvers,
                 static::INCLUDE_TYPE_GROUP,
                 $this->includeMainKey,
-                $xrefPath
+                $xrefPath,
+                $logger
             );
             $this->recursiveAddData($includeData, $result);
         }
         unset($xrefPath[$xrefId]);
 
         if (isset($xrefData[$this->removeKey])) {
             if (isset($tokenResolvers)) {
-                $tokenResolvers->applyToArray($xrefData[$this->removeKey]);
+                if (isset($logger)) {
+                    $logger->addRecord(
+                        LoggerInterface::DEBUG,
+                        sprintf(
+                            'Applying token resolvers to "%s" key in "%s"',
+                            $this->removeKey,
+                            $xref->getLocation()
+                        )    
+                    );
+                }
+                $tokenResolvers->applyToArray($xrefData[$this->removeKey], $logger);
             }
             $this->recursiveRemoveData($xrefData[$this->removeKey], $result);
         }
 
         if (isset($xrefData[$this->addKey])) {
             if (isset($tokenResolvers)) {
-                $tokenResolvers->applyToArray($xrefData[$this->addKey]);
+                if (isset($logger)) {
+                    $logger->addRecord(
+                        LoggerInterface::DEBUG,
+                        sprintf(
+                            'Applying token resolvers to "%s" key in "%s"',
+                            $this->addKey,
+                            $xref->getLocation()
+                        )
+                    );
+                }
+                $tokenResolvers->applyToArray($xrefData[$this->addKey], $logger);
             }
             $this->recursiveAddData($xrefData[$this->addKey], $result);
         }
 
         return $result;
     }
 
-    public function compileXref(Xref $xref, $includeType = null, $includeTypeValue = null)
+    public function compileXref(Xref $xref, $includeType = null, $includeTypeValue = null, LoggerInterface $logger=null)
     {
         $xrefPath = array();
-        $compiledData = $this->recursiveCompileXref($xref, null, $includeType, $includeTypeValue, $xrefPath);
+        $compiledData = $this->recursiveCompileXref($xref, null, $includeType, $includeTypeValue, $xrefPath, $logger);
         return $compiledData;
     }
 
-    public function compileLocalFile($inputFileName, $includeType = null, $includeKeyValue = null)
+    public function compileLocalFile($inputFileName, $includeType = null, $includeKeyValue = null, LoggerInterface $logger=null)
     {
         $xref = new Xref(LocalFileXrefResolver::getType(), $inputFileName);
-        return $this->compileXref($xref, $includeType, $includeKeyValue);
+        return $this->compileXref($xref, $includeType, $includeKeyValue, $logger);
     }
 
-    public function compileUrl($inputUrl, $includeType = null, $includeKeyValue = null)
+    public function compileUrl($inputUrl, $includeType = null, $includeKeyValue = null, LoggerInterface $logger=null)
     {
         $xref = new Xref(UrlXrefResolver::getType(), $inputUrl);
-        return $this->compileXref($xref, $includeType, $includeKeyValue);
+        return $this->compileXref($xref, $includeType, $includeKeyValue, $logger);
     }
 
     public function save(array $tree, $fileName)

lib/ConfigToken/TreeCompiler/Xref.php

@@ -2,6 +2,7 @@
 
 namespace ConfigToken\TreeCompiler;
 
+use ConfigToken\LoggerInterface;
 use ConfigToken\TreeCompiler\XrefResolver\XrefResolverFactory;
 
 
@@ -92,7 +93,7 @@ public function getResolver()
         return XrefResolverFactory::getByType($this->type);
     }
 
-    public function resolve($force = false)
+    public function resolve($force = false, LoggerInterface $logger=null, $headers=array())
     {
         if ($this->isResolved() && (!$force)) {
             return;
@@ -101,7 +102,7 @@ public function resolve($force = false)
             throw new \Exception('Unable to resolve Xref without type.');
         }
         $resolver = $this->getResolver();
-        $resolver::resolve($this, $force);
+        $resolver::resolve($this, $force, $logger, $headers);
     }
 
     public function hasType()