%line	%branch
org.apache.commons.validator.ValidatorResources$1	9%	50%

1		/*
2		* $Id: ValidatorResources.java 386637 2006-03-17 13:22:26Z niallp $
3		* $Rev: 386637 $
4		* $Date: 2006-03-17 13:22:26 +0000 (Fri, 17 Mar 2006) $
5		*
6		* ====================================================================
7		* Copyright 2001-2006 The Apache Software Foundation
8		*
9		* Licensed under the Apache License, Version 2.0 (the "License");
10		* you may not use this file except in compliance with the License.
11		* You may obtain a copy of the License at
12		*
13		* http://www.apache.org/licenses/LICENSE-2.0
14		*
15		* Unless required by applicable law or agreed to in writing, software
16		* distributed under the License is distributed on an "AS IS" BASIS,
17		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18		* See the License for the specific language governing permissions and
19		* limitations under the License.
20		*/
21
22		package org.apache.commons.validator;
23
24		import java.io.IOException;
25		import java.io.InputStream;
26		import java.io.Serializable;
27		import java.net.URL;
28		import java.util.Collections;
29		import java.util.Iterator;
30		import java.util.Locale;
31		import java.util.Map;
32
33		import org.apache.commons.collections.FastHashMap;
34		import org.apache.commons.digester.Digester;
35		import org.apache.commons.digester.Rule;
36		import org.apache.commons.digester.xmlrules.DigesterLoader;
37		import org.apache.commons.logging.Log;
38		import org.apache.commons.logging.LogFactory;
39		import org.xml.sax.SAXException;
40		import org.xml.sax.Attributes;
41
42		/**
43		* <p>
44		* General purpose class for storing <code>FormSet</code> objects based
45		* on their associated <code>Locale</code>. Instances of this class are usually
46		* configured through a validation.xml file that is parsed in a constructor.
47		* </p>
48		*
49		* <p><strong>Note</strong> - Classes that extend this class
50		* must be Serializable so that instances may be used in distributable
51		* application server environments.</p>
52		*
53		* <p>
54		* The use of FastHashMap is deprecated and will be replaced in a future
55		* release.
56		* </p>
57		*/
58		public class ValidatorResources implements Serializable {
59
60		/**
61		* The set of public identifiers, and corresponding resource names, for
62		* the versions of the configuration file DTDs that we know about. There
63		* <strong>MUST</strong> be an even number of Strings in this list!
64		*/
65		private static final String REGISTRATIONS[] = {
66		"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN",
67		"/org/apache/commons/validator/resources/validator_1_0.dtd",
68		"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0.1//EN",
69		"/org/apache/commons/validator/resources/validator_1_0_1.dtd",
70		"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1//EN",
71		"/org/apache/commons/validator/resources/validator_1_1.dtd",
72		"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN",
73		"/org/apache/commons/validator/resources/validator_1_1_3.dtd",
74		"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.2.0//EN",
75		"/org/apache/commons/validator/resources/validator_1_2_0.dtd",
76		"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.3.0//EN",
77		"/org/apache/commons/validator/resources/validator_1_3_0.dtd"
78		};
79
80		private transient Log log = LogFactory.getLog(ValidatorResources.class);
81
82		/**
83		* <code>Map</code> of <code>FormSet</code>s stored under
84		* a <code>Locale</code> key.
85		* @deprecated Subclasses should use getFormSets() instead.
86		*/
87		protected FastHashMap hFormSets = new FastHashMap();
88
89		/**
90		* <code>Map</code> of global constant values with
91		* the name of the constant as the key.
92		* @deprecated Subclasses should use getConstants() instead.
93		*/
94		protected FastHashMap hConstants = new FastHashMap();
95
96		/**
97		* <code>Map</code> of <code>ValidatorAction</code>s with
98		* the name of the <code>ValidatorAction</code> as the key.
99		* @deprecated Subclasses should use getActions() instead.
100		*/
101		protected FastHashMap hActions = new FastHashMap();
102
103		/**
104		* The default locale on our server.
105		*/
106		protected static Locale defaultLocale = Locale.getDefault();
107
108		/**
109		* Create an empty ValidatorResources object.
110		*/
111		public ValidatorResources() {
112		super();
113		}
114
115		/**
116		* This is the default <code>FormSet</code> (without locale). (We probably don't need
117		* the defaultLocale anymore.)
118		*/
119		protected FormSet defaultFormSet;
120
121		/**
122		* Create a ValidatorResources object from an InputStream.
123		*
124		* @param in InputStream to a validation.xml configuration file. It's the client's
125		* responsibility to close this stream.
126		* @throws IOException
127		* @throws SAXException if the validation XML files are not valid or well
128		* formed.
129		* @throws IOException if an I/O error occurs processing the XML files
130		* @since Validator 1.1
131		*/
132		public ValidatorResources(InputStream in) throws IOException, SAXException {
133		this(new InputStream[]{in});
134		}
135
136		/**
137		* Create a ValidatorResources object from an InputStream.
138		*
139		* @param streams An array of InputStreams to several validation.xml
140		* configuration files that will be read in order and merged into this object.
141		* It's the client's responsibility to close these streams.
142		* @throws IOException
143		* @throws SAXException if the validation XML files are not valid or well
144		* formed.
145		* @throws IOException if an I/O error occurs processing the XML files
146		* @since Validator 1.1
147		*/
148		public ValidatorResources(InputStream[] streams)
149		throws IOException, SAXException {
150
151		super();
152
153		Digester digester = initDigester();
154		for (int i = 0; i < streams.length; i++) {
155		digester.push(this);
156		digester.parse(streams[i]);
157		}
158
159		this.process();
160		}
161
162		/**
163		* Create a ValidatorResources object from an uri
164		*
165		* @param uri The location of a validation.xml configuration file.
166		* @throws IOException
167		* @throws SAXException if the validation XML files are not valid or well
168		* formed.
169		* @throws IOException if an I/O error occurs processing the XML files
170		* @since Validator 1.2
171		*/
172		public ValidatorResources(String uri) throws IOException, SAXException {
173		this(new String[]{uri});
174		}
175
176		/**
177		* Create a ValidatorResources object from several uris
178		*
179		* @param uris An array of uris to several validation.xml
180		* configuration files that will be read in order and merged into this object.
181		* @throws IOException
182		* @throws SAXException if the validation XML files are not valid or well
183		* formed.
184		* @throws IOException if an I/O error occurs processing the XML files
185		* @since Validator 1.2
186		*/
187		public ValidatorResources(String[] uris)
188		throws IOException, SAXException {
189
190		super();
191
192		Digester digester = initDigester();
193		for (int i = 0; i < uris.length; i++) {
194		digester.push(this);
195		digester.parse(uris[i]);
196		}
197
198		this.process();
199		}
200
201		/**
202		* Initialize the digester.
203		*/
204		private Digester initDigester() {
205		URL rulesUrl = this.getClass().getResource("digester-rules.xml");
206		Digester digester = DigesterLoader.createDigester(rulesUrl);
207		digester.setNamespaceAware(true);
208		digester.setValidating(true);
209		digester.setUseContextClassLoader(true);
210
211		// Add rules for arg0-arg3 elements
212		addOldArgRules(digester);
213
214		// register DTDs
215		for (int i = 0; i < REGISTRATIONS.length; i += 2) {
216		URL url = this.getClass().getResource(REGISTRATIONS[i + 1]);
217		if (url != null) {
218		digester.register(REGISTRATIONS[i], url.toString());
219		}
220		}
221		return digester;
222		}
223
224		private static final String ARGS_PATTERN
225		= "form-validation/formset/form/field/arg";
226
227		/**
228		* Create a <code>Rule</code> to handle <code>arg0-arg3</code>
229		* elements. This will allow validation.xml files that use the
230		* versions of the DTD prior to Validator 1.2.0 to continue
231		* working.
232		*/
233		private void addOldArgRules(Digester digester) {
234
235		// Create a new rule to process args elements
236		Rule rule = new Rule() {
237	94	public void begin(String namespace, String name,
238		Attributes attributes) throws Exception {
239		// Create the Arg
240	0	Arg arg = new Arg();
241	0	arg.setKey(attributes.getValue("key"));
242	0	arg.setName(attributes.getValue("name"));
243	0	if ("false".equalsIgnoreCase(attributes.getValue("resource"))) {
244	0	arg.setResource(false);
245		}
246		try {
247	0	arg.setPosition(Integer.parseInt(name.substring(3)));
248	0	} catch (Exception ex) {
249	0	getLog().error("Error parsing Arg position: "
250		+ name + " " + arg + " " + ex);
251		}
252
253		// Add the arg to the parent field
254	0	((Field)getDigester().peek(0)).addArg(arg);
255	0	}
256		};
257
258		// Add the rule for each of the arg elements
259		digester.addRule(ARGS_PATTERN + "0", rule);
260		digester.addRule(ARGS_PATTERN + "1", rule);
261		digester.addRule(ARGS_PATTERN + "2", rule);
262		digester.addRule(ARGS_PATTERN + "3", rule);
263
264		}
265
266		/**
267		* Add a <code>FormSet</code> to this <code>ValidatorResources</code>
268		* object. It will be associated with the <code>Locale</code> of the
269		* <code>FormSet</code>.
270		* @param fs The form set to add.
271		* @since Validator 1.1
272		*/
273		public void addFormSet(FormSet fs) {
274		String key = this.buildKey(fs);
275		if (key.length() == 0) {// there can only be one default formset
276		if (getLog().isWarnEnabled() && defaultFormSet != null) {
277		// warn the user he might not get the expected results
278		getLog().warn("Overriding default FormSet definition.");
279		}
280		defaultFormSet = fs;
281		} else {
282		FormSet formset = (FormSet) hFormSets.get(key);
283		if (formset == null) {// it hasn't been included yet
284		if (getLog().isDebugEnabled()) {
285		getLog().debug("Adding FormSet '" + fs.toString() + "'.");
286		}
287		} else if (getLog().isWarnEnabled()) {// warn the user he might not
288		// get the expected results
289		getLog()
290		.warn("Overriding FormSet definition. Duplicate for locale: "
291		+ key);
292		}
293		hFormSets.put(key, fs);
294		}
295		}
296
297		/**
298		* Add a global constant to the resource.
299		* @param name The constant name.
300		* @param value The constant value.
301		*/
302		public void addConstant(String name, String value) {
303		if (getLog().isDebugEnabled()) {
304		getLog().debug("Adding Global Constant: " + name + "," + value);
305		}
306
307		this.hConstants.put(name, value);
308		}
309
310		/**
311		* Add a <code>ValidatorAction</code> to the resource. It also creates an
312		* instance of the class based on the <code>ValidatorAction</code>s
313		* classname and retrieves the <code>Method</code> instance and sets them
314		* in the <code>ValidatorAction</code>.
315		* @param va The validator action.
316		*/
317		public void addValidatorAction(ValidatorAction va) {
318		va.init();
319
320		this.hActions.put(va.getName(), va);
321
322		if (getLog().isDebugEnabled()) {
323		getLog().debug("Add ValidatorAction: " + va.getName() + "," + va.getClassname());
324		}
325		}
326
327		/**
328		* Get a <code>ValidatorAction</code> based on it's name.
329		* @param key The validator action key.
330		* @return The validator action.
331		*/
332		public ValidatorAction getValidatorAction(String key) {
333		return (ValidatorAction) hActions.get(key);
334		}
335
336		/**
337		* Get an unmodifiable <code>Map</code> of the <code>ValidatorAction</code>s.
338		* @return Map of validator actions.
339		*/
340		public Map getValidatorActions() {
341		return Collections.unmodifiableMap(hActions);
342		}
343
344		/**
345		* Builds a key to store the <code>FormSet</code> under based on it's
346		* language, country, and variant values.
347		* @param fs The Form Set.
348		* @return generated key for a formset.
349		*/
350		protected String buildKey(FormSet fs) {
351		return
352		this.buildLocale(fs.getLanguage(), fs.getCountry(), fs.getVariant());
353		}
354
355		/**
356		* Assembles a Locale code from the given parts.
357		*/
358		private String buildLocale(String lang, String country, String variant) {
359		String key = ((lang != null && lang.length() > 0) ? lang : "");
360		key += ((country != null && country.length() > 0) ? "_" + country : "");
361		key += ((variant != null && variant.length() > 0) ? "_" + variant : "");
362		return key;
363		}
364
365		/**
366		* <p>Gets a <code>Form</code> based on the name of the form and the
367		* <code>Locale</code> that most closely matches the <code>Locale</code>
368		* passed in. The order of <code>Locale</code> matching is:</p>
369		* <ol>
370		* <li>language + country + variant</li>
371		* <li>language + country</li>
372		* <li>language</li>
373		* <li>default locale</li>
374		* </ol>
375		* @param locale The Locale.
376		* @param formKey The key for the Form.
377		* @return The validator Form.
378		* @since Validator 1.1
379		*/
380		public Form getForm(Locale locale, String formKey) {
381		return this.getForm(locale.getLanguage(), locale.getCountry(), locale
382		.getVariant(), formKey);
383		}
384
385		/**
386		* <p>Gets a <code>Form</code> based on the name of the form and the
387		* <code>Locale</code> that most closely matches the <code>Locale</code>
388		* passed in. The order of <code>Locale</code> matching is:</p>
389		* <ol>
390		* <li>language + country + variant</li>
391		* <li>language + country</li>
392		* <li>language</li>
393		* <li>default locale</li>
394		* </ol>
395		* @param language The locale's language.
396		* @param country The locale's country.
397		* @param variant The locale's language variant.
398		* @param formKey The key for the Form.
399		* @return The validator Form.
400		* @since Validator 1.1
401		*/
402		public Form getForm(String language, String country, String variant,
403		String formKey) {
404
405		Form form = null;
406
407		// Try language/country/variant
408		String key = this.buildLocale(language, country, variant);
409		if (key.length() > 0) {
410		FormSet formSet = (FormSet)hFormSets.get(key);
411		if (formSet != null) {
412		form = formSet.getForm(formKey);
413		}
414		}
415		String localeKey = key;
416
417
418		// Try language/country
419		if (form == null) {
420		key = buildLocale(language, country, null);
421		if (key.length() > 0) {
422		FormSet formSet = (FormSet)hFormSets.get(key);
423		if (formSet != null) {
424		form = formSet.getForm(formKey);
425		}
426		}
427		}
428
429		// Try language
430		if (form == null) {
431		key = buildLocale(language, null, class="keyword">null);
432		if (key.length() > 0) {
433		FormSet formSet = (FormSet)hFormSets.get(key);
434		if (formSet != null) {
435		form = formSet.getForm(formKey);
436		}
437		}
438		}
439
440		// Try default formset
441		if (form == null) {
442		form = defaultFormSet.getForm(formKey);
443		key = "default";
444		}
445
446		if (form == null) {
447		if (getLog().isWarnEnabled()) {
448		getLog().warn("Form '" + formKey + "' not found for locale '" +
449		localeKey + "'");
450		}
451		} else {
452		if (getLog().isDebugEnabled()) {
453		getLog().debug("Form '" + formKey + "' found in formset '" +
454		key + "' for locale '" + localeKey + "'");
455		}
456		}
457
458		return form;
459
460		}
461
462		/**
463		* Process the <code>ValidatorResources</code> object. Currently sets the
464		* <code>FastHashMap</code> s to the 'fast' mode and call the processes
465		* all other resources. <strong>Note </strong>: The framework calls this
466		* automatically when ValidatorResources is created from an XML file. If you
467		* create an instance of this class by hand you <strong>must </strong> call
468		* this method when finished.
469		*/
470		public void process() {
471		hFormSets.setFast(true);
472		hConstants.setFast(true);
473		hActions.setFast(true);
474
475		this.processForms();
476		}
477
478		/**
479		* <p>Process the <code>Form</code> objects. This clones the <code>Field</code>s
480		* that don't exist in a <code>FormSet</code> compared to its parent
481		* <code>FormSet</code>.</p>
482		*/
483		private void processForms() {
484		if (defaultFormSet == null) {// it isn't mandatory to have a
485		// default formset
486		defaultFormSet = new FormSet();
487		}
488		defaultFormSet.process(hConstants);
489		// Loop through FormSets and merge if necessary
490		for (Iterator i = hFormSets.keySet().iterator(); i.hasNext();) {
491		String key = (String) i.next();
492		FormSet fs = (FormSet) hFormSets.get(key);
493		fs.merge(getParent(fs));
494		}
495
496		// Process Fully Constructed FormSets
497		for (Iterator i = hFormSets.values().iterator(); i.hasNext();) {
498		FormSet fs = (FormSet) i.next();
499		if (!fs.isProcessed()) {
500		fs.process(hConstants);
501		}
502		}
503		}
504
505		/**
506		* Finds the given formSet's parent. ex: A formSet with locale en_UK_TEST1
507		* has a direct parent in the formSet with locale en_UK. If it doesn't
508		* exist, find the formSet with locale en, if no found get the
509		* defaultFormSet.
510		*
511		* @param fs
512		* the formSet we want to get the parent from
513		* @return fs's parent
514		*/
515		private FormSet getParent(FormSet fs) {
516
517		FormSet parent = null;
518		if (fs.getType() == FormSet.LANGUAGE_FORMSET) {
519		parent = defaultFormSet;
520		} else if (fs.getType() == FormSet.COUNTRY_FORMSET) {
521		parent = (FormSet) hFormSets.get(buildLocale(fs.getLanguage(),
522		null, class="keyword">null));
523		if (parent == null) {
524		parent = defaultFormSet;
525		}
526		} else if (fs.getType() == FormSet.VARIANT_FORMSET) {
527		parent = (FormSet) hFormSets.get(buildLocale(fs.getLanguage(), fs
528		.getCountry(), null));
529		if (parent == null) {
530		parent = (FormSet) hFormSets.get(buildLocale(fs.getLanguage(),
531		null, class="keyword">null));
532		if (parent == null) {
533		parent = defaultFormSet;
534		}
535		}
536		}
537		return parent;
538		}
539
540		/**
541		* <p>Gets a <code>FormSet</code> based on the language, country
542		* and variant.</p>
543		* @param language The locale's language.
544		* @param country The locale's country.
545		* @param variant The locale's language variant.
546		* @return The FormSet for a locale.
547		* @since Validator 1.2
548		*/
549		FormSet getFormSet(String language, String country, String variant) {
550
551		String key = buildLocale(language, country, variant);
552
553		if (key.length() == 0) {
554		return defaultFormSet;
555		}
556
557		return (FormSet)hFormSets.get(key);
558		}
559
560		/**
561		* Returns a Map of String locale keys to Lists of their FormSets.
562		* @return Map of Form sets
563		* @since Validator 1.2.0
564		*/
565		protected Map getFormSets() {
566		return hFormSets;
567		}
568
569		/**
570		* Returns a Map of String constant names to their String values.
571		* @return Map of Constants
572		* @since Validator 1.2.0
573		*/
574		protected Map getConstants() {
575		return hConstants;
576		}
577
578		/**
579		* Returns a Map of String ValidatorAction names to their ValidatorAction.
580		* @return Map of Validator Actions
581		* @since Validator 1.2.0
582		*/
583		protected Map getActions() {
584		return hActions;
585		}
586
587		/**
588		* Accessor method for Log instance.
589		*
590		* The Log instance variable is transient and
591		* accessing it through this method ensures it
592		* is re-initialized when this instance is
593		* de-serialized.
594		*
595		* @return The Log instance.
596		*/
597		private Log getLog() {
598		if (log == null) {
599		log = LogFactory.getLog(ValidatorResources.class);
600		}
601		return log;
602		}
603
604		}

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