Nokogiri_precompiled_aarch64_dedshit 1.14.5

data/ext/java/nokogiri/XmlEntityDecl.java

@@ -0,0 +1,151 @@
+package nokogiri;
+
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Node;
+
+/**
+ * DTD entity declaration.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+@JRubyClass(name = "Nokogiri::XML::EntityDecl", parent = "Nokogiri::XML::Node")
+public class XmlEntityDecl extends XmlNode
+{
+  private static final long serialVersionUID = 1L;
+
+  public static final int INTERNAL_GENERAL = 1;
+  public static final int EXTERNAL_GENERAL_PARSED = 2;
+  public static final int EXTERNAL_GENERAL_UNPARSED  = 3;
+  public static final int INTERNAL_PARAMETER = 4;
+  public static final int EXTERNAL_PARAMETER = 5;
+  public static final int INTERNAL_PREDEFINED = 6;
+
+  private IRubyObject entityType;
+  private IRubyObject name;
+  private IRubyObject external_id;
+  private IRubyObject system_id;
+  private IRubyObject content;
+
+  XmlEntityDecl(Ruby runtime, RubyClass klass)
+  {
+    super(runtime, klass);
+  }
+
+  /**
+   * Initialize based on an entityDecl node from a NekoDTD parsed DTD.
+   */
+  public
+  XmlEntityDecl(Ruby runtime, RubyClass klass, Node entDeclNode)
+  {
+    super(runtime, klass, entDeclNode);
+    entityType = RubyFixnum.newFixnum(runtime, XmlEntityDecl.INTERNAL_GENERAL);
+    name = external_id = system_id = content = runtime.getNil();
+  }
+
+  public
+  XmlEntityDecl(Ruby runtime, RubyClass klass, Node entDeclNode, IRubyObject[] argv)
+  {
+    super(runtime, klass, entDeclNode);
+    name = argv[0];
+    entityType = RubyFixnum.newFixnum(runtime, XmlEntityDecl.INTERNAL_GENERAL);
+    external_id = system_id = content = runtime.getNil();
+
+    if (argv.length > 1) { entityType = argv[1]; }
+    if (argv.length > 4) {
+      external_id = argv[2];
+      system_id = argv[3];
+      content = argv[4];
+    }
+  }
+
+  static XmlEntityDecl
+  create(ThreadContext context, Node entDeclNode)
+  {
+    return new XmlEntityDecl(context.runtime,
+                             getNokogiriClass(context.runtime, "Nokogiri::XML::EntityDecl"),
+                             entDeclNode
+                            );
+  }
+
+  // when entity is created by create_entity method
+  static XmlEntityDecl
+  create(ThreadContext context, Node entDeclNode, IRubyObject... argv)
+  {
+    return new XmlEntityDecl(context.runtime,
+                             getNokogiriClass(context.runtime, "Nokogiri::XML::EntityDecl"),
+                             entDeclNode, argv
+                            );
+  }
+
+  /**
+   * Returns the local part of the element name.
+   */
+  @Override
+  @JRubyMethod
+  public IRubyObject
+  node_name(ThreadContext context)
+  {
+    IRubyObject value = getAttribute(context, "name");
+    if (value.isNil()) { value = name; }
+    return value;
+  }
+
+  @Override
+  @JRubyMethod(name = "node_name=")
+  public IRubyObject
+  node_name_set(ThreadContext context, IRubyObject name)
+  {
+    throw context.runtime.newRuntimeError("cannot change name of DTD decl");
+  }
+
+  @JRubyMethod
+  public IRubyObject
+  content(ThreadContext context)
+  {
+    IRubyObject value = getAttribute(context, "value");
+    if (value.isNil()) { value = content; }
+    return value;
+  }
+
+  // TODO: what is content vs. original_content?
+  @JRubyMethod
+  public IRubyObject
+  original_content(ThreadContext context)
+  {
+    return getAttribute(context, "value");
+  }
+
+  @JRubyMethod
+  public IRubyObject
+  system_id(ThreadContext context)
+  {
+    IRubyObject value = getAttribute(context, "sysid");
+    if (value.isNil()) { value = system_id; }
+    return value;
+  }
+
+  @JRubyMethod
+  public IRubyObject
+  external_id(ThreadContext context)
+  {
+    IRubyObject value = getAttribute(context, "pubid");
+    if (value.isNil()) { value = external_id; }
+    return value;
+  }
+
+  @JRubyMethod
+  public IRubyObject
+  entity_type(ThreadContext context)
+  {
+    return entityType;
+  }
+}

data/ext/java/nokogiri/XmlEntityReference.java

@@ -0,0 +1,79 @@
+package nokogiri;
+
+import static nokogiri.internals.NokogiriHelpers.getCachedNodeOrCreate;
+import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
+import nokogiri.internals.SaveContextVisitor;
+
+import org.apache.xerces.dom.CoreDocumentImpl;
+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.w3c.dom.Node;
+
+/**
+ * Class for Nokogiri::XML::EntityReference
+ *
+ * @author sergio
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+@JRubyClass(name = "Nokogiri::XML::EntityReference", parent = "Nokogiri::XML::Node")
+public class XmlEntityReference extends XmlNode
+{
+  private static final long serialVersionUID = 1L;
+
+  public
+  XmlEntityReference(Ruby ruby, RubyClass klazz)
+  {
+    super(ruby, klazz);
+  }
+
+  public
+  XmlEntityReference(Ruby ruby, RubyClass klass, Node node)
+  {
+    super(ruby, klass, node);
+  }
+
+  protected void
+  init(ThreadContext context, IRubyObject[] args)
+  {
+    if (args.length < 2) {
+      throw context.runtime.newArgumentError(args.length, 2);
+    }
+
+    IRubyObject doc = args[0];
+    IRubyObject name = args[1];
+
+    Document document = ((XmlNode) doc).getOwnerDocument();
+    // FIXME: disable error checking as a workaround for #719. this depends on the internals of Xerces.
+    CoreDocumentImpl internalDocument = (CoreDocumentImpl) document;
+    boolean oldErrorChecking = internalDocument.getErrorChecking();
+    internalDocument.setErrorChecking(false);
+    Node node = document.createEntityReference(rubyStringToString(name));
+    internalDocument.setErrorChecking(oldErrorChecking);
+    setNode(context.runtime, node);
+  }
+
+  @Override
+  public void
+  accept(ThreadContext context, SaveContextVisitor visitor)
+  {
+    visitor.enter(node);
+    Node child = node.getFirstChild();
+    while (child != null) {
+      IRubyObject nokoNode = getCachedNodeOrCreate(context.getRuntime(), child);
+      if (nokoNode instanceof XmlNode) {
+        XmlNode cur = (XmlNode) nokoNode;
+        cur.accept(context, visitor);
+      } else if (nokoNode instanceof XmlNamespace) {
+        XmlNamespace cur = (XmlNamespace) nokoNode;
+        cur.accept(context, visitor);
+      }
+      child = child.getNextSibling();
+    }
+    visitor.leave(node);
+  }
+}

data/ext/java/nokogiri/XmlNamespace.java

@@ -0,0 +1,193 @@
+package nokogiri;
+
+import static nokogiri.internals.NokogiriHelpers.getCachedNodeOrCreate;
+import static nokogiri.internals.NokogiriHelpers.getLocalNameForNamespace;
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+import nokogiri.internals.SaveContextVisitor;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+/**
+ * Class for Nokogiri::XML::Namespace
+ *
+ * @author serabe
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+@JRubyClass(name = "Nokogiri::XML::Namespace")
+public class XmlNamespace extends RubyObject
+{
+  private static final long serialVersionUID = 1L;
+
+  private Attr attr;
+  private transient IRubyObject prefixRuby;
+  private transient IRubyObject hrefRuby;
+  private String prefix;
+  private String href;
+
+  public
+  XmlNamespace(Ruby runtime, RubyClass klazz)
+  {
+    super(runtime, klazz);
+  }
+
+  XmlNamespace(Ruby runtime, Attr attr, String prefix, String href, IRubyObject document)
+  {
+    this(runtime, attr, prefix, null, href, null, document);
+  }
+
+  private
+  XmlNamespace(Ruby runtime, Attr attr, String prefix, IRubyObject prefixRuby,
+               String href, IRubyObject hrefRuby, IRubyObject document)
+  {
+    super(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Namespace"));
+
+    this.attr = attr;
+    this.prefix = prefix;
+    this.href = href;
+    this.prefixRuby = prefixRuby;
+    this.hrefRuby = hrefRuby;
+    setInstanceVariable("@document", document);
+  }
+
+  public Node
+  getNode()
+  {
+    return attr;
+  }
+
+  public String
+  getPrefix()
+  {
+    return prefix;
+  }
+
+  boolean
+  hasPrefix(String prefix)
+  {
+    return prefix == null ? this.prefix == null : prefix.equals(this.prefix);
+  }
+
+  public String
+  getHref()
+  {
+    return href;
+  }
+
+  public static XmlNamespace
+  createFromAttr(Ruby runtime, Attr attr)
+  {
+    String prefixStr = getLocalNameForNamespace(attr.getName(), null);
+    IRubyObject prefix = prefixStr == null ? runtime.getNil() : null;
+    String hrefStr = attr.getValue();
+    // check namespace cache
+    XmlDocument xmlDocument = (XmlDocument) getCachedNodeOrCreate(runtime, attr.getOwnerDocument());
+    XmlNamespace namespace = xmlDocument.getNamespaceCache().get(prefixStr, hrefStr);
+    if (namespace != null) { return namespace; }
+
+    namespace = new XmlNamespace(runtime, attr, prefixStr, prefix, hrefStr, null, xmlDocument);
+    xmlDocument.getNamespaceCache().put(namespace, attr.getOwnerElement());
+    return namespace;
+  }
+
+  static XmlNamespace
+  createImpl(Node owner, IRubyObject prefix, String prefixStr, IRubyObject href, String hrefStr)
+  {
+    final Ruby runtime = prefix.getRuntime();
+
+    Document document = owner.getOwnerDocument();
+    XmlDocument xmlDocument = (XmlDocument) getCachedNodeOrCreate(runtime, document);
+
+    assert xmlDocument.getNamespaceCache().get(prefixStr, hrefStr) == null;
+
+    // creating XmlNamespace instance
+    String attrName = "xmlns";
+    if (prefixStr != null && !prefixStr.isEmpty()) { attrName = attrName + ':' + prefixStr; }
+
+    Attr attrNode = document.createAttribute(attrName);
+    attrNode.setNodeValue(hrefStr);
+
+    XmlNamespace namespace = new XmlNamespace(runtime, attrNode, prefixStr, prefix, hrefStr, href, xmlDocument);
+    xmlDocument.getNamespaceCache().put(namespace, owner);
+    return namespace;
+  }
+
+  // owner should be an Attr node
+  public static XmlNamespace
+  createDefaultNamespace(Ruby runtime, Node owner)
+  {
+    String prefixStr = owner.getPrefix();
+    String hrefStr = owner.getNamespaceURI();
+    // check namespace cache
+    XmlDocument xmlDocument = (XmlDocument) getCachedNodeOrCreate(runtime, owner.getOwnerDocument());
+    XmlNamespace namespace = xmlDocument.getNamespaceCache().get(prefixStr, hrefStr);
+    if (namespace != null) { return namespace; }
+
+    namespace = new XmlNamespace(runtime, (Attr) owner, prefixStr, hrefStr, xmlDocument);
+    xmlDocument.getNamespaceCache().put(namespace, owner);
+    return namespace;
+  }
+
+  /**
+   * Create and return a copy of this object.
+   *
+   * @return a clone of this object
+   */
+  @Override
+  public Object
+  clone() throws CloneNotSupportedException
+  {
+    return super.clone();
+  }
+
+  public boolean
+  isEmpty()
+  {
+    return prefix == null && href == null;
+  }
+
+  @JRubyMethod
+  public IRubyObject
+  href(ThreadContext context)
+  {
+    if (hrefRuby == null) {
+      if (href == null) { return hrefRuby = context.nil; }
+      return hrefRuby = context.runtime.newString(href);
+    }
+    return hrefRuby;
+  }
+
+  @JRubyMethod
+  public IRubyObject
+  prefix(ThreadContext context)
+  {
+    if (prefixRuby == null) {
+      if (prefix == null) { return prefixRuby = context.nil; }
+      return prefixRuby = context.runtime.newString(prefix);
+    }
+    return prefixRuby;
+  }
+
+  public void
+  accept(ThreadContext context, SaveContextVisitor visitor)
+  {
+    String prefix = this.prefix;
+    if (prefix == null) { prefix = ""; }
+    String href = this.href;
+    if (href == null) { href = ""; }
+    String string = ' ' + prefix + '=' + '"' + href + '"';
+    visitor.enter(string);
+    visitor.leave(string);
+    // is below better?
+    //visitor.enter(attr);
+    //visitor.leave(attr);
+  }
+}