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.