mshamaseen / laravel-repository-pattern

src/RepositoryServiceProvider.php

<?php

namespace Shamaseen\Repository\Generator;

use Illuminate\Support\Facades\Config;
use Illuminate\Support\ServiceProvider;
use Illuminate\Support\Str;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use RecursiveRegexIterator;
use RegexIterator;
use Shamaseen\Repository\Generator\Utility\ContractInterface;

/**
 * Class RepositoryServiceProvider.
 */
class RepositoryServiceProvider extends ServiceProvider
{
    /**
     * Indicates if loading of the provider is deferred.
     *
     * @var bool
     */
    protected $defer = true;

    /**
     * All of the container bindings that should be registered.
     *
     * @var array
     */
    public $bindings = [];
    protected $providers = [];

    /**
     * RepositoryServiceProvider constructor.
     *
     * @param $app
     */
    public function __construct($app)
    {
        parent::__construct($app);

        if (null === $this->app['config']->get('repository')) {
            $this->app['config']->set('repository', require __DIR__ . '/config/repository.php');
        }
        $interfaces = Str::plural(Config::get('repository.interface'));
        $repositories = Str::plural(Config::get('repository.repository'));
        $interface = Config::get('repository.interface');
        $repository = Config::get('repository.repository');

        $contractsFolder = Config::get('repository.app_path') . '/' . $interfaces;

        if (is_dir($contractsFolder)) {
            $directory = new RecursiveDirectoryIterator($contractsFolder);
            $iterator = new RecursiveIteratorIterator($directory);
            $regex = new RegexIterator($iterator, '/^.+\.php$/i', RecursiveRegexIterator::GET_MATCH);
            foreach ($regex as $name => $value) {
                $contract = strstr($name, 'app/') ?: strstr($name, 'app\\');

It seems like $name can also be of type null and true; however, parameter $haystack of strstr() does only seem to accept string, maybe add an additional type check?

                $contract = rtrim($contract, '.php');

                $contractName = str_replace('/', '\\', ucfirst($contract));

                //replace only first occurrence
                $pos = strpos($contractName, $interfaces);
                $repositoryClass = '';
                if ($pos !== false) {
                    $repositoryClass = substr_replace($contractName, $repositories, $pos, strlen($interfaces));
                }

                //replace only last occurrence
                $pos = strrpos($repositoryClass, $interface);

It seems like $repositoryClass can also be of type array; however, parameter $haystack of strrpos() does only seem to accept string, maybe add an additional type check?

                if ($pos !== false) {
                    $repositoryClass = substr_replace($repositoryClass, $repository, $pos, strlen($interface));
                }

                $this->providers[] = $contractName;
                $this->bindings[$contractName] = $repositoryClass;

                if (
                    interface_exists($contractName) &&
                    in_array(ContractInterface::class, class_implements($contractName))
                ) {
                    $this->providers[] = $contractName;
                    $this->bindings[$contractName] = $repositoryClass;
                }
            }
        }
    }

    /**
     * Bootstrap services.
     */
    public function boot()
    {
    }

    /**
     * Register services.
     */
    public function register()
    {
    }

    /**
     * Get the services provided by the provider.
     *
     * @return array
     */
    public function provides(): array
    {
        return $this->providers;
    }
}