nokogiri 1.10.9-java → 1.11.0.rc4-java

data/ext/java/nokogiri/XmlSchema.java

@@ -51,6 +51,8 @@ import javax.xml.validation.Validator;
 import nokogiri.internals.IgnoreSchemaErrorsErrorHandler;
 import nokogiri.internals.SchemaErrorHandler;
 import nokogiri.internals.XmlDomParserContext;
+import nokogiri.internals.ParserContext;
+import nokogiri.internals.ParserContext.Options;
 
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
@@ -63,11 +65,13 @@ import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.Visibility;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.Helpers;
 import org.w3c.dom.Document;
 import org.w3c.dom.ls.LSInput;
 import org.w3c.dom.ls.LSResourceResolver;
 import org.xml.sax.ErrorHandler;
 import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
 
 /**
  * Class for Nokogiri::XML::Schema
@@ -93,11 +97,20 @@ public class XmlSchema extends RubyObject {
         return super.clone();
     }
 
-    private Schema getSchema(Source source, String currentDir, String scriptFileName) throws SAXException {
+    private Schema getSchema(Source source,
+                             String currentDir,
+                             String scriptFileName,
+                             SchemaErrorHandler errorHandler,
+                             long parseOptions) throws SAXException {
+        boolean noNet = new ParserContext.Options(parseOptions).noNet;
+
         SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
-        SchemaResourceResolver resourceResolver = new SchemaResourceResolver(currentDir, scriptFileName, null);
+        SchemaResourceResolver resourceResolver =
+            new SchemaResourceResolver(currentDir, scriptFileName, null, errorHandler, noNet);
+
         schemaFactory.setResourceResolver(resourceResolver);
-        schemaFactory.setErrorHandler(new IgnoreSchemaErrorsErrorHandler());
+        schemaFactory.setErrorHandler(errorHandler);
+
         return schemaFactory.newSchema(source);
     }
 
@@ -105,13 +118,27 @@ public class XmlSchema extends RubyObject {
         this.validator = validator;
     }
 
-    static XmlSchema createSchemaInstance(ThreadContext context, RubyClass klazz, Source source) {
+    static XmlSchema createSchemaInstance(ThreadContext context, RubyClass klazz, Source source, IRubyObject parseOptions) {
         Ruby runtime = context.getRuntime();
         XmlSchema xmlSchema = (XmlSchema) NokogiriService.XML_SCHEMA_ALLOCATOR.allocate(runtime, klazz);
+
+        if (parseOptions == null) {
+            parseOptions = defaultParseOptions(context.getRuntime());
+        }
+        long intParseOptions = RubyFixnum.fix2long(Helpers.invoke(context, parseOptions, "to_i"));
+
         xmlSchema.setInstanceVariable("@errors", runtime.newEmptyArray());
+        xmlSchema.setInstanceVariable("@parse_options", parseOptions);
 
         try {
-            Schema schema = xmlSchema.getSchema(source, context.getRuntime().getCurrentDirectory(), context.getRuntime().getInstanceConfig().getScriptFileName());
+            SchemaErrorHandler errorHandler =
+                new SchemaErrorHandler(context.getRuntime(), (RubyArray)xmlSchema.getInstanceVariable("@errors"));
+            Schema schema =
+                xmlSchema.getSchema(source,
+                                    context.getRuntime().getCurrentDirectory(),
+                                    context.getRuntime().getInstanceConfig().getScriptFileName(),
+                                    errorHandler,
+                                    intParseOptions);
             xmlSchema.setValidator(schema.newValidator());
             return xmlSchema;
         } catch (SAXException ex) {
@@ -119,19 +146,29 @@ public class XmlSchema extends RubyObject {
         }
     }
 
+    protected static IRubyObject defaultParseOptions(Ruby runtime) {
+        return ((RubyClass)runtime.getClassFromPath("Nokogiri::XML::ParseOptions")).getConstant("DEFAULT_SCHEMA");
+    }
+
     /*
      * call-seq:
      *  from_document(doc)
      *
      * Create a new Schema from the Nokogiri::XML::Document +doc+
      */
-    @JRubyMethod(meta=true)
-    public static IRubyObject from_document(ThreadContext context, IRubyObject klazz, IRubyObject document) {
+    @JRubyMethod(meta=true, required=1, optional=1)
+    public static IRubyObject from_document(ThreadContext context, IRubyObject klazz, IRubyObject[] args) {
+        IRubyObject document = args[0];
+        IRubyObject parseOptions = null;
+        if (args.length > 1) {
+            parseOptions = args[1];
+        }
+
         XmlDocument doc = ((XmlDocument) ((XmlNode) document).document(context));
 
         RubyArray errors = (RubyArray) doc.getInstanceVariable("@errors");
         if (!errors.isEmpty()) {
-            throw new RaiseException((XmlSyntaxError) errors.first());
+            throw ((XmlSyntaxError) errors.first()).toThrowable();
         }
 
         DOMSource source = new DOMSource(doc.getDocument());
@@ -142,25 +179,30 @@ public class XmlSchema extends RubyObject {
             source.setSystemId(uri.convertToString().asJavaString());
         }
 
-        return getSchema(context, (RubyClass)klazz, source);
+        return getSchema(context, (RubyClass)klazz, source, parseOptions);
+    }
+
+    @JRubyMethod(meta=true, required=1, optional=1)
+    public static IRubyObject read_memory(ThreadContext context, IRubyObject klazz, IRubyObject[] args) {
+        IRubyObject content = args[0];
+        IRubyObject parseOptions = null;
+        if (args.length > 1) {
+            parseOptions = args[1];
+        }
+        String data = content.convertToString().asJavaString();
+        return getSchema(context, (RubyClass) klazz, new StreamSource(new StringReader(data)), parseOptions);
     }
 
-    private static IRubyObject getSchema(ThreadContext context, RubyClass klazz, Source source) {
+    private static IRubyObject getSchema(ThreadContext context, RubyClass klazz, Source source, IRubyObject parseOptions) {
         String moduleName = klazz.getName();
         if ("Nokogiri::XML::Schema".equals(moduleName)) {
-            return XmlSchema.createSchemaInstance(context, klazz, source);
+            return XmlSchema.createSchemaInstance(context, klazz, source, parseOptions);
         } else if ("Nokogiri::XML::RelaxNG".equals(moduleName)) {
-            return XmlRelaxng.createSchemaInstance(context, klazz, source);
+            return XmlRelaxng.createSchemaInstance(context, klazz, source, parseOptions);
         }
         return context.getRuntime().getNil();
     }
 
-    @JRubyMethod(meta=true)
-    public static IRubyObject read_memory(ThreadContext context, IRubyObject klazz, IRubyObject content) {
-        String data = content.convertToString().asJavaString();
-        return getSchema(context, (RubyClass) klazz, new StreamSource(new StringReader(data)));
-    }
-
     @JRubyMethod(visibility=Visibility.PRIVATE)
     public IRubyObject validate_document(ThreadContext context, IRubyObject document) {
         return validate_document_or_file(context, (XmlDocument)document);
@@ -168,11 +210,11 @@ public class XmlSchema extends RubyObject {
 
     @JRubyMethod(visibility=Visibility.PRIVATE)
     public IRubyObject validate_file(ThreadContext context, IRubyObject file) {
-        Ruby ruby = context.getRuntime();
+        Ruby runtime = context.runtime;
 
-        XmlDomParserContext ctx = new XmlDomParserContext(ruby, RubyFixnum.newFixnum(ruby, 1L));
+        XmlDomParserContext ctx = new XmlDomParserContext(runtime, RubyFixnum.newFixnum(runtime, 1L));
         ctx.setInputSourceFile(context, file);
-        XmlDocument xmlDocument = ctx.parse(context, getNokogiriClass(ruby, "Nokogiri::XML::Document"), ruby.getNil());
+        XmlDocument xmlDocument = ctx.parse(context, getNokogiriClass(runtime, "Nokogiri::XML::Document"), context.nil);
         return validate_document_or_file(context, xmlDocument);
     }
 
@@ -209,11 +251,15 @@ public class XmlSchema extends RubyObject {
         SchemaLSInput lsInput = new SchemaLSInput();
         String currentDir;
         String scriptFileName;
+        SchemaErrorHandler errorHandler;
+        boolean noNet;
         //String defaultURI;
 
-        SchemaResourceResolver(String currentDir, String scriptFileName, Object input) {
+        SchemaResourceResolver(String currentDir, String scriptFileName, Object input, SchemaErrorHandler errorHandler, boolean noNet) {
             this.currentDir = currentDir;
             this.scriptFileName = scriptFileName;
+            this.errorHandler = errorHandler;
+            this.noNet = noNet;
             if (input == null) return;
             if (input instanceof String) {
                 lsInput.setStringData((String)input);
@@ -225,11 +271,25 @@ public class XmlSchema extends RubyObject {
         }
 
         @Override
-        public LSInput resolveResource(String type, String namespaceURI, String publicId, String systemId, String baseURI) {
-            String adjusted = adjustSystemIdIfNecessary(currentDir, scriptFileName, baseURI, systemId);
-            lsInput.setPublicId(publicId);
-            lsInput.setSystemId(adjusted != null? adjusted : systemId);
-            lsInput.setBaseURI(baseURI);
+        public LSInput resolveResource(String type,
+                                       String namespaceURI,
+                                       String publicId,
+                                       String systemId,
+                                       String baseURI) {
+            if (noNet && (systemId.startsWith("http://") || systemId.startsWith("ftp://"))) {
+                if (systemId.startsWith(XMLConstants.W3C_XML_SCHEMA_NS_URI)) {
+                    return null; // use default resolver
+                }
+                try {
+                    this.errorHandler.warning(new SAXParseException(String.format("Attempt to load network entity '%s'", systemId), null));
+                } catch (SAXException ex) {
+                }
+            } else {
+                String adjusted = adjustSystemIdIfNecessary(currentDir, scriptFileName, baseURI, systemId);
+                lsInput.setPublicId(publicId);
+                lsInput.setSystemId(adjusted != null? adjusted : systemId);
+                lsInput.setBaseURI(baseURI);
+            }
             return lsInput;
         }
     }

data/ext/java/nokogiri/XmlSyntaxError.java

@@ -120,13 +120,9 @@ public class XmlSyntaxError extends RubyException {
         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) {
+    @Override
+    public IRubyObject to_s(ThreadContext context) {
         RubyString msg = msg(context.runtime);
         return msg != null ? msg : super.to_s(context).asString();
     }

data/ext/java/nokogiri/XmlText.java

@@ -36,11 +36,14 @@ import static nokogiri.internals.NokogiriHelpers.getCachedNodeOrCreate;
 import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
 import nokogiri.internals.SaveContextVisitor;
 
+import org.jcodings.specific.USASCIIEncoding;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
+import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 import org.w3c.dom.Text;
@@ -54,6 +57,9 @@ import org.w3c.dom.Text;
 @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); }
+
     public XmlText(Ruby runtime, RubyClass rubyClass, Node node) {
         super(runtime, rubyClass, node);
     }
@@ -65,34 +71,31 @@ public class XmlText extends XmlNode {
     @Override
     protected void init(ThreadContext context, IRubyObject[] args) {
         if (args.length < 2) {
-            throw getRuntime().newArgumentError(args.length, 2);
+            throw context.runtime.newArgumentError(args.length, 2);
         }
 
         content = args[0];
         IRubyObject xNode = args[1];
 
-        XmlNode xmlNode = asXmlNode(context, xNode);
-        XmlDocument xmlDoc = (XmlDocument)xmlNode.document(context);
-        doc = xmlDoc;
-        Document document = xmlDoc.getDocument();
+        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, node);
+        setNode(context.runtime, node);
     }
     
     @Override
     protected IRubyObject getNodeName(ThreadContext context) {
-        if (name == null) name = context.getRuntime().newString("text");
+        if (name == null) name = RubyString.newStringShared(context.runtime, TEXT);
         return name;
     }
 
     @Override
     public void accept(ThreadContext context, SaveContextVisitor visitor) {
-        visitor.enter((Text)node);
+        visitor.enter((Text) node);
         Node child = node.getFirstChild();
         while (child != null) {
-            IRubyObject nokoNode = getCachedNodeOrCreate(context.getRuntime(), child);
+            IRubyObject nokoNode = getCachedNodeOrCreate(context.runtime, child);
             if (nokoNode instanceof XmlNode) {
                 XmlNode cur = (XmlNode) nokoNode;
                 cur.accept(context, visitor);

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;
 
@@ -57,6 +59,8 @@ import nokogiri.internals.NokogiriNamespaceContext;
 import nokogiri.internals.NokogiriXPathFunctionResolver;
 import nokogiri.internals.NokogiriXPathVariableResolver;
 
+import static nokogiri.internals.NokogiriHelpers.nodeListToRubyArray;
+
 /**
  * Class for Nokogiri::XML::XpathContext
  *
@@ -66,7 +70,6 @@ import nokogiri.internals.NokogiriXPathVariableResolver;
  */
 @JRubyClass(name="Nokogiri::XML::XPathContext")
 public class XmlXpathContext extends RubyObject {
-
     static {
         final String DTMManager = "org.apache.xml.dtm.DTMManager";
         if (SafePropertyAccessor.getProperty(DTMManager) == null) {
@@ -107,25 +110,53 @@ public class XmlXpathContext extends RubyObject {
         }
     }
 
+
+    // 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 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)
+    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(":");
                 }
+
+                namespacedQuery.append(query.subSequence(xpathFunctionCalls.start(), xpathFunctionCalls.end()));
+                jchar = xpathFunctionCalls.end();
+            }
+
+            if (jchar < query.length()-1) {
+                namespacedQuery.append(query.subSequence(jchar, query.length()));
             }
+            query = namespacedQuery.toString();
         }
 
-        return node_set(context, src, handler);
+        return node_set(context, query, handler);
     }
 
     @JRubyMethod
@@ -155,13 +186,14 @@ public class XmlXpathContext extends RubyObject {
     }
 
     private IRubyObject node_set(ThreadContext context, String expr, IRubyObject handler) {
-        final NokogiriXPathFunctionResolver fnResolver =
-            handler.isNil() ? null : NokogiriXPathFunctionResolver.create(handler);
+        final NokogiriXPathFunctionResolver fnResolver = 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
+            throw XmlSyntaxError.createXMLXPathSyntaxError(context.runtime,
+                                                           (expr + ": " + ex.toString()),
+                                                           ex).toThrowable();
         }
     }
 
@@ -181,14 +213,12 @@ public class XmlXpathContext extends RubyObject {
             xobj = xpathInternal.execute(getXPathContext(fnResolver), contextNode, prefixResolver);
 
         switch (xobj.getType()) {
-            case XObject.CLASS_BOOLEAN : return context.getRuntime().newBoolean(xobj.bool());
-            case XObject.CLASS_NUMBER :  return context.getRuntime().newFloat(xobj.num());
+            case XObject.CLASS_BOOLEAN : return context.runtime.newBoolean(xobj.bool());
+            case XObject.CLASS_NUMBER :  return context.runtime.newFloat(xobj.num());
             case XObject.CLASS_NODESET :
-                XmlNodeSet xmlNodeSet = XmlNodeSet.newEmptyNodeSet(context);
-                xmlNodeSet.setNodeList(xobj.nodelist());
-                xmlNodeSet.initialize(context.getRuntime(), this.context);
-                return xmlNodeSet;
-            default : return context.getRuntime().newString(xobj.str());
+                IRubyObject[] nodes = nodeListToRubyArray(context.runtime, xobj.nodelist());
+                return XmlNodeSet.newNodeSet(context.runtime, nodes, this.context);
+            default : return context.runtime.newString(xobj.str());
         }
     }
 

data/ext/java/nokogiri/XsltStylesheet.java

@@ -130,12 +130,11 @@ public class XsltStylesheet extends RubyObject {
         }
     }
     
-    private Pattern p = Pattern.compile("'.{1,}'");
+    private static final Pattern QUOTED = Pattern.compile("'.{1,}'");
 
     private String unparseValue(String orig) {
-        Matcher m = p.matcher(orig);
-        if ((orig.startsWith("\"") && orig.endsWith("\"")) || m.matches()) {
-            orig = orig.substring(1, orig.length()-1);
+        if ((orig.startsWith("\"") && orig.endsWith("\"")) || QUOTED.matcher(orig).matches()) {
+            orig = orig.substring(1, orig.length() - 1);
         }
 
         return orig;
@@ -174,11 +173,8 @@ public class XsltStylesheet extends RubyObject {
     }
     
     private static void ensureFirstArgIsDocument(Ruby runtime, IRubyObject arg) {
-        if (arg instanceof XmlDocument) {
-            return;
-        } else {
-            throw runtime.newArgumentError("doc must be a Nokogiri::XML::Document instance");
-        }
+        if (arg instanceof XmlDocument) return;
+        throw runtime.newArgumentError("doc must be a Nokogiri::XML::Document instance");
     }
     
     private static void ensureDocumentHasNoError(ThreadContext context, XmlDocument xmlDoc) {
@@ -289,13 +285,9 @@ public class XsltStylesheet extends RubyObject {
     
     private IRubyObject createDocumentFromDomResult(ThreadContext context, Ruby runtime, DOMResult domResult) {
         if ("html".equals(domResult.getNode().getFirstChild().getNodeName())) {
-            HtmlDocument htmlDocument = (HtmlDocument) getNokogiriClass(runtime, "Nokogiri::HTML::Document").allocate();
-            htmlDocument.setDocumentNode(context, (Document) domResult.getNode());
-            return htmlDocument;
+            return new HtmlDocument(context.runtime, (Document) domResult.getNode());
         } else {
-            XmlDocument xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Document"));
-            xmlDocument.setDocumentNode(context, (Document) domResult.getNode());
-            return xmlDocument;
+            return new XmlDocument(context.runtime, (Document) domResult.getNode());
         }
     }