Nokogiri_precompiled_aarch64_dedshit 1.14.5

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

@@ -0,0 +1,228 @@
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import nokogiri.XmlNamespace;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+/**
+ * Cache of namespaces of each node. XmlDocument has one cache of this class.
+ *
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNamespaceCache
+{
+
+  private final Map<CacheKey, CacheEntry> cache;  // pair of the index of a given key and entry
+  private XmlNamespace defaultNamespace = null;
+
+  public
+  NokogiriNamespaceCache()
+  {
+    this.cache = new LinkedHashMap<CacheKey, CacheEntry>(4);
+  }
+
+  public
+  NokogiriNamespaceCache(NokogiriNamespaceCache cache)
+  {
+    this.cache = new LinkedHashMap<CacheKey, CacheEntry>(cache.size() + 2);
+    this.cache.putAll(cache.cache);
+  }
+
+  public XmlNamespace
+  getDefault()
+  {
+    return defaultNamespace;
+  }
+
+  public XmlNamespace
+  get(String prefix, String href)
+  {
+    if (href == null) { return null; }
+
+    CacheEntry value = cache.get(new CacheKey(prefix, href));
+    return value == null ? null : value.namespace;
+  }
+
+  public XmlNamespace
+  get(Node node, String prefix)
+  {
+    if (prefix == null) { return defaultNamespace; }
+    for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+      if (entry.getKey().prefix.equals(prefix)) {
+        if (entry.getValue().isOwner(node)) {
+          return entry.getValue().namespace;
+        }
+      }
+    }
+    return null;
+  }
+
+  public List<XmlNamespace>
+  get(String prefix)
+  {
+    List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
+    if (prefix == null) {
+      namespaces.add(defaultNamespace);
+      return namespaces;
+    }
+    for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+      if (entry.getKey().prefix.equals(prefix)) {
+        namespaces.add(entry.getValue().namespace);
+      }
+    }
+    return namespaces;
+  }
+
+  public List<XmlNamespace>
+  get(Node node)
+  {
+    List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
+    for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+      if (entry.getValue().isOwner(node)) {
+        namespaces.add(entry.getValue().namespace);
+      }
+    }
+    return namespaces;
+  }
+
+  public void
+  put(XmlNamespace namespace, Node ownerNode)
+  {
+    String prefix = namespace.getPrefix();
+    String href = namespace.getHref();
+    if (href == null) { return; }
+
+    CacheKey key = new CacheKey(prefix, href);
+    if (cache.get(key) != null) { return; }
+    cache.put(key, new CacheEntry(namespace, ownerNode));
+    if ("".equals(prefix)) { defaultNamespace = namespace; }
+  }
+
+  public void
+  remove(Node ownerNode)
+  {
+    String prefix = ownerNode.getPrefix();
+    String href = ownerNode.getNamespaceURI();
+    if (href == null) { return; }
+
+    cache.remove(new CacheKey(prefix, href));
+  }
+
+  public int
+  size()
+  {
+    return cache.size();
+  }
+
+  public void
+  clear()
+  {
+    // removes namespace declarations from node
+    for (CacheEntry entry : cache.values()) {
+      NamedNodeMap attributes = entry.ownerNode.getAttributes();
+      for (int j = 0; j < attributes.getLength(); j++) {
+        String name = ((Attr) attributes.item(j)).getName();
+        if (isNamespace(name)) {
+          attributes.removeNamedItem(name);
+        }
+      }
+    }
+    cache.clear();
+    defaultNamespace = null;
+  }
+
+  public void
+  replaceNode(Node oldNode, Node newNode)
+  {
+    for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+      if (entry.getValue().isOwner(oldNode)) {
+        entry.getValue().replaceOwner(newNode);
+      }
+    }
+  }
+
+  @Override
+  public String
+  toString()
+  {
+    return getClass().getName() + '@' + Integer.toHexString(hashCode()) + '(' + cache + "default=" + defaultNamespace + ')';
+  }
+
+  private static class CacheKey
+  {
+    final String prefix;
+    final String href;
+
+    CacheKey(String prefix, String href)
+    {
+      this.prefix = prefix;
+      this.href = href;
+    }
+
+    @Override
+    public boolean
+    equals(final Object obj)
+    {
+      if (obj instanceof CacheKey) {
+        CacheKey that = (CacheKey) obj;
+        return prefix == null ? that.prefix == null : prefix.equals(that.prefix) && href.equals(that.href);
+      }
+      return false;
+    }
+
+    @Override
+    public int
+    hashCode()
+    {
+      return (prefix == null ? 0 : prefix.hashCode()) + 37 * href.hashCode();
+    }
+
+    @Override
+    public String
+    toString()
+    {
+      return '[' + prefix + ']' + href;
+    }
+  }
+
+  private static class CacheEntry
+  {
+    final XmlNamespace namespace;
+    private Node ownerNode;
+
+    CacheEntry(XmlNamespace namespace, Node ownerNode)
+    {
+      this.namespace = namespace;
+      this.ownerNode = ownerNode;
+    }
+
+    boolean
+    isOwner(Node node)
+    {
+      return ownerNode.isSameNode(node);
+    }
+
+    void
+    replaceOwner(Node newNode)
+    {
+      this.ownerNode = newNode;
+    }
+
+    @Override
+    public String
+    toString()
+    {
+      return namespace.toString();
+    }
+  }
+}

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

@@ -0,0 +1,110 @@
+package nokogiri.internals;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import javax.xml.XMLConstants;
+import javax.xml.namespace.NamespaceContext;
+
+/**
+ * Holder of each node's namespace.
+ *
+ * @author Yoko Harada <yokolet@gmail.com>
+ *
+ */
+public final class NokogiriNamespaceContext implements NamespaceContext
+{
+
+  /*
+   * these constants have matching declarations in
+   * ext/nokogiri/xml_xpath_context.c
+   */
+  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_BUILTIN_PREFIX = "nokogiri-builtin";
+  public static final String NOKOGIRI_BUILTIN_URI = "https://www.nokogiri.org/default_ns/ruby/builtins";
+
+  private final Map<String, String> register;
+
+  public static NokogiriNamespaceContext
+  create()
+  {
+    return new NokogiriNamespaceContext();
+  }
+
+  private
+  NokogiriNamespaceContext()
+  {
+    register = new HashMap<String, String>(6, 1);
+    register.put(NOKOGIRI_PREFIX, NOKOGIRI_URI);
+    register.put(NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_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");
+    }
+    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)
+  {
+    Set<Entry<String, String>> entries = register.entrySet();
+    ArrayList<String> list = new ArrayList<String>(entries.size());
+    for (Entry<String, String> entry : entries) {
+      if (uri.equals(entry.getValue())) {
+        list.add(entry.getKey());
+      }
+    }
+    return list.iterator();
+  }
+
+  public Set<String>
+  getAllPrefixes()
+  {
+    return register.keySet();
+  }
+
+  public void
+  registerNamespace(String prefix, String uri)
+  {
+    if ("xmlns".equals(prefix)) { prefix = ""; }
+    register.put(prefix, uri);
+  }
+
+}

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

@@ -0,0 +1,86 @@
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.jruby.Ruby;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Error Handler for XML document when recover is true (default).
+ *
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNonStrictErrorHandler extends NokogiriErrorHandler
+{
+  public
+  NokogiriNonStrictErrorHandler(Ruby runtime, boolean noerror, boolean nowarning)
+  {
+    super(runtime, noerror, nowarning);
+  }
+
+  public void
+  warning(SAXParseException ex) throws SAXException
+  {
+    addError(ex);
+  }
+
+  public void
+  error(SAXParseException ex) throws SAXException
+  {
+    addError(ex);
+  }
+
+  public void
+  fatalError(SAXParseException ex) throws SAXException
+  {
+    // fix #837
+    // Xerces won't skip the reference entity (and other invalid) constructs
+    // found in the prolog, instead it will keep calling this method and we'll
+    // keep inserting the error in the document errors array until we run
+    // out of memory
+    addError(ex);
+    String message = ex.getMessage();
+
+    // The problem with Xerces is that some errors will cause the
+    // parser not to advance the reader and it will keep reporting
+    // the same error over and over, which will cause the parser
+    // to enter an infinite loop unless we throw the exception.
+    if (message != null && isFatal(message)) {
+      throw 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);
+  }
+
+  /*
+   * Determine whether this is a fatal error that should cause
+   * the parsing to stop, or an error that can be ignored.
+   */
+  private static boolean
+  isFatal(String msg)
+  {
+    String msgLowerCase = msg.toLowerCase();
+    return
+      msgLowerCase.contains("in prolog") ||
+      msgLowerCase.contains("limit") ||
+      msgLowerCase.contains("preceding the root element must be well-formed") ||
+      msgLowerCase.contains("following the root element must be well-formed");
+  }
+}

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

@@ -0,0 +1,107 @@
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.jruby.Ruby;
+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 all warnings are eliminated.
+ *
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler
+{
+
+  public
+  NokogiriNonStrictErrorHandler4NekoHtml(Ruby runtime, boolean nowarning)
+  {
+    super(runtime, false, nowarning);
+  }
+
+  public
+  NokogiriNonStrictErrorHandler4NekoHtml(Ruby runtime, boolean noerror, boolean nowarning)
+  {
+    super(runtime, noerror, nowarning);
+  }
+
+  public void
+  warning(SAXParseException ex) throws SAXException
+  {
+    //noop. NekoHtml adds too many warnings.
+  }
+
+  public void
+  error(SAXParseException ex) throws SAXException
+  {
+    addError(ex);
+  }
+
+  public void
+  fatalError(SAXParseException ex) throws SAXException
+  {
+    addError(ex);
+  }
+
+  /**
+   * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+   * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+   *
+   * @param domain The domain of the error. The domain can be any string but is
+   *               suggested to be a valid URI. The domain can be used to conveniently
+   *               specify a web site location of the relevant specification or
+   *               document pertaining to this warning.
+   * @param key The error key. This key can be any string and is implementation
+   *            dependent.
+   * @param e Exception.
+   */
+  public void
+  error(String domain, String key, XMLParseException e)
+  {
+    addError(e);
+  }
+
+  /**
+   * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+   * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+   *
+   * @param domain The domain of the fatal error. The domain can be any string but is
+   *               suggested to be a valid URI. The domain can be used to conveniently
+   *               specify a web site location of the relevant specification or
+   *               document pertaining to this warning.
+   * @param key The fatal error key. This key can be any string and is implementation
+   *            dependent.
+   * @param e Exception.
+   */
+  public void
+  fatalError(String domain, String key, XMLParseException e)
+  {
+    addError(e);
+  }
+
+  /**
+   * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+   * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+   *
+   * @param domain The domain of the warning. The domain can be any string but is
+   *               suggested to be a valid URI. The domain can be used to conveniently
+   *               specify a web site location of the relevant specification or
+   *               document pertaining to this warning.
+   * @param key The warning key. This key can be any string and is implementation
+   *            dependent.
+   * @param e Exception.
+   */
+  public void
+  warning(String domain, String key, XMLParseException e)
+  {
+    addError(e);
+  }
+
+}

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

@@ -0,0 +1,62 @@
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.jruby.Ruby;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Strict error handler. Even though strict is specified, Nokogiri allows to go further
+ * when NOERROR or/both NOWARNING is/are true.
+ *
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriStrictErrorHandler extends NokogiriErrorHandler
+{
+  public
+  NokogiriStrictErrorHandler(Ruby runtime, boolean noerror, boolean nowarning)
+  {
+    super(runtime, noerror, nowarning);
+  }
+
+  public void
+  warning(SAXParseException spex) throws SAXException
+  {
+    if (!nowarning) { throw spex; }
+    else { addError(spex); }
+  }
+
+  public void
+  error(SAXParseException spex) throws SAXException
+  {
+    if (!noerror) { throw spex; }
+    else { addError(spex); }
+  }
+
+  public void
+  fatalError(SAXParseException spex) throws SAXException
+  {
+    throw spex;
+  }
+
+  public void
+  error(String domain, String key, XMLParseException e) throws XMLParseException
+  {
+    if (!noerror) { throw e; }
+    else { addError(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
+  {
+    if (!nowarning) { throw e; }
+    else { addError(e); }
+  }
+}