user/src/com/google/gwt/editor/client/impl/SimpleViolation.java

/*
 * Copyright 2011 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.editor.client.impl;

import com.google.gwt.editor.client.Editor;
import com.google.gwt.editor.client.EditorDriver;
import com.google.gwt.editor.client.impl.DelegateMap.KeyMethod;

import java.util.Iterator;
import java.util.List;

import javax.validation.ConstraintViolation;

/**
 * Abstraction of a ConstraintViolation or a RequestFactory Violation object.
 * Also contains a factory method to create SimpleViolation instances from
 * {@link ConstraintViolation} objects.
 */
public abstract class SimpleViolation {
  /**
   * Provides a source of SimpleViolation objects based on ConstraintViolations.
   * This is re-used by the RequestFactoryEditorDriver implementation, which
   * does not share a type hierarchy with the SimpleBeanEditorDriver.
   */
  static class ConstraintViolationIterable implements Iterable<SimpleViolation> {

    private final Iterable<ConstraintViolation<?>> violations;

    public ConstraintViolationIterable(
        Iterable<ConstraintViolation<?>> violations) {
      this.violations = violations;
    }

    public Iterator<SimpleViolation> iterator() {
      // Use a fresh source iterator each time
      final Iterator<ConstraintViolation<?>> source = violations.iterator();
      return new Iterator<SimpleViolation>() {
        public boolean hasNext() {
          return source.hasNext();
        }

        public SimpleViolation next() {
          return new SimpleViolationAdapter(source.next());
        }

        public void remove() {
          source.remove();
        }
      };
    }
  }

  /**
   * Adapts the ConstraintViolation interface to the SimpleViolation interface.
   */
  static class SimpleViolationAdapter extends SimpleViolation {
    private final ConstraintViolation<?> v;

    public SimpleViolationAdapter(ConstraintViolation<?> v) {
      this.v = v;
    }

    @Override
    public Object getKey() {
      return v.getRootBean();
    }

    @Override
    public String getMessage() {
      return v.getMessage();
    }

    @Override
    public String getPath() {
      /*
       * TODO(bobv,nchalko): Determine the correct way to extract this
       * information from the ConstraintViolation.
       */
      return v.getPropertyPath().toString();
    }

    @Override
    public Object getUserDataObject() {
      return v;
    }
  }

  public static Iterable<SimpleViolation> iterableFromConstrantViolations(
      Iterable<ConstraintViolation<?>> violations) {
    return new ConstraintViolationIterable(violations);
  }

  /**
   * Maps an abstract representation of a violation into the appropriate
   * EditorDelegate.
   */
  public static void pushViolations(Iterable<SimpleViolation> violations,
      EditorDriver<?> driver, KeyMethod keyMethod) {
    if (violations == null) {
      return;
    }

    DelegateMap delegateMap = DelegateMap.of(driver, keyMethod);

    // For each violation
    for (SimpleViolation error : violations) {
      Object key = error.getKey();
      List<AbstractEditorDelegate<?, ?>> delegateList = delegateMap.get(key);
      if (delegateList != null) {

        // For each delegate editing some record...
        for (AbstractEditorDelegate<?, ?> baseDelegate : delegateList) {

          // compute its base path in the hierarchy...
          String basePath = baseDelegate.getPath();

          // and the absolute path of the leaf editor receiving the error.
          String absolutePath = (basePath.length() > 0 ? basePath + "." : "")
              + error.getPath();
          final String originalAbsolutePath = absolutePath;
          while (true) {
            if (processLeafDelegates(
                delegateMap, originalAbsolutePath, absolutePath, error)) {
              break;
            } else if (processEditors(
                delegateMap, baseDelegate, absolutePath, error)) {
              break;
            } else {
              // This is guaranteed to never happen because we should always
              // process a delegate/editor if the absolutePath is empty.
              // Still, we have the check here to prevent an infinite
              // loop if something goes wrong.
              if (absolutePath.isEmpty()) {
                throw new IllegalStateException(
                    "No editor: " + originalAbsolutePath);
              }
              absolutePath = getParentPath(absolutePath);
            }
          }
        }
      }
    }
  }

  /**
   * Returns the path with everything after the last '.' stripped off,
   * or "" if there was no '.' in the path.
   */
  private static String getParentPath(String absolutePath) {
    // Traverse upwards in the path to the parents in order
    // to report the error to the nearest valid parent.
    int dotIdx = absolutePath.lastIndexOf('.');
    if (dotIdx > 0) {
      return absolutePath.substring(0, dotIdx);
    }
    return "";
  }

  /**
   * Records an error in any editors that match the path, returning true
   * if any editors matched.
   */
  private static boolean processEditors(DelegateMap delegateMap,
      AbstractEditorDelegate<?, ?> baseDelegate,
      String absolutePath,
      SimpleViolation error) {
    List<Editor<?>> editors = delegateMap.getEditorByPath(absolutePath);
    if (editors == null) {
      return false;
    }
    // No EditorDelegate to attach it to, so record on the baseDelegate
    // with the appropriate editor & path.
    for (Editor<?> editor : editors) {
      baseDelegate.recordError(error.getMessage(), null,
          error.getUserDataObject(), error.getPath(), editor);
    }
    return true;
  }

  /**
   * Records an error in any delegates that match the {@code absolutePath},
   * returning true if any matched.  ({@code originalAbsolutePath}
   * is not used for finding delegates, but is instead used to determine
   * how to record the error.)
   */
  private static boolean processLeafDelegates(DelegateMap delegateMap,
      String originalAbsolutePath,
      String absolutePath,
      SimpleViolation error) {
    // Find the leaf editor's delegate.
    List<AbstractEditorDelegate<?, ?>> leafDelegates =
      delegateMap.getDelegatesByPath(absolutePath);
    if (leafDelegates == null) {
      return false;
    }
    String addlPath = originalAbsolutePath.substring(absolutePath.length());
    for (AbstractEditorDelegate<?, ?> delegate : leafDelegates) {
      // If this is the original path value, don't record the additional path.
      if (addlPath.isEmpty()) {
        delegate.recordError(error.getMessage(), null,
            error.getUserDataObject());
      } else {
        // Otherwise, include the additional path.
        delegate.recordError(error.getMessage(), null,
            error.getUserDataObject(), addlPath,
            delegate.getEditor());
      }
    }
    return true;
  }

  /**
   * Typically constructed via factory methods.
   */
  protected SimpleViolation() {
  }

  /**
   * Return the object that the violation is about.
   */
  public abstract Object getKey();

  /**
   * Return a user-facing message describing the violation.
   */
  public abstract String getMessage();

  /**
   * Return a dotted path describing the property.
   */
  public abstract String getPath();

  /**
   * An object that should be available from
   * {@link com.google.gwt.editor.client.EditorError#getUserData()}.
   */
  public abstract Object getUserDataObject();
}