Clover coverage report - Code Coverage for tapestry release 4.0-alpha-3
Coverage timestamp: Mon May 16 2005 09:05:49 EDT
file stats: LOC: 354   Methods: 26
NCLOC: 184   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
DateValidator.java 72.7% 69.8% 53.8% 66.7%
coverage coverage
 1   
 // Copyright 2004, 2005 The Apache Software Foundation
 2   
 //
 3   
 // Licensed under the Apache License, Version 2.0 (the "License");
 4   
 // you may not use this file except in compliance with the License.
 5   
 // You may obtain a copy of the License at
 6   
 //
 7   
 //     http://www.apache.org/licenses/LICENSE-2.0
 8   
 //
 9   
 // Unless required by applicable law or agreed to in writing, software
 10   
 // distributed under the License is distributed on an "AS IS" BASIS,
 11   
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12   
 // See the License for the specific language governing permissions and
 13   
 // limitations under the License.
 14   
 
 15   
 package org.apache.tapestry.valid;
 16   
 
 17   
 import java.text.DateFormat;
 18   
 import java.text.ParseException;
 19   
 import java.text.SimpleDateFormat;
 20   
 import java.util.Calendar;
 21   
 import java.util.Date;
 22   
 import java.util.GregorianCalendar;
 23   
 import java.util.HashMap;
 24   
 import java.util.Map;
 25   
 
 26   
 import org.apache.tapestry.IMarkupWriter;
 27   
 import org.apache.tapestry.IRequestCycle;
 28   
 import org.apache.tapestry.form.IFormComponent;
 29   
 
 30   
 /**
 31   
  * Provides input validation for strings treated as dates. In addition, allows a minimum and maximum
 32   
  * date to be set.
 33   
  * 
 34   
  * @author Howard Lewis Ship
 35   
  * @since 1.0.8
 36   
  */
 37   
 
 38   
 public class DateValidator extends BaseValidator
 39   
 {
 40   
     private DateFormat _format;
 41   
 
 42   
     private String _displayFormat;
 43   
 
 44   
     private Date _minimum;
 45   
 
 46   
     private Date _maximum;
 47   
 
 48   
     private Calendar _calendar;
 49   
 
 50   
     private String _scriptPath = "/org/apache/tapestry/valid/DateValidator.script";
 51   
 
 52   
     private static DateFormat defaultDateFormat = new SimpleDateFormat("MM/dd/yyyy");
 53   
 
 54   
     private static final String defaultDateDisplayFormat = "MM/DD/YYYY";
 55   
 
 56   
     private String _dateTooEarlyMessage;
 57   
 
 58   
     private String _dateTooLateMessage;
 59   
 
 60   
     private String _invalidDateFormatMessage;
 61   
 
 62  14
     public DateValidator()
 63   
     {
 64   
 
 65   
     }
 66   
 
 67   
     /**
 68   
      * Initializes the DateValidator with properties defined by the initializer.
 69   
      * 
 70   
      * @since 4.0
 71   
      */
 72   
 
 73  0
     public DateValidator(String initializer)
 74   
     {
 75  0
         super(initializer);
 76   
     }
 77   
 
 78  2
     public void setFormat(DateFormat value)
 79   
     {
 80  2
         _format = value;
 81   
     }
 82   
 
 83  0
     public DateFormat getFormat()
 84   
     {
 85  0
         return _format;
 86   
     }
 87   
 
 88   
     /**
 89   
      * @return the {@link DateFormat}the validator will use, returning the default if no other date
 90   
      *         format is specified via {@link #setFormat(DateFormat)}
 91   
      * @since 3.0
 92   
      */
 93  11
     public DateFormat getEffectiveFormat()
 94   
     {
 95  11
         if (_format == null)
 96  9
             return defaultDateFormat;
 97   
 
 98  2
         return _format;
 99   
     }
 100   
 
 101  0
     public String getDisplayFormat()
 102   
     {
 103  0
         return _displayFormat;
 104   
     }
 105   
 
 106  0
     public void setDisplayFormat(String value)
 107   
     {
 108  0
         _displayFormat = value;
 109   
     }
 110   
 
 111   
     /**
 112   
      * @return the display format message the validator will use, returning the default if no other
 113   
      *         display format message is specified. The default is the
 114   
      *         {@link SimpleDateFormat#toPattern()}for {@link SimpleDateFormat}s, or "MM/DD/YYYY"
 115   
      *         for unknown {@link DateFormat}subclasses.
 116   
      * @since 3.0
 117   
      */
 118  2
     public String getEffectiveDisplayFormat()
 119   
     {
 120  2
         if (_displayFormat == null)
 121   
         {
 122  2
             DateFormat format = getEffectiveFormat();
 123  2
             if (format instanceof SimpleDateFormat)
 124  2
                 return ((SimpleDateFormat) format).toPattern();
 125   
 
 126  0
             return defaultDateDisplayFormat;
 127   
         }
 128   
 
 129  0
         return _displayFormat;
 130   
     }
 131   
 
 132  3
     public String toString(IFormComponent file, Object value)
 133   
     {
 134  3
         if (value == null)
 135  1
             return null;
 136   
 
 137  2
         Date date = (Date) value;
 138   
 
 139  2
         DateFormat format = getEffectiveFormat();
 140   
 
 141   
         // DateFormat is not threadsafe, so guard access to it.
 142   
 
 143  2
         synchronized (format)
 144   
         {
 145  2
             return format.format(date);
 146   
         }
 147   
     }
 148   
 
 149  11
     public Object toObject(IFormComponent field, String value) throws ValidatorException
 150   
     {
 151  11
         if (checkRequired(field, value))
 152  4
             return null;
 153   
 
 154  7
         DateFormat format = getEffectiveFormat();
 155   
 
 156  7
         Date result;
 157   
 
 158  7
         try
 159   
         {
 160   
             // DateFormat is not threadsafe, so guard access
 161   
             // to it.
 162   
 
 163  7
             synchronized (format)
 164   
             {
 165  7
                 result = format.parse(value);
 166   
             }
 167   
 
 168  5
             if (_calendar == null)
 169  5
                 _calendar = new GregorianCalendar();
 170   
 
 171  5
             _calendar.setTime(result);
 172   
 
 173   
             // SimpleDateFormat allows two-digit dates to be
 174   
             // entered, i.e., 12/24/66 is Dec 24 0066 ... that's
 175   
             // probably not what is really wanted, so treat
 176   
             // it as an invalid date.
 177   
 
 178  5
             if (_calendar.get(Calendar.YEAR) < 1000)
 179  0
                 result = null;
 180   
 
 181   
         }
 182   
         catch (ParseException ex)
 183   
         {
 184   
             // ParseException does not include a useful error message
 185   
             // about what's wrong.
 186  2
             result = null;
 187   
         }
 188   
 
 189  7
         if (result == null)
 190  2
             throw new ValidatorException(buildInvalidDateFormatMessage(field),
 191   
                     ValidationConstraint.DATE_FORMAT);
 192   
 
 193   
         // OK, check that the date is in range.
 194   
 
 195  5
         if (_minimum != null && _minimum.compareTo(result) > 0)
 196  2
             throw new ValidatorException(buildDateTooEarlyMessage(field, format.format(_minimum)),
 197   
                     ValidationConstraint.TOO_SMALL);
 198   
 
 199  3
         if (_maximum != null && _maximum.compareTo(result) < 0)
 200  2
             throw new ValidatorException(buildDateTooLateMessage(field, format.format(_maximum)),
 201   
                     ValidationConstraint.TOO_LARGE);
 202   
 
 203  1
         return result;
 204   
 
 205   
     }
 206   
 
 207  0
     public Date getMaximum()
 208   
     {
 209  0
         return _maximum;
 210   
     }
 211   
 
 212  3
     public void setMaximum(Date maximum)
 213   
     {
 214  3
         _maximum = maximum;
 215   
     }
 216   
 
 217  0
     public Date getMinimum()
 218   
     {
 219  0
         return _minimum;
 220   
     }
 221   
 
 222  3
     public void setMinimum(Date minimum)
 223   
     {
 224  3
         _minimum = minimum;
 225   
     }
 226   
 
 227   
     /**
 228   
      * @since 2.2
 229   
      */
 230   
 
 231  0
     public void renderValidatorContribution(IFormComponent field, IMarkupWriter writer,
 232   
             IRequestCycle cycle)
 233   
     {
 234  0
         if (!(isClientScriptingEnabled() && isRequired()))
 235  0
             return;
 236   
 
 237  0
         Map symbols = new HashMap();
 238   
 
 239  0
         symbols.put("requiredMessage", buildRequiredMessage(field));
 240   
 
 241  0
         processValidatorScript(_scriptPath, cycle, field, symbols);
 242   
     }
 243   
 
 244   
     /**
 245   
      * @since 2.2
 246   
      */
 247   
 
 248  0
     public String getScriptPath()
 249   
     {
 250  0
         return _scriptPath;
 251   
     }
 252   
 
 253   
     /**
 254   
      * Allows a developer to use the existing validation logic with a different client-side script.
 255   
      * This is often sufficient to allow application-specific error presentation (perhaps by using
 256   
      * DHTML to update the content of a &lt;span&gt; tag, or to use a more sophisticated pop-up
 257   
      * window than <code>window.alert()</code>).
 258   
      * 
 259   
      * @since 2.2
 260   
      */
 261   
 
 262  0
     public void setScriptPath(String scriptPath)
 263   
     {
 264  0
         _scriptPath = scriptPath;
 265   
     }
 266   
 
 267   
     /** @since 3.0 */
 268   
 
 269  0
     public String getDateTooEarlyMessage()
 270   
     {
 271  0
         return _dateTooEarlyMessage;
 272   
     }
 273   
 
 274   
     /** @since 3.0 */
 275   
 
 276  0
     public String getDateTooLateMessage()
 277   
     {
 278  0
         return _dateTooLateMessage;
 279   
     }
 280   
 
 281   
     /** @since 3.0 */
 282   
 
 283  0
     public String getInvalidDateFormatMessage()
 284   
     {
 285  0
         return _invalidDateFormatMessage;
 286   
     }
 287   
 
 288   
     /** @since 3.0 */
 289   
 
 290  2
     protected String buildInvalidDateFormatMessage(IFormComponent field)
 291   
     {
 292  2
         String pattern = getPattern(_invalidDateFormatMessage, "invalid-date-format", field
 293   
                 .getPage().getLocale());
 294   
 
 295  2
         return formatString(pattern, field.getDisplayName(), getEffectiveDisplayFormat());
 296   
     }
 297   
 
 298   
     /** @since 3.0 * */
 299   
 
 300  2
     protected String buildDateTooEarlyMessage(IFormComponent field, String earliestDate)
 301   
     {
 302  2
         String pattern = getPattern(_dateTooEarlyMessage, "date-too-early", field.getPage()
 303   
                 .getLocale());
 304   
 
 305  2
         return formatString(pattern, field.getDisplayName(), earliestDate);
 306   
     }
 307   
 
 308   
     /** @since 3.0 */
 309   
 
 310  2
     protected String buildDateTooLateMessage(IFormComponent field, String latestDate)
 311   
     {
 312  2
         String pattern = getPattern(_dateTooLateMessage, "date-too-late", field.getPage()
 313   
                 .getLocale());
 314   
 
 315  2
         return formatString(pattern, field.getDisplayName(), latestDate);
 316   
     }
 317   
 
 318   
     /**
 319   
      * Overrides the bundle key <code>date-too-early</code>. Parameter {0} is the display name of
 320   
      * the field. Parameter {1} is the earliest allowed date.
 321   
      * 
 322   
      * @since 3.0
 323   
      */
 324   
 
 325  1
     public void setDateTooEarlyMessage(String string)
 326   
     {
 327  1
         _dateTooEarlyMessage = string;
 328   
     }
 329   
 
 330   
     /**
 331   
      * Overrides the bundle key <code>date-too-late</code>. Parameter {0} is the display name of
 332   
      * the field. Parameter {1} is the latest allowed date.
 333   
      * 
 334   
      * @since 3.0
 335   
      */
 336   
 
 337  1
     public void setDateTooLateMessage(String string)
 338   
     {
 339  1
         _dateTooLateMessage = string;
 340   
     }
 341   
 
 342   
     /**
 343   
      * Overrides the bundle key <code>invalid-date-format</code>. Parameter {0} is the display
 344   
      * name of the field. Parameter {1} is the allowed format.
 345   
      * 
 346   
      * @since 3.0
 347   
      */
 348   
 
 349  1
     public void setInvalidDateFormatMessage(String string)
 350   
     {
 351  1
         _invalidDateFormatMessage = string;
 352   
     }
 353   
 
 354   
 }