Code Coverage for /home/travis/build/eloquent/cosmos/src/Eloquent/Cosmos/ClassName.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total		100.00%	1 / 1		100.00%	21 / 21	CRAP		100.00%	77 / 77
ClassName		100.00%	1 / 1		100.00%	21 / 21	38		100.00%	77 / 77
fromString($className)					100.00%	1 / 1	2		100.00%	7 / 7
fromAtoms(array $atoms, $isAbsolute = false)					100.00%	1 / 1	1		100.00%	1 / 1
atoms()					100.00%	1 / 1	1		100.00%	1 / 1
isAbsolute()					100.00%	1 / 1	1		100.00%	1 / 1
isShortName()					100.00%	1 / 1	2		100.00%	1 / 1
isEqualTo(ClassName $className, Comparator $comparator = null)					100.00%	1 / 1	2		100.00%	4 / 4
isRuntimeEquivalentTo(ClassName $className)					100.00%	1 / 1	1		100.00%	1 / 1
join(ClassName $className)					100.00%	1 / 1	2		100.00%	3 / 3
joinAtoms($atom)					100.00%	1 / 1	1		100.00%	1 / 1
joinAtomsArray(array $atoms)					100.00%	1 / 1	1		100.00%	4 / 4
hasParent()					100.00%	1 / 1	1		100.00%	1 / 1
parent()					100.00%	1 / 1	2		100.00%	5 / 5
shortName()					100.00%	1 / 1	1		100.00%	3 / 3
toAbsolute()					100.00%	1 / 1	2		100.00%	3 / 3
toRelative()					100.00%	1 / 1	2		100.00%	3 / 3
hasDescendant(ClassName $className, Comparator $comparator = null)					100.00%	1 / 1	5		100.00%	11 / 11
stripNamespace(ClassName $namespaceName)					100.00%	1 / 1	2		100.00%	7 / 7
exists($useAutoload = null, Isolator $isolator = null)					100.00%	1 / 1	2		100.00%	5 / 5
string()					100.00%	1 / 1	2		100.00%	5 / 5
__toString()					100.00%	1 / 1	1		100.00%	1 / 1
__construct(array $atoms, $isAbsolute)					100.00%	1 / 1	4		100.00%	9 / 9

1	<?php
2
3	/*
4	* This file is part of the Cosmos package.
5	*
6	* Copyright © 2013 Erin Millard
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	namespace Eloquent\Cosmos;
13
14	use Eloquent\Equality\Comparator;
15	use Icecave\Isolator\Isolator;
16
17	class ClassName
18	{
19	/**
20	* @param string $className
21	*
22	* @return ClassName
23	*/
24	public static function fromString($className)
25	{
26	$atoms = explode(static::NAMESPACE_SEPARATOR, $className);
27	$isAbsolute = false;
28	if ('' === $atoms[0]) {
29	$isAbsolute = true;
30	array_shift($atoms);
31	}
32
33	return static::fromAtoms($atoms, $isAbsolute);
34	}
35
36	/**
37	* @param string $className
38	*
39	* @return ClassName
40	*/
41	public static function fromAtoms(array $atoms, $isAbsolute = false)
42	{
43	return new static($atoms, $isAbsolute);
44	}
45
46	/**
47	* @return array<integer,string>
48	*/
49	public function atoms()
50	{
51	return $this->atoms;
52	}
53
54	/**
55	* @return boolean
56	*/
57	public function isAbsolute()
58	{
59	return $this->isAbsolute;
60	}
61
62	/**
63	* @return boolean
64	*/
65	public function isShortName()
66	{
67	return !$this->isAbsolute() && 1 === count($this->atoms());
68	}
69
70	/**
71	* @param ClassName $className
72	* @param Comparator\|null $comparator
73	*
74	* @return boolean
75	*/
76	public function isEqualTo(ClassName $className, Comparator $comparator = null)
77	{
78	if (null === $comparator) {
79	$comparator = new Comparator;
80	}
81
82	return $comparator->equals($this, $className);
83	}
84
85	/**
86	* @param ClassName $className
87	*
88	* @return boolean
89	*/
90	public function isRuntimeEquivalentTo(ClassName $className)
91	{
92	return $className->atoms() === $this->atoms();
93	}
94
95	/**
96	* @param ClassName $className
97	*
98	* @return ClassName
99	*/
100	public function join(ClassName $className)
101	{
102	if ($className->isAbsolute()) {
103	throw new Exception\AbsoluteJoinException($className);
104	}
105
106	return static::joinAtomsArray($className->atoms());
107	}
108
109	/**
110	* @param string $atom
111	* @param string $atom,...
112	*
113	* @return ClassName
114	*/
115	public function joinAtoms($atom)
116	{
117	return static::joinAtomsArray(func_get_args());
118	}
119
120	/**
121	* @param array<string> $atoms
122	*
123	* @return ClassName
124	*/
125	public function joinAtomsArray(array $atoms)
126	{
127	return static::fromAtoms(
128	array_merge($this->atoms(), $atoms),
129	$this->isAbsolute()
130	);
131	}
132
133	/**
134	* @return boolean
135	*/
136	public function hasParent()
137	{
138	return count($this->atoms()) > 1;
139	}
140
141	/**
142	* @return ClassName
143	*/
144	public function parent()
145	{
146	if (!$this->hasParent()) {
147	throw new Exception\ParentException($this);
148	}
149
150	$atoms = $this->atoms();
151	array_pop($atoms);
152
153	return static::fromAtoms($atoms, $this->isAbsolute());
154	}
155
156	/**
157	* @return ClassName
158	*/
159	public function shortName()
160	{
161	$atoms = $this->atoms();
162	$atom = array_pop($atoms);
163
164	return static::fromAtoms(array($atom), false);
165	}
166
167	/**
168	* @return ClassName
169	*/
170	public function toAbsolute()
171	{
172	if (!$this->isAbsolute()) {
173	return static::fromAtoms($this->atoms(), true);
174	}
175
176	return $this;
177	}
178
179	/**
180	* @return ClassName
181	*/
182	public function toRelative()
183	{
184	if ($this->isAbsolute()) {
185	return static::fromAtoms($this->atoms(), false);
186	}
187
188	return $this;
189	}
190
191	/**
192	* @param ClassName $className
193	* @param Comparator\|null $comparator
194	*
195	* @return boolean
196	*/
197	public function hasDescendant(ClassName $className, Comparator $comparator = null)
198	{
199	if ($this->isAbsolute() !== $className->isAbsolute()) {
200	return false;
201	}
202
203	if (null === $comparator) {
204	$comparator = new Comparator;
205	}
206
207	while ($className->hasParent()) {
208	$className = $className->parent();
209	if ($comparator->equals($this, $className)) {
210	return true;
211	}
212	}
213
214	return false;
215	}
216
217	/**
218	* @param ClassName $namespaceName
219	*
220	* @return ClassName
221	*/
222	public function stripNamespace(ClassName $namespaceName)
223	{
224	if (!$namespaceName->hasDescendant($this)) {
225	throw new Exception\NamespaceMismatchException(
226	$this,
227	$namespaceName
228	);
229	}
230
231	$atoms = $this->atoms();
232	array_splice($atoms, 0, count($namespaceName->atoms()));
233
234	return static::fromAtoms($atoms, false);
235	}
236
237	/**
238	* @param boolean\|null $useAutoload
239	* @param Isolator $isolator
240	*
241	* @return boolean
242	*/
243	public function exists($useAutoload = null, Isolator $isolator = null)
244	{
245	if (null === $useAutoload) {
246	$useAutoload = true;
247	}
248	$isolator = Isolator::get($isolator);
249
250	return $isolator->class_exists($this->string(), $useAutoload);
251	}
252
253	/**
254	* @return string
255	*/
256	public function string()
257	{
258	$className = implode(static::NAMESPACE_SEPARATOR, $this->atoms());
259	if ($this->isAbsolute()) {
260	$className = static::NAMESPACE_SEPARATOR.$className;
261	}
262
263	return $className;
264	}
265
266	/**
267	* @return string
268	*/
269	public function __toString()
270	{
271	return $this->string();
272	}
273
274	const NAMESPACE_SEPARATOR = '\\';
275
276	/**
277	* @param array<integer,string> $atoms
278	* @param boolean $isAbsolute
279	*/
280	protected function __construct(array $atoms, $isAbsolute)
281	{
282	if (count($atoms) < 1) {
283	throw new Exception\EmptyClassNameException;
284	}
285	foreach ($atoms as $atom) {
286	if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $atom)) {
287	throw new Exception\InvalidClassNameAtomException($atom);
288	}
289	}
290
291	$this->atoms = $atoms;
292	$this->isAbsolute = $isAbsolute;
293	}
294
295	private $atoms;
296	private $isAbsolute;
297	}