nokogiri 1.11.0.rc3-java → 1.11.0.rc4-java

data/README.md

@@ -129,7 +129,7 @@ end
 
 ## Requirements
 
-Ruby 2.4.0 or higher, including any development packages necessary to compile native extensions.
+Ruby 2.5.0 or higher, including any development packages necessary to compile native extensions.
 
 In Nokogiri 1.6.0 and later libxml2 and libxslt are bundled with the gem, but if you want to use the system versions:
 

data/ext/java/nokogiri/HtmlSaxParserContext.java

@@ -194,7 +194,7 @@ public class HtmlSaxParserContext extends XmlSaxParserContext {
             throw context.getRuntime().newEncodingCompatibilityError(rubyEncoding + "is not supported");
         }
         catch (IllegalCharsetNameException e) {
-            throw context.getRuntime().newInvalidEncoding(e.getMessage());
+            throw context.getRuntime().newEncodingError(e.getMessage());
         }
     }
 

data/ext/java/nokogiri/HtmlSaxPushParser.java

@@ -129,7 +129,7 @@ public class HtmlSaxPushParser extends RubyObject {
         final ByteArrayInputStream data = NokogiriHelpers.stringBytesToStream(chunk);
         if (data == null) {
             terminateTask(context.runtime);
-            throw new RaiseException(XmlSyntaxError.createHTMLSyntaxError(context.runtime)); // Nokogiri::HTML::SyntaxError
+            throw XmlSyntaxError.createHTMLSyntaxError(context.runtime).toThrowable(); // Nokogiri::HTML::SyntaxError
         }
 
         int errorCount0 = parserTask.getErrorCount();

data/ext/java/nokogiri/XmlNode.java

@@ -720,7 +720,7 @@ public class XmlNode extends RubyObject {
         // Do not touch this if, if it's not for a good reason.
         if (node.getNodeType() == Node.DOCUMENT_NODE ||
            otherNode.getNodeType() == Node.DOCUMENT_NODE) {
-            return context.runtime.newFixnum(-1);
+            return context.runtime.newFixnum(1);
         }
 
         try{
@@ -759,15 +759,13 @@ public class XmlNode extends RubyObject {
             klass = getNokogiriClass(runtime, "Nokogiri::HTML::Document");
             ctx = new HtmlDomParserContext(runtime, options);
             ((HtmlDomParserContext) ctx).enableDocumentFragment();
-            istream = new ByteArrayInputStream((rubyStringToString(str)).getBytes());
+            ctx.setStringInputSource(context, str, context.nil);
         } else {
             klass = getNokogiriClass(runtime, "Nokogiri::XML::Document");
             ctx = new XmlDomParserContext(runtime, options);
-            String input = rubyStringToString(str);
-            istream = new ByteArrayInputStream(input.getBytes());
+            ctx.setStringInputSource(context, str, context.nil);
         }
 
-        ctx.setInputSource(istream);
         // TODO: for some reason, document.getEncoding() can be null or nil (don't know why)
         // run `test_parse_with_unparented_html_text_context_node' few times to see this happen
         if (document instanceof HtmlDocument && !(document.getEncoding() == null || document.getEncoding().isNil())) {
@@ -1662,7 +1660,7 @@ public class XmlNode extends RubyObject {
         while(errors.getLength() > 0) {
             XmlSyntaxError error = (XmlSyntaxError)errors.shift(context);
             if (error.toString().contains("Include operation failed")) {
-                throw new RaiseException(error);
+                throw error.toThrowable();
             }
         }
         return this;

data/ext/java/nokogiri/XmlReader.java

@@ -328,7 +328,7 @@ public class XmlReader extends RubyObject {
             continueParsing = config.parse(false);
         }
         catch (XNIException e) {
-            throw new RaiseException(XmlSyntaxError.createXMLSyntaxError(context.runtime, e)); // Nokogiri::XML::SyntaxError
+            throw XmlSyntaxError.createXMLSyntaxError(context.runtime, e).toThrowable(); // Nokogiri::XML::SyntaxError
         }
         catch (IOException e) {
             throw context.runtime.newRuntimeError(e.toString());
@@ -364,7 +364,7 @@ public class XmlReader extends RubyObject {
             errors.append(error);
             setInstanceVariable("@errors", errors);
 
-            throw ex != null ? ex : new RaiseException((XmlSyntaxError) error);
+            throw ex != null ? ex : ((XmlSyntaxError) error).toThrowable();
         }
         if ( ex != null ) throw ex;
         return this;

data/ext/java/nokogiri/XmlRelaxng.java

@@ -56,6 +56,7 @@ import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.anno.JRubyClass;
 import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
 import org.w3c.dom.Document;
 import org.xml.sax.ErrorHandler;
 import org.xml.sax.SAXException;
@@ -78,11 +79,17 @@ public class XmlRelaxng extends XmlSchema {
         this.verifier = verifier;
     }
     
-    static XmlSchema createSchemaInstance(ThreadContext context, RubyClass klazz, Source source) {
+    static XmlSchema createSchemaInstance(ThreadContext context, RubyClass klazz, Source source, IRubyObject parseOptions) {
         Ruby runtime = context.getRuntime();
         XmlRelaxng xmlRelaxng = (XmlRelaxng) NokogiriService.XML_RELAXNG_ALLOCATOR.allocate(runtime, klazz);
+
+        if (parseOptions == null) {
+            parseOptions = defaultParseOptions(context.getRuntime());
+        }
+
         xmlRelaxng.setInstanceVariable("@errors", runtime.newEmptyArray());
-        
+        xmlRelaxng.setInstanceVariable("@parse_options", parseOptions);
+
         try {
             Schema schema = xmlRelaxng.getSchema(source, context);
             xmlRelaxng.setVerifier(schema.newVerifier());
@@ -128,7 +135,7 @@ public class XmlRelaxng extends XmlSchema {
             throw context.getRuntime()
                 .newRuntimeError("Could not parse document: "+ex.getMessage());
         } catch (IOException ex) {
-            throw context.getRuntime().newIOError(ex.getMessage());
+            throw context.getRuntime().newIOError(ex.getClass() + ": " + ex.getMessage());
         }
     }
     

data/ext/java/nokogiri/XmlSaxParserContext.java

@@ -94,7 +94,10 @@ public class XmlSaxParserContext extends ParserContext {
             parser = createParser();
         }
         catch (SAXException se) {
-            throw RaiseException.createNativeRaiseException(runtime, se);
+            // Unexpected failure in XML subsystem
+            RaiseException ex = runtime.newRuntimeError(se.toString());
+            ex.initCause(se);
+            throw ex;
         }
     }
 
@@ -208,7 +211,8 @@ public class XmlSaxParserContext extends ParserContext {
                 parser.setFeature(FEATURE_CONTINUE_AFTER_FATAL_ERROR, true);
             }
             catch (Exception e) {
-                throw RaiseException.createNativeRaiseException(runtime, e);
+                // Unexpected failure in XML subsystem
+                throw runtime.newRuntimeError(e.getMessage());
             }
         }
     }
@@ -261,7 +265,8 @@ public class XmlSaxParserContext extends ParserContext {
             }
         }
         catch (SAXException ex) {
-            throw RaiseException.createNativeRaiseException(runtime, ex);
+            // Unexpected failure in XML subsystem
+            throw runtime.newRuntimeError(ex.getMessage());
         }
         catch (IOException ex) {
             throw runtime.newIOErrorFromException(ex);

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);
@@ -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/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;
 
@@ -68,7 +70,6 @@ import static nokogiri.internals.NokogiriHelpers.nodeListToRubyArray;
  */
 @JRubyClass(name="Nokogiri::XML::XPathContext")
 public class XmlXpathContext extends RubyObject {
-
     static {
         final String DTMManager = "org.apache.xml.dtm.DTMManager";
         if (SafePropertyAccessor.getProperty(DTMManager) == null) {
@@ -109,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
@@ -157,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();
         }
     }