Attachment #26448 for bug #27717

View | Details | Raw Unified | Return to bug 27717
Collapse All | Expand All




/*
 * 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.apache.taglibs.standard.xpath.jaxp;

import java.io.InputStream;

import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.apache.taglibs.standard.xpath.JSTLVariableResolver;
import org.apache.taglibs.standard.xpath.xalan.XalanXPathExpressionTest;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.w3c.dom.Document;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;

/**
 */
public class JAXPXPathExpressionTest {

    private XPath xpath;
    private JSTLVariableResolver resolver;
    private PageContext pageContext;

    private static Document d;

    @BeforeClass
    public static void loadTestXML() throws Exception {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        dbf.setValidating(false);
        DocumentBuilder db = dbf.newDocumentBuilder();
        InputStream is = XalanXPathExpressionTest.class.getResourceAsStream("test.xml");
        try {
            d = db.parse(is);
        } finally {
            is.close();
        }
    }

    @Before
    public void setup() {
        XPathFactory factory = XPathFactory.newInstance();
        xpath = factory.newXPath();
        resolver = new JSTLVariableResolver();
        xpath.setXPathVariableResolver(resolver);
        pageContext = createMock(PageContext.class);

    }

    @Ignore
    @Test
    public void testBooleanExpressionReturnsBoolean() throws JspTagException, XPathExpressionException {
        XPathExpression exp = xpath.compile("true()");
        JAXPXPathExpression xpe = new JAXPXPathExpression(exp, resolver);
        Assert.assertEquals(Boolean.TRUE, xpe.evaluateObject(null, null));
    }
    @Test
    public void testSelectTextFromDOM() throws Exception {
        XPathExpression exp = xpath.compile("string($a/root/b/hello)");
        JAXPXPathExpression xpe = new JAXPXPathExpression(exp, resolver);
        expect(pageContext.findAttribute("a")).andReturn(d);
        replay(pageContext);
        Assert.assertEquals("world", xpe.evaluateString(null, pageContext));
        verify(pageContext);
    }
}




/*
 * 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.apache.taglibs.standard.xpath.xalan;

import java.io.InputStream;
import java.util.concurrent.Callable;

import javax.servlet.jsp.PageContext;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.taglibs.standard.xpath.JSTLXPathContext;
import org.apache.xpath.XPath;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;

/**
 */
public class XalanXPathExpressionTest {
    private PageContext pageContext;
    private static Document d;
    private static DocumentBuilder db;

    @BeforeClass
    public static void loadTestXML() throws Exception {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        dbf.setValidating(false);
        db = dbf.newDocumentBuilder();
        InputStream is = XalanXPathExpressionTest.class.getResourceAsStream("test.xml");
        try {
            d = db.parse(is);
        } finally {
            is.close();
        }
    }

    @Before
    public void setup() {
        pageContext = createMock(PageContext.class);
    }

    @Test
    public void testBooleanExpressionReturnsBoolean() throws Exception {
        XPath xpath = new XPath("true()", null, null, XPath.SELECT);
        XalanXPathExpression xpe = new XalanXPathExpression(xpath);
        Assert.assertEquals(Boolean.TRUE, xpe.evaluateObject(null, null));
    }

    @Test
    public void testStringExpressionReturnsString() throws Exception {
        XPath xpath = new XPath("\"hello\"", null, null, XPath.SELECT);
        XalanXPathExpression xpe = new XalanXPathExpression(xpath);
        Assert.assertEquals("hello", xpe.evaluateObject(null, null));
    }

    @Test
    public void testNumberExpressionReturnsNumber() throws Exception {
        XPath xpath = new XPath("1234", null, null, XPath.SELECT);
        XalanXPathExpression xpe = new XalanXPathExpression(xpath);
        Assert.assertEquals(1234.0, xpe.evaluateObject(null, null));
    }

    @Test
    public void testBooleanVariable() throws Exception {
        XPath xpath = new XPath("$a", null, null, XPath.SELECT);
        XalanXPathExpression xpe = new XalanXPathExpression(xpath);
        expect(pageContext.findAttribute("a")).andReturn(Boolean.TRUE);
        replay(pageContext);
        Assert.assertEquals(Boolean.TRUE, xpe.evaluateObject(null, pageContext));
        verify(pageContext);
    }

    @Test
    public void testNumberVariable() throws Exception {
        XPath xpath = new XPath("$a", null, null, XPath.SELECT);
        XalanXPathExpression xpe = new XalanXPathExpression(xpath);
        Number value = 1234.5;
        expect(pageContext.findAttribute("a")).andReturn(value);
        replay(pageContext);
        Assert.assertEquals(value, xpe.evaluateObject(null, pageContext));
        verify(pageContext);
    }

    @Test
    public void testStringVariable() throws Exception {
        XPath xpath = new XPath("$a", null, null, XPath.SELECT);
        XalanXPathExpression xpe = new XalanXPathExpression(xpath);
        String value = "Hello";
        expect(pageContext.findAttribute("a")).andReturn(value);
        replay(pageContext);
        Assert.assertEquals(value, xpe.evaluateObject(null, pageContext));
        verify(pageContext);
    }

    @Test
    public void testSelectTextFromDOM() throws Exception {
        XPath xpath = new XPath("string($a/root/b/hello)", null, null, XPath.SELECT);
        XalanXPathExpression xpe = new XalanXPathExpression(xpath);
        expect(pageContext.findAttribute("a")).andReturn(d);
        replay(pageContext);
        Assert.assertEquals("world", xpe.evaluateObject(null, pageContext));
        verify(pageContext);
    }

    @Ignore
    @Test
    public void testIterationPerformance() throws Exception {
        int size = 200000;
        System.out.println("Creating DOM");
        d = db.newDocument();
        Element root = d.createElement("root");
        d.appendChild(root);
        for (int i = 0; i < size; i++) {
            Element a = d.createElement("a");
            root.appendChild(a);
            Element b = d.createElement("b");
            b.setTextContent(Integer.toString(i));
            a.appendChild(b);
        }
        System.out.println("DOM created");
        expect(pageContext.findAttribute("doc")).andStubReturn(d);
        replay(pageContext);
        final XalanXPathExpression forEach = new XalanXPathExpression(new XPath("$doc/root/a", null, null, XPath.SELECT));
        final XalanXPathExpression inner = new XalanXPathExpression(new XPath("b", null, null, XPath.SELECT));
        Callable<Long> test = new Callable<Long>() {
            public Long call() throws Exception {
                long time = -System.nanoTime();
                JSTLXPathContext iterator = forEach.iterate(null, pageContext);
                while (iterator.hasNext()) {
                    Object node = iterator.next();
                    String s = inner.evaluateString(iterator, pageContext);
                }
                time += System.nanoTime();
                return time;
            }
        };
        // warm up the JIT
        test.call();
        System.out.println("JIT Primed, starting test");
        long time = test.call();
        System.out.println("time = " + time/1000000+"ms.");
        System.out.flush();
    }
}

Line 0 Link Here

(-)impl/src/test/resources/org/apache/taglibs/standard/xpath/xalan/test.xml (+10 lines)
	1	<root>
	2	<a>
	3	<num>one</num>
	4	<num>two</num>
	5	<num>three</num>
	6	</a>
	7	<b>
	8	<hello>world</hello>
	9	</b>
	10	</root>




/*
 * 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.apache.taglibs.standard.xpath;

import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;

/**
 */
public interface JSTLXPathExpression {

    boolean evaluateBoolean(JSTLXPathContext context, PageContext pageContext) throws JspTagException;

    String evaluateString(JSTLXPathContext context, PageContext pageContext) throws JspTagException;

    Object evaluateObject(JSTLXPathContext context, PageContext pageContext) throws JspTagException;

    JSTLXPathContext iterate(JSTLXPathContext context, PageContext pageContext) throws JspTagException;
}




/*
 * 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.apache.taglibs.standard.xpath.jaxp;

import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathFactory;

import org.apache.taglibs.standard.xpath.JSTLVariableResolver;
import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
import org.apache.taglibs.standard.xpath.JSTLXPathFactory;

/**
 */
public class JAXPXPathFactory extends JSTLXPathFactory {
    private static final XPathFactory xpf = XPathFactory.newInstance();

    @Override
    public JSTLXPathCompiler newCompiler() {
        XPath xpath;
        synchronized (xpf) {
            xpath = xpf.newXPath();
        }
        JSTLVariableResolver resolver = new JSTLVariableResolver();
        xpath.setXPathVariableResolver(resolver);
        xpath.setNamespaceContext(resolver);
        return new JAXPXPathCompiler(xpath);
    }
}




/*
 * 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.apache.taglibs.standard.xpath.jaxp;

import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathExpressionException;

import org.apache.taglibs.standard.xpath.InvalidXPathException;
import org.apache.taglibs.standard.xpath.JSTLVariableResolver;
import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
import org.apache.taglibs.standard.xpath.JSTLXPathExpression;

/**
 */
public class JAXPXPathCompiler implements JSTLXPathCompiler {
    private final XPath xpath;

    public JAXPXPathCompiler(XPath xpath) {
        this.xpath = xpath;
    }

    public JSTLXPathExpression compile(String select) {
        try {
            JSTLVariableResolver resolver = (JSTLVariableResolver) xpath.getXPathVariableResolver();
            return new JAXPXPathExpression(xpath.compile(select), resolver);
        } catch (XPathExpressionException e) {
            throw new InvalidXPathException(e);
        }
    }
}




/*
 * 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.apache.taglibs.standard.xpath.jaxp;

import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;
import javax.xml.namespace.QName;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;

import org.apache.taglibs.standard.xpath.JSTLVariableResolver;
import org.apache.taglibs.standard.xpath.JSTLXPathContext;
import org.apache.taglibs.standard.xpath.JSTLXPathExpression;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 */
public class JAXPXPathExpression implements JSTLXPathExpression {
    private final XPathExpression expr;
    private final JSTLVariableResolver resolver;

    public JAXPXPathExpression(XPathExpression expr, JSTLVariableResolver resolver) {
        this.expr = expr;
        this.resolver = resolver;
    }

    public boolean evaluateBoolean(JSTLXPathContext context, PageContext pageContext) throws JspTagException {
        return (Boolean) evaluate(context, pageContext, XPathConstants.BOOLEAN);
    }

    public String evaluateString(JSTLXPathContext context, PageContext pageContext) throws JspTagException {
        return (String) evaluate(context, pageContext, XPathConstants.STRING);
    }

    public Object evaluateObject(JSTLXPathContext context, PageContext pageContext) throws JspTagException {
        return evaluate(context, pageContext, XPathConstants.NODE);
    }

    public JSTLXPathContext iterate(JSTLXPathContext context, PageContext pageContext) throws JspTagException {
        NodeList nodes = (NodeList) evaluate(context, pageContext, XPathConstants.NODESET);
        return new JAXPXPathContext(nodes);
    }

    private Object evaluate(JSTLXPathContext context, PageContext pageContext, QName resultType) throws JspTagException {
        resolver.setPageContext(pageContext);
        Node contextNode = (context == null) ? null : ((JAXPXPathContext) context).current();
        try {
            return expr.evaluate(contextNode, resultType);
        } catch (XPathExpressionException e) {
            throw new JspTagException(e);
        }
    }
}




/*
 * 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.apache.taglibs.standard.xpath.jaxp;

import org.apache.taglibs.standard.xpath.JSTLXPathContext;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 */
public class JAXPXPathContext implements JSTLXPathContext {
    private final NodeList nodes;
    private int index;

    public JAXPXPathContext(NodeList nodes) {
        this.nodes = nodes;
    }

    public boolean hasNext() {
        return index < nodes.getLength();
    }

    public Object next() {
        return nodes.item(index++);
    }

    Node current() {
        return nodes.item(index);
    }
}




/*
 * 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.apache.taglibs.standard.xpath.xalan;

import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
import org.apache.taglibs.standard.xpath.JSTLXPathFactory;

/**
 */
public class XalanXPathFactory extends JSTLXPathFactory {
    @Override
    public JSTLXPathCompiler newCompiler() {
        return new XalanXPathCompiler();
    }
}




/*
 * 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.apache.taglibs.standard.xpath.xalan;

import javax.xml.transform.TransformerException;

import org.apache.taglibs.standard.xpath.InvalidXPathException;
import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
import org.apache.taglibs.standard.xpath.JSTLXPathExpression;
import org.apache.xpath.XPath;

/**
 */
public class XalanXPathCompiler implements JSTLXPathCompiler {
    public JSTLXPathExpression compile(String expression) throws InvalidXPathException {
        try {
            XPath xpath = new XPath(expression, null, null, XPath.SELECT);
            return new XalanXPathExpression(xpath);
        } catch (TransformerException e) {
            throw new InvalidXPathException(e);
        }
    }
}




/*
 * 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.apache.taglibs.standard.xpath.xalan;

import javax.servlet.jsp.PageContext;
import javax.xml.XMLConstants;
import javax.xml.transform.TransformerException;

import org.apache.taglibs.standard.xpath.JSTLVariableResolver;
import org.apache.xml.utils.QName;
import org.apache.xpath.VariableStack;
import org.apache.xpath.XPathContext;
import org.apache.xpath.objects.XObject;
import org.apache.xpath.objects.XObjectFactory;

/**
 */
public class JSTLVariableStack extends VariableStack {

    private final JSTLVariableResolver resolver;

    public JSTLVariableStack(PageContext pageContext) {
        super(2);
        resolver = new JSTLVariableResolver();
        resolver.setPageContext(pageContext);
    }

    @Override
    public XObject getVariableOrParam(XPathContext xctxt, QName qname) throws TransformerException {
        String uri = qname.getNamespaceURI();
        if (uri == null) {
            uri = XMLConstants.NULL_NS_URI;
        }
        String namespaceURI = resolver.getNamespaceURI(uri);
        String localPart = qname.getLocalPart();
        javax.xml.namespace.QName name = new javax.xml.namespace.QName(namespaceURI, localPart);
        Object value = resolver.resolveVariable(name);
        if (value == null) {
            throw new TransformerException("Variable " + qname + " not found");
        }
        return coerceToXPath(value, xctxt);
    }

    XObject coerceToXPath(Object value, XPathContext xctxt) {
        return XObjectFactory.create(value, xctxt);
    }
}




/*
 * 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.apache.taglibs.standard.xpath.xalan;

import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;

import org.apache.taglibs.standard.xpath.JSTLXPathContext;
import org.apache.taglibs.standard.xpath.JSTLXPathExpression;
import org.apache.xpath.VariableStack;
import org.apache.xpath.XPath;
import org.apache.xpath.XPathContext;
import org.apache.xpath.objects.XBoolean;
import org.apache.xpath.objects.XNodeSet;
import org.apache.xpath.objects.XNumber;
import org.apache.xpath.objects.XObject;
import org.apache.xpath.objects.XString;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 */
public class XalanXPathExpression implements JSTLXPathExpression {
    private final XPath xpath;
    private static final DocumentBuilderFactory dbf;

    static {
        dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        dbf.setValidating(false);
    }

    public XalanXPathExpression(XPath xpath) {
        this.xpath = xpath;
    }

    public boolean evaluateBoolean(JSTLXPathContext context, PageContext pageContext) throws JspTagException {
        try {
            return evaluate(context, pageContext).bool();
        } catch (TransformerException e) {
            throw new JspTagException(e);
        }
    }

    public String evaluateString(JSTLXPathContext context, PageContext pageContext) throws JspTagException {
        try {
            return evaluate(context, pageContext).str();
        } catch (TransformerException e) {
            throw new JspTagException(e);
        }
    }

    public Object evaluateObject(JSTLXPathContext context, PageContext pageContext) throws JspTagException {
        try {
            XObject result = evaluate(context, pageContext);
            return coerceToJava(result);
        } catch (TransformerException e) {
            throw new JspTagException(e);
        }
    }

    public JSTLXPathContext iterate(JSTLXPathContext jstlContext, PageContext pageContext) throws JspTagException {
        XPathContext xpathContext;
        int node;
        if (jstlContext == null) {
            xpathContext = newContext(pageContext);
            Node root = getEmptyDocument();
            node = xpathContext.getDTMHandleFromNode(root);
        } else {
            XalanXPathContext context = (XalanXPathContext) jstlContext;
            xpathContext = context.getContext();
            node = context.getCurrentNode();
        }
        try {
            XObject result = xpath.execute(xpathContext, node, null);
            return new XalanXPathContext(xpathContext, result);
        } catch (TransformerException e) {
            throw new JspTagException(e);
        }
    }

    XObject evaluate(JSTLXPathContext jstlContext, PageContext pageContext) throws TransformerException {
        XPathContext xpathContext;
        int dtm;
        if (jstlContext == null) {
            xpathContext = newContext(pageContext);
            Node node = getEmptyDocument();
            dtm = xpathContext.getDTMHandleFromNode(node);
        } else {
            XalanXPathContext context = (XalanXPathContext) jstlContext;
            xpathContext = context.getContext();
            dtm = context.getCurrentNode();
        }
        return xpath.execute(xpathContext, dtm, null);
    }

    XPathContext newContext(PageContext pageContext) {
        XPathContext context = new XPathContext(false);
        VariableStack variableStack = new JSTLVariableStack(pageContext);
        context.setVarStack(variableStack);
        return context;
    }

    Object coerceToJava(XObject xo) throws TransformerException {
        if (xo instanceof XBoolean) {
            return xo.bool();
        } else if (xo instanceof XNumber) {
            return xo.num();
        } else if (xo instanceof XString) {
            return xo.str();
        } else if (xo instanceof XNodeSet) {
            NodeList nodes = xo.nodelist();
            // if there is only one node in the nodeset return that rather than the list
            if (nodes.getLength() == 1) {
                return nodes.item(0);
            } else {
                return nodes;
            }
        } else {
            // unexpected result type
            throw new AssertionError();
        }
    }

    Document getEmptyDocument() {
        try {
            DocumentBuilder db = dbf.newDocumentBuilder();
            return db.newDocument();
        } catch (ParserConfigurationException e) {
            throw new AssertionError();
        }
    }
}




/*
 * 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.apache.taglibs.standard.xpath.xalan;

import javax.xml.transform.TransformerException;

import org.apache.taglibs.standard.xpath.JSTLXPathContext;
import org.apache.xml.dtm.DTMIterator;
import org.apache.xpath.XPathContext;
import org.apache.xpath.objects.XObject;

/**
 */
public class XalanXPathContext implements JSTLXPathContext {
    private final XPathContext context;
    private final DTMIterator iterator;

    public XalanXPathContext(XPathContext context, XObject nodes) throws TransformerException {
        this.context = context;
        iterator = nodes.iter();
    }

    public boolean hasNext() {
        return iterator.getCurrentPos() < iterator.getLength();
    }

    public Object next() {
        int next = iterator.nextNode();
        return iterator.getDTM(next).getNode(next);
    }

    XPathContext getContext() {
        return context;
    }

    int getCurrentNode() {
        return iterator.getCurrentNode();
    }
}




/*
 * 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.apache.taglibs.standard.xpath;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.PageContext;
import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.xpath.XPathVariableResolver;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 */
public class JSTLVariableResolver implements XPathVariableResolver, NamespaceContext {

    private static enum Scope {
        JSP,
        PARAM,
        HEADER,
        COOKIE,
        INITPARAM,
        PAGE,
        REQUEST,
        SESSION,
        APPLICATION
    }

    // Namespace URIs for JSTL implicit variables
    private static final String PARAM_NS_URL = "http://java.sun.com/jstl/xpath/param";
    private static final String HEADER_NS_URL = "http://java.sun.com/jstl/xpath/header";
    private static final String COOKIE_NS_URL = "http://java.sun.com/jstl/xpath/cookie";
    private static final String INITPARAM_NS_URL = "http://java.sun.com/jstl/xpath/initParam";
    private static final String PAGE_NS_URL = "http://java.sun.com/jstl/xpath/page";
    private static final String REQUEST_NS_URL = "http://java.sun.com/jstl/xpath/request";
    private static final String SESSION_NS_URL = "http://java.sun.com/jstl/xpath/session";
    private static final String APP_NS_URL = "http://java.sun.com/jstl/xpath/app";

    // Prefixes for JSTL implicit variables
    private static final String PARAM_PREFIX = "param";
    private static final String HEADER_PREFIX = "header";
    private static final String COOKIE_PREFIX = "cookie";
    private static final String INITPARAM_PREFIX = "initParam";
    private static final String PAGE_PREFIX = "pageScope";
    private static final String REQUEST_PREFIX = "requestScope";
    private static final String SESSION_PREFIX = "sessionScope";
    private static final String APP_PREFIX = "applicationScope";

    // map prefixes to namespaces
    private static final Map<String, String> NAMESPACES;

    static {
        NAMESPACES = new HashMap<String, String>(8);
        NAMESPACES.put(XMLConstants.DEFAULT_NS_PREFIX, XMLConstants.NULL_NS_URI);
        NAMESPACES.put(XMLConstants.XML_NS_PREFIX, XMLConstants.XML_NS_URI);
        NAMESPACES.put(XMLConstants.XMLNS_ATTRIBUTE, XMLConstants.XMLNS_ATTRIBUTE_NS_URI);
        NAMESPACES.put(PARAM_PREFIX, PARAM_NS_URL);
        NAMESPACES.put(HEADER_PREFIX, HEADER_NS_URL);
        NAMESPACES.put(COOKIE_PREFIX, COOKIE_NS_URL);
        NAMESPACES.put(INITPARAM_PREFIX, INITPARAM_NS_URL);
        NAMESPACES.put(PAGE_PREFIX, PAGE_NS_URL);
        NAMESPACES.put(REQUEST_PREFIX, REQUEST_NS_URL);
        NAMESPACES.put(SESSION_PREFIX, SESSION_NS_URL);
        NAMESPACES.put(APP_PREFIX, APP_NS_URL);
    }

    // map namespaces to scopes
    private static final Map<String, Scope> SCOPES;

    static {
        SCOPES = new HashMap<String, Scope>(8);
        SCOPES.put(XMLConstants.NULL_NS_URI, Scope.JSP);
        SCOPES.put(PARAM_NS_URL, Scope.PARAM);
        SCOPES.put(HEADER_NS_URL, Scope.HEADER);
        SCOPES.put(COOKIE_NS_URL, Scope.COOKIE);
        SCOPES.put(INITPARAM_NS_URL, Scope.INITPARAM);
        SCOPES.put(PAGE_NS_URL, Scope.PAGE);
        SCOPES.put(REQUEST_NS_URL, Scope.REQUEST);
        SCOPES.put(SESSION_NS_URL, Scope.SESSION);
        SCOPES.put(APP_NS_URL, Scope.APPLICATION);
    }


    private PageContext pageContext;

    public void setPageContext(PageContext pageContext) {
        this.pageContext = pageContext;
    }

    public Object resolveVariable(QName variableName) {
        String name = variableName.getLocalPart();
        Scope scope = SCOPES.get(variableName.getNamespaceURI());
        if (scope == null) {
            return null;
        }
        switch (scope) {
            case JSP:
                return pageContext.findAttribute(name);
            case PARAM:
                return pageContext.getRequest().getParameter(name);
            case HEADER:
                return ((HttpServletRequest) pageContext.getRequest()).getHeader(name);
            case COOKIE:
                Cookie[] cookies = ((HttpServletRequest) pageContext.getRequest()).getCookies();
                if (cookies != null) {
                    for (Cookie cookie : cookies) {
                        if (cookie.getName().equals(name)) {
                            return cookie.getValue();
                        }
                    }
                }
                return null;
            case INITPARAM:
                return pageContext.getServletContext().getInitParameter(name);
            case PAGE:
                return pageContext.getAttribute(name, PageContext.PAGE_SCOPE);
            case REQUEST:
                return pageContext.getAttribute(name, PageContext.REQUEST_SCOPE);
            case SESSION:
                return pageContext.getAttribute(name, PageContext.SESSION_SCOPE);
            case APPLICATION:
                return pageContext.getAttribute(name, PageContext.APPLICATION_SCOPE);
            default:
                throw new AssertionError();
        }
    }

    public String getNamespaceURI(String prefix) {
        if (prefix == null) {
            throw new IllegalArgumentException("prefix is null");
        }
        String uri = NAMESPACES.get(prefix);
        if (uri != null) {
            return uri;
        }
        return XMLConstants.NULL_NS_URI;
    }

    public String getPrefix(String namespaceURI) {
        throw new UnsupportedOperationException();
    }

    public Iterator getPrefixes(String namespaceURI) {
        throw new UnsupportedOperationException();
    }
}




/*
 * 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.apache.taglibs.standard.xpath;

/**
 */
public interface JSTLXPathContext {
    boolean hasNext();
    Object next();
}




/*
 * 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.apache.taglibs.standard.xpath;

import org.apache.taglibs.standard.xpath.xalan.XalanXPathFactory;

/**
 */
public abstract class JSTLXPathFactory {

    private static final JSTLXPathFactory factory = new XalanXPathFactory();

    public static JSTLXPathFactory getFactory() {
        return factory;
    }

    public abstract JSTLXPathCompiler newCompiler();
}
  + native




/*
 * 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.apache.taglibs.standard.xpath;

/**
 */
public class InvalidXPathException extends RuntimeException {
    public InvalidXPathException() {
    }

    public InvalidXPathException(String s) {
        super(s);
    }

    public InvalidXPathException(String s, Throwable throwable) {
        super(s, throwable);
    }

    public InvalidXPathException(Throwable throwable) {
        super(throwable);
    }
}




/*
 * 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.apache.taglibs.standard.xpath;

/**
 */
public interface JSTLXPathCompiler {

    /**
     * Pre-compiles an XPath expression for future evaluation;
     *
     * @param xpath the xpath to compile
     * @return an JSTLXPathExpression that can be used to evaluate the XPath
     * @throws InvalidXPathException if the supplied XPath is not valid
     */
    JSTLXPathExpression compile(String xpath) throws InvalidXPathException;
}




/*
 * 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.apache.taglibs.standard.tag.common.xml;

import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Vector;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.TransformerException;

import org.apache.taglibs.standard.resources.Resources;
import org.apache.xml.utils.QName;
import org.apache.xpath.VariableStack;
import org.apache.xpath.XPathContext;
import org.apache.xpath.objects.XBoolean;
import org.apache.xpath.objects.XNodeSetForDOM;
import org.apache.xpath.objects.XNumber;
import org.apache.xpath.objects.XObject;
import org.apache.xpath.objects.XString;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * <p>Support for tag handlers that evaluate XPath expressions.</p>
 *
 * @author Shawn Bayern
 * @author Ramesh Mandava ( ramesh.mandava@sun.com )
 * @author Pierre Delisle ( pierre.delisle@sun.com )
 */
// would ideally be a base class, but some of our user handlers already
// have their own parents
public class XPathUtil {

    //*********************************************************************
    // Constructor

    /**
     * Constructs a new XPathUtil object associated with the given
     * PageContext.
     */
    public XPathUtil(PageContext pc) {
        pageContext = pc;
    }

    int globalVarSize = 0;

    public Vector getVariableQNames() {

        globalVarSize = 0;
        Vector variableVector = new Vector();
        // Now construct attributes in different scopes
        Enumeration enum_ = pageContext.getAttributeNamesInScope(
                PageContext.PAGE_SCOPE);
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(PAGE_NS_URL, PAGE_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;

            variableVector.addElement(new QName(null, varName));
            globalVarSize++;
        }
        enum_ = pageContext.getAttributeNamesInScope(
                PageContext.REQUEST_SCOPE);
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(REQUEST_NS_URL, REQUEST_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;
            variableVector.addElement(new QName(null, varName));
            globalVarSize++;
        }

        if (pageContext.getSession() != null) {
            // we may have a page directive preventing session creation/access
            // do not attempt to retrieve attribute names in session scope
            // @see [ http://issues.apache.org/bugzilla/show_bug.cgi?id=35216 ]
            enum_ = pageContext.getAttributeNamesInScope(
                    PageContext.SESSION_SCOPE);
            while (enum_.hasMoreElements()) {
                String varName = (String) enum_.nextElement();
                QName varQName = new QName(SESSION_NS_URL, SESSION_P, varName);
                //Adding both namespace qualified QName and just localName
                variableVector.addElement(varQName);
                globalVarSize++;
                variableVector.addElement(new QName(null, varName));
                globalVarSize++;
            }
        }

        enum_ = pageContext.getAttributeNamesInScope(
                PageContext.APPLICATION_SCOPE);
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(APP_NS_URL, APP_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;
            variableVector.addElement(new QName(null, varName));
            globalVarSize++;
        }
        enum_ = pageContext.getRequest().getParameterNames();
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(PARAM_NS_URL, PARAM_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;
        }
        enum_ = pageContext.getServletContext().getInitParameterNames();
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(INITPARAM_NS_URL, INITPARAM_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;
        }
        enum_ = ((HttpServletRequest) pageContext.getRequest()).getHeaderNames();
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(HEADER_NS_URL, HEADER_P, varName);
            //Adding namespace qualified QName 
            variableVector.addElement(varQName);
            globalVarSize++;
        }
        Cookie[] c = ((HttpServletRequest) pageContext.getRequest()).getCookies();
        if (c != null) {
            for (int i = 0; i < c.length; i++) {
                String varName = c[i].getName();
                QName varQName = new QName(COOKIE_NS_URL, COOKIE_P, varName);
                //Adding namespace qualified QName 
                variableVector.addElement(varQName);
                globalVarSize++;
            }
        }

        return variableVector;

    }

    //*********************************************************************
    // Support for JSTL variable resolution

    // The URLs
    private static final String PAGE_NS_URL
            = "http://java.sun.com/jstl/xpath/page";
    private static final String REQUEST_NS_URL
            = "http://java.sun.com/jstl/xpath/request";
    private static final String SESSION_NS_URL
            = "http://java.sun.com/jstl/xpath/session";
    private static final String APP_NS_URL
            = "http://java.sun.com/jstl/xpath/app";
    private static final String PARAM_NS_URL
            = "http://java.sun.com/jstl/xpath/param";
    private static final String INITPARAM_NS_URL
            = "http://java.sun.com/jstl/xpath/initParam";
    private static final String COOKIE_NS_URL
            = "http://java.sun.com/jstl/xpath/cookie";
    private static final String HEADER_NS_URL
            = "http://java.sun.com/jstl/xpath/header";

    // The prefixes
    private static final String PAGE_P = "pageScope";
    private static final String REQUEST_P = "requestScope";
    private static final String SESSION_P = "sessionScope";
    private static final String APP_P = "applicationScope";
    private static final String PARAM_P = "param";
    private static final String INITPARAM_P = "initParam";
    private static final String COOKIE_P = "cookie";
    private static final String HEADER_P = "header";

    /**
     * org.apache.xpath.VariableStack defines a class to keep track of a stack
     * for template arguments and variables.
     * JstlVariableContext customizes it so it handles JSTL custom
     * variable-mapping rules.
     */
    protected class JstlVariableContext extends org.apache.xpath.VariableStack {

        public JstlVariableContext() {
            super();
        }

        /**
         * Get a variable as an XPath object based on it's qualified name.
         * We override the base class method so JSTL's custom variable-mapping
         * rules can be applied.
         *
         * @param xctxt The XPath context. @@@ we don't use it...
         *              (from xalan: which must be passed in order to lazy evaluate variables.)
         * @param qname The qualified name of the variable.
         */
        @Override
        public XObject getVariableOrParam(
                XPathContext xctxt,
                org.apache.xml.utils.QName qname)
                throws javax.xml.transform.TransformerException, UnresolvableException {
            //p( "***********************************getVariableOrParam begin****");
            String namespace = qname.getNamespaceURI();
            String prefix = qname.getPrefix();
            String localName = qname.getLocalName();

            //p("namespace:prefix:localname=>"+ namespace
            //     + ":" + prefix +":" + localName );

            try {
                Object varObject = getVariableValue(namespace, prefix, localName);


                //XObject varObject = myvs.getVariableOrParam( xpathSupport, varQName);
                XObject newXObject = new XObject(varObject);

                if (Class.forName("org.w3c.dom.Document").isInstance(varObject)) {

                    NodeList nl = ((Document) varObject).getChildNodes();
                    // To allow non-welformed document
                    Vector nodeVector = new Vector();
                    for (int i = 0; i < nl.getLength(); i++) {
                        Node currNode = nl.item(i);
                        if (currNode.getNodeType() == Node.ELEMENT_NODE) {
                            nodeVector.addElement(currNode);
                        }
                    }
                    JSTLNodeList jstlNodeList = new JSTLNodeList(nodeVector);
                    newXObject = new XNodeSetForDOM(jstlNodeList, xctxt);

                    return newXObject;

                }
                if (Class.forName(
                        "org.apache.taglibs.standard.tag.common.xml.JSTLNodeList").isInstance(
                        varObject)) {
                    JSTLNodeList jstlNodeList = (JSTLNodeList) varObject;
                    if ((jstlNodeList.getLength() == 1) &&
                            (!Class.forName("org.w3c.dom.Node").isInstance(jstlNodeList.elementAt(0)))) {
                        varObject = jstlNodeList.elementAt(0);
                        //Now we need to allow this primitive type to be coverted 
                        // to type which Xalan XPath understands 
                    } else {
                        return new XNodeSetForDOM(jstlNodeList, xctxt);
                    }
                }
                if (Class.forName("org.w3c.dom.Node").isInstance(varObject)) {
                    newXObject = new XNodeSetForDOM(new JSTLNodeList((Node) varObject), xctxt);
                } else if (Class.forName("java.lang.String").isInstance(varObject)) {
                    newXObject = new XString((String) varObject);
                } else if (Class.forName("java.lang.Boolean").isInstance(varObject)) {
                    newXObject = new XBoolean((Boolean) varObject);
                } else if (Class.forName("java.lang.Number").isInstance(varObject)) {
                    newXObject = new XNumber((Number) varObject);
                }

                return newXObject;
                // myvs.setGlobalVariable( i, newXObject );
            } catch (ClassNotFoundException cnfe) {
                // This shouldn't happen (TODO: LOG)
                System.out.println("CLASS NOT FOUND EXCEPTION :" + cnfe);
            }
            //System.out.println("*****getVariableOrParam returning *null*" );
            return null;
        }

        /**
         * Retrieve an XPath's variable value using JSTL's custom
         * variable-mapping rules
         */
        public Object getVariableValue(
                String namespace,
                String prefix,
                String localName)
                throws UnresolvableException {
            // p("resolving: ns=" + namespace + " prefix=" + prefix + " localName=" + localName);
            // We can match on namespace with Xalan but leaving as is
            // [ I 'd prefer to match on namespace, but this doesn't appear
            // to work in Jaxen]
            if (prefix == null || prefix.equals("")) {
                return notNull(
                        pageContext.findAttribute(localName),
                        prefix,
                        localName);
            } else if (prefix.equals(PAGE_P)) {
                return notNull(
                        pageContext.getAttribute(localName, PageContext.PAGE_SCOPE),
                        prefix,
                        localName);
            } else if (prefix.equals(REQUEST_P)) {
                return notNull(
                        pageContext.getAttribute(localName,
                                PageContext.REQUEST_SCOPE),
                        prefix,
                        localName);
            } else if (prefix.equals(SESSION_P)) {
                return notNull(
                        pageContext.getAttribute(localName,
                                PageContext.SESSION_SCOPE),
                        prefix,
                        localName);
            } else if (prefix.equals(APP_P)) {
                return notNull(
                        pageContext.getAttribute(localName,
                                PageContext.APPLICATION_SCOPE),
                        prefix,
                        localName);
            } else if (prefix.equals(PARAM_P)) {
                return notNull(
                        pageContext.getRequest().getParameter(localName),
                        prefix,
                        localName);
            } else if (prefix.equals(INITPARAM_P)) {
                return notNull(
                        pageContext.getServletContext().
                                getInitParameter(localName),
                        prefix,
                        localName);
            } else if (prefix.equals(HEADER_P)) {
                HttpServletRequest hsr =
                        (HttpServletRequest) pageContext.getRequest();
                return notNull(
                        hsr.getHeader(localName),
                        prefix,
                        localName);
            } else if (prefix.equals(COOKIE_P)) {
                HttpServletRequest hsr =
                        (HttpServletRequest) pageContext.getRequest();
                Cookie[] c = hsr.getCookies();
                for (int i = 0; i < c.length; i++) {
                    if (c[i].getName().equals(localName)) {
                        return c[i].getValue();
                    }
                }
                throw new UnresolvableException("$" + prefix + ":" + localName);
            } else {
                throw new UnresolvableException("$" + prefix + ":" + localName);
            }
        }

        /**
         * Validate that the Object returned is not null. If it is
         * null, throw an exception.
         */
        private Object notNull(Object o, String prefix, String localName)
                throws UnresolvableException {
            if (o == null) {
                throw new UnresolvableException("$" + (prefix == null ? "" : prefix + ":") + localName);
            }
            //p("resolved to: " + o);
            return o;
        }
    }

    //*********************************************************************
    // Support for XPath evaluation

    private PageContext pageContext;
    private static HashMap exprCache;
    private static JSTLPrefixResolver jstlPrefixResolver = null;

    /**
     * Initialize globally useful data.
     */
    private synchronized static void staticInit() {
        if (jstlPrefixResolver == null) {
            // register supported namespaces
            jstlPrefixResolver = new JSTLPrefixResolver();
            jstlPrefixResolver.addNamespace("pageScope", PAGE_NS_URL);
            jstlPrefixResolver.addNamespace("requestScope", REQUEST_NS_URL);
            jstlPrefixResolver.addNamespace("sessionScope", SESSION_NS_URL);
            jstlPrefixResolver.addNamespace("applicationScope", APP_NS_URL);
            jstlPrefixResolver.addNamespace("param", PARAM_NS_URL);
            jstlPrefixResolver.addNamespace("initParam", INITPARAM_NS_URL);
            jstlPrefixResolver.addNamespace("header", HEADER_NS_URL);
            jstlPrefixResolver.addNamespace("cookie", COOKIE_NS_URL);


            // create a HashMap to cache the expressions
            exprCache = new HashMap();
        }
    }

    static DocumentBuilderFactory dbf = null;
    static DocumentBuilder db = null;
    static Document d = null;

    static Document getDummyDocument() {
        try {
            if (dbf == null) {
                dbf = DocumentBuilderFactory.newInstance();
                dbf.setNamespaceAware(true);
                dbf.setValidating(false);
            }
            db = dbf.newDocumentBuilder();

            DOMImplementation dim = db.getDOMImplementation();
            d = dim.createDocument("http://java.sun.com/jstl", "dummyroot", null);
            //d = db.newDocument();
            return d;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    static Document getDummyDocumentWithoutRoot() {
        try {
            if (dbf == null) {
                dbf = DocumentBuilderFactory.newInstance();
                dbf.setNamespaceAware(true);
                dbf.setValidating(false);
            }
            db = dbf.newDocumentBuilder();

            d = db.newDocument();
            return d;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private static Document getDocumentForNode(Node node) {
        Document doc = getDummyDocumentWithoutRoot();
        Node importedNode = doc.importNode(node, true);
        doc.appendChild(importedNode);
        return doc;
    }

    // The following variable is used for holding the modified xpath string
    // when adapting parameter for Xalan XPath engine, where we need to have
    // a Non null context node.
    String modifiedXPath = null;


    /**
     * Evaluate an XPath expression to a String value.
     */
    public String valueOf(Node n, String xpath) throws JspTagException {
        //p("******** valueOf(" + n + ", " + xpath + ")");
        staticInit();
        // @@@ but where do we set the Pag4eContext for the varaiblecontext?
        JstlVariableContext vs = new JstlVariableContext();
        XPathContext xpathSupport = new XPathContext();
        xpathSupport.setVarStack(vs);

        Vector varVector = fillVarStack(vs, xpathSupport);

        Node contextNode = adaptParamsForXalan(vs, n, xpath.trim());

        xpath = modifiedXPath;

        //p("******** valueOf: modified xpath: " + xpath);

        XObject result = JSTLXPathAPI.eval(contextNode, xpath,
                jstlPrefixResolver, xpathSupport, varVector);


        //p("******Result TYPE => " + result.getTypeString() );

        String resultString = result.str();
        //p("******** valueOf: after eval: " + resultString);

        return resultString;

    }

    /**
     * Evaluate an XPath expression to a boolean value.
     */
    public boolean booleanValueOf(Node n, String xpath)
            throws JspTagException {

        staticInit();
        JstlVariableContext vs = new JstlVariableContext();
        XPathContext xpathSupport = new XPathContext();
        xpathSupport.setVarStack(vs);

        Vector varVector = fillVarStack(vs, xpathSupport);

        Node contextNode = adaptParamsForXalan(vs, n, xpath.trim());
        xpath = modifiedXPath;

        XObject result = JSTLXPathAPI.eval(contextNode, xpath,
                jstlPrefixResolver, xpathSupport, varVector);

        try {
            return result.bool();
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);
        }
    }

    /**
     * Evaluate an XPath expression to a List of nodes.
     */
    public List selectNodes(Node n, String xpath) throws JspTagException {

        staticInit();
        JstlVariableContext vs = new JstlVariableContext();
        XPathContext xpathSupport = new XPathContext();
        xpathSupport.setVarStack(vs);

        Vector varVector = fillVarStack(vs, xpathSupport);

        Node contextNode = adaptParamsForXalan(vs, n, xpath.trim());
        xpath = modifiedXPath;

        XObject result = JSTLXPathAPI.eval(contextNode, xpath,
                jstlPrefixResolver, xpathSupport, varVector);
        try {
            NodeList nl = JSTLXPathAPI.getNodeList(result);
            return new JSTLNodeList(nl);
        } catch (JspTagException e) {
            try {
                //If result can't be converted to NodeList we receive exception
                // In this case we may have single primitive value as the result
                // Populating List with this value ( String, Boolean or Number )

                //System.out.println("JSTLXPathAPI.getNodeList thrown exception:"+ e);
                Vector vector = new Vector();
                Object resultObject = null;
                if (result.getType() == XObject.CLASS_BOOLEAN) {
                    resultObject = result.bool();
                } else if (result.getType() == XObject.CLASS_NUMBER) {
                    resultObject = result.num();
                } else if (result.getType() == XObject.CLASS_STRING) {
                    resultObject = result.str();
                }

                vector.add(resultObject);
                return new JSTLNodeList(vector);
            } catch (TransformerException te) {
                throw new JspTagException(te.toString(), te);
            }
        }


    }

    /**
     * Evaluate an XPath expression to a single node.
     */
    public Node selectSingleNode(Node n, String xpath)
            throws JspTagException {
        //p("selectSingleNode of XPathUtil = passed node:" +
        //   "xpath => " + n + " : " + xpath );

        staticInit();
        JstlVariableContext vs = new JstlVariableContext();
        XPathContext xpathSupport = new XPathContext();
        xpathSupport.setVarStack(vs);

        Vector varVector = fillVarStack(vs, xpathSupport);

        Node contextNode = adaptParamsForXalan(vs, n, xpath.trim());
        xpath = modifiedXPath;

        return (Node) JSTLXPathAPI.selectSingleNode(contextNode, xpath,
                jstlPrefixResolver, xpathSupport);
    }

    /**
     * Returns a locally appropriate context given a node.
     */
    private VariableStack getLocalContext() {
        // set up instance-specific contexts
        VariableStack vc = new JstlVariableContext();
        return vc;
    }

    //*********************************************************************
    // Adapt XPath expression for integration with Xalan

    /**
     * To evaluate an XPath expression using Xalan, we need
     * to create an XPath object, which wraps an expression object and provides
     * general services for execution of that expression.
     * <p>An XPath object can be instantiated with the following information:
     * - XPath expression to evaluate
     * - SourceLocator
     * (reports where an error occurred in the XML source or
     * transformation instructions)
     * - PrefixResolver
     * (resolve prefixes to namespace URIs)
     * - type
     * (one of SELECT or MATCH)
     * - ErrorListener
     * (customized error handling)
     * <p>Execution of the XPath expression represented by an XPath object
     * is done via method execute which takes the following parameters:
     * - XPathContext
     * The execution context
     * - Node contextNode
     * The node that "." expresses
     * - PrefixResolver namespaceContext
     * The context in which namespaces in the XPath are supposed to be
     * expanded.
     * <p>Given all of this, if no context node is set for the evaluation
     * of the XPath expression, one must be set so Xalan
     * can successfully evaluate a JSTL XPath expression.
     * (it will not work if the context node is given as a varialbe
     * at the beginning of the expression)
     *
     * @@@ Provide more details...
     */
    protected Node adaptParamsForXalan(JstlVariableContext jvc, Node n,
                                       String xpath) {
        Node boundDocument = null;

        modifiedXPath = xpath;
        String origXPath = xpath;
        boolean whetherOrigXPath = true;

        // If contextNode is not null then  just pass the values to Xalan XPath
        // unless this is an expression that starts off with an xml document 
        if (n != null && !xpath.startsWith("$")) {
            return n;
        }

        if (xpath.startsWith("$")) {
            // JSTL uses $scopePrefix:varLocalName/xpath expression

            String varQName = xpath.substring(xpath.indexOf("$") + 1);
            if (varQName.indexOf("/") > 0) {
                varQName = varQName.substring(0, varQName.indexOf("/"));
            }
            String varPrefix = null;
            String varLocalName = varQName;
            if (varQName.indexOf(":") >= 0) {
                varPrefix = varQName.substring(0, varQName.indexOf(":"));
                varLocalName = varQName.substring(varQName.indexOf(":") + 1);
            }

            if (xpath.indexOf("/") > 0) {
                xpath = xpath.substring(xpath.indexOf("/"));
            } else {
                xpath = "/*";
                whetherOrigXPath = false;
            }


            try {
                Object varObject = jvc.getVariableValue(null, varPrefix,
                        varLocalName);
                //System.out.println( "varObject => : its Class " +varObject +
                // ":" + varObject.getClass() );

                if (Class.forName("org.w3c.dom.Document").isInstance(
                        varObject)) {
                    //boundDocument = ((Document)varObject).getDocumentElement();
                    boundDocument = ((Document) varObject);
                } else {

                    //System.out.println("Creating a Dummy document to pass " +
                    // " onto as context node " );

                    if (Class.forName("org.apache.taglibs.standard.tag.common.xml.JSTLNodeList").isInstance(varObject)) {
                        Document newDocument = getDummyDocument();

                        JSTLNodeList jstlNodeList = (JSTLNodeList) varObject;
                        if (jstlNodeList.getLength() == 1) {
                            if (Class.forName("org.w3c.dom.Node").isInstance(
                                    jstlNodeList.elementAt(0))) {
                                Node node = (Node) jstlNodeList.elementAt(0);
                                boundDocument = getDocumentForNode(node);
                                if (whetherOrigXPath) {
                                    xpath = "/*" + xpath;
                                }

                            } else {

                                //Nodelist with primitive type
                                Object myObject = jstlNodeList.elementAt(0);

                                //p("Single Element of primitive type");
                                //p("Type => " + myObject.getClass());

                                xpath = myObject.toString();

                                //p("String value ( xpathwould be this) => " + xpath);
                                boundDocument = newDocument;
                            }

                        } else {

                            Element dummyroot = newDocument.getDocumentElement();
                            for (int i = 0; i < jstlNodeList.getLength(); i++) {
                                Node currNode = (Node) jstlNodeList.item(i);

                                Node importedNode = newDocument.importNode(
                                        currNode, true);

                                //printDetails ( newDocument);

                                dummyroot.appendChild(importedNode);

                                //p( "Details of the document After importing");
                                //printDetails ( newDocument);
                            }
                            boundDocument = newDocument;
                            // printDetails ( boundDocument );
                            //Verify :As we are adding Document element we need
                            // to change the xpath expression.Hopefully this
                            // won't  change the result

                            xpath = "/*" + xpath;
                        }
                    } else if (Class.forName("org.w3c.dom.Node").isInstance(
                            varObject)) {
                        boundDocument = getDocumentForNode((Node) varObject);
                        if (whetherOrigXPath) {
                            xpath = "/*" + xpath;
                        }
                    } else {
                        boundDocument = getDummyDocument();
                        xpath = origXPath;
                    }


                }
            } catch (UnresolvableException ue) {
                // TODO: LOG
                System.out.println("Variable Unresolvable :" + ue.getMessage());
                ue.printStackTrace();
            } catch (ClassNotFoundException cnf) {
                // Will never happen
            }
        } else {
            //System.out.println("Not encountered $ Creating a Dummydocument 2 "+
            //   "pass onto as context node " );
            boundDocument = getDummyDocument();
        }

        modifiedXPath = xpath;
        //System.out.println("Modified XPath::boundDocument =>" + modifiedXPath +
        //    "::" + boundDocument );

        return boundDocument;
    }


    //*********************************************************************
    // 

    /**
     * * @@@ why do we have to pass varVector in the varStack first, and then
     * to XPath object?
     */
    private Vector fillVarStack(JstlVariableContext vs, XPathContext xpathSupport)
            throws JspTagException {
        org.apache.xpath.VariableStack myvs = xpathSupport.getVarStack();
        Vector varVector = getVariableQNames();
        for (int i = 0; i < varVector.size(); i++) {

            QName varQName = (QName) varVector.elementAt(i);

            try {
                XObject variableValue = vs.getVariableOrParam(xpathSupport, varQName);
                //p("&&&&Variable set to => " + variableValue.toString() );
                //p("&&&&Variable type => " + variableValue.getTypeString() );
                myvs.setGlobalVariable(i, variableValue);

            } catch (TransformerException te) {
                throw new JspTagException(te.toString(), te);
            }

        }
        return varVector;
    }


    //*********************************************************************
    // Static support for context retrieval from parent <forEach> tag

    public static Node getContext(Tag t) throws JspTagException {
        ForEachTag xt =
                (ForEachTag) TagSupport.findAncestorWithClass(
                        t, ForEachTag.class);
        if (xt == null) {
            return null;
        } else {
            return (xt.getContext());
        }
    }

    //*********************************************************************
    // Utility methods

    private static void p(String s) {
        System.out.println("[XPathUtil] " + s);
    }

    public static void printDetails(Node n) {
        System.out.println("\n\nDetails of Node = > " + n);
        System.out.println("Name:Type:Node Value = > " + n.getNodeName() +
                ":" + n.getNodeType() + ":" + n.getNodeValue());
        System.out.println("Namespace URI : Prefix : localName = > " +
                n.getNamespaceURI() + ":" + n.getPrefix() + ":" + n.getLocalName());
        System.out.println("\n Node has children => " + n.hasChildNodes());
        if (n.hasChildNodes()) {
            NodeList nl = n.getChildNodes();
            System.out.println("Number of Children => " + nl.getLength());
            for (int i = 0; i < nl.getLength(); i++) {
                Node childNode = nl.item(i);
                printDetails(childNode);
            }
        }
    }
}

class JSTLNodeList extends Vector implements NodeList {

    Vector nodeVector;

    public JSTLNodeList(Vector nodeVector) {
        this.nodeVector = nodeVector;
    }

    public JSTLNodeList(NodeList nl) {
        nodeVector = new Vector();
        //System.out.println("[JSTLNodeList] nodelist details");
        for (int i = 0; i < nl.getLength(); i++) {
            Node currNode = nl.item(i);
            //XPathUtil.printDetails ( currNode );
            nodeVector.add(i, nl.item(i));
        }
    }

    public JSTLNodeList(Node n) {
        nodeVector = new Vector();
        nodeVector.addElement(n);
    }


    public Node item(int index) {
        return (Node) nodeVector.elementAt(index);
    }

    @Override
    public Object elementAt(int index) {
        return nodeVector.elementAt(index);
    }

    @Override
    public Object get(int index) {
        return nodeVector.get(index);
    }

    public int getLength() {
        return nodeVector.size();
    }

    @Override
    public int size() {
        //System.out.println("JSTL node list size => " + nodeVector.size() );
        return nodeVector.size();
    }

    // Can implement other Vector methods to redirect those methods to 
    // the vector in the variable param. As we are not using them as part 
    // of this implementation we are not doing that here. If this changes
    // then we need to override those methods accordingly  

}
         




Lines 17-28 Link Here

(-)impl/src/main/java/org/apache/taglibs/standard/tag/common/xml/ForEachTag.java (-51 / +31 lines)
17		17
18	package org.apache.taglibs.standard.tag.common.xml;	18	package org.apache.taglibs.standard.tag.common.xml;
19		19
20	import java.util.List;
21
22	import javax.servlet.jsp.JspTagException;	20	import javax.servlet.jsp.JspTagException;
23	import javax.servlet.jsp.jstl.core.LoopTagSupport;	21	import javax.servlet.jsp.jstl.core.LoopTagSupport;
		22	import javax.servlet.jsp.tagext.Tag;
		23	import javax.servlet.jsp.tagext.TagSupport;
24		24
25	import org.apache.taglibs.standard.resources.Resources;	25	import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
		26	import org.apache.taglibs.standard.xpath.JSTLXPathContext;
		27	import org.apache.taglibs.standard.xpath.JSTLXPathExpression;
		28	import org.apache.taglibs.standard.xpath.JSTLXPathFactory;
26		29
27	/**	30	/**
28	* <p>Support for the XML library's <forEach> tag.</p>	31	* <p>Support for the XML library's <forEach> tag.</p>
Lines 32-91 Link Here
32	*/	35	*/
33	public class ForEachTag extends LoopTagSupport {	36	public class ForEachTag extends LoopTagSupport {
34		37
35	//*********************************************************************	38	private JSTLXPathCompiler compiler;
36	// Private state	39	private JSTLXPathExpression select;
		40	private JSTLXPathContext context;
37		41
38	private String select; // tag attribute	42	public ForEachTag() {
39	private List nodes; // XPath result	43	JSTLXPathFactory xpf = JSTLXPathFactory.getFactory();
40	private int nodesIndex; // current index	44	compiler = xpf.newCompiler();
41	private org.w3c.dom.Node current; // current node	45	}
42		46
43	//*********************************************************************	47	@Override
44	// Iteration control methods	48	public void release() {
		49	super.release();
		50	compiler = null;
		51	select = null;
		52	context = null;
		53	}
45		54
46	// (We inherit semantics and Javadoc from LoopTagSupport.)
47
48	@Override	55	@Override
49	protected void prepare() throws JspTagException {	56	protected void prepare() throws JspTagException {
50	nodesIndex = 0;	57	context = select.iterate(getContext(this), pageContext);
51	XPathUtil xu = new XPathUtil(pageContext);
52	nodes = xu.selectNodes(XPathUtil.getContext(this), select);
53	}	58	}
54		59
55	@Override	60	@Override
56	protected boolean hasNext() throws JspTagException {	61	protected boolean hasNext() throws JspTagException {
57	return (nodesIndex < nodes.size());	62	return context.hasNext();
58	}	63	}
59		64
60	@Override	65	@Override
61	protected Object next() throws JspTagException {	66	protected Object next() throws JspTagException {
62	Object o = nodes.get(nodesIndex++);	67	return context.next();
63	if (!(o instanceof org.w3c.dom.Node)) {
64	throw new JspTagException(
65	Resources.getMessage("FOREACH_NOT_NODESET"));
66	}
67	current = (org.w3c.dom.Node) o;
68	return current;
69	}	68	}
70		69
71		70
72	//*********************************************************************	71	//*********************************************************************
73	// Tag logic and lifecycle management
74
75	// Releases any resources we may have (or inherit)
76
77	@Override
78	public void release() {
79	init();
80	super.release();
81	}
82
83
84	//*********************************************************************
85	// Attribute accessors	72	// Attribute accessors
86		73
87	public void setSelect(String select) {	74	public void setSelect(String select) {
88	this.select = select;	75	this.select = compiler.compile(select);
89	}	76	}
90		77
91	public void setBegin(int begin) throws JspTagException {	78	public void setBegin(int begin) throws JspTagException {
Lines 111-130 Link Here
111		98
112	/* Retrieves the current context. */	99	/* Retrieves the current context. */
113		100
114	public org.w3c.dom.Node getContext() throws JspTagException {	101	public static JSTLXPathContext getContext(Tag child) {
115	// expose the current node as the context	102	ForEachTag forEachTag = (ForEachTag) TagSupport.findAncestorWithClass(child, ForEachTag.class);
116	return current;	103	if (forEachTag == null) {
		104	return null;
		105	} else {
		106	return forEachTag.context;
		107	}
117	}	108	}
118
119
120	//*********************************************************************
121	// Private utility methods
122
123	private void init() {
124	select = null;
125	nodes = null;
126	nodesIndex = 0;
127	current = null;
128	}
129	}	109	}
130		110

Lines 17-29 Link Here

(-)impl/src/main/java/org/apache/taglibs/standard/tag/common/xml/SetTag.java (-43 / +17 lines)
17		17
18	package org.apache.taglibs.standard.tag.common.xml;	18	package org.apache.taglibs.standard.tag.common.xml;
19		19
20	import java.util.List;
21
22	import javax.servlet.jsp.JspException;	20	import javax.servlet.jsp.JspException;
23	import javax.servlet.jsp.PageContext;	21	import javax.servlet.jsp.PageContext;
24	import javax.servlet.jsp.tagext.TagSupport;	22	import javax.servlet.jsp.tagext.TagSupport;
25		23
26	import org.apache.taglibs.standard.tag.common.core.Util;	24	import org.apache.taglibs.standard.tag.common.core.Util;
		25	import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
		26	import org.apache.taglibs.standard.xpath.JSTLXPathExpression;
		27	import org.apache.taglibs.standard.xpath.JSTLXPathFactory;
27		28
28	/**	29	/**
29	* <p>Tag handler for <set> in JSTL's XML library.</p>	30	* <p>Tag handler for <set> in JSTL's XML library.</p>
Lines 32-44 Link Here
32	*/	33	*/
33	public class SetTag extends TagSupport {	34	public class SetTag extends TagSupport {
34		35
35	//*********************************************************************	36	private JSTLXPathCompiler compiler;
36	// Internal state	37	private JSTLXPathExpression select;
		38	private String var;
		39	private int scope = PageContext.PAGE_SCOPE;
37		40
38	private String select; // tag attribute
39	private String var; // tag attribute
40	private int scope; // processed tag attribute
41
42	//*********************************************************************	41	//*********************************************************************
43	// Construction and initialization	42	// Construction and initialization
44		43
Lines 48-66 Link Here
48	* superclass constructor.	47	* superclass constructor.
49	*/	48	*/
50	public SetTag() {	49	public SetTag() {
51	super();	50	JSTLXPathFactory xpf = JSTLXPathFactory.getFactory();
52	init();	51	compiler = xpf.newCompiler();
53	}	52	}
54		53
55	// resets local state	54	@Override
56		55	public void release() {
57	private void init() {	56	super.release();
58	var = null;	57	compiler = null;
59	select = null;	58	select = null;
60	scope = PageContext.PAGE_SCOPE;	59	var = null;
61	}	60	}
62		61
63
64	//*********************************************************************	62	//*********************************************************************
65	// Tag logic	63	// Tag logic
66		64
Lines 68-107 Link Here
68		66
69	@Override	67	@Override
70	public int doStartTag() throws JspException {	68	public int doStartTag() throws JspException {
71	// process the query	69	Object result = select.evaluateObject(ForEachTag.getContext(this), pageContext);
72	XPathUtil xu = new XPathUtil(pageContext);	70	pageContext.setAttribute(var, result, scope);
73	List result =
74	xu.selectNodes(XPathUtil.getContext(this), select);
75	Object ret = result;
76
77	// unwrap primitive types if that's what we received
78	if (result.size() == 1) {
79	Object o = result.get(0);
80	if (o instanceof String \|\| o instanceof Boolean
81	\|\| o instanceof Number) {
82	ret = o;
83	}
84	}
85
86	// expose the final result
87	pageContext.setAttribute(var, ret, scope);
88	return SKIP_BODY;	71	return SKIP_BODY;
89	}	72	}
90		73
91	// Releases any resources we may have (or inherit)
92
93	@Override
94	public void release() {
95	super.release();
96	init();
97	}
98
99
100	//*********************************************************************	74	//*********************************************************************
101	// Attribute accessors	75	// Attribute accessors
102		76
103	public void setSelect(String select) {	77	public void setSelect(String select) {
104	this.select = select;	78	this.select = compiler.compile(select);
105	}	79	}
106		80
107	public void setVar(String var) {	81	public void setVar(String var) {




import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.jstl.core.ConditionalTagSupport;

import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
import org.apache.taglibs.standard.xpath.JSTLXPathExpression;
import org.apache.taglibs.standard.xpath.JSTLXPathFactory;

/**
 * <p>Tag handler for &lt;if&gt; in JSTL's XML library.</p>
 *


public class IfTag extends ConditionalTagSupport {

    private JSTLXPathCompiler compiler;
    private JSTLXPathExpression select;

    // initialize inherited and local state

    public IfTag() {
        JSTLXPathFactory xpf = JSTLXPathFactory.getFactory();
        compiler = xpf.newCompiler();
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();
        compiler = null;
        select = null;
    }


    //*********************************************************************
    // Supplied conditional logic

    @Override
    protected boolean condition() throws JspTagException {
        return select.evaluateBoolean(ForEachTag.getContext(this), pageContext);
        return (xu.booleanValueOf(XPathUtil.getContext(this), select));
    }


    //*********************************************************************
    // Private state

    private String select;               // the value of the 'test' attribute


    //*********************************************************************
    // Attribute accessors

    public void setSelect(String select) {
        this.select = compiler.compile(select);
    }


    //*********************************************************************
    // Private utility methods

    // resets internal state

    private void init() {
        select = null;
    }
}




 * 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.

import javax.servlet.jsp.tagext.TagSupport;

import org.apache.taglibs.standard.util.EscapeXML;
import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
import org.apache.taglibs.standard.xpath.JSTLXPathExpression;
import org.apache.taglibs.standard.xpath.JSTLXPathFactory;

/**
 * Tag handler for &lt;out&gt; in JSTL's XML library.
 * TODO: should we rename this to OutSupport to match the tag name?
 *
 * @author Shawn Bayern
 */
public abstract class ExprSupport extends TagSupport {

    private JSTLXPathCompiler compiler;
    private JSTLXPathExpression select;
    protected boolean escapeXml = true;  // tag attribute

    private String select;                       // tag attribute
    protected boolean escapeXml;         // tag attribute

    //*********************************************************************
    // Construction and initialization

    /**
     * Constructs a new handler.  As with TagSupport, subclasses should
     * not provide other constructors and are expected to call the
     * superclass constructor.
     */
    public ExprSupport() {
        JSTLXPathFactory xpf = JSTLXPathFactory.getFactory();
        compiler = xpf.newCompiler();
    }

    @Override
    public void release() {
        super.release();
        compiler = null;
        select = null;
        escapeXml = true;
    }


    //*********************************************************************
    // Tag logic

    // applies XPath expression from 'select' and prints the result

    @Override
    public int doStartTag() throws JspException {
        try {
            String result = select.evaluateString(ForEachTag.getContext(this), pageContext);
            String result = xu.valueOf(XPathUtil.getContext(this), select);
            EscapeXML.emit(result, escapeXml, pageContext.getOut());
            return SKIP_BODY;
        } catch (java.io.IOException ex) {

        }
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();
        init();
    }


    //*********************************************************************
    // Attribute accessors

    public void setSelect(String select) {
        this.select = compiler.compile(select);
    }
}




/*
 * 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.apache.taglibs.standard.tag.common.xml;

import java.util.Vector;

import javax.servlet.jsp.JspTagException;
import javax.xml.transform.TransformerException;

import org.apache.taglibs.standard.resources.Resources;
import org.apache.xml.utils.PrefixResolver;
import org.apache.xpath.XPath;
import org.apache.xpath.XPathAPI;
import org.apache.xpath.XPathContext;
import org.apache.xpath.objects.XObject;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.traversal.NodeIterator;

/**
 * The methods in this class are convenience methods into the
 * low-level XPath API.
 * These functions tend to be a little slow, since a number of objects must be
 * created for each evaluation.  A faster way is to precompile the
 * XPaths using the low-level API, and then just use the XPaths
 * over and over.
 * <p>NOTE: In particular, each call to this method will create a new
 * XPathContext, a new DTMManager... and thus a new DTM. That's very
 * safe, since it guarantees that you're always processing against a
 * fully up-to-date view of your document. But it's also portentially
 * very expensive, since you're rebuilding the DTM every time. You should
 * consider using an instance of CachedXPathAPI rather than these static
 * methods.
 *
 * @see <a href="http://www.w3.org/TR/xpath">XPath Specification</a>
 */
public class JSTLXPathAPI extends XPathAPI {
    /**
     * Use an XPath string to select a single node.
     * XPath namespace prefixes are resolved using the prefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return The first node found that matches the XPath, or null.
     * @throws JspTagException
     */
    public static Node selectSingleNode(
            Node contextNode, String str, PrefixResolver prefixResolver)
            throws JspTagException {

        // Have the XObject return its result as a NodeSetDTM.
        NodeIterator nl = selectNodeIterator(contextNode, str, prefixResolver);

        // Return the first node, or null
        return nl.nextNode();
    }

    /**
     * Use an XPath string to select a single node.
     * XPath namespace prefixes are resolved using the prefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return The first node found that matches the XPath, or null.
     * @throws JspTagException
     */
    public static Node selectSingleNode(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport) throws JspTagException {

        // Have the XObject return its result as a NodeSetDTM.
        NodeIterator nl = selectNodeIterator(contextNode, str, prefixResolver, xpathSupport);

        // Return the first node, or null
        return nl.nextNode();
    }

    /**
     * Use an XPath string to select a nodelist.
     * XPath namespace prefixes are resolved using PrefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return A NodeIterator, should never be null.
     * @throws JspTagException
     */
    public static NodeIterator selectNodeIterator(
            Node contextNode, String str, PrefixResolver prefixResolver)
            throws JspTagException {

        // Execute the XPath, and have it return the result
        XObject list = eval(contextNode, str, prefixResolver, null);

        // Have the XObject return its result as a NodeSetDTM.
        return getNodeIterator(list);
    }

    /**
     * Use an XPath string to select a nodelist.
     * XPath namespace prefixes are resolved using PrefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return A NodeIterator, should never be null.
     * @throws JspTagException
     */
    public static NodeIterator selectNodeIterator(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport) throws JspTagException {

        // Execute the XPath, and have it return the result
        XObject list = eval(contextNode, str, prefixResolver, xpathSupport);

        // Have the XObject return its result as a NodeSetDTM.
        return getNodeIterator(list);
    }

    /**
     * Use an XPath string to select a nodelist.
     * XPath namespace prefixes are resolved using the prefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return A NodeIterator, should never be null.
     * @throws JspTagException
     */
    private static NodeList selectNodeList(
            Node contextNode, String str, PrefixResolver prefixResolver)
            throws JspTagException {
        // Execute the XPath, and have it return the result
        XObject list = eval(contextNode, str, prefixResolver, null);

        // Return a NodeList.
        return getNodeList(list);
    }

    /**
     * Use an XPath string to select a nodelist.
     * XPath namespace prefixes are resolved using the prefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return A NodeIterator, should never be null.
     * @throws JspTagException
     */
    public static NodeList selectNodeList(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport)
            throws JspTagException {
        // Execute the XPath, and have it return the result
        XObject list = eval(contextNode, str, prefixResolver, xpathSupport);

        // Return a NodeList.
        return getNodeList(list);
    }

    /**
     * Returns a NodeIterator from an XObject.
     *
     * @param list The XObject from which a NodeIterator is returned.
     * @return A NodeIterator, should never be null.
     * @throws JspTagException
     */
    private static NodeIterator getNodeIterator(XObject list)
            throws JspTagException {
        try {
            return list.nodeset();
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);
        }
    }

    /**
     * Returns a NodeList from an XObject.
     *
     * @param list The XObject from which a NodeList is returned.
     * @return A NodeList, should never be null.
     * @throws JspTagException
     */
    static NodeList getNodeList(XObject list)
            throws JspTagException {
        try {
            return list.nodelist();
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);
        }
    }

    /**
     * Evaluate XPath string to an XObject.
     * XPath namespace prefixes are resolved from the namespaceNode.
     * The implementation of this is a little slow, since it creates
     * a number of objects each time it is called.  This could be optimized
     * to keep the same objects around, but then thread-safety issues would arise.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param xpathSupport   The node from which prefixes in the XPath will be resolved to namespaces.
     * @param prefixResolver Will be called if the parser encounters namespace
     *                       prefixes, to resolve the prefixes to URLs.
     * @return An XObject, which can be used to obtain a string, number, nodelist, etc, should never be null.
     * @throws JspTagException
     * @see org.apache.xpath.objects.XObject
     * @see org.apache.xpath.objects.XNull
     * @see org.apache.xpath.objects.XBoolean
     * @see org.apache.xpath.objects.XNumber
     * @see org.apache.xpath.objects.XString
     * @see org.apache.xpath.objects.XRTreeFrag
     */
    public static XObject eval(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport) throws JspTagException {
        //System.out.println("eval of XPathContext params: contextNode:str(xpath)"+
        // ":prefixResolver:xpathSupport => " + contextNode + ":" + str + ":" +
        //  prefixResolver + ":" + xpathSupport );        
        try {
            if (xpathSupport == null) {
                return eval(contextNode, str, prefixResolver);
            }

            // Since we don't have a XML Parser involved here, install some default support
            // for things like namespaces, etc.
            // (Changed from: XPathContext xpathSupport = new XPathContext();
            //    because XPathContext is weak in a number of areas... perhaps
            //    XPathContext should be done away with.)
            // Create the XPath object.
            XPath xpath = new XPath(str, null, prefixResolver, XPath.SELECT, null);

            // Execute the XPath, and have it return the result
            int ctxtNode = xpathSupport.getDTMHandleFromNode(contextNode);

            // System.out.println("Context Node id ( after getDTMHandlerFromNode) => " + ctxtNode );
            XObject xobj = xpath.execute(xpathSupport, ctxtNode, prefixResolver);
            return xobj;
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_EVALUATING_EXPR", str, ex.toString()), ex);
        } catch (IllegalArgumentException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ILLEGAL_ARG_EVALUATING_EXPR", str, ex.toString()), ex);
        }
    }

    public static XObject eval(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport, Vector varQNames) throws JspTagException {
        //p("***************** eval ");
        //p( "contextNode => " + contextNode );
        //p( "XPath str => " + str );
        //p( "PrefixResolver => " + prefixResolver );
        //p( "XPath Context => " + xpathSupport );
        //p( "Var QNames => " + varQNames );
        //p( "Global Var Size => " + varQNames.size() );        
        try {
            XPath xpath = new XPath(str, null, prefixResolver, XPath.SELECT, null);
            xpath.fixupVariables(varQNames, varQNames.size());
            // Execute the XPath, and have it return the result
            int ctxtNode = xpathSupport.getDTMHandleFromNode(contextNode);
            // System.out.println("Context Node id ( after getDTMHandlerFromNode) => " + ctxtNode );            
            return xpath.execute(xpathSupport, ctxtNode, prefixResolver);
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_EVALUATING_EXPR", str, ex.toString()), ex);
        } catch (IllegalArgumentException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ILLEGAL_ARG_EVALUATING_EXPR", str, ex.toString()), ex);
        }
    }

    private static void p(String s) {
        System.out.println("[JSTLXPathAPI] " + s);
    }
}




/*
 * 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.apache.taglibs.standard.tag.common.xml;

import java.util.HashMap;

import org.apache.xml.utils.PrefixResolver;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

/**
 * <meta name="usage" content="general"/>
 * This class implements a JSTL PrefixResolver that
 * can be used to perform prefix-to-namespace lookup
 * for the XPath object.
 */
public class JSTLPrefixResolver implements PrefixResolver {

    /**
     * The context to resolve the prefix from, if the context
     * is not given.
     */

    HashMap namespaces;

    /**
     * The URI for the XML namespace.
     * (Duplicate of that found in org.apache.xpath.XPathContext).
     */

    public static final String S_XMLNAMESPACEURI =
            "http://www.w3.org/XML/1998/namespace";

    /**
     * No-arg constructor which would create empty HashMap of namespaces
     */
    public JSTLPrefixResolver() {
        namespaces = new HashMap();
    }

    public JSTLPrefixResolver(HashMap nses) {
        namespaces = nses;
    }

    /**
     * Given a namespace, get the corresponding prefix.  This assumes that
     * the PrevixResolver hold's it's own namespace context, or is a namespace
     * context itself.
     *
     * @param prefix Prefix to resolve.
     * @return Namespace that prefix resolves to, or null if prefix
     *         is not bound.
     */
    public String getNamespaceForPrefix(String prefix) {
        return (String) namespaces.get(prefix);
    }

    /**
     * Given a prefix and a Context Node, get the corresponding namespace.
     * Warning: This will not work correctly if namespaceContext
     * is an attribute node.
     *
     * @param prefix           Prefix to resolve.
     * @param namespaceContext Node from which to start searching for a
     *                         xmlns attribute that binds a prefix to a namespace.
     * @return Namespace that prefix resolves to, or null if prefix
     *         is not bound.
     */
    public String getNamespaceForPrefix(String prefix,
                                        org.w3c.dom.Node namespaceContext) {

        Node parent = namespaceContext;
        String namespace = null;

        if (prefix.equals("xml")) {
            namespace = S_XMLNAMESPACEURI;
        } else {
            int type;

            while ((null != parent) && (null == namespace)
                    && (((type = parent.getNodeType()) == Node.ELEMENT_NODE)
                    || (type == Node.ENTITY_REFERENCE_NODE))) {
                if (type == Node.ELEMENT_NODE) {
                    NamedNodeMap nnm = parent.getAttributes();

                    for (int i = 0; i < nnm.getLength(); i++) {
                        Node attr = nnm.item(i);
                        String aname = attr.getNodeName();
                        boolean isPrefix = aname.startsWith("xmlns:");

                        if (isPrefix || aname.equals("xmlns")) {
                            int index = aname.indexOf(':');
                            String p = isPrefix ? aname.substring(index + 1) : "";

                            if (p.equals(prefix)) {
                                namespace = attr.getNodeValue();

                                break;
                            }
                        }
                    }
                }

                parent = parent.getParentNode();
            }
        }

        return namespace;
    }

    /**
     * Return the base identifier.
     *
     * @return null
     */
    public String getBaseIdentifier() {
        return null;
    }

    /**
     * @see PrefixResolver#handlesNullPrefixes()
     */
    public boolean handlesNullPrefixes() {
        return false;
    }

    public void addNamespace(String prefix, String uri) {
        namespaces.put(prefix, uri);
    }

}




import javax.servlet.jsp.JspTagException;

import org.apache.taglibs.standard.tag.common.core.WhenTagSupport;
import org.apache.taglibs.standard.xpath.JSTLXPathCompiler;
import org.apache.taglibs.standard.xpath.JSTLXPathExpression;
import org.apache.taglibs.standard.xpath.JSTLXPathFactory;

/**
 * <p>Tag handler for &lt;if&gt; in JSTL's XML library.</p>


public class WhenTag extends WhenTagSupport {

    private JSTLXPathCompiler compiler;
    private JSTLXPathExpression select;

    // initialize inherited and local state

    public WhenTag() {
        JSTLXPathFactory xpf = JSTLXPathFactory.getFactory();
        compiler = xpf.newCompiler();
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();
        compiler = null;
        select = null;
    }


    //*********************************************************************
    // Supplied conditional logic

    @Override
    protected boolean condition() throws JspTagException {
        return select.evaluateBoolean(ForEachTag.getContext(this), pageContext);
        return (xu.booleanValueOf(XPathUtil.getContext(this), select));
    }

    //*********************************************************************
    // Private state

    private String select;               // the value of the 'test' attribute


    //*********************************************************************
    // Attribute accessors

    public void setSelect(String select) {
        this.select = compiler.compile(select);
    }


    //*********************************************************************
    // Private utility methods

    // resets internal state

    private void init() {
        select = null;
    }
}

Return to bug 27717

Line 0 Link Here

(-)impl/src/test/java/org/apache/taglibs/standard/xpath/jaxp/JAXPXPathExpressionTest.java (+94 lines)
		1	/*
		2	* Licensed to the Apache Software Foundation (ASF) under one or more
		3	* contributor license agreements. See the NOTICE file distributed with
		4	* this work for additional information regarding copyright ownership.
		5	* The ASF licenses this file to You under the Apache License, Version 2.0
		6	* (the "License"); you may not use this file except in compliance with
		7	* the License. You may obtain a copy of the License at
		8	*
		9	* http://www.apache.org/licenses/LICENSE-2.0
		10	*
		11	* Unless required by applicable law or agreed to in writing, software
		12	* distributed under the License is distributed on an "AS IS" BASIS,
		13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		14	* See the License for the specific language governing permissions and
		15	* limitations under the License.
		16	*/
		17	package org.apache.taglibs.standard.xpath.jaxp;
		18
		19	import java.io.InputStream;
		20
		21	import javax.servlet.jsp.JspTagException;
		22	import javax.servlet.jsp.PageContext;
		23	import javax.xml.parsers.DocumentBuilder;
		24	import javax.xml.parsers.DocumentBuilderFactory;
		25	import javax.xml.xpath.XPath;
		26	import javax.xml.xpath.XPathExpression;
		27	import javax.xml.xpath.XPathExpressionException;
		28	import javax.xml.xpath.XPathFactory;
		29
		30	import org.apache.taglibs.standard.xpath.JSTLVariableResolver;
		31	import org.apache.taglibs.standard.xpath.xalan.XalanXPathExpressionTest;
		32	import org.junit.Assert;
		33	import org.junit.Before;
		34	import org.junit.BeforeClass;
		35	import org.junit.Ignore;
		36	import org.junit.Test;
		37	import org.w3c.dom.Document;
		38
		39	import static org.easymock.EasyMock.createMock;
		40	import static org.easymock.EasyMock.expect;
		41	import static org.easymock.EasyMock.replay;
		42	import static org.easymock.EasyMock.verify;
		43
		44	/**
		45	*/
		46	public class JAXPXPathExpressionTest {
		47
		48	private XPath xpath;
		49	private JSTLVariableResolver resolver;
		50	private PageContext pageContext;
		51
		52	private static Document d;
		53
		54	@BeforeClass
		55	public static void loadTestXML() throws Exception {
		56	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		57	dbf.setNamespaceAware(true);
		58	dbf.setValidating(false);
		59	DocumentBuilder db = dbf.newDocumentBuilder();
		60	InputStream is = XalanXPathExpressionTest.class.getResourceAsStream("test.xml");
		61	try {
		62	d = db.parse(is);
		63	} finally {
		64	is.close();
65	}
66	}
67
68	@Before
69	public void setup() {
70	XPathFactory factory = XPathFactory.newInstance();
71	xpath = factory.newXPath();
72	resolver = new JSTLVariableResolver();
73	xpath.setXPathVariableResolver(resolver);
74	pageContext = createMock(PageContext.class);
75
76	}
77
78	@Ignore
79	@Test
80	public void testBooleanExpressionReturnsBoolean() throws JspTagException, XPathExpressionException {
81	XPathExpression exp = xpath.compile("true()");
82	JAXPXPathExpression xpe = new JAXPXPathExpression(exp, resolver);
83	Assert.assertEquals(Boolean.TRUE, xpe.evaluateObject(null, null));
84	}
85	@Test
86	public void testSelectTextFromDOM() throws Exception {
87	XPathExpression exp = xpath.compile("string($a/root/b/hello)");
88	JAXPXPathExpression xpe = new JAXPXPathExpression(exp, resolver);
89	expect(pageContext.findAttribute("a")).andReturn(d);
90	replay(pageContext);
91	Assert.assertEquals("world", xpe.evaluateString(null, pageContext));
92	verify(pageContext);
93	}
94	}