/**
* 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 org.waveprotocol.wave.client.editor.content.misc.CaretAnnotations;
import org.waveprotocol.wave.client.editor.content.misc.CaretAnnotations.AnnotationResolver;
import org.waveprotocol.wave.model.document.util.DocProviders;
import junit.framework.TestCase;
import org.waveprotocol.wave.model.document.AnnotationBehaviour;
import org.waveprotocol.wave.model.document.AnnotationBehaviour.AnnotationFamily;
import org.waveprotocol.wave.model.document.AnnotationBehaviour.BiasDirection;
import org.waveprotocol.wave.model.document.AnnotationBehaviour.ContentType;
import org.waveprotocol.wave.model.document.AnnotationBehaviour.DefaultAnnotationBehaviour;
import org.waveprotocol.wave.model.document.MutableDocument;
import org.waveprotocol.wave.model.document.RangedAnnotation;
import org.waveprotocol.wave.model.document.operation.Nindo;
import org.waveprotocol.wave.model.document.raw.impl.Element;
import org.waveprotocol.wave.model.document.raw.impl.Node;
import org.waveprotocol.wave.model.document.raw.impl.Text;
import org.waveprotocol.wave.model.document.util.AnnotationRegistry;
import org.waveprotocol.wave.model.document.util.AnnotationRegistryImpl;
import org.waveprotocol.wave.model.document.util.LineContainers;
import org.waveprotocol.wave.model.util.CollectionUtils;
import org.waveprotocol.wave.model.util.ReadableStringMap;
import org.waveprotocol.wave.model.util.ReadableStringMap.ProcV;
import org.waveprotocol.wave.model.util.ReadableStringSet;
import org.waveprotocol.wave.model.util.StringMap;
import org.waveprotocol.wave.model.util.StringSet;
import org.waveprotocol.wave.model.util.ValueUtils;
import java.util.List;
/**
* Tests a number of cases for the logic of when to replace / inherit annotations while pasting.
*
* NOTE(patcoleman):
* a) Rich text paste is all that's done so far, so that's all that's currently tested
* b) The paste extractor doesn't currently respect right cursor bias.
*/
public class PasteAnnotationLogicTest extends TestCase {
private AnnotationRegistry REGISTRY = null;
private static final String LINK_KEY = "link";
private static final String STYLE_KEY = "style";
private static final String SPELL_KEY = "spell";
/** Sets up a state with anything needed by all the tests. */
private AnnotationRegistry initTestAnnotationBehaviour(AnnotationRegistry root) {
LineContainers.setTopLevelContainerTagname("body");
/**
* Create a registry that has three types of behaviours:
* - style-like (no bias change, inherits inside)
* - link-like (bias away, with priority overriding containers).
* - spell-like (metadata, never inherits)
*/
AnnotationRegistry registry = root.createExtension();
registry.registerBehaviour(STYLE_KEY, new DefaultAnnotationBehaviour(AnnotationFamily.CONTENT));
registry.registerBehaviour(LINK_KEY, new AnnotationBehaviour() {
public BiasDirection getBias(StringMap<Object> left, StringMap<Object> right,
CursorDirection cursor) {
assert left.containsKey(LINK_KEY) && right.containsKey(LINK_KEY);
return left.get(LINK_KEY) == null ? BiasDirection.LEFT : BiasDirection.RIGHT; // away
}
public double getPriority() {
return 10.0; // higher than default
}
public InheritDirection replace(StringMap<Object> inside, StringMap<Object> outside,
ContentType type) {
return InheritDirection.INSIDE;
}
public AnnotationFamily getAnnotationFamily() {
return AnnotationFamily.CONTENT;
}
});
registry.registerBehaviour(SPELL_KEY, AnnotationBehaviour.REPLACE_NEITHER);
useCaretAnnotations();
return registry;
}
private final PasteAnnotationLogic<Node, Element, Text> initDefault() {
REGISTRY = initTestAnnotationBehaviour(AnnotationRegistryImpl.ROOT);
return new PasteAnnotationLogic<Node, Element, Text>(doc, REGISTRY);
}
//
// TESTS
//
// strip keys - paste into middle of normal region
public void testStripKeysInUnstyled() {
useDocument("<line/>abcd");
PasteAnnotationLogic<Node, Element, Text> logic = initDefault();
final StringMap<String> built = CollectionUtils.createStringMap();
Nindo.Builder builder = new Nindo.Builder() {
@Override public void startAnnotation(String key, String value) {
built.put(key, value);
}
};
final StringMap<String> changed =
logic.stripKeys(doc, 5, BiasDirection.LEFT, ContentType.RICH_TEXT, builder);
checkEquals(built, changed);
}
// strip keys - paste into middle of bold region
public void testStripKeysInStyled() {
useDocument("<line/>abcd", "style:S:4:6");
PasteAnnotationLogic<Node, Element, Text> logic = initDefault();
final StringMap<String> built = CollectionUtils.createStringMap();
Nindo.Builder builder = new Nindo.Builder() {
@Override public void startAnnotation(String key, String value) {
built.put(key, value);
}
};
final StringMap<String> changed =
logic.stripKeys(doc, 5, BiasDirection.LEFT, ContentType.RICH_TEXT, builder);
checkEquals(built, changed, "style", null);
}
// strip keys - paste onto divider with normal on right, bold on left
public void testStripKeysBetweenUnstyledStyled() {
useDocument("<line/>abcd", "style:S:5:7");
PasteAnnotationLogic<Node, Element, Text> logic = initDefault();
final StringMap<String> built = CollectionUtils.createStringMap();
Nindo.Builder builder = new Nindo.Builder() {
@Override public void startAnnotation(String key, String value) {
built.put(key, value);
}
};
final StringMap<String> changed =
logic.stripKeys(doc, 5, BiasDirection.LEFT, ContentType.RICH_TEXT, builder);
checkEquals(built, changed);
}
// strip keys - paste onto divider with normal on right, bold on left
public void testStripKeysBetweenStyledUnstyled() {
useDocument("<line/>abcd", "style:S:3:5", "spell:S:2:6");
PasteAnnotationLogic<Node, Element, Text> logic = initDefault();
final StringMap<String> built = CollectionUtils.createStringMap();
Nindo.Builder builder = new Nindo.Builder() {
@Override public void startAnnotation(String key, String value) {
built.put(key, value);
}
};
final StringMap<String> changed =
logic.stripKeys(doc, 5, BiasDirection.LEFT, ContentType.RICH_TEXT, builder);
checkEquals(built, changed, "style", null, "spell", null);
}
// unstrip keys - cover everything (both skipped and unskipped keys)
public void testUnstripKeys() {
useDocument("<line/>abcd", "link:L:4:6", "spell:S:5:7");
PasteAnnotationLogic<Node, Element, Text> logic = initDefault();
final StringSet ended = CollectionUtils.createStringSet();
Nindo.Builder builder = new Nindo.Builder() {
@Override public void endAnnotation(String key) {
ended.add(key);
}
};
ReadableStringSet keyCheck = CollectionUtils.newStringSet("A", "B", "C");
ReadableStringSet toIgnore = CollectionUtils.newStringSet("B", "D");
logic.unstripKeys(builder, keyCheck, toIgnore);
assertEquals(2, ended.countEntries());
assertTrue(ended.contains("A"));
assertFalse(ended.contains("B"));
assertTrue(ended.contains("C"));
assertFalse(ended.contains("D"));
}
// extract normalized - check simple case with link and spell
public void testExtractNormalizedAnnotation() {
// a[b{c]d} where [] = link, {} = spell annotation, normalizing over abcd
useDocument("<line/>abcd", "link:L:4:6", "spell:S:5:7", "style:Q:1:2");
PasteAnnotationLogic<Node, Element, Text> logic = initDefault();
List<RangedAnnotation<String>> extracted =
logic.extractNormalizedAnnotation(doc.locate(3), doc.locate(7));
assertEquals(4, extracted.size());
checkRangedAnnotation(extracted, 0, 4, STYLE_KEY, null); // no styles
checkRangedAnnotation(extracted, 0, 1, LINK_KEY, null); // before linked bit
checkRangedAnnotation(extracted, 1, 3, LINK_KEY, "L"); // linked bit
checkRangedAnnotation(extracted, 3, 4, LINK_KEY, null); // after linked bit
}
//
// Utilities
//
// CHeck whether A = B, and both contain mappings (key = 2n, value = 2n+1);
private void checkEquals(ReadableStringMap<String> A, ReadableStringMap<String> B, String... C) {
StringMap<String> shouldBe = CollectionUtils.createStringMap();
for (int i = 0; i < C.length; i += 2) {
shouldBe.put(C[i], C[i+1]);
}
checkMapEquals(A, shouldBe);
checkMapEquals(B, shouldBe);
}
private void checkMapEquals(ReadableStringMap<String> A, final ReadableStringMap<String> B) {
assertEquals(B.countEntries(), A.countEntries());
A.each(new ProcV<String>() {
public void apply(String key, String value) {
assertTrue(B.containsKey(key));
assertTrue(ValueUtils.equal(value, B.get(key)));
}
});
}
private void checkRangedAnnotation(List<RangedAnnotation<String>> extracted,
int from, int to, String key, String value) {
boolean hasAnnotation = true;
for (RangedAnnotation<String> annotation : extracted) {
if (annotation.start() == from && annotation.end() == to &&
ValueUtils.equal(key, annotation.key()) && ValueUtils.equal(value, annotation.value())) {
return;
}
}
fail();
}
///
/// Convenience methods for a context, copied from EditorAnnotationUtilTest.
/// TODO(patcoleman): make it so this doesn't have to be copied everywhere.
///
// Parameters to make generating the EditorContext wrappers easier
private int start;
private int end;
private MutableDocument<Node, Element, Text> doc;
private CaretAnnotations caret;
// Resolve the annotations by left-biasing within the document, stores it in doc.
AnnotationResolver annotationResolver = new AnnotationResolver() {
public String getAnnotation(String key) {
return start == 0 || doc.getAnnotation(start - 1, key) == null ?
null : doc.getAnnotation(start - 1, key).toString();
}
};
// Converts the document and annotations into a CMutableDocument and stores in doc
private void useDocument(String docContent, String... annotations) {
MutableDocument<Node, Element, Text> mutable =
DocProviders.MOJO.parse("<body>" + docContent + "</body>");
// format: key:value:start:end
for (String value : annotations) {
String[] vals = value.split(":");
mutable.setAnnotation(Integer.parseInt(vals[2]), Integer.parseInt(vals[3]), vals[0], vals[1]);
}
doc = mutable;
}
// Converts the annotations passed into a CaretAnnotations bundle and stores in caret
private void useCaretAnnotations(String... annotations) {
CaretAnnotations localCaret = new CaretAnnotations();
for (String value : annotations) {
String[] dup = value.split(":");
localCaret.setAnnotation(dup[0], dup[1]);
}
caret = localCaret;
caret.setAnnotationResolver(annotationResolver);
}
// Stores the start and end of the selection range to simulate.
private void useSelection(int begin, int finish) {
start = begin;
end = finish;
}
}
// PASTE TESTS to write?
// plaintext paste of normal in bold
// richtext paste of normal in bold
// richtext paste of normal on a blank line between bold and normal
// richtext paste of bold on a blank line between bold and normal
// richtext paste of normal + bold on a blank line between bold and normal
// richtext paste of normal at the end of a line after normal
// richtext paste of bold + normal at the end of a line after normal
// richtext paste of normal at the end of a line after bold
// richtext paste of normal + bold at the end of a line after bold