%line | %branch | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
org.apache.commons.configuration.ConfigurationUtils |
|
|
1 | /* |
|
2 | * Copyright 2001-2004 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.PrintStream; |
|
22 | import java.io.PrintWriter; |
|
23 | import java.io.StringWriter; |
|
24 | import java.net.MalformedURLException; |
|
25 | import java.net.URL; |
|
26 | import java.util.Iterator; |
|
27 | ||
28 | import org.apache.commons.lang.StringUtils; |
|
29 | import org.apache.commons.logging.Log; |
|
30 | import org.apache.commons.logging.LogFactory; |
|
31 | ||
32 | /** |
|
33 | * Miscellaneous utility methods for configurations. |
|
34 | * |
|
35 | * @author <a href="mailto:herve.quiroz@esil.univ-mrs.fr">Herve Quiroz</a> |
|
36 | * @author <a href="mailto:oliver.heger@t-online.de">Oliver Heger</a> |
|
37 | * @author Emmanuel Bourg |
|
38 | * @version $Revision: 1.9 $, $Date: 2004/09/23 11:42:00 $ |
|
39 | */ |
|
40 | public final class ConfigurationUtils |
|
41 | { |
|
42 | 30 | private static Log log = LogFactory.getLog(ConfigurationUtils.class); |
43 | ||
44 | private ConfigurationUtils() |
|
45 | 0 | { |
46 | // to prevent instanciation... |
|
47 | 0 | } |
48 | ||
49 | /** |
|
50 | * Dump the configuration key/value mappings to some ouput stream. |
|
51 | * |
|
52 | * @param configuration the configuration |
|
53 | * @param out the output stream to dump the configuration to |
|
54 | */ |
|
55 | public static void dump(Configuration configuration, PrintStream out) |
|
56 | { |
|
57 | 0 | dump(configuration, new PrintWriter(out)); |
58 | 0 | } |
59 | ||
60 | /** |
|
61 | * Dump the configuration key/value mappings to some writer. |
|
62 | * |
|
63 | * @param configuration the configuration |
|
64 | * @param out the writer to dump the configuration to |
|
65 | */ |
|
66 | public static void dump(Configuration configuration, PrintWriter out) |
|
67 | { |
|
68 | 5 | Iterator keys = configuration.getKeys(); |
69 | 11 | while (keys.hasNext()) |
70 | { |
|
71 | 6 | String key = (String) keys.next(); |
72 | 6 | Object value = configuration.getProperty(key); |
73 | 6 | out.print(key); |
74 | 6 | out.print("="); |
75 | 6 | out.print(value); |
76 | ||
77 | 6 | if (keys.hasNext()) |
78 | { |
|
79 | 2 | out.println(); |
80 | } |
|
81 | } |
|
82 | ||
83 | 5 | out.flush(); |
84 | 5 | } |
85 | ||
86 | /** |
|
87 | * Get a string representation of the key/value mappings of a |
|
88 | * configuration. |
|
89 | * |
|
90 | * @param configuration the configuration |
|
91 | * @return a string representation of the configuration |
|
92 | */ |
|
93 | public static String toString(Configuration configuration) |
|
94 | { |
|
95 | 5 | StringWriter writer = new StringWriter(); |
96 | 5 | dump(configuration, new PrintWriter(writer)); |
97 | 5 | return writer.toString(); |
98 | } |
|
99 | ||
100 | /** |
|
101 | * Constructs a URL from a base path and a file name. The file name can |
|
102 | * be absolute, relative or a full URL. If necessary the base path URL is |
|
103 | * applied. |
|
104 | * |
|
105 | * @param basePath the base path URL (can be <b>null</b>) |
|
106 | * @param file the file name |
|
107 | * @return the resulting URL |
|
108 | * @throws MalformedURLException if URLs are invalid |
|
109 | */ |
|
110 | public static URL getURL(String basePath, String file) throws MalformedURLException |
|
111 | { |
|
112 | 8 | File f = new File(file); |
113 | 8 | if (f.isAbsolute()) // already absolute? |
114 | { |
|
115 | 2 | return f.toURL(); |
116 | } |
|
117 | ||
118 | try |
|
119 | { |
|
120 | 6 | if (basePath == null) |
121 | { |
|
122 | 2 | return new URL(file); |
123 | } |
|
124 | else |
|
125 | { |
|
126 | 4 | URL base = new URL(basePath); |
127 | 3 | return new URL(base, file); |
128 | } |
|
129 | } |
|
130 | 2 | catch (MalformedURLException uex) |
131 | { |
|
132 | 2 | return constructFile(basePath, file).toURL(); |
133 | } |
|
134 | } |
|
135 | ||
136 | /** |
|
137 | * Helper method for constructing a file object from a base path and a |
|
138 | * file name. This method is called if the base path passed to |
|
139 | * <code>getURL()</code> does not seem to be a valid URL. |
|
140 | * |
|
141 | * @param basePath the base path |
|
142 | * @param fileName the file name |
|
143 | * @return the resulting file |
|
144 | */ |
|
145 | static File constructFile(String basePath, String fileName) |
|
146 | { |
|
147 | 100 | File file = null; |
148 | ||
149 | 100 | File absolute = null; |
150 | 100 | if (fileName != null) |
151 | { |
|
152 | 99 | absolute = new File(fileName); |
153 | } |
|
154 | ||
155 | 100 | if (StringUtils.isEmpty(basePath) || (absolute != null && absolute.isAbsolute())) |
156 | { |
|
157 | 20 | file = new File(fileName); |
158 | } |
|
159 | else |
|
160 | { |
|
161 | 80 | StringBuffer fName = new StringBuffer(); |
162 | 80 | fName.append(basePath); |
163 | ||
164 | // My best friend. Paranoia. |
|
165 | 80 | if (!basePath.endsWith(File.separator)) |
166 | { |
|
167 | 77 | fName.append(File.separator); |
168 | } |
|
169 | ||
170 | // |
|
171 | // We have a relative path, and we have |
|
172 | // two possible forms here. If we have the |
|
173 | // "./" form then just strip that off first |
|
174 | // before continuing. |
|
175 | // |
|
176 | 80 | if (fileName.startsWith("." + File.separator)) |
177 | { |
|
178 | 0 | fName.append(fileName.substring(2)); |
179 | } |
|
180 | else |
|
181 | { |
|
182 | 80 | fName.append(fileName); |
183 | } |
|
184 | ||
185 | 80 | file = new File(fName.toString()); |
186 | } |
|
187 | ||
188 | 99 | return file; |
189 | } |
|
190 | ||
191 | ||
192 | /** |
|
193 | * Return the location of the specified resource by searching the user home |
|
194 | * directory, the current classpath and the system classpath. |
|
195 | * |
|
196 | * @param name the name of the resource |
|
197 | * |
|
198 | * @return the location of the resource |
|
199 | */ |
|
200 | public static URL locate(String name) |
|
201 | { |
|
202 | 182 | return locate(null, name); |
203 | } |
|
204 | ||
205 | /** |
|
206 | * Return the location of the specified resource by searching the user home |
|
207 | * directory, the current classpath and the system classpath. |
|
208 | * |
|
209 | * @param base the base path of the resource |
|
210 | * @param name the name of the resource |
|
211 | * |
|
212 | * @return the location of the resource |
|
213 | */ |
|
214 | public static URL locate(String base, String name) |
|
215 | { |
|
216 | 377 | URL url = null; |
217 | ||
218 | // attempt to create an URL directly |
|
219 | try |
|
220 | { |
|
221 | 377 | if (base == null) |
222 | { |
|
223 | 195 | url = new URL(name); |
224 | } |
|
225 | else |
|
226 | { |
|
227 | 182 | URL baseURL = new URL(base); |
228 | 126 | url = new URL(baseURL, name); |
229 | } |
|
230 | ||
231 | 126 | log.debug("Configuration loaded from the URL " + url); |
232 | } |
|
233 | 251 | catch (MalformedURLException e) |
234 | { |
|
235 | ||
236 | 126 | } |
237 | ||
238 | // attempt to load from an absolute path |
|
239 | 377 | if (url == null) |
240 | { |
|
241 | 251 | File file = new File(name); |
242 | 251 | if (file.isAbsolute()) // already absolute? |
243 | { |
|
244 | try |
|
245 | { |
|
246 | 180 | url = file.toURL(); |
247 | 180 | log.debug("Configuration loaded from the absolute path " + name); |
248 | } |
|
249 | 0 | catch (MalformedURLException e) |
250 | { |
|
251 | 0 | e.printStackTrace(); |
252 | 180 | } |
253 | } |
|
254 | } |
|
255 | ||
256 | // attempt to load from the base directory |
|
257 | 377 | if (url == null) |
258 | { |
|
259 | try |
|
260 | { |
|
261 | 71 | File file = constructFile(base, name); |
262 | 71 | if (file != null && file.exists()) |
263 | { |
|
264 | 52 | url = file.toURL(); |
265 | } |
|
266 | ||
267 | 71 | if (url != null) |
268 | { |
|
269 | 52 | log.debug("Configuration loaded from the base path " + name); |
270 | } |
|
271 | } |
|
272 | 0 | catch (IOException e) |
273 | { |
|
274 | 0 | e.printStackTrace(); |
275 | 71 | } |
276 | } |
|
277 | ||
278 | ||
279 | // attempt to load from the user home directory |
|
280 | 377 | if (url == null) |
281 | { |
|
282 | try |
|
283 | { |
|
284 | 19 | File file = constructFile(System.getProperty("user.home"), name); |
285 | 19 | if (file != null && file.exists()) |
286 | { |
|
287 | 0 | url = file.toURL(); |
288 | } |
|
289 | ||
290 | 19 | if (url != null) |
291 | { |
|
292 | 0 | log.debug("Configuration loaded from the home path " + name); |
293 | } |
|
294 | ||
295 | } |
|
296 | 0 | catch (IOException e) |
297 | { |
|
298 | 0 | e.printStackTrace(); |
299 | 19 | } |
300 | } |
|
301 | ||
302 | // attempt to load from the context classpath |
|
303 | 377 | if (url == null) |
304 | { |
|
305 | 19 | ClassLoader loader = Thread.currentThread().getContextClassLoader(); |
306 | 19 | url = loader.getResource(name); |
307 | ||
308 | 19 | if (url != null) |
309 | { |
|
310 | 17 | log.debug("Configuration loaded from the context classpath (" + name + ")"); |
311 | } |
|
312 | } |
|
313 | ||
314 | // attempt to load from the system classpath |
|
315 | 377 | if (url == null) |
316 | { |
|
317 | 2 | url = ClassLoader.getSystemResource(name); |
318 | ||
319 | 2 | if (url != null) |
320 | { |
|
321 | 0 | log.debug("Configuration loaded from the system classpath (" + name + ")"); |
322 | } |
|
323 | } |
|
324 | ||
325 | 377 | return url; |
326 | } |
|
327 | ||
328 | /** |
|
329 | * Return the path without the file name, for example http://xyz.net/foo/bar.xml |
|
330 | * results in http://xyz.net/foo/ |
|
331 | * |
|
332 | * @param url |
|
333 | * @return |
|
334 | */ |
|
335 | static String getBasePath(URL url) |
|
336 | { |
|
337 | 264 | String s = url.toString(); |
338 | ||
339 | 264 | if (s.endsWith("/") || StringUtils.isEmpty(url.getPath())) |
340 | { |
|
341 | 3 | return s; |
342 | } |
|
343 | else |
|
344 | { |
|
345 | 261 | return s.substring(0, s.lastIndexOf("/") + 1); |
346 | } |
|
347 | } |
|
348 | ||
349 | /** |
|
350 | * Extract the file name from the specified URL. |
|
351 | */ |
|
352 | static String getFileName(URL url) |
|
353 | { |
|
354 | 80 | if (url == null) |
355 | { |
|
356 | 1 | return null; |
357 | } |
|
358 | ||
359 | 79 | String path = url.getPath(); |
360 | ||
361 | 79 | if (path.endsWith("/") || StringUtils.isEmpty(path)) |
362 | { |
|
363 | 1 | return null; |
364 | } |
|
365 | else |
|
366 | { |
|
367 | 78 | return path.substring(path.lastIndexOf("/") + 1); |
368 | } |
|
369 | } |
|
370 | ||
371 | } |
This report is generated by jcoverage, Maven and Maven JCoverage Plugin. |