nokogiri 1.10.9-java → 1.11.0.rc4-java

data/ext/java/nokogiri/XmlDocumentFragment.java

@@ -64,7 +64,8 @@ import org.w3c.dom.NamedNodeMap;
  */
 @JRubyClass(name="Nokogiri::XML::DocumentFragment", parent="Nokogiri::XML::Node")
 public class XmlDocumentFragment extends XmlNode {
-    private XmlElement fragmentContext = null;
+
+    private XmlElement fragmentContext;
 
     public XmlDocumentFragment(Ruby ruby) {
         this(ruby, getNokogiriClass(ruby, "Nokogiri::XML::DocumentFragment"));
@@ -76,27 +77,27 @@ public class XmlDocumentFragment extends XmlNode {
 
     @JRubyMethod(name="new", meta = true, required=1, optional=2)
     public static IRubyObject rbNew(ThreadContext context, IRubyObject cls, IRubyObject[] args) {
-        
-        if(args.length < 1) {
-            throw context.getRuntime().newArgumentError(args.length, 1);
+        if (args.length < 1) {
+            throw context.runtime.newArgumentError(args.length, 1);
         }
 
-        if(!(args[0] instanceof XmlDocument)){
-            throw context.getRuntime().newArgumentError("first parameter must be a Nokogiri::XML::Document instance");
+        if (!(args[0] instanceof XmlDocument)){
+            throw context.runtime.newArgumentError("first parameter must be a Nokogiri::XML::Document instance");
         }
 
         XmlDocument doc = (XmlDocument) args[0];
         
         // make wellformed fragment, ignore invalid namespace, or add appropriate namespace to parse
         if (args.length > 1 && args[1] instanceof RubyString) {
-            if (XmlDocumentFragment.isTag((RubyString)args[1])) {
-                args[1] = RubyString.newString(context.getRuntime(), addNamespaceDeclIfNeeded(doc, rubyStringToString(args[1])));
+            final RubyString arg1 = (RubyString) args[1];
+            if (XmlDocumentFragment.isTag(arg1)) {
+                args[1] = RubyString.newString(context.runtime, addNamespaceDeclIfNeeded(doc, rubyStringToString(arg1)));
             }
         }
 
-        XmlDocumentFragment fragment = (XmlDocumentFragment) NokogiriService.XML_DOCUMENT_FRAGMENT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)cls);
+        XmlDocumentFragment fragment = (XmlDocumentFragment) NokogiriService.XML_DOCUMENT_FRAGMENT_ALLOCATOR.allocate(context.runtime, (RubyClass)cls);
         fragment.setDocument(context, doc);
-        fragment.setNode(context, doc.getDocument().createDocumentFragment());
+        fragment.setNode(context.runtime, doc.getDocument().createDocumentFragment());
 
         //TODO: Get namespace definitions from doc.
         if (args.length == 3 && args[2] != null && args[2] instanceof XmlElement) {
@@ -118,7 +119,7 @@ public class XmlDocumentFragment extends XmlNode {
         for (int i=0; i < nodeMap.getLength(); i++) {
             Attr attr = (Attr)nodeMap.item(i);
             if (isNamespace(attr.getNodeName())) {
-                String localPart = getLocalNameForNamespace(attr.getNodeName());
+                String localPart = getLocalNameForNamespace(attr.getNodeName(), null);
                 if (getPrefix(qName).equals(localPart)) {
                     return true;
                 }
@@ -177,27 +178,8 @@ public class XmlDocumentFragment extends XmlNode {
         return fragmentContext;
     }
 
-    //@Override
-    public void add_child(ThreadContext context, XmlNode child) {
-        // Some magic for DocumentFragment
-
-        Ruby ruby = context.getRuntime();
-        XmlNodeSet children = (XmlNodeSet) child.children(context);
-
-        long length = children.length();
-
-        RubyArray childrenArray = children.convertToArray();
-
-        if(length != 0) {
-            for(int i = 0; i < length; i++) {
-                XmlNode item = (XmlNode) ((XmlNode) childrenArray.aref(ruby.newFixnum(i))).dup_implementation(context, true);
-                add_child(context, item);
-            }
-        }
-    }
-
     @Override
     public void relink_namespace(ThreadContext context) {
-        ((XmlNodeSet) children(context)).relink_namespace(context);
+        relink_namespace(context, getChildren());
     }
 }

data/ext/java/nokogiri/XmlDtd.java

@@ -369,7 +369,7 @@ public class XmlDtd extends XmlNode {
      * the various collections.
      */
     protected void extractDecls(ThreadContext context) {
-        Ruby runtime = context.getRuntime();
+        Ruby runtime = context.runtime;
 
         // initialize data structures
         attributes = RubyHash.newHash(runtime);
@@ -383,7 +383,7 @@ public class XmlDtd extends XmlNode {
         if (node == null) return; // leave all the decl hash's empty
 
         // convert allDecls to a NodeSet
-        children = XmlNodeSet.newXmlNodeSet(context, extractDecls(context, node.getFirstChild()));
+        children = XmlNodeSet.newNodeSet(runtime, extractDecls(context, node.getFirstChild()));
 
         // add attribute decls as attributes to the matching element decl
         RubyArray keys = attributes.keys();
@@ -432,18 +432,15 @@ public class XmlDtd extends XmlNode {
             if (isExternalSubset(node)) {
                 break;
             } else if (isAttributeDecl(node)) {
-                XmlAttributeDecl decl = (XmlAttributeDecl)
-                    XmlAttributeDecl.create(context, node);
+                XmlAttributeDecl decl = XmlAttributeDecl.create(context, node);
                 attributes.op_aset(context, decl.attribute_name(context), decl);
                 decls.add(decl);
             } else if (isElementDecl(node)) {
-                XmlElementDecl decl = (XmlElementDecl)
-                    XmlElementDecl.create(context, node);
+                XmlElementDecl decl = XmlElementDecl.create(context, node);
                 elements.op_aset(context, decl.element_name(context), decl);
                 decls.add(decl);
             } else if (isEntityDecl(node)) {
-                XmlEntityDecl decl = (XmlEntityDecl)
-                    XmlEntityDecl.create(context, node);
+                XmlEntityDecl decl = XmlEntityDecl.create(context, node);
                 entities.op_aset(context, decl.node_name(context), decl);
                 decls.add(decl);
             } else if (isNotationDecl(node)) {

data/ext/java/nokogiri/XmlElement.java

@@ -59,29 +59,10 @@ public class XmlElement extends XmlNode {
         super(runtime, klazz, element);
     }
     
-    @Override
-    public void setNode(ThreadContext context, Node node) {
-      super.setNode(context, node);
-      if (doc != null)
-        setInstanceVariable("@document", doc);
-    }
-    
     @Override
     public void accept(ThreadContext context, SaveContextVisitor visitor) {
         visitor.enter((Element) node);
-        XmlNodeSet xmlNodeSet = (XmlNodeSet) children(context);
-        if (xmlNodeSet.length() > 0) {
-            IRubyObject[] nodes = XmlNodeSet.getNodes(context, xmlNodeSet);
-            for( int i = 0; i < nodes.length; i++ ) {
-                Object item = nodes[i];
-                if (item instanceof XmlNode) {
-                    ((XmlNode) item).accept(context, visitor);
-                }
-                else if (item instanceof XmlNamespace) {
-                    ((XmlNamespace) item).accept(context, visitor);
-                }
-            }
-        }
+        acceptChildren(context, getChildren(), visitor);
         visitor.leave((Element) node);
     }
 }

data/ext/java/nokogiri/XmlElementDecl.java

@@ -56,32 +56,31 @@ public class XmlElementDecl extends XmlNode {
     RubyArray attrDecls;
     IRubyObject contentModel;
     
-    public XmlElementDecl(Ruby ruby, RubyClass klazz) {
-        super(ruby, klazz);
-    }
-    
-    public void setNode(ThreadContext context, Node node) {
-        super.setNode(context, node);
-        attrDecls = RubyArray.newArray(context.getRuntime());
-        contentModel = context.getRuntime().getNil();
+    public XmlElementDecl(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz);
+        attrDecls = RubyArray.newArray(runtime);
+        contentModel = runtime.getNil();
     }
 
     /**
-     * Initialize based on an elementDecl node from a NekoDTD parsed
-     * DTD.
+     * Initialize based on an elementDecl node from a NekoDTD parsed DTD.
      */
     public XmlElementDecl(Ruby ruby, RubyClass klass, Node elemDeclNode) {
         super(ruby, klass, elemDeclNode);
-        attrDecls = RubyArray.newArray(ruby);
-        contentModel = ruby.getNil();
     }
 
-    public static IRubyObject create(ThreadContext context, Node elemDeclNode) {
-        XmlElementDecl self =
-            new XmlElementDecl(context.getRuntime(),
-                               getNokogiriClass(context.getRuntime(), "Nokogiri::XML::ElementDecl"),
-                               elemDeclNode);
-        return self;
+    @Override // gets called from constructor ^^^
+    public void setNode(Ruby runtime, Node node) {
+        super.setNode(runtime, node);
+        attrDecls = RubyArray.newArray(runtime);
+        contentModel = runtime.getNil();
+    }
+
+    static XmlElementDecl create(ThreadContext context, Node elemDeclNode) {
+        return new XmlElementDecl(context.runtime,
+            getNokogiriClass(context.runtime, "Nokogiri::XML::ElementDecl"),
+            elemDeclNode
+        );
     }
 
     public IRubyObject element_name(ThreadContext context) {
@@ -105,10 +104,8 @@ public class XmlElementDecl extends XmlNode {
     @JRubyMethod
     public IRubyObject prefix(ThreadContext context) {
         String enamePrefix = getPrefix(getAttribute("ename"));
-        if (enamePrefix == null)
-            return context.getRuntime().getNil();
-        else
-            return context.getRuntime().newString(enamePrefix);
+        if (enamePrefix == null) return context.nil;
+        return context.runtime.newString(enamePrefix);
     }
 
     /**
@@ -118,14 +115,13 @@ public class XmlElementDecl extends XmlNode {
     @JRubyMethod
     public IRubyObject node_name(ThreadContext context) {
         String ename = getLocalPart(getAttribute("ename"));
-        return context.getRuntime().newString(ename);
+        return context.runtime.newString(ename);
     }
 
     @Override
     @JRubyMethod(name = "node_name=")
     public IRubyObject node_name_set(ThreadContext context, IRubyObject name) {
-        throw context.getRuntime()
-            .newRuntimeError("cannot change name of DTD decl");
+        throw context.runtime.newRuntimeError("cannot change name of DTD decl");
     }
 
     @Override
@@ -137,8 +133,7 @@ public class XmlElementDecl extends XmlNode {
     @Override
     @JRubyMethod
     public IRubyObject attribute(ThreadContext context, IRubyObject name) {
-        throw context.getRuntime()
-            .newRuntimeError("attribute by name not implemented");
+        throw context.runtime.newRuntimeError("attribute by name not implemented");
     }
 
     public void appendAttrDecl(XmlAttributeDecl decl) {
@@ -147,6 +142,6 @@ public class XmlElementDecl extends XmlNode {
 
     @JRubyMethod
     public IRubyObject element_type(ThreadContext context) {
-        return context.getRuntime().newFixnum(node.getNodeType());
+        return context.runtime.newFixnum(node.getNodeType());
     }
 }

data/ext/java/nokogiri/XmlEntityDecl.java

@@ -64,26 +64,25 @@ public class XmlEntityDecl extends XmlNode {
     private IRubyObject system_id;
     private IRubyObject content;
 
-    public XmlEntityDecl(Ruby ruby, RubyClass klass) {
-        super(ruby, klass);
-        throw ruby.newRuntimeError("node required");
+    XmlEntityDecl(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
     }
 
     /**
-     * Initialize based on an entityDecl node from a NekoDTD parsed
-     * DTD.
+     * Initialize based on an entityDecl node from a NekoDTD parsed DTD.
      */
-    public XmlEntityDecl(Ruby ruby, RubyClass klass, Node entDeclNode) {
-        super(ruby, klass, entDeclNode);
-        entityType = RubyFixnum.newFixnum(ruby, XmlEntityDecl.INTERNAL_GENERAL);
-        name = external_id = system_id = content = ruby.getNil();       
+    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 ruby, RubyClass klass, Node entDeclNode, IRubyObject[] argv) {
-        super(ruby, klass, entDeclNode);
+    public XmlEntityDecl(Ruby runtime, RubyClass klass, Node entDeclNode, IRubyObject[] argv) {
+        super(runtime, klass, entDeclNode);
         name = argv[0];
-        entityType = RubyFixnum.newFixnum(ruby, XmlEntityDecl.INTERNAL_GENERAL);
-        external_id = system_id = content = ruby.getNil(); 
+        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];
@@ -92,21 +91,19 @@ public class XmlEntityDecl extends XmlNode {
         }
     }
 
-    public static IRubyObject create(ThreadContext context, Node entDeclNode) {
-        XmlEntityDecl self =
-            new XmlEntityDecl(context.getRuntime(),
-                              getNokogiriClass(context.getRuntime(), "Nokogiri::XML::EntityDecl"),
-                              entDeclNode);
-        return self;
+    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
-    public static IRubyObject create(ThreadContext context, Node entDeclNode, IRubyObject[] argv) {
-        XmlEntityDecl self =
-            new XmlEntityDecl(context.getRuntime(),
-                              getNokogiriClass(context.getRuntime(), "Nokogiri::XML::EntityDecl"),
-                              entDeclNode, argv);
-        return self;
+    static XmlEntityDecl create(ThreadContext context, Node entDeclNode, IRubyObject... argv) {
+        return new XmlEntityDecl(context.runtime,
+            getNokogiriClass(context.runtime, "Nokogiri::XML::EntityDecl"),
+            entDeclNode, argv
+        );
     }
 
     /**
@@ -123,8 +120,7 @@ public class XmlEntityDecl extends XmlNode {
     @Override
     @JRubyMethod(name = "node_name=")
     public IRubyObject node_name_set(ThreadContext context, IRubyObject name) {
-        throw context.getRuntime()
-            .newRuntimeError("cannot change name of DTD decl");
+        throw context.runtime.newRuntimeError("cannot change name of DTD decl");
     }
 
     @JRubyMethod

data/ext/java/nokogiri/XmlEntityReference.java

@@ -65,7 +65,7 @@ public class XmlEntityReference extends XmlNode {
 
     protected void init(ThreadContext context, IRubyObject[] args) {
         if (args.length < 2) {
-            throw getRuntime().newArgumentError(args.length, 2);
+            throw context.runtime.newArgumentError(args.length, 2);
         }
 
         IRubyObject doc = args[0];
@@ -78,7 +78,7 @@ public class XmlEntityReference extends XmlNode {
         internalDocument.setErrorChecking(false);
         Node node = document.createEntityReference(rubyStringToString(name));
         internalDocument.setErrorChecking(oldErrorChecking);
-        setNode(context, node);
+        setNode(context.runtime, node);
     }
     
     @Override

data/ext/java/nokogiri/XmlNamespace.java

@@ -32,18 +32,14 @@
 
 package nokogiri;
 
-import static nokogiri.internals.NokogiriHelpers.CACHED_NODE;
 import static nokogiri.internals.NokogiriHelpers.getCachedNodeOrCreate;
 import static nokogiri.internals.NokogiriHelpers.getLocalNameForNamespace;
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
-import static nokogiri.internals.NokogiriHelpers.stringOrNil;
-import nokogiri.internals.NokogiriHelpers;
 import nokogiri.internals.SaveContextVisitor;
 
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyObject;
-import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
@@ -61,122 +57,97 @@ import org.w3c.dom.Node;
 @JRubyClass(name="Nokogiri::XML::Namespace")
 public class XmlNamespace extends RubyObject {
     private Attr attr;
-    private IRubyObject prefix;
-    private IRubyObject href;
-    private String prefixString;
-    private String hrefString;
+    private transient IRubyObject prefixRuby;
+    private transient IRubyObject hrefRuby;
+    private String prefix;
+    private String href;
 
-    public XmlNamespace(Ruby ruby, RubyClass klazz) {
-        super(ruby, klazz);
+    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 prefixString;
+        return prefix;
     }
-    
+
+    boolean hasPrefix(String prefix) {
+        return prefix == null ? this.prefix == null : prefix.equals(this.prefix);
+    }
+
     public String getHref() {
-        return hrefString;
+        return href;
     }
     
     void deleteHref() {
-        hrefString = "http://www.w3.org/XML/1998/namespace";
-        href = NokogiriHelpers.stringOrNil(getRuntime(), hrefString);
+        href = "http://www.w3.org/XML/1998/namespace";
+        hrefRuby = null;
         attr.getOwnerElement().removeAttributeNode(attr);
     }
-
-    public void init(Attr attr, IRubyObject prefix, IRubyObject href, IRubyObject xmlDocument) {
-        init(attr, prefix, href, (String) prefix.toJava(String.class), (String) href.toJava(String.class), xmlDocument);
-    }
-    
-    public void init(Attr attr, IRubyObject prefix, IRubyObject href, String prefixString, String hrefString, IRubyObject xmlDocument) {
-        this.attr = attr;
-        this.prefix = prefix;
-        this.href = href;
-        this.prefixString = prefixString;
-        this.hrefString = hrefString;
-        setInstanceVariable("@document", xmlDocument);
-    }
     
     public static XmlNamespace createFromAttr(Ruby runtime, Attr attr) {
-        String prefixValue = getLocalNameForNamespace(attr.getName());
-        IRubyObject prefix_value;
-        if (prefixValue == null) {
-            prefix_value = runtime.getNil();
-            prefixValue = "";
-        } else {
-            prefix_value = RubyString.newString(runtime, prefixValue);
-        }
-        String hrefValue = attr.getValue();
-        IRubyObject href_value = RubyString.newString(runtime, hrefValue);
+        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());
-        xmlDocument.initializeNamespaceCacheIfNecessary();
-        XmlNamespace xmlNamespace = xmlDocument.getNamespaceCache().get(prefixValue, hrefValue);
-        if (xmlNamespace != null) return xmlNamespace;
-        
-        // creating XmlNamespace instance
-        XmlNamespace namespace =
-            (XmlNamespace) NokogiriService.XML_NAMESPACE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Namespace")); 
-        namespace.init(attr, prefix_value, href_value, prefixValue, hrefValue, xmlDocument);
-        
-        // updateing 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;
     }
     
-    public static XmlNamespace createFromPrefixAndHref(Node owner, IRubyObject prefix, IRubyObject href) {
-        String prefixValue = prefix.isNil() ? "" : (String) prefix.toJava(String.class);
-        String hrefValue = (String) href.toJava(String.class);
-        Ruby runtime = prefix.getRuntime();
+    static XmlNamespace createImpl(Node owner, IRubyObject prefix, String prefixStr, IRubyObject href, String hrefStr) {
+        final Ruby runtime = prefix.getRuntime();
+
         Document document = owner.getOwnerDocument();
-        // check namespace cache
-        XmlDocument xmlDocument = (XmlDocument)getCachedNodeOrCreate(runtime, document);
-        xmlDocument.initializeNamespaceCacheIfNecessary();
-        XmlNamespace xmlNamespace = xmlDocument.getNamespaceCache().get(prefixValue, hrefValue);
-        if (xmlNamespace != null) return xmlNamespace;
+        XmlDocument xmlDocument = (XmlDocument) getCachedNodeOrCreate(runtime, document);
+
+        assert xmlDocument.getNamespaceCache().get(prefixStr, hrefStr) == null;
 
         // creating XmlNamespace instance
-        XmlNamespace namespace =
-            (XmlNamespace) NokogiriService.XML_NAMESPACE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Namespace"));
         String attrName = "xmlns";
-        if (!"".equals(prefixValue)) {
-            attrName = attrName + ":" + prefixValue;
-        }
+        if (prefixStr != null && !prefixStr.isEmpty()) attrName = attrName + ':' + prefixStr;
+
         Attr attrNode = document.createAttribute(attrName);
-        attrNode.setNodeValue(hrefValue);
+        attrNode.setNodeValue(hrefStr);
 
-        // initialize XmlNamespace object
-        namespace.init(attrNode, prefix, href, prefixValue, hrefValue, xmlDocument);
-        
-        // updating namespace cache
+        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 prefixValue = owner.getPrefix();
-        String hrefValue = owner.getNamespaceURI();
-        Document document = owner.getOwnerDocument();
+        String prefixStr = owner.getPrefix();
+        String hrefStr = owner.getNamespaceURI();
         // check namespace cache
-        XmlDocument xmlDocument = (XmlDocument)getCachedNodeOrCreate(runtime, document);
-        XmlNamespace xmlNamespace = xmlDocument.getNamespaceCache().get(prefixValue, hrefValue);
-        if (xmlNamespace != null) return xmlNamespace;
+        XmlDocument xmlDocument = (XmlDocument) getCachedNodeOrCreate(runtime, owner.getOwnerDocument());
+        XmlNamespace namespace = xmlDocument.getNamespaceCache().get(prefixStr, hrefStr);
+        if (namespace != null) return namespace;
 
-        // creating XmlNamespace instance
-        XmlNamespace namespace =
-            (XmlNamespace) NokogiriService.XML_NAMESPACE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Namespace"));
-
-        IRubyObject prefix = stringOrNil(runtime, prefixValue);
-        IRubyObject href = stringOrNil(runtime, hrefValue);
-        // initialize XmlNamespace object
-        namespace.init((Attr)owner, prefix, href, prefixValue, hrefValue, xmlDocument);
-        
-        // updating namespace cache
+        namespace = new XmlNamespace(runtime, (Attr) owner, prefixStr, hrefStr, xmlDocument);
         xmlDocument.getNamespaceCache().put(namespace, owner);
         return namespace;
     }
@@ -192,21 +163,33 @@ public class XmlNamespace extends RubyObject {
     }
 
     public boolean isEmpty() {
-        return prefix.isNil() && href.isNil();
+        return prefix == null && href == null;
     }
 
     @JRubyMethod
     public IRubyObject href(ThreadContext context) {
-        return href;
+        if (hrefRuby == null) {
+            if (href == null) return hrefRuby = context.nil;
+            return hrefRuby = context.runtime.newString(href);
+        }
+        return hrefRuby;
     }
 
     @JRubyMethod
     public IRubyObject prefix(ThreadContext context) {
-        return prefix;
+        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 string = " " + prefix + "=\"" + href + "\"";
+        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?