nokogiri 1.5.4.rc3-java → 1.5.5-java

data/ext/java/nokogiri/XmlNode.java

@@ -167,28 +167,33 @@ public class XmlNode extends RubyObject {
      * @param anchorNode
      */
     protected static void coalesceTextNodes(ThreadContext context,
-                                            IRubyObject anchorNode) {
+                                            IRubyObject anchorNode,
+                                            AdoptScheme scheme) {
         XmlNode xa = asXmlNode(context, anchorNode);
 
         XmlNode xp = asXmlNodeOrNull(context, xa.previous_sibling(context));
         XmlNode xn = asXmlNodeOrNull(context, xa.next_sibling(context));
-        
+
         Node p = xp == null ? null : xp.node;
         Node a = xa.node;
         Node n = xn == null ? null : xn.node;
-        
+
         Node parent = a.getParentNode();
 
-        if (p != null && p.getNodeType() == Node.TEXT_NODE) {
-            xa.setContent(p.getNodeValue() + a.getNodeValue());
-            parent.removeChild(p);
-            xp.assimilateXmlNode(context, xa);
-        }
-        if (n != null && n.getNodeType() == Node.TEXT_NODE) {
+        boolean shouldMergeP = scheme == AdoptScheme.NEXT_SIBLING || scheme == AdoptScheme.CHILD || scheme == AdoptScheme.REPLACEMENT;
+        boolean shouldMergeN = scheme == AdoptScheme.PREV_SIBLING || scheme == AdoptScheme.REPLACEMENT;
+
+        // apply the merge right to left
+        if (shouldMergeN && n != null && n.getNodeType() == Node.TEXT_NODE) {
             xa.setContent(a.getNodeValue() + n.getNodeValue());
             parent.removeChild(n);
             xn.assimilateXmlNode(context, xa);
         }
+        if (shouldMergeP && p != null && p.getNodeType() == Node.TEXT_NODE) {
+            xp.setContent(p.getNodeValue() + a.getNodeValue());
+            parent.removeChild(a);
+            xa.assimilateXmlNode(context, xp);
+        }
     }
 
     /**
@@ -318,7 +323,15 @@ public class XmlNode extends RubyObject {
             throw getRuntime().newArgumentError("node must have owner document");
         }
 
-        Element element = document.createElementNS(null, rubyStringToString(name));
+        Element element = null;
+        String node_name = rubyStringToString(name);
+        try {
+          element = document.createElementNS(null, node_name);
+        } catch (org.w3c.dom.DOMException e) {
+            // issue#683 NAMESPACE_ERR is thrown from RDF::RDFXML::Writer.new
+            // retry without namespace
+            element = document.createElement(node_name);
+        }
         setNode(context, element);
     }
 
@@ -396,7 +409,10 @@ public class XmlNode extends RubyObject {
 
     public boolean isComment() { return false; }
 
-    public boolean isElement() { return false; }
+    public boolean isElement() {
+        if (node instanceof Element) return true; // in case of subclassing
+        else return false;
+    }
 
     public boolean isProcessingInstruction() { return false; }
 
@@ -430,7 +446,33 @@ public class XmlNode extends RubyObject {
     }
 
     public void relink_namespace(ThreadContext context) {
-        //this should delegate to subclasses' implementation
+        if (node instanceof Element) {
+            Element e = (Element) node;
+            e.getOwnerDocument().renameNode(e, e.lookupNamespaceURI(e.getPrefix()), e.getNodeName());
+
+            if (e.hasAttributes()) {
+                NamedNodeMap attrs = e.getAttributes();
+
+                for (int i = 0; i < attrs.getLength(); i++) {
+                    Attr attr = (Attr) attrs.item(i);
+                    String nsUri = "";
+                    String prefix = attr.getPrefix();
+                    String nodeName = attr.getNodeName();
+                    if ("xml".equals(prefix)) {
+                        nsUri = "http://www.w3.org/XML/1998/namespace";
+                    } else if ("xmlns".equals(prefix) || nodeName.equals("xmlns")) {
+                        nsUri = "http://www.w3.org/2000/xmlns/";
+                    } else {
+                        nsUri = attr.getNamespaceURI();
+                    }
+                    e.getOwnerDocument().renameNode(attr, nsUri, nodeName);
+                }
+            }
+
+            if (e.hasChildNodes()) {
+                ((XmlNodeSet) children(context)).relink_namespace(context);
+            }
+        }
     }
 
     // Users might extend XmlNode. This method works for such a case.
@@ -519,7 +561,15 @@ public class XmlNode extends RubyObject {
                                                 IRubyObject prefix,
                                                 IRubyObject href) {
         Node namespaceOwner;
-        if (node.getNodeType() == Node.ELEMENT_NODE) namespaceOwner = node;
+        if (node.getNodeType() == Node.ELEMENT_NODE) {
+            namespaceOwner = node;
+            Element element = (Element) node;
+
+            final String uri = "http://www.w3.org/2000/xmlns/";
+            String qName =
+                prefix.isNil() ? "xmlns" : "xmlns:" + rubyStringToString(prefix);
+            element.setAttributeNS(uri, qName, rubyStringToString(href));
+        }
         else if (node.getNodeType() == Node.ATTRIBUTE_NODE) namespaceOwner = ((Attr)node).getOwnerElement();
         else namespaceOwner = node.getParentNode();
         XmlNamespace ns = XmlNamespace.createFromPrefixAndHref(namespaceOwner, prefix, href);
@@ -758,7 +808,12 @@ public class XmlNode extends RubyObject {
         String textContent;
         if (content != null) textContent = rubyStringToString(content);
         else if (this instanceof XmlDocument) {
-            textContent = ((Document)this.node).getDocumentElement().getTextContent().trim();
+            Node node = ((Document)this.node).getDocumentElement();
+            if (node == null) {
+                textContent = "";
+            } else {
+                textContent = ((Document)this.node).getDocumentElement().getTextContent().trim();
+            }
         } else {
             textContent = this.node.getTextContent();
         }
@@ -1324,7 +1379,7 @@ public class XmlNode extends RubyObject {
          }
 
         if (otherNode.getNodeType() == Node.TEXT_NODE) {
-            coalesceTextNodes(context, other);
+            coalesceTextNodes(context, other, scheme);
         }
 
         relink_namespace(context);
@@ -1374,10 +1429,7 @@ public class XmlNode extends RubyObject {
                 otherNode.getParentNode().removeChild(otherNode);
             return;
         }
-        if (thisNode.getPreviousSibling() != null &&
-            thisNode.getPreviousSibling().getNodeType() == Node.TEXT_NODE &&
-            otherNode.getNodeType() == Node.TEXT_NODE) return;
-        
+
         parent.insertBefore(otherNode, thisNode);
     }
 

data/ext/java/nokogiri/XmlNodeSet.java

@@ -93,7 +93,7 @@ public class XmlNodeSet extends RubyObject implements NodeList {
         setNodes(nodeListToRubyArray(getRuntime(), nodeList));
     }
     
-    private void initialize(Ruby ruby, IRubyObject refNode) {
+    public void initialize(Ruby ruby, IRubyObject refNode) {
         if (refNode instanceof XmlNode) {
             XmlNode n = (XmlNode)refNode;
             doc = n.document(ruby.getCurrentContext());

data/ext/java/nokogiri/XmlReader.java

@@ -40,6 +40,9 @@ import java.io.IOException;
 import java.util.ArrayDeque;
 import java.util.Stack;
 
+import nokogiri.internals.NokogiriEntityResolver;
+import nokogiri.internals.ParserContext;
+import nokogiri.internals.ParserContext.Options;
 import nokogiri.internals.ReaderNode;
 import nokogiri.internals.ReaderNode.ElementNode;
 
@@ -54,6 +57,7 @@ import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.lexer.yacc.SyntaxException;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
@@ -97,20 +101,22 @@ public class XmlReader extends RubyObject {
     public Object clone() throws CloneNotSupportedException {
         return super.clone();
     }
-    
+
     public void init(Ruby runtime) {
         nodeQueue = new ArrayDeque<ReaderNode>();
         nodeQueue.add(new ReaderNode.EmptyNode(runtime));
     }
 
-    private void parseRubyString(ThreadContext context, RubyString content){
+    private void parseRubyString(ThreadContext context, RubyString content, IRubyObject url, Options options){
         Ruby ruby = context.getRuntime();
         try {
             this.setState(XML_TEXTREADER_MODE_READING);
-            XMLReader reader = this.createReader(ruby);
+            XMLReader reader = this.createReader(ruby, options);
             ByteList byteList = content.getByteList();
             ByteArrayInputStream bais = new ByteArrayInputStream(byteList.unsafeBytes(), byteList.begin(), byteList.length());
-            reader.parse(new InputSource(bais));
+            InputSource inputSource = new InputSource(bais);
+            ParserContext.setUrl(context, inputSource, url);
+            reader.parse(inputSource);
             this.setState(XML_TEXTREADER_MODE_CLOSED);
         } catch (SAXParseException spe) {
             this.setState(XML_TEXTREADER_MODE_ERROR);
@@ -188,16 +194,26 @@ public class XmlReader extends RubyObject {
         reader.init(runtime);
         reader.setInstanceVariable("@source", args[0]);
         reader.setInstanceVariable("@errors", runtime.newArray());
+        IRubyObject url = context.nil;
+        if (args.length > 1) url = args[1];
         if (args.length > 2) reader.setInstanceVariable("@encoding", args[2]);
 
         RubyString content = RuntimeHelpers.invoke(context, args[0], "read").convertToString();
-        reader.parseRubyString(context, content);
+
+        Options options;
+        if (args.length > 3) {
+          options = new ParserContext.Options((Long)args[3].toJava(Long.class));
+        } else {
+          // use the default options RECOVER | NONET
+          options = new ParserContext.Options(2048 | 1);
+        }
+        reader.parseRubyString(context, content, url, options);
         return reader;
     }
 
     @JRubyMethod(meta = true, rest = true)
     public static IRubyObject from_memory(ThreadContext context, IRubyObject cls, IRubyObject args[]) {
-        // args[0]: string, args[1]: url, args[2]: encoding, args[3]: options 
+        // args[0]: string, args[1]: url, args[2]: encoding, args[3]: options
         Ruby runtime = context.getRuntime();
         // Not nil allowed!
         if(args[0].isNil()) throw runtime.newArgumentError("string cannot be nil");
@@ -206,9 +222,18 @@ public class XmlReader extends RubyObject {
         reader.init(runtime);
         reader.setInstanceVariable("@source", args[0]);
         reader.setInstanceVariable("@errors", runtime.newArray());
+        IRubyObject url = context.nil;
+        if (args.length > 1) url = args[1];
         if (args.length > 2) reader.setInstanceVariable("@encoding", args[2]);
 
-        reader.parseRubyString(context, args[0].convertToString());
+        Options options;
+        if (args.length > 3) {
+          options = new ParserContext.Options((Long)args[3].toJava(Long.class));
+        } else {
+          // use the default options RECOVER | NONET
+          options = new ParserContext.Options(2048 | 1);
+        }
+        reader.parseRubyString(context, args[0].convertToString(), url, options);
         return reader;
     }
 
@@ -227,13 +252,13 @@ public class XmlReader extends RubyObject {
         if (current.depth < 0) return null;
         if (!current.hasChildren) return null;
         StringBuffer sb = new StringBuffer();
-        int currentDepth = (Integer)current.depth;
+        int currentDepth = current.depth;
         int inner = 0;
         for (ReaderNode node : nodeQueue) {
-            if (((Integer)node.depth) == currentDepth && node.getName().equals(current.getName())) {
+            if (node.depth == currentDepth && node.getName().equals(current.getName())) {
                 inner++;
             }
-            if (((Integer)node.depth) > currentDepth) {
+            if (node.depth > currentDepth) {
                 sb.append(node.getString());
             }
             if (inner == 2) break;
@@ -249,11 +274,11 @@ public class XmlReader extends RubyObject {
     private String getOuterXml(ArrayDeque<ReaderNode> nodeQueue, ReaderNode current) {
         if (current.depth < 0) return null;
         StringBuffer sb = new StringBuffer();
-        int initialDepth = (Integer)current.depth;
+        int initialDepth = current.depth;
         int inner = 0;
         for (ReaderNode node : nodeQueue) {
-            if (((Integer)node.depth) >= initialDepth) {
-                if (((Integer)node.depth) == initialDepth && node.getName().equals(current.getName())) {
+            if (node.depth >= initialDepth) {
+                if (node.depth == initialDepth && node.getName().equals(current.getName())) {
                     inner++;
                 }
 
@@ -331,7 +356,7 @@ public class XmlReader extends RubyObject {
         return nodeQueue.peek().getXmlVersion();
     }
 
-    protected XMLReader createReader(final Ruby ruby) {
+    protected XMLReader createReader(final Ruby ruby, Options options) {
         DefaultHandler2 handler = new DefaultHandler2() {
 
             Stack<String> langStack;
@@ -401,6 +426,13 @@ public class XmlReader extends RubyObject {
                 elementStack.push((ReaderNode.ElementNode)readerNode);
             }
 
+            @Override
+            public void skippedEntity(String name) {
+              XmlSyntaxError error = XmlSyntaxError.createNokogiriXmlSyntaxError(ruby);
+              error.setException(new Exception("Unknown entity " + name));
+              throw new RaiseException(error);
+            }
+
             @Override
             public void warning(SAXParseException ex) throws SAXParseException {
                 nodeQueue.add(new ReaderNode.ExceptionNode(ruby, ex));
@@ -412,9 +444,10 @@ public class XmlReader extends RubyObject {
             reader.setContentHandler(handler);
             reader.setDTDHandler(handler);
             reader.setErrorHandler(handler);
+            reader.setEntityResolver(new NokogiriEntityResolver(ruby, null, options));
             reader.setFeature("http://xml.org/sax/features/xmlns-uris", true);
             reader.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
-            reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
+            reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", options.dtdLoad || options.dtdValid);
             return reader;
         } catch (SAXException saxe) {
             throw RaiseException.createNativeRaiseException(ruby, saxe);

data/ext/java/nokogiri/XmlSyntaxError.java

@@ -75,23 +75,27 @@ public class XmlSyntaxError extends RubyException {
     }
 
     public static XmlSyntaxError createWarning(Ruby runtime, SAXParseException e) {
-        XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
+        XmlSyntaxError xmlSyntaxError = createNokogiriXmlSyntaxError(runtime);
         xmlSyntaxError.setException(runtime, e, 1);
         return xmlSyntaxError;
     }
 
     public static XmlSyntaxError createError(Ruby runtime, SAXParseException e) {
-        XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
+        XmlSyntaxError xmlSyntaxError = createNokogiriXmlSyntaxError(runtime);
         xmlSyntaxError.setException(runtime, e, 2);
         return xmlSyntaxError;
     }
 
     public static XmlSyntaxError createFatalError(Ruby runtime, SAXParseException e) {
-        XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
+        XmlSyntaxError xmlSyntaxError = createNokogiriXmlSyntaxError(runtime);
         xmlSyntaxError.setException(runtime, e, 3);
         return xmlSyntaxError;
     }
-    
+
+    public static XmlSyntaxError createNokogiriXmlSyntaxError(Ruby runtime) {
+      return (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
+    }
+
     public void setException(Exception exception) {
         this.exception = exception;
     }
@@ -112,6 +116,7 @@ public class XmlSyntaxError extends RubyException {
     //@Override
     //"to_s" method was branched in 1.8 and 1.9 since JRuby 1.6.6
     // to support older version of JRuby, the annotation is commented out
+    @Override
     @JRubyMethod(name = "to_s", compat = CompatVersion.RUBY1_8)
     public IRubyObject to_s(ThreadContext context) {
         if (exception != null && exception.getMessage() != null)

data/ext/java/nokogiri/XmlXpathContext.java

@@ -94,16 +94,16 @@ public class XmlXpathContext extends RubyObject {
     }
 
     @JRubyMethod(name = "new", meta = true)
-    public static IRubyObject rbNew(ThreadContext context, IRubyObject klazz, IRubyObject node) {
+    public static IRubyObject rbNew(ThreadContext thread_context, IRubyObject klazz, IRubyObject node) {
         XmlNode xmlNode = (XmlNode)node;
-        XmlXpathContext xmlXpathContext = (XmlXpathContext) NokogiriService.XML_XPATHCONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)klazz);
+        XmlXpathContext xmlXpathContext = (XmlXpathContext) NokogiriService.XML_XPATHCONTEXT_ALLOCATOR.allocate(thread_context.getRuntime(), (RubyClass)klazz);
         xmlXpathContext.xpath = XPathFactory.newInstance().newXPath();
         xmlXpathContext.setNode(xmlNode);
         return xmlXpathContext;
     }
 
     @JRubyMethod
-    public IRubyObject evaluate(ThreadContext context, IRubyObject expr, IRubyObject handler) {
+    public IRubyObject evaluate(ThreadContext thread_context, IRubyObject expr, IRubyObject handler) {
         String src = (String) expr.toJava(String.class);
         try {
             if(!handler.isNil()) {
@@ -116,7 +116,7 @@ public class XmlXpathContext extends RubyObject {
                 xpath.setXPathFunctionResolver(NokogiriXPathFunctionResolver.create(handler));
             }
             XPathExpression xpathExpression = xpath.compile(src);
-            return node_set(context, xpathExpression);
+            return node_set(thread_context, xpathExpression);
         } catch (XPathExpressionException xpee) {
             xpee = new XPathExpressionException(src);
             RubyException e = XmlSyntaxError.createXPathSyntaxError(getRuntime(), xpee);
@@ -124,10 +124,10 @@ public class XmlXpathContext extends RubyObject {
         }
     }
 
-    protected IRubyObject node_set(ThreadContext rbctx, XPathExpression xpathExpression) {
+    protected IRubyObject node_set(ThreadContext thread_context, XPathExpression xpathExpression) {
         XmlNodeSet result = null;
         try {  
-            result = tryGetNodeSet(xpathExpression);
+            result = tryGetNodeSet(thread_context, xpathExpression);
             return result;
         } catch (XPathExpressionException xpee) {
             try {
@@ -139,10 +139,11 @@ public class XmlXpathContext extends RubyObject {
         }
     }
     
-    private XmlNodeSet tryGetNodeSet(XPathExpression xpathExpression) throws XPathExpressionException {
+    private XmlNodeSet tryGetNodeSet(ThreadContext thread_context, XPathExpression xpathExpression) throws XPathExpressionException {
         NodeList nodeList = (NodeList)xpathExpression.evaluate(context.node, XPathConstants.NODESET);
         XmlNodeSet xmlNodeSet = (XmlNodeSet) NokogiriService.XML_NODESET_ALLOCATOR.allocate(getRuntime(), getNokogiriClass(getRuntime(), "Nokogiri::XML::NodeSet"));
         xmlNodeSet.setNodeList(nodeList);
+        xmlNodeSet.initialize(thread_context.getRuntime(), context);
         return xmlNodeSet;    
     }
 

data/ext/java/nokogiri/internals/NokogiriHandler.java

@@ -92,7 +92,13 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
         String objectName = object.getMetaClass().getName();
         if (htmlParserName.equals(objectName)) needEmptyAttrCheck = true;
     }
-    
+
+    @Override
+    public void skippedEntity(String skippedEntity) {
+        call("error", ruby.newString("Entity '" + skippedEntity + "' not defined\n"));
+    }
+
+    @Override
     public void setDocumentLocator(Locator locator) {
         this.locator = locator;
     }

data/ext/java/nokogiri/internals/NokogiriNamespaceCache.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2011:
+ * Copyright (c) 2008 - 2012:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -32,7 +32,6 @@
 
 package nokogiri.internals;
 
-import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import static nokogiri.internals.NokogiriHelpers.isNamespace;
 
 import java.util.ArrayList;
@@ -40,11 +39,8 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
-import nokogiri.NokogiriService;
-import nokogiri.XmlDocument;
 import nokogiri.XmlNamespace;
 
-import org.jruby.Ruby;
 import org.w3c.dom.Attr;
 import org.w3c.dom.NamedNodeMap;
 import org.w3c.dom.Node;