Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.configuration.AbstractFileConfiguration |
64% |
90% |

1 |  |
     /*
2 |  |
      * Copyright 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.FileNotFoundException;
21 |  |
     import java.io.FileOutputStream;
22 |  |
     import java.io.IOException;
23 |  |
     import java.io.InputStream;
24 |  |
     import java.io.InputStreamReader;
25 |  |
     import java.io.OutputStream;
26 |  |
     import java.io.OutputStreamWriter;
27 |  |
     import java.io.Reader;
28 |  |
     import java.io.UnsupportedEncodingException;
29 |  |
     import java.io.Writer;
30 |  |
     import java.net.MalformedURLException;
31 |  |
     import java.net.URL;
32 |  |
33 |  |
     /**
34 |  |
      * Partial implementation of the <code>FileConfiguration</code> interface.
35 |  |
      * Developpers of file based configuration may wan't to extend this class,
36 |  |
      * the two methods left to implement are {@see AbstractFileConfiguration#load(Reader)}
37 |  |
      * and {@see AbstractFileConfiguration#save(Reader)}.
38 |  |
      *
39 |  |
      * @author Emmanuel Bourg
40 |  |
      * @version $Revision: 1.4 $, $Date: 2004/10/04 21:45:10 $
41 |  |
      * @since 1.0-rc2
42 |  |
      */
43 | 310 |
     public abstract class AbstractFileConfiguration extends BaseConfiguration implements FileConfiguration
44 |  |
     {
45 |  |
         protected String fileName;
46 |  |
         protected String basePath;
47 |  |
         protected URL url;
48 |  |
49 |  |
         /**
50 |  |
          * Load the configuration from the underlying URL. If the URL is not
51 |  |
          * specified, it attempts to locate the specified file name.
52 |  |
          *
53 |  |
          * @throws ConfigurationException
54 |  |
          */
55 |  |
         public void load() throws ConfigurationException
56 |  |
         {
57 | 309 |
             if (url == null)
58 |  |
             {
59 | 0 |
                 load(fileName);
60 |  |
             }
61 |  |
             else
62 |  |
             {
63 | 309 |
                 load(url);
64 |  |
             }
65 | 309 |
         }
66 |  |
67 |  |
         /**
68 |  |
          * Locate the specified file and load the configuration.
69 |  |
          *
70 |  |
          * @param fileName the name of the file loaded
71 |  |
          *
72 |  |
          * @throws ConfigurationException
73 |  |
          */
74 |  |
         public void load(String fileName) throws ConfigurationException
75 |  |
         {
76 |  |
             try
77 |  |
             {
78 | 1 |
                 URL url = ConfigurationUtils.locate(basePath, fileName);
79 | 1 |
                 load(url);
80 |  |
             }
81 | 0 |
             catch (ConfigurationException e)
82 |  |
             {
83 | 0 |
                 throw e;
84 |  |
             }
85 | 0 |
             catch (Exception e)
86 |  |
             {
87 | 0 |
                 throw new ConfigurationException(e.getMessage(), e);
88 | 1 |
             }
89 | 1 |
         }
90 |  |
91 |  |
         /**
92 |  |
          * Load the configuration from the specified file.
93 |  |
          *
94 |  |
          * @param file the loaded file
95 |  |
          *
96 |  |
          * @throws ConfigurationException
97 |  |
          */
98 |  |
         public void load(File file) throws ConfigurationException
99 |  |
         {
100 |  |
             try
101 |  |
             {
102 | 0 |
                 load(file.toURL());
103 |  |
             }
104 | 0 |
             catch (MalformedURLException e)
105 |  |
             {
106 | 0 |
                 throw new ConfigurationException(e.getMessage(), e);
107 | 0 |
             }
108 | 0 |
         }
109 |  |
110 |  |
         /**
111 |  |
          * Load the configuration from the specified URL.
112 |  |
          *
113 |  |
          * @param url the URL of the file loaded
114 |  |
          *
115 |  |
          * @throws ConfigurationException
116 |  |
          */
117 |  |
         public void load(URL url) throws ConfigurationException
118 |  |
         {
119 | 440 |
             InputStream in = null;
120 |  |
121 |  |
             try
122 |  |
             {
123 | 440 |
                 in = url.openStream();
124 | 440 |
                 load(in);
125 | 440 |
             }
126 | 0 |
             catch (Exception e)
127 |  |
             {
128 | 0 |
                 throw new ConfigurationException(e.getMessage(), e);
129 |  |
             }
130 |  |
             finally
131 |  |
             {
132 |  |
                 // close the input stream
133 | 0 |
                 try
134 |  |
                 {
135 | 440 |
                     if (in != null)
136 |  |
                     {
137 | 440 |
                         in.close();
138 |  |
                     }
139 |  |
                 }
140 | 0 |
                 catch (IOException e)
141 |  |
                 {
142 | 0 |
                     e.printStackTrace();
143 | 880 |
                 }
144 | 440 |
             }
145 | 440 |
         }
146 |  |
147 |  |
         /**
148 |  |
          * Load the configuration from the specified stream, using the default
149 |  |
          * platform specific encoding.
150 |  |
          *
151 |  |
          * @param in the input stream
152 |  |
          *
153 |  |
          * @throws ConfigurationException
154 |  |
          */
155 |  |
         public void load(InputStream in) throws ConfigurationException
156 |  |
         {
157 | 440 |
             load(in, null);
158 | 440 |
         }
159 |  |
160 |  |
         /**
161 |  |
          * Load the configuration from the specified stream, using the specified
162 |  |
          * encoding. If the encoding is null the default encoding is used.
163 |  |
          *
164 |  |
          * @param in the input stream
165 |  |
          * @param encoding the encoding used. <code>null</code> to use the default encoding
166 |  |
          *
167 |  |
          * @throws ConfigurationException
168 |  |
          */
169 |  |
         public void load(InputStream in, String encoding) throws ConfigurationException
170 |  |
         {
171 | 440 |
             Reader reader = null;
172 |  |
173 | 440 |
             if (encoding != null)
174 |  |
             {
175 |  |
                 try
176 |  |
                 {
177 | 0 |
                     reader = new InputStreamReader(in, encoding);
178 |  |
                 }
179 | 0 |
                 catch (UnsupportedEncodingException e)
180 |  |
                 {
181 | 0 |
                     throw new ConfigurationException("The requested encoding is not supported, try the default encoding.", e);
182 | 0 |
                 }
183 |  |
             }
184 |  |
185 | 440 |
             if (reader == null)
186 |  |
             {
187 | 440 |
                 reader = new InputStreamReader(in);
188 |  |
             }
189 |  |
190 | 440 |
             load(reader);
191 | 440 |
         }
192 |  |
193 |  |
         /**
194 |  |
          * Save the configuration.
195 |  |
          *
196 |  |
          * @throws ConfigurationException
197 |  |
          */
198 |  |
         public void save() throws ConfigurationException
199 |  |
         {
200 | 4 |
             save(fileName);
201 | 3 |
         }
202 |  |
203 |  |
         /**
204 |  |
          * Save the configuration to the specified file. This doesn't change the
205 |  |
          * source of the configuration, use setFileName() if you need it.
206 |  |
          *
207 |  |
          * @param fileName
208 |  |
          *
209 |  |
          * @throws ConfigurationException
210 |  |
          */
211 |  |
         public void save(String fileName) throws ConfigurationException
212 |  |
         {
213 |  |
             try
214 |  |
             {
215 |  |
                 // create a new file
216 | 6 |
                 save(ConfigurationUtils.constructFile(basePath, fileName));
217 |  |
             }
218 | 0 |
             catch (ConfigurationException e)
219 |  |
             {
220 | 0 |
                 throw e;
221 |  |
             }
222 | 1 |
             catch (Exception e)
223 |  |
             {
224 | 1 |
                 throw new ConfigurationException(e.getMessage(), e);
225 | 5 |
             }
226 | 5 |
         }
227 |  |
228 |  |
         /**
229 |  |
          * Save the configuration to the specified URL if it's a file URL.
230 |  |
          * This doesn't change the source of the configuration, use setURL()
231 |  |
          * if you need it.
232 |  |
          *
233 |  |
          * @param url
234 |  |
          *
235 |  |
          * @throws ConfigurationException
236 |  |
          */
237 |  |
         public void save(URL url) throws ConfigurationException
238 |  |
         {
239 | 0 |
             if ("file".equals(url.getProtocol()))
240 |  |
             {
241 | 0 |
                 save(new File(url.getFile()));
242 |  |
             }
243 | 0 |
         }
244 |  |
245 |  |
         /**
246 |  |
          * Save the configuration to the specified file. This doesn't change the
247 |  |
          * source of the configuration, use setFile() if you need it.
248 |  |
          *
249 |  |
          * @param file
250 |  |
          *
251 |  |
          * @throws ConfigurationException
252 |  |
          */
253 |  |
         public void save(File file) throws ConfigurationException
254 |  |
         {
255 | 5 |
             OutputStream out = null;
256 |  |
257 |  |
             try
258 |  |
             {
259 | 5 |
                 out = new FileOutputStream(file);
260 | 5 |
                 save(out);
261 | 5 |
             }
262 | 0 |
             catch (FileNotFoundException e)
263 |  |
             {
264 | 0 |
                 e.printStackTrace();
265 | 0 |
             }
266 |  |
             finally
267 |  |
             {
268 |  |
                 // close the output stream
269 | 0 |
                 try
270 |  |
                 {
271 | 5 |
                     if (out != null)
272 |  |
                     {
273 | 5 |
                         out.close();
274 |  |
                     }
275 |  |
                 }
276 | 0 |
                 catch (IOException e)
277 |  |
                 {
278 | 0 |
                     e.printStackTrace();
279 | 10 |
                 }
280 | 5 |
             }
281 | 5 |
         }
282 |  |
283 |  |
         /**
284 |  |
          * Save the configuration to the specified stream.
285 |  |
          *
286 |  |
          * @param out
287 |  |
          *
288 |  |
          * @throws ConfigurationException
289 |  |
          */
290 |  |
         public void save(OutputStream out) throws ConfigurationException
291 |  |
         {
292 | 5 |
             save(out, null);
293 | 5 |
         }
294 |  |
295 |  |
         /**
296 |  |
          * Save the configuration to the specified stream, using the specified
297 |  |
          * encoding. If the encoding is null the default encoding is used.
298 |  |
          *
299 |  |
          * @param out
300 |  |
          * @param encoding
301 |  |
          * @throws ConfigurationException
302 |  |
          */
303 |  |
         public void save(OutputStream out, String encoding) throws ConfigurationException
304 |  |
         {
305 | 5 |
             Writer writer = null;
306 |  |
307 | 5 |
             if (encoding != null)
308 |  |
             {
309 |  |
                 try
310 |  |
                 {
311 | 0 |
                     writer = new OutputStreamWriter(out, encoding);
312 |  |
                 }
313 | 0 |
                 catch (UnsupportedEncodingException e)
314 |  |
                 {
315 | 0 |
                     throw new ConfigurationException("The requested encoding is not supported, try the default encoding.", e);
316 | 0 |
                 }
317 |  |
             }
318 |  |
319 | 5 |
             if (writer == null)
320 |  |
             {
321 | 5 |
                 writer = new OutputStreamWriter(out);
322 |  |
             }
323 |  |
324 | 5 |
             save(writer);
325 | 5 |
         }
326 |  |
327 |  |
         /**
328 |  |
          * Return the name of the file.
329 |  |
          */
330 |  |
         public String getFileName()
331 |  |
         {
332 | 15 |
             return fileName;
333 |  |
         }
334 |  |
335 |  |
         /**
336 |  |
          * Set the name of the file.
337 |  |
          *
338 |  |
          * @param fileName the name of the file
339 |  |
          */
340 |  |
         public void setFileName(String fileName)
341 |  |
         {
342 | 48 |
             this.fileName = fileName;
343 |  |
344 |  |
             // update the URL
345 | 48 |
             url = ConfigurationUtils.locate(basePath, fileName);
346 | 48 |
         }
347 |  |
348 |  |
         /**
349 |  |
          * Return the base path.
350 |  |
          */
351 |  |
         public String getBasePath()
352 |  |
         {
353 | 134 |
             return basePath;
354 |  |
         }
355 |  |
356 |  |
         /**
357 |  |
          * Set the base path. Relative configurations are loaded from this path.
358 |  |
          *
359 |  |
          * @param basePath the base path.
360 |  |
          */
361 |  |
         public void setBasePath(String basePath)
362 |  |
         {
363 | 220 |
             this.basePath = basePath;
364 |  |
365 |  |
             // todo: update the url
366 | 220 |
         }
367 |  |
368 |  |
         /**
369 |  |
          * Return the file where the configuration is stored.
370 |  |
          */
371 |  |
         public File getFile()
372 |  |
         {
373 | 3 |
             if (url != null && "file".equals(url.getProtocol()))
374 |  |
             {
375 | 1 |
                 return new File(url.getFile());
376 |  |
             }
377 |  |
             else
378 |  |
             {
379 | 2 |
                 return ConfigurationUtils.constructFile(getBasePath(), getFileName());
380 |  |
             }
381 |  |
         }
382 |  |
383 |  |
         /**
384 |  |
          * Set the file where the configuration is stored.
385 |  |
          *
386 |  |
          * @param file
387 |  |
          */
388 |  |
         public void setFile(File file)
389 |  |
         {
390 | 75 |
             if (file != null)
391 |  |
             {
392 |  |
                 try
393 |  |
                 {
394 | 75 |
                     setURL(file.toURL());
395 |  |
                 }
396 | 0 |
                 catch (MalformedURLException e)
397 |  |
                 {
398 | 0 |
                     e.printStackTrace();
399 | 75 |
                 }
400 |  |
             }
401 |  |
             else
402 |  |
             {
403 | 0 |
                 url = null;
404 |  |
             }
405 | 75 |
         }
406 |  |
407 |  |
         /**
408 |  |
          * Return the URL where the configuration is stored.
409 |  |
          */
410 |  |
         public URL getURL()
411 |  |
         {
412 | 0 |
             return url;
413 |  |
         }
414 |  |
415 |  |
         /**
416 |  |
          * The URL where the configuration is stored.
417 |  |
          *
418 |  |
          * @param url
419 |  |
          */
420 |  |
         public void setURL(URL url)
421 |  |
         {
422 | 77 |
             this.url = url;
423 |  |
424 |  |
             // update the base path
425 | 77 |
             basePath = ConfigurationUtils.getBasePath(url);
426 | 77 |
             if (basePath != null && basePath.startsWith("file:"))
427 |  |
             {
428 | 76 |
                 basePath = basePath.substring(5);
429 |  |
             }
430 |  |
431 |  |
             // update the file name
432 | 77 |
             fileName = ConfigurationUtils.getFileName(url);
433 | 77 |
         }
434 |  |
     }

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