Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.validator.Validator |
57% |
94% |

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 |  |
     package org.apache.commons.validator;
18 |  |
19 |  |
     import java.io.Serializable;
20 |  |
     import java.util.HashMap;
21 |  |
     import java.util.Locale;
22 |  |
     import java.util.Map;
23 |  |
24 |  |
     /**
25 |  |
      * Validations are processed by the validate method. An instance of
26 |  |
      * <code>ValidatorResources</code> is used to define the validators
27 |  |
      * (validation methods) and the validation rules for a JavaBean.
28 |  |
      *
29 |  |
      * @version $Revision: 478345 $ $Date: 2006-11-22 22:25:19 +0000 (Wed, 22 Nov 2006) $
30 |  |
      */
31 |  |
     public class Validator implements Serializable {
32 |  |
33 |  |
         /**
34 |  |
          * Resources key the JavaBean is stored to perform validation on.
35 |  |
          */
36 |  |
         public static final String BEAN_PARAM = "java.lang.Object";
37 |  |
38 |  |
         /**
39 |  |
          * Resources key the <code>ValidatorAction</code> is stored under.
40 |  |
          * This will be automatically passed into a validation method
41 |  |
          * with the current <code>ValidatorAction</code> if it is
42 |  |
          * specified in the method signature.
43 |  |
          */
44 |  |
         public static final String VALIDATOR_ACTION_PARAM =
45 |  |
                 "org.apache.commons.validator.ValidatorAction";
46 |  |
47 |  |
         /**
48 |  |
          * Resources key the <code>ValidatorResults</code> is stored under.
49 |  |
          * This will be automatically passed into a validation method
50 |  |
          * with the current <code>ValidatorResults</code> if it is
51 |  |
          * specified in the method signature.
52 |  |
          */
53 |  |
         public static final String VALIDATOR_RESULTS_PARAM =
54 |  |
                 "org.apache.commons.validator.ValidatorResults";
55 |  |
56 |  |
         /**
57 |  |
          * Resources key the <code>Form</code> is stored under.
58 |  |
          * This will be automatically passed into a validation method
59 |  |
          * with the current <code>Form</code> if it is
60 |  |
          * specified in the method signature.
61 |  |
          */
62 |  |
         public static final String FORM_PARAM = "org.apache.commons.validator.Form";
63 |  |
64 |  |
         /**
65 |  |
          * Resources key the <code>Field</code> is stored under.
66 |  |
          * This will be automatically passed into a validation method
67 |  |
          * with the current <code>Field</code> if it is
68 |  |
          * specified in the method signature.
69 |  |
          */
70 |  |
         public static final String FIELD_PARAM = "org.apache.commons.validator.Field";
71 |  |
72 |  |
         /**
73 |  |
          * Resources key the <code>Validator</code> is stored under.
74 |  |
          * This will be automatically passed into a validation method
75 |  |
          * with the current <code>Validator</code> if it is
76 |  |
          * specified in the method signature.
77 |  |
          */
78 |  |
         public static final String VALIDATOR_PARAM =
79 |  |
                 "org.apache.commons.validator.Validator";
80 |  |
81 |  |
         /**
82 |  |
          * Resources key the <code>Locale</code> is stored.
83 |  |
          * This will be used to retrieve the appropriate
84 |  |
          * <code>FormSet</code> and <code>Form</code> to be
85 |  |
          * processed.
86 |  |
          */
87 |  |
         public static final String LOCALE_PARAM = "java.util.Locale";
88 |  |
89 |  |
         /**
90 |  |
          * The Validator Resources.
91 |  |
          */
92 | 111 |
         protected ValidatorResources resources = null;
93 |  |
94 |  |
         /**
95 |  |
          * The name of the form to validate
96 |  |
          */
97 | 111 |
         protected String formName = null;
98 |  |
99 |  |
         /**
100 |  |
          * The name of the field on the form to validate
101 |  |
          * @since 1.2.0
102 |  |
          */
103 | 111 |
         protected String fieldName = null;
104 |  |
105 |  |
         /**
106 |  |
          * Maps validation method parameter class names to the objects to be passed
107 |  |
          * into the method.
108 |  |
          */
109 | 111 |
         protected Map parameters = new HashMap();
110 |  |
111 |  |
         /**
112 |  |
          * The current page number to validate.
113 |  |
          */
114 | 111 |
         protected int page = 0;
115 |  |
116 |  |
         /**
117 |  |
          * The class loader to use for instantiating application objects.
118 |  |
          * If not specified, the context class loader, or the class loader
119 |  |
          * used to load Digester itself, is used, based on the value of the
120 |  |
          * <code>useContextClassLoader</code> variable.
121 |  |
          */
122 | 111 |
         protected ClassLoader classLoader = null;
123 |  |
124 |  |
         /**
125 |  |
          * Whether or not to use the Context ClassLoader when loading classes
126 |  |
          * for instantiating new objects.  Default is <code>false</code>.
127 |  |
          */
128 | 111 |
         protected boolean useContextClassLoader = false;
129 |  |
130 |  |
         /**
131 |  |
          * Set this to true to not return Fields that pass validation.  Only return failures.
132 |  |
          */
133 | 111 |
         protected boolean onlyReturnErrors = false;
134 |  |
135 |  |
         /**
136 |  |
          * Construct a <code>Validator</code> that will
137 |  |
          * use the <code>ValidatorResources</code>
138 |  |
          * passed in to retrieve pluggable validators
139 |  |
          * the different sets of validation rules.
140 |  |
          *
141 |  |
          * @param resources <code>ValidatorResources</code> to use during validation.
142 |  |
          */
143 |  |
         public Validator(ValidatorResources resources) {
144 | 0 |
             this(resources, null);
145 | 0 |
         }
146 |  |
147 |  |
         /**
148 |  |
          * Construct a <code>Validator</code> that will
149 |  |
          * use the <code>ValidatorResources</code>
150 |  |
          * passed in to retrieve pluggable validators
151 |  |
          * the different sets of validation rules.
152 |  |
          *
153 |  |
          * @param resources <code>ValidatorResources</code> to use during validation.
154 |  |
          * @param formName Key used for retrieving the set of validation rules.
155 |  |
          */
156 | 110 |
         public Validator(ValidatorResources resources, String formName) {
157 | 110 |
             if (resources == null) {
158 | 0 |
                 throw new IllegalArgumentException("Resources cannot be null.");
159 |  |
             }
160 |  |
161 | 110 |
             this.resources = resources;
162 | 110 |
             this.formName = formName;
163 | 110 |
         }
164 |  |
165 |  |
         /**
166 |  |
          * Construct a <code>Validator</code> that will
167 |  |
          * use the <code>ValidatorResources</code>
168 |  |
          * passed in to retrieve pluggable validators
169 |  |
          * the different sets of validation rules.
170 |  |
          *
171 |  |
          * @param resources <code>ValidatorResources</code> to use during validation.
172 |  |
          * @param formName Key used for retrieving the set of validation rules.
173 |  |
          * @param fieldName Key used for retrieving the set of validation rules for a field
174 |  |
          * @since 1.2.0
175 |  |
          */
176 | 1 |
         public Validator(ValidatorResources resources, String formName, String fieldName) {
177 | 1 |
             if (resources == null) {
178 | 0 |
                 throw new IllegalArgumentException("Resources cannot be null.");
179 |  |
             }
180 |  |
181 | 1 |
             this.resources = resources;
182 | 1 |
             this.formName = formName;
183 | 1 |
             this.fieldName = fieldName;
184 | 1 |
         }
185 |  |
186 |  |
         /**
187 |  |
          * Set a parameter of a pluggable validation method.
188 |  |
          *
189 |  |
          * @param parameterClassName The full class name of the parameter of the
190 |  |
          * validation method that corresponds to the value/instance passed in with it.
191 |  |
          *
192 |  |
          * @param parameterValue The instance that will be passed into the
193 |  |
          * validation method.
194 |  |
          */
195 |  |
         public void setParameter(String parameterClassName, Object parameterValue) {
196 | 350 |
             this.parameters.put(parameterClassName, parameterValue);
197 | 350 |
         }
198 |  |
199 |  |
         /**
200 |  |
          * Returns the value of the specified parameter that will be used during the
201 |  |
          * processing of validations.
202 |  |
          *
203 |  |
          * @param parameterClassName The full class name of the parameter of the
204 |  |
          * validation method that corresponds to the value/instance passed in with it.
205 |  |
          * @return value of the specified parameter.
206 |  |
          */
207 |  |
         public Object getParameterValue(String parameterClassName) {
208 | 131 |
             return this.parameters.get(parameterClassName);
209 |  |
         }
210 |  |
211 |  |
         /**
212 |  |
          * Gets the form name which is the key to a set of validation rules.
213 |  |
          * @return the name of the form.
214 |  |
          */
215 |  |
         public String getFormName() {
216 | 0 |
             return formName;
217 |  |
         }
218 |  |
219 |  |
         /**
220 |  |
          * Sets the form name which is the key to a set of validation rules.
221 |  |
          * @param formName the name of the form.
222 |  |
          */
223 |  |
         public void setFormName(String formName) {
224 | 0 |
             this.formName = formName;
225 | 0 |
         }
226 |  |
227 |  |
         /**
228 |  |
          * Sets the name of the field to validate in a form (optional)
229 |  |
          *
230 |  |
          * @param fieldName The name of the field in a form set
231 |  |
          * @since 1.2.0
232 |  |
          */
233 |  |
         public void setFieldName(String fieldName) {
234 | 0 |
             this.fieldName = fieldName;
235 | 0 |
         }
236 |  |
237 |  |
         /**
238 |  |
          * Gets the page.  This in conjunction with the page property of
239 |  |
          * a <code>Field<code> can control the processing of fields. If the field's
240 |  |
          * page is less than or equal to this page value, it will be processed.
241 |  |
          * @return the page number.
242 |  |
          */
243 |  |
         public int getPage() {
244 | 0 |
             return page;
245 |  |
         }
246 |  |
247 |  |
         /**
248 |  |
          * Sets the page.  This in conjunction with the page property of
249 |  |
          * a <code>Field<code> can control the processing of fields. If the field's page
250 |  |
          * is less than or equal to this page value, it will be processed.
251 |  |
          * @param page the page number.
252 |  |
          */
253 |  |
         public void setPage(int page) {
254 | 0 |
             this.page = page;
255 | 0 |
         }
256 |  |
257 |  |
         /**
258 |  |
          * Clears the form name, resources that were added, and the page that was
259 |  |
          * set (if any).  This can be called to reinitialize the Validator instance
260 |  |
          * so it can be reused.  The form name (key to set of validation rules) and any
261 |  |
          * resources needed, like the JavaBean being validated, will need to
262 |  |
          * set and/or added to this instance again.  The
263 |  |
          * <code>ValidatorResources</code> will not be removed since it can be used
264 |  |
          * again and is thread safe.
265 |  |
          */
266 |  |
         public void clear() {
267 | 0 |
             this.formName = null;
268 | 0 |
             this.fieldName = null;
269 | 0 |
             this.parameters = new HashMap();
270 | 0 |
             this.page = 0;
271 | 0 |
         }
272 |  |
273 |  |
         /**
274 |  |
          * Return the boolean as to whether the context classloader should be used.
275 |  |
          * @return whether the context classloader should be used.
276 |  |
          */
277 |  |
         public boolean getUseContextClassLoader() {
278 | 0 |
             return this.useContextClassLoader;
279 |  |
         }
280 |  |
281 |  |
         /**
282 |  |
          * Determine whether to use the Context ClassLoader (the one found by
283 |  |
          * calling <code>Thread.currentThread().getContextClassLoader()</code>)
284 |  |
          * to resolve/load classes that are defined in various rules.  If not
285 |  |
          * using Context ClassLoader, then the class-loading defaults to
286 |  |
          * using the calling-class' ClassLoader.
287 |  |
          *
288 |  |
          * @param use determines whether to use Context ClassLoader.
289 |  |
          */
290 |  |
         public void setUseContextClassLoader(boolean use) {
291 | 0 |
             this.useContextClassLoader = use;
292 | 0 |
         }
293 |  |
294 |  |
         /**
295 |  |
          * Return the class loader to be used for instantiating application objects
296 |  |
          * when required.  This is determined based upon the following rules:
297 |  |
          * <ul>
298 |  |
          * <li>The class loader set by <code>setClassLoader()</code>, if any</li>
299 |  |
          * <li>The thread context class loader, if it exists and the
300 |  |
          *     <code>useContextClassLoader</code> property is set to true</li>
301 |  |
          * <li>The class loader used to load the Digester class itself.
302 |  |
          * </ul>
303 |  |
          * @return the class loader.
304 |  |
          */
305 |  |
         public ClassLoader getClassLoader() {
306 | 113 |
             if (this.classLoader != null) {
307 | 0 |
                 return this.classLoader;
308 |  |
             }
309 |  |
310 | 113 |
             if (this.useContextClassLoader) {
311 | 0 |
                 ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
312 | 0 |
                 if (contextLoader != null) {
313 | 0 |
                     return contextLoader;
314 |  |
                 }
315 |  |
             }
316 |  |
317 | 113 |
             return this.getClass().getClassLoader();
318 |  |
         }
319 |  |
320 |  |
         /**
321 |  |
          * Set the class loader to be used for instantiating application objects
322 |  |
          * when required.
323 |  |
          *
324 |  |
          * @param classLoader The new class loader to use, or <code>null</code>
325 |  |
          *  to revert to the standard rules
326 |  |
          */
327 |  |
         public void setClassLoader(ClassLoader classLoader) {
328 | 0 |
             this.classLoader = classLoader;
329 | 0 |
         }
330 |  |
331 |  |
         /**
332 |  |
          * Performs validations based on the configured resources.
333 |  |
          *
334 |  |
          * @return The <code>Map</code> returned uses the property of the
335 |  |
          * <code>Field</code> for the key and the value is the number of error the
336 |  |
          * field had.
337 |  |
          * @throws ValidatorException If an error occurs during validation
338 |  |
          */
339 |  |
         public ValidatorResults validate() throws ValidatorException {
340 | 114 |
             Locale locale = (Locale) this.getParameterValue(LOCALE_PARAM);
341 |  |
342 | 114 |
             if (locale == null) {
343 | 104 |
                 locale = Locale.getDefault();
344 |  |
             }
345 |  |
346 | 114 |
             this.setParameter(VALIDATOR_PARAM, class="keyword">this);
347 |  |
348 | 114 |
             Form form = this.resources.getForm(locale, class="keyword">this.formName);
349 | 114 |
             if (form != null) {
350 | 114 |
                 this.setParameter(FORM_PARAM, form);
351 | 114 |
                 return form.validate(
352 |  |
                     this.parameters,
353 |  |
                     this.resources.getValidatorActions(),
354 |  |
                     this.page,
355 |  |
                     this.fieldName);
356 |  |
             }
357 |  |
358 | 0 |
             return new ValidatorResults();
359 |  |
         }
360 |  |
361 |  |
         /**
362 |  |
          * Returns true if the Validator is only returning Fields that fail validation.
363 |  |
          * @return whether only failed fields are returned.
364 |  |
          */
365 |  |
         public boolean getOnlyReturnErrors() {
366 | 91 |
             return onlyReturnErrors;
367 |  |
         }
368 |  |
369 |  |
         /**
370 |  |
          * Configures which Fields the Validator returns from the validate() method.  Set this
371 |  |
          * to true to only return Fields that failed validation.  By default, validate() returns
372 |  |
          * all fields.
373 |  |
          * @param onlyReturnErrors whether only failed fields are returned.
374 |  |
          */
375 |  |
         public void setOnlyReturnErrors(boolean onlyReturnErrors) {
376 | 1 |
             this.onlyReturnErrors = onlyReturnErrors;
377 | 1 |
         }
378 |  |
379 |  |
     }

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