Code Coverage for /libraries/loader.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total		0.00%	0 / 1		64.29%	9 / 14	CRAP		84.83%	151 / 178
jexit($message = 0)					100.00%	1 / 1	0
jimport($path)					100.00%	1 / 1	0		100.00%	1 / 1
JLoader		0.00%	0 / 1		64.29%	9 / 14	80.00		84.75%	150 / 177
discover($classPrefix, $parentPath, $force = true, $recurse = false)					100.00%	1 / 1	8		100.00%	19 / 19
getClassList()					100.00%	1 / 1	1		100.00%	1 / 1
getNamespaces()					0.00%	0 / 1	2		0.00%	0 / 1
import($key, $base = null)					100.00%	1 / 1	7		100.00%	28 / 28
load($class)					100.00%	1 / 1	3		100.00%	9 / 9
loadByNamespaceLowerCase($class)					0.00%	0 / 1	5.16		81.25%	13 / 16
loadByNamespaceNaturalCase($class)					0.00%	0 / 1	5.16		81.25%	13 / 16
loadByNamespaceMixedCase($class)					0.00%	0 / 1	16.67		33.33%	7 / 21
register($class, $path, $force = true)					100.00%	1 / 1	5		100.00%	9 / 9
registerPrefix($prefix, $path, $reset = false)					0.00%	0 / 1	8.74		33.33%	3 / 9
registerNamespace($namespace, $path, $reset = false)					100.00%	1 / 1	4		100.00%	9 / 9
setup($caseStrategy = self::LOWER_CASE, $enableNamespaces = false, $enablePrefixes = true, $enableClasses = true)					100.00%	1 / 1	7		100.00%	23 / 23
_autoload($class)					100.00%	1 / 1	5		100.00%	7 / 7
_load($class, $lookup)					100.00%	1 / 1	4		100.00%	9 / 9

1	<?php
2	/**
3	* @package Joomla.Platform
4	*
5	* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
6	* @license GNU General Public License version 2 or later; see LICENSE
7	*/
8
9	defined('JPATH_PLATFORM') or die;
10
11	/**
12	* Static class to handle loading of libraries.
13	*
14	* @package Joomla.Platform
15	* @since 11.1
16	*/
17	abstract class JLoader
18	{
19	const LOWER_CASE = 1;
20	const NATURAL_CASE = 2;
21	const MIXED_CASE = 3;
22
23	/**
24	* Container for already imported library paths.
25	*
26	* @var array
27	* @since 11.1
28	*/
29	protected static $classes = array();
30
31	/**
32	* Container for already imported library paths.
33	*
34	* @var array
35	* @since 11.1
36	*/
37	protected static $imported = array();
38
39	/**
40	* Container for registered library class prefixes and path lookups.
41	*
42	* @var array
43	* @since 12.1
44	*/
45	protected static $prefixes = array();
46
47	/**
48	* Container for namespace => path map.
49	*
50	* @var array
51	* @since 12.3
52	*/
53	protected static $namespaces = array();
54
55	/**
56	* Method to discover classes of a given type in a given path.
57	*
58	* @param string $classPrefix The class name prefix to use for discovery.
59	* @param string $parentPath Full path to the parent folder for the classes to discover.
60	* @param boolean $force True to overwrite the autoload path value for the class if it already exists.
61	* @param boolean $recurse Recurse through all child directories as well as the parent path.
62	*
63	* @return void
64	*
65	* @since 11.1
66	*/
67	public static function discover($classPrefix, $parentPath, $force = true, $recurse = false)
68	{
69	try
70	{
71	if ($recurse)
72	{
73	$iterator = new RecursiveIteratorIterator(
74	new RecursiveDirectoryIterator($parentPath),
75	RecursiveIteratorIterator::SELF_FIRST
76	);
77	}
78	else
79	{
80	$iterator = new DirectoryIterator($parentPath);
81	}
82
83	foreach ($iterator as $file)
84	{
85	$fileName = $file->getFilename();
86
87	// Only load for php files.
88	// Note: DirectoryIterator::getExtension only available PHP >= 5.3.6
89	if ($file->isFile() && substr($fileName, strrpos($fileName, '.') + 1) == 'php')
90	{
91	// Get the class name and full path for each file.
92	$class = strtolower($classPrefix . preg_replace('#\.php$#', '', $fileName));
93
94	// Register the class with the autoloader if not already registered or the force flag is set.
95	if (empty(self::$classes[$class]) \|\| $force)
96	{
97	self::register($class, $file->getPath() . '/' . $fileName);
98	}
99	}
100	}
101	}
102	catch (UnexpectedValueException $e)
103	{
104	// Exception will be thrown if the path is not a directory. Ignore it.
105	}
106	}
107
108	/**
109	* Method to get the list of registered classes and their respective file paths for the autoloader.
110	*
111	* @return array The array of class => path values for the autoloader.
112	*
113	* @since 11.1
114	*/
115	public static function getClassList()
116	{
117	return self::$classes;
118	}
119
120	/**
121	* Method to get the list of registered namespaces.
122	*
123	* @return array The array of namespace => path values for the autoloader.
124	*
125	* @since 12.3
126	*/
127	public static function getNamespaces()
128	{
129	return self::$namespaces;
130	}
131
132	/**
133	* Loads a class from specified directories.
134	*
135	* @param string $key The class name to look for (dot notation).
136	* @param string $base Search this directory for the class.
137	*
138	* @return boolean True on success.
139	*
140	* @since 11.1
141	*/
142	public static function import($key, $base = null)
143	{
144	// Only import the library if not already attempted.
145	if (!isset(self::$imported[$key]))
146	{
147	// Setup some variables.
148	$success = false;
149	$parts = explode('.', $key);
150	$class = array_pop($parts);
151	$base = (!empty($base)) ? $base : __DIR__;
152	$path = str_replace('.', DIRECTORY_SEPARATOR, $key);
153
154	// Handle special case for helper classes.
155	if ($class == 'helper')
156	{
157	$class = ucfirst(array_pop($parts)) . ucfirst($class);
158	}
159	// Standard class.
160	else
161	{
162	$class = ucfirst($class);
163	}
164
165	// If we are importing a library from the Joomla namespace set the class to autoload.
166	if (strpos($path, 'joomla') === 0)
167	{
168	// Since we are in the Joomla namespace prepend the classname with J.
169	$class = 'J' . $class;
170
171	// Only register the class for autoloading if the file exists.
172	if (is_file($base . '/' . $path . '.php'))
173	{
174	self::$classes[strtolower($class)] = $base . '/' . $path . '.php';
175	$success = true;
176	}
177	}
178	/*
179	* If we are not importing a library from the Joomla namespace directly include the
180	* file since we cannot assert the file/folder naming conventions.
181	*/
182	else
183	{
184	// If the file exists attempt to include it.
185	if (is_file($base . '/' . $path . '.php'))
186	{
187	$success = (bool) include_once $base . '/' . $path . '.php';
188	}
189	}
190
191	// Add the import key to the memory cache container.
192	self::$imported[$key] = $success;
193	}
194
195	return self::$imported[$key];
196	}
197
198	/**
199	* Load the file for a class.
200	*
201	* @param string $class The class to be loaded.
202	*
203	* @return boolean True on success
204	*
205	* @since 11.1
206	*/
207	public static function load($class)
208	{
209	// Sanitize class name.
210	$class = strtolower($class);
211
212	// If the class already exists do nothing.
213	if (class_exists($class, false))
214	{
215	return true;
216	}
217
218	// If the class is registered include the file.
219	if (isset(self::$classes[$class]))
220	{
221	include_once self::$classes[$class];
222
223	return true;
224	}
225
226	return false;
227	}
228
229	/**
230	* Load a class based on namespace using the Lower Case strategy.
231	* This loader might be used when the namespace is lower case or camel case
232	* and the path lower case.
233	*
234	* @param string $class The class (including namespace) to load.
235	*
236	* @return boolean True on success, false otherwise.
237	*
238	* @since 12.3
239	*/
240	public static function loadByNamespaceLowerCase($class)
241	{
242	// If the class already exists do nothing.
243	if (class_exists($class, false))
244	{
245	return true;
246	}
247
248	// Get the root namespace name.
249	$namespace = strstr($class, '\\', true);
250
251	// If we find the namespace in the stack.
252	if (isset(self::$namespaces[$namespace]))
253	{
254	// Remove the namespace name from the class.
255	$class = str_replace($namespace, '', $class);
256
257	// Create a lower case relative path.
258	$relativePath = strtolower(str_replace('\\', '/', $class));
259
260	// Iterate the registered root paths.
261	foreach (self::$namespaces[$namespace] as $rootPath)
262	{
263	// Create the full path.
264	$path = $rootPath . '/' . $relativePath . '.php';
265
266	// Include the file if it exists.
267	if (file_exists($path))
268	{
269	return (bool) include $path;
270	}
271	}
272	}
273
274	return false;
275	}
276
277	/**
278	* Load a class based on namespace using the Natural Case strategy.
279	* This loader might be used when the namespace case matches the path case.
280	*
281	* @param string $class The class (including namespace) to load.
282	*
283	* @return boolean True on success, false otherwise.
284	*
285	* @since 12.3
286	*/
287	public static function loadByNamespaceNaturalCase($class)
288	{
289	// If the class already exists do nothing.
290	if (class_exists($class, false))
291	{
292	return true;
293	}
294
295	// Get the root namespace name.
296	$namespace = strstr($class, '\\', true);
297
298	// If we find the namespace in the stack.
299	if (isset(self::$namespaces[$namespace]))
300	{
301	// Remove the namespace name from the class.
302	$class = str_replace($namespace, '', $class);
303
304	// Create a relative path.
305	$relativePath = str_replace('\\', '/', $class);
306
307	// Iterate the registered root paths.
308	foreach (self::$namespaces[$namespace] as $rootPath)
309	{
310	// Create the full path.
311	$path = $rootPath . '/' . $relativePath . '.php';
312
313	// Include the file if it exists.
314	if (file_exists($path))
315	{
316	return (bool) include $path;
317	}
318	}
319	}
320
321	return false;
322	}
323
324	/**
325	* Load a class based on namespace using the Mixed Case strategy.
326	* This loader might be used when the namespace case matches the path case,
327	* or when the namespace is camel case and the path lower case.
328	*
329	* @param string $class The class (including namespace) to load.
330	*
331	* @return boolean True on success, false otherwise.
332	*
333	* @since 12.3
334	*/
335	public static function loadByNamespaceMixedCase($class)
336	{
337	// If the class already exists do nothing.
338	if (class_exists($class, false))
339	{
340	return true;
341	}
342
343	// Get the root namespace name.
344	$namespace = strstr($class, '\\', true);
345
346	// If we find the namespace in the stack.