%line	%branch
org.apache.commons.configuration.ConfigurationUtils	91%	100%

1		/*
2		* Copyright 2001-2005 The Apache Software Foundation.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License")
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17		package org.apache.commons.configuration;
18
19		import java.io.File;
20		import java.io.IOException;
21		import java.io.InputStream;
22		import java.io.PrintStream;
23		import java.io.PrintWriter;
24		import java.io.StringWriter;
25		import java.net.MalformedURLException;
26		import java.net.URL;
27		import java.net.URLDecoder;
28		import java.util.Iterator;
29
30		import org.apache.commons.lang.StringUtils;
31		import org.apache.commons.logging.Log;
32		import org.apache.commons.logging.LogFactory;
33
34		/**
35		* Miscellaneous utility methods for configurations.
36		*
37		* @see ConfigurationConverter Utility methods to convert configurations.
38		*
39		* @author <a href="mailto:herve.quiroz@esil.univ-mrs.fr">Herve Quiroz</a>
40		* @author <a href="mailto:oliver.heger@t-online.de">Oliver Heger</a>
41		* @author Emmanuel Bourg
42	40	* @version $Revision$, $Date: 2005-12-14 16:20:30 +0100 (Wed, 14 Dec 2005) $
43		*/
44	20	public final class ConfigurationUtils
45		{
46		/** Constant for the file URL protocol.*/
47		static final String PROTOCOL_FILE = "file";
48	40
49		/** The logger.*/
50	20	private static Log log = LogFactory.getLog(ConfigurationUtils.class);
51
52		/**
53		* Private constructor. Prevents instances from being created.
54		*/
55		private ConfigurationUtils()
56	0	{
57		// to prevent instanciation...
58	0	}
59
60		/**
61		* Dump the configuration key/value mappings to some ouput stream.
62		*
63		* @param configuration the configuration
64		* @param out the output stream to dump the configuration to
65		*/
66		public static void dump(Configuration configuration, PrintStream out)
67		{
68	0	dump(configuration, new PrintWriter(out));
69	0	}
70
71		/**
72		* Dump the configuration key/value mappings to some writer.
73		*
74		* @param configuration the configuration
75		* @param out the writer to dump the configuration to
76		*/
77	10	public static void dump(Configuration configuration, PrintWriter out)
78	32	{
79	5	Iterator keys = configuration.getKeys();
80	28	while (keys.hasNext())
81	12	{
82	18	String key = (String) keys.next();
83	18	Object value = configuration.getProperty(key);
84	18	out.print(key);
85	6	out.print("=");
86	18	out.print(value);
87
88	10	if (keys.hasNext())
89		{
90	2	out.println();
91		}
92	10	}
93	10
94	5	out.flush();
95	5	}
96
97		/**
98		* Get a string representation of the key/value mappings of a
99		* configuration.
100		*
101		* @param configuration the configuration
102		* @return a string representation of the configuration
103		*/
104	10	public static String toString(Configuration configuration)
105	10	{
106	15	StringWriter writer = new StringWriter();
107	5	dump(configuration, new PrintWriter(writer));
108	5	return writer.toString();
109		}
110
111		/**
112		* Copy all properties from the source configuration to the target
113		* configuration. Properties in the target configuration are replaced with
114		* the properties with the same key in the source configuration.
115		* <em>Note:</em> This method won't work well on hierarchical configurations
116		* because it is not able to copy information about the properties'
117		* structure. So when dealing with hierarchical configuration objects their
118		* <code>{@link HierarchicalConfiguration#clone() clone()}</code> methods
119		* should be used.
120		*
121		* @param source the source configuration
122		* @param target the target configuration
123		* @since 1.1
124		*/
125	2	public static void copy(Configuration source, Configuration target)
126	8	{
127	1	Iterator keys = source.getKeys();
128	8	while (keys.hasNext())
129	4	{
130	2	String key = (String) keys.next();
131	4	target.setProperty(key, source.getProperty(key));
132		}
133	1	}
134
135		/**
136		* Append all properties from the source configuration to the target
137		* configuration. Properties in the source configuration are appended to
138		* the properties with the same key in the target configuration.
139		*
140		* @param source the source configuration
141		* @param target the target configuration
142		* @since 1.1
143		*/
144	2	public static void append(Configuration source, Configuration target)
145	8	{
146	1	Iterator keys = source.getKeys();
147	8	while (keys.hasNext())
148	4	{
149	2	String key = (String) keys.next();
150	4	target.addProperty(key, source.getProperty(key));
151		}
152	1	}
153
154		/**
155		* Constructs a URL from a base path and a file name. The file name can
156		* be absolute, relative or a full URL. If necessary the base path URL is
157		* applied.
158		*
159		* @param basePath the base path URL (can be <b>null</b>)
160		* @param file the file name
161		* @return the resulting URL
162		* @throws MalformedURLException if URLs are invalid
163		*/
164	16	public static URL getURL(String basePath, String file) throws MalformedURLException
165	16	{
166	8	File f = new File(file);
167	12	if (f.isAbsolute()) // already absolute?
168		{
169	2	return f.toURL();
170		}
171
172	12	try
173		{
174	10	if (basePath == null)
175		{
176	2	return new URL(file);
177		}
178	8	else
179	6	{
180	4	URL base = new URL(basePath);
181	3	return new URL(base, file);
182		}
183		}
184	4	catch (MalformedURLException uex)
185		{
186	2	return constructFile(basePath, file).toURL();
187		}
188		}
189
190		/**
191		* Helper method for constructing a file object from a base path and a
192		* file name. This method is called if the base path passed to
193		* <code>getURL()</code> does not seem to be a valid URL.
194		*
195		* @param basePath the base path
196		* @param fileName the file name
197		* @return the resulting file
198		*/
199	1166	static File constructFile(String basePath, String fileName)
200		{
201	1749	File file = null;
202	1166
203	583	File absolute = null;
204	1749	if (fileName != null)
205		{
206	583	absolute = new File(fileName);
207	1166	}
208
209	659	if (StringUtils.isEmpty(basePath) || (absolute != null && absolute.isAbsolute()))
210		{
211	38	file = new File(fileName);
212		}
213	1090	else
214	1090	{
215	545	StringBuffer fName = new StringBuffer();
216	545	fName.append(basePath);
217	1090
218		// My best friend. Paranoia.
219	1635	if (!basePath.endsWith(File.separator))
220		{
221	545	fName.append(File.separator);
222		}
223
224		//
225		// We have a relative path, and we have
226		// two possible forms here. If we have the
227		// "./" form then just strip that off first
228	1090	// before continuing.
229		//
230	545	if (fileName.startsWith("." + File.separator))
231		{
232	0	fName.append(fileName.substring(2));
233		}
234	1090	else
235		{
236	545	fName.append(fileName);
237	1090	}
238
239	545	file = new File(fName.toString());
240	1166	}
241
242	583	return file;
243		}
244
245		/**
246		* Return the location of the specified resource by searching the user home
247		* directory, the current classpath and the system classpath.
248		*
249		* @param name the name of the resource
250		*
251		* @return the location of the resource
252		*/
253		public static URL locate(String name)
254		{
255	0	return locate(null, name);
256		}
257
258		/**
259		* Return the location of the specified resource by searching the user home
260		* directory, the current classpath and the system classpath.
261		*
262		* @param base the base path of the resource
263		* @param name the name of the resource
264		*
265		* @return the location of the resource
266		*/
267	1172	public static URL locate(String base, String name)
268		{
269	580	if (name == null)
270	6	{
271		// undefined, always return null
272	3	return null;
273	1166	}
274
275	577	URL url = null;
276
277		// attempt to create an URL directly
278	1166	try
279		{
280	677	if (base == null)
281		{
282	50	url = new URL(name);
283		}
284	1066	else
285	86	{
286	527	URL baseURL = new URL(base);
287	37	url = new URL(baseURL, name);
288	86
289		// check if the file exists
290	37	InputStream in = null;
291	86	try
292	68	{
293	37	in = url.openStream();
294	28	}
295	18	finally
296		{
297	77	if (in != null)
298		{
299	28	in.close();
300		}
301		}
302	68	}
303	68
304	28	log.debug("Configuration loaded from the URL " + url);
305	28	}
306	1098	catch (IOException e)
307		{
308	549	url = null;
309		}
310	1166
311		// attempt to load from an absolute path
312	1675	if (url == null)
313	1098	{
314	549	File file = new File(name);
315	549	if (file.isAbsolute() && file.exists()) // already absolute?
316		{
317	36	try
318	36	{
319	54	url = file.toURL();
320	18	log.debug("Configuration loaded from the absolute path " + name);
321	18	}
322		catch (MalformedURLException e)
323		{
324	0	e.printStackTrace();
325		}
326		}
327		}
328	1166
329		// attempt to load from the base directory
330	577	if (url == null)
331		{
332	1062	try
333	1062	{
334	531	File file = constructFile(base, name);
335	1535	if (file != null && file.exists())
336		{
337	502	url = file.toURL();
338	1062	}
339
340	1535	if (url != null)
341		{
342	1564	log.debug("Configuration loaded from the base path " + name);
343		}
344	531	}
345		catch (IOException e)
346		{
347	0	e.printStackTrace();
348		}
349		}
350	1166
351		// attempt to load from the user home directory
352	577	if (url == null)
353		{
354	58	try
355	58	{
356	29	File file = constructFile(System.getProperty("user.home"), name);
357	31	if (file != null && file.exists())
358		{
359	1	url = file.toURL();
360	58	}
361
362	31	if (url != null)
363		{
364	1	log.debug("Configuration loaded from the home path " + name);
365	58	}
366
367	29	}
368		catch (IOException e)
369		{
370	0	e.printStackTrace();
371		}
372		}
373	1166
374		// attempt to load from the context classpath
375	633	if (url == null)
376	56	{
377	28	ClassLoader loader = Thread.currentThread().getContextClassLoader();
378	84	url = loader.getResource(name);
379
380	56	if (url != null)
381		{
382	14	log.debug("Configuration loaded from the context classpath (" + name + ")");
383		}
384		}
385	1166
386		// attempt to load from the system classpath
387	605	if (url == null)
388		{
389	42	url = ClassLoader.getSystemResource(name);
390
391	14	if (url != null)
392		{
393	0	log.debug("Configuration loaded from the system classpath (" + name + ")");
394		}
395	1166	}
396
397	577	return url;
398		}
399
400		/**
401		* Return the path without the file name, for example http://xyz.net/foo/bar.xml
402		* results in http://xyz.net/foo/
403		*
404		* @param url the URL from which to extract the path
405		* @return the path component of the passed in URL
406		*/
407	20	static String getBasePath(URL url)
408		{
409	11	if (url == null)
410		{
411	0	return null;
412	20	}
413
414	31	String s = url.toString();
415
416	17	if (s.endsWith("/") || StringUtils.isEmpty(url.getPath()))
417		{
418	3	return s;
419		}
420	14	else
421		{
422	8	return s.substring(0, s.lastIndexOf("/") + 1);
423		}
424		}
425
426		/**
427		* Extract the file name from the specified URL.
428		*
429		* @param url the URL from which to extract the file name
430		* @return the extracted file name
431		*/
432	16	static String getFileName(URL url)
433		{
434	11	if (url == null)
435		{
436	1	return null;
437	14	}
438
439	22	String path = url.getPath();
440
441	10	if (path.endsWith("/") || StringUtils.isEmpty(path))
442		{
443	1	return null;
444		}
445	12	else
446		{
447	7	return path.substring(path.lastIndexOf("/") + 1);
448		}
449		}
450
451		/**
452		* Tries to convert the specified base path and file name into a file object.
453		* This method is called e.g. by the save() methods of file based
454		* configurations. The parameter strings can be relative files, absolute
455		* files and URLs as well.
456		*
457		* @param basePath the base path
458		* @param fileName the file name
459		* @return the file object (<b>null</b> if no file can be obtained)
460		*/
461		public static File getFile(String basePath, String fileName)
462		{
463		// Check if URLs are involved
464		URL url;
465	56	try
466	10	{
467	28	url = new URL(class="keyword">new URL(basePath), fileName);
468	5	}
469	46	catch (MalformedURLException mex1)
470		{
471	69	try
472	4	{
473	23	url = new URL(fileName);
474	2	}
475	42	catch (MalformedURLException mex2)
476		{
477	21	url = null;
478		}
479	56	}
480
481	42	if (url != null)
482		{
483	7	return fileFromURL(url);
484	42	}
485
486	21	return constructFile(basePath, fileName);
487		}
488
489		/**
490		* Tries to convert the specified URL to a file object. If this fails,
491		* <b>null</b> is returned.
492		*
493		* @param url the URL
494		* @return the resulting file object
495		*/
496	1208	public static File fileFromURL(URL url)
497		{
498	1808	if (PROTOCOL_FILE.equals(url.getProtocol()))
499		{
500	602	return new File(URLDecoder.decode(url.getPath()));
501		}
502	4	else
503		{
504	2	return null;
505		}
506		}
507		}

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.