nokogiri-backport 1.11.0

data/ext/java/nokogiri/XmlEntityDecl.java

@@ -0,0 +1,157 @@
+/**
+ * (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;
+
+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 {
+    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,101 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2012:
+ *
+ * * {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;
+
+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 {
+
+    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,199 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2012:
+ *
+ * * {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;
+
+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 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;
+    }
+    
+    void deleteHref() {
+        href = "http://www.w3.org/XML/1998/namespace";
+        hrefRuby = null;
+        attr.getOwnerElement().removeAttributeNode(attr);
+    }
+    
+    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);
+    }
+}