nokogiri 1.5.0.beta.4-java → 1.5.0-java

data/ext/java/nokogiri/internals/HtmlDomParserContext.java

@@ -57,6 +57,7 @@ import org.w3c.dom.Document;
  * Parser for HtmlDocument. This class actually parses HtmlDocument using NekoHtml.
  * 
  * @author sergio
+ * @author Patrick Mahoney <pat@polycrystal.org>
  * @author Yoko Harada <yokolet@gmail.com>
  */
 public class HtmlDomParserContext extends XmlDomParserContext {
@@ -92,9 +93,9 @@ public class HtmlDomParserContext extends XmlDomParserContext {
         setProperty("http://cyberneko.org/html/properties/default-encoding", java_encoding);
         setProperty("http://cyberneko.org/html/properties/names/elems", "lower");
         setProperty("http://cyberneko.org/html/properties/names/attrs", "lower");
+        setProperty("http://cyberneko.org/html/properties/filters", filters);
         setFeature("http://cyberneko.org/html/features/report-errors", true);
         setFeature("http://xml.org/sax/features/namespaces", false);
-        setProperty("http://cyberneko.org/html/properties/filters", filters);
         setFeature("http://cyberneko.org/html/features/insert-doctype", true);
     }
 
@@ -125,9 +126,6 @@ public class HtmlDomParserContext extends XmlDomParserContext {
 
     /**
      * Filter to strip out attributes that pertain to XML namespaces.
-     *
-     * @author sergio
-     * @author Patrick Mahoney <pat@polycrystal.org>
      */
     public static class RemoveNSAttrsFilter extends DefaultFilter {
         @Override

data/ext/java/nokogiri/internals/NokogiriHelpers.java

@@ -32,18 +32,24 @@
 
 package nokogiri.internals;
 
+import java.io.File;
 import java.io.UnsupportedEncodingException;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import nokogiri.NokogiriService;
 import nokogiri.XmlAttr;
 import nokogiri.XmlCdata;
 import nokogiri.XmlComment;
 import nokogiri.XmlDocument;
+import nokogiri.XmlDtd;
 import nokogiri.XmlElement;
+import nokogiri.XmlEntityReference;
 import nokogiri.XmlNamespace;
 import nokogiri.XmlNode;
+import nokogiri.XmlProcessingInstruction;
 import nokogiri.XmlText;
 
 import org.jruby.Ruby;
@@ -87,9 +93,8 @@ public class NokogiriHelpers {
             prefix = prefix != null ? prefix : "";
             String href = ((Attr)node).getValue();
             XmlNamespace xmlNamespace = xmlDocument.getNamespaceCache().get(prefix, href);
-            if (xmlNamespace == null) {
-                return xmlDocument.getNamespaceCache().put(ruby, prefix, ((Attr)node).getValue(), node, xmlDocument);
-            }
+            if (xmlNamespace != null) return xmlNamespace;
+            else return XmlNamespace.createFromAttr(ruby, (Attr)node);
         }
         XmlNode xmlNode = getCachedNode(node);
         if(xmlNode == null) {
@@ -126,6 +131,14 @@ public class NokogiriHelpers {
                 return xmlComment;
             case Node.ENTITY_NODE:
                 return new XmlNode(runtime, getNokogiriClass(runtime, "Nokogiri::XML::EntityDecl"), node);
+            case Node.ENTITY_REFERENCE_NODE:
+                XmlEntityReference xmlEntityRef = (XmlEntityReference) NokogiriService.XML_ENTITY_REFERENCE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::EntityReference"));
+                xmlEntityRef.setNode(runtime.getCurrentContext(), node);
+                return xmlEntityRef;
+            case Node.PROCESSING_INSTRUCTION_NODE:
+                XmlProcessingInstruction xmlProcessingInstruction = (XmlProcessingInstruction) NokogiriService.XML_PROCESSING_INSTRUCTION_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::ProcessingInstruction"));
+                xmlProcessingInstruction.setNode(runtime.getCurrentContext(), node);
+                return xmlProcessingInstruction;
             case Node.CDATA_SECTION_NODE:
                 XmlCdata xmlCdata = (XmlCdata) NokogiriService.XML_CDATA_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::CDATA"));
                 xmlCdata.setNode(runtime.getCurrentContext(), node);
@@ -134,6 +147,10 @@ public class NokogiriHelpers {
                 XmlDocument xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Document"));
                 xmlDocument.setNode(runtime.getCurrentContext(), node);
                 return xmlDocument;
+            case Node.DOCUMENT_TYPE_NODE:
+                XmlDtd xmlDtd = (XmlDtd) NokogiriService.XML_DTD_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::DTD"));
+                xmlDtd.setNode(runtime, node);
+                return xmlDtd;
             default:
                 XmlNode xmlNode = (XmlNode) NokogiriService.XML_NODE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Node"));
                 xmlNode.setNode(runtime.getCurrentContext(), node);
@@ -481,28 +498,44 @@ public class NokogiriHelpers {
                 (b.equals(a)));
     }
 
+    private static Pattern encoded_pattern = Pattern.compile("&|>|<|
");
+    private static Pattern decoded_pattern = Pattern.compile("&|>|<|\r");
+    private static String[] encoded = {"&amp;", "&gt;", "&lt;", "&#13;"};
+    private static String[] decoded = {"&", ">", "<", "\r"};
+    
+    private static String convert(Pattern ptn, String input, String[] oldChars, String[] newChars)  {
+        Matcher matcher = ptn.matcher(input);
+        boolean result = matcher.find();
+        StringBuffer sb = new StringBuffer();
+        while(result) {
+            String matched = matcher.group();
+            String replacement = "";
+            for (int i=0; i<oldChars.length; i++) {
+                if (matched.contains(oldChars[i])) {
+                    replacement = matched.replace(oldChars[i], newChars[i]);
+                    break;
+                }
+            }
+            matcher.appendReplacement(sb, replacement);
+            result = matcher.find();
+        }
+        matcher.appendTail(sb);
+        return sb.toString();
+    }
+    
     public static String encodeJavaString(String s) {
-
-        // From entities.c
-        s = s.replaceAll("&", "&amp;");
-        s = s.replaceAll("<", "&lt;");
-        s = s.replaceAll(">", "&gt;");
-//        s = s.replaceAll("\"", "&quot;");
-        return s.replaceAll("\r", "&#13;");
+        return convert(decoded_pattern, s, decoded, encoded);
     }
     
     public static String decodeJavaString(String s) {
-        s = s.replaceAll("&amp;", "&");
-        s = s.replaceAll("&lt;", "<");
-        s = s.replaceAll("&gt;", ">");
-        return s.replaceAll("&#13;", "\r");
+        return convert(encoded_pattern, s, encoded, decoded);
     }
-    
-    public static boolean isXmlEscaped(String s) {
-        if (s == null) return true;
-        if (s.contains("<") || s.contains(">") || s.contains("\r")) return false;
-        if (s.contains("&") && !s.contains("&amp;")) return false;
-        return true;
+
+    private static Pattern not_escaped_pattern = Pattern.compile("\\&(?!(amp;|gt;|lt;))|<|>");
+    public static boolean isNotXmlEscaped(String s) {
+        if (s == null) return false;
+        Matcher matcher = not_escaped_pattern.matcher(s);
+        return (matcher.find());
     }
 
     public static String getNodeName(Node node) {
@@ -579,4 +612,28 @@ public class NokogiriHelpers {
         if (name == null) name = "UTF-8";
         return name;
     }
+    
+    public static String adjustSystemIdIfNecessary(String currentDir, String scriptFileName, String baseURI, String systemId) {
+        if (systemId == null) return systemId;
+        File file = new File(systemId);
+        if (file.isAbsolute()) return systemId;
+        String path = resolveSystemId(baseURI, systemId);
+        if (path != null) return path;
+        path = resolveSystemId(currentDir, systemId);
+        if (path != null) return path;
+        return resolveSystemId(scriptFileName, systemId);
+    }
+    
+    private static String resolveSystemId(String baseName, String systemId) {
+        if (baseName == null || baseName.length() < 1) return null;
+        String parentName = null;
+        baseName = baseName.replaceAll("%20", " ");
+        File base = new File(baseName);
+        if (base.isDirectory()) parentName = baseName;
+        else parentName = base.getParent();
+        if (parentName.toLowerCase().startsWith("file:")) parentName = parentName.substring("file:".length());
+        File dtdFile = new File(parentName + "/" + systemId);
+        if (dtdFile.exists()) return dtdFile.getPath();
+        return null;
+    }
 }

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

@@ -103,32 +103,28 @@ public class NokogiriNamespaceCache {
         List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
         for (int i=0; i < keys.size(); i++) {
             CacheEntry entry = cache.get(i);
-            if (entry.node == node) {
+            if (entry.ownerNode == node) {
                 namespaces.add(entry.namespace);
             }
         }
         return namespaces;
     }
-    
-    public XmlNamespace put(Ruby ruby, String prefix, String href, Node node, XmlDocument document) {
+
+    public void put(XmlNamespace namespace, Node ownerNode) {
         // prefix should not be null.
         // In case of a default namespace, an empty string should be given to prefix argument.
-        if (prefix == null || href == null) return null;
-        Long hash = hashCode(prefix, href);
+        String prefixString = namespace.getPrefix();
+        String hrefString = namespace.getHref();
+        Long hash = hashCode(prefixString, hrefString);
         Integer index;
         if ((index = keys.indexOf(hash)) != -1) {
-            return cache.get(index).namespace;
+            return;
         } else {
             keys.add(hash);
             index = keys.size() - 1;
-            String actualPrefix = (prefix.equals("")) ? null : prefix;
-            XmlNamespace namespace = (XmlNamespace) NokogiriService.XML_NAMESPACE_ALLOCATOR.allocate(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Namespace"));
-            namespace.setDefinition(ruby, actualPrefix, href);
-            namespace.setDocument(document);
-            CacheEntry entry = new CacheEntry(namespace, node);
+            CacheEntry entry = new CacheEntry(namespace, ownerNode);
             cache.put(index, entry);
-            if ("".equals(prefix)) defaultNamespace = namespace;
-            return namespace;
+            if ("".equals(prefixString)) defaultNamespace = namespace;
         }
     }
 
@@ -146,7 +142,7 @@ public class NokogiriNamespaceCache {
         // removes namespace declarations from node
         for (int i=0; i < keys.size(); i++) {
             CacheEntry entry = cache.get(i);
-            NamedNodeMap attributes = entry.node.getAttributes();
+            NamedNodeMap attributes = entry.ownerNode.getAttributes();
             for (int j=0; j<attributes.getLength(); j++) {
                 String name = ((Attr)attributes.item(j)).getName();
                 if (isNamespace(name)) {
@@ -161,11 +157,11 @@ public class NokogiriNamespaceCache {
     
     private class CacheEntry {
         private XmlNamespace namespace;
-        private Node node;
+        private Node ownerNode;
         
-        CacheEntry(XmlNamespace namespace, Node node) {
+        CacheEntry(XmlNamespace namespace, Node ownerNode) {
             this.namespace = namespace;
-            this.node = node;
+            this.ownerNode = ownerNode;
         }
     }
 }

data/ext/java/nokogiri/internals/NokogiriNamespaceContext.java

@@ -50,13 +50,25 @@ import javax.xml.namespace.NamespaceContext;
  */
 
 public class NokogiriNamespaceContext implements NamespaceContext {
+    private static NokogiriNamespaceContext namespaceContext;
 	public static final String NOKOGIRI_PREFIX = "nokogiri";
     public static final String NOKOGIRI_URI = "http://www.nokogiri.org/default_ns/ruby/extensions_functions";
     public static final String NOKOGIRI_TEMPORARY_ROOT_TAG = "nokogiri-temporary-root-tag";
     
     private Hashtable<String,String> register;
 
-    public NokogiriNamespaceContext() {
+    public static NokogiriNamespaceContext create() {
+        if (namespaceContext == null) namespaceContext = new NokogiriNamespaceContext();
+        try {
+            NokogiriNamespaceContext clone = (NokogiriNamespaceContext) namespaceContext.clone();
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            NokogiriNamespaceContext freshContext = new NokogiriNamespaceContext();
+            return freshContext;
+        }
+    }
+    
+    private NokogiriNamespaceContext() {
         this.register = new Hashtable<String,String>();
         register.put(NOKOGIRI_PREFIX, NOKOGIRI_URI);
         register.put("xml", "http://www.w3.org/XML/1998/namespace");

data/ext/java/nokogiri/internals/NokogiriXPathFunction.java

@@ -61,16 +61,32 @@ import org.w3c.dom.NodeList;
  * @author Yoko Harada <yokolet@gmail.com>
  */
 public class NokogiriXPathFunction implements XPathFunction {
-    private final IRubyObject handler;
-    private final String name;
-    private final int arity;
+    private static NokogiriXPathFunction xpathFunction;
+    private IRubyObject handler;
+    private String name;
+    private int arity;
+    
+    public static NokogiriXPathFunction create(IRubyObject handler, String name, int arity) {
+        if (xpathFunction == null) xpathFunction = new NokogiriXPathFunction();
+        try {
+            NokogiriXPathFunction clone = (NokogiriXPathFunction) xpathFunction.clone();
+            clone.init(handler, name, arity);
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            NokogiriXPathFunction freshXpathFunction = new NokogiriXPathFunction();
+            freshXpathFunction.init(handler, name, arity);
+            return freshXpathFunction;
+        }
+    }
 
-    public NokogiriXPathFunction(IRubyObject handler, String name, int arity) {
+    private void init(IRubyObject handler, String name, int arity) {
         this.handler = handler;
         this.name = name;
         this.arity = arity;
     }
 
+    private NokogiriXPathFunction() {}
+
     public Object evaluate(List args) throws XPathFunctionException {
         if(args.size() != this.arity) {
             throw new XPathFunctionException("arity does not match");
@@ -114,11 +130,10 @@ public class NokogiriXPathFunction implements XPathFunction {
         } else if (o instanceof RubyBoolean) {
             return o.toJava(Boolean.class);
         } else if (o instanceof XmlNodeSet) {
-            return ((XmlNodeSet) o).toNodeList(runtime);
+            return (NodeList)o;
         } else if (o instanceof RubyArray) {
-            XmlNodeSet xmlNodeSet = (XmlNodeSet)NokogiriService.XML_NODESET_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::NodeSet"));
-            xmlNodeSet.setInitialNodes((RubyArray)o);
-            return xmlNodeSet.toNodeList(runtime);
+            XmlNodeSet xmlNodeSet = XmlNodeSet.newXmlNodeSet(runtime.getCurrentContext(), (RubyArray)o);
+            return (NodeList)xmlNodeSet;
         } else /*if (o instanceof XmlNode)*/ {
             return ((XmlNode) o).getNode();
         }

data/ext/java/nokogiri/internals/NokogiriXPathFunctionResolver.java

@@ -35,22 +35,39 @@ package nokogiri.internals;
 import javax.xml.namespace.QName;
 import javax.xml.xpath.XPathFunction;
 import javax.xml.xpath.XPathFunctionResolver;
+
 import org.jruby.runtime.builtin.IRubyObject;
 
 /**
  * Xpath function resolver class, which is used in XmlXpathContext. 
  * 
  * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
  */
 public class NokogiriXPathFunctionResolver implements XPathFunctionResolver {
-
+    private static NokogiriXPathFunctionResolver resolver;
     private IRubyObject handler;
     
-    public NokogiriXPathFunctionResolver(IRubyObject handler) {
+    public static NokogiriXPathFunctionResolver create(IRubyObject handler) {
+        if (resolver == null) resolver = new NokogiriXPathFunctionResolver();
+        try {
+            NokogiriXPathFunctionResolver clone = (NokogiriXPathFunctionResolver) resolver.clone();
+            clone.setHandler(handler);
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            NokogiriXPathFunctionResolver freshResolver = new NokogiriXPathFunctionResolver();
+            freshResolver.setHandler(handler);
+            return freshResolver;
+        }
+    }
+    
+    private NokogiriXPathFunctionResolver() {}
+    
+    private void setHandler(IRubyObject handler) {
         this.handler = handler;
     }
 
     public XPathFunction resolveFunction(QName name, int arity) {
-        return new NokogiriXPathFunction(this.handler, name.getLocalPart(), arity);
+        return NokogiriXPathFunction.create(handler, name.getLocalPart(), arity);
     }
 }

data/ext/java/nokogiri/internals/NokogiriXPathVariableResolver.java

@@ -0,0 +1,67 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * 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.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package nokogiri.internals;
+
+import java.util.HashMap;
+import javax.xml.namespace.QName;
+import javax.xml.xpath.XPathVariableResolver;
+
+/**
+ * XPath variable support
+ * 
+ * @author Ken Bloom <kbloom@gmail.com>
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriXPathVariableResolver implements XPathVariableResolver {
+    private static NokogiriXPathVariableResolver resolver;
+    private HashMap<QName,String> variables = new HashMap<QName,String>();
+
+    public static NokogiriXPathVariableResolver create() {
+        if (resolver == null) resolver = new NokogiriXPathVariableResolver();
+        try {
+            NokogiriXPathVariableResolver clone = (NokogiriXPathVariableResolver) resolver.clone();
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            NokogiriXPathVariableResolver freshResolver = new NokogiriXPathVariableResolver();
+            return freshResolver;
+        }
+    }
+    
+    private NokogiriXPathVariableResolver() {}
+    
+    public Object resolveVariable(QName variableName){
+        return variables.get(variableName);
+    }
+    public void registerVariable(String name,String value){
+        variables.put(new QName(name),value);
+    }
+}

data/ext/java/nokogiri/internals/NokogiriXsltErrorListener.java

@@ -0,0 +1,86 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * 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.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import javax.xml.transform.ErrorListener;
+import javax.xml.transform.TransformerException;
+
+/**
+ * Error Listener for XSLT transformer
+ * 
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriXsltErrorListener implements ErrorListener {
+    public enum ErrorType {
+        WARNING,
+        ERROR,
+        FATAL
+    }
+
+    private ErrorType type;
+    private String errorMessage;
+    private Exception exception;
+
+    public void warning(TransformerException ex) throws TransformerException {
+        type = ErrorType.WARNING;
+        setError(ex);
+    }
+
+    public void error(TransformerException ex) throws TransformerException {
+       type = ErrorType.ERROR;
+       setError(ex);
+    }
+
+    public void fatalError(TransformerException ex) throws TransformerException {
+        type = ErrorType.FATAL;
+        setError(ex);
+    }
+    
+    private void setError(TransformerException ex) {
+        errorMessage = ex.getMessage();
+        exception = ex;
+    }
+    
+    public String getErrorMessage() {
+        return errorMessage;
+    }
+    
+    public ErrorType getErrorType() {
+        return type;
+    }
+    
+    public Exception getException() {
+        return exception;
+    }
+
+}