Normalize Context Values

composer.json

@@ -17,7 +17,8 @@
     "phpunit/phpunit": "^6.0 | ^7.0 | ^8.0",
     "psr/container": "^1.0",
     "vimeo/psalm": "^3.11.7 | ^4.0",
-    "slevomat/coding-standard": "^6.0"
+    "slevomat/coding-standard": "^6.0",
+    "symfony/polyfill-php80": "^1.19"
   },
   "autoload": {
     "psr-4": {

src/Template.php

@@ -6,8 +6,10 @@
 
 use ArrayAccess;
 use Dhii\Output\Template\TemplateInterface;
+use Exception;
 use InvalidArgumentException;
 use Psr\Container\ContainerInterface;
+use RangeException;
 use Stringable;
 
 /**
@@ -98,6 +100,8 @@ public function render($context = null)
      * @return string A string with tokens replaced by values.
      *                If value not found in context, token will remain unchanged.
      * @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+     *
+     * @throws Exception If problem replacing.
      */
     protected function replaceTokens(string $template, $context): string
     {
@@ -115,6 +119,7 @@ protected function replaceTokens(string $template, $context): string
             if ($value === null) {
                 continue;
             }
+            $value = $this->normalizeValue($value);
 
             $result = str_replace($token, $value, $result);
         }
@@ -197,13 +202,15 @@ protected function getContextValue($context, string $key, $default)
         }
 
         /** @psalm-suppress RedundantConditionGivenDocblockType Not guaranteed by typehint */
-        if ($context instanceof ContainerInterface) {
-            return $context->has($key)
-                ? $context->get($key)
-                : $default;
+        if (!($context instanceof ContainerInterface)) {
+            throw new InvalidArgumentException('Invalid context');
         }
 
-        throw new InvalidArgumentException('Invalid context');
+        $value = $context->has($key)
+            ? $context->get($key)
+            : $default;
+
+        return $value;
     }
 
     /**
@@ -252,4 +259,29 @@ protected function cleanTokens(array $tokens): array
 
         return $newTokens;
     }
+
+    /**
+     * Normalize a value to string.
+     *
+     * @param scalar|Stringable|mixed $value The value to normalize.
+     * @return string The normalized value.
+     *
+     * @throws RangeException If cannot normalize.
+     */
+    protected function normalizeValue($value): string
+    {
+        if (is_bool($value)) {
+            $value = (int) $value;
+        }
+
+        if (is_scalar($value) || (is_object($value) && method_exists($value, '__toString'))) {
+            $value = (string) $value;
+        }
+
+        if (!is_string($value)) {
+            throw new RangeException(sprintf('Could not normalize value: %1$s', print_r($value, true)));
+        }
+
+        return $value;
+    }
 }

tests/functional/TemplateTest.php

@@ -5,6 +5,9 @@
 use Dhii\Output\DelimitedTokenTemplate\Template as TestSubject;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
+use RangeException;
+use stdClass;
+use Stringable;
 
 class TemplateTest extends TestCase
 {
@@ -110,4 +113,89 @@ public function testRenderDelimiterInMiddle()
             $this->assertEquals("Good night, $value!", $result);
         }
     }
+
+    /**
+     * Tests that values of allowed types may be used, and disallowed throw.
+     *
+     * @dataProvider provideContext
+     * @param mixed $context The context to render with.
+     * @param mixed $expect What to expect.
+     * @param string|null $shouldExpectException The exception type to expect, if any.
+     */
+    public function testValueTypes($context, $expect, ?string $shouldExpectException)
+    {
+        {
+            $e = '\\';
+            $d = '%';
+            $key = 'key';
+            $template = "{$d}{$key}{$d}";
+            $subject = $this->createInstance($template, $d, $d, $e);
+        }
+
+        {
+            if ($shouldExpectException) {
+                $this->expectException($shouldExpectException);
+            }
+
+            $result = $subject->render($context);
+            $this->assertEquals($expect, $result);
+        }
+    }
+
+    /**
+     * @return array[]
+     */
+    public function provideContext(): array
+    {
+        return [
+            [ // Set
+                ['key' => $value = uniqid('value1')], // Context
+                $value, // Expect
+                null, // Should throw
+            ],
+
+            [ // Set
+                ['key' => $value = rand(1, 99)], // Context
+                $value, // Expect
+                null, // Should throw
+            ],
+
+            [ // Set
+                ['key' => $value = rand(0, 100) < 50], // Context
+                (string) (int) $value, // Expect
+                null, // Should throw
+            ],
+
+            [ // Set
+                ['key' => $value = $this->createStringable(uniqid('value2'))], // Context
+                $value, // Expect
+                null, // Should throw
+            ],
+
+            [ // Set
+                ['key' => new stdClass()], // Context
+                null, // Expect
+                RangeException::class, // Should throw
+            ],
+        ];
+    }
+
+    /**
+     * Creates a new stringable that represents the specified content.
+     *
+     * @param string $content The content of the stringable.
+     *
+     * @return Stringable|MockObject The new stringable.
+     */
+    protected function createStringable(string $content): Stringable
+    {
+        $mock = $this->getMockBuilder(Stringable::class)
+            ->setMethods(['__toString'])
+            ->getMockForAbstractClass();
+
+        $mock->method('__toString')
+            ->will($this->returnValue($content));
+
+        return $mock;
+    }
 }