Merge pull request #32 from otsch/feature/invade-static

Invade static properties and methods

README.md

@@ -61,6 +61,40 @@ Using `invade` you can also call private functions.
 invade($myClass)->privateMethod(); // returns 'private return value'
 ```
 
+Further, you can also get and set private static class properties and call private static methods. Imagine having this class:
+
+```php
+class MyClass
+{
+    private static string $privateStaticProperty = 'privateValue';
+
+    private static function privateStaticMethod(string $string, int $int): string
+    {
+        return 'private return value ' . $string . ' ' . $int;
+    }
+}
+```
+
+Here is how you get and set private class properties:
+
+```php
+invade(MyClass::class)->get('privateStaticProperty'); // returns 'private value'
+
+invade(MyClass::class)->set('privateStaticProperty', 'changedValue');
+
+invade(MyClass::class)->get('privateStaticProperty'); // returns 'changedValue'
+```
+
+And this is how you call private static methods:
+
+```php
+invade(MyClass::class)
+    ->method('privateStaticMethod')
+    ->call('foo', 123);
+
+// returns 'private return value foo 123'
+```
+
 ## Testing
 
 ```bash

src/StaticInvader.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Spatie\Invade;
+
+use Exception;
+
+class StaticInvader
+{
+    private ?string $method = null;
+
+    /**
+     * @param class-string $className
+     */
+    public function __construct(
+        public string $className,
+    ) {
+    }
+
+    public function get(string $name): mixed
+    {
+        return (fn () => static::${$name})->bindTo(null, $this->className)();
+    }
+
+    public function set(string $name, mixed $value): void
+    {
+        (fn ($value) => static::${$name} = $value)->bindTo(null, $this->className)($value);
+    }
+
+    public function method(string $name): self
+    {
+        $this->method = $name;
+
+        return $this;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function call(...$params): mixed
+    {
+        if ($this->method === null) {
+            throw new Exception(
+                'No method to be called. Use it like: invadeStatic(Foo::class)->method(\'bar\')->call()'
+            );
+        }
+
+        return (fn ($method) => static::{$method}(...$params))->bindTo(null, $this->className)($this->method);
+    }
+}

src/functions.php

@@ -1,16 +1,21 @@
 <?php
 
 use Spatie\Invade\Invader;
+use Spatie\Invade\StaticInvader;
 
 if (! function_exists('invade')) {
     /**
      * @template T of object
      *
-     * @param T $object
-     * @return Invader<T>
+     * @param T|class-string $object
+     * @return Invader<T>|StaticInvader
      */
-    function invade(object $object): Invader
+    function invade(object|string $object): Invader|StaticInvader
     {
-        return new Invader($object);
+        if (is_object($object)) {
+            return new Invader($object);
+        }
+
+        return new StaticInvader($object);
     }
 }

tests/Example.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Spatie\Invade\Tests;
+
+class Example
+{
+    private static string $privateStaticProperty = 'privateValue';
+
+    private static function privateStaticMethod(string $string, int $int): string
+    {
+        return 'private return value ' . $string . ' ' . $int;
+    }
+}

tests/StaticInvaderTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Spatie\Invade\Tests;
+
+beforeEach(function () {
+    if (invade(Example::class)->get('privateStaticProperty') === 'changedValue') {
+        invade(Example::class)->set('privateStaticProperty', 'privateValue');
+    }
+});
+
+it('reads a static private property', function () {
+    $privateValue = invade(Example::class)->get('privateStaticProperty');
+
+    expect($privateValue)->toBe('privateValue');
+});
+
+it('sets a private static property', function () {
+    invade(Example::class)->set('privateStaticProperty', 'changedValue');
+
+    $privateValue = invade(Example::class)->get('privateStaticProperty');
+
+    expect($privateValue)->toBe('changedValue');
+});
+
+it('calls a private static method', function () {
+    $returnValue = invade(Example::class)
+        ->method('privateStaticMethod')
+        ->call('test', 123);
+
+    expect($returnValue)->toBe('private return value test 123');
+});