Small refactored

Author: Andrey Helldar

src/Support/Container.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Helldar\ApiResponse\Support;
+
+abstract class Container
+{
+    protected static $containers = [];
+
+    /**
+     * @param  object|string  $class
+     *
+     * @return object|null
+     */
+    protected static function makeContainer($class)
+    {
+        $name = static::containerName($class);
+
+        if (! isset(static::$containers[$name])) {
+            static::$containers[$name] = Is::object($class) ? $class : new $class;
+        }
+
+        return static::$containers[$name];
+    }
+
+    /**
+     * @param  object|string  $class
+     *
+     * @return string
+     */
+    protected static function containerName($class): string
+    {
+        return Is::object($class) ? get_class($class) : $class;
+    }
+}

src/Support/Exception.php

@@ -61,15 +61,15 @@ public static function getType(Throwable $class): string
 
     public static function getData($exception)
     {
-        if ($exception instanceof SymfonyResponse || $exception instanceof LaravelResponse) {
+        if (Instance::of($exception, [SymfonyResponse::class, LaravelResponse::class])) {
             return Instance::callsWhenNotEmpty($exception, ['getOriginalContent', 'getContent', 'getMessage']);
         }
 
-        if ($exception instanceof Responsable || $exception instanceof HttpResponseException) {
+        if (Instance::of($exception, [Responsable::class, HttpResponseException::class])) {
             return $exception->getResponse();
         }
 
-        if ($exception instanceof ValidationException) {
+        if (Instance::of($exception, ValidationException::class)) {
             return $exception->errors();
         }
 

src/Support/Instance.php

@@ -6,10 +6,8 @@
 use ReflectionClass;
 use Throwable;
 
-class Instance
+final class Instance extends Container
 {
-    protected static $instances = [];
-
     /**
      * @param  mixed  $haystack
      * @param  array|string  $needles
@@ -24,17 +22,17 @@ public static function of($haystack, $needles): bool
             return false;
         }
 
+        $reflection = static::reflection($haystack);
+
         foreach (Arr::wrap($needles) as $needle) {
             if (! static::isClassExists($needle)) {
                 continue;
             }
 
-            $reflection = static::reflection($haystack);
-
             if (
-                $reflection->isInstance(static::make($needle)) ||
+                $reflection->isInstance(static::makeContainer($needle)) ||
                 $reflection->isSubclassOf($needle) ||
-                $reflection->implementsInterface($needle)
+                (Is::contract($reflection) && $reflection->implementsInterface($needle))
             ) {
                 return true;
             }
@@ -99,7 +97,7 @@ protected static function isExistsObject($value): bool
      */
     protected static function isClassExists($class = null): bool
     {
-        return is_string($class) && class_exists($class);
+        return Is::string($class) && class_exists($class);
     }
 
     /**
@@ -109,7 +107,7 @@ protected static function isClassExists($class = null): bool
      */
     protected static function isObject($value): bool
     {
-        return is_object($value);
+        return Is::object($value);
     }
 
     /**
@@ -123,22 +121,4 @@ protected static function reflection(Throwable $class): ReflectionClass
     {
         return new ReflectionClass($class);
     }
-
-    /**
-     * @param  string|Throwable  $class
-     *
-     * @return Throwable
-     */
-    protected static function make($class): Throwable
-    {
-        $is_object = static::isObject($class);
-
-        $name = $is_object ? get_class($class) : $class;
-
-        if (! isset(static::$instances[$name])) {
-            static::$instances[$name] = $is_object ? $class : new $class;
-        }
-
-        return static::$instances[$name];
-    }
 }

src/Support/Is.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Helldar\ApiResponse\Support;
+
+use ReflectionClass;
+
+final class Is
+{
+    public static function object($class): bool
+    {
+        return is_object($class);
+    }
+
+    public static function string($class): bool
+    {
+        return is_string($class);
+    }
+
+    /**
+     * @param $class
+     *
+     * @throws \ReflectionException
+     * @return bool
+     */
+    public static function contract($class): bool
+    {
+        if (! ($class instanceof ReflectionClass)) {
+            $class = new ReflectionClass($class);
+        }
+
+        return $class->isInterface();
+    }
+}