Add basic support for object method calls

Author: Nicolas Oelgart

src/TokenStream/AST.php

@@ -14,6 +14,7 @@
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenFactory;
 use nicoSWD\Rule\Tokenizer\TokenizerInterface;
+use nicoSWD\Rule\TokenStream\Token\TokenObject;
 
 class AST
 {
@@ -47,6 +48,10 @@ public function getStream(string $rule): TokenStream
 
     public function getMethod(string $methodName, BaseToken $token): CallableUserFunctionInterface
     {
+        if ($token instanceof TokenObject) {
+            return $this->getUserObjectCallable($token, $methodName);
+        }
+
         if (empty($this->methods)) {
             $this->registerMethods();
         }
@@ -120,4 +125,35 @@ private function registerFunctions()
             $this->registerFunctionClass($functionName, $className);
         }
     }
+
+    private function getUserObjectCallable(BaseToken $token, string $methodName): CallableUserFunctionInterface
+    {
+        return new class ($token, $this->tokenFactory, $methodName) implements CallableUserFunctionInterface
+        {
+            /** @var BaseToken */
+            private $token;
+            /** @var TokenFactory */
+            private $tokenFactory;
+            /** @var string */
+            private $methodName;
+
+            public function __construct(BaseToken $token, TokenFactory $tokenFactory, string $methodName)
+            {
+                $this->token = $token;
+                $this->tokenFactory = $tokenFactory;
+                $this->methodName = $methodName;
+            }
+
+            public function call(BaseToken $param = null): BaseToken
+            {
+                $object = [$this->token->getValue(), $this->methodName];
+
+                if (!is_callable($object)) {
+                    throw new \Exception();
+                }
+
+                return $this->tokenFactory->createFromPHPType($object());
+            }
+        };
+    }
 }

src/TokenStream/Node/BaseNode.php

@@ -8,10 +8,10 @@
 namespace nicoSWD\Rule\TokenStream\Node;
 
 use Closure;
+use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\TokenCollection;
 use nicoSWD\Rule\Parser\Exception\ParserException;
-use nicoSWD\Rule\Grammar\CallableFunction;
 use nicoSWD\Rule\TokenStream\TokenStream;
 use nicoSWD\Rule\TokenStream\Token\TokenType;
 
@@ -59,7 +59,7 @@ protected function hasMethodCall(): bool
         return $hasMethod;
     }
 
-    protected function getMethod(BaseToken $token): CallableFunction
+    protected function getMethod(BaseToken $token): CallableUserFunctionInterface
     {
         $this->tokenStream->getStack()->seek($this->methodOffset);
 

src/TokenStream/Token/TokenFactory.php

@@ -58,13 +58,9 @@ public function createFromPHPType($value): BaseToken
             case 'double':
                 return new TokenFloat($value);
             case 'array':
-                $params = new TokenCollection();
-
-                foreach ($value as $item) {
-                    $params->attach($this->createFromPHPType($item));
-                }
-
-                return new TokenArray($params);
+                return $this->buildTokenCollection($value);
+            case 'object':
+                return new TokenObject($value);
             default:
                 throw new ParserException(sprintf(
                     'Unsupported PHP type: "%s"',
@@ -81,4 +77,15 @@ public function createFromTokenName(string $tokenName): string
 
         return $this->tokenMap[$tokenName];
     }
+
+    private function buildTokenCollection($value): TokenArray
+    {
+        $params = new TokenCollection();
+
+        foreach ($value as $item) {
+            $params->attach($this->createFromPHPType($item));
+        }
+
+        return new TokenArray($params);
+    }
 }

src/TokenStream/Token/TokenObject.php

@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <[email protected]>
+ */
+namespace nicoSWD\Rule\TokenStream\Token;
+
+final class TokenObject extends BaseToken
+{
+    public function getType() : int
+    {
+        return TokenType::OBJECT;
+    }
+}

src/TokenStream/Token/TokenType.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 
 /**
  * @license     http://opensource.org/licenses/mit-license.php MIT

src/TokenStream/TokenStream.php

@@ -9,6 +9,7 @@
 
 use ArrayIterator;
 use Closure;
+use nicoSWD\Rule\Grammar\CallableFunction;
 use nicoSWD\Rule\Parser\Exception\ParserException;
 use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;

tests/integration/ObjectTest.php

@@ -0,0 +1,28 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <[email protected]>
+ */
+use nicoSWD\Rule\tests\integration\AbstractTestBase;
+
+final class ObjectTest extends AbstractTestBase
+{
+    public function testObjects()
+    {
+        $myObj = new class {
+            function test() {
+                return 'test one two';
+            }
+        };
+
+        $variables = [
+            'my_obj' => $myObj,
+            'my_string' => 'some test'
+        ];
+
+        $this->assertTrue($this->evaluate('my_obj.test() === "test one two"', $variables));
+        $this->assertFalse($this->evaluate('my_obj.test() === "oh no"', $variables));
+    }
+}

tests/unit/Token/TokenFactoryTest.php

@@ -38,9 +38,9 @@ public function testSimpleTypeReturnsCorrectInstance()
     public function testUnsupportedTypeThrowsException()
     {
         $this->expectException(ParserException::class);
-        $this->expectExceptionMessage('Unsupported PHP type: "object"');
+        $this->expectExceptionMessage('Unsupported PHP type: "resource"');
 
-        $this->tokenFactory->createFromPHPType(new \stdClass());
+        $this->tokenFactory->createFromPHPType(tmpfile());
     }
 
     public function testGivenAnInvalidTokenNameItShouldThrowAnException()