/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.waveprotocol.wave.client.editor.extract;
import com.google.common.annotations.VisibleForTesting;
import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Element;
import com.google.gwt.dom.client.Node;
import com.google.gwt.dom.client.StyleInjector;
import org.waveprotocol.wave.client.debug.logger.LogLevel;
import org.waveprotocol.wave.client.editor.EditorStaticDeps;
import org.waveprotocol.wave.client.editor.RestrictedRange;
import org.waveprotocol.wave.client.editor.content.ContentElement;
import org.waveprotocol.wave.client.editor.content.ContentNode;
import org.waveprotocol.wave.client.editor.content.ContentTextNode;
import org.waveprotocol.wave.client.editor.content.ContentView;
import org.waveprotocol.wave.client.editor.extract.InconsistencyException.HtmlInserted;
import org.waveprotocol.wave.client.editor.extract.InconsistencyException.HtmlMissing;
import org.waveprotocol.wave.client.editor.impl.HtmlView;
import org.waveprotocol.wave.client.scheduler.ScheduleTimer;
import org.waveprotocol.wave.model.document.ReadableDocument;
import org.waveprotocol.wave.model.document.util.Point;
/**
* Repairs inconsistencies between content and html, in both directions.
*
* TODO(danilatos): This class is just a loosely related collection of methods,
* and does not encapsulate any state other than a reference to its bundle. Perhaps
* break it up, or convert to static methods?
*
* @author danilatos@google.com (Daniel Danilatos)
*/
public class Repairer {
/** For testing/debug purposes, treat repairs as fatal errors */
@VisibleForTesting public static boolean debugRepairIsFatal = getAssertionsOn();
private static boolean getAssertionsOn() {
try {
assert false;
} catch (AssertionError e) {
return true;
}
return false;
}
/**
* Resources for repairing & problem finding
*/
public static final ExtractResources resources;
static {
if (GWT.isClient()) {
resources = GWT.create(ExtractResources.class);
StyleInjector.inject(resources.css().getText(), true);
} else {
resources = null;
}
}
private final ContentView persistentView, renderedView;
private final HtmlView strippingView;
private final RepairListener listener;
/**
* @param persistentView
* @param renderedView
* @param strippingView
*/
public Repairer(ContentView persistentView, ContentView renderedView, HtmlView strippingView,
RepairListener listener) {
this.persistentView = persistentView;
this.renderedView = renderedView;
this.strippingView = strippingView;
this.listener = listener;
}
/**
* Generic handler for any inconsistency exception
* @param error
*/
public void handle(InconsistencyException error) {
// Do something nicer (visitor?) if we end up with more
// inconsistency exception types
if (error instanceof HtmlInserted) {
handleInserted((HtmlInserted) error);
} else {
handleMissing((HtmlMissing) error);
}
}
/**
* Specific handler for {@link HtmlInserted}
* Currently just reverts the HTML
* @param error
*/
public void handleInserted(HtmlInserted error) {
EditorStaticDeps.logger.error().log("handleInserted: ", error);
assert false : "Repairer triggered, handleInserted";
revert(error.getContentPoint(), null);
}
/**
* Specific handler for {@link HtmlMissing}
* Currently just reverts the HTML
* @param error
*/
public void handleMissing(HtmlMissing error) {
EditorStaticDeps.logger.error().log("handleMissing: ", error);
assert false : "Repairer triggered, handleMissing";
revert(Point.before(renderedView, error.getBrokenNode()), null);
}
/**
* Revert the HTML implementation between two node-bounded points.
* The points must be in the container element.
* TODO(danilatos): Change interface to use RestrictedRange, or improve
* implementation to not require restriction.
*
* @param start
* @param end if null, keep going until consistency is found
*/
@SuppressWarnings("deprecation")
private void revertWithoutNotification(Point.El<ContentNode> start, Point.El<ContentNode> end) {
if (debugRepairIsFatal) {
throw new RuntimeException("Repair is fatal");
}
if (start.getContainer() == null) {
revert(renderedView, renderedView.getDocumentElement());
return;
}
EditorStaticDeps.startIgnoreMutations();
try {
// TODO(danilatos): Log all calls to here, & find causes.
// In the ideal universe, there would be none!
EditorStaticDeps.logger.error().logPlainText("REPAIRING!! " + start.getContainer());
flashShowRepair((ContentElement) start.getContainer());
try {
revertInner(start, end);
return;
} catch (RuntimeException t1) {
EditorStaticDeps.logger.error().logPlainText("exception while revertInner: " + t1);
for (ContentNode attempt = start.getContainer(); attempt != null; attempt =
attempt.getParentElement()) {
try {
attempt.revertImplementation();
return;
} catch (RuntimeException t2) {
EditorStaticDeps.logger.error().logPlainText(
"Exception while revertImplementation: " + t2);
// iterate
if (attempt == persistentView.getDocumentElement()) {
// We cannot reconstruct the document. Re-throw the original exception from
// the first repair attempt so we get as meaningful an error message and
// stacktrace as possible.
throw t1;
}
}
}
}
} finally {
EditorStaticDeps.endIgnoreMutations();
}
EditorStaticDeps.logger.trace().logPlainText("Revert successful");
}
/**
* Same as {@link #revertWithoutNotification(Point.El, Point.El)}, but first notifies listener.
*/
public void revert(Point.El<ContentNode> start, Point.El<ContentNode> end) {
// notify and fix
listener.onRangeRevert(start, end);
revertWithoutNotification(start, end);
}
/**
* Reverts the entire content of a particular element
* @param doc The document containing the element to revert
* @param element The element to revert
*/
public void revert(ReadableDocument<ContentNode, ContentElement, ContentTextNode> doc,
ContentElement element) {
// find start and end as points
Point.El<ContentNode> start = Point.start(doc, element);
Point.El<ContentNode> end = Point.end((ContentNode) element);
// notify and fix.
if (element == doc.getDocumentElement()) {
listener.onFullDocumentRevert(doc);
} else {
listener.onRangeRevert(start, end);
}
revertWithoutNotification(start, end);
}
/**
* Briefly give a visual cue that the given element has been repaired
* @param regionNode
*/
public void flashShowRepair(final ContentElement regionNode) {
EditorStaticDeps.logger.error().log("repairing region: " + regionNode);
if (!LogLevel.showErrors()) {
return;
}
if (regionNode.getImplNodelet() == null) {
return;
}
regionNode.getImplNodelet().addClassName(resources.css().repaired());
ScheduleTimer t = new ScheduleTimer() {
@Override
public void run() {
regionNode.getImplNodelet().removeClassName(resources.css().repaired());
}
};
t.schedule(800);
}
/**
* Mark a region (probably everything) as not recoverable
* @param regionNode
*/
public void showDeath(ContentElement regionNode) {
if (!LogLevel.showErrors()) {
return;
}
if (regionNode.getImplNodelet() != null) {
regionNode.getImplNodelet().addClassName(resources.css().dead());
}
}
/**
* Clear death marking. Probably because we are calling setContent and
* totally refreshing everything.
*
* @param regionNode
*/
public void hideDeath(ContentElement regionNode) {
if (!LogLevel.showErrors()) {
return;
}
if (regionNode.getImplNodelet() != null) {
regionNode.getImplNodelet().removeClassName(resources.css().dead());
}
}
/**
* Same as {@link #revertWithoutNotification(Point.El, Point.El)}, but without runtime exception
* handling
*/
void revertInner(Point.El<ContentNode> start, Point.El<ContentNode> end) {
// TODO(danilatos): This naive implementation has three main problems
// 1. It does more work than it needs to, by throwing everything away and
// redoing it
// 2. It blatantly disregards transparent nodes. It should "work" with them
// around, but it might mess them up.
// 3. The code is too complicated
ContentView renderedContent = renderedView;
assert end == null || end.getContainer() == start.getContainer() :
"No reverting across elements";
ContentNode before = Point.nodeBefore(renderedContent, start);
Node nodeletBefore = before == null ? null : before.getImplNodelet();
Element parentNodelet;
if (nodeletBefore == null) {
parentNodelet = renderedContent.getVisibleNode(start.getContainer()).getImplNodelet().cast();
} else {
parentNodelet = nodeletBefore.getParentElement();
}
ContentNode first = start.getNodeAfter();
ContentNode last = end == null ? null : end.getNodeAfter();
assert renderedContent.getVisibleNode(first) == first;
assert renderedContent.getVisibleNode(last) == last;
assert last == null
|| renderedContent.getParentElement(first) == renderedContent.getParentElement(last)
: "First and last are expected to have same parent";
{
ContentNode node;
for (node = first; node != last; node = renderedContent.getNextSibling(node)) {
// If node is consistent, we assume the ones after are ok.
if (end == null && node.isConsistent()) {
break;
}
node.revertImplementation();
}
last = node;
}
// TODO(danilatos): Actually use some view that strips unknown nodes out. or do something
// better.
Node nodeletAfter = last == null ? null : last.getImplNodelet();
reattachImplChildren(parentNodelet, nodeletBefore, nodeletAfter, first, last);
}
private void reattachImplChildren(Node parentNodelet, Node nodeletBefore, Node nodeletAfter,
ContentNode first, ContentNode last) {
// TODO(danilatos): Replace this hairy code with pre-order traversal
// getters, once they exist
while (true) {
Node nodelet = nodeletBefore == null
? strippingView.getFirstChild(parentNodelet)
: strippingView.getNextSibling(nodeletBefore);
if (nodelet == null || nodelet == nodeletAfter) {
break;
}
if (nodelet.getParentElement() != null) {
nodelet.removeFromParent();
}
}
for (ContentNode node = first; node != last; node = renderedView.getNextSibling(node)) {
parentNodelet.insertBefore(node.getImplNodelet(), nodeletAfter);
}
}
/**
* Zip between the given range
* @see ContentElement#zipChildren(ContentNode, ContentNode, Node)
* @param range
* @param userSelection Node within which the user has their selection. If
* zipping ends up splitting it, we will return true, so we know if we
* need to restore the selection.
* HACK(danilatos): This is a bit nasty. Better way? (issue can probably
* be avoided altogether if we can have some control on which text nodes
* operations affect, when there is a choice).
* @return true if html in the user's selection was affected
* (e.g. splitting a text node)
*/
public boolean zipRange(RestrictedRange<ContentNode> range, Node userSelection) {
try {
// nodeAfter is 1 further than we need, but meh
return ((ContentElement)range.getContainer()).zipChildrenExcludingFrom(
range.getNodeBefore(), range.getNodeAfter(), userSelection);
} catch (RuntimeException t) {
// Do the more expensive, but robust action
// TODO(danilatos): Should this be content or renderedContent?
revert(range.getPointBefore(persistentView), range.getPointAfter());
return true;
}
}
}