@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);
      }
    }
  }
Exemple #2
0
    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));
   }
 }
Exemple #4
0
 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)");
  }
Exemple #15
0
  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)");
  }
Exemple #18
0
  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);
  }
Exemple #19
0
 public boolean hasOutputVariable(MessageActivity msgActivity) {
   Nodes outVar = msgActivity.toXOM().query("attribute::outputVariable", CONTEXT);
   return outVar.hasAny();
 }