Coverage report

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

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

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