Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.validator.Form |
82% |
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.ArrayList;
21 |  |
     import java.util.Collections;
22 |  |
     import java.util.Iterator;
23 |  |
     import java.util.List;
24 |  |
     import java.util.Map;
25 |  |
26 |  |
     import org.apache.commons.collections.FastHashMap;// DEPRECATED
27 |  |
28 |  |
     /**
29 |  |
      * <p>
30 |  |
      *
31 |  |
      * This contains a set of validation rules for a form/JavaBean. The information
32 |  |
      * is contained in a list of <code>Field</code> objects. Instances of this class
33 |  |
      * are configured with a &lt;form&gt; xml element. </p> <p>
34 |  |
      *
35 |  |
      * The use of FastHashMap is deprecated and will be replaced in a future
36 |  |
      * release. </p>
37 |  |
      *
38 |  |
      * @version $Revision: 478334 $ $Date: 2006-11-22 21:31:54 +0000 (Wed, 22 Nov 2006) $
39 |  |
      */
40 | 852 |
     public class Form implements Serializable {
41 |  |
42 |  |
         /** The name/key the set of validation rules is stored under. */
43 | 426 |
         protected String name = null;
44 |  |
45 |  |
         /**
46 |  |
          * List of <code>Field</code>s. Used to maintain the order they were added
47 |  |
          * in although individual <code>Field</code>s can be retrieved using <code>Map</code>
48 |  |
          * of <code>Field</code>s.
49 |  |
          */
50 | 426 |
         protected List lFields = new ArrayList();
51 |  |
52 |  |
         /**
53 |  |
          * Map of <code>Field</code>s keyed on their property value.
54 |  |
          *
55 |  |
          * @deprecated   Subclasses should use getFieldMap() instead.
56 |  |
          */
57 | 426 |
         protected FastHashMap hFields = new FastHashMap();
58 |  |
59 |  |
         /**
60 |  |
          * The name/key of the form which this form extends from.
61 |  |
          *
62 |  |
          * @since   Validator 1.2.0
63 |  |
          */
64 | 426 |
         protected String inherit = null;
65 |  |
66 |  |
         /**
67 |  |
          * Whether or not the this <code>Form</code> was processed for replacing
68 |  |
          * variables in strings with their values.
69 |  |
          */
70 | 426 |
         private boolean processed = false;
71 |  |
72 |  |
         /**
73 |  |
          * Gets the name/key of the set of validation rules.
74 |  |
          *
75 |  |
          * @return   The name value
76 |  |
          */
77 |  |
         public String getName() {
78 | 962 |
             return name;
79 |  |
         }
80 |  |
81 |  |
         /**
82 |  |
          * Sets the name/key of the set of validation rules.
83 |  |
          *
84 |  |
          * @param name  The new name value
85 |  |
          */
86 |  |
         public void setName(String name) {
87 | 426 |
             this.name = name;
88 | 426 |
         }
89 |  |
90 |  |
         /**
91 |  |
          * Add a <code>Field</code> to the <code>Form</code>.
92 |  |
          *
93 |  |
          * @param f  The field
94 |  |
          */
95 |  |
         public void addField(Field f) {
96 | 513 |
             this.lFields.add(f);
97 | 513 |
             this.hFields.put(f.getKey(), f);
98 | 513 |
         }
99 |  |
100 |  |
         /**
101 |  |
          * A <code>List</code> of <code>Field</code>s is returned as an unmodifiable
102 |  |
          * <code>List</code>.
103 |  |
          *
104 |  |
          * @return   The fields value
105 |  |
          */
106 |  |
         public List getFields() {
107 | 77 |
             return Collections.unmodifiableList(lFields);
108 |  |
         }
109 |  |
110 |  |
         /**
111 |  |
          * Returns the Field with the given name or null if this Form has no such
112 |  |
          * field.
113 |  |
          *
114 |  |
          * @param fieldName  The field name
115 |  |
          * @return           The field value
116 |  |
          * @since            Validator 1.1
117 |  |
          */
118 |  |
         public Field getField(String fieldName) {
119 | 100 |
             return (Field) this.hFields.get(fieldName);
120 |  |
         }
121 |  |
122 |  |
         /**
123 |  |
          * Returns true if this Form contains a Field with the given name.
124 |  |
          *
125 |  |
          * @param fieldName  The field name
126 |  |
          * @return           True if this form contains the field by the given name
127 |  |
          * @since            Validator 1.1
128 |  |
          */
129 |  |
         public boolean containsField(String fieldName) {
130 | 70 |
             return this.hFields.containsKey(fieldName);
131 |  |
         }
132 |  |
133 |  |
         /**
134 |  |
          * Merges the given form into this one. For any field in <code>depends</code>
135 |  |
          * not present in this form, include it. <code>depends</code> has precedence
136 |  |
          * in the way the fields are ordered.
137 |  |
          *
138 |  |
          * @param depends  the form we want to merge
139 |  |
          * @since          Validator 1.2.0
140 |  |
          */
141 |  |
         protected void merge(Form depends) {
142 |  |
143 | 55 |
             List templFields = new ArrayList();
144 | 55 |
             Map temphFields = new FastHashMap();
145 | 55 |
             Iterator dependsIt = depends.getFields().iterator();
146 | 180 |
             while (dependsIt.hasNext()) {
147 | 70 |
                 Field defaultField = (Field) dependsIt.next();
148 | 70 |
                 if (defaultField != null) {
149 | 70 |
                     String fieldKey = defaultField.getKey();
150 | 70 |
                     if (!this.containsField(fieldKey)) {
151 | 0 |
                         templFields.add(defaultField);
152 | 0 |
                         temphFields.put(fieldKey, defaultField);
153 |  |
                     }
154 |  |
                     else {
155 | 70 |
                         Field old = getField(fieldKey);
156 | 70 |
                         hFields.remove(fieldKey);
157 | 70 |
                         lFields.remove(old);
158 | 70 |
                         templFields.add(old);
159 | 70 |
                         temphFields.put(fieldKey, old);
160 |  |
                     }
161 |  |
                 }
162 |  |
             }
163 | 55 |
             lFields.addAll(0, templFields);
164 | 55 |
             hFields.putAll(temphFields);
165 | 55 |
         }
166 |  |
167 |  |
         /**
168 |  |
          * Processes all of the <code>Form</code>'s <code>Field</code>s.
169 |  |
          *
170 |  |
          * @param globalConstants  A map of global constants
171 |  |
          * @param constants        Local constants
172 |  |
          * @param forms            Map of forms
173 |  |
          * @since                  Validator 1.2.0
174 |  |
          */
175 |  |
         protected void process(Map globalConstants, Map constants, Map forms) {
176 | 497 |
             if (isProcessed()) {
177 | 71 |
                 return;
178 |  |
             }
179 |  |
180 | 426 |
             int n = 0;//we want the fields from its parent first
181 | 426 |
             if (isExtending()) {
182 | 16 |
                 Form parent = (Form) forms.get(inherit);
183 | 16 |
                 if (parent != null) {
184 | 16 |
                     if (!parent.isProcessed()) {
185 |  |
                         //we want to go all the way up the tree
186 | 16 |
                         parent.process(constants, globalConstants, forms);
187 |  |
                     }
188 | 56 |
                     for (Iterator i = parent.getFields().iterator(); i.hasNext(); ) {
189 | 24 |
                         Field f = (Field) i.next();
190 |  |
                         //we want to be able to override any fields we like
191 | 24 |
                         if (hFields.get(f.getKey()) == null) {
192 | 8 |
                             lFields.add(n, f);
193 | 8 |
                             hFields.put(f.getKey(), f);
194 | 8 |
                             n++;
195 |  |
                         }
196 |  |
                     }
197 |  |
                 }
198 |  |
             }
199 | 426 |
             hFields.setFast(true);
200 |  |
             //no need to reprocess parent's fields, we iterate from 'n'
201 | 1365 |
             for (Iterator i = lFields.listIterator(n); i.hasNext(); ) {
202 | 513 |
                 Field f = (Field) i.next();
203 | 513 |
                 f.process(globalConstants, constants);
204 |  |
             }
205 |  |
206 | 426 |
             processed = true;
207 | 426 |
         }
208 |  |
209 |  |
         /**
210 |  |
          * Returns a string representation of the object.
211 |  |
          *
212 |  |
          * @return string representation
213 |  |
          */
214 |  |
         public String toString() {
215 | 0 |
             StringBuffer results = new StringBuffer();
216 |  |
217 | 0 |
             results.append("Form: ");
218 | 0 |
             results.append(name);
219 | 0 |
             results.append("\n");
220 |  |
221 | 0 |
             for (Iterator i = lFields.iterator(); i.hasNext(); ) {
222 | 0 |
                 results.append("\tField: \n");
223 | 0 |
                 results.append(i.next());
224 | 0 |
                 results.append("\n");
225 |  |
             }
226 |  |
227 | 0 |
             return results.toString();
228 |  |
         }
229 |  |
230 |  |
         /**
231 |  |
          * Validate all Fields in this Form on the given page and below.
232 |  |
          *
233 |  |
          * @param params               A Map of parameter class names to parameter
234 |  |
          *      values to pass into validation methods.
235 |  |
          * @param actions              A Map of validator names to ValidatorAction
236 |  |
          *      objects.
237 |  |
          * @param page                 Fields on pages higher than this will not be
238 |  |
          *      validated.
239 |  |
          * @return                     A ValidatorResults object containing all
240 |  |
          *      validation messages.
241 |  |
          * @throws ValidatorException
242 |  |
          */
243 |  |
         ValidatorResults validate(Map params, Map actions, int page)
244 |  |
             throws ValidatorException {
245 | 0 |
             return validate(params, actions, page, null);
246 |  |
         }
247 |  |
248 |  |
         /**
249 |  |
          * Validate all Fields in this Form on the given page and below.
250 |  |
          *
251 |  |
          * @param params               A Map of parameter class names to parameter
252 |  |
          *      values to pass into validation methods.
253 |  |
          * @param actions              A Map of validator names to ValidatorAction
254 |  |
          *      objects.
255 |  |
          * @param page                 Fields on pages higher than this will not be
256 |  |
          *      validated.
257 |  |
          * @return                     A ValidatorResults object containing all
258 |  |
          *      validation messages.
259 |  |
          * @throws ValidatorException
260 |  |
          * @since 1.2.0
261 |  |
          */
262 |  |
         ValidatorResults validate(Map params, Map actions, int page, String fieldName)
263 |  |
             throws ValidatorException {
264 |  |
265 | 114 |
             ValidatorResults results = new ValidatorResults();
266 | 114 |
             params.put(Validator.VALIDATOR_RESULTS_PARAM, results);
267 |  |
268 |  |
             // Only validate a single field if specified
269 | 114 |
             if (fieldName != null) {
270 | 1 |
                 Field field = (Field) this.hFields.get(fieldName);
271 |  |
272 | 1 |
                 if (field == null) {
273 | 0 |
                    throw new ValidatorException("Unknown field "+fieldName+" in form "+getName());
274 |  |
                 }
275 | 1 |
                 params.put(Validator.FIELD_PARAM, field);
276 |  |
277 | 1 |
                 if (field.getPage() <= page) {
278 | 1 |
                    results.merge(field.validate(params, actions));
279 |  |
                 }
280 |  |
             } else {
281 | 113 |
                 Iterator fields = this.lFields.iterator();
282 | 387 |
                 while (fields.hasNext()) {
283 | 162 |
                     Field field = (Field) fields.next();
284 |  |
285 | 162 |
                     params.put(Validator.FIELD_PARAM, field);
286 |  |
287 | 162 |
                     if (field.getPage() <= page) {
288 | 162 |
                         results.merge(field.validate(params, actions));
289 |  |
                     }
290 |  |
                 }
291 |  |
             }
292 |  |
293 | 113 |
             return results;
294 |  |
         }
295 |  |
296 |  |
         /**
297 |  |
          * Whether or not the this <code>Form</code> was processed for replacing
298 |  |
          * variables in strings with their values.
299 |  |
          *
300 |  |
          * @return   The processed value
301 |  |
          * @since    Validator 1.2.0
302 |  |
          */
303 |  |
         public boolean isProcessed() {
304 | 513 |
             return processed;
305 |  |
         }
306 |  |
307 |  |
         /**
308 |  |
          * Gets the name/key of the parent set of validation rules.
309 |  |
          *
310 |  |
          * @return   The extends value
311 |  |
          * @since    Validator 1.2.0
312 |  |
          */
313 |  |
         public String getExtends() {
314 | 0 |
             return inherit;
315 |  |
         }
316 |  |
317 |  |
         /**
318 |  |
          * Sets the name/key of the parent set of validation rules.
319 |  |
          *
320 |  |
          * @param inherit  The new extends value
321 |  |
          * @since          Validator 1.2.0
322 |  |
          */
323 |  |
         public void setExtends(String inherit) {
324 | 16 |
             this.inherit = inherit;
325 | 16 |
         }
326 |  |
327 |  |
         /**
328 |  |
          * Get extends flag.
329 |  |
          *
330 |  |
          * @return   The extending value
331 |  |
          * @since    Validator 1.2.0
332 |  |
          */
333 |  |
         public boolean isExtending() {
334 | 426 |
             return inherit != null;
335 |  |
         }
336 |  |
337 |  |
         /**
338 |  |
          * Returns a Map of String field keys to Field objects.
339 |  |
          *
340 |  |
          * @return   The fieldMap value
341 |  |
          * @since    Validator 1.2.0
342 |  |
          */
343 |  |
         protected Map getFieldMap() {
344 | 0 |
             return hFields;
345 |  |
         }
346 |  |
     }

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