Example usage for org.jsoup.nodes Element Element

List of usage examples for org.jsoup.nodes Element Element

Introduction

In this page you can find the example usage for org.jsoup.nodes Element Element.

Prototype

public Element(Tag tag, String baseUri) 

Source Link

Document

Create a new Element from a tag and a base URI.

Usage

From source file:com.assignmentone.snippet.ComplicatedSnippet.java

private Element createElement() {
    Element ul = new Element(Tag.valueOf("ul"), "");
    ul.appendChild(new Element(Tag.valueOf("li"), "").appendText("This text is created by snippet.(1)"));
    ul.appendChild(new Element(Tag.valueOf("li"), "").appendText("This text is created by snippet.(2)"));
    ul.appendChild(new Element(Tag.valueOf("li"), "").appendText("This text is created by snippet.(3)"));
    return ul;/*w w w  .ja  v a2s . co m*/
}

From source file:com.assignmentone.snippet.ShowCodeSnippet.java

private Element makeShowHtml(String file, String title, String contents) {

    // create the panel tag
    Element panel = new Element(Tag.valueOf("div"), "");
    panel.addClass("panel");
    panel.addClass("panel-default");

    Element heading = new Element(Tag.valueOf("div"), "");
    heading.addClass("panel-heading");

    Element body = new Element(Tag.valueOf("div"), "");
    body.addClass("panel-body");

    panel.appendChild(heading);/*  w  w w  .j a  v a2s .  c  om*/
    panel.appendChild(body);

    // write title and file path
    String headStr = StringUtils.isEmpty(title) ? "" : title + ":";
    headStr += file;
    heading.appendText(headStr);

    // create the pre tag
    Element pre = new Element(Tag.valueOf("pre"), "");
    pre.addClass("prettyprint source");
    pre.attr("style", "overflow-x:auto");
    if (contents != null) {
        pre.appendChild(new Element(Tag.valueOf("span"), "").appendText(contents));
    }
    body.appendChild(pre);
    return panel;
}

From source file:com.astamuse.asta4d.web.form.flow.base.BasicFormFlowSnippetTrait.java

/**
 * We only render the form trace map when it exists
 * //from  w w w  . j  a  va2  s .  c  o m
 * @return
 */
default Renderer renderTraceId(String traceId) {
    if (StringUtils.isEmpty(traceId)) {
        return Renderer.create();
    } else {
        return Renderer.create(":root", new ElementSetter() {
            @Override
            public void set(Element elem) {
                Element hide = new Element(Tag.valueOf("input"), "");
                hide.attr("name", FormFlowConstants.FORM_FLOW_TRACE_ID_QUERY_PARAM);
                hide.attr("type", "hidden");
                hide.attr("value", traceId);
                elem.appendChild(hide);
            }
        });
    }
}

From source file:me.vertretungsplan.parser.SVPlanParser.java

@NotNull
SubstitutionSchedule parseSVPlanSchedule(List<Document> docs) throws IOException, JSONException {
    SubstitutionSchedule v = SubstitutionSchedule.fromData(scheduleData);

    for (Document doc : docs) {
        if (doc.select(".svp").size() > 0) {
            for (Element svp : doc.select(".svp")) {
                parseSvPlanDay(v, svp, doc);
            }/*from   w w  w  .  j  a v a  2s . com*/
        } else if (doc.select(".Trennlinie").size() > 0) {
            Element div = new Element(Tag.valueOf("div"), "");
            for (Node node : doc.body().childNodesCopy()) {
                if (node instanceof Element && ((Element) node).hasClass("Trennlinie")
                        && div.select("table").size() > 0) {
                    parseSvPlanDay(v, div, doc);
                    div = new Element(Tag.valueOf("div"), "");
                } else {
                    div.appendChild(node);
                }
            }
            parseSvPlanDay(v, div, doc);
        } else {
            parseSvPlanDay(v, doc, doc);
        }
    }

    v.setClasses(getAllClasses());
    v.setTeachers(getAllTeachers());
    return v;
}

From source file:com.astamuse.asta4d.web.form.field.SimpleFormFieldValueRenderer.java

protected Element createAlternativeDisplayElement(String nonNullString) {
    Element span = new Element(Tag.valueOf("span"), "");
    span.text(nonNullString);/* w  w  w.java2 s. c  o m*/
    return span;
}

From source file:com.astamuse.asta4d.web.form.flow.base.AbstractFormFlowSnippet.java

/**
 * We only render the form trace map when it exists
 * /*from ww  w .  jav  a2s  . co  m*/
 * @return
 */
protected Renderer renderTraceMapData() {
    if (StringUtils.isEmpty(formTraceMapStr)) {
        return Renderer.create();
    } else {
        return Renderer.create(":root", new ElementSetter() {
            @Override
            public void set(Element elem) {
                Element hide = new Element(Tag.valueOf("input"), "");
                hide.attr("name", FormFlowConstants.FORM_STEP_TRACE_MAP_STR);
                hide.attr("type", "hidden");
                hide.attr("value", formTraceMapStr);
                elem.appendChild(hide);
            }
        });
    }
}

From source file:com.astamuse.asta4d.web.form.field.impl.AbstractRadioAndCheckboxPrepareRenderer.java

@Override
public Renderer preRender(final String editSelector, final String displaySelector) {

    if (duplicateSelector != null && labelWrapperIndicatorAttr != null) {
        String msg = "duplicateSelector (%s) and labelWrapperIndicatorAttr (%s) cannot be specified at same time.";
        throw new IllegalArgumentException(String.format(msg, duplicateSelector, labelWrapperIndicatorAttr));
    }/*from  w w  w .  j ava  2s.com*/

    Renderer renderer = super.preRender(editSelector, displaySelector);

    renderer.disableMissingSelectorWarning();

    // create wrapper for input element
    final WrapperIdHolder wrapperIdHolder = new WrapperIdHolder();

    if (duplicateSelector == null && optionMap != null) {

        renderer.add(new Renderer(editSelector, new ElementTransformer(null) {
            @Override
            public Element invoke(Element elem) {

                if (wrapperIdHolder.wrapperId != null) {
                    throw new RuntimeException("The target of selector[" + editSelector
                            + "] must be unique but over than 1 target was found."
                            + "Perhaps you have specified an option value map on a group of elements "
                            + "which is intented to be treated as predefined static options by html directly.");
                }

                String id = elem.id();
                if (StringUtils.isEmpty(id)) {
                    String msg = "A %s input element must have id value being configured:%s";
                    throw new RuntimeException(String.format(msg, getTypeString(), elem.outerHtml()));
                }

                GroupNode wrapper = new GroupNode();

                // cheating the rendering engine for not skipping the rendering on group node
                wrapper.attr(ExtNodeConstants.GROUP_NODE_ATTR_TYPE,
                        ExtNodeConstants.GROUP_NODE_ATTR_TYPE_USERDEFINE);

                // put the input element under the wrapper node
                wrapper.appendChild(elem.clone());

                String wrapperId = IdGenerator.createId();
                wrapper.attr("id", wrapperId);

                wrapperIdHolder.inputId = id;
                wrapperIdHolder.wrapperId = wrapperId;

                // record the selector for against label
                if (labelWrapperIndicatorAttr == null) {
                    wrapperIdHolder.labelSelector = SelectorUtil.attr("label", "for", wrapperIdHolder.inputId);
                } else {
                    wrapperIdHolder.labelSelector = SelectorUtil.attr(labelWrapperIndicatorAttr,
                            wrapperIdHolder.inputId);
                }

                return wrapper;
            }
        }));

        renderer.add(":root", new Renderable() {
            @Override
            public Renderer render() {
                if (wrapperIdHolder.wrapperId == null) {
                    // for display mode?
                    return Renderer.create();
                }

                // remove the label element and cache it in warpperIdHolder, we will relocate it later(since we have to duplicate the
                // input
                // and label pair by given option value map, we have to make sure that the input and label elements are in same parent
                // node
                // which can be duplicated)
                Renderer renderer = Renderer.create().disableMissingSelectorWarning();
                renderer.add(new Renderer(wrapperIdHolder.labelSelector, new ElementTransformer(null) {
                    @Override
                    public Element invoke(Element elem) {
                        wrapperIdHolder.relocatingLabels.add(elem.clone());
                        return new GroupNode();
                    }

                }));

                return renderer.enableMissingSelectorWarning();
            }
        });

        renderer.add(":root", new Renderable() {
            @Override
            public Renderer render() {

                if (wrapperIdHolder.wrapperId == null) {
                    // for display mode?
                    return Renderer.create();
                }

                String selector = SelectorUtil.id(wrapperIdHolder.wrapperId);

                // relocate the label element to the wrapper node
                return Renderer.create(selector, new ElementSetter() {
                    @Override
                    public void set(Element elem) {
                        if (wrapperIdHolder.relocatingLabels.isEmpty()) {// no existing label found
                            Element label = new Element(Tag.valueOf("label"), "");
                            label.attr("for", wrapperIdHolder.inputId);
                            elem.appendChild(label);
                        } else {
                            for (Element label : wrapperIdHolder.relocatingLabels) {
                                elem.appendChild(label);
                            }
                        }
                    }
                });

            }
        });

    } else {
        if (duplicateSelector != null && optionMap != null) {
            // if duplicateSelector is specified, we just only need to store the input element id
            renderer.add(editSelector, new ElementSetter() {
                @Override
                public void set(Element elem) {
                    if (wrapperIdHolder.inputId != null) {
                        String msg = "The target of selector[%s] (inside duplicator:%s) must be unique but over than 1 target was found.";
                        throw new RuntimeException(String.format(msg, editSelector, duplicateSelector));
                    }
                    String id = elem.id();
                    if (StringUtils.isEmpty(id)) {
                        String msg = "A %s input element (inside duplicator:%s) must have id value being configured:%s";
                        throw new RuntimeException(
                                String.format(msg, getTypeString(), duplicateSelector, elem.outerHtml()));
                    }
                    wrapperIdHolder.inputId = id;

                    // record the selector for against label
                    // labelWrapperIndicatorAttr would not be null since we checked it at the entry of this method.
                    wrapperIdHolder.labelSelector = SelectorUtil.attr("label", "for", wrapperIdHolder.inputId);
                }
            });
        }
    }

    // here we finished restructure the input element and its related label element and then we begin to manufacture all the input/label
    // pairs for option list

    renderer.add(":root", new Renderable() {
        @Override
        public Renderer render() {

            if (optionMap == null) {
                // for static options
                Renderer renderer = Renderer.create();
                final List<String> inputIdList = new LinkedList<>();
                renderer.add(editSelector, new ElementSetter() {
                    @Override
                    public void set(Element elem) {
                        inputIdList.add(elem.id());
                    }
                });
                renderer.add(":root", new Renderable() {
                    @Override
                    public Renderer render() {
                        Renderer render = Renderer.create().disableMissingSelectorWarning();
                        for (String id : inputIdList) {
                            render.add(SelectorUtil.attr(labelWrapperIndicatorAttr, id), LABEL_REF_ATTR, id);
                            render.add(SelectorUtil.attr("label", "for", id), LABEL_REF_ATTR, id);
                        }
                        return render.enableMissingSelectorWarning();
                    }
                });

                if (duplicateSelector != null) {
                    renderer.add(duplicateSelector, new Renderable() {
                        @Override
                        public Renderer render() {
                            String duplicatorRef = IdGenerator.createId();
                            Renderer render = Renderer.create(":root", DUPLICATOR_REF_ID_ATTR, duplicatorRef);
                            render.add("input", DUPLICATOR_REF_ATTR, duplicatorRef);
                            String labelSelector;
                            if (labelWrapperIndicatorAttr == null) {
                                labelSelector = SelectorUtil.tag("label");
                            } else {
                                labelSelector = SelectorUtil.attr(labelWrapperIndicatorAttr);
                            }
                            render.add(labelSelector, DUPLICATOR_REF_ATTR, duplicatorRef);
                            return render;
                        }
                    });
                }
                return renderer;
            } else {
                if (wrapperIdHolder.wrapperId == null && duplicateSelector == null) {
                    // for display mode?
                    return Renderer.create();
                }
                if (wrapperIdHolder.inputId == null) {
                    // target input element not found
                    return Renderer.create();
                }
                String selector = duplicateSelector == null ? SelectorUtil.id(wrapperIdHolder.wrapperId)
                        : duplicateSelector;
                return Renderer.create(selector, optionMap.getOptionList(), row -> {

                    Renderer renderer = Renderer.create().disableMissingSelectorWarning();

                    String inputSelector = SelectorUtil.id("input", wrapperIdHolder.inputId);
                    renderer.add(inputSelector, "value", row.getValue());

                    // we have to generate a new uuid for the input element to make sure its id is unique even we duplicated it.
                    String newInputId = inputIdByValue ? row.getValue() : IdGenerator.createId();

                    // make the generated id more understandable by prefixing with original id
                    newInputId = wrapperIdHolder.inputId + "-" + newInputId;

                    String duplicatorRef = null;

                    if (duplicateSelector != null) {
                        duplicatorRef = IdGenerator.createId();
                    }

                    renderer.add(":root", DUPLICATOR_REF_ID_ATTR, duplicatorRef);

                    renderer.add(inputSelector, DUPLICATOR_REF_ATTR, duplicatorRef);
                    renderer.add(inputSelector, "id", newInputId);

                    // may be a wrapper container of label
                    renderer.add(wrapperIdHolder.labelSelector, LABEL_REF_ATTR, newInputId);
                    if (labelWrapperIndicatorAttr != null) {
                        renderer.add(wrapperIdHolder.labelSelector, labelWrapperIndicatorAttr, newInputId);
                    }
                    renderer.add(wrapperIdHolder.labelSelector, DUPLICATOR_REF_ATTR, duplicatorRef);

                    renderer.add("label", "for", newInputId);
                    renderer.add("label", row.getDisplayText());

                    return renderer.enableMissingSelectorWarning();
                });
            }
        }
    });

    // since we cheated the rendering engine, we should set the type of group node created to faked for fast clean up
    renderer.add(":root", new Renderable() {
        @Override
        public Renderer render() {
            if (wrapperIdHolder.wrapperId == null) {
                // for display mode?
                return Renderer.create();
            }
            String selector = SelectorUtil.id(wrapperIdHolder.wrapperId);
            return Renderer.create(selector, new ElementSetter() {
                @Override
                public void set(Element elem) {
                    elem.attr(ExtNodeConstants.GROUP_NODE_ATTR_TYPE,
                            ExtNodeConstants.GROUP_NODE_ATTR_TYPE_FAKE);
                }
            });
        }
    });

    PrepareRenderingDataUtil.storeDataToContextBySelector(editSelector, displaySelector, optionMap);

    return renderer.enableMissingSelectorWarning();
}

From source file:com.pagecrumb.proxy.util.filter.HtmlProxyTransformParser.java

public HtmlProxyTransformParser(String html, final String targetServer) throws ParserException {

    log.debug("Creating Html Parser Object.");

    // TODO Using targetServer directly is dangerous
    // because there might be URL passed which is not absolute URL.
    // its either the URL is decoded using some utilities to get
    // absolute domain

    this.targetServer = targetServer;

    log.info(this.getClass().toString() + " " + "Requested URL: " + this.targetServer);

    NodeVisitor linkvisitor = new NodeVisitor() {

        @Override/*  w  w  w . j  a  v a 2s. c om*/
        public void visitTag(Tag tag) {
            String name = tag.getTagName();

            if ("link".equalsIgnoreCase(name)) {
                String hrefValue = tag.getAttribute("href");
                if (hrefValue != null && !hrefValue.startsWith("/proxy")) {
                    if (hrefValue.startsWith("http://") || hrefValue.startsWith("https://")) { // add more protocols later
                        log.info("Rewriting with targetServer: " + hrefValue);
                        hrefValue = hostServlet + hrefValue;
                    }
                    if (!hrefValue.startsWith("http://")
                            || !hrefValue.startsWith("https://") && !hrefValue.startsWith("/proxy")) { // add more protocols later

                        if (!hrefValue.startsWith("/")) {
                            hrefValue = "/" + hrefValue;
                        }

                        if (hrefValue.startsWith("/") && !hrefValue.startsWith("/proxy")) {
                            log.info("Rewriting with targetServer: " + hrefValue);
                            hrefValue = hostServlet + targetServer + hrefValue;
                        }
                        hrefValue = hrefValue.replaceAll("&", "&amp;");
                        tag.setAttribute("href", hrefValue);
                        log.debug("hrefValue=" + hrefValue);
                    }
                }
            }

            /**
             * Anchor 
             */
            if ("a".equalsIgnoreCase(name)) {
                String hrefValue = tag.getAttribute("href");

                if (hrefValue != null && !hrefValue.startsWith("/proxy")) // Prevent over re-writing the proxy strings
                {
                    log.debug("hrefValue=" + hrefValue);

                    if (hrefValue.startsWith("//")) {
                        hrefValue = "http:" + hrefValue;
                    }

                    if (hrefValue.startsWith("http://") || hrefValue.startsWith("https://")) { // add more protocols later
                        log.info("Rewriting with targetServer: " + hrefValue);
                        hrefValue = hostServlet + hrefValue;
                    }

                    // TODO Check if the href value is just a filename e.g "home.html"

                    /**
                     * Mail Protocol
                     */
                    else if (hrefValue.startsWith("mailto:")) {

                    }
                    /**
                     * HTTP Protocol
                     */
                    else if (!hrefValue.startsWith("http://")
                            || !hrefValue.startsWith("https://") && !hrefValue.startsWith("/proxy")) { // add more protocols later
                        // TODO Must run hrefValue in malformed URL fix, to fix problems with the URL
                        // i.e. "double slash" http://127.0.0.1:8888/proxy?http://localhost:8080/docs//introduction.html
                        // reason could be that target server end with "/"
                        if (!hrefValue.startsWith("/")) {
                            hrefValue = "/" + hrefValue;
                            hrefValue = hostServlet + targetServer + hrefValue;
                        } else if (hrefValue.startsWith("/") && !hrefValue.startsWith("/proxy")) {
                            log.info("Rewriting with targetServer: " + hrefValue);
                            hrefValue = hostServlet + targetServer + hrefValue;
                        }

                    }

                    hrefValue = hrefValue.replaceAll("&", "&amp;");
                    tag.setAttribute("href", hrefValue);
                    log.debug("hrefValue=" + hrefValue);

                }
            }

            // TODO hostServletNoFilter is intended to be used for 
            // non page documents, like .js or .css
            // this way it will not run through the filter URL rewriting

            if ("script".equalsIgnoreCase(name)) {
                String srcValue = tag.getAttribute("src");
                if (srcValue != null && !srcValue.startsWith("/")) {
                    srcValue = "/" + srcValue;
                    srcValue = /*hostServer +*/ hostServlet + targetServer + srcValue;
                }
                if (srcValue != null && srcValue.startsWith("//")) { // special case (see YouTube)
                    //srcValue = /*hostServer +*/ hostServletNoFilter + targetServer + srcValue;
                    srcValue = "http:" + srcValue;
                    srcValue = hostServlet + srcValue;
                }
                if (srcValue != null) {
                    tag.setAttribute("src", srcValue);
                }
                log.debug("srcValue=" + srcValue);
            }

            if ("form".equalsIgnoreCase(name)) {
                String actionValue = tag.getAttribute("action");
                if (actionValue != null && !actionValue.startsWith("/")) {
                    actionValue = "/" + actionValue;
                    actionValue = hostServlet + targetServer + actionValue;
                }
                if (actionValue != null && actionValue.startsWith("/")) {
                    actionValue = hostServlet + targetServer + actionValue;
                }
                if (actionValue != null) {
                    tag.setAttribute("action", actionValue);
                }
                log.debug("actionValue=" + actionValue);
            }

            /**
             * Get javascripts
             */
            if ("script".equalsIgnoreCase(name)) {
                ScriptTag script = (ScriptTag) tag;
                if (script != null) {
                    //String text = script.getStringText();
                    //final AstNode astRoot = new org.mozilla.javascript.Parser().parse(text, "", 1);
                    //log.info("Script_from_parser="+astRoot.toSource());
                    //log.info("script="+text);
                    // Parse the script? based on the documented activities.
                }
            }

            if ("img".equalsIgnoreCase(name)) {
                String srcValue = tag.getAttribute("src");
                if (srcValue != null && !srcValue.startsWith("/proxy")) {
                    if (srcValue.startsWith("http://") || srcValue.startsWith("https://")) { // add more protocols later
                        log.info("Rewriting with targetServer: " + srcValue);
                        srcValue = hostServlet + srcValue;
                    }
                    if (!srcValue.startsWith("http://")
                            || !srcValue.startsWith("https://") && !srcValue.startsWith("/proxy")) { // add more protocols later

                        if (!srcValue.startsWith("/")) {
                            srcValue = "/" + srcValue;
                            srcValue = hostServlet + targetServer + srcValue;
                        }

                        if (srcValue.startsWith("/") && !srcValue.startsWith("/proxy")) {
                            log.info("Rewriting with targetServer: " + srcValue);
                            srcValue = hostServlet + targetServer + srcValue;
                        }
                        srcValue = srcValue.replaceAll("&", "&amp;");
                        tag.setAttribute("src", srcValue);
                        log.debug("srcValue=" + srcValue);
                    }
                }
            }

        }
    };

    Parser parser = new Parser(html, null);

    NodeList nl = parser.parse(null);

    nl.visitAllNodesWith(linkvisitor);

    this.html = nl.toHtml();

    Document doc = Jsoup.parse(this.html);

    //Element bScriptElement = new Element(org.jsoup.parser.Tag.valueOf("script"), "");
    //bScriptElement.attr("src", "/browz.js");
    //bScriptElement.attr("type", "text/javascript");
    //bScriptElement.attr("language", "javascript");

    Element jqEl = new Element(org.jsoup.parser.Tag.valueOf("script"), "");
    jqEl.attr("src", "/jquery.min.js");
    jqEl.attr("type", "text/javascript");
    jqEl.attr("language", "javascript");

    Element bzEl = new Element(org.jsoup.parser.Tag.valueOf("script"), "");
    bzEl.attr("src", "/browz.js");
    bzEl.attr("type", "text/javascript");
    bzEl.attr("language", "javascript");

    //doc.select("head").first().children().first().before("<script type=\"text/javascript\" language=\"javascript\">" 
    //      + readFileAsString("browz.js") + "</script>");

    // Important! Removed to satisfy error, must be reviewed

    //      doc.select("head").first().children().first().before(bzEl);
    //      doc.select("head").first().children().first().before(jqEl);
    /*
    for (Element el : doc.getElementsByTag("html")) {
       jqEl = el.appendElement("script");
       jqEl.attr("src", "/jquery.min.js");
       jqEl.attr("type", "text/javascript");
       jqEl.attr("language", "javascript");
               
       bzEl = el.appendElement("script");
       bzEl.attr("src", "/browz.js");
       bzEl.attr("type", "text/javascript");
       bzEl.attr("language", "javascript");
    }
    */
    this.html = doc.toString();

}

From source file:org.asqatasun.rules.elementchecker.text.TextEmptinessCheckerTest.java

@Override
protected void setUp() throws Exception {
    super.setUp();
    mockTextElementBuilder = createMock(TextElementBuilder.class);
    mockSSPHandler = createMock(SSPHandler.class);
    elements = new Elements();
    element = new Element(Tag.valueOf("div"), "");
    mockTestSolutionHandler = createMock(TestSolutionHandler.class);
    mockProcessRemarkService = createMock(ProcessRemarkService.class);
}

From source file:org.asqatasun.rules.elementchecker.text.TextNotIdenticalToAttributeCheckerTest.java

@Override
protected void setUp() throws Exception {
    super.setUp();
    mockTextElementBuilder = createMock(TextElementBuilder.class);
    mockSSPHandler = createMock(SSPHandler.class);
    elements = new Elements();
    element = new Element(Tag.valueOf("div"), "");
    element.attr(AttributeStore.ALT_ATTR, "test");
    mockTestSolutionHandler = createMock(TestSolutionHandler.class);
    mockProcessRemarkService = createMock(ProcessRemarkService.class);
}