Add support for collaborator properties

Author: akondas

README.md

@@ -16,6 +16,7 @@
   * support for array return type (check if array item has correct type)
 * Allow to user `Propehcy` as `Collaborator` arguments
   * `Argument::cetera()`, `Argument::any()`
+* Provides correct attributes for `Collaborator`
 * Provides correct methods for `ObjectBehavior`:
   * `should*` methods
   * `during*` methods

composer.json

@@ -22,7 +22,9 @@
     },
     "autoload-dev": {
         "psr-4": {
-            "spec\\PhpSpec\\": "spec/PhpSpec/"
+            "spec\\PhpSpec\\": "spec/PhpSpec/",
+            "spec\\Proget\\": "spec/Proget/",
+            "Proget\\Tests\\": "tests/"
         }
     },
     "license": "MIT",
@@ -35,7 +37,7 @@
     "scripts": {
         "check-cs": "php-cs-fixer fix --dry-run --diff",
         "fix-cs": "php-cs-fixer fix",
-        "tests": "phpspec run",
+        "tests": "phpspec run --format=dot",
         "stan": "phpstan analyse -l max -c ./phpstan.neon ./src ./spec",
         "check": [
             "@check-cs",

extension.neon

@@ -14,6 +14,9 @@ services:
     -
         class: Proget\PHPStan\PhpSpec\Reflection\ObjectBehaviorPropertiesClassReflectionExtension
         tags: [phpstan.broker.propertiesClassReflectionExtension]
+    -
+        class: Proget\PHPStan\PhpSpec\Reflection\SpoofedCollaboratorPropertiesClassReflectionExtension
+        tags: [phpstan.broker.propertiesClassReflectionExtension]
     -
         class: Proget\PHPStan\PhpSpec\Type\ObjectBehaviorDynamicMethodReturnTypeExtension
         tags: [phpstan.broker.dynamicMethodReturnTypeExtension]

spec/Proget/Tests/BarSpec.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace spec\Proget\Tests;
+
+use Proget\Tests\Bar;
+use PhpSpec\ObjectBehavior;
+use Proget\Tests\Foo;
+
+class BarSpec extends ObjectBehavior
+{
+    public function let(Foo $foo): void
+    {
+        $this->beConstructedWith($foo);
+    }
+
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType(Bar::class);
+    }
+
+    public function it_should_return_foo_property(Foo $foo): void
+    {
+        $foo->property = 'Some text';
+
+        $this->getFooProperty()->shouldBe('Some text');
+    }
+}

spec/Proget/Tests/FooSpec.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace spec\Proget\Tests;
+
+use Proget\Tests\Bar;
+use Proget\Tests\Baz;
+use Proget\Tests\Foo;
+use PhpSpec\ObjectBehavior;
+
+class FooSpec extends ObjectBehavior
+{
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType(Foo::class);
+    }
+
+    public function it_should_return_int_from_baz(Bar $bar, Baz $baz): void
+    {
+        $bar->baz = $baz;
+        $baz->someInt()->willReturn(99);
+
+        $this->getIntFromBaz($bar)->shouldBe(99);
+    }
+}

src/Reflection/CollaboratorPropertyReflection.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Proget\PHPStan\PhpSpec\Reflection;
+
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\PropertyReflection;
+use PHPStan\Type\Type;
+use Proget\PHPStan\PhpSpec\Type\CollaboratorPropertyType;
+
+final class CollaboratorPropertyReflection implements PropertyReflection
+{
+    /**
+     * @var PropertyReflection
+     */
+    private $wrappedReflection;
+
+    public function __construct(PropertyReflection $wrappedReflection)
+    {
+        $this->wrappedReflection = $wrappedReflection;
+    }
+
+    public function getDeclaringClass(): ClassReflection
+    {
+        return $this->wrappedReflection->getDeclaringClass();
+    }
+
+    public function isStatic(): bool
+    {
+        return $this->wrappedReflection->isStatic();
+    }
+
+    public function isPrivate(): bool
+    {
+        return $this->wrappedReflection->isPrivate();
+    }
+
+    public function isPublic(): bool
+    {
+        return $this->wrappedReflection->isPublic();
+    }
+
+    public function getType(): Type
+    {
+        return new CollaboratorPropertyType($this->wrappedReflection->getType());
+    }
+
+    public function isReadable(): bool
+    {
+        return $this->wrappedReflection->isReadable();
+    }
+
+    public function isWritable(): bool
+    {
+        return $this->wrappedReflection->isWritable();
+    }
+}

src/Reflection/SpoofedCollaboratorPropertiesClassReflectionExtension.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Proget\PHPStan\PhpSpec\Reflection;
+
+use PhpSpec\Wrapper\Collaborator;
+use PHPStan\Analyser\OutOfClassScope;
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\BrokerAwareExtension;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\PropertiesClassReflectionExtension;
+use PHPStan\Reflection\PropertyReflection;
+use Proget\PHPStan\PhpSpec\Registry\SpoofedCollaboratorRegistry;
+use Proget\PHPStan\PhpSpec\Wrapper\SpoofedCollaborator;
+
+final class SpoofedCollaboratorPropertiesClassReflectionExtension implements PropertiesClassReflectionExtension, BrokerAwareExtension
+{
+    /**
+     * @var Broker
+     */
+    private $broker;
+
+    public function setBroker(Broker $broker): void
+    {
+        $this->broker = $broker;
+    }
+
+    public function hasProperty(ClassReflection $classReflection, string $propertyName): bool
+    {
+        return in_array(SpoofedCollaborator::class, array_map(function (ClassReflection $interface):string {
+            return $interface->getName();
+        }, $classReflection->getInterfaces()), true);
+    }
+
+    public function getProperty(ClassReflection $classReflection, string $propertyName): PropertyReflection
+    {
+        $collaboratorClassName = (string) preg_replace('/Collaborator$/', '', SpoofedCollaboratorRegistry::getAlias($classReflection->getName()));
+
+        return new CollaboratorPropertyReflection($this->broker->getClass($collaboratorClassName)->getProperty($propertyName, new OutOfClassScope()));
+    }
+
+    public function hasMethod(ClassReflection $classReflection, string $methodName): bool
+    {
+        return in_array(SpoofedCollaborator::class, array_map(function (ClassReflection $interface):string {
+            return $interface->getName();
+        }, $classReflection->getInterfaces()), true);
+    }
+
+    public function getMethod(ClassReflection $classReflection, string $methodName): MethodReflection
+    {
+        $collaboratorReflection = $this->broker->getClass(Collaborator::class);
+        if ($collaboratorReflection->hasMethod($methodName)) {
+            return $collaboratorReflection->getMethod($methodName, new OutOfClassScope());
+        }
+
+        $collaboratorClassName = (string) preg_replace('/Collaborator$/', '', SpoofedCollaboratorRegistry::getAlias($classReflection->getName()));
+
+        return new CollaboratorMethodReflection($this->broker->getClass($collaboratorClassName)->getMethod($methodName, new OutOfClassScope()));
+    }
+}