Fix ArrayAccess access, add access to public object properties

Author: wol-soft

README.md

@@ -134,6 +134,20 @@ $render->renderTemplateString(
 );
 ```
 
+Also, public properties of objects may be accessed from the template:
+
+```php
+$person = new stdClass();
+$person->name = 'Hans';
+
+$render->renderTemplateString(
+    '{{ person.name }}',
+    [
+        'person' => $person,
+    ]
+);
+```
+
 By default, a used variable which is not provided will result in an `UndefinedSymbolException`. You can register a callback function via `onResolveError` to handle unresolved variable errors. The callback function must implement the signature `function (string $unresolvedVariable): string`. The provided `$unresolvedVariable` will contain the whole expression which failed to resolve (eg. `myUnresolvedVariable`, `myUnresolvedObject.render(var1, var2)`).
 
 ```php

src/Render.php

@@ -4,6 +4,7 @@
 
 namespace PHPMicroTemplate;
 
+use ArrayAccess;
 use PHPMicroTemplate\Exception\FileSystemException;
 use PHPMicroTemplate\Exception\SyntaxErrorException;
 use PHPMicroTemplate\Exception\UndefinedSymbolException;
@@ -238,20 +239,7 @@ protected function getValue(array $matches, array $variables)
             array_push($variablePath, ...explode('.', trim($matches['nestedVariable'], '.')));
         }
 
-        foreach ($variablePath as $variable) {
-            // first check via isset for faster lookup
-            if (!isset($resolved[$variable]) && !array_key_exists($variable, $resolved)) {
-                if ($this->resolveErrorCallback) {
-                    return ($this->resolveErrorCallback)($matches['expression']);
-                }
-
-                throw new UndefinedSymbolException(sprintf('Unknown variable %s', implode('.', $variablePath)));
-            }
-
-            $resolved = $resolved[$variable];
-        }
-
-        if (empty($matches['method'])) {
+        if (!$this->resolveNestedVariable($resolved, $variablePath, $matches) || empty($matches['method'])) {
             return $resolved;
         }
 
@@ -275,6 +263,44 @@ protected function getValue(array $matches, array $variables)
         return call_user_func_array([$resolved, $matches['method']], $parameter ?? []);
     }
 
+    /**
+     * Resolve nested variable access and object property access
+     *
+     * @param mixed $resolved
+     * @param array $variablePath
+     * @param array $matches
+     *
+     * @return bool
+     *
+     * @throws UndefinedSymbolException
+     */
+    protected function resolveNestedVariable(&$resolved, array $variablePath, array $matches): bool
+    {
+        foreach ($variablePath as $variable) {
+            if (is_object($resolved) && !($resolved instanceof ArrayAccess)) {
+                if (isset($resolved->$variable)) {
+                    $resolved = $resolved->$variable;
+
+                    continue;
+                }
+            } elseif (isset($resolved[$variable]) || (is_array($resolved) && array_key_exists($variable, $resolved))) {
+                $resolved = $resolved[$variable];
+
+                continue;
+            }
+
+            if ($this->resolveErrorCallback) {
+                $resolved = ($this->resolveErrorCallback)($matches['expression']);
+
+                return false;
+            }
+
+            throw new UndefinedSymbolException(sprintf('Unknown variable %s', implode('.', $variablePath)));
+        }
+
+        return true;
+    }
+
     /**
      * Index a control structure in a given template section so a handling of nested control structures of the same
      * type can be offered

tests/RenderTest.php

@@ -4,12 +4,15 @@
 
 namespace PHPMicroTemplate\Tests;
 
+use ArrayAccess;
+use ArrayObject;
 use PHPMicroTemplate\Exception\FileSystemException;
 use PHPMicroTemplate\Exception\SyntaxErrorException;
 use PHPMicroTemplate\Exception\UndefinedSymbolException;
 use PHPMicroTemplate\Render;
 use PHPMicroTemplate\Tests\Objects\Product;
 use PHPUnit\Framework\TestCase;
+use stdClass;
 
 /**
  * Class RenderTest
@@ -139,18 +142,28 @@ public function testWhitespaceTolerance(): void
 
     /**
      * Test multiple loops following each other
+     *
+     * @dataProvider loopDataProvider
      */
-    public function testMultipleLoops(): void
+    public function testMultipleLoops($products): void
+    {
+        $result = $this->render->renderTemplate('multipleLoops.template', ['products' => $products]);
+
+        $this->assertXmlStringEqualsXmlFile(__DIR__ . '/Expectations/multipleLoops', $result);
+    }
+
+    public function loopDataProvider(): array
     {
         $products = [
             new Product('Hammer', true),
             new Product('Nails', true),
             new Product('Wood', true),
         ];
 
-        $result = $this->render->renderTemplate('multipleLoops.template', ['products' => $products]);
-
-        $this->assertXmlStringEqualsXmlFile(__DIR__ . '/Expectations/multipleLoops', $result);
+        return [
+            'array' => [$products],
+            'ArrayObject' => [new ArrayObject($products)],
+        ];
     }
 
     /**
@@ -283,4 +296,89 @@ public function resolveErrorDataProvider()
             'object function call with parameters' => ['person.renderName(firstname, lastname)'],
         ];
     }
+
+    /**
+     * @dataProvider nonExistingPropertyDataProvider
+     */
+    public function testAccessExistingProperty($person): void
+    {
+        $this->assertSame(
+            'Schmidt, Hans',
+            $this->render->renderTemplateString(
+                '{{ person.lastName }}, {{ person.firstName }}',
+                [
+                    'person' => $person,
+                ]
+            )
+        );
+    }
+
+    /**
+     * @dataProvider nonExistingPropertyDataProvider
+     */
+    public function testAccessNonExistingPropertyFails($person): void
+    {
+        $this->expectException(UndefinedSymbolException::class);
+        $this->expectExceptionMessage('Unknown variable person.age');
+
+        $this->render->renderTemplateString(
+            '{{ person.age }}',
+            [
+                'person' => $person,
+            ]
+        );
+    }
+
+    public function nonExistingPropertyDataProvider(): array
+    {
+        return [
+            'array' => [
+                [
+                    'firstName' => 'Hans',
+                    'lastName' => 'Schmidt',
+                ],
+            ],
+            'arrayAccess' => [$this->getArrayAccessObject()],
+            'object' => [$this->getPersonObject()],
+        ];
+    }
+
+    private function getArrayAccessObject(): ArrayAccess
+    {
+        return new class () implements ArrayAccess {
+            private $data = [
+                'firstName' => 'Hans',
+                'lastName' => 'Schmidt',
+            ];
+
+            public function offsetExists($offset)
+            {
+                return array_key_exists($offset, $this->data);
+            }
+
+            public function offsetGet($offset)
+            {
+                return $this->data[$offset];
+            }
+
+            public function offsetSet($offset, $value)
+            {
+                $this->data[$offset] = $value;
+            }
+
+            public function offsetUnset($offset)
+            {
+                unset($this->data[$offset]);
+            }
+        };
+    }
+
+    public function getPersonObject(): stdClass
+    {
+        $person = new stdClass();
+        $person->lastName = 'Schmidt';
+        $person->firstName = 'Hans';
+
+        return $person;
+    }
 }