5:15 a.m.
Author: jbarrez
Date: 2009-12-10 06:15:51 -0500 (Thu, 10 Dec 2009)
New Revision: 5942
Added:
jbpm4/trunk/modules/pvm/src/main/java/org/jbpm/pvm/internal/script/XPathScriptEngine.java
jbpm4/trunk/modules/pvm/src/main/java/org/jbpm/pvm/internal/script/XPathScriptEngineFactory.java
Removed:
jbpm4/trunk/modules/bpmn/src/main/java/com/sun/script/xpath/
Modified:
jbpm4/trunk/modules/bpmn/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory
Log:
JBPM-2632: move XpathScriptEngine
Modified:
jbpm4/trunk/modules/bpmn/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory
===================================================================
---
jbpm4/trunk/modules/bpmn/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory 2009-12-10
09:09:01 UTC (rev 5941)
+++
jbpm4/trunk/modules/bpmn/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory 2009-12-10
11:15:51 UTC (rev 5942)
@@ -1 +1 @@
-com.sun.script.xpath.XPathScriptEngineFactory
\ No newline at end of file
+org.jbpm.pvm.internal.script.XPathScriptEngineFactory
\ No newline at end of file
Copied:
jbpm4/trunk/modules/pvm/src/main/java/org/jbpm/pvm/internal/script/XPathScriptEngine.java
(from rev 5938,
jbpm4/trunk/modules/bpmn/src/main/java/com/sun/script/xpath/XPathScriptEngine.java)
===================================================================
---
jbpm4/trunk/modules/pvm/src/main/java/org/jbpm/pvm/internal/script/XPathScriptEngine.java
(rev 0)
+++
jbpm4/trunk/modules/pvm/src/main/java/org/jbpm/pvm/internal/script/XPathScriptEngine.java 2009-12-10
11:15:51 UTC (rev 5942)
@@ -0,0 +1,458 @@
+/*
+ * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
+ * Use is subject to license terms.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met: Redistributions of source
code
+ * must retain the above copyright notice, this list of conditions and the following
disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of
+ * conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution. Neither the name of the Sun Microsystems nor the names
of
+ * is contributors may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * XPathScriptEngine.java
+ * @author A. Sundararajan
+ */
+
+package org.jbpm.pvm.internal.script;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import javax.script.AbstractScriptEngine;
+import javax.script.Bindings;
+import javax.script.Compilable;
+import javax.script.CompiledScript;
+import javax.script.Invocable;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineFactory;
+import javax.script.ScriptException;
+import javax.script.SimpleBindings;
+import javax.xml.XMLConstants;
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpression;
+import javax.xml.xpath.XPathFactory;
+import javax.xml.xpath.XPathFunction;
+import javax.xml.xpath.XPathFunctionResolver;
+import javax.xml.xpath.XPathVariableResolver;
+
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+
+public class XPathScriptEngine extends AbstractScriptEngine implements Compilable {
+
+ // my factory, may be null
+ private ScriptEngineFactory factory;
+ private XPathFactory xpathFactory;
+
+ // special context variables for XPath result type and input
+ public static final String XPATH_RESULT_TYPE =
"com.sun.script.xpath.resultType";
+ public static final String XPATH_INPUT_SRC =
"com.sun.script.xpath.inputSource";
+
+ // XML namespace prefixes and URIs.
+ public static final String XMLNS_COLON = "xmlns:";
+ public static final String XPATH_CONTEXT_PREFIX = "context";
+ public static final String XPATH_CONTEXT_URI =
"http://www.sun.com/java/jsr223/xpath/context";
+
+ private Document objectData;
+
+ public XPathScriptEngine() {
+ xpathFactory = XPathFactory.newInstance();
+ }
+
+ // my implementation for CompiledScript
+ private class XPathCompiledScript extends CompiledScript {
+
+ private XPathExpression expr;
+
+ XPathCompiledScript(XPathExpression expr) {
+ this.expr = expr;
+ }
+
+ public ScriptEngine getEngine() {
+ return XPathScriptEngine.this;
+ }
+
+ public Object eval(ScriptContext ctx) throws ScriptException {
+ return evalXPath(expr, ctx);
+ }
+ }
+
+ public CompiledScript compile(String script) throws ScriptException {
+ XPathExpression expr = compileXPath(script, context);
+ return new XPathCompiledScript(expr);
+ }
+
+ public CompiledScript compile(Reader reader) throws ScriptException {
+ return compile(readFully(reader));
+ }
+
+ public Object eval(String str, ScriptContext ctx) throws ScriptException {
+ XPathExpression expr = compileXPath(str, ctx);
+ return evalXPath(expr, ctx);
+ }
+
+ public Object eval(Reader reader, ScriptContext ctx) throws ScriptException {
+ return eval(readFully(reader), ctx);
+ }
+
+ public ScriptEngineFactory getFactory() {
+ synchronized (this) {
+ if (factory == null) {
+ factory = new XPathScriptEngineFactory();
+ }
+ }
+ return factory;
+ }
+
+ public Bindings createBindings() {
+ return new SimpleBindings();
+ }
+
+ void setFactory(ScriptEngineFactory factory) {
+ this.factory = factory;
+ }
+
+ // Internals only below this point
+
+ // find a variable of given qname in given context
+ private static Object findVariable(QName qname, ScriptContext ctx) {
+ String name;
+ int scope;
+
+ if (XPATH_CONTEXT_URI.equals(qname.getNamespaceURI())) {
+ name = qname.getLocalPart();
+ synchronized (ctx) {
+ scope = ctx.getAttributesScope(name);
+ if (scope != -1) {
+ return ctx.getAttribute(name, scope);
+ } // else fallthru
+ }
+ }
+ if (qname.getPrefix() == null || "".equals(qname.getPrefix())) {
+ name = qname.getLocalPart();
+ } else {
+ name = qname.getPrefix() + ":" + qname.getLocalPart();
+ }
+ synchronized (ctx) {
+ scope = ctx.getAttributesScope(name);
+ if (scope != -1) {
+ return ctx.getAttribute(name, scope);
+ } // else fallthru
+ }
+ return null;
+ }
+
+ private static void collectNamespaces(Map<String, String> map, Bindings scope) {
+ for (String key : scope.keySet()) {
+ if (key.startsWith(XMLNS_COLON)) {
+ Object uri = scope.get(key);
+ // collect all variables starting with "xmlns:" and
+ // collect the prefix to URI mappings.
+ String prefix = key.substring(XMLNS_COLON.length());
+ if (uri instanceof String) {
+ String tmp = (String) uri;
+ if (tmp.length() != 0) {
+ map.put(prefix, tmp);
+ }
+ }
+ }
+ }
+ }
+
+ private static NamespaceContext makeNamespaceContext(ScriptContext ctx) {
+ // namespace prefix-to-URI mappings
+ final Map<String, String> namespaces = new HashMap<String, String>();
+ for (int scope : ctx.getScopes()) {
+ Bindings bind = ctx.getBindings(scope);
+ if (bind != null) {
+ // TODO: See what needs to be done....
+ // collectNamespaces(namespaces, bind);
+ }
+ }
+
+ // look for mapping for default XML namespace
+ Object def = ctx.getAttribute(XMLConstants.XMLNS_ATTRIBUTE);
+ if (def instanceof String) {
+ namespaces.put(XMLConstants.DEFAULT_NS_PREFIX, (String) def);
+ }
+
+ // standard required mappings by XPath standard
+ namespaces.put(XMLConstants.XML_NS_PREFIX, XMLConstants.XML_NS_URI);
+ namespaces.put(XMLConstants.XMLNS_ATTRIBUTE, XMLConstants.XMLNS_ATTRIBUTE_NS_URI);
+
+ // add prefix mapping for XPATH_CONTEXT_PREFIX
+ namespaces.put(XPATH_CONTEXT_PREFIX, XPATH_CONTEXT_URI);
+
+ return new NamespaceContext() {
+
+ public String getNamespaceURI(String prefix) {
+ if (prefix == null) {
+ throw new IllegalArgumentException();
+ }
+ String uri = namespaces.get(prefix);
+ if (uri == null) {
+ return XMLConstants.NULL_NS_URI;
+ } else {
+ return uri;
+ }
+ }
+
+ public String getPrefix(String namespaceURI) {
+ if (namespaceURI == null) {
+ throw new IllegalArgumentException();
+ }
+ for (String prefix : namespaces.keySet()) {
+ String uri = namespaces.get(prefix);
+ if (namespaceURI.equals(uri)) {
+ return prefix;
+ }
+ }
+ return null;
+ }
+
+ public Iterator getPrefixes(String namespaceURI) {
+ if (namespaceURI == null) {
+ throw new IllegalArgumentException();
+ }
+ List list = new ArrayList();
+ for (String prefix : namespaces.keySet()) {
+ String uri = namespaces.get(prefix);
+ if (namespaceURI.equals(uri)) {
+ list.add(prefix);
+ }
+ }
+ return Collections.unmodifiableList(list).iterator();
+ }
+ };
+ }
+
+ private static XPathFunction makeXPathFunction(final Constructor ctr, int arity) {
+ if (ctr.getParameterTypes().length != arity) {
+ return null;
+ }
+ return new XPathFunction() {
+
+ public Object evaluate(List args) {
+ try {
+ return ctr.newInstance(args.toArray());
+ } catch (Exception exp) {
+ throw new RuntimeException(exp);
+ }
+ }
+ };
+ }
+
+ private static XPathFunction makeXPathFunction(final Method method, int arity) {
+ int modifiers = method.getModifiers();
+ int numArgs = method.getParameterTypes().length;
+ if (Modifier.isStatic(modifiers) && numArgs == arity) {
+ // static method. expose "as is".
+ return new XPathFunction() {
+
+ public Object evaluate(List args) {
+ try {
+ return method.invoke(null, args.toArray());
+ } catch (Exception exp) {
+ throw new RuntimeException(exp);
+ }
+ }
+ };
+ } else if ((numArgs + 1) == arity) {
+ // instance method. treat the first arg as 'this'
+ return new XPathFunction() {
+
+ public Object evaluate(List args) {
+ List tmp = args.subList(1, args.size());
+ try {
+ return method.invoke(args.get(0), tmp.toArray());
+ } catch (Exception exp) {
+ throw new RuntimeException(exp);
+ }
+ }
+ };
+ } else {
+ return null;
+ }
+ }
+
+ private static XPathFunction makeXPathFunction(final String funcName, final Invocable
invocable) {
+ return new XPathFunction() {
+
+ public Object evaluate(List args) {
+ try {
+ return invocable.invokeFunction(funcName, args.toArray());
+ } catch (Exception exp) {
+ throw new RuntimeException(exp);
+ }
+ }
+ };
+ }
+
+ // make a XPathFunction from given object
+ private static XPathFunction makeXPathFunction(QName qname, Object obj, int arity) {
+ if (obj == null) {
+ return null;
+ } else if (obj instanceof XPathFunction) {
+ // already XPathFunction - just return
+ return (XPathFunction) obj;
+ } else if (obj instanceof Method) {
+ // a Method object. wrap as XPathFunction
+ return makeXPathFunction((Method) obj, arity);
+ } else if (obj instanceof Constructor) {
+ // a Constructor object. wrap as XPathFunction
+ return makeXPathFunction((Constructor) obj, arity);
+ } else if (obj instanceof Invocable) {
+ // wrap a script function as XPathFunction. Using this,
+ // scripts from other languages (for eg. JavaScript) can use
+ // this engine and pass script functions as XPathFunction extensions
+
+ return makeXPathFunction(qname.getLocalPart(), (Invocable) obj);
+ } else {
+ // can't map the object as XPathFunction.
+ return null;
+ }
+ }
+
+ // Internals only below this point
+ private XPathExpression compileXPath(String str, final ScriptContext ctx) throws
ScriptException {
+ // JSR-223 requirement
+ ctx.setAttribute("context", ctx, ScriptContext.ENGINE_SCOPE);
+ try {
+ XPath xpath = xpathFactory.newXPath();
+ xpath.setXPathVariableResolver(new XPathVariableResolver() {
+
+ public Object resolveVariable(QName qname) {
+ return findVariable(qname, ctx);
+ }
+ });
+
+ xpath.setXPathFunctionResolver(new XPathFunctionResolver() {
+
+ public XPathFunction resolveFunction(QName qname, int arity) {
+ Object obj = findVariable(qname, ctx);
+ return makeXPathFunction(qname, obj, arity);
+ }
+ });
+ xpath.setNamespaceContext(makeNamespaceContext(ctx));
+ // xpath.setNamespaceContext(new BpmnFunctionResolver());
+ // xpath.setXPathFunctionResolver(new BpmnFunctionResolver());
+ int begin = str.indexOf("getObjectData") > -1 ? 14 : 0;
+ if (begin > 0) {
+ String objectDataRef = str.substring(begin + 1, str.indexOf(")") - 1);
+
+ objectData = (Document) ctx.getAttribute(objectDataRef);
+ // ctx.setAttribute(XPATH_INPUT_SRC, objectData , 100);
+
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ Source xmlSource = new DOMSource(objectData);
+ Result outputTarget = new StreamResult(outputStream);
+ TransformerFactory.newInstance().newTransformer().transform(xmlSource,
outputTarget);
+ InputStream is = new ByteArrayInputStream(outputStream.toByteArray());
+ ctx.setReader(new InputStreamReader(is));
+
+ str = str.substring(str.indexOf(")") + 1);
+ }
+ XPathExpression xpe = xpath.compile(str);
+ return xpe;
+ } catch (Exception exp) {
+ throw new ScriptException(exp);
+ }
+ }
+
+ private Object getVariable(ScriptContext ctx, String name) {
+ synchronized (ctx) {
+ int scope = ctx.getAttributesScope(name);
+ if (scope != -1) {
+ return ctx.getAttribute(name, scope);
+ }
+ }
+ return null;
+ }
+ private Object evalXPath(XPathExpression expr, final ScriptContext ctx) throws
ScriptException {
+
+ try {
+ Object resultType = getVariable(ctx, XPATH_RESULT_TYPE);
+ Object input = getVariable(ctx, XPATH_INPUT_SRC);
+
+ InputSource src;
+ if (input == null) {
+ // no input specified, use context reader
+ src = new InputSource(ctx.getReader());
+ } else {
+ // explicit InputSource specified
+ if (input instanceof InputSource) {
+ src = (InputSource) input;
+ } else if (input instanceof String) {
+ src = new InputSource((String) input);
+ } else if (input instanceof Reader) {
+ src = new InputSource((Reader) input);
+ } else if (input instanceof InputStream) {
+ src = new InputSource((InputStream) input);
+ } else {
+ // some other object input type specified (Node/NodeList)
+ src = null;
+ }
+ }
+
+ resultType = XPathConstants.BOOLEAN;
+
+ if (resultType instanceof QName) {
+ return (src != null) ? expr.evaluate(src, (QName) resultType) :
expr.evaluate(input, (QName) resultType);
+ } else {
+ return (src != null) ? expr.evaluate(src) : expr.evaluate(input);
+ }
+ } catch (Exception exp) {
+ throw new ScriptException(exp);
+ }
+ }
+
+ private String readFully(Reader reader) throws ScriptException {
+ char[] arr = new char[8 * 1024]; // 8K at a time
+ StringBuilder buf = new StringBuilder();
+ int numChars;
+ try {
+ while ((numChars = reader.read(arr, 0, arr.length)) > 0) {
+ buf.append(arr, 0, numChars);
+ }
+ } catch (IOException exp) {
+ throw new ScriptException(exp);
+ }
+ return buf.toString();
+ }
+}
Copied:
jbpm4/trunk/modules/pvm/src/main/java/org/jbpm/pvm/internal/script/XPathScriptEngineFactory.java
(from rev 5938,
jbpm4/trunk/modules/bpmn/src/main/java/com/sun/script/xpath/XPathScriptEngineFactory.java)
===================================================================
---
jbpm4/trunk/modules/pvm/src/main/java/org/jbpm/pvm/internal/script/XPathScriptEngineFactory.java
(rev 0)
+++
jbpm4/trunk/modules/pvm/src/main/java/org/jbpm/pvm/internal/script/XPathScriptEngineFactory.java 2009-12-10
11:15:51 UTC (rev 5942)
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
+ * Use is subject to license terms.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met: Redistributions of source
code
+ * must retain the above copyright notice, this list of conditions and the following
disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of
+ * conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution. Neither the name of the Sun Microsystems nor the names
of
+ * is contributors may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * XPathScriptEngineFactory.java
+ * @author A. Sundararajan
+ */
+
+package org.jbpm.pvm.internal.script;
+
+import javax.script.*;
+import java.util.*;
+
+public class XPathScriptEngineFactory implements ScriptEngineFactory {
+ public String getEngineName() {
+ return "xpath";
+ }
+
+ public String getEngineVersion() {
+ return "1.0";
+ }
+
+ public List<String> getExtensions() {
+ return extensions;
+ }
+
+ public String getLanguageName() {
+ return "jaxp";
+ }
+
+ public String getLanguageVersion() {
+ return "1.4";
+ }
+
+ public String getMethodCallSyntax(String obj, String m, String... args) {
+ throw new UnsupportedOperationException("getMethodCallSyntax");
+ }
+
+ public List<String> getMimeTypes() {
+ return mimeTypes;
+ }
+
+ public List<String> getNames() {
+ return names;
+ }
+
+ public String getOutputStatement(String str) {
+ throw new UnsupportedOperationException("getOutputStatement");
+ }
+
+ public String getParameter(String key) {
+ if (key.equals(ScriptEngine.ENGINE)) {
+ return getEngineName();
+ } else if (key.equals(ScriptEngine.ENGINE_VERSION)) {
+ return getEngineVersion();
+ } else if (key.equals(ScriptEngine.NAME)) {
+ return getEngineName();
+ } else if (key.equals(ScriptEngine.LANGUAGE)) {
+ return getLanguageName();
+ } else if (key.equals(ScriptEngine.LANGUAGE_VERSION)) {
+ return getLanguageVersion();
+ } else if (key.equals("THREADING")) {
+ return "MULTITHREADED";
+ } else {
+ return null;
+ }
+ }
+
+ public String getProgram(String... statements) {
+ throw new UnsupportedOperationException("getProgram");
+ }
+
+ public ScriptEngine getScriptEngine() {
+ XPathScriptEngine engine = new XPathScriptEngine();
+ engine.setFactory(this);
+ return engine;
+ }
+
+ private static List<String> names;
+ private static List<String> extensions;
+ private static List<String> mimeTypes;
+ static {
+ names = new ArrayList<String>(1);
+ names.add("xpath");
+ names = Collections.unmodifiableList(names);
+ extensions = names;
+ mimeTypes = new ArrayList<String>(0);
+ mimeTypes = Collections.unmodifiableList(mimeTypes);
+ }
+}