File Manager Lite

Dir: /home/codewavebd/public_html/vendor/laravel/framework/src/Illuminate/Routing

[..]

Attributes/

CallableDispatcher.php (1.32 KB)

Console/

Contracts/

ControllerDispatcher.php (2.22 KB)

Controllers/

Events/

Exceptions/

FiltersControllerMiddleware.php (524 B)

ImplicitRouteBinding.php (4.32 KB)

LICENSE.md (1.05 KB)

Matching/

Middleware/

PendingResourceRegistration.php (7.51 KB)

PendingSingletonResourceRegistration.php (6.78 KB)

Pipeline.php (1.49 KB)

RedirectController.php (1.22 KB)

Redirector.php (7.17 KB)

ResolvesRouteDependencies.php (3.82 KB)

ResourceRegistrar.php (21.7 KB)

ResponseFactory.php (11.41 KB)

RouteAction.php (3.38 KB)

RouteCollection.php (8.52 KB)

RouteDependencyResolverTrait.php (135 B)

RouteFileRegistrar.php (621 B)

RouteGroup.php (2.67 KB)

RouteParameterBinder.php (3.02 KB)

RouteRegistrar.php (9.25 KB)

RouteUri.php (1.27 KB)

RouteUrlGenerator.php (14.61 KB)

RoutingServiceProvider.php (6.69 KB)

SortedMiddleware.php (3.74 KB)

UrlGenerator.php (24.28 KB)

composer.json (1.67 KB)

Edit: ImplicitRouteBinding.php

<?php

namespace Illuminate\Routing;

use Illuminate\Contracts\Routing\UrlRoutable;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException;
use Illuminate\Support\Reflector;
use Illuminate\Support\Str;

class ImplicitRouteBinding
{
    /**
     * Resolve the implicit route bindings for the given route.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  \Illuminate\Routing\Route  $route
     * @return void
     *
     * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
     * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
     */
    public static function resolveForRoute($container, $route)
    {
        $parameters = $route->parameters();

$route = static::resolveBackedEnumsForRoute($route, $parameters);

foreach ($route->signatureParameters(['subClass' => UrlRoutable::class]) as $parameter) {
            if (! $parameterName = static::getParameterName($parameter->getName(), $parameters)) {
                continue;
            }

$parameterValue = $parameters[$parameterName];

if ($parameterValue instanceof UrlRoutable) {
                continue;
            }

$instance = $container->make(Reflector::getParameterClassName($parameter));

$parent = $route->parentOfParameter($parameterName);

$routeBindingMethod = $route->allowsTrashedBindings() && $instance::isSoftDeletable()
                ? 'resolveSoftDeletableRouteBinding'
                : 'resolveRouteBinding';

if ($parent instanceof UrlRoutable &&
                ! $route->preventsScopedBindings() &&
                ($route->enforcesScopedBindings() || array_key_exists($parameterName, $route->bindingFields()))) {
                $childRouteBindingMethod = $route->allowsTrashedBindings() && $instance::isSoftDeletable()
                    ? 'resolveSoftDeletableChildRouteBinding'
                    : 'resolveChildRouteBinding';

if (! $model = $parent->{$childRouteBindingMethod}(
                    $parameterName, $parameterValue, $route->bindingFieldFor($parameterName)
                )) {
                    throw (new ModelNotFoundException)->setModel(get_class($instance), [$parameterValue]);
                }
            } elseif (! $model = $instance->{$routeBindingMethod}($parameterValue, $route->bindingFieldFor($parameterName))) {
                throw (new ModelNotFoundException)->setModel(get_class($instance), [$parameterValue]);
            }

$route->setParameter($parameterName, $model);
        }
    }

/**
     * Resolve the Backed Enums route bindings for the route.
     *
     * @param  \Illuminate\Routing\Route  $route
     * @param  array  $parameters
     * @return \Illuminate\Routing\Route
     *
     * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
     */
    protected static function resolveBackedEnumsForRoute($route, $parameters)
    {
        foreach ($route->signatureParameters(['backedEnum' => true]) as $parameter) {
            if (! $parameterName = static::getParameterName($parameter->getName(), $parameters)) {
                continue;
            }

$parameterValue = $parameters[$parameterName];

if ($parameterValue === null) {
                continue;
            }

$backedEnumClass = $parameter->getType()?->getName();

$backedEnum = $parameterValue instanceof $backedEnumClass
                ? $parameterValue
                : $backedEnumClass::tryFrom((string) $parameterValue);

if (is_null($backedEnum)) {
                throw new BackedEnumCaseNotFoundException($backedEnumClass, $parameterValue);
            }

$route->setParameter($parameterName, $backedEnum);
        }

return $route;
    }

/**
     * Return the parameter name if it exists in the given parameters.
     *
     * @param  string  $name
     * @param  array  $parameters
     * @return string|null
     */
    protected static function getParameterName($name, $parameters)
    {
        if (array_key_exists($name, $parameters)) {
            return $name;
        }

if (array_key_exists($snakedName = Str::snake($name), $parameters)) {
            return $snakedName;
        }
    }
}