Initial setup

Author: Yaroslav Zborovsky

.github/workflows/build.yml

@@ -0,0 +1,34 @@
+name: Build
+on: [push]
+
+jobs:
+  build:
+    name: Run checks
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: '7.4'
+
+      - name: Get composer cache directory
+        id: composer-cache
+        run: echo "::set-output name=dir::$(composer config cache-files-dir)"
+
+      - name: Cache dependencies
+        uses: actions/cache@v1
+        with:
+          path: ${{ steps.composer-cache.outputs.dir }}
+          key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}
+          restore-keys: ${{ runner.os }}-composer-
+
+      - name: Install dependencies
+        run: |
+          composer install --prefer-dist
+
+      - name: Run tests
+        run: composer test
+

.gitignore

@@ -0,0 +1,3 @@
+/.idea
+/vendor/
+/composer.lock

README.md

@@ -1,2 +1,64 @@
-# php-external-interface-matcher
-Simple reflection-based library to check if a class matches external interface
+# PHP implicit interface checker
+Simple reflection-based ~~library~~ function to check if a class matches an external interface (i.e. an interface
+that is not implemented by this class, but probably having the same method signatures).
+
+## Wait, but why?
+This library was inspired by Go language and its concept of interfaces. In Go interfaces are
+implemented implicitly, i.e. an object implements an interface when it provides the same method signatures 
+as described in the interface. Whereas in PHP interfaces MUST 
+be implemented explicitly and this fact somehow prevents proper code decoupling.
+
+Let's say we have the following class:
+
+```php
+class DeepThought
+{
+    public function answer(string $life, int $universe, array $everything): int
+    {
+        return 42;
+    }
+}
+```
+
+It does not implement any interface. Let us coin an interface for it:
+
+```php
+interface DeepThoughtInterface
+{
+    public function answer(string $life, int $universe, array $everything): int;
+}
+```
+    
+Actually, the signature of method `answer()` in the class completely matches the one in the interface.
+But we can't actually confirm that with any standard PHP tools.
+
+```php
+$instance = new DeepThought();
+if ($instance instanceof DeepThoughtInterface::class) {
+    echo 'Success';
+} else {
+    echo 'Failure';
+}
+```
+
+We will always receive `Failure` message. And this is sad. 
+But now we can use this library for checking:
+
+```php
+use function yaronius\ExternalInterfaceMatcher\class_provides;
+
+$instance = new DeepThought();
+if (class_provides($instance, DeepThoughtInterface::class)) {
+    echo 'Success';
+} else {
+    echo 'Failure';
+}
+```
+
+Now we get `Success`! Finally!
+    
+## TODO
+
+- more OOP 
+- more tests
+- benchmark performance impact

composer.json

@@ -0,0 +1,25 @@
+{
+    "name": "yaronius/php-implicit-interface-checker",
+    "require-dev": {
+        "phpunit/phpunit": "^9.1"
+    },
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Yaroslav Zborovsky",
+            "email": "[email protected]"
+        }
+    ],
+    "autoload": {
+        "files": [
+            "src/functions.php"
+        ],
+        "psr-4": {
+            "yaronius\\ImplicitInterface\\": "src/"
+        }
+    },
+    "scripts": {
+        "test": "vendor/bin/phpunit"
+    },
+    "require": {}
+}

phpunit.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<phpunit bootstrap="./tests/bootstrap.php"
+         backupGlobals="true"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         stopOnFailure="false"
+>
+    <testsuites>
+        <testsuite name="Test Suite">
+            <directory>./tests</directory>
+        </testsuite>
+    </testsuites>
+</phpunit>

src/functions.php

@@ -0,0 +1,145 @@
+<?php
+
+namespace yaronius\ImplicitInterface;
+
+use InvalidArgumentException;
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionParameter;
+use ReflectionException;
+use ReflectionNamedType;
+
+/**
+ * @param object|string $class
+ * @param string $interface
+ * @return bool
+ * @throws ReflectionException
+ */
+function class_provides($class, string $interface): bool {
+    // an object may be provided, so we handle this case here
+    if (is_object($class)) {
+        if ($class instanceof $interface) {
+            return true;
+        }
+        $class = get_class($class);
+    }
+
+    try {
+        $classReflect = new ReflectionClass($class);
+    } catch (ReflectionException $e) {
+        //todo throw dedicated exception
+        return false;
+    }
+
+    // check if the class explicitly implements the interface
+    if ($classReflect->implementsInterface($interface)) {
+        return true;
+    }
+
+    try {
+        $interfaceReflect = new ReflectionClass($interface);
+    } catch (ReflectionException $e) {
+        //todo throw dedicated exception
+        return false;
+    }
+
+    if (!$interfaceReflect->isInterface()) {
+        throw new InvalidArgumentException('Second argument must be an interface');
+    }
+
+    foreach ($interfaceReflect->getMethods() as $interfaceMethod) {
+        // check if class has same method name
+        if (!$classReflect->hasMethod($interfaceMethod->getName())) {
+            return false;
+        }
+        $classMethod = $classReflect->getMethod($interfaceMethod->getName());
+        if (!reflection_methods_same($classMethod, $interfaceMethod)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * @param ReflectionMethod $method1
+ * @param ReflectionMethod $method2
+ * @return bool
+ */
+function reflection_methods_same(ReflectionMethod $method1, ReflectionMethod $method2): bool
+{
+    $firstMethodModifiers = $method1->getModifiers();
+    $secondMethodModifiers = $method1->getModifiers();
+    if ($firstMethodModifiers != $secondMethodModifiers) {
+        // interface methods are always abstract, so if it is the only difference, we ignore it
+        if ($firstMethodModifiers ^ $secondMethodModifiers != ReflectionMethod::IS_ABSTRACT) {
+            return false;
+        }
+    }
+    if ($method1->getNumberOfParameters() != $method2->getNumberOfParameters()) {
+        return false;
+    }
+    if ($method1->getNumberOfRequiredParameters() != $method2->getNumberOfRequiredParameters()) {
+        return false;
+    }
+    $firstParams = $method1->getParameters();
+    $secondParams = $method2->getParameters();
+    /**
+     * @var ReflectionParameter $interfaceParam
+     * @var ReflectionParameter $classParam
+     */
+    foreach ($secondParams as $i => $interfaceParam) {
+        $classParam = $firstParams[$i];
+        if (!reflection_params_same($interfaceParam, $classParam)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @param ReflectionParameter $param1
+ * @param ReflectionParameter $param2
+ * @return bool
+ */
+function reflection_params_same(ReflectionParameter $param1, ReflectionParameter $param2): bool
+{
+    if ($param1->isPassedByReference() != $param2->isPassedByReference()) {
+        return false;
+    }
+    if ($param1->isArray() != $param2->isArray()) {
+        return false;
+    }
+    if ($param1->isCallable() != $param2->isCallable()) {
+        return false;
+    }
+    if ($param1->isOptional() != $param2->isOptional()) {
+        return false;
+    }
+    if ($param1->isVariadic() != $param2->isVariadic()) {
+        return false;
+    }
+    $firstParamType = $param1->getType();
+    $secondParamType = $param2->getType();
+
+    if (is_null($firstParamType) || is_null($secondParamType)) {
+        return $firstParamType === $secondParamType;
+    }
+
+    if (get_class($firstParamType) != get_class($secondParamType)) {
+        return false;
+    }
+    if ($firstParamType instanceof ReflectionNamedType && $secondParamType instanceof ReflectionNamedType) {
+        if ($firstParamType->getName() != $secondParamType->getName()) {
+            return false;
+        }
+    }
+    if ($firstParamType->isBuiltin() != $secondParamType->isBuiltin()) {
+        return false;
+    }
+    if ($firstParamType->allowsNull() != $secondParamType->allowsNull()) {
+        return false;
+    }
+
+    return true;
+}

tests/FunctionsTest.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace yaronius\ImplicitInterface\tests;
+
+use PHPUnit\Framework\TestCase;
+
+use function yaronius\ImplicitInterface\class_provides;
+
+class FunctionsTest extends TestCase
+{
+    public function testClassProvidesFunction()
+    {
+        $this->assertTrue(class_provides(AbstractFoo::class, FooInterface::class));
+        $this->assertTrue(class_provides(Foo::class, FooInterface::class));
+
+        $this->assertTrue(class_provides(new Foo, FooInterface::class));
+
+        $this->assertTrue(class_provides(new Bar, BarInterface::class));
+        $this->assertFalse(class_provides(new Bar, BazInterface::class));
+    }
+}
+
+abstract class AbstractFoo
+{
+    abstract public function doDomething(string $param, int $param2): int;
+}
+
+class Foo extends AbstractFoo
+{
+    public function doDomething(string $param, int $param2): int
+    {
+        return 42;
+    }
+}
+
+interface FooInterface
+{
+    function doDomething(string $param, int $param2): int;
+}
+
+class Bar
+{
+    function doDomethingElse(array $param, callable $param2, $untypedParam = null)
+    {
+        return 'bar';
+    }
+}
+
+interface BarInterface
+{
+    function doDomethingElse(array $param, callable $param2, $untypedParam = null);
+}
+
+interface BazInterface
+{
+    function doDomethingElse(array $param, callable $param2, $untypedParam);
+}

tests/bootstrap.php

@@ -0,0 +1,3 @@
+<?php
+
+require_once __DIR__ . '/../vendor/autoload.php';