nokogiri 1.5.0.beta.1-java → 1.5.0.beta.2-java

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

@@ -0,0 +1,136 @@
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import nokogiri.XmlDocument;
+import nokogiri.XmlNamespace;
+
+import org.jruby.Ruby;
+import org.jruby.runtime.ThreadContext;
+import org.w3c.dom.Attr;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+/**
+ *
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNamespaceCache {
+
+    private List<Long> keys;  // order matters.
+    private Map<Integer, CacheEntry> cache;  // pair of the index of a given key and entry
+    private XmlNamespace defaultNamespace = null;
+
+    public NokogiriNamespaceCache() {
+        keys = new ArrayList<Long>();
+        cache = new HashMap<Integer, CacheEntry>();
+    }
+    
+    private Long hashCode(String prefix, String href) {
+        long prefix_hash = prefix.hashCode();
+        long href_hash = href.hashCode();
+        return prefix_hash << 31 | href_hash;
+    }
+
+    public XmlNamespace get(String prefix, String href) {
+        // 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);
+        Integer index = keys.indexOf(hash);
+        if (index != -1) return cache.get(index).namespace;
+        return null;
+    }
+    
+    public XmlNamespace getDefault() {
+        return defaultNamespace;
+    }
+    
+    public XmlNamespace get(String prefix) {
+        if (prefix == null) return defaultNamespace;
+        long h = prefix.hashCode();
+        Long hash = h << 31;
+        Long mask = 0xFF00L;
+        for (int i=0; i < keys.size(); i++) {
+            if ((keys.get(i) & mask) == hash) {
+                return cache.get(i).namespace;
+            }
+        }
+        return null;
+    }
+    
+    public List<XmlNamespace> get(Node node) {
+        List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
+        for (int i=0; i < keys.size(); i++) {
+            CacheEntry entry = cache.get(i);
+            if (entry.node == node) {
+                namespaces.add(entry.namespace);
+            }
+        }
+        return namespaces;
+    }
+    
+    public XmlNamespace put(Ruby ruby, String prefix, String href, Node node, XmlDocument document) {
+        // 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);
+        Integer index;
+        if ((index = keys.indexOf(hash)) != -1) {
+            return cache.get(index).namespace;
+        } else {
+            keys.add(hash);
+            index = keys.size() - 1;
+            String actualPrefix = (prefix.equals("")) ? null : prefix;
+            XmlNamespace namespace = new XmlNamespace(ruby, actualPrefix, href);
+            namespace.setDocument(document);
+            CacheEntry entry = new CacheEntry(namespace, node);
+            cache.put(index, entry);
+            if ("".equals(prefix)) defaultNamespace = namespace;
+            return namespace;
+        }
+    }
+
+    public void remove(String prefix, String href) {
+        if (prefix == null || href == null) return;
+        Long hash = hashCode(prefix, href);
+        Integer index = keys.indexOf(hash);
+        if (index != -1) {
+            cache.remove(index);
+        }
+        keys.remove(index);
+    }
+    
+    public void clear() {
+        // removes namespace declarations from node
+        for (int i=0; i < keys.size(); i++) {
+            CacheEntry entry = cache.get(i);
+            NamedNodeMap attributes = entry.node.getAttributes();
+            for (int j=0; j<attributes.getLength(); j++) {
+                String name = ((Attr)attributes.item(j)).getName();
+                if (isNamespace(name)) {
+                    attributes.removeNamedItem(name);
+                }
+            }
+        }
+        keys.clear();
+        cache.clear();
+        defaultNamespace = null;
+    }
+    
+    private class CacheEntry {
+        private XmlNamespace namespace;
+        private Node node;
+        
+        CacheEntry(XmlNamespace namespace, Node node) {
+            this.namespace = namespace;
+            this.node = node;
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+package nokogiri.internals;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import javax.xml.XMLConstants;
+import javax.xml.namespace.NamespaceContext;
+
+public class NokogiriNamespaceContext implements 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() {
+        this.register = new Hashtable<String,String>();
+        register.put(NOKOGIRI_PREFIX, NOKOGIRI_URI);
+        register.put("xml", "http://www.w3.org/XML/1998/namespace");
+        register.put("xhtml", "http://www.w3.org/1999/xhtml");
+    }
+
+    public String getNamespaceURI(String prefix) {
+    	if (prefix == null) {
+            throw new IllegalArgumentException();
+        }
+        String uri = this.register.get(prefix);
+        if (uri != null) {
+            return uri;
+        }
+
+        if (prefix.equals(XMLConstants.XMLNS_ATTRIBUTE)) {
+            uri = this.register.get(XMLConstants.XMLNS_ATTRIBUTE);
+            return (uri == null) ? XMLConstants.XMLNS_ATTRIBUTE_NS_URI : uri;
+        }
+
+        return XMLConstants.NULL_NS_URI;
+    }
+
+    public String getPrefix(String uri) {
+    	if (uri == null) {
+            throw new IllegalArgumentException("uri is null");
+        } else {
+            Set<Entry<String, String>> entries = register.entrySet();
+            for (Entry<String, String> entry : entries) {
+                if (uri.equals(entry.getValue())) {
+                    return entry.getKey();
+                }
+            }
+        }
+        return null;
+    }
+
+    public Iterator<String> getPrefixes(String uri) {
+        if (register == null) return null;
+        Set<Entry<String, String>> entries = register.entrySet();
+        List<String> list = new ArrayList<String>();
+        for (Entry<String, String> entry : entries) {
+            if (uri.equals(entry.getValue())) {
+                list.add(entry.getKey());
+            }
+        }
+        return list.iterator();
+    }
+    
+    public Set<String> getAllPrefixes() {
+        if (register == null) return null;
+        return register.keySet();
+    }
+
+    public void registerNamespace(String prefix, String uri) {
+        if("xmlns".equals(prefix)) prefix = "";
+        this.register.put(prefix, uri);
+    }
+}

data/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler.java

@@ -0,0 +1,37 @@
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ *
+ * @author sergio
+ */
+public class NokogiriNonStrictErrorHandler extends NokogiriErrorHandler{
+
+    public void warning(SAXParseException ex) throws SAXException {
+        this.errors.add(ex);
+    }
+
+    public void error(SAXParseException ex) throws SAXException {
+        this.errors.add(ex);
+    }
+
+    public void fatalError(SAXParseException ex) throws SAXException {
+        this.errors.add(ex);
+    }
+
+    public void error(String domain, String key, XMLParseException e) {
+        addError(e);
+    }
+
+    public void fatalError(String domain, String key, XMLParseException e) {
+        addError(e);
+    }
+
+    public void warning(String domain, String key, XMLParseException e) {
+        addError(e);
+    }
+
+}

data/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler4NekoHtml.java

@@ -0,0 +1,54 @@
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Non-strict error handler for NekoHtml.
+ * 
+ * NekoHtml adds too many warnings, which makes later processing hard. For example,
+ * Nokogiri wants to know whether number of errors have been increased or not to judge 
+ * availability of creating NodeSet from a given fragment. When the fragment nodes 
+ * are to be created from HTML document, which means NekoHtml is used, always errors
+ * increases. As a result, even though the given fragment is correct HTML, NodeSet
+ * base on the given fragment won't be created. This is why warnings are eliminated.
+ * 
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler {
+    private boolean noerror;
+    
+    public NokogiriNonStrictErrorHandler4NekoHtml() {
+        this.noerror = false;
+    }
+    
+    public NokogiriNonStrictErrorHandler4NekoHtml(boolean noerror) {
+        this.noerror = noerror;
+    }
+
+    public void warning(SAXParseException ex) throws SAXException {
+        //noop. NekoHtml adds too many warnings.
+    }
+
+    public void error(SAXParseException ex) throws SAXException {
+        if (!noerror) this.errors.add(ex);
+    }
+
+    public void fatalError(SAXParseException ex) throws SAXException {
+        this.errors.add(ex);
+    }
+
+    public void error(String domain, String key, XMLParseException e) {
+        if (!noerror) addError(e);
+    }
+
+    public void fatalError(String domain, String key, XMLParseException e) {
+        addError(e);
+    }
+
+    public void warning(String domain, String key, XMLParseException e) {
+        //noop. NekoHtml adds too many warnings.
+    }
+
+}

data/ext/java/nokogiri/internals/NokogiriStrictErrorHandler.java

@@ -0,0 +1,49 @@
+package nokogiri.internals;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ *
+ * @author sergio
+ */
+public class NokogiriStrictErrorHandler extends NokogiriErrorHandler{
+
+    @Override
+    public List<IRubyObject> getErrorsReadyForRuby(ThreadContext context){
+        return new ArrayList<IRubyObject>();
+    }
+
+    public void warning(SAXParseException spex) throws SAXException {
+        throw spex;
+    }
+
+    public void error(SAXParseException spex) throws SAXException {
+        throw spex;
+    }
+
+    public void fatalError(SAXParseException spex) throws SAXException {
+        throw spex;
+    }
+
+    public void error(String domain, String key, XMLParseException e)
+        throws XMLParseException {
+        throw e;
+    }
+
+    public void fatalError(String domain, String key, XMLParseException e)
+        throws XMLParseException {
+        throw e;
+    }
+
+    public void warning(String domain, String key, XMLParseException e)
+        throws XMLParseException {
+        throw e;
+    }
+
+}

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

@@ -0,0 +1,88 @@
+package nokogiri.internals;
+
+import java.util.List;
+
+import javax.xml.xpath.XPathFunction;
+import javax.xml.xpath.XPathFunctionException;
+
+import nokogiri.XmlNode;
+import nokogiri.XmlNodeSet;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyFloat;
+import org.jruby.RubyString;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ *
+ * @author sergio
+ */
+public class NokogiriXPathFunction implements XPathFunction {
+    private final IRubyObject handler;
+    private final String name;
+    private final int arity;
+
+    public NokogiriXPathFunction(IRubyObject handler, String name, int arity) {
+        this.handler = handler;
+        this.name = name;
+        this.arity = arity;
+    }
+
+    public Object evaluate(List args) throws XPathFunctionException {
+        if(args.size() != this.arity) {
+            throw new XPathFunctionException("arity does not match");
+        }
+        
+        Ruby ruby = this.handler.getRuntime();
+        ThreadContext context = ruby.getCurrentContext();
+
+        IRubyObject result = RuntimeHelpers.invoke(context, this.handler,
+                this.name, fromObjectToRubyArgs(args));
+
+        return fromRubyToObject(result);
+    }
+
+    private IRubyObject[] fromObjectToRubyArgs(List args) {
+        IRubyObject[] newArgs = new IRubyObject[args.size()];
+        for(int i = 0; i < args.size(); i++) {
+            newArgs[i] = fromObjectToRuby(args.get(i));
+        }
+        return newArgs;
+    }
+
+    private IRubyObject fromObjectToRuby(Object o) {
+        // argument object type is one of NodeList, String, Boolean, or Double.
+        Ruby ruby = this.handler.getRuntime();
+        if (o instanceof NodeList) {
+            return new XmlNodeSet(ruby, (NodeList) o);
+        //} else if (o instanceof Node) {
+        //    return NokogiriHelpers.getCachedNodeOrCreate(ruby, (Node) o);
+        } else {
+            return JavaUtil.convertJavaToUsableRubyObject(ruby, o);
+        }
+    }
+
+    private Object fromRubyToObject(IRubyObject o) {
+        Ruby ruby = this.handler.getRuntime();
+        if(o instanceof RubyString) {
+            return o.toJava(String.class);
+        } else if (o instanceof RubyFloat) {
+            return o.toJava(Double.class);
+        } else if (o instanceof RubyBoolean) {
+            return o.toJava(Boolean.class);
+        } else if (o instanceof XmlNodeSet) {
+            return ((XmlNodeSet) o).toNodeList(ruby);
+        } else if (o instanceof RubyArray) {
+            return (new XmlNodeSet(ruby, (RubyArray) o)).toNodeList(ruby);
+        } else /*if (o instanceof XmlNode)*/ {
+            return ((XmlNode) o).getNode();
+        }
+    }
+}