Coverage report

  %line %branch
org.apache.commons.configuration.XMLPropertiesConfiguration$1
100% 
100% 

 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.PrintWriter;
 21  
 import java.io.Reader;
 22  
 import java.io.Writer;
 23  
 import java.net.URL;
 24  
 import java.util.Iterator;
 25  
 import java.util.List;
 26  
 
 27  
 import org.apache.commons.digester.Digester;
 28  
 import org.apache.commons.lang.StringEscapeUtils;
 29  
 import org.apache.commons.lang.StringUtils;
 30  
 import org.xml.sax.EntityResolver;
 31  
 import org.xml.sax.InputSource;
 32  
 
 33  
 /**
 34  
  * This configuration implements the XML properties format introduced in Java
 35  
  * 5.0, see http://java.sun.com/j2se/1.5.0/docs/api/java/util/Properties.html.
 36  
  * An XML properties file looks like this:
 37  
  *
 38  
  * <pre>
 39  
  * &lt;?xml version="1.0"?>
 40  
  * &lt;!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
 41  
  * &lt;properties>
 42  
  *   &lt;comment>Description of the property list&lt;/comment>
 43  
  *   &lt;entry key="key1">value1&lt;/entry>
 44  
  *   &lt;entry key="key2">value2&lt;/entry>
 45  
  *   &lt;entry key="key3">value3&lt;/entry>
 46  
  * &lt;/properties>
 47  
  * &lt;/pre>
 48  
  *
 49  
  * The Java 5.0 runtime is not required to use this class. The default encoding
 50  
  * for this configuration format is UTF-8. Note that unlike
 51  
  * <code>PropertiesConfiguration</code>, <code>XMLPropertiesConfiguration</code>
 52  
  * does not support includes.
 53  
  *
 54  
  * @since 1.1
 55  
  *
 56  
  * @author Emmanuel Bourg
 57  
  * @version $Revision: 155408 $, $Date: 2005-02-26 13:56:39 +0100 (Sa, 26 Feb 2005) $
 58  
  */
 59  
 public class XMLPropertiesConfiguration extends PropertiesConfiguration
 60  
 {
 61  
     /**
 62  
      * The default encoding (UTF-8 as specified by http://java.sun.com/j2se/1.5.0/docs/api/java/util/Properties.html)
 63  
      */
 64  
     private static final String DEFAULT_ENCODING = "UTF-8";
 65  
 
 66  
     // initialization block to set the encoding before loading the file in the constructors
 67  
     {
 68  
         setEncoding(DEFAULT_ENCODING);
 69  
     }
 70  
 
 71  
     /**
 72  
      * Creates an empty XMLPropertyConfiguration object which can be
 73  
      * used to synthesize a new Properties file by adding values and
 74  
      * then saving(). An object constructed by this C'tor can not be
 75  
      * tickled into loading included files because it cannot supply a
 76  
      * base for relative includes.
 77  
      */
 78  
     public XMLPropertiesConfiguration()
 79  
     {
 80  
         super();
 81  
     }
 82  
 
 83  
     /**
 84  
      * Creates and loads the xml properties from the specified file.
 85  
      * The specified file can contain "include" properties which then
 86  
      * are loaded and merged into the properties.
 87  
      *
 88  
      * @param fileName The name of the properties file to load.
 89  
      * @throws ConfigurationException Error while loading the properties file
 90  
      */
 91  
     public XMLPropertiesConfiguration(String fileName) throws ConfigurationException
 92  
     {
 93  
         super(fileName);
 94  
     }
 95  
 
 96  
     /**
 97  
      * Creates and loads the xml properties from the specified file.
 98  
      * The specified file can contain "include" properties which then
 99  
      * are loaded and merged into the properties.
 100  
      *
 101  
      * @param file The properties file to load.
 102  
      * @throws ConfigurationException Error while loading the properties file
 103  
      */
 104  
     public XMLPropertiesConfiguration(File file) throws ConfigurationException
 105  
     {
 106  
         super(file);
 107  
     }
 108  
 
 109  
     /**
 110  
      * Creates and loads the xml properties from the specified URL.
 111  
      * The specified file can contain "include" properties which then
 112  
      * are loaded and merged into the properties.
 113  
      *
 114  
      * @param url The location of the properties file to load.
 115  
      * @throws ConfigurationException Error while loading the properties file
 116  
      */
 117  
     public XMLPropertiesConfiguration(URL url) throws ConfigurationException
 118  
     {
 119  
         super(url);
 120  
     }
 121  
 
 122  
     public void load(Reader in) throws ConfigurationException
 123  
     {
 124  
         // todo: replace with a pure SAX implementation to reduce the dependencies
 125  
 
 126  
         // set up the digester
 127  
         Digester digester = new Digester();
 128  
         digester.setEntityResolver(new EntityResolver(){
 129  69
             public InputSource resolveEntity(String class="keyword">publicId, String systemId)
 130  
             {
 131  69
                 return new InputSource(getClass().getClassLoader().getResourceAsStream("properties.dtd"));
 132  
             }
 133  
         });
 134  
 
 135  
         digester.addCallMethod("properties/comment", "setHeader", 0);
 136  
 
 137  
         digester.addCallMethod("properties/entry", "addProperty", 2);
 138  
         digester.addCallParam("properties/entry", 0, "key");
 139  
         digester.addCallParam("properties/entry", 1);
 140  
 
 141  
         // todo: support included properties ?
 142  
 
 143  
         // parse the file
 144  
         digester.push(this);
 145  
         try
 146  
         {
 147  
             digester.parse(in);
 148  
         }
 149  
         catch (Exception e)
 150  
         {
 151  
             throw new ConfigurationException("Unable to parse the configuration file", e);
 152  
         }
 153  
     }
 154  
 
 155  
     public void save(Writer out) throws ConfigurationException
 156  
     {
 157  
         PrintWriter writer = new PrintWriter(out);
 158  
 
 159  
         String encoding = getEncoding() != null ? getEncoding() : DEFAULT_ENCODING;
 160  
         writer.println("<?xml version=\ŕ.0\" encoding=\"" + encoding + "\"?>");
 161  
         writer.println("<!DOCTYPE properties SYSTEM \"http://java.sun.com/dtd/properties.dtd\">");
 162  
         writer.println("<properties>");
 163  
 
 164  
         if (getHeader() != null)
 165  
         {
 166  
             writer.println("  <comment>" + StringEscapeUtils.escapeXml(getHeader()) + "</comment>");
 167  
         }
 168  
 
 169  
         Iterator keys = getKeys();
 170  
         while (keys.hasNext())
 171  
         {
 172  
             String key = (String) keys.next();
 173  
             Object value = getProperty(key);
 174  
 
 175  
             if (value instanceof List)
 176  
             {
 177  
                 writeProperty(writer, key, (List) value);
 178  
             }
 179  
             else
 180  
             {
 181  
                 writeProperty(writer, key, value);
 182  
             }
 183  
         }
 184  
 
 185  
         writer.println("</properties>");
 186  
         writer.flush();
 187  
     }
 188  
 
 189  
     /**
 190  
      * Write a property.
 191  
      */
 192  
     private void writeProperty(PrintWriter out, String key, Object value)
 193  
     {
 194  
         // escape the key
 195  
         String k = StringEscapeUtils.escapeXml(key);
 196  
 
 197  
         if (value != null)
 198  
         {
 199  
             // escape the value
 200  
             String v = StringEscapeUtils.escapeXml(String.valueOf(value));
 201  
             v = StringUtils.replace(v, String.valueOf(getDelimiter()), "\\" + getDelimiter());
 202  
 
 203  
             out.println("  <entry key=\"" + k + "\">" + v + "</entry>");
 204  
         }
 205  
         else
 206  
         {
 207  
             out.println("  <entry key=\"" + k + "\"/>");
 208  
         }
 209  
     }
 210  
 
 211  
     /**
 212  
      * Write a list property.
 213  
      */
 214  
     private void writeProperty(PrintWriter out, String key, List values)
 215  
     {
 216  
         for (int i = 0; i < values.size(); i++)
 217  
         {
 218  
             writeProperty(out, key, values.get(i));
 219  
         }
 220  
     }
 221  
 }

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