bytic / utility

src/Oop.php

<?php

namespace Nip\Utility;

/**
 * Class Oop
 * @package Nip\Utility
 */
class Oop
{
    /**
     * @param $class
     * @return string
     */
    public static function basename($class)
    {
        $class = is_object($class) ? get_class($class) : $class;

        return basename(str_replace('\\', '/', $class));
    }

    public static function classUsesTrait($class, $trait): bool
    {
        $traits = static::uses($class);
        return isset($traits[$trait]);
    }

    /**
     * @param $class
     * @param bool $recursive
     * @return array
     */
    public static function uses($class, $recursive = true)
    {
        if (is_object($class)) {
            $class = get_class($class);
        }
        if (class_exists($class) && $recursive == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return class_uses($class);
        }
        $results = [];

        foreach (array_reverse(class_parents($class)) + [$class => $class] as $class) {

$class is overwriting one of the parameters of this function.

            $results += static::traitUses($class);
        }

        return array_unique($results);
    }

    /**
     * @param $trait
     * @param bool $recursive
     * @return array
     */
    public static function traitUses($trait, $recursive = true)

The parameter $recursive is not used and could be removed.

    {
        $traits = class_uses($trait);

        foreach ($traits as $trait) {

$trait is overwriting one of the parameters of this function.

            $traits += static::traitUses($trait);
        }

        return $traits;
    }

    /**
     * @param $name
     * @return bool
     */
    public static function isTrait($name)
    {
        return trait_exists($name);
    }
}