4912994209

Build Type

push

github

Committed by Milan Felix Šulc

Commit Message

Tests: fix exception matching (number in exception message can vary)

Run Details

122 of 148 relevant lines covered (82.43%)

0.82 hits per line

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

41.18

/src/Helper/ExtensionDefinitionsHelper.php

<?php declare(strict_types = 1);

namespace Contributte\DI\Helper;

use Nette\DI\Compiler;
use Nette\DI\Definitions\Definition;
use Nette\DI\Definitions\FactoryDefinition;
use Nette\DI\Definitions\LocatorDefinition;
use Nette\DI\Definitions\ServiceDefinition;
use Nette\DI\Definitions\Statement;
use Nette\DI\Resolver;
use Nette\Utils\Strings;

class ExtensionDefinitionsHelper
{

        /** @var Compiler */
        private $compiler;

        public function __construct(Compiler $compiler)
        {
                $this->compiler = $compiler;
        }

        /**
         * @param Definition[] $definitions
         * @return ServiceDefinition[]
         */
        public function getServiceDefinitionsFromDefinitions(array $definitions): array
        {
                $serviceDefinitions = [];
                $resolver = new Resolver($this->compiler->getContainerBuilder());

                foreach ($definitions as $definition) {
                        if ($definition instanceof ServiceDefinition) {
                                $serviceDefinitions[] = $definition;
                        } elseif ($definition instanceof FactoryDefinition) {
                                $serviceDefinitions[] = $definition->getResultDefinition();
                        } elseif ($definition instanceof LocatorDefinition) {
                                $references = $definition->getReferences();
                                foreach ($references as $reference) {
                                        // Check that reference is valid
                                        $reference = $resolver->normalizeReference($reference);
                                        // Get definition by reference
                                        $definition = $resolver->resolveReference($reference);
                                        // Only ServiceDefinition should be possible here
                                        assert($definition instanceof ServiceDefinition);
                                        $serviceDefinitions[] = $definition;
                                }
                        } else {
                                // Definition is of type:
                                //                accessor - service definition exists independently
                                //                imported - runtime-created service, cannot work with
                                //                unknown
                                continue;
                        }
                }

                // Filter out duplicates - we cannot distinguish if service from LocatorDefinition is created by accessor or factory so duplicates are possible
                $serviceDefinitions = array_unique($serviceDefinitions, SORT_REGULAR);

                return $serviceDefinitions;
        }

        /**
         * @param string|mixed[]|Statement $config
         * @return Definition|string
         */
        public function getDefinitionFromConfig($config, string $preferredPrefix)
        {
                $builder = $this->compiler->getContainerBuilder();

                // Definition is defined in ServicesExtension, try to get it
                if (is_string($config) && Strings::startsWith($config, '@')) {
                        $definitionName = substr($config, 1);

                        // Definition is already loaded (beforeCompile phase), return it
                        if ($builder->hasDefinition($definitionName)) {
                                return $builder->getDefinition($definitionName);
                        }

                        // Definition not loaded yet (loadConfiguration phase), return reference string
                        return $config;
                }

                // Raw configuration given, create definition from it
                $this->compiler->loadDefinitionsFromConfig([$preferredPrefix => $config]);
                return $builder->getDefinition($preferredPrefix);
        }

        /**
         * Check if config is valid callable or callable syntax which may result in valid callable at runtime and returns an definition otherwise
         *
         * @param string|mixed[]|Statement $config
         * @return mixed
         */
        public function getCallableFromConfig($config, string $preferredPrefix)
        {
                if (is_callable($config)) {
                        return $config;
                }

                // Might be valid callable at runtime
                if (is_array($config) && is_callable($config, true) && Strings::startsWith($config[0], '@')) {
                        return $config;
                }

                return $this->getDefinitionFromConfig($config, $preferredPrefix);
        }

}

1	<?php declare(strict_types = 1);
2
3	namespace Contributte\DI\Helper;
4
5	use Nette\DI\Compiler;
6	use Nette\DI\Definitions\Definition;
7	use Nette\DI\Definitions\FactoryDefinition;
8	use Nette\DI\Definitions\LocatorDefinition;
9	use Nette\DI\Definitions\ServiceDefinition;
10	use Nette\DI\Definitions\Statement;
11	use Nette\DI\Resolver;
12	use Nette\Utils\Strings;
13
14	class ExtensionDefinitionsHelper
15	{
16
17	/** @var Compiler */
18	private $compiler;
19
20	public function __construct(Compiler $compiler)	1✔
21	{
22	$this->compiler = $compiler;	1✔
23	}	1✔
24
25	/**
26	* @param Definition[] $definitions
27	* @return ServiceDefinition[]
28	*/
29	public function getServiceDefinitionsFromDefinitions(array $definitions): array	1✔
30	{
31	$serviceDefinitions = [];	1✔
32	$resolver = new Resolver($this->compiler->getContainerBuilder());	1✔
33
34	foreach ($definitions as $definition) {	1✔
35	if ($definition instanceof ServiceDefinition) {	1✔
36	$serviceDefinitions[] = $definition;	1✔
37	} elseif ($definition instanceof FactoryDefinition) {	1✔
38	$serviceDefinitions[] = $definition->getResultDefinition();	×
39	} elseif ($definition instanceof LocatorDefinition) {	1✔
40	$references = $definition->getReferences();	×
41	foreach ($references as $reference) {	×
42	// Check that reference is valid
43	$reference = $resolver->normalizeReference($reference);	×
44	// Get definition by reference
45	$definition = $resolver->resolveReference($reference);	×
46	// Only ServiceDefinition should be possible here
47	assert($definition instanceof ServiceDefinition);	×
48	$serviceDefinitions[] = $definition;	×
49	}
50	} else {
51	// Definition is of type:
52	// accessor - service definition exists independently
53	// imported - runtime-created service, cannot work with
54	// unknown
55	continue;	1✔
56	}
57	}
58
59	// Filter out duplicates - we cannot distinguish if service from LocatorDefinition is created by accessor or factory so duplicates are possible
60	$serviceDefinitions = array_unique($serviceDefinitions, SORT_REGULAR);	1✔
61
62	return $serviceDefinitions;	1✔
63	}
64
65	/**
66	* @param string\|mixed[]\|Statement $config
67	* @return Definition\|string
68	*/
69	public function getDefinitionFromConfig($config, string $preferredPrefix)
70	{
71	$builder = $this->compiler->getContainerBuilder();	×
72
73	// Definition is defined in ServicesExtension, try to get it
74	if (is_string($config) && Strings::startsWith($config, '@')) {	×
75	$definitionName = substr($config, 1);	×
76
77	// Definition is already loaded (beforeCompile phase), return it
78	if ($builder->hasDefinition($definitionName)) {	×
79	return $builder->getDefinition($definitionName);	×
80	}
81
82	// Definition not loaded yet (loadConfiguration phase), return reference string
83	return $config;	×
84	}
85
86	// Raw configuration given, create definition from it
87	$this->compiler->loadDefinitionsFromConfig([$preferredPrefix => $config]);	×
88	return $builder->getDefinition($preferredPrefix);	×
89	}
90
91	/**
92	* Check if config is valid callable or callable syntax which may result in valid callable at runtime and returns an definition otherwise
93	*
94	* @param string\|mixed[]\|Statement $config
95	* @return mixed
96	*/
97	public function getCallableFromConfig($config, string $preferredPrefix)
98	{
99	if (is_callable($config)) {	×
100	return $config;	×
101	}
102
103	// Might be valid callable at runtime
104	if (is_array($config) && is_callable($config, true) && Strings::startsWith($config[0], '@')) {	×
105	return $config;	×
106	}
107
108	return $this->getDefinitionFromConfig($config, $preferredPrefix);	×
109	}
110
111	}

contributte / di / 4912994209

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