001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: package org.apache.wicket.validation.validator;
018:
019: import java.util.Map;
020: import java.util.regex.Pattern;
021:
022: import org.apache.wicket.util.parse.metapattern.MetaPattern;
023: import org.apache.wicket.validation.IValidatable;
024:
025: /**
026: * FIXME 2.0: ivaynberg: look over javadoc
027: *
028: * Validates component by matching the component's value against a regular
029: * expression pattern. A PatternValidator can be constructed with either a Java
030: * regular expression (compiled or not) or a MetaPattern. If the pattern matches
031: * against the value of the component it is attached to when validate() is
032: * called by the framework, then that input value is considered valid. If the
033: * pattern does not match, the errorMessage() method will be called.
034: * <p>
035: * For example, to restrict a field to only digits, you might add a
036: * PatternValidator constructed with the pattern "\d+". Another way to do the
037: * same thing would be to construct the PatternValidator passing in
038: * MetaPattern.DIGITS. The advantages of using MetaPattern over straight Java
039: * regular expressions are that the patterns are easier to construct and easier
040: * to combine into complex patterns. They are also more readable and more
041: * reusable. See {@link org.apache.wicket.util.parse.metapattern.MetaPattern}for details.
042: * <p>
043: * The error message will be generated with the key "PatternValidator" and the
044: * messages keys that can be used are:
045: * <ul>
046: * <li>${pattern}: the pattern which failed to match</li>
047: * <li>${input}: the input the user did give</li>
048: * <li>${name}: the name of the component that failed</li>
049: * <li>${label}: the label of the component - either comes from
050: * FormComponent.labelModel or resource key [form-id].[form-component-id] in
051: * that order</li>
052: * </ul>
053: *
054: * @see java.util.regex.Pattern
055: * @see org.apache.wicket.util.parse.metapattern.MetaPattern
056: * @author Jonathan Locke *
057: * @author Igor Vaynberg(ivaynberg)
058: *
059: */
060: public class PatternValidator extends StringValidator {
061: private static final long serialVersionUID = 1L;
062:
063: /** The regexp pattern. */
064: private final Pattern pattern;
065:
066: /**
067: * Constructor.
068: *
069: * @param pattern
070: * Regular expression pattern
071: */
072: public PatternValidator(final String pattern) {
073: this (Pattern.compile(pattern));
074: }
075:
076: /**
077: * Constructor.
078: *
079: * @param pattern
080: * Regular expression pattern
081: * @param flags
082: * Compile flags for java.util.regex.Pattern
083: */
084: public PatternValidator(final String pattern, final int flags) {
085: this (Pattern.compile(pattern, flags));
086: }
087:
088: /**
089: * Constructor.
090: *
091: * @param pattern
092: * Java regex pattern
093: */
094: public PatternValidator(final Pattern pattern) {
095: this .pattern = pattern;
096: }
097:
098: /**
099: * Constructor.
100: *
101: * @param pattern
102: * MetaPattern pattern
103: */
104: public PatternValidator(final MetaPattern pattern) {
105: this (pattern.pattern());
106: }
107:
108: /**
109: * Gets the regexp pattern.
110: *
111: * @return the regexp pattern
112: */
113: public final Pattern getPattern() {
114: return pattern;
115: }
116:
117: protected Map variablesMap(IValidatable validatable) {
118: final Map map = super .variablesMap(validatable);
119: map.put("pattern", pattern);
120: return map;
121: }
122:
123: /**
124: * @see java.lang.Object#toString()
125: */
126: public String toString() {
127: return "[PatternValidator pattern = " + pattern + "]";
128: }
129:
130: protected void onValidate(IValidatable validatable) {
131: // Check value against pattern
132: if (!pattern.matcher((String) validatable.getValue()).matches()) {
133: error(validatable);
134: }
135:
136: }
137:
138: }
|