19937261397

Committed 04 Dec 2025 05:04PM UTC coverage: 97.317% (-1.5%) from 98.808%

Build # 19937261397

Build Type

push

github

Committed by

web-flow

Commit Message

Merge branch 'slimphp:5.x' into 5.x

Run Details

158 of 171 new or added lines in 22 files covered. (92.4%)

4 existing lines in 2 files now uncovered.

943 of 969 relevant lines covered (97.32%)

34.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.68

/Slim/Container/ContainerResolver.php

<?php

/**
 * Slim Framework (https://slimframework.com)
 *
 * @license https://github.com/slimphp/Slim/blob/5.x/LICENSE.md (MIT License)
 */

declare(strict_types=1);

namespace Slim\Container;

use Closure;
use Psr\Container\ContainerInterface;
use RuntimeException;
use Slim\Interfaces\ContainerResolverInterface;

use function is_array;

/**
 * Resolves identifiers into services or callables using a PSR-11 DI container.
 *
 * Supports:
 * - Service names (strings)
 * - Slim notation: "service:method"
 * - PHP notation: "Class::method"
 * - Arrays like ["service", "method"]
 * - Callables or objects directly
 *
 * Returned results can be:
 * - A callable
 * - An object fetched from the container
 * - A callable bound to the container (closures)
 *
 * This is used internally by Slim to resolve route callables, middleware, and
 * other handler definitions.
 */
final class ContainerResolver implements ContainerResolverInterface
{
    private ContainerInterface $container;

    /**
     * Regex matching Slim-style "service:method" callables.
     */
    private string $callablePattern = '!^([^\:]+)\:([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)$!';

    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    /**
     * {@inheritdoc}
     */
    public function resolve(callable|object|array|string $identifier): mixed
    {
        // Already an object, no further resolution needed
        if (is_object($identifier)) {
            return $identifier;
        }

        // Bind callable to container
        if (is_callable($identifier)) {
            return $this->bindToContainer($identifier);
        }

        // ClassName::methodName or Slim notation ClassName:methodName
        if (is_string($identifier) && preg_match($this->callablePattern, $identifier, $matches)) {
            $identifier = [$matches[1], $matches[2]];
        }

        // Resolve as a container entry name
        if (is_string($identifier)) {
            return $this->container->get($identifier);
        }

        // Array callable notation: ['service-id', 'method']
        // @phpstan-ignore-next-line
        if (is_string($identifier[0])) {
            // Replace the container entry name by the actual object
            $service = $this->container->get($identifier[0]);

            if (!is_object($service) && !is_string($service)) {
                throw new RuntimeException(
                    sprintf(
                        'Container entry "%s" must resolve to an object or class name.',
                        $identifier[0],
                    ),
                );
            }

            $method = (string)($identifier[1] ?? '');

            if (!method_exists($service, $method)) {
                throw new RuntimeException(sprintf('The method "%s" does not exist', $method));
            }

            return [$service, $method];
        }

        // @phpstan-ignore-next-line
        return $identifier;
    }

    /**
     * {@inheritdoc}
     */
    public function resolveCallable(callable|array|string $identifier): callable
    {
        if (is_string($identifier)) {
            $identifier = $this->resolve($identifier);
        }

        if (is_callable($identifier)) {
            return $this->bindToContainer($identifier);
        }

        // Unrecognized stuff, we let it fail
        throw new RuntimeException(
            sprintf('The definition "%s" is not a callable.', implode(':', (array)$identifier)),
        );
    }

    /**
     * Bind closures to the container to allow `$this` access.
     * @param callable $callable
     */
    private function bindToContainer(callable $callable): callable
    {
        if (is_array($callable) && $callable[0] instanceof Closure) {
            $callable = $callable[0];
        }

        if ($callable instanceof Closure) {
            $callable = $callable->bindTo($this->container) ?? throw new RuntimeException(
                'Unable to bind callable to DI container.',
            );
        }

        return $callable;
    }
}

1	<?php
2
3	/**
4	* Slim Framework (https://slimframework.com)
5	*
6	* @license https://github.com/slimphp/Slim/blob/5.x/LICENSE.md (MIT License)
7	*/
8
9	declare(strict_types=1);
10
11	namespace Slim\Container;
12
13	use Closure;
14	use Psr\Container\ContainerInterface;
15	use RuntimeException;
16	use Slim\Interfaces\ContainerResolverInterface;
17
18	use function is_array;
19
20	/**
21	* Resolves identifiers into services or callables using a PSR-11 DI container.
22	*
23	* Supports:
24	* - Service names (strings)
25	* - Slim notation: "service:method"
26	* - PHP notation: "Class::method"
27	* - Arrays like ["service", "method"]
28	* - Callables or objects directly
29	*
30	* Returned results can be:
31	* - A callable
32	* - An object fetched from the container
33	* - A callable bound to the container (closures)
34	*
35	* This is used internally by Slim to resolve route callables, middleware, and
36	* other handler definitions.
37	*/
38	final class ContainerResolver implements ContainerResolverInterface
39	{
40	private ContainerInterface $container;
41
42	/**
43	* Regex matching Slim-style "service:method" callables.
44	*/
45	private string $callablePattern = '!^([^\:]+)\:([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)$!';
46
47	public function __construct(ContainerInterface $container)
48	{
49	$this->container = $container;	213✔
50	}
51
52	/**
53	* {@inheritdoc}
54	*/
55	public function resolve(callable\|object\|array\|string $identifier): mixed
56	{
57	// Already an object, no further resolution needed
58	if (is_object($identifier)) {	120✔
59	return $identifier;	101✔
60	}
61
62	// Bind callable to container
63	if (is_callable($identifier)) {	106✔
64	return $this->bindToContainer($identifier);	3✔
65	}
66
67	// ClassName::methodName or Slim notation ClassName:methodName
68	if (is_string($identifier) && preg_match($this->callablePattern, $identifier, $matches)) {	104✔
69	$identifier = [$matches[1], $matches[2]];	8✔
70	}
71
72	// Resolve as a container entry name
73	if (is_string($identifier)) {	104✔
74	return $this->container->get($identifier);	96✔
75	}
76
77	// Array callable notation: ['service-id', 'method']
78	// @phpstan-ignore-next-line
79	if (is_string($identifier[0])) {	11✔
80	// Replace the container entry name by the actual object
81	$service = $this->container->get($identifier[0]);	10✔
82
83	if (!is_object($service) && !is_string($service)) {	8✔
NEW 84	throw new RuntimeException(	×
NEW 85	sprintf(	×
NEW 86	'Container entry "%s" must resolve to an object or class name.',	×
NEW 87	$identifier[0],	×
NEW 88	),	×
NEW 89	);	×
90	}
91
92	$method = (string)($identifier[1] ?? '');	8✔
93
94	if (!method_exists($service, $method)) {	8✔
95	throw new RuntimeException(sprintf('The method "%s" does not exist', $method));	2✔
96	}
97
98	return [$service, $method];	6✔
99	}
100
101	// @phpstan-ignore-next-line
102	return $identifier;	1✔
103	}
104
105	/**
106	* {@inheritdoc}
107	*/
108	public function resolveCallable(callable\|array\|string $identifier): callable
109	{
110	if (is_string($identifier)) {	85✔
111	$identifier = $this->resolve($identifier);	5✔
112	}
113
114	if (is_callable($identifier)) {	84✔
115	return $this->bindToContainer($identifier);	84✔
116	}
117
118	// Unrecognized stuff, we let it fail
UNCOV 119	throw new RuntimeException(	×
NEW 120	sprintf('The definition "%s" is not a callable.', implode(':', (array)$identifier)),	×
UNCOV 121	);	×
122	}
123
124	/**
125	* Bind closures to the container to allow `$this` access.
126	* @param callable $callable
127	*/
128	private function bindToContainer(callable $callable): callable
129	{
130	if (is_array($callable) && $callable[0] instanceof Closure) {	86✔
131	$callable = $callable[0];	1✔
132	}
133
134	if ($callable instanceof Closure) {	86✔
135	$callable = $callable->bindTo($this->container) ?? throw new RuntimeException(	80✔
136	'Unable to bind callable to DI container.',	80✔
137	);	80✔
138	}
139
140	return $callable;	86✔
141	}
142	}

odan / Slim / 19937261397

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous