nokogiri 1.11.0.rc1-java → 1.11.2-java

data/ext/java/nokogiri/XmlSyntaxError.java

@@ -50,93 +50,119 @@ import org.xml.sax.SAXParseException;
  * @author sergio
  * @author Yoko Harada <yokolet@gmail.com>
  */
-@JRubyClass(name="Nokogiri::XML::SyntaxError", parent="Nokogiri::SyntaxError")
-public class XmlSyntaxError extends RubyException {
-
-    private Exception exception;
-    private boolean messageSet; // whether a custom error message was set
-
-    public XmlSyntaxError(Ruby runtime, RubyClass klazz) {
-        super(runtime, klazz);
-    }
-
-    public XmlSyntaxError(Ruby runtime, RubyClass rubyClass, Exception ex) {
-        super(runtime, rubyClass, ex.getMessage());
-        this.exception = ex;
-    }
-
-    public XmlSyntaxError(Ruby runtime, RubyClass rubyClass, String message, Exception ex) {
-        super(runtime, rubyClass, message);
-        this.exception = ex; this.messageSet = true;
-    }
-
-    public static XmlSyntaxError createXMLSyntaxError(final Ruby runtime) {
-        RubyClass klazz = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::SyntaxError");
-        return new XmlSyntaxError(runtime, klazz);
-    }
-
-    public static XmlSyntaxError createXMLSyntaxError(final Ruby runtime, final Exception ex) {
-        RubyClass klazz = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::SyntaxError");
-        return new XmlSyntaxError(runtime, klazz, ex);
-    }
-
-    public static XmlSyntaxError createHTMLSyntaxError(final Ruby runtime) {
-        RubyClass klazz = (RubyClass) runtime.getClassFromPath("Nokogiri::HTML::SyntaxError");
-        return new XmlSyntaxError(runtime, klazz);
-    }
-
-    public static RubyException createXMLXPathSyntaxError(final Ruby runtime, final String msg, final Exception ex) {
-        RubyClass klazz = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::XPath::SyntaxError");
-        return new XmlSyntaxError(runtime, klazz, msg, ex);
-    }
-
-    public static XmlSyntaxError createWarning(Ruby runtime, SAXParseException e) {
-        XmlSyntaxError xmlSyntaxError = createXMLSyntaxError(runtime);
-        xmlSyntaxError.setException(runtime, e, 1);
-        return xmlSyntaxError;
-    }
-
-    public static XmlSyntaxError createError(Ruby runtime, SAXParseException e) {
-        XmlSyntaxError xmlSyntaxError = createXMLSyntaxError(runtime);
-        xmlSyntaxError.setException(runtime, e, 2);
-        return xmlSyntaxError;
-    }
-
-    public static XmlSyntaxError createFatalError(Ruby runtime, SAXParseException e) {
-        XmlSyntaxError xmlSyntaxError = createXMLSyntaxError(runtime);
-        xmlSyntaxError.setException(runtime, e, 3);
-        return xmlSyntaxError;
-    }
-
-    public void setException(Exception exception) {
-        this.exception = exception;
-    }
-
-    public void setException(Ruby runtime, SAXParseException exception, int level) {
-        this.exception = exception;
-        setInstanceVariable("@level", runtime.newFixnum(level));
-        setInstanceVariable("@line", runtime.newFixnum(exception.getLineNumber()));
-        setInstanceVariable("@column", runtime.newFixnum(exception.getColumnNumber()));
-        setInstanceVariable("@file", stringOrNil(runtime, exception.getSystemId()));
-    }
-
-    // NOTE: special care - due JRuby 1.7.x
-    
-    @Override
-    public IRubyObject to_s(ThreadContext context) { return to_s19(context); }
-
-    @JRubyMethod(name = "to_s")
-    public RubyString to_s19(ThreadContext context) {
-        RubyString msg = msg(context.runtime);
-        return msg != null ? msg : super.to_s(context).asString();
-    }
-
-    private RubyString msg(final Ruby runtime) {
-        if (exception != null && exception.getMessage() != null) {
-            if (messageSet) return null;
-            return runtime.newString( exception.getMessage() );
-        }
-        return null;
+@JRubyClass(name = "Nokogiri::XML::SyntaxError", parent = "Nokogiri::SyntaxError")
+public class XmlSyntaxError extends RubyException
+{
+
+  private Exception exception;
+  private boolean messageSet; // whether a custom error message was set
+
+  public
+  XmlSyntaxError(Ruby runtime, RubyClass klazz)
+  {
+    super(runtime, klazz);
+  }
+
+  public
+  XmlSyntaxError(Ruby runtime, RubyClass rubyClass, Exception ex)
+  {
+    super(runtime, rubyClass, ex.getMessage());
+    this.exception = ex;
+  }
+
+  public
+  XmlSyntaxError(Ruby runtime, RubyClass rubyClass, String message, Exception ex)
+  {
+    super(runtime, rubyClass, message);
+    this.exception = ex;
+    this.messageSet = true;
+  }
+
+  public static XmlSyntaxError
+  createXMLSyntaxError(final Ruby runtime)
+  {
+    RubyClass klazz = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::SyntaxError");
+    return new XmlSyntaxError(runtime, klazz);
+  }
+
+  public static XmlSyntaxError
+  createXMLSyntaxError(final Ruby runtime, final Exception ex)
+  {
+    RubyClass klazz = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::SyntaxError");
+    return new XmlSyntaxError(runtime, klazz, ex);
+  }
+
+  public static XmlSyntaxError
+  createHTMLSyntaxError(final Ruby runtime)
+  {
+    RubyClass klazz = (RubyClass) runtime.getClassFromPath("Nokogiri::HTML::SyntaxError");
+    return new XmlSyntaxError(runtime, klazz);
+  }
+
+  public static RubyException
+  createXMLXPathSyntaxError(final Ruby runtime, final String msg, final Exception ex)
+  {
+    RubyClass klazz = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::XPath::SyntaxError");
+    return new XmlSyntaxError(runtime, klazz, msg, ex);
+  }
+
+  public static XmlSyntaxError
+  createWarning(Ruby runtime, SAXParseException e)
+  {
+    XmlSyntaxError xmlSyntaxError = createXMLSyntaxError(runtime);
+    xmlSyntaxError.setException(runtime, e, 1);
+    return xmlSyntaxError;
+  }
+
+  public static XmlSyntaxError
+  createError(Ruby runtime, SAXParseException e)
+  {
+    XmlSyntaxError xmlSyntaxError = createXMLSyntaxError(runtime);
+    xmlSyntaxError.setException(runtime, e, 2);
+    return xmlSyntaxError;
+  }
+
+  public static XmlSyntaxError
+  createFatalError(Ruby runtime, SAXParseException e)
+  {
+    XmlSyntaxError xmlSyntaxError = createXMLSyntaxError(runtime);
+    xmlSyntaxError.setException(runtime, e, 3);
+    return xmlSyntaxError;
+  }
+
+  public void
+  setException(Exception exception)
+  {
+    this.exception = exception;
+  }
+
+  public void
+  setException(Ruby runtime, SAXParseException exception, int level)
+  {
+    this.exception = exception;
+    setInstanceVariable("@level", runtime.newFixnum(level));
+    setInstanceVariable("@line", runtime.newFixnum(exception.getLineNumber()));
+    setInstanceVariable("@column", runtime.newFixnum(exception.getColumnNumber()));
+    setInstanceVariable("@file", stringOrNil(runtime, exception.getSystemId()));
+  }
+
+  @JRubyMethod(name = "to_s")
+  @Override
+  public IRubyObject
+  to_s(ThreadContext context)
+  {
+    RubyString msg = msg(context.runtime);
+    return msg != null ? msg : super.to_s(context).asString();
+  }
+
+  private RubyString
+  msg(final Ruby runtime)
+  {
+    if (exception != null && exception.getMessage() != null) {
+      if (messageSet) { return null; }
+      return runtime.newString(exception.getMessage());
     }
+    return null;
+  }
 
 }

data/ext/java/nokogiri/XmlText.java

@@ -17,10 +17,10 @@
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
@@ -54,57 +54,68 @@ import org.w3c.dom.Text;
  * @author sergio
  * @author Yoko Harada <yokolet@gmail.com>
  */
-@JRubyClass(name="Nokogiri::XML::Text", parent="Nokogiri::XML::CharacterData")
-public class XmlText extends XmlNode {
+@JRubyClass(name = "Nokogiri::XML::Text", parent = "Nokogiri::XML::CharacterData")
+public class XmlText extends XmlNode
+{
 
-    private static final ByteList TEXT = ByteList.create("text");
-    static { TEXT.setEncoding(USASCIIEncoding.INSTANCE); }
+  private static final ByteList TEXT = ByteList.create("text");
+  static { TEXT.setEncoding(USASCIIEncoding.INSTANCE); }
 
-    public XmlText(Ruby runtime, RubyClass rubyClass, Node node) {
-        super(runtime, rubyClass, node);
-    }
+  public
+  XmlText(Ruby runtime, RubyClass rubyClass, Node node)
+  {
+    super(runtime, rubyClass, node);
+  }
 
-    public XmlText(Ruby runtime, RubyClass klass) {
-        super(runtime, klass);
+  public
+  XmlText(Ruby runtime, RubyClass klass)
+  {
+    super(runtime, klass);
+  }
+
+  @Override
+  protected void
+  init(ThreadContext context, IRubyObject[] args)
+  {
+    if (args.length < 2) {
+      throw context.runtime.newArgumentError(args.length, 2);
     }
 
-    @Override
-    protected void init(ThreadContext context, IRubyObject[] args) {
-        if (args.length < 2) {
-            throw context.runtime.newArgumentError(args.length, 2);
-        }
+    content = args[0];
+    IRubyObject xNode = args[1];
 
-        content = args[0];
-        IRubyObject xNode = args[1];
+    Document document = asXmlNode(context, xNode).getOwnerDocument();
+    // text node content should not be encoded when it is created by Text node.
+    // while content should be encoded when it is created by Element node.
+    Node node = document.createTextNode(rubyStringToString(content));
+    setNode(context.runtime, node);
+  }
 
-        Document document = asXmlNode(context, xNode).getOwnerDocument();
-        // text node content should not be encoded when it is created by Text node.
-        // while content should be encoded when it is created by Element node.
-        Node node = document.createTextNode(rubyStringToString(content));
-        setNode(context.runtime, node);
-    }
-    
-    @Override
-    protected IRubyObject getNodeName(ThreadContext context) {
-        if (name == null) name = RubyString.newStringShared(context.runtime, TEXT);
-        return name;
-    }
+  @Override
+  protected IRubyObject
+  getNodeName(ThreadContext context)
+  {
+    if (name == null) { name = RubyString.newStringShared(context.runtime, TEXT); }
+    return name;
+  }
 
-    @Override
-    public void accept(ThreadContext context, SaveContextVisitor visitor) {
-        visitor.enter((Text) node);
-        Node child = node.getFirstChild();
-        while (child != null) {
-            IRubyObject nokoNode = getCachedNodeOrCreate(context.runtime, child);
-            if (nokoNode instanceof XmlNode) {
-                XmlNode cur = (XmlNode) nokoNode;
-                cur.accept(context, visitor);
-            } else if (nokoNode instanceof XmlNamespace) {
-                XmlNamespace cur = (XmlNamespace) nokoNode;
-                cur.accept(context, visitor);
-            }
-            child = child.getNextSibling();
-        }
-        visitor.leave(node);
+  @Override
+  public void
+  accept(ThreadContext context, SaveContextVisitor visitor)
+  {
+    visitor.enter((Text) node);
+    Node child = node.getFirstChild();
+    while (child != null) {
+      IRubyObject nokoNode = getCachedNodeOrCreate(context.runtime, child);
+      if (nokoNode instanceof XmlNode) {
+        XmlNode cur = (XmlNode) nokoNode;
+        cur.accept(context, visitor);
+      } else if (nokoNode instanceof XmlNamespace) {
+        XmlNamespace cur = (XmlNamespace) nokoNode;
+        cur.accept(context, visitor);
+      }
+      child = child.getNextSibling();
     }
+    visitor.leave(node);
+  }
 }

data/ext/java/nokogiri/XmlXpathContext.java

@@ -33,6 +33,8 @@
 package nokogiri;
 
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import javax.xml.transform.TransformerException;
 
@@ -66,206 +68,268 @@ import static nokogiri.internals.NokogiriHelpers.nodeListToRubyArray;
  * @author Yoko Harada <yokolet@gmail.com>
  * @author John Shahid <jvshahid@gmail.com>
  */
-@JRubyClass(name="Nokogiri::XML::XPathContext")
-public class XmlXpathContext extends RubyObject {
-
-    static {
-        final String DTMManager = "org.apache.xml.dtm.DTMManager";
-        if (SafePropertyAccessor.getProperty(DTMManager) == null) {
-            try { // use patched "org.apache.xml.dtm.ref.DTMManagerDefault"
-                System.setProperty(DTMManager, nokogiri.internals.XalanDTMManagerPatch.class.getName());
-            }
-            catch (SecurityException ex) { /* no-op - will work although might be slower */ }
-        }
+@JRubyClass(name = "Nokogiri::XML::XPathContext")
+public class XmlXpathContext extends RubyObject
+{
+  static
+  {
+    final String DTMManager = "org.apache.xml.dtm.DTMManager";
+    if (SafePropertyAccessor.getProperty(DTMManager) == null) {
+      try { // use patched "org.apache.xml.dtm.ref.DTMManagerDefault"
+        System.setProperty(DTMManager, nokogiri.internals.XalanDTMManagerPatch.class.getName());
+      } catch (SecurityException ex) { /* no-op - will work although might be slower */ }
     }
-
-    /**
-     * user-data key for (cached) {@link XPathContext}
-     */
-    public static final String XPATH_CONTEXT = "CACHED_XPATH_CONTEXT";
-
-    private XmlNode context;
-
-    public XmlXpathContext(Ruby runtime, RubyClass klass) {
-        super(runtime, klass);
+  }
+
+  /**
+   * user-data key for (cached) {@link XPathContext}
+   */
+  public static final String XPATH_CONTEXT = "CACHED_XPATH_CONTEXT";
+
+  private XmlNode context;
+
+  public
+  XmlXpathContext(Ruby runtime, RubyClass klass)
+  {
+    super(runtime, klass);
+  }
+
+  public
+  XmlXpathContext(Ruby runtime, RubyClass klass, XmlNode node)
+  {
+    this(runtime, klass);
+    initNode(node);
+  }
+
+  private void
+  initNode(XmlNode node)
+  {
+    context = node;
+  }
+
+  @JRubyMethod(name = "new", meta = true)
+  public static IRubyObject
+  rbNew(ThreadContext context, IRubyObject klazz, IRubyObject node)
+  {
+    try {
+      return new XmlXpathContext(context.runtime, (RubyClass) klazz, (XmlNode) node);
+    } catch (IllegalArgumentException e) {
+      throw context.getRuntime().newRuntimeError(e.getMessage());
     }
+  }
+
+
+  // see https://en.wikipedia.org/wiki/QName
+  private static final String NameStartCharStr =
+    "[_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]"
+    ;
+  private static final String NameCharStr = "[-\\.0-9\u00B7\u0300-\u036F\u203F-\u2040]|" + NameStartCharStr ;
+  private static final String NCNameStr = "(?:" + NameStartCharStr + ")(?:" + NameCharStr + ")*";
+  private static final String XPathFunctionCaptureStr = "(" + NCNameStr + "(?=\\())";
+  private static final Pattern XPathFunctionCaptureRE = Pattern.compile(XPathFunctionCaptureStr);
+
+  @JRubyMethod
+  public IRubyObject
+  evaluate(ThreadContext context, IRubyObject rbQuery, IRubyObject handler)
+  {
+    String query = rbQuery.convertToString().asJavaString();
+
+    if (!handler.isNil() && !isContainsPrefix(query)) {
+      //
+      //  The user has passed in a handler, but isn't using the `nokogiri:` prefix as
+      //  instructed in JRuby land, so let's try to be clever and rewrite the query, inserting
+      //  the nokogiri namespace where appropriate.
+      //
+      StringBuilder namespacedQuery = new StringBuilder();
+      int jchar = 0;
+
+      // Find the methods on the handler object
+      Set<String> methodNames = handler.getMetaClass().getMethods().keySet();
+
+      // Find the function calls in the xpath query
+      Matcher xpathFunctionCalls = XPathFunctionCaptureRE.matcher(query);
+
+      while (xpathFunctionCalls.find()) {
+        namespacedQuery.append(query.subSequence(jchar, xpathFunctionCalls.start()));
+        jchar = xpathFunctionCalls.start();
+
+        if (methodNames.contains(xpathFunctionCalls.group())) {
+          namespacedQuery.append(NokogiriNamespaceContext.NOKOGIRI_PREFIX);
+          namespacedQuery.append(":");
+        }
 
-    public XmlXpathContext(Ruby runtime, RubyClass klass, XmlNode node) {
-        this(runtime, klass);
-        initNode(node);
-    }
+        namespacedQuery.append(query.subSequence(xpathFunctionCalls.start(), xpathFunctionCalls.end()));
+        jchar = xpathFunctionCalls.end();
+      }
 
-    private void initNode(XmlNode node) {
-        context = node;
+      if (jchar < query.length() - 1) {
+        namespacedQuery.append(query.subSequence(jchar, query.length()));
+      }
+      query = namespacedQuery.toString();
     }
 
-    @JRubyMethod(name = "new", meta = true)
-    public static IRubyObject rbNew(ThreadContext context, IRubyObject klazz, IRubyObject node) {
-        try {
-            return new XmlXpathContext(context.runtime, (RubyClass) klazz, (XmlNode) node);
-        }
-        catch (IllegalArgumentException e) {
-            throw context.getRuntime().newRuntimeError(e.getMessage());
-        }
+    return node_set(context, query, handler);
+  }
+
+  @JRubyMethod
+  public IRubyObject
+  evaluate(ThreadContext context, IRubyObject expr)
+  {
+    return this.evaluate(context, expr, context.getRuntime().getNil());
+  }
+
+  private final NokogiriNamespaceContext nsContext = NokogiriNamespaceContext.create();
+
+  @JRubyMethod
+  public IRubyObject
+  register_ns(IRubyObject prefix, IRubyObject uri)
+  {
+    nsContext.registerNamespace(prefix.asJavaString(), uri.asJavaString());
+    return this;
+  }
+
+  private NokogiriXPathVariableResolver variableResolver; // binds (if any)
+
+  @JRubyMethod
+  public IRubyObject
+  register_variable(IRubyObject name, IRubyObject value)
+  {
+    NokogiriXPathVariableResolver variableResolver = this.variableResolver;
+    if (variableResolver == null) {
+      variableResolver = NokogiriXPathVariableResolver.create();
+      this.variableResolver = variableResolver;
     }
-
-    @JRubyMethod
-    public IRubyObject evaluate(ThreadContext context, IRubyObject expr, IRubyObject handler) {
-
-        String src = expr.convertToString().asJavaString();
-        if (!handler.isNil()) {
-            if (!isContainsPrefix(src)) {
-                StringBuilder replacement = new StringBuilder();
-                Set<String> methodNames = handler.getMetaClass().getMethods().keySet();
-                final String PREFIX = NokogiriNamespaceContext.NOKOGIRI_PREFIX;
-                for (String name : methodNames) {
-                    replacement.setLength(0);
-                    replacement.ensureCapacity(PREFIX.length() + 1 + name.length());
-                    replacement.append(PREFIX).append(':').append(name);
-                    src = src.replace(name, replacement); // replace(name, NOKOGIRI_PREFIX + ':' + name)
-                }
-            }
-        }
-
-        return node_set(context, src, handler);
+    variableResolver.registerVariable(name.asJavaString(), value.asJavaString());
+    return this;
+  }
+
+  private IRubyObject
+  node_set(ThreadContext context, String expr, IRubyObject handler)
+  {
+    final NokogiriXPathFunctionResolver fnResolver = NokogiriXPathFunctionResolver.create(handler);
+    try {
+      return tryGetNodeSet(context, expr, fnResolver);
+    } catch (TransformerException ex) {
+      throw XmlSyntaxError.createXMLXPathSyntaxError(context.runtime,
+          (expr + ": " + ex.toString()),
+          ex).toThrowable();
     }
-
-    @JRubyMethod
-    public IRubyObject evaluate(ThreadContext context, IRubyObject expr) {
-        return this.evaluate(context, expr, context.getRuntime().getNil());
+  }
+
+  private IRubyObject
+  tryGetNodeSet(ThreadContext context, String expr, NokogiriXPathFunctionResolver fnResolver) throws TransformerException
+  {
+    final Node contextNode = this.context.node;
+
+    final JAXPPrefixResolver prefixResolver = new JAXPPrefixResolver(nsContext);
+    XPath xpathInternal = new XPath(expr, null, prefixResolver, XPath.SELECT);
+
+    // We always need to have a ContextNode with Xalan XPath implementation
+    // To allow simple expression evaluation like 1+1 we are setting
+    // dummy Document as Context Node
+    final XObject xobj;
+    if (contextNode == null) {
+      xobj = xpathInternal.execute(getXPathContext(fnResolver), DTM.NULL, prefixResolver);
+    } else {
+      xobj = xpathInternal.execute(getXPathContext(fnResolver), contextNode, prefixResolver);
     }
 
-    private final NokogiriNamespaceContext nsContext = NokogiriNamespaceContext.create();
-
-    @JRubyMethod
-    public IRubyObject register_ns(IRubyObject prefix, IRubyObject uri) {
-        nsContext.registerNamespace(prefix.asJavaString(), uri.asJavaString());
-        return this;
+    switch (xobj.getType()) {
+    case XObject.CLASS_BOOLEAN :
+      return context.runtime.newBoolean(xobj.bool());
+    case XObject.CLASS_NUMBER :
+      return context.runtime.newFloat(xobj.num());
+    case XObject.CLASS_NODESET :
+      IRubyObject[] nodes = nodeListToRubyArray(context.runtime, xobj.nodelist());
+      return XmlNodeSet.newNodeSet(context.runtime, nodes, this.context);
+    default :
+      return context.runtime.newString(xobj.str());
     }
-
-    private NokogiriXPathVariableResolver variableResolver; // binds (if any)
-
-    @JRubyMethod
-    public IRubyObject register_variable(IRubyObject name, IRubyObject value) {
-        NokogiriXPathVariableResolver variableResolver = this.variableResolver;
-        if (variableResolver == null) {
-            variableResolver = NokogiriXPathVariableResolver.create();
-            this.variableResolver = variableResolver;
-        }
-        variableResolver.registerVariable(name.asJavaString(), value.asJavaString());
-        return this;
+  }
+
+  private XPathContext
+  getXPathContext(final NokogiriXPathFunctionResolver fnResolver)
+  {
+    Node doc = context.getNode().getOwnerDocument();
+    if (doc == null) { doc = context.getNode(); }
+
+    XPathContext xpathContext = (XPathContext) doc.getUserData(XPATH_CONTEXT);
+
+    if (xpathContext == null) {
+      xpathContext = newXPathContext(fnResolver);
+      if (variableResolver == null) {
+        // NOTE: only caching without variables - could be improved by more sophisticated caching
+        doc.setUserData(XPATH_CONTEXT, xpathContext, null);
+      }
+    } else {
+      Object owner = xpathContext.getOwnerObject();
+      if ((owner == null && fnResolver == null) ||
+          (owner instanceof JAXPExtensionsProvider && ((JAXPExtensionsProvider) owner).hasSameResolver(fnResolver))) {
+        // can be re-used assuming it has the same variable-stack (for now only cached if no variables)
+        if (variableResolver == null) { return xpathContext; }
+      }
+      xpathContext = newXPathContext(fnResolver); // otherwise we can not use the cached xpath-context
     }
 
-    private IRubyObject node_set(ThreadContext context, String expr, IRubyObject handler) {
-        final NokogiriXPathFunctionResolver fnResolver =
-            handler.isNil() ? null : NokogiriXPathFunctionResolver.create(handler);
-        try {
-            return tryGetNodeSet(context, expr, fnResolver);
-        }
-        catch (TransformerException ex) {
-            throw new RaiseException(XmlSyntaxError.createXMLXPathSyntaxError(context.runtime, expr, ex)); // Nokogiri::XML::XPath::SyntaxError
-        }
+    if (variableResolver != null) {
+      xpathContext.setVarStack(new JAXPVariableStack(variableResolver));
     }
 
-    private IRubyObject tryGetNodeSet(ThreadContext context, String expr, NokogiriXPathFunctionResolver fnResolver) throws TransformerException {
-        final Node contextNode = this.context.node;
-
-        final JAXPPrefixResolver prefixResolver = new JAXPPrefixResolver(nsContext);
-        XPath xpathInternal = new XPath(expr, null, prefixResolver, XPath.SELECT);
-
-        // We always need to have a ContextNode with Xalan XPath implementation
-        // To allow simple expression evaluation like 1+1 we are setting
-        // dummy Document as Context Node
-        final XObject xobj;
-        if ( contextNode == null )
-            xobj = xpathInternal.execute(getXPathContext(fnResolver), DTM.NULL, prefixResolver);
-        else
-            xobj = xpathInternal.execute(getXPathContext(fnResolver), contextNode, prefixResolver);
-
-        switch (xobj.getType()) {
-            case XObject.CLASS_BOOLEAN : return context.runtime.newBoolean(xobj.bool());
-            case XObject.CLASS_NUMBER :  return context.runtime.newFloat(xobj.num());
-            case XObject.CLASS_NODESET :
-                IRubyObject[] nodes = nodeListToRubyArray(context.runtime, xobj.nodelist());
-                return XmlNodeSet.newNodeSet(context.runtime, nodes, this.context);
-            default : return context.runtime.newString(xobj.str());
-        }
+    return xpathContext;
+  }
+
+  private static XPathContext
+  newXPathContext(final NokogiriXPathFunctionResolver functionResolver)
+  {
+    if (functionResolver == null) { return new XPathContext(false); }
+    return new XPathContext(new JAXPExtensionsProvider(functionResolver), false);
+  }
+
+  private boolean
+  isContainsPrefix(final String str)
+  {
+    final StringBuilder prefix_ = new StringBuilder();
+    for (String prefix : nsContext.getAllPrefixes()) {
+      prefix_.setLength(0);
+      prefix_.ensureCapacity(prefix.length() + 1);
+      prefix_.append(prefix).append(':');
+      if (str.contains(prefix_)) {   // prefix + ':'
+        return true;
+      }
     }
+    return false;
+  }
 
-    private XPathContext getXPathContext(final NokogiriXPathFunctionResolver fnResolver) {
-        Node doc = context.getNode().getOwnerDocument();
-        if (doc == null) doc = context.getNode();
-
-        XPathContext xpathContext = (XPathContext) doc.getUserData(XPATH_CONTEXT);
+  private static final class JAXPExtensionsProvider extends org.apache.xpath.jaxp.JAXPExtensionsProvider
+  {
 
-        if ( xpathContext == null ) {
-            xpathContext = newXPathContext(fnResolver);
-            if ( variableResolver == null ) {
-                // NOTE: only caching without variables - could be improved by more sophisticated caching
-                doc.setUserData(XPATH_CONTEXT, xpathContext, null);
-            }
-        }
-        else {
-            Object owner = xpathContext.getOwnerObject();
-            if ( ( owner == null && fnResolver == null ) ||
-                ( owner instanceof JAXPExtensionsProvider && ((JAXPExtensionsProvider) owner).hasSameResolver(fnResolver) ) ) {
-                // can be re-used assuming it has the same variable-stack (for now only cached if no variables)
-                if ( variableResolver == null ) return xpathContext;
-            }
-            xpathContext = newXPathContext(fnResolver); // otherwise we can not use the cached xpath-context
-        }
+    final NokogiriXPathFunctionResolver resolver;
 
-        if ( variableResolver != null ) {
-            xpathContext.setVarStack(new JAXPVariableStack(variableResolver));
-        }
-
-        return xpathContext;
+    JAXPExtensionsProvider(NokogiriXPathFunctionResolver resolver)
+    {
+      super(resolver, false);
+      this.resolver = resolver;
     }
 
-    private static XPathContext newXPathContext(final NokogiriXPathFunctionResolver functionResolver) {
-        if ( functionResolver == null ) return new XPathContext(false);
-        return new XPathContext(new JAXPExtensionsProvider(functionResolver), false);
+    //@Override
+    //public boolean equals(Object obj) {
+    //    if (obj instanceof JAXPExtensionsProvider) {
+    //        return hasSameResolver(((JAXPExtensionsProvider) obj).resolver);
+    //    }
+    //    return false;
+    //}
+
+    final boolean
+    hasSameResolver(final NokogiriXPathFunctionResolver resolver)
+    {
+      return resolver == this.resolver || resolver != null && (
+               resolver.getHandler() == null ? this.resolver.getHandler() == null : (
+                 resolver.getHandler() == this.resolver.getHandler()
+                 // resolver.getHandler().eql( this.resolver.getHandler() )
+               )
+             );
     }
 
-    private boolean isContainsPrefix(final String str) {
-        final StringBuilder prefix_ = new StringBuilder();
-        for ( String prefix : nsContext.getAllPrefixes() ) {
-            prefix_.setLength(0);
-            prefix_.ensureCapacity(prefix.length() + 1);
-            prefix_.append(prefix).append(':');
-            if ( str.contains(prefix_) ) { // prefix + ':'
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private static final class JAXPExtensionsProvider extends org.apache.xpath.jaxp.JAXPExtensionsProvider {
-
-        final NokogiriXPathFunctionResolver resolver;
-
-        JAXPExtensionsProvider(NokogiriXPathFunctionResolver resolver) {
-            super(resolver, false);
-            this.resolver = resolver;
-        }
-
-        //@Override
-        //public boolean equals(Object obj) {
-        //    if (obj instanceof JAXPExtensionsProvider) {
-        //        return hasSameResolver(((JAXPExtensionsProvider) obj).resolver);
-        //    }
-        //    return false;
-        //}
-
-        final boolean hasSameResolver(final NokogiriXPathFunctionResolver resolver) {
-            return resolver == this.resolver || resolver != null && (
-                resolver.getHandler() == null ? this.resolver.getHandler() == null : (
-                    resolver.getHandler() == this.resolver.getHandler()
-                    // resolver.getHandler().eql( this.resolver.getHandler() )
-                )
-            );
-        }
-
-    }
+  }
 
 }