SortBySiblingBlock(Node def) throws RuleBaseException {
super(def);
before = def.query().exists("@before");
String attrName = before ? "@before" : "@after";
if (!"sibling".equals(def.query().single(attrName).value()))
throw new RuleBaseException("sort block " + attrName + " must have value 'sibling'");
}
@Test(expected = TransformException.class)
public void resolveOrderBadQuery() throws RuleBaseException, TransformException {
SortBlock block = define("<sort as='corresponding'>*</sort>");
Node uc1 = content.query().single("/id('uc1')").node();
setModBuilderCustomScope(uc1.query());
block.resolveOrder(modBuilder, uc1);
}
@Test(expected = TransformException.class)
public void resolveOrderNotSibling() throws RuleBaseException, TransformException {
SortBlock block = define("<sort before='sibling'>.//uml:operation</sort>");
Node cname = content.query().single("/id('cname')").node();
Node uc1 = content.query().single("/id('uc1')").node();
setModBuilderCustomScope(uc1.query());
block.resolveOrder(modBuilder, cname);
}
@Test
public void resolveOrder() throws RuleBaseException, TransformException {
SortBlock block = define("<sort by='ascending'>@name</sort>");
Node m1 = content.query().single("/id('m1')").node();
setModBuilderCustomScope(m1.query());
supplement();
block.resolveOrder(modBuilder, m1);
checkSupplement("<sort-value refid='m1'>start</sort-value>");
}
@Test
public void resolveOrderEmpty() throws RuleBaseException, TransformException {
SortBlock block = define("<sort before='sibling'>()</sort>");
Node cname = content.query().single("/id('cname')").node();
Node uc1 = content.query().single("/id('uc1')").node();
setModBuilderCustomScope(uc1.query());
supplement();
block.resolveOrder(modBuilder, cname);
checkSupplement("<sort-siblings run-length='0'/>");
}
public void resolve(Mod.Builder modBuilder) throws TransformException {
for (Node node :
modBuilder.dependOnNearest(NodeTarget.class).unverified().get().targets().nodes()) {
modBuilder.dependOn(node.document());
modBuilder.order(node);
resolveOrder(modBuilder, node);
}
modBuilder.dependOn(requiredVariables);
modBuilder.commit();
}
@Test
public void resolveOrder() throws RuleBaseException, TransformException {
SortBlock block = define("<sort as='corresponding'>$source</sort>");
Node um1 = content.query().single("/id('um1')").node();
Node m1 = content.query().single("/id('m1')").node();
setModBuilderCustomScope(um1.query().let("$source", m1));
reference(m1);
supplement();
block.resolveOrder(modBuilder, um1);
checkSupplement("<sort-proxy position='1'/>");
}
@Test
public void resolveOrder1() throws RuleBaseException, TransformException {
SortBlock block = define("<sort after='sibling'>uml:name</sort>");
Node comp1 = content.query().single("/id('comp1')").node();
Node uc1 = content.query().single("/id('uc1')").node();
setModBuilderCustomScope(uc1.query());
reference(content.query().single("/id('cname')").node());
supplement();
block.resolveOrder(modBuilder, comp1);
checkSupplement("<sort-siblings run-length='1'/>");
}
@Override
public void restore() throws TransformException {
ItemList targets = mod.nearest(NodeTarget.class).targets();
values = new ArrayList<Pair<String, Item>>(targets.size());
for (Node node : targets.nodes()) {
ItemList items = query.runOn(mod.scope(node.query()));
if (items.size() != 1)
throw new TransformException(
"sort by value query did not select exactly one item: " + items);
values.add(Pair.of(node.query().single("@xml:id").value(), items.get(0).toAtomicItem()));
}
}
@AllowAttributes({"priority", "by", "as", "before", "after"})
@Override
public Block define(Node def) throws RuleBaseException {
int numDirectives = def.query().single("count(@by | @as | @before | @after)").intValue();
if (numDirectives > 1)
throw new RuleBaseException(
"sort block specified with more than one of @by, @as, @before and @after");
if (numDirectives < 1)
throw new RuleBaseException("sort block specified without any @by, @as, @before or @after");
if (def.query().exists("@by")) return new SortByValueBlock(def);
else if (def.query().exists("@as")) return new SortByProxyBlock(def);
else return new SortBySiblingBlock(def);
}
@Override
void resolveOrder(Mod.Builder modBuilder, Node node) throws TransformException {
ItemList siblings = query.runOn(modBuilder.customScope(node.query().single("..").query()));
for (Node sibling : siblings.nodes()) {
if (!node.query().single(".. is $_1/..", sibling).booleanValue())
throw new TransformException("query selected non-sibling node: " + sibling);
modBuilder.reference(sibling);
}
modBuilder
.supplement()
.elem("sort-siblings")
.attr("run-length", siblings.size())
.end("sort-siblings");
}
@SuppressWarnings("unchecked")
@Test(expected = TransformException.class)
public void verifyNotSibling() throws RuleBaseException, TransformException {
Node uc1 = content.query().single("/id('uc1')").node();
Node comp1 = content.query().single("/id('comp1')").node();
Node um1 = content.query().single("/id('um1')").node();
setModScope(uc1.query());
SortBySiblingBlock block = define("<sort before='sibling'>.//uml:method</sort>");
SortBySiblingBlock.SortBySiblingSeg seg =
(SortBySiblingBlock.SortBySiblingSeg) block.createSeg(mod);
seg.siblingsByTarget =
Arrays.<Pair<Node, List<Node>>>asList(new Pair[] {Pair.of(comp1, Arrays.asList(um1))});
seg.verify();
}
@Override
void resolveOrder(Mod.Builder modBuilder, Node node) throws TransformException {
ItemList items = query.runOn(modBuilder.customScope(node.query()));
if (items.size() != 1)
throw new TransformException(
"sort by value must select one value per target, but instead selected "
+ items.size()
+ ": "
+ items);
modBuilder
.supplement()
.elem("sort-value")
.attr("refid", node.query().single("@xml:id").value())
.text(items.get(0).value())
.end("sort-value");
}
@SuppressWarnings("unchecked")
@Test
public void verify() throws RuleBaseException, TransformException {
Node uc1 = content.query().single("/id('uc1')").node();
Node comp1 = content.query().single("/id('comp1')").node();
Node comp2 = content.query().single("/id('comp2')").node();
Node cname = content.query().single("/id('cname')").node();
setModScope(uc1.query());
SortBySiblingBlock block = define("<sort before='sibling'>uml:name</sort>");
SortBySiblingBlock.SortBySiblingSeg seg =
(SortBySiblingBlock.SortBySiblingSeg) block.createSeg(mod);
seg.siblingsByTarget =
Arrays.<Pair<Node, List<Node>>>asList(
new Pair[] {
Pair.of(comp1, Arrays.asList(cname)), Pair.of(comp2, Arrays.asList(cname))
});
seg.verify();
}
@Override
public void verify() throws TransformException {
for (Pair<Node, List<Node>> pair : siblingsByTarget) {
Node target = pair.first;
List<Node> storedSiblings = pair.second;
for (Node sibling : storedSiblings) {
if (!target.query().single(".. is $_1/..", sibling).booleanValue())
throw new TransformException(
"previously selected node is no longer a sibling: " + sibling);
}
List<Node> actualSiblings =
query.runOn(mod.scope(target.query().single("..").query())).nodes().asList();
if (!actualSiblings.equals(storedSiblings))
throw new TransformException(
"sibling list changed for target " + target.query().single("@xml:id").value());
// No need to check sibling order, since any change in the node's document will trigger a
// sort.
}
}
@Override
void resolveOrder(Mod.Builder modBuilder, Node node) throws TransformException {
// TODO: see if we can resolve /id in global scope while keeping node context
ItemList items = query.runOn(modBuilder.customScope(node.query()));
if (items.size() != 1)
throw new TransformException(
"sort by corresponding node must select one node per target, but instead selected "
+ items.size()
+ ": "
+ items);
Node proxy = items.get(0).node();
modBuilder.reference(proxy);
modBuilder
.supplement()
.elem("sort-proxy")
.attr(
"position", proxy.query().single("count(preceding::*) + count(ancestor::*)").value())
.end("sort-proxy");
}
SortBlock(Node def) throws RuleBaseException {
Item priorityItem = def.query().optional("@priority");
try {
priority = priorityItem.extant() ? priorityItem.intValue() : 0;
} catch (DatabaseException e) {
throw new RuleBaseException(
"sort block specified bad priority '" + priorityItem.value() + "'", e);
}
query = new Query.Items(def);
}
SortByValueBlock(Node def) throws RuleBaseException {
super(def);
// TODO: support collations
String direction = def.query().single("@by").value();
if ("ascending".equals(direction)) ascending = true;
else if ("descending".equals(direction)) ascending = false;
else
throw new RuleBaseException(
"sort block @by must have value 'ascending' or 'descending', got '" + direction + "'");
}
private void runVerifyScenario(String proxyid, String modData)
throws TransformException, RuleBaseException {
Node um1 = content.query().single("/id('um1')").node();
Node m1 = content.query().single("/id('m1')").node();
setModNearestAncestorImplementing(
NodeTarget.class,
new NodeTarget() {
public ItemList targets() throws TransformException {
return content.query().all("/id('um1')");
}
});
setModData(modData);
setModReferences(content.query().single("/id($_1)", proxyid).node());
setModScope(um1.query().let("$source", m1));
SortByProxyBlock block = define("<sort as='corresponding'>$source</sort>");
SortByProxyBlock.SortByProxySeg seg = (SortByProxyBlock.SortByProxySeg) block.createSeg(mod);
seg.proxies = new ArrayList<Pair<String, Node>>();
seg.proxies.add(Pair.of("um1", mod.references().get(0)));
seg.verify();
}
@Override
public void verify() throws TransformException {
ItemList targets = mod.nearest(NodeTarget.class).targets();
List<Node> references = mod.references();
ItemList records = mod.supplementQuery().all("sort-proxy");
assert targets.size() == references.size();
assert records.size() == references.size();
for (int i = 0; i < targets.size(); i++) {
Node target = targets.get(i).node();
Node restoredProxy = references.get(i);
ItemList items = query.runOn(mod.scope(target.query()));
if (items.size() != 1)
throw new TransformException(
"sort by corresponding node must select one node per target, but instead selected "
+ items.size()
+ ": "
+ items);
Node proxy = items.get(0).node();
if (!restoredProxy.equals(proxy)) throw new TransformException("computed proxy changed");
if (!proxy
.query()
.single(
"(count(preceding::*) + count(ancestor::*)) eq xs:integer($_1/@position)",
records.get(i))
.booleanValue()) throw new SortingException("computed proxy moved");
}
}
SortByProxyBlock(Node def) throws RuleBaseException {
super(def);
if (!"corresponding".equals(def.query().single("@as").value()))
throw new RuleBaseException("sort block @as must have value 'corresponding'");
}