ServiceContainerTrait::unifyNameStyle() - Code Metrics - fwolf/fwlib - Measure and Improve Code Quality continuously with Scrutinizer

ServiceContainerTrait::unifyNameStyle() A
last analyzed 2019-05-09 15:53 UTC

↳ Parent: ServiceContainerTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	1
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php
namespace Fwlib\Base;

use Fwlib\Base\Exception\ServiceInstanceCreationFailException;

/**
 * Trait for service container
 *
 * Usually only one container instance is need, so use Singleton pattern.
 *
 * Service name better use camelCase or StudyCaps style.
 *
 * @copyright   Copyright 2013-2015 Fwolf
 * @license     http://www.gnu.org/licenses/lgpl.html LGPL-3.0+
 * @see         ServiceContainerInterface
 */
trait ServiceContainerTrait
{
    use SingletonTrait;


    /**
     * Service class map
     *
     * These class can have static getInstance() method for reuse, see
     * {@see SingleInstanceTrait}.
     *
     * For easy inherit and not conflict with user registered class, do not
     * set value here, set them in {@see buildClassMap()}.
     *
     * @var string[]
     */
    protected $classMap = [];

    /**
     * Service instances
     *
     * @var object[]
     */
    protected $instances = [];


    /**
     * Constructor
     */
    protected function __construct()
    {
        $this->classMap = $this->buildClassMap();
    }


    /**
     * Build service class map
     *
     * @return  string[]
     */
    protected function buildClassMap()
    {
        // Dummy for inherit and extend by child class.
        $classMap = [];

        return $classMap;
    }


    /**
     * Create service instance by name
     *
     * Will try below sequence to create instance:
     *
     *  - createName() in this container
     *  - Name::getInstance()
     *  - new Name
     *
     * @param   string $name
     * @return  object
     * @throws  ServiceInstanceCreationFailException
     */
    protected function createService($name)
    {
        $service = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $name = $this->unifyNameStyle($name);

        $method = 'create' . $name;
        if (method_exists($this, $method)) {
            $service = $this->$method();


        } elseif (isset($this->classMap[$name])) {
            $className = $this->classMap[$name];

            // Singleton or single instance class instantiate diffs
            if (method_exists($className, 'getInstance')) {
                $service = $className::getInstance();
            } else {
                $service = new $className;
            }


        } else {
            throw (new ServiceInstanceCreationFailException)
                ->setServiceName($name);
        }


        return $service;
    }


    /**
     * Get service instance by name
     *
     * The return type maybe variable, so this method is inner use only. Make
     * getFoo() methods in client class to identify return type.
     *
     * When $forcenew is true, it will ignore exists service instance and
     * create a new one-time use instance, which will not be stored in instance
     * array.
     *
     * $forcenew does not affect instances create according to class map,
     * because they use singleton or single instance pattern.
     *
     * @param   string  $name
     * @param   boolean $forcenew
     * @return  object
     */
    protected function get($name, $forcenew = false)
    {
        $name = $this->unifyNameStyle($name);

        if ($forcenew) {
            return $this->createService($name);

        } else {
            if (!isset($this->instances[$name])) {
                $this->instances[$name] = $this->createService($name);
            }

            return $this->instances[$name];
        }
    }


    /**
     * @see ServiceContainerInterface::getRegistered()
     *
     * @param   string $name
     * @return  object
     */
    public function getRegistered($name)
    {
        $name = $this->unifyNameStyle($name);

        return $this->get($name, false);
    }


    /**
     * @see ServiceContainerInterface::register()
     *
     * @param   string        $name
     * @param   string|object $service
     * @return  static
     */
    public function register($name, $service)
    {
        $name = $this->unifyNameStyle($name);

        if (is_string($service)) {
            return $this->registerClass($name, $service);
        } else {
            return $this->registerInstance($name, $service);
        }
    }


    /**
     * @see ServiceContainerInterface::registerClass()
     *
     * @param   string $name
     * @param   string $className Full qualified name without leading '\'
     * @return  static
     */
    public function registerClass($name, $className)
    {
        $name = $this->unifyNameStyle($name);

        $this->classMap[$name] = $className;

        return $this;
    }


    /**
     * @see ServiceContainerInterface::registerInstance()
     *
     * @param   string $name
     * @param   object $instance
     * @return  static
     */
    public function registerInstance($name, $instance)
    {
        $name = $this->unifyNameStyle($name);

        $this->instances[$name] = $instance;

        return $this;
    }


    /**
     * Unify service name case style
     *
     * @param   string $name
     * @return  string
     */
    protected function unifyNameStyle($name)
    {
        return ucfirst($name);
    }
}


1			<?php
2			namespace Fwlib\Base;
3
4			use Fwlib\Base\Exception\ServiceInstanceCreationFailException;
5
6			/**
7			* Trait for service container
8			*
9			* Usually only one container instance is need, so use Singleton pattern.
10			*
11			* Service name better use camelCase or StudyCaps style.
12			*
13			* @copyright Copyright 2013-2015 Fwolf
14			* @license http://www.gnu.org/licenses/lgpl.html LGPL-3.0+
15			* @see ServiceContainerInterface
16			*/
17			trait ServiceContainerTrait
18			{
19			use SingletonTrait;
20
21
22			/**
23			* Service class map
24			*
25			* These class can have static getInstance() method for reuse, see
26			* {@see SingleInstanceTrait}.
27			*
28			* For easy inherit and not conflict with user registered class, do not
29			* set value here, set them in {@see buildClassMap()}.
30			*
31			* @var string[]
32			*/
33			protected $classMap = [];
34
35			/**
36			* Service instances
37			*
38			* @var object[]
39			*/
40			protected $instances = [];
41
42
43			/**
44			* Constructor
45			*/
46			protected function __construct()
47			{
48			$this->classMap = $this->buildClassMap();
49			}
50
51
52			/**
53			* Build service class map
54			*
55			* @return string[]
56			*/
57			protected function buildClassMap()
58			{
59			// Dummy for inherit and extend by child class.
60			$classMap = [];
61
62			return $classMap;
63			}
64
65
66			/**
67			* Create service instance by name
68			*
69			* Will try below sequence to create instance:
70			*
71			* - createName() in this container
72			* - Name::getInstance()
73			* - new Name
74			*
75			* @param string $name
76			* @return object
77			* @throws ServiceInstanceCreationFailException
78			*/
79			protected function createService($name)
80			{
81			$service = null;
			0 ignored issues – show Unused Code introduced 2016-06-01 06:17 UTC by Report Bug Copy Issue Report `$service` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
82			$name = $this->unifyNameStyle($name);
83
84			$method = 'create' . $name;
85			if (method_exists($this, $method)) {
86			$service = $this->$method();
87
88
89			} elseif (isset($this->classMap[$name])) {
90			$className = $this->classMap[$name];
91
92			// Singleton or single instance class instantiate diffs
93			if (method_exists($className, 'getInstance')) {
94			$service = $className::getInstance();
95			} else {
96			$service = new $className;
97			}
98
99
100			} else {
101			throw (new ServiceInstanceCreationFailException)
102			->setServiceName($name);
103			}
104
105
106			return $service;
107			}
108
109
110			/**
111			* Get service instance by name
112			*
113			* The return type maybe variable, so this method is inner use only. Make
114			* getFoo() methods in client class to identify return type.
115			*
116			* When $forcenew is true, it will ignore exists service instance and
117			* create a new one-time use instance, which will not be stored in instance
118			* array.
119			*
120			* $forcenew does not affect instances create according to class map,
121			* because they use singleton or single instance pattern.
122			*
123			* @param string $name
124			* @param boolean $forcenew
125			* @return object
126			*/
127			protected function get($name, $forcenew = false)
128			{
129			$name = $this->unifyNameStyle($name);
130
131			if ($forcenew) {
132			return $this->createService($name);
133
134			} else {
135			if (!isset($this->instances[$name])) {
136			$this->instances[$name] = $this->createService($name);
137			}
138
139			return $this->instances[$name];
140			}
141			}
142
143
144			/**
145			* @see ServiceContainerInterface::getRegistered()
146			*
147			* @param string $name
148			* @return object
149			*/
150			public function getRegistered($name)
151			{
152			$name = $this->unifyNameStyle($name);
153
154			return $this->get($name, false);
155			}
156
157
158			/**
159			* @see ServiceContainerInterface::register()
160			*
161			* @param string $name
162			* @param string\|object $service
163			* @return static
164			*/
165			public function register($name, $service)
166			{
167			$name = $this->unifyNameStyle($name);
168
169			if (is_string($service)) {
170			return $this->registerClass($name, $service);
171			} else {
172			return $this->registerInstance($name, $service);
173			}
174			}
175
176
177			/**
178			* @see ServiceContainerInterface::registerClass()
179			*
180			* @param string $name
181			* @param string $className Full qualified name without leading '\'
182			* @return static
183			*/
184			public function registerClass($name, $className)
185			{
186			$name = $this->unifyNameStyle($name);
187
188			$this->classMap[$name] = $className;
189
190			return $this;
191			}
192
193
194			/**
195			* @see ServiceContainerInterface::registerInstance()
196			*
197			* @param string $name
198			* @param object $instance
199			* @return static
200			*/
201			public function registerInstance($name, $instance)
202			{
203			$name = $this->unifyNameStyle($name);
204
205			$this->instances[$name] = $instance;
206
207			return $this;
208			}
209
210
211			/**
212			* Unify service name case style
213			*
214			* @param string $name
215			* @return string
216			*/
217			protected function unifyNameStyle($name)
218			{
219			return ucfirst($name);
220			}
221			}
222

fwolf / fwlib

ServiceContainerTrait::unifyNameStyle() A last analyzed 2019-05-09 15:53 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ServiceContainerTrait::unifyNameStyle() A
last analyzed 2019-05-09 15:53 UTC