Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
PropertiesConfiguration |
|
| 2.575;2,575 | ||||
PropertiesConfiguration$PropertiesReader |
|
| 2.575;2,575 | ||||
PropertiesConfiguration$PropertiesWriter |
|
| 2.575;2,575 |
1 | /* | |
2 | * Licensed to the Apache Software Foundation (ASF) under one or more | |
3 | * contributor license agreements. See the NOTICE file distributed with | |
4 | * this work for additional information regarding copyright ownership. | |
5 | * The ASF licenses this file to You under the Apache License, Version 2.0 | |
6 | * (the "License"); you may not use this file except in compliance with | |
7 | * the License. You may obtain a copy of the License at | |
8 | * | |
9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
10 | * | |
11 | * Unless required by applicable law or agreed to in writing, software | |
12 | * distributed under the License is distributed on an "AS IS" BASIS, | |
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
14 | * See the License for the specific language governing permissions and | |
15 | * limitations under the License. | |
16 | */ | |
17 | ||
18 | package org.apache.commons.configuration; | |
19 | ||
20 | import java.io.File; | |
21 | import java.io.FilterWriter; | |
22 | import java.io.IOException; | |
23 | import java.io.LineNumberReader; | |
24 | import java.io.Reader; | |
25 | import java.io.Writer; | |
26 | import java.net.URL; | |
27 | import java.util.ArrayList; | |
28 | import java.util.Iterator; | |
29 | import java.util.List; | |
30 | ||
31 | import org.apache.commons.lang.ArrayUtils; | |
32 | import org.apache.commons.lang.StringEscapeUtils; | |
33 | import org.apache.commons.lang.StringUtils; | |
34 | ||
35 | /** | |
36 | * This is the "classic" Properties loader which loads the values from | |
37 | * a single or multiple files (which can be chained with "include =". | |
38 | * All given path references are either absolute or relative to the | |
39 | * file name supplied in the constructor. | |
40 | * <p> | |
41 | * In this class, empty PropertyConfigurations can be built, properties | |
42 | * added and later saved. include statements are (obviously) not supported | |
43 | * if you don't construct a PropertyConfiguration from a file. | |
44 | * | |
45 | * <p>The properties file syntax is explained here, basically it follows | |
46 | * the syntax of the stream parsed by {@link java.util.Properties#load} and | |
47 | * adds several useful extensions: | |
48 | * | |
49 | * <ul> | |
50 | * <li> | |
51 | * Each property has the syntax <code>key <separator> value</code>. The | |
52 | * separators accepted are <code>'='</code>, <code>':'</code> and any white | |
53 | * space character. Examples: | |
54 | * <pre> | |
55 | * key1 = value1 | |
56 | * key2 : value2 | |
57 | * key3 value3</pre> | |
58 | * </li> | |
59 | * <li> | |
60 | * The <i>key</i> may use any character, separators must be escaped: | |
61 | * <pre> | |
62 | * key\:foo = bar</pre> | |
63 | * </li> | |
64 | * <li> | |
65 | * <i>value</i> may be separated on different lines if a backslash | |
66 | * is placed at the end of the line that continues below. | |
67 | * </li> | |
68 | * <li> | |
69 | * <i>value</i> can contain <em>value delimiters</em> and will then be interpreted | |
70 | * as a list of tokens. Default value delimiter is the comma ','. So the | |
71 | * following property definition | |
72 | * <pre> | |
73 | * key = This property, has multiple, values | |
74 | * </pre> | |
75 | * will result in a property with three values. You can change the value | |
76 | * delimiter using the <code>{@link AbstractConfiguration#setListDelimiter(char)}</code> | |
77 | * method. Setting the delimiter to 0 will disable value splitting completely. | |
78 | * </li> | |
79 | * <li> | |
80 | * Commas in each token are escaped placing a backslash right before | |
81 | * the comma. | |
82 | * </li> | |
83 | * <li> | |
84 | * If a <i>key</i> is used more than once, the values are appended | |
85 | * like if they were on the same line separated with commas. <em>Note</em>: | |
86 | * When the configuration file is written back to disk the associated | |
87 | * <code>{@link PropertiesConfigurationLayout}</code> object (see below) will | |
88 | * try to preserve as much of the original format as possible, i.e. properties | |
89 | * with multiple values defined on a single line will also be written back on | |
90 | * a single line, and multiple occurrences of a single key will be written on | |
91 | * multiple lines. If the <code>addProperty()</code> method was called | |
92 | * multiple times for adding multiple values to a property, these properties | |
93 | * will per default be written on multiple lines in the output file, too. | |
94 | * Some options of the <code>PropertiesConfigurationLayout</code> class have | |
95 | * influence on that behavior. | |
96 | * </li> | |
97 | * <li> | |
98 | * Blank lines and lines starting with character '#' or '!' are skipped. | |
99 | * </li> | |
100 | * <li> | |
101 | * If a property is named "include" (or whatever is defined by | |
102 | * setInclude() and getInclude() and the value of that property is | |
103 | * the full path to a file on disk, that file will be included into | |
104 | * the configuration. You can also pull in files relative to the parent | |
105 | * configuration file. So if you have something like the following: | |
106 | * | |
107 | * include = additional.properties | |
108 | * | |
109 | * Then "additional.properties" is expected to be in the same | |
110 | * directory as the parent configuration file. | |
111 | * | |
112 | * The properties in the included file are added to the parent configuration, | |
113 | * they do not replace existing properties with the same key. | |
114 | * | |
115 | * </li> | |
116 | * </ul> | |
117 | * | |
118 | * <p>Here is an example of a valid extended properties file: | |
119 | * | |
120 | * <p><pre> | |
121 | * # lines starting with # are comments | |
122 | * | |
123 | * # This is the simplest property | |
124 | * key = value | |
125 | * | |
126 | * # A long property may be separated on multiple lines | |
127 | * longvalue = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \ | |
128 | * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa | |
129 | * | |
130 | * # This is a property with many tokens | |
131 | * tokens_on_a_line = first token, second token | |
132 | * | |
133 | * # This sequence generates exactly the same result | |
134 | * tokens_on_multiple_lines = first token | |
135 | * tokens_on_multiple_lines = second token | |
136 | * | |
137 | * # commas may be escaped in tokens | |
138 | * commas.escaped = Hi\, what'up? | |
139 | * | |
140 | * # properties can reference other properties | |
141 | * base.prop = /base | |
142 | * first.prop = ${base.prop}/first | |
143 | * second.prop = ${first.prop}/second | |
144 | * </pre> | |
145 | * | |
146 | * <p>A <code>PropertiesConfiguration</code> object is associated with an | |
147 | * instance of the <code>{@link PropertiesConfigurationLayout}</code> class, | |
148 | * which is responsible for storing the layout of the parsed properties file | |
149 | * (i.e. empty lines, comments, and such things). The <code>getLayout()</code> | |
150 | * method can be used to obtain this layout object. With <code>setLayout()</code> | |
151 | * a new layout object can be set. This should be done before a properties file | |
152 | * was loaded. | |
153 | * <p><em>Note:</em>Configuration objects of this type can be read concurrently | |
154 | * by multiple threads. However if one of these threads modifies the object, | |
155 | * synchronization has to be performed manually. | |
156 | * | |
157 | * @see java.util.Properties#load | |
158 | * | |
159 | * @author <a href="mailto:stefano@apache.org">Stefano Mazzocchi</a> | |
160 | * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a> | |
161 | * @author <a href="mailto:daveb@miceda-data">Dave Bryson</a> | |
162 | * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> | |
163 | * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a> | |
164 | * @author <a href="mailto:kjohnson@transparent.com">Kent Johnson</a> | |
165 | * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a> | |
166 | * @author <a href="mailto:ipriha@surfeu.fi">Ilkka Priha</a> | |
167 | * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> | |
168 | * @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl</a> | |
169 | * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a> | |
170 | * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a> | |
171 | * @author Oliver Heger | |
172 | * @author <a href="mailto:ebourg@apache.org">Emmanuel Bourg</a> | |
173 | * @version $Id: PropertiesConfiguration.java 727168 2008-12-16 21:44:29Z oheger $ | |
174 | */ | |
175 | 4222153 | public class PropertiesConfiguration extends AbstractFileConfiguration |
176 | { | |
177 | /** Constant for the supported comment characters.*/ | |
178 | static final String COMMENT_CHARS = "#!"; | |
179 | ||
180 | /** | |
181 | * This is the name of the property that can point to other | |
182 | * properties file for including other properties files. | |
183 | */ | |
184 | 24 | private static String include = "include"; |
185 | ||
186 | /** The list of possible key/value separators */ | |
187 | 24 | private static final char[] SEPARATORS = new char[] {'=', ':'}; |
188 | ||
189 | /** The white space characters used as key/value separators. */ | |
190 | 24 | private static final char[] WHITE_SPACE = new char[]{' ', '\t', '\f'}; |
191 | ||
192 | /** | |
193 | * The default encoding (ISO-8859-1 as specified by | |
194 | * http://java.sun.com/j2se/1.5.0/docs/api/java/util/Properties.html) | |
195 | */ | |
196 | private static final String DEFAULT_ENCODING = "ISO-8859-1"; | |
197 | ||
198 | /** Constant for the platform specific line separator.*/ | |
199 | 24 | private static final String LINE_SEPARATOR = System.getProperty("line.separator"); |
200 | ||
201 | /** Constant for the escaping character.*/ | |
202 | private static final String ESCAPE = "\\"; | |
203 | ||
204 | /** Constant for the radix of hex numbers.*/ | |
205 | private static final int HEX_RADIX = 16; | |
206 | ||
207 | /** Constant for the length of a unicode literal.*/ | |
208 | private static final int UNICODE_LEN = 4; | |
209 | ||
210 | /** Stores the layout object.*/ | |
211 | private PropertiesConfigurationLayout layout; | |
212 | ||
213 | /** Allow file inclusion or not */ | |
214 | private boolean includesAllowed; | |
215 | ||
216 | /** | |
217 | * Creates an empty PropertyConfiguration object which can be | |
218 | * used to synthesize a new Properties file by adding values and | |
219 | * then saving(). | |
220 | */ | |
221 | public PropertiesConfiguration() | |
222 | 189 | { |
223 | 189 | layout = createLayout(); |
224 | 189 | setIncludesAllowed(false); |
225 | 189 | } |
226 | ||
227 | /** | |
228 | * Creates and loads the extended properties from the specified file. | |
229 | * The specified file can contain "include = " properties which then | |
230 | * are loaded and merged into the properties. | |
231 | * | |
232 | * @param fileName The name of the properties file to load. | |
233 | * @throws ConfigurationException Error while loading the properties file | |
234 | */ | |
235 | public PropertiesConfiguration(String fileName) throws ConfigurationException | |
236 | { | |
237 | 270 | super(fileName); |
238 | 268 | } |
239 | ||
240 | /** | |
241 | * Creates and loads the extended properties from the specified file. | |
242 | * The specified file can contain "include = " properties which then | |
243 | * are loaded and merged into the properties. If the file does not exist, | |
244 | * an empty configuration will be created. Later the <code>save()</code> | |
245 | * method can be called to save the properties to the specified file. | |
246 | * | |
247 | * @param file The properties file to load. | |
248 | * @throws ConfigurationException Error while loading the properties file | |
249 | */ | |
250 | public PropertiesConfiguration(File file) throws ConfigurationException | |
251 | { | |
252 | 21 | super(file); |
253 | ||
254 | // If the file does not exist, no layout object was created. We have to | |
255 | // do this manually in this case. | |
256 | 20 | getLayout(); |
257 | 20 | } |
258 | ||
259 | /** | |
260 | * Creates and loads the extended properties from the specified URL. | |
261 | * The specified file can contain "include = " properties which then | |
262 | * are loaded and merged into the properties. | |
263 | * | |
264 | * @param url The location of the properties file to load. | |
265 | * @throws ConfigurationException Error while loading the properties file | |
266 | */ | |
267 | public PropertiesConfiguration(URL url) throws ConfigurationException | |
268 | { | |
269 | 2 | super(url); |
270 | 2 | } |
271 | ||
272 | /** | |
273 | * Gets the property value for including other properties files. | |
274 | * By default it is "include". | |
275 | * | |
276 | * @return A String. | |
277 | */ | |
278 | public static String getInclude() | |
279 | { | |
280 | 246560 | return PropertiesConfiguration.include; |
281 | } | |
282 | ||
283 | /** | |
284 | * Sets the property value for including other properties files. | |
285 | * By default it is "include". | |
286 | * | |
287 | * @param inc A String. | |
288 | */ | |
289 | public static void setInclude(String inc) | |
290 | { | |
291 | 2 | PropertiesConfiguration.include = inc; |
292 | 2 | } |
293 | ||
294 | /** | |
295 | * Controls whether additional files can be loaded by the include = <xxx> | |
296 | * statement or not. Base rule is, that objects created by the empty | |
297 | * C'tor can not have included files. | |
298 | * | |
299 | * @param includesAllowed includesAllowed True if Includes are allowed. | |
300 | */ | |
301 | protected void setIncludesAllowed(boolean includesAllowed) | |
302 | { | |
303 | 592 | this.includesAllowed = includesAllowed; |
304 | 592 | } |
305 | ||
306 | /** | |
307 | * Reports the status of file inclusion. | |
308 | * | |
309 | * @return True if include files are loaded. | |
310 | */ | |
311 | public boolean getIncludesAllowed() | |
312 | { | |
313 | 4399 | return this.includesAllowed; |
314 | } | |
315 | ||
316 | /** | |
317 | * Return the comment header. | |
318 | * | |
319 | * @return the comment header | |
320 | * @since 1.1 | |
321 | */ | |
322 | public String getHeader() | |
323 | { | |
324 | 4 | return getLayout().getHeaderComment(); |
325 | } | |
326 | ||
327 | /** | |
328 | * Set the comment header. | |
329 | * | |
330 | * @param header the header to use | |
331 | * @since 1.1 | |
332 | */ | |
333 | public void setHeader(String header) | |
334 | { | |
335 | 14 | getLayout().setHeaderComment(header); |
336 | 14 | } |
337 | ||
338 | /** | |
339 | * Returns the encoding to be used when loading or storing configuration | |
340 | * data. This implementation ensures that the default encoding will be used | |
341 | * if none has been set explicitly. | |
342 | * | |
343 | * @return the encoding | |
344 | */ | |
345 | public String getEncoding() | |
346 | { | |
347 | 6809 | String enc = super.getEncoding(); |
348 | 6809 | return (enc != null) ? enc : DEFAULT_ENCODING; |
349 | } | |
350 | ||
351 | /** | |
352 | * Returns the associated layout object. | |
353 | * | |
354 | * @return the associated layout object | |
355 | * @since 1.3 | |
356 | */ | |
357 | public synchronized PropertiesConfigurationLayout getLayout() | |
358 | { | |
359 | 6846 | if (layout == null) |
360 | { | |
361 | 290 | layout = createLayout(); |
362 | } | |
363 | 6846 | return layout; |
364 | } | |
365 | ||
366 | /** | |
367 | * Sets the associated layout object. | |
368 | * | |
369 | * @param layout the new layout object; can be <b>null</b>, then a new | |
370 | * layout object will be created | |
371 | * @since 1.3 | |
372 | */ | |
373 | public synchronized void setLayout(PropertiesConfigurationLayout layout) | |
374 | { | |
375 | // only one layout must exist | |
376 | 42 | if (this.layout != null) |
377 | { | |
378 | 42 | removeConfigurationListener(this.layout); |
379 | } | |
380 | ||
381 | 42 | if (layout == null) |
382 | { | |
383 | 1 | this.layout = createLayout(); |
384 | } | |
385 | else | |
386 | { | |
387 | 41 | this.layout = layout; |
388 | } | |
389 | 42 | } |
390 | ||
391 | /** | |
392 | * Creates the associated layout object. This method is invoked when the | |
393 | * layout object is accessed and has not been created yet. Derived classes | |
394 | * can override this method to hook in a different layout implementation. | |
395 | * | |
396 | * @return the layout object to use | |
397 | * @since 1.3 | |
398 | */ | |
399 | protected PropertiesConfigurationLayout createLayout() | |
400 | { | |
401 | 480 | return new PropertiesConfigurationLayout(this); |
402 | } | |
403 | ||
404 | /** | |
405 | * Load the properties from the given reader. | |
406 | * Note that the <code>clear()</code> method is not called, so | |
407 | * the properties contained in the loaded file will be added to the | |
408 | * actual set of properties. | |
409 | * | |
410 | * @param in An InputStream. | |
411 | * | |
412 | * @throws ConfigurationException if an error occurs | |
413 | */ | |
414 | public synchronized void load(Reader in) throws ConfigurationException | |
415 | { | |
416 | 6762 | boolean oldAutoSave = isAutoSave(); |
417 | 6762 | setAutoSave(false); |
418 | ||
419 | try | |
420 | { | |
421 | 6762 | getLayout().load(in); |
422 | } | |
423 | finally | |
424 | { | |
425 | 6762 | setAutoSave(oldAutoSave); |
426 | 6761 | } |
427 | 6761 | } |
428 | ||
429 | /** | |
430 | * Save the configuration to the specified stream. | |
431 | * | |
432 | * @param writer the output stream used to save the configuration | |
433 | * @throws ConfigurationException if an error occurs | |
434 | */ | |
435 | public void save(Writer writer) throws ConfigurationException | |
436 | { | |
437 | 36 | enterNoReload(); |
438 | try | |
439 | { | |
440 | 36 | getLayout().save(writer); |
441 | } | |
442 | finally | |
443 | { | |
444 | 36 | exitNoReload(); |
445 | 36 | } |
446 | 36 | } |
447 | ||
448 | /** | |
449 | * Extend the setBasePath method to turn includes | |
450 | * on and off based on the existence of a base path. | |
451 | * | |
452 | * @param basePath The new basePath to set. | |
453 | */ | |
454 | public void setBasePath(String basePath) | |
455 | { | |
456 | 402 | super.setBasePath(basePath); |
457 | 402 | setIncludesAllowed(StringUtils.isNotEmpty(basePath)); |
458 | 402 | } |
459 | ||
460 | /** | |
461 | * Creates a copy of this object. | |
462 | * | |
463 | * @return the copy | |
464 | */ | |
465 | public Object clone() | |
466 | { | |
467 | 4 | PropertiesConfiguration copy = (PropertiesConfiguration) super.clone(); |
468 | 4 | if (layout != null) |
469 | { | |
470 | 4 | copy.setLayout(new PropertiesConfigurationLayout(copy, layout)); |
471 | } | |
472 | 4 | return copy; |
473 | } | |
474 | ||
475 | /** | |
476 | * This method is invoked by the associated | |
477 | * <code>{@link PropertiesConfigurationLayout}</code> object for each | |
478 | * property definition detected in the parsed properties file. Its task is | |
479 | * to check whether this is a special property definition (e.g. the | |
480 | * <code>include</code> property). If not, the property must be added to | |
481 | * this configuration. The return value indicates whether the property | |
482 | * should be treated as a normal property. If it is <b>false</b>, the | |
483 | * layout object will ignore this property. | |
484 | * | |
485 | * @param key the property key | |
486 | * @param value the property value | |
487 | * @return a flag whether this is a normal property | |
488 | * @throws ConfigurationException if an error occurs | |
489 | * @since 1.3 | |
490 | */ | |
491 | boolean propertyLoaded(String key, String value) | |
492 | throws ConfigurationException | |
493 | { | |
494 | boolean result; | |
495 | ||
496 | 123275 | if (StringUtils.isNotEmpty(getInclude()) |
497 | && key.equalsIgnoreCase(getInclude())) | |
498 | { | |
499 | 4399 | if (getIncludesAllowed()) |
500 | { | |
501 | String[] files; | |
502 | 4398 | if (!isDelimiterParsingDisabled()) |
503 | { | |
504 | 4396 | files = StringUtils.split(value, getListDelimiter()); |
505 | } | |
506 | else | |
507 | { | |
508 | 2 | files = new String[]{value}; |
509 | } | |
510 | 8796 | for (int i = 0; i < files.length; i++) |
511 | { | |
512 | 4399 | loadIncludeFile(interpolate(files[i].trim())); |
513 | } | |
514 | } | |
515 | 4398 | result = false; |
516 | } | |
517 | ||
518 | else | |
519 | { | |
520 | 118876 | addProperty(key, value); |
521 | 118876 | result = true; |
522 | } | |
523 | ||
524 | 123274 | return result; |
525 | } | |
526 | ||
527 | /** | |
528 | * Tests whether a line is a comment, i.e. whether it starts with a comment | |
529 | * character. | |
530 | * | |
531 | * @param line the line | |
532 | * @return a flag if this is a comment line | |
533 | * @since 1.3 | |
534 | */ | |
535 | static boolean isCommentLine(String line) | |
536 | { | |
537 | 248273 | String s = line.trim(); |
538 | // blanc lines are also treated as comment lines | |
539 | 248273 | return s.length() < 1 || COMMENT_CHARS.indexOf(s.charAt(0)) >= 0; |
540 | } | |
541 | ||
542 | /** | |
543 | * This class is used to read properties lines. These lines do | |
544 | * not terminate with new-line chars but rather when there is no | |
545 | * backslash sign a the end of the line. This is used to | |
546 | * concatenate multiple lines for readability. | |
547 | */ | |
548 | public static class PropertiesReader extends LineNumberReader | |
549 | { | |
550 | /** Stores the comment lines for the currently processed property.*/ | |
551 | private List commentLines; | |
552 | ||
553 | /** Stores the name of the last read property.*/ | |
554 | private String propertyName; | |
555 | ||
556 | /** Stores the value of the last read property.*/ | |
557 | private String propertyValue; | |
558 | ||
559 | /** Stores the list delimiter character.*/ | |
560 | private char delimiter; | |
561 | ||
562 | /** | |
563 | * Constructor. | |
564 | * | |
565 | * @param reader A Reader. | |
566 | */ | |
567 | public PropertiesReader(Reader reader) | |
568 | { | |
569 | 0 | this(reader, AbstractConfiguration.getDefaultListDelimiter()); |
570 | 0 | } |
571 | ||
572 | /** | |
573 | * Creates a new instance of <code>PropertiesReader</code> and sets | |
574 | * the underlaying reader and the list delimiter. | |
575 | * | |
576 | * @param reader the reader | |
577 | * @param listDelimiter the list delimiter character | |
578 | * @since 1.3 | |
579 | */ | |
580 | public PropertiesReader(Reader reader, char listDelimiter) | |
581 | { | |
582 | 6779 | super(reader); |
583 | 6779 | commentLines = new ArrayList(); |
584 | 6779 | delimiter = listDelimiter; |
585 | 6779 | } |
586 | ||
587 | /** | |
588 | * Reads a property line. Returns null if Stream is | |
589 | * at EOF. Concatenates lines ending with "\". | |
590 | * Skips lines beginning with "#" or "!" and empty lines. | |
591 | * The return value is a property definition (<code><name></code> | |
592 | * = <code><value></code>) | |
593 | * | |
594 | * @return A string containing a property value or null | |
595 | * | |
596 | * @throws IOException in case of an I/O error | |
597 | */ | |
598 | public String readProperty() throws IOException | |
599 | { | |
600 | 130054 | commentLines.clear(); |
601 | 130054 | StringBuffer buffer = new StringBuffer(); |
602 | ||
603 | while (true) | |
604 | { | |
605 | 254782 | String line = readLine(); |
606 | 254782 | if (line == null) |
607 | { | |
608 | // EOF | |
609 | 6778 | return null; |
610 | } | |
611 | ||
612 | 248004 | if (isCommentLine(line)) |
613 | { | |
614 | 118140 | commentLines.add(line); |
615 | 118140 | continue; |
616 | } | |
617 | ||
618 | 129864 | line = line.trim(); |
619 | ||
620 | 129864 | if (checkCombineLines(line)) |
621 | { | |
622 | 6588 | line = line.substring(0, line.length() - 1); |
623 | 6588 | buffer.append(line); |
624 | } | |
625 | else | |
626 | { | |
627 | 123276 | buffer.append(line); |
628 | 123276 | break; |
629 | } | |
630 | } | |
631 | 123276 | return buffer.toString(); |
632 | } | |
633 | ||
634 | /** | |
635 | * Parses the next property from the input stream and stores the found | |
636 | * name and value in internal fields. These fields can be obtained using | |
637 | * the provided getter methods. The return value indicates whether EOF | |
638 | * was reached (<b>false</b>) or whether further properties are | |
639 | * available (<b>true</b>). | |
640 | * | |
641 | * @return a flag if further properties are available | |
642 | * @throws IOException if an error occurs | |
643 | * @since 1.3 | |
644 | */ | |
645 | public boolean nextProperty() throws IOException | |
646 | { | |
647 | 130054 | String line = readProperty(); |
648 | ||
649 | 130054 | if (line == null) |
650 | { | |
651 | 6778 | return false; // EOF |
652 | } | |
653 | ||
654 | // parse the line | |
655 | 123276 | String[] property = parseProperty(line); |
656 | 123276 | propertyName = StringEscapeUtils.unescapeJava(property[0]); |
657 | 123276 | propertyValue = unescapeJava(property[1], delimiter); |
658 | 123276 | return true; |
659 | } | |
660 | ||
661 | /** | |
662 | * Returns the comment lines that have been read for the last property. | |
663 | * | |
664 | * @return the comment lines for the last property returned by | |
665 | * <code>readProperty()</code> | |
666 | * @since 1.3 | |
667 | */ | |
668 | public List getCommentLines() | |
669 | { | |
670 | 576386 | return commentLines; |
671 | } | |
672 | ||
673 | /** | |
674 | * Returns the name of the last read property. This method can be called | |
675 | * after <code>{@link #nextProperty()}</code> was invoked and its | |
676 | * return value was <b>true</b>. | |
677 | * | |
678 | * @return the name of the last read property | |
679 | * @since 1.3 | |
680 | */ | |
681 | public String getPropertyName() | |
682 | { | |
683 | 361032 | return propertyName; |
684 | } | |
685 | ||
686 | /** | |
687 | * Returns the value of the last read property. This method can be | |
688 | * called after <code>{@link #nextProperty()}</code> was invoked and | |
689 | * its return value was <b>true</b>. | |
690 | * | |
691 | * @return the value of the last read property | |
692 | * @since 1.3 | |
693 | */ | |
694 | public String getPropertyValue() | |
695 | { | |
696 | 123276 | return propertyValue; |
697 | } | |
698 | ||
699 | /** | |
700 | * Checks if the passed in line should be combined with the following. | |
701 | * This is true, if the line ends with an odd number of backslashes. | |
702 | * | |
703 | * @param line the line | |
704 | * @return a flag if the lines should be combined | |
705 | */ | |
706 | private static boolean checkCombineLines(String line) | |
707 | { | |
708 | 129864 | int bsCount = 0; |
709 | 154060 | for (int idx = line.length() - 1; idx >= 0 && line.charAt(idx) == '\\'; idx--) |
710 | { | |
711 | 24196 | bsCount++; |
712 | } | |
713 | ||
714 | 129864 | return bsCount % 2 != 0; |
715 | } | |
716 | ||
717 | /** | |
718 | * Parse a property line and return the key and the value in an array. | |
719 | * | |
720 | * @param line the line to parse | |
721 | * @return an array with the property's key and value | |
722 | * @since 1.2 | |
723 | */ | |
724 | private static String[] parseProperty(String line) | |
725 | { | |
726 | // sorry for this spaghetti code, please replace it as soon as | |
727 | // possible with a regexp when the Java 1.3 requirement is dropped | |
728 | ||
729 | 123276 | String[] result = new String[2]; |
730 | 123276 | StringBuffer key = new StringBuffer(); |
731 | 123276 | StringBuffer value = new StringBuffer(); |
732 | ||
733 | // state of the automaton: | |
734 | // 0: key parsing | |
735 | // 1: antislash found while parsing the key | |
736 | // 2: separator crossing | |
737 | // 3: value parsing | |
738 | 123276 | int state = 0; |
739 | ||
740 | 3691513 | for (int pos = 0; pos < line.length(); pos++) |
741 | { | |
742 | 3568237 | char c = line.charAt(pos); |
743 | ||
744 | 3568237 | switch (state) |
745 | { | |
746 | case 0: | |
747 | 1993531 | if (c == '\\') |
748 | { | |
749 | 11013 | state = 1; |
750 | } | |
751 | 1982518 | else if (ArrayUtils.contains(WHITE_SPACE, c)) |
752 | { | |
753 | // switch to the separator crossing state | |
754 | 123048 | state = 2; |
755 | } | |
756 | 1859470 | else if (ArrayUtils.contains(SEPARATORS, c)) |
757 | { | |
758 | // switch to the value parsing state | |
759 | 226 | state = 3; |
760 | } | |
761 | else | |
762 | { | |
763 | 1859244 | key.append(c); |
764 | } | |
765 | ||
766 | 1859244 | break; |
767 | ||
768 | case 1: | |
769 | 11013 | if (ArrayUtils.contains(SEPARATORS, c) || ArrayUtils.contains(WHITE_SPACE, c)) |
770 | { | |
771 | // this is an escaped separator or white space | |
772 | 11010 | key.append(c); |
773 | } | |
774 | else | |
775 | { | |
776 | // another escaped character, the '\' is preserved | |
777 | 3 | key.append('\\'); |
778 | 3 | key.append(c); |
779 | } | |
780 | ||
781 | // return to the key parsing state | |
782 | 11013 | state = 0; |
783 | ||
784 | 11013 | break; |
785 | ||
786 | case 2: | |
787 | 218094 | if (ArrayUtils.contains(WHITE_SPACE, c)) |
788 | { | |
789 | // do nothing, eat all white spaces | |
790 | 95046 | state = 2; |
791 | } | |
792 | 123048 | else if (ArrayUtils.contains(SEPARATORS, c)) |
793 | { | |
794 | // switch to the value parsing state | |
795 | 116454 | state = 3; |
796 | } | |
797 | else | |
798 | { | |
799 | // any other character indicates we encoutered the beginning of the value | |
800 | 6594 | value.append(c); |
801 | ||
802 | // switch to the value parsing state | |
803 | 6594 | state = 3; |
804 | } | |
805 | ||
806 | 6594 | break; |
807 | ||
808 | case 3: | |
809 | 1345599 | value.append(c); |
810 | break; | |
811 | } | |
812 | } | |
813 | ||
814 | 123276 | result[0] = key.toString().trim(); |
815 | 123276 | result[1] = value.toString().trim(); |
816 | ||
817 | 123276 | return result; |
818 | } | |
819 | } // class PropertiesReader | |
820 | ||
821 | /** | |
822 | * This class is used to write properties lines. | |
823 | */ | |
824 | public static class PropertiesWriter extends FilterWriter | |
825 | { | |
826 | /** The delimiter for multi-valued properties.*/ | |
827 | private char delimiter; | |
828 | ||
829 | /** | |
830 | * Constructor. | |
831 | * | |
832 | * @param writer a Writer object providing the underlying stream | |
833 | * @param delimiter the delimiter character for multi-valued properties | |
834 | */ | |
835 | public PropertiesWriter(Writer writer, char delimiter) | |
836 | { | |
837 | 41 | super(writer); |
838 | 41 | this.delimiter = delimiter; |
839 | 41 | } |
840 | ||
841 | /** | |
842 | * Write a property. | |
843 | * | |
844 | * @param key the key of the property | |
845 | * @param value the value of the property | |
846 | * | |
847 | * @throws IOException if an I/O error occurs | |
848 | */ | |
849 | public void writeProperty(String key, Object value) throws IOException | |
850 | { | |
851 | 288 | writeProperty(key, value, false); |
852 | 288 | } |
853 | ||
854 | /** | |
855 | * Write a property. | |
856 | * | |
857 | * @param key The key of the property | |
858 | * @param values The array of values of the property | |
859 | * | |
860 | * @throws IOException if an I/O error occurs | |
861 | */ | |
862 | public void writeProperty(String key, List values) throws IOException | |
863 | { | |
864 | 410 | for (int i = 0; i < values.size(); i++) |
865 | { | |
866 | 288 | writeProperty(key, values.get(i)); |
867 | } | |
868 | 122 | } |
869 | ||
870 | /** | |
871 | * Writes the given property and its value. If the value happens to be a | |
872 | * list, the <code>forceSingleLine</code> flag is evaluated. If it is | |
873 | * set, all values are written on a single line using the list delimiter | |
874 | * as separator. | |
875 | * | |
876 | * @param key the property key | |
877 | * @param value the property value | |
878 | * @param forceSingleLine the "force single line" flag | |
879 | * @throws IOException if an error occurs | |
880 | * @since 1.3 | |
881 | */ | |
882 | public void writeProperty(String key, Object value, | |
883 | boolean forceSingleLine) throws IOException | |
884 | { | |
885 | String v; | |
886 | ||
887 | 847 | if (value instanceof List) |
888 | { | |
889 | 130 | List values = (List) value; |
890 | 130 | if (forceSingleLine) |
891 | { | |
892 | 8 | v = makeSingleLineValue(values); |
893 | } | |
894 | else | |
895 | { | |
896 | 122 | writeProperty(key, values); |
897 | 122 | return; |
898 | } | |
899 | } | |
900 | else | |
901 | { | |
902 | 717 | v = escapeValue(value); |
903 | } | |
904 | ||
905 | 725 | write(escapeKey(key)); |
906 | 725 | write(" = "); |
907 | 725 | write(v); |
908 | ||
909 | 725 | writeln(null); |
910 | 725 | } |
911 | ||
912 | /** | |
913 | * Write a comment. | |
914 | * | |
915 | * @param comment the comment to write | |
916 | * @throws IOException if an I/O error occurs | |
917 | */ | |
918 | public void writeComment(String comment) throws IOException | |
919 | { | |
920 | 0 | writeln("# " + comment); |
921 | 0 | } |
922 | ||
923 | /** | |
924 | * Escape the separators in the key. | |
925 | * | |
926 | * @param key the key | |
927 | * @return the escaped key | |
928 | * @since 1.2 | |
929 | */ | |
930 | private String escapeKey(String key) | |
931 | { | |
932 | 725 | StringBuffer newkey = new StringBuffer(); |
933 | ||
934 | 10931 | for (int i = 0; i < key.length(); i++) |
935 | { | |
936 | 10206 | char c = key.charAt(i); |
937 | ||
938 | 10206 | if (ArrayUtils.contains(SEPARATORS, c) || ArrayUtils.contains(WHITE_SPACE, c)) |
939 | { | |
940 | // escape the separator | |
941 | 55 | newkey.append('\\'); |
942 | 55 | newkey.append(c); |
943 | } | |
944 | else | |
945 | { | |
946 | 10151 | newkey.append(c); |
947 | } | |
948 | } | |
949 | ||
950 | 725 | return newkey.toString(); |
951 | } | |
952 | ||
953 | /** | |
954 | * Escapes the given property value. Delimiter characters in the value | |
955 | * will be escaped. | |
956 | * | |
957 | * @param value the property value | |
958 | * @return the escaped property value | |
959 | * @since 1.3 | |
960 | */ | |
961 | private String escapeValue(Object value) | |
962 | { | |
963 | 743 | String escapedValue = StringEscapeUtils.escapeJava(String.valueOf(value)); |
964 | 743 | if (delimiter != 0) |
965 | { | |
966 | 741 | escapedValue = StringUtils.replace(escapedValue, String.valueOf(delimiter), ESCAPE + delimiter); |
967 | } | |
968 | 743 | return escapedValue; |
969 | } | |
970 | ||
971 | /** | |
972 | * Transforms a list of values into a single line value. | |
973 | * | |
974 | * @param values the list with the values | |
975 | * @return a string with the single line value (can be <b>null</b>) | |
976 | * @since 1.3 | |
977 | */ | |
978 | private String makeSingleLineValue(List values) | |
979 | { | |
980 | 8 | if (!values.isEmpty()) |
981 | { | |
982 | 8 | Iterator it = values.iterator(); |
983 | 8 | String lastValue = escapeValue(it.next()); |
984 | 8 | StringBuffer buf = new StringBuffer(lastValue); |
985 | 26 | while (it.hasNext()) |
986 | { | |
987 | // if the last value ended with an escape character, it has | |
988 | // to be escaped itself; otherwise the list delimiter will | |
989 | // be escaped | |
990 | 18 | if (lastValue.endsWith(ESCAPE)) |
991 | { | |
992 | 2 | buf.append(ESCAPE).append(ESCAPE); |
993 | } | |
994 | 18 | buf.append(delimiter); |
995 | 18 | lastValue = escapeValue(it.next()); |
996 | 18 | buf.append(lastValue); |
997 | } | |
998 | 8 | return buf.toString(); |
999 | } | |
1000 | else | |
1001 | { | |
1002 | 0 | return null; |
1003 | } | |
1004 | } | |
1005 | ||
1006 | /** | |
1007 | * Helper method for writing a line with the platform specific line | |
1008 | * ending. | |
1009 | * | |
1010 | * @param s the content of the line (may be <b>null</b>) | |
1011 | * @throws IOException if an error occurs | |
1012 | * @since 1.3 | |
1013 | */ | |
1014 | public void writeln(String s) throws IOException | |
1015 | { | |
1016 | 1011 | if (s != null) |
1017 | { | |
1018 | 67 | write(s); |
1019 | } | |
1020 | 1011 | write(LINE_SEPARATOR); |
1021 | 1011 | } |
1022 | ||
1023 | } // class PropertiesWriter | |
1024 | ||
1025 | /** | |
1026 | * <p>Unescapes any Java literals found in the <code>String</code> to a | |
1027 | * <code>Writer</code>.</p> This is a slightly modified version of the | |
1028 | * StringEscapeUtils.unescapeJava() function in commons-lang that doesn't | |
1029 | * drop escaped separators (i.e '\,'). | |
1030 | * | |
1031 | * @param str the <code>String</code> to unescape, may be null | |
1032 | * @param delimiter the delimiter for multi-valued properties | |
1033 | * @return the processed string | |
1034 | * @throws IllegalArgumentException if the Writer is <code>null</code> | |
1035 | */ | |
1036 | protected static String unescapeJava(String str, char delimiter) | |
1037 | { | |
1038 | 123277 | if (str == null) |
1039 | { | |
1040 | 0 | return null; |
1041 | } | |
1042 | 123277 | int sz = str.length(); |
1043 | 123277 | StringBuffer out = new StringBuffer(sz); |
1044 | 123277 | StringBuffer unicode = new StringBuffer(UNICODE_LEN); |
1045 | 123277 | boolean hadSlash = false; |
1046 | 123277 | boolean inUnicode = false; |
1047 | 1361228 | for (int i = 0; i < sz; i++) |
1048 | { | |
1049 | 1237951 | char ch = str.charAt(i); |
1050 | 1237951 | if (inUnicode) |
1051 | { | |
1052 | // if in unicode, then we're reading unicode | |
1053 | // values in somehow | |
1054 | 8784 | unicode.append(ch); |
1055 | 8784 | if (unicode.length() == UNICODE_LEN) |
1056 | { | |
1057 | // unicode now contains the four hex digits | |
1058 | // which represents our unicode character | |
1059 | try | |
1060 | { | |
1061 | 2196 | int value = Integer.parseInt(unicode.toString(), HEX_RADIX); |
1062 | 2196 | out.append((char) value); |
1063 | 2196 | unicode.setLength(0); |
1064 | 2196 | inUnicode = false; |
1065 | 2196 | hadSlash = false; |
1066 | } | |
1067 | 0 | catch (NumberFormatException nfe) |
1068 | { | |
1069 | 0 | throw new ConfigurationRuntimeException("Unable to parse unicode value: " + unicode, nfe); |
1070 | 2196 | } |
1071 | } | |
1072 | continue; | |
1073 | } | |
1074 | ||
1075 | 1229167 | if (hadSlash) |
1076 | { | |
1077 | // handle an escaped value | |
1078 | 30835 | hadSlash = false; |
1079 | ||
1080 | 30835 | if (ch == '\\') |
1081 | { | |
1082 | 19830 | out.append('\\'); |
1083 | } | |
1084 | 11005 | else if (ch == '\'') |
1085 | { | |
1086 | 0 | out.append('\''); |
1087 | } | |
1088 | 11005 | else if (ch == '\"') |
1089 | { | |
1090 | 2202 | out.append('"'); |
1091 | } | |
1092 | 8803 | else if (ch == 'r') |
1093 | { | |
1094 | 0 | out.append('\r'); |
1095 | } | |
1096 | 8803 | else if (ch == 'f') |
1097 | { | |
1098 | 0 | out.append('\f'); |
1099 | } | |
1100 | 8803 | else if (ch == 't') |
1101 | { | |
1102 | 2202 | out.append('\t'); |
1103 | } | |
1104 | 6601 | else if (ch == 'n') |
1105 | { | |
1106 | 2202 | out.append('\n'); |
1107 | } | |
1108 | 4399 | else if (ch == 'b') |
1109 | { | |
1110 | 0 | out.append('\b'); |
1111 | } | |
1112 | 4399 | else if (ch == delimiter) |
1113 | { | |
1114 | 2200 | out.append('\\'); |
1115 | 2200 | out.append(delimiter); |
1116 | } | |
1117 | 2199 | else if (ch == 'u') |
1118 | { | |
1119 | // uh-oh, we're in unicode country.... | |
1120 | 2196 | inUnicode = true; |
1121 | } | |
1122 | else | |
1123 | { | |
1124 | 3 | out.append(ch); |
1125 | } | |
1126 | ||
1127 | 3 | continue; |
1128 | } | |
1129 | 1198332 | else if (ch == '\\') |
1130 | { | |
1131 | 30835 | hadSlash = true; |
1132 | 30835 | continue; |
1133 | } | |
1134 | 1167497 | out.append(ch); |
1135 | } | |
1136 | ||
1137 | 123277 | if (hadSlash) |
1138 | { | |
1139 | // then we're in the weird case of a \ at the end of the | |
1140 | // string, let's output it anyway. | |
1141 | 0 | out.append('\\'); |
1142 | } | |
1143 | ||
1144 | 123277 | return out.toString(); |
1145 | } | |
1146 | ||
1147 | /** | |
1148 | * Helper method for loading an included properties file. This method is | |
1149 | * called by <code>load()</code> when an <code>include</code> property | |
1150 | * is encountered. It tries to resolve relative file names based on the | |
1151 | * current base path. If this fails, a resolution based on the location of | |
1152 | * this properties file is tried. | |
1153 | * | |
1154 | * @param fileName the name of the file to load | |
1155 | * @throws ConfigurationException if loading fails | |
1156 | */ | |
1157 | private void loadIncludeFile(String fileName) throws ConfigurationException | |
1158 | { | |
1159 | 4399 | URL url = ConfigurationUtils.locate(getBasePath(), fileName); |
1160 | 4399 | if (url == null) |
1161 | { | |
1162 | 2 | URL baseURL = getURL(); |
1163 | 2 | if (baseURL != null) |
1164 | { | |
1165 | 2 | url = ConfigurationUtils.locate(baseURL.toString(), fileName); |
1166 | } | |
1167 | } | |
1168 | ||
1169 | 4399 | if (url == null) |
1170 | { | |
1171 | 1 | throw new ConfigurationException("Cannot resolve include file " |
1172 | + fileName); | |
1173 | } | |
1174 | 4398 | load(url); |
1175 | 4398 | } |
1176 | } |