@Override
public void execute_node(
SesameDataSet dataset,
String expression,
TriplesMap parentTriplesMap,
RMLPerformer performer,
Object node,
Resource subject) {
// still need to make it work with more nore-results
// currently it handles only one
if (expression.startsWith("/")) expression = expression.substring(1);
Node node2 = (Node) node;
Nodes nodes = node2.query(expression, nsContext);
for (int i = 0; i < nodes.size(); i++) {
Node n = nodes.get(i);
if (subject == null) performer.perform(n, dataset, parentTriplesMap);
else {
RMLProcessorFactory factory = new ConcreteRMLProcessorFactory();
RMLProcessor subprocessor =
factory.create(map.getLogicalSource().getReferenceFormulation());
RMLPerformer subperformer = new NodeRMLPerformer(subprocessor);
subperformer.perform(n, dataset, parentTriplesMap, subject);
}
}
}
public void map(LongWritable key, Text value, Context context)
throws IOException, InterruptedException {
String strId = "";
String strBody = "";
// Parse the xml and read data (page id and article body)
// Using XOM library
Builder builder = new Builder();
try {
Document doc = builder.build(value.toString(), null);
Nodes nodeId = doc.query("//eecs485_article_id");
strId = nodeId.get(0).getChild(0).getValue();
Nodes nodeBody = doc.query("//eecs485_article_body");
strBody = nodeBody.get(0).getChild(0).getValue();
} catch (ParsingException ex) {
System.out.println("Not well-formed.");
System.out.println(ex.getMessage());
} catch (IOException ex) {
System.out.println("io exception");
}
// Tokenize document body
Pattern pattern = Pattern.compile("\\w+");
Matcher matcher = pattern.matcher(strBody);
while (matcher.find()) {
// Write the parsed token
// key = term, docid value = 1
context.write(new Text(matcher.group() + "," + strId), one);
}
}
public static void runCommentExamples(String templateResourceName, String baseUri) {
Element templateElement = getTemplate(templateResourceName, baseUri);
Nodes templatesWithExamples =
templateElement.query(".//template[comment[@class='" + EXAMPLE_INPUT + "' and @id]]");
for (int i = 0; i < templatesWithExamples.size(); i++) {
runCommentExamples((Element) templatesWithExamples.get(i));
}
}
public static String getAttributeValue(Nodes attributes) {
if (attributes.hasAny()) {
Node attribute = attributes.get(0);
if (attribute instanceof Attribute) {
return attribute.getValue();
}
}
return "";
}
public List<CMLMolecule> getToplevelMoleculeDescendants() {
moleculeList = new ArrayList<CMLMolecule>();
if (rootElement != null) {
Nodes nodes = rootElement.query(TOPLEVEL_MOLECULE_DESCENDANTS, CML_XPATH);
for (int i = 0; i < nodes.size(); i++) {
moleculeList.add((CMLMolecule) nodes.get(i));
}
}
return moleculeList;
}
public List<CMLMolecule> getImmediateMoleculeChildren() {
moleculeList = new ArrayList<CMLMolecule>();
if (rootElement != null) {
Nodes nodes = rootElement.query(IMMEDIATE_MOLECULE_CHILDREN, CML_XPATH);
for (int i = 0; i < nodes.size(); i++) {
moleculeList.add((CMLMolecule) nodes.get(i));
}
}
return moleculeList;
}
public List<CMLReaction> getToplevelReactionDescendants() {
reactionList = new ArrayList<CMLReaction>();
if (rootElement != null) {
Nodes nodes = rootElement.query(TOPLEVEL_REACTION_DESCENDANTS, CML_XPATH);
for (int i = 0; i < nodes.size(); i++) {
reactionList.add((CMLReaction) nodes.get(i));
}
}
return reactionList;
}
public List<CMLReaction> getImmediateReactionChildren() {
reactionList = new ArrayList<CMLReaction>();
if (rootElement != null) {
Nodes nodes = rootElement.query(IMMEDIATE_REACTION_CHILDREN, CML_XPATH);
for (int i = 0; i < nodes.size(); i++) {
reactionList.add((CMLReaction) nodes.get(i));
}
}
return reactionList;
}
private static Element getOutputElement(Element template, String id) {
Nodes nodes = template.query("comment[@class='" + EXAMPLE_OUTPUT + "' and @id='" + id + "']");
if (nodes.size() != 1) {
throw new RuntimeException(
"Missing output for: " + id + "; found " + nodes.size() + " nodes");
}
Element content = (Element) nodes.get(0).getChild(0);
if (content == null) {
throw new RuntimeException("output must have content: " + id);
}
return content;
}
/**
* True if a linkend has the value of id and carrier is not descendant of glosslist
*
* @param id
* @param linkends
* @param glosslist
* @return
*/
private boolean referencedFromOutside(String id, Nodes linkends, Element glosslist) {
for (int i = 0; i < linkends.size(); i++) {
Element linkend = (Element) linkends.get(i);
String ref = linkend.getAttributeValue("linkend");
if (id.equals(ref)) {
if (getAncestor(linkend, "glosslist", dbns) == null) {
return true;
}
}
}
return false;
}
/**
* Process a XPath expression against an XML node
*
* @param node
* @param expression
* @return value that matches expression
*/
private List<String> extractValueFromNode(Node node, String expression) {
DefaultNamespaceContext dnc = get_namespaces();
List<String> list = new ArrayList<>();
if (expression.startsWith("count(")) {
// Nodes result = node.query(expression, nsContext);
String result;
try {
result = execute(node, expression);
list.add(result.toString());
} catch (SaxonApiException ex) {
Logger.getLogger(XPathProcessor.class.getName()).log(Level.SEVERE, null, ex);
}
} else {
// if there's nothing to uniquelly identify, use # - temporary solution - challenge
if (expression.equals("#")) {
list.add(Integer.toString(enumerator++));
return list;
}
Nodes nodes = node.query(expression, nsContext);
for (int i = 0; i < nodes.size(); i++) {
Node n = nodes.get(i);
// checks if the node has a value or children
if (!n.getValue().isEmpty() || (n.getChildCount() != 0))
// MVS's for extracting elements and not the string
/*if (!(n instanceof Attribute) && n.getChild(0) instanceof Element) {
list.add(n.toXML());
}
else {
list.add(n.getValue());
}*/
// checks if the node has children, then cleans up new lines and extra spaces
if (!(n instanceof Attribute) && n.getChildCount() > 1)
list.add(
n.getValue()
.trim()
.replaceAll("[\\t\\n\\r]", " ")
.replaceAll(" +", " ")
.replaceAll("\\( ", "\\(")
.replaceAll(" \\)", "\\)")
.replaceAll(" :", ":")
.replaceAll(" ,", ","));
else list.add(n.getValue().toString());
}
}
return list;
}
/**
* In the given glosslist (assuming 1 per doc) 1) collect all glossentries that are referenced
* from outside the current glosslist 2) collect all glossentries that are referenced from the
* entries in 1
*/
private Document process(Document doc) {
Nodes linkends = doc.getRootElement().query("//db:*[@linkend]", con);
Nodes glosslists = doc.getRootElement().query("//db:glosslist", con);
if (glosslists.size() > 1) throw new IllegalArgumentException("only one glosslist per doc");
if (glosslists.size() == 0) return doc;
Element glosslist = (Element) glosslists.get(0);
// 1) collect all glossentries that are referenced from outside the current glosslist
List<Element> usedGlossEntries = new LinkedList<Element>();
Elements allGlossentries = glosslist.getChildElements("glossentry", dbns);
for (int k = 0; k < allGlossentries.size(); k++) {
Element glossentry = allGlossentries.get(k);
String id = glossentry.getAttributeValue("id", xmlns);
if (referencedFromOutside(id, linkends, glosslist)) {
if (!contains(usedGlossEntries, glossentry)) {
usedGlossEntries.add(glossentry);
}
}
}
// 2: go through usedEntries nested linkends, and add any referenced glossEntries
// recursively until list stops growing
while (true) {
List<Element> moreUsedGlossEntries = recurse(glosslist, allGlossentries, usedGlossEntries);
if (moreUsedGlossEntries.size() == 0) {
break;
}
for (Element more : moreUsedGlossEntries) {
if (!contains(usedGlossEntries, more)) {
usedGlossEntries.add(more);
}
}
}
// finally, remove any unused glossentries
for (int k = 0; k < allGlossentries.size(); k++) {
Element glossentry = allGlossentries.get(k);
if (!contains(usedGlossEntries, glossentry)) {
glossentry.getParent().removeChild(glossentry);
}
}
return doc;
}
private List<Element> recurse(
Element glosslist, Elements allGlossentries, List<Element> usedGlossEntries) {
List<Element> newUsedGlossEntries = new LinkedList<Element>();
for (Element usedEntry : usedGlossEntries) {
Nodes linkends = usedEntry.query(".//db:*[@linkend]", con);
for (int i = 0; i < linkends.size(); i++) {
Element referer = (Element) linkends.get(i);
String ref = referer.getAttributeValue("linkend");
Element referredTo = getGlossEntryByID(ref, allGlossentries);
if (referredTo != null && !contains(usedGlossEntries, referredTo)) {
newUsedGlossEntries.add(referredTo);
}
}
}
return newUsedGlossEntries;
}
@Test
public void update()
throws ValidityException, ParsingException, IOException, MojoExecutionException {
Document pom = new Builder().build(new File(new File("src/it/reflector"), "pom.xml"));
Artifact artifact =
new DefaultArtifact("net.stickycode", "sticky-coercion", "jar", "", "[3.1,4)");
new StickyBoundsMojo().updateDependency(pom, artifact, "[3.6,4)");
XPathContext context = new XPathContext("mvn", "http://maven.apache.org/POM/4.0.0");
Nodes versions = pom.query("//mvn:version", context);
assertThat(versions.size()).isEqualTo(3);
Nodes nodes = pom.query("//mvn:version[text()='[3.6,4)']", context);
assertThat(nodes.size()).isEqualTo(1);
Node node = nodes.get(0);
assertThat(node.getValue()).isEqualTo("[3.6,4)");
}
public void loadLocationsAsync(String kml) {
List<LotLocation> locations = new ArrayList<LotLocation>();
try {
XMLReader parser = XMLReaderFactory.createXMLReader("org.ccil.cowan.tagsoup.Parser");
InputStream is = new ByteArrayInputStream(kml.getBytes());
// build out an XML document using TagSoup
Document doc = new Builder(parser).build(is);
// set the ns of the document as the XPathContext or we will not find the elements when we
// attempt to parse
XPathContext context = new XPathContext("ns", "http://www.w3.org/1999/xhtml");
// get the Placemark nodes within the data
Nodes nodes = doc.query(".//ns:Placemark", context);
for (int index = 0; index < nodes.size(); index++) {
LotLocation placemark = new LotLocation();
Node placemarkNode = nodes.get(index);
Node nameNode = placemarkNode.query("ns:name", context).get(0);
if (nameNode != null) placemark.setLocation(nameNode.getValue());
Node descriptionNode = placemarkNode.query("ns:description", context).get(0);
if (descriptionNode != null) placemark.setDescription(descriptionNode.getValue());
Node lnglatNode = placemarkNode.query("ns:Point/ns:coordinates", context).get(0);
if (lnglatNode != null) {
// get longitude,latitude,altitude, per KML spec
String[] points = lnglatNode.getValue().split(",");
placemark.setPoint(
new LatLng(
Double.parseDouble(points[1].trim()), Double.parseDouble(points[0].trim())));
}
locations.add(placemark);
}
// spin off a new thread and load locations
new LoadLocationsTask().execute(locations);
} catch (Exception e) {
Log.e("LoadLocationsTask", "Failure attempting to load locations", e);
}
}
public static void runCommentExamples(Element template) {
Text2XMLTemplateConverter tc = new Text2XMLTemplateConverter(template);
Nodes exampleInputComments = template.query("comment[@class='" + EXAMPLE_INPUT + "' and @id]");
if (exampleInputComments.size() == 0) {
throw new RuntimeException("No examples found");
}
for (int j = 0; j < exampleInputComments.size(); j++) {
Element exampleInput = (Element) exampleInputComments.get(j);
String id = exampleInput.getAttributeValue(ID);
if (id == null) {
throw new RuntimeException("outputElement must have id: ");
}
Element outputElement = getOutputElement(template, id);
if (outputElement == null) {
throw new RuntimeException("Cannot create OutputElement: " + id);
}
String exampleContent = exampleInput.getValue();
Element outputXML = parseText(tc, exampleContent);
JumboTestUtils.assertEqualsCanonically("template", outputElement, outputXML, true);
}
}
@Test
public void updateTheClassifier()
throws ValidityException, ParsingException, IOException, MojoExecutionException {
Document pom =
new Builder()
.build(
new BufferedReader(
new InputStreamReader(getClass().getResourceAsStream("classifiers.xml"))));
Artifact artifact =
new DefaultArtifact("net.stickycode", "sticky-coercion", "jar", "test-jar", "[2.1,4)");
new StickyBoundsMojo().updateDependency(pom, artifact, "[2.6,3)");
XPathContext context = new XPathContext("mvn", "http://maven.apache.org/POM/4.0.0");
Nodes versions = pom.query("//mvn:version", context);
assertThat(versions.size()).isEqualTo(4);
Nodes nodes = pom.query("//mvn:version[text()='[2.6,3)']", context);
assertThat(nodes.size()).isEqualTo(1);
Node node = nodes.get(0);
assertThat(node.getValue()).isEqualTo("[2.6,3)");
}
public VariableLike getVariableByName(Referable referable, String variableName)
throws NavigationException {
Objects.requireNonNull(variableName, "VariableName must not be null!");
NodeHelper element = new NodeHelper(referable);
String elementName = element.getLocalName();
if ("scope".equals(elementName) || "process".equals(elementName)) {
Nodes variable =
element
.toXOM()
.query("./bpel:variables/bpel:variable[@name='" + variableName + "']", CONTEXT);
if (variable != null && !variable.isEmpty()) {
return new VariableElement(variable.get(0), processContainer);
}
if ("process".equals(elementName)) {
throw new NavigationException("Variable does not exist.");
}
}
if ("onEvent".equals(elementName)) {
if (variableName.equals(element.getAttribute("variable"))) {
return new OnEventElement(element.toXOM(), processContainer);
}
}
if ("catch".equals(elementName)) {
if (variableName.equals(element.getAttribute("faultVariable"))) {
return new CatchElement(element.toXOM(), processContainer);
}
}
if ("forEach".equals(elementName)) {
if (variableName.equals(element.getAttribute("counterName"))) {
return new ForEachVariable(element.toXOM(), processContainer);
}
}
return getVariableByName(element.getParent(), variableName);
}
public boolean hasOutputVariable(MessageActivity msgActivity) {
Nodes outVar = msgActivity.toXOM().query("attribute::outputVariable", CONTEXT);
return outVar.hasAny();
}