AbstractValidDate.java

/*******************************************************************************
 * Copyright (c) 2007, 2014 compeople AG and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    compeople AG - initial API and implementation
 *******************************************************************************/
package org.eclipse.riena.ui.ridgets.validation;

import java.text.ParsePosition;
import java.text.SimpleDateFormat;

import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExecutableExtension;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.osgi.util.NLS;

import org.eclipse.riena.core.util.PropertiesUtils;
import org.eclipse.riena.ui.ridgets.IDateTextRidget;
import org.eclipse.riena.ui.ridgets.nls.Messages;

/**
 * Validator checking that a String matches a given pattern for a Date.
 */
public abstract class AbstractValidDate implements IValidator, IExecutableExtension {

	private static final String DAY_COMPONENT_LETTER = "d"; //$NON-NLS-1$
	private static final String MONTH_COMPONENT_LETTER = "M"; //$NON-NLS-1$
	private static final String YEAR_COMPONENT_LETTER = "y"; //$NON-NLS-1$
	private static final String A_LEAP_YEAR = "2004"; //$NON-NLS-1$

	/**
	 * the separator key used in the format for this date validation rule
	 */
	private static final char SEPERATOR_KEY = '.'; // default is the dot-separator

	// placeholderValid to use in completion, if no input occurs between two
	// separators
	private static final String PLACEHOLDER_VALID = "1"; //$NON-NLS-1$
	// placeholderInvalid to use in completion to mark invalid input. May be
	// used, if input occurs for
	// some part of the format pattern, which should be marked as invalid.
	// Example: yyyy is the part of the format pattern to be validated and the
	// input is 0xx and should be
	// marked invalid, so 0xx is replaced by ?.
	private static final String PLACEHOLDER_INVALID = "?"; //$NON-NLS-1$

	private String pattern;

	private boolean checkValidIntermediate;

	/**
	 * Creates a StringToDateValidator.
	 */
	protected AbstractValidDate(final boolean checkValidIntermediate) {
		this("", checkValidIntermediate); //$NON-NLS-1$
	}

	/**
	 * Creates a StringToDateValidator.
	 * 
	 * @param pattern
	 *            The pattern to match e.g. MM/dd/yyyy.
	 */
	public AbstractValidDate(final String pattern, final boolean checkValidIntermediate) {
		this.pattern = pattern;
		this.checkValidIntermediate = checkValidIntermediate;
	}

	/**
	 * @see org.eclipse.core.databinding.validation.IValidator#validate(java.lang.Object)
	 */
	public IStatus validate(final Object value) {
		if (value != null) {
			if (!(value instanceof String)) {
				throw new ValidationFailure("ValidCharacters can only validate objects of type String."); //$NON-NLS-1$
			}
			final String string = (String) value;

			// an empty String should not create an ErrorMarker
			if (Utils.isEmptyDate(string)) {
				return ValidationRuleStatus.ok();
			}

			if (string.length() > 0 && !isDateValid(string, pattern)) {
				final String message = NLS.bind(Messages.AbstractValidDate_error_invalidDate, pattern);
				return ValidationRuleStatus.error(false, message);
			}
		}
		return ValidationRuleStatus.ok();
	}

	private boolean isDateValid(String value, String datePattern) {
		// fix for problem report #651
		// workaround for org.apache.commons.validator.GenericValidator bug #221
		// https://issues.apache.org/jira/browse/VALIDATOR-221
		if (datePattern.contains(DAY_COMPONENT_LETTER) && datePattern.contains(MONTH_COMPONENT_LETTER)
				&& !datePattern.contains(YEAR_COMPONENT_LETTER)) {
			datePattern += SEPERATOR_KEY + YEAR_COMPONENT_LETTER + YEAR_COMPONENT_LETTER + YEAR_COMPONENT_LETTER
					+ YEAR_COMPONENT_LETTER;
			value += SEPERATOR_KEY + A_LEAP_YEAR;
		}

		if (checkValidIntermediate) {
			return isDate(complete(value, datePattern), datePattern, false);
		}
		return isDate(value, datePattern, true);
		// if (checkValidIntermediate) {
		// return GenericValidator.isDate(complete(value, datePattern),
		// datePattern, false);
		// }
		// return GenericValidator.isDate(value, datePattern, true);
	}

	private boolean isDate(final String value, final String pattern, final boolean strict) {
		if (value == null || pattern == null || pattern.length() <= 0) {

			return false;
		}
		if (strict && value.length() != pattern.length()) {
			return false;
		}
		final SimpleDateFormat formatter = new SimpleDateFormat(pattern);
		formatter.setLenient(false);

		final ParsePosition pos = new ParsePosition(0);
		formatter.parse(value, pos);
		if (pos.getErrorIndex() != -1) {
			return false;
		}
		if (strict) {
			if (pos.getIndex() < value.length()) {
				return false;
			}
		}
		return true;
	}

	private String complete(final String value, final String datePattern) {

		final StringBuilder completedValue = new StringBuilder();
		String valueToCheck = value;
		String datePatternToCheck = datePattern;
		int nextSeparatorIndex = nextSeparatorIndex(datePatternToCheck);
		while (nextSeparatorIndex != -1) {
			final int nextSeparatorIndexOfValueToCheck = valueToCheck.indexOf(datePatternToCheck
					.charAt(nextSeparatorIndex));
			if (nextSeparatorIndexOfValueToCheck == -1) {
				break;
			}
			if (nextSeparatorIndexOfValueToCheck == 0
					|| isPlaceholderInvalidSubstitutionNeeded(valueToCheck.substring(0,
							nextSeparatorIndexOfValueToCheck))) {
				completedValue.append(PLACEHOLDER_VALID);
				completedValue.append(valueToCheck.charAt(nextSeparatorIndexOfValueToCheck));
			} else if (isNoPossibleCompletionToAllowedYear(valueToCheck.substring(0, nextSeparatorIndexOfValueToCheck),
					datePatternToCheck)) {
				completedValue.append(PLACEHOLDER_INVALID);
			} else {
				completedValue.append(valueToCheck.substring(0, nextSeparatorIndexOfValueToCheck + 1));
			}
			datePatternToCheck = datePatternToCheck.substring(nextSeparatorIndex + 1);
			valueToCheck = valueToCheck.substring(nextSeparatorIndexOfValueToCheck + 1);
			nextSeparatorIndex = nextSeparatorIndex(datePatternToCheck);
		}

		if (("".equals(valueToCheck) && !"".equals(datePatternToCheck)) //$NON-NLS-1$//$NON-NLS-2$
				|| isPlaceholderInvalidSubstitutionNeeded(valueToCheck)) {
			completedValue.append(PLACEHOLDER_VALID);
		} else if (isNoPossibleCompletionToAllowedYear(valueToCheck, datePatternToCheck)) {
			completedValue.append(PLACEHOLDER_INVALID);
		} else {
			completedValue.append(valueToCheck);
		}

		// System.out.println("completed= " + completedValue.toString());
		return completedValue.toString();
	}

	private boolean isPlaceholderInvalidSubstitutionNeeded(final String value) {
		return "0".equals(value); //$NON-NLS-1$
	}

	private boolean isNoPossibleCompletionToAllowedYear(final String value, final String datePattern) {
		boolean result = false;
		if (datePattern.startsWith(IDateTextRidget.FORMAT_YYYY)) {
			final String trimedValue = value.trim();
			result = trimedValue.length() < 2 || (trimedValue.length() > 2 && trimedValue.startsWith("0")); //$NON-NLS-1$
			// System.out.println(String.format("%s '%s' %b", datePattern, trimedValue, result));
		}
		return result;
	}

	private int nextSeparatorIndex(final String value) {
		for (int i = 0; i < value.length(); i++) {
			if (!Character.isLetter(value.charAt(i))) {
				return i;
			}
		}
		return -1;
	}

	protected void setPattern(final String pattern) {
		this.pattern = pattern;
	}

	protected void setCheckValidIntermediate(final boolean checkValidIntermediate) {
		this.checkValidIntermediate = checkValidIntermediate;
	}

	/**
	 * This method is called on a newly constructed extension for validation.
	 * After creating a new instance of {@code AbstractValidDate} this method is
	 * called to initialize the instance. The argument for initialization is in
	 * the parameter {@code data}. Is the data a string the argument is the
	 * initial value of {@code pattern}.
	 * 
	 * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org.eclipse.core.runtime.IConfigurationElement,
	 *      java.lang.String, java.lang.Object)
	 */
	public void setInitializationData(final IConfigurationElement config, final String propertyName, final Object data)
			throws CoreException {

		if (data instanceof String) {
			final String[] args = PropertiesUtils.asArray(data);
			setPattern(args[0]);
		}

	}

}