Coverage report

  %line %branch
org.apache.commons.validator.Validator
57% 
93% 

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

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